Merge branch 'master' into cpplint

Author: vkucera

.pre-commit-config.yaml

@@ -2,15 +2,47 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v6.0.0
+    rev: 3e8a8703264a2f4a69428a0aa4dcb512790b2c8c # frozen: v6.0.0
     hooks:
-      - id: trailing-whitespace
+      - id: check-added-large-files
+      - id: check-ast
+      - id: check-case-conflict
+      - id: check-executables-have-shebangs
+      - id: check-merge-conflict
+      - id: check-symlinks
+      - id: check-yaml
       - id: end-of-file-fixer
+      - id: trailing-whitespace
+  - repo: https://github.com/shellcheck-py/shellcheck-py
+    rev: a6564f5d57444e123433a5c9af733e3975c77229 # frozen: v0.11.0.1-1
+    hooks:
+      - id: shellcheck
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: f12be1ebaa5351c1fc76472de98db2c3446c8253 # frozen: v0.16.10
+    hooks:
+      - id: ruff-check # linter
+        args: ["--fix"]
+      - id: ruff-format # formatter
+  - repo: local
+    hooks:
+      - id: format-includes
+        name: format includes
+        language: python
+        entry: Scripts/format_includes.py
+        types: [c++]
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v20.1.3 # clang-format version (keep synced with https://github.com/alisw/ali-bot/blob/master/.github/workflows/c++-code-formatting.yml)
+    # clang-format version (keep synced with https://github.com/alisw/ali-bot/blob/master/.github/workflows/c++-code-formatting.yml)
+    rev: 7ec07eeb4135dc6ecf410d24ac4ead986a5d413d # frozen: v20.1.3
     hooks:
       - id: clang-format
   - repo: https://github.com/cpplint/cpplint
-    rev: 2.0.2
+    rev: 350702a4d39395571bd118c9a3cff0a573488d61 # frozen: 2.0.2
     hooks:
       - id: cpplint
+  - repo: local
+    hooks:
+      - id: O2 linter
+        name: O2 linter
+        language: python
+        entry: Scripts/o2_linter.py
+        types_or: [c++, cmake, python]

ALICE3/Core/DetLayer.h

@@ -108,25 +108,25 @@ struct DetLayer {
   TString mName;
 
   // position variables
-  float mR; // radius in centimeters
-  float mZ; // mZ dimension in centimeters
+  float mR{}; // radius in centimeters
+  float mZ{}; // mZ dimension in centimeters
 
   // material variables
-  float mX0;   // radiation length
-  float mXrho; // density
+  float mX0{};   // radiation length
+  float mXrho{}; // density
 
   // resolution variables for active layers
-  float mResRPhi; // RPhi resolution in centimeters
-  float mResZ;    // Z resolution in centimeters
+  float mResRPhi{}; // RPhi resolution in centimeters
+  float mResZ{};    // Z resolution in centimeters
 
   // efficiency
-  float mEff; // detection efficiency
+  float mEff{1.f}; // detection efficiency
 
   // dead regions in phi (in radians)
   TGraph* mDeadPhiRegions = nullptr;
 
   // layer type
-  int mType; // 0: undefined/inert, 1: silicon, 2: gas/tpc
+  int mType{0}; // 0: undefined/inert, 1: silicon, 2: gas/tpc
 };
 
 } // namespace o2::fastsim

ALICE3/Core/FastTracker.cxx

@@ -312,6 +312,8 @@ int FastTracker::fastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa
   nIntercepts = 0;
   nSiliconPoints = 0;
   nGasPoints = 0;
+  trackIU = -1.f;
+  trackOU = -1.f;
   std::array<float, 3> posIni{}; // provision for != PV
   inputTrack.getXYZGlo(posIni);
   const float initialRadius = std::hypot(posIni[0], posIni[1]);
@@ -416,6 +418,9 @@ int FastTracker::fastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa
       firstLayerReached = il;
     }
     lastLayerReached = il;
+    if (layers[il].isTOF()) {
+      continue; // TOF layers are not used for tracking, but are kept in range for the innermost/outermost update
+    }
     nIntercepts++;
   }
 
@@ -475,7 +480,7 @@ int FastTracker::fastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa
       continue;
     }
 
-    if (!layers[il].isInert()) { // only update covm for tracker hits
+    if (!layers[il].isInert() && !layers[il].isTOF()) { // only update covm for tracker hits
       const o2::track::TrackParametrization<float>::dim2_t hitpoint = {xyz1[1], xyz1[2]};
       const o2::track::TrackParametrization<float>::dim3_t hitpointcov = {layers[il].getResolutionRPhi() * layers[il].getResolutionRPhi(), 0.f, layers[il].getResolutionZ() * layers[il].getResolutionZ()};
 
@@ -510,7 +515,14 @@ int FastTracker::fastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa
     }
 
     hits.push_back(thisHit);
-    if (!layers[il].isInert()) { // good hit probability calculation
+    if (!layers[il].isInert()) {
+      trackIU = std::hypot(spacePoint[0], spacePoint[1]);
+      if (trackOU < 0.f) {
+        trackOU = trackIU;
+      }
+    }
+
+    if (!layers[il].isInert() && !layers[il].isTOF()) { // good hit probability calculation
       float sigYCmb = o2::math_utils::sqrt(inwardTrack.getSigmaY2() + layers[il].getResolutionRPhi() * layers[il].getResolutionRPhi());
       float sigZCmb = o2::math_utils::sqrt(inwardTrack.getSigmaZ2() + layers[il].getResolutionZ() * layers[il].getResolutionZ());
       goodHitProbability[il] = probGoodChiSqHit(layers[il].getRadius() * 100, sigYCmb * 100, sigZCmb * 100);

ALICE3/Core/FastTracker.h

@@ -58,7 +58,7 @@ class FastTracker
   /// \param phiEnd End angle of the dead region (in radians)
   void addDeadPhiRegionInLayer(const std::string& layerName, float phiStart, float phiEnd);
   [[nodiscard]] DetLayer getLayer(const int layer) const { return layers[layer]; }
-  [[nodiscard]] std::vector<DetLayer> getLayers() const { return layers; }
+  [[nodiscard]] const std::vector<DetLayer>& getLayers() const { return layers; }
   [[nodiscard]] int getLayerIndex(const std::string& name) const;
   [[nodiscard]] size_t getNLayers() const { return layers.size(); }
   [[nodiscard]] bool isLayerInert(const int layer) const { return layers[layer].isInert(); }
@@ -127,6 +127,8 @@ class FastTracker
   [[nodiscard]] int getNIntercepts() const { return nIntercepts; }
   [[nodiscard]] int getNSiliconPoints() const { return nSiliconPoints; }
   [[nodiscard]] int getNGasPoints() const { return nGasPoints; }
+  [[nodiscard]] float getTrackIU() const { return trackIU; }
+  [[nodiscard]] float getTrackOU() const { return trackOU; }
   [[nodiscard]] float getGoodHitProb(int layer) const
   {
     return (layer >= 0 && static_cast<size_t>(layer) < goodHitProbability.size()) ? goodHitProbability[layer] : 0.0f;
@@ -172,6 +174,8 @@ class FastTracker
   int nIntercepts = 0;    /// found in first outward propagation
   int nSiliconPoints = 0; /// silicon-based space points added to track
   int nGasPoints = 0;     /// tpc-based space points added to track
+  float trackIU = -1.f;   /// innermost update: radius of the innermost active-layer hit added to track
+  float trackOU = -1.f;   /// outermost update: radius of the outermost active-layer hit added to track
   std::vector<float> goodHitProbability;
 
   ClassDef(FastTracker, 1);

ALICE3/Core/GeometryContainer.cxx

@@ -19,7 +19,6 @@
 
 #include "Common/Core/TableHelper.h"
 
-#include <CCDB/BasicCCDBManager.h>
 #include <Framework/InitContext.h>
 #include <Framework/Logger.h>
 
@@ -41,15 +40,15 @@ void GeometryContainer::init(o2::framework::InitContext& initContext)
   }
   LOG(info) << "Size of detector configuration: " << detectorConfiguration.size();
 
-  bool cleanLutWhenLoaded;
-  const bool foundCleanLutWhenLoaded = common::core::getTaskOptionValue(initContext, "on-the-fly-detector-geometry-provider", "cleanLutWhenLoaded", cleanLutWhenLoaded, false);
+  bool cleanLut;
+  const bool foundCleanLutWhenLoaded = common::core::getTaskOptionValue(initContext, "on-the-fly-detector-geometry-provider", "cleanLutWhenLoaded", cleanLut, false);
   if (!foundCleanLutWhenLoaded) {
     LOG(fatal) << "Could not retrieve foundCleanLutWhenLoaded option from OnTheFlyDetectorGeometryProvider task.";
     return;
   }
-  setLutCleanupSetting(cleanLutWhenLoaded);
+  setLutCleanupSetting(cleanLut);
 
-  for (std::string& configFile : detectorConfiguration) {
+  for (const std::string& configFile : detectorConfiguration) {
     LOG(info) << "Detector geometry configuration file used: " << configFile;
     addEntry(configFile);
   }

ALICE3/Core/GeometryContainer.h

@@ -36,18 +36,18 @@ struct GeometryEntry {
   // Default constructor
   GeometryEntry() = default;
   explicit GeometryEntry(const std::string& filename, o2::ccdb::BasicCCDBManager* ccdb = nullptr)
+    : mFileName(ConfigurationParser::accessFile(filename, "./.ALICE3/Configuration/", ccdb))
   {
-    mFileName = ConfigurationParser::accessFile(filename, "./.ALICE3/Configuration/", ccdb);
     mConfigurations = ConfigurationParser::parseTEnvConfiguration(mFileName, mLayerNames);
     LOG(info) << "Loaded geometry configuration from file: " << mFileName << " with " << mLayerNames.size() << " layers.";
     if (mLayerNames.empty()) {
       LOG(warning) << "No layers found in geometry configuration file: " << filename;
     }
   }
 
-  std::map<std::string, std::map<std::string, std::string>> getConfigurations() const { return mConfigurations; }
+  const std::map<std::string, std::map<std::string, std::string>>& getConfigurations() const { return mConfigurations; }
   std::map<std::string, std::string> getConfiguration(const std::string& layerName) const;
-  std::vector<std::string> getLayerNames() const { return mLayerNames; }
+  const std::vector<std::string>& getLayerNames() const { return mLayerNames; }
   bool hasValue(const std::string& layerName, const std::string& key) const;
   std::string getValue(const std::string& layerName, const std::string& key, bool require = true) const;
   void setValue(const std::string& layerName, const std::string& key, const std::string& value) { mConfigurations[layerName][key] = value; }

ALICE3/DataModel/OTFTOF.h

@@ -79,6 +79,8 @@ DECLARE_SOA_COLUMN(OuterTOFExpectedTimeDe, outerTOFExpectedTimeDe, float);   //!
 DECLARE_SOA_COLUMN(OuterTOFExpectedTimeTr, outerTOFExpectedTimeTr, float);   //! Reconstructed expected time at the OuterTOF for the Triton mass hypotheses
 DECLARE_SOA_COLUMN(OuterTOFExpectedTimeHe3, outerTOFExpectedTimeHe3, float); //! Reconstructed expected time at the OuterTOF for the Helium3 mass hypotheses
 DECLARE_SOA_COLUMN(OuterTOFExpectedTimeAl, outerTOFExpectedTimeAl, float);   //! Reconstructed expected time at the OuterTOF for the Alpha mass hypotheses
+DECLARE_SOA_COLUMN(HasInnerTOF, hasInnerTOF, bool);                          //! InnerTOF short-lived values are filled (false if dummy)
+DECLARE_SOA_COLUMN(HasOuterTOF, hasOuterTOF, bool);                          //! OuterTOF short-lived values are filled (false if dummy)
 DECLARE_SOA_DYNAMIC_COLUMN(NSigmaInnerTOF, nSigmaInnerTOF,                   //! General function to get the nSigma for the InnerTOF
                            [](const float el,
                               const float mu,
@@ -260,10 +262,15 @@ DECLARE_SOA_TABLE(UpgradeTofShortLiveds, "AOD", "UPGRTOFSHRTLVD",
                   upgrade_tof::OuterTOFExpectedTimeXi,
                   upgrade_tof::OuterTOFExpectedTimeOm);
 
+DECLARE_SOA_TABLE(UpgradeTofShortLivedSignals, "AOD", "UPGRTOFSLSIGNAL",
+                  upgrade_tof::HasInnerTOF,
+                  upgrade_tof::HasOuterTOF);
+
 using UpgradeTofMC = UpgradeTofMCs::iterator;
 using UpgradeTof = UpgradeTofs::iterator;
 using UpgradeTofExpectedTime = UpgradeTofExpectedTimes::iterator;
 using UpgradeTofShortLived = UpgradeTofShortLiveds::iterator;
+using UpgradeTofShortLivedSignal = UpgradeTofShortLivedSignals::iterator;
 
 } // namespace o2::aod
 

ALICE3/DataModel/tracksAlice3.h

@@ -32,9 +32,13 @@ DECLARE_SOA_COLUMN(NTPCHits, nTPCHits, int);                //! number of tpc hi
 DECLARE_SOA_COLUMN(PdgCode, pdgCode, int);                  //! PDG code of the linked truth MC particle
 DECLARE_SOA_COLUMN(TrackType, trackType, int);              //! Type of the track
 DECLARE_SOA_COLUMN(IsPVContributor, isPVContributor, bool); //! Has track contributed to the PV fit?
+DECLARE_SOA_COLUMN(TrackIU, trackIU, float);                //! Innermost update: radius (cm) of the innermost hit assigned to the track
+DECLARE_SOA_COLUMN(TrackOU, trackOU, float);                //! Outermost update: radius (cm) of the outermost hit assigned to the track
 } // namespace track_alice3
 DECLARE_SOA_TABLE(TracksAlice3, "AOD", "TRACKSALICE3",
-                  track_alice3::IsReconstructed);
+                  track_alice3::IsReconstructed,
+                  track_alice3::TrackIU,
+                  track_alice3::TrackOU);
 using TrackAlice3 = TracksAlice3::iterator;
 
 DECLARE_SOA_TABLE(TracksAlice3Pdg, "AOD", "TRACKSALICE3PDG",

ALICE3/Macros/Configuration/a3geometry_v3.ini

@@ -92,15 +92,6 @@ B05.resZ: 0.001
 B05.eff: 1.00
 B05.type: 1
 
-iTOF.r: 19
-iTOF.z: 250
-iTOF.x0: 0.01*3.
-iTOF.xrho: 0.03
-iTOF.resRPhi: 0.001
-iTOF.resZ: 0.001
-iTOF.eff: 1.00
-iTOF.type: 0
-
 B06.r: 20.
 B06.z: 250
 B06.x0: 0.01
@@ -110,6 +101,15 @@ B06.resZ: 0.001
 B06.eff: 1.00
 B06.type: 1
 
+iTOF.r: 21
+iTOF.z: 250
+iTOF.x0: 0.01*3.
+iTOF.xrho: 0.03
+iTOF.resRPhi: 0.001
+iTOF.resZ: 0.001
+iTOF.eff: 1.00
+iTOF.type: 3
+
 B07.r: 30.
 B07.z: 250
 B07.x0: 0.01
@@ -146,6 +146,15 @@ B10.resZ: 0.001
 B10.eff: 1.00
 B10.type: 1
 
+oTOF.r: 92
+oTOF.z: 250
+oTOF.x0: 0.01*3.
+oTOF.xrho: 0.03
+oTOF.resRPhi: 0.001
+oTOF.resZ: 0.001
+oTOF.eff: 1.00
+oTOF.type: 3
+
 # Lookup tables
 global.lutEl: ccdb:/Users/j/jekarlss/LUTs/v3/b/el
 global.lutMu: ccdb:/Users/j/jekarlss/LUTs/v3/b/mu

ALICE3/TableProducer/OTF/onTheFlyTofPid.cxx

@@ -30,6 +30,7 @@
 #include "ALICE3/Core/TrackUtilities.h"
 #include "ALICE3/DataModel/OTFCollision.h"
 #include "ALICE3/DataModel/OTFTOF.h"
+#include "ALICE3/DataModel/tracksAlice3.h"
 #include "Common/Core/trackUtilities.h"
 
 #include <CCDB/BasicCCDBManager.h>
@@ -77,6 +78,7 @@ struct OnTheFlyTofPid {
   Produces<aod::UpgradeTof> upgradeTof;
   Produces<aod::UpgradeTofExpectedTime> upgradeTofExpectedTime;
   Produces<aod::UpgradeTofShortLived> upgradeTofShortLived;
+  Produces<aod::UpgradeTofShortLivedSignal> upgradeTofShortLivedSignal;
 
   // necessary for particle charges
   Service<o2::framework::O2DatabasePDG> pdgDatabase{};
@@ -103,6 +105,7 @@ struct OnTheFlyTofPid {
     Configurable<float> multiplicityEtaRange{"multiplicityEtaRange", 0.800000012, "eta range to compute the multiplicity"};
     Configurable<bool> flagIncludeTrackTimeRes{"flagIncludeTrackTimeRes", true, "flag to include or exclude track time resolution"};
     Configurable<bool> flagTOFLoadDelphesLUTs{"flagTOFLoadDelphesLUTs", false, "flag to load Delphes LUTs for tracking correction (use recoTrack parameters if false)"};
+    Configurable<float> shortLivedRadiusTolerance{"shortLivedRadiusTolerance", 0.1f, "tolerance (cm) when checking if a TOF layer is within the innermost and outermost track update of short-lived particles"};
   } simConfig;
 
   struct : ConfigurableGroup {
@@ -211,6 +214,39 @@ struct OnTheFlyTofPid {
                                                                      particleHe,
                                                                      particleAl};
 
+  template <typename TTrack>
+  void fillShortLivedTables(const TTrack& track,
+                            std::array<float, NParticles> nSigmaInnerTOF,
+                            std::array<float, NParticles> nSigmaOuterTOF,
+                            std::array<float, NParticles> expectedTimeInnerTOF,
+                            std::array<float, NParticles> expectedTimeOuterTOF,
+                            const std::pair<float, float>& trackLengthInnerTOF,
+                            const std::pair<float, float>& trackLengthOuterTOF)
+  {
+    const auto isWithinTrackUpdates = [&](const float tofRadius) {
+      return (track.trackIU() - simConfig.shortLivedRadiusTolerance <= tofRadius) && (tofRadius <= track.trackOU() + simConfig.shortLivedRadiusTolerance);
+    };
+
+    const bool hasInnerTOF = isWithinTrackUpdates(simConfig.innerTOFRadius) && trackLengthInnerTOF.first > 0 && trackLengthInnerTOF.second > 0;
+    const bool hasOuterTOF = isWithinTrackUpdates(simConfig.outerTOFRadius) && trackLengthOuterTOF.first > 0 && trackLengthOuterTOF.second > 0;
+    static constexpr float DummyValue = -999.f;
+    for (const int ii : {Sp, Sm, Xi, Om}) {
+      if (!hasInnerTOF) {
+        nSigmaInnerTOF[ii] = DummyValue;
+        expectedTimeInnerTOF[ii] = DummyValue;
+      }
+      if (!hasOuterTOF) {
+        nSigmaOuterTOF[ii] = DummyValue;
+        expectedTimeOuterTOF[ii] = DummyValue;
+      }
+    }
+    upgradeTofShortLived(nSigmaInnerTOF[Sp], nSigmaInnerTOF[Sm], nSigmaInnerTOF[Xi], nSigmaInnerTOF[Om],
+                         nSigmaOuterTOF[Sp], nSigmaOuterTOF[Sm], nSigmaOuterTOF[Xi], nSigmaOuterTOF[Om],
+                         expectedTimeInnerTOF[Sp], expectedTimeInnerTOF[Sm], expectedTimeInnerTOF[Xi], expectedTimeInnerTOF[Om],
+                         expectedTimeOuterTOF[Sp], expectedTimeOuterTOF[Sm], expectedTimeOuterTOF[Xi], expectedTimeOuterTOF[Om]);
+    upgradeTofShortLivedSignal(hasInnerTOF, hasOuterTOF);
+  }
+
   bool doQaForParticle(const int pdgCode)
   {
     return std::find(plotsConfig.particlesForQa.value.begin(), plotsConfig.particlesForQa.value.end(), std::abs(pdgCode)) != plotsConfig.particlesForQa.value.end();
@@ -652,7 +688,7 @@ struct OnTheFlyTofPid {
   }
 
   void process(soa::Join<aod::Collisions, aod::McCollisionLabels, aod::OTFLUTConfigId>::iterator const& collision,
-               soa::Join<aod::Tracks, aod::TracksCov, aod::McTrackLabels> const& tracks,
+               soa::Join<aod::Tracks, aod::TracksCov, aod::McTrackLabels, aod::TracksAlice3> const& tracks,
                aod::McParticles const&,
                aod::McCollisions const&)
   {
@@ -971,10 +1007,8 @@ struct OnTheFlyTofPid {
                  measuredTimeOuterTOF, trackLengthRecoOuterTOF);
       upgradeTofExpectedTime(expectedTimeInnerTOF[El], expectedTimeInnerTOF[Mu], expectedTimeInnerTOF[Pi], expectedTimeInnerTOF[Ka], expectedTimeInnerTOF[Pr], expectedTimeInnerTOF[De], expectedTimeInnerTOF[Tr], expectedTimeInnerTOF[He], expectedTimeInnerTOF[Al],
                              expectedTimeOuterTOF[El], expectedTimeOuterTOF[Mu], expectedTimeOuterTOF[Pi], expectedTimeOuterTOF[Ka], expectedTimeOuterTOF[Pr], expectedTimeOuterTOF[De], expectedTimeOuterTOF[Tr], expectedTimeOuterTOF[He], expectedTimeOuterTOF[Al]);
-      upgradeTofShortLived(nSigmaInnerTOF[Sp], nSigmaInnerTOF[Sm], nSigmaInnerTOF[Xi], nSigmaInnerTOF[Om],
-                           nSigmaOuterTOF[Sp], nSigmaOuterTOF[Sm], nSigmaOuterTOF[Xi], nSigmaOuterTOF[Om],
-                           expectedTimeInnerTOF[Sp], expectedTimeInnerTOF[Sm], expectedTimeInnerTOF[Xi], expectedTimeInnerTOF[Om],
-                           expectedTimeOuterTOF[Sp], expectedTimeOuterTOF[Sm], expectedTimeOuterTOF[Xi], expectedTimeOuterTOF[Om]);
+      fillShortLivedTables(track, nSigmaInnerTOF, nSigmaOuterTOF, expectedTimeInnerTOF, expectedTimeOuterTOF,
+                           trkWithTime.mTrackLengthInnerTOF, trkWithTime.mTrackLengthOuterTOF);
     }
 
     if (trackWithTimeIndex != tracks.size()) {