Merge branch 'AliceO2Group:master' into master

Author: ljoergen

.github/labeler.yml

@@ -9,7 +9,19 @@ common:
 
 infrastructure:
   - changed-files:
-      - any-glob-to-any-file: ['.github/**', 'cmake/**', 'dependencies/**', 'packaging/**']
+      - any-glob-to-any-file:
+          - '.clang-format'
+          - '.clang-tidy'
+          - '.flake8'
+          - '.github/**'
+          - '.checkov.yml'
+          - '.mega-linter.yml'
+          - 'cmake/**'
+          - 'CODEOWNERS'
+          - 'CPPLINT.cfg'
+          - 'dependencies/**'
+          - 'packaging/**'
+          - 'pyproject.toml'
 
 dpg:
   - changed-files:

ALICE3/TableProducer/OTF/onTheFlyTracker.cxx

@@ -81,7 +81,7 @@ struct OnTheFlyTracker {
   Produces<aod::UpgradeCascades> upgradeCascades;
 
   // optionally produced, empty (to be tuned later)
-  Produces<aod::StoredTracksExtra> tracksExtra; // base table, extend later
+  Produces<aod::StoredTracksExtra_001> tracksExtra; // base table, extend later
   Produces<aod::TrackSelection> trackSelection;
   Produces<aod::TrackSelectionExtension> trackSelectionExtension;
 

ALICE3/TableProducer/alice3-multicharm.cxx

@@ -499,15 +499,14 @@ struct alice3multicharm {
             continue; // do not take if radius too small, likely a primary combination
 
           o2::dataformats::DCA dcaInfo;
-          float xicdcaXY = 1e+10, xicdcaZ = 1e+10;
+          float xicdcaXY = 1e+10;
           o2::track::TrackParCov xicTrackCopy(xicTrack); // paranoia
 
           o2::vertexing::PVertex primaryVertex;
           primaryVertex.setXYZ(collision.posX(), collision.posY(), collision.posZ());
 
           if (xicTrackCopy.propagateToDCA(primaryVertex, magneticField, &dcaInfo)) {
             xicdcaXY = dcaInfo.getY();
-            xicdcaZ = dcaInfo.getZ();
           }
 
           histos.fill(HIST("hMassXiC"), thisXiCcandidate.mass);
@@ -543,10 +542,9 @@ struct alice3multicharm {
 
             o2::track::TrackParCov xiccTrack(thisXiCCcandidate.xyz, momentumCC, thisXiCCcandidate.parentTrackCovMatrix, +2);
 
-            float xiccdcaXY = 1e+10, xiccdcaZ = 1e+10;
+            float xiccdcaXY = 1e+10;
             if (xiccTrack.propagateToDCA(primaryVertex, magneticField, &dcaInfo)) {
               xiccdcaXY = dcaInfo.getY();
-              xiccdcaZ = dcaInfo.getZ();
             }
 
             // produce multi-charm table for posterior analysis

CODEOWNERS

@@ -55,7 +55,7 @@
 /PWGMM/UE   @alibuild @aalkin @aortizve
 
 /PWGUD @alibuild @pbuehler @abylinkin @rolavick
-/PWGJE @alibuild @lhavener @maoyx @nzardosh @ddobrigk @mfasDa
+/PWGJE @alibuild @lhavener @maoyx @nzardosh @fjonasALICE @mfasDa
 /Tools/PIDML @alibuild @saganatt
 /Tools/ML @alibuild @fcatalan92 @fmazzasc
 /Tutorials/PWGCF @alibuild @jgrosseo @saganatt @victor-gonzalez @zchochul

CPPLINT.cfg

@@ -1 +1 @@
-filter=-build/c++11,-build/namespaces,-readability/fn_size,-readability/todo,-runtime/references,-whitespace/blank_line,-whitespace/braces,-whitespace/comments,-whitespace/line_length,-whitespace/semicolon,-whitespace/todo
+filter=-build/c++11,-build/namespaces,-readability/fn_size,-readability/todo,-runtime/references,-whitespace/blank_line,-whitespace/braces,-whitespace/comments,-whitespace/indent_namespace,-whitespace/line_length,-whitespace/semicolon,-whitespace/todo

Common/Core/RecoDecay.h

@@ -20,10 +20,12 @@
 #include <algorithm> // std::find
 #include <array>     // std::array
 #include <cmath>     // std::abs, std::sqrt
+#include <cstdio>
 #include <utility>   // std::move
 #include <vector>    // std::vector
 
 #include "TMCProcess.h" // for VMC Particle Production Process
+#include "TPDGCode.h"   // for PDG codes
 #include "CommonConstants/MathConstants.h"
 
 /// Base class for calculating properties of reconstructed decays
@@ -663,26 +665,33 @@ struct RecoDecay {
   /// Checks whether the reconstructed decay candidate is the expected decay.
   /// \param checkProcess  switch to accept only decay daughters by checking the production process of MC particles
   /// \param acceptIncompleteReco  switch to accept candidates with only part of the daughters reconstructed
+  /// \tparam acceptTrackDecay  switch to accept candidates with daughter tracks of pions and kaons which decayed
   /// \param particlesMC  table with MC particles
   /// \param arrDaughters  array of candidate daughters
   /// \param PDGMother  expected mother PDG code
   /// \param arrPDGDaughters  array of expected daughter PDG codes
   /// \param acceptAntiParticles  switch to accept the antiparticle version of the expected decay
   /// \param sign  antiparticle indicator of the found mother w.r.t. PDGMother; 1 if particle, -1 if antiparticle, 0 if mother not found
   /// \param depthMax  maximum decay tree level to check; Daughters up to this level will be considered. If -1, all levels are considered.
+  /// \param nPiToMu  number of pion prongs decayed to a muon
+  /// \param nKaToPi  number of kaon prongs decayed to a pion
   /// \return index of the mother particle if the mother and daughters are correct, -1 otherwise
-  template <bool acceptFlavourOscillation = false, bool checkProcess = false, bool acceptIncompleteReco = false, std::size_t N, typename T, typename U>
+  template <bool acceptFlavourOscillation = false, bool checkProcess = false, bool acceptIncompleteReco = false, bool acceptTrackDecay = false, std::size_t N, typename T, typename U>
   static int getMatchedMCRec(const T& particlesMC,
                              const std::array<U, N>& arrDaughters,
                              int PDGMother,
                              std::array<int, N> arrPDGDaughters,
                              bool acceptAntiParticles = false,
                              int8_t* sign = nullptr,
-                             int depthMax = 1)
+                             int depthMax = 1,
+                             int8_t* nPiToMu = nullptr,
+                             int8_t* nKaToPi = nullptr)
   {
     // Printf("MC Rec: Expected mother PDG: %d", PDGMother);
     int8_t coefFlavourOscillation = 1;     // 1 if no B0(s) flavour oscillation occured, -1 else
     int8_t sgn = 0;                        // 1 if the expected mother is particle, -1 if antiparticle (w.r.t. PDGMother)
+    int8_t nPiToMuLocal = 0;               // number of pion prongs decayed to a muon
+    int8_t nKaToPiLocal = 0;               // number of kaon prongs decayed to a pion
     int indexMother = -1;                  // index of the mother particle
     std::vector<int> arrAllDaughtersIndex; // vector of indices of all daughters of the mother of the first provided daughter
     std::array<int, N> arrDaughtersIndex;  // array of indices of provided daughters
@@ -708,6 +717,21 @@ struct RecoDecay {
         return -1;
       }
       auto particleI = arrDaughters[iProng].mcParticle(); // ith daughter particle
+      if constexpr (acceptTrackDecay) {
+        // Replace the MC particle associated with the prong by its mother for π → μ and K → π.
+        auto motherI = particleI.template mothers_first_as<T>();
+        auto pdgI = std::abs(particleI.pdgCode());
+        auto pdgMotherI = std::abs(motherI.pdgCode());
+        if (pdgI == kMuonMinus && pdgMotherI == kPiPlus) {
+          // π → μ
+          nPiToMuLocal++;
+          particleI = motherI;
+        } else if (pdgI == kPiPlus && pdgMotherI == kKPlus) {
+          // K → π
+          nKaToPiLocal++;
+          particleI = motherI;
+        }
+      }
       arrDaughtersIndex[iProng] = particleI.globalIndex();
       // Get the list of daughter indices from the mother of the first prong.
       if (iProng == 0) {
@@ -780,6 +804,14 @@ struct RecoDecay {
     if (sign) {
       *sign = sgn;
     }
+    if constexpr (acceptTrackDecay) {
+      if (nPiToMu) {
+        *nPiToMu = nPiToMuLocal;
+      }
+      if (nKaToPi) {
+        *nKaToPi = nKaToPiLocal;
+      }
+    }
     return indexMother;
   }
 

Common/Core/TPCVDriftManager.h

@@ -116,8 +116,8 @@ class TPCVDriftManager
     if (dDriftErr < 0.f || dDrift > 250.f) { // we cannot move a track outside the drift volume
       if (mOutside < mWarningLimit) {
         LOGP(warn, "Skipping correction outside of tpc volume with dDrift={} +- {}", dDrift, dDriftErr);
-        const auto& trackBC = trackExtra.template collision_as<Collisions>().template foundBC_as<BCs>().globalBC();
-        const auto& colBC = col.template foundBC_as<BCs>().globalBC();
+        const auto trackBC = trackExtra.template collision_as<Collisions>().template foundBC_as<BCs>().globalBC();
+        const auto colBC = col.template foundBC_as<BCs>().globalBC();
         int diffBC = colBC - trackBC;
         LOGP(info, "ct={}; ctr={}; tTB={}; t0={}; dTime={}; dDrift={}; tgl={}:   colBC={}   trackBC={}  diffBC={}", col.collisionTime(), col.collisionTimeRes(), tTB, trackExtra.trackTime(), dTime, dDrift, track.getTgl(), colBC, trackBC, diffBC);
         if (mOutside == mWarningLimit - 1) {

Common/DataModel/TrackSelectionTables.h

@@ -60,6 +60,7 @@ struct TrackSelectionFlags {
   static constexpr flagtype kGlobalTrackWoTPCCluster = kQualityTracksWoTPCCluster | kPrimaryTracks | kInAcceptanceTracks;
   static constexpr flagtype kGlobalTrackWoPtEta = kQualityTracks | kPrimaryTracks;
   static constexpr flagtype kGlobalTrackWoDCA = kQualityTracks | kInAcceptanceTracks;
+  static constexpr flagtype kGlobalTrackWoDCAxy = kQualityTracks | kInAcceptanceTracks | kDCAz;
   static constexpr flagtype kGlobalTrackWoDCATPCCluster = kQualityTracksWoTPCCluster | kInAcceptanceTracks;
 
   /// @brief Function to check flag content

Common/TableProducer/Converters/bcFlagsCreator.cxx

@@ -22,7 +22,7 @@ struct bcFlagsCreator {
 
   void process(aod::BCs const& bcTable)
   {
-    for (auto& _ : bcTable) {
+    for (int64_t i = 0; i < bcTable.size(); ++i) {
       bcFlags(0);
     }
   }

Common/TableProducer/ft0CorrectedTable.cxx

@@ -10,38 +10,89 @@
 // or submit itself to any jurisdiction.
 
 #include <bitset>
-#include "Common/DataModel/FT0Corrected.h"
 #include "Framework/ConfigParamSpec.h"
 #include "Framework/runDataProcessing.h"
 #include "Framework/AnalysisTask.h"
-#include "Common/DataModel/EventSelection.h"
 #include "Framework/AnalysisDataModel.h"
+#include "Framework/HistogramRegistry.h"
+#include "Common/DataModel/FT0Corrected.h"
+#include "Common/DataModel/EventSelection.h"
 #include "CommonConstants/LHCConstants.h"
 #include "CommonConstants/PhysicsConstants.h"
 #include "DataFormatsFT0/Digit.h"
+#include "CCDB/BasicCCDBManager.h"
+#include "CollisionTypeHelper.h"
+#include "TRandom3.h"
 
 using namespace o2;
 using namespace o2::framework;
-
 using namespace o2::aod;
-struct FT0CorrectedTable {
+
+struct ft0CorrectedTable {
+  // Configurables
+  Configurable<float> resoFT0A{"resoFT0A", 20.f, "FT0A resolution"};
+  Configurable<float> resoFT0C{"resoFT0C", 20.f, "FT0C resolution"};
+  Configurable<bool> addHistograms{"addHistograms", false, "Add QA histograms"};
+  Configurable<int> cfgCollisionSystem{"collisionSystem", -2, "Collision system: -2 (use cfg values), -1 (autoset), 0 (pp), 1 (PbPb), 2 (XeXe), 3 (pPb)"};
+  Configurable<std::string> cfgUrl{"ccdb-url", "http://alice-ccdb.cern.ch", "url of the ccdb repository"};
+  Configurable<std::string> cfgPathGrpLhcIf{"ccdb-path-grplhcif", "GLO/Config/GRPLHCIF", "Path on the CCDB for the GRPLHCIF object"};
+  Configurable<int64_t> cfgTimestamp{"ccdb-timestamp", -1, "timestamp of the object"};
+  Service<o2::ccdb::BasicCCDBManager> ccdb;
+
+  // Producer
   Produces<o2::aod::FT0sCorrected> table;
   using BCsWithMatchings = soa::Join<aod::BCs, aod::Run3MatchedToBCSparse>;
   using CollisionEvSel = soa::Join<aod::Collisions, aod::EvSels>::iterator;
+  static constexpr float invLightSpeedCm2NS = 1.f / o2::constants::physics::LightSpeedCm2NS;
 
-  void process(BCsWithMatchings const&, soa::Join<aod::Collisions, aod::EvSels> const& collisions, aod::FT0s const&)
+  HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject};
+  void init(o2::framework::InitContext&)
   {
+    if (doprocessStandard && doprocessWithBypassFT0timeInMC) {
+      LOG(fatal) << "Both processStandard and processWithBypassFT0timeInMC are enabled. Pick one of the two";
+    }
+    if (!doprocessStandard && !doprocessWithBypassFT0timeInMC) {
+      LOG(fatal) << "No process is enabled. Pick one";
+    }
+    ccdb->setURL(cfgUrl);
+    ccdb->setTimestamp(cfgTimestamp);
+    ccdb->setCaching(true);
+    ccdb->setLocalObjectValidityChecking();
+    // Not later than now objects
+    ccdb->setCreatedNotAfter(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count());
+
+    if (!addHistograms) {
+      return;
+    }
+    histos.add("t0A", "t0A", kTH1D, {{1000, -1, 1, "t0A (ns)"}});
+    histos.add("t0C", "t0C", kTH1D, {{1000, -1, 1, "t0C (ns)"}});
+    histos.add("t0AC", "t0AC", kTH1D, {{1000, -1000, 1000, "t0AC (ns)"}});
+    histos.add("deltat0AC", "deltat0AC", kTH1D, {{1000, -10, 10, "#Deltat0AC (ns)"}});
+    if (doprocessWithBypassFT0timeInMC) {
+      histos.add("MC/deltat0A", "t0A", kTH1D, {{1000, -50, 50, "t0A (ps)"}});
+      histos.add("MC/deltat0C", "t0C", kTH1D, {{1000, -50, 50, "t0C (ps)"}});
+      histos.add("MC/deltat0AC", "t0AC", kTH1D, {{1000, -50, 50, "t0AC (ps)"}});
+    }
+  }
+
+  void processStandard(soa::Join<aod::Collisions, aod::EvSels> const& collisions,
+                       BCsWithMatchings const&,
+                       aod::FT0s const&)
+  {
+    table.reserve(collisions.size());
+    float t0A = 1e10f;
+    float t0C = 1e10f;
     for (auto& collision : collisions) {
-      float vertexPV = collision.posZ();
-      float vertex_corr = vertexPV / o2::constants::physics::LightSpeedCm2NS;
-      float t0A = 1e10;
-      float t0C = 1e10;
+      t0A = 1e10f;
+      t0C = 1e10f;
+      const float vertexPV = collision.posZ();
+      const float vertex_corr = vertexPV * invLightSpeedCm2NS;
       constexpr float dummyTime = 30.; // Due to HW limitations time can be only within range (-25,25) ns, dummy time is around 32 ns
       if (collision.has_foundFT0()) {
-        auto ft0 = collision.foundFT0();
-        std::bitset<8> triggers = ft0.triggerMask();
-        bool ora = triggers[o2::ft0::Triggers::bitA];
-        bool orc = triggers[o2::ft0::Triggers::bitC];
+        const auto& ft0 = collision.foundFT0();
+        const std::bitset<8>& triggers = ft0.triggerMask();
+        const bool ora = triggers[o2::ft0::Triggers::bitA];
+        const bool orc = triggers[o2::ft0::Triggers::bitC];
         LOGF(debug, "triggers OrA %i OrC %i ", ora, orc);
         LOGF(debug, " T0A = %f, T0C %f, vertex_corr %f", ft0.timeA(), ft0.timeC(), vertex_corr);
         if (ora && ft0.timeA() < dummyTime) {
@@ -52,11 +103,100 @@ struct FT0CorrectedTable {
         }
       }
       LOGF(debug, " T0 collision time T0A = %f, T0C = %f", t0A, t0C);
+      if (addHistograms) {
+        histos.fill(HIST("t0A"), t0A);
+        histos.fill(HIST("t0C"), t0C);
+        histos.fill(HIST("t0AC"), (t0A + t0C) * 0.5f);
+        histos.fill(HIST("deltat0AC"), t0A - t0C);
+      }
+      table(t0A, t0C);
+    }
+  }
+  PROCESS_SWITCH(ft0CorrectedTable, processStandard, "Process standard table (default)", true);
+
+  void processWithBypassFT0timeInMC(soa::Join<aod::Collisions, aod::EvSels, aod::McCollisionLabels> const& collisions,
+                                    soa::Join<BCsWithMatchings, aod::Timestamps> const& bcs,
+                                    aod::FT0s const&,
+                                    aod::McCollisions const&)
+  {
+    if (cfgCollisionSystem.value == -1) {
+      o2::parameters::GRPLHCIFData* grpo = ccdb->template getForTimeStamp<o2::parameters::GRPLHCIFData>(cfgPathGrpLhcIf,
+                                                                                                        bcs.iteratorAt(0).timestamp());
+      cfgCollisionSystem.value = CollisionSystemType::getCollisionTypeFromGrp(grpo);
+      switch (cfgCollisionSystem.value) {
+        case CollisionSystemType::kCollSyspp:
+          resoFT0A.value = 24.f;
+          resoFT0C.value = 24.f;
+          break;
+        case CollisionSystemType::kCollSysPbPb:
+          resoFT0A.value = 5.65f;
+          resoFT0C.value = 5.65f;
+          break;
+        default:
+          break;
+      }
+    }
+    table.reserve(collisions.size());
+    float t0A = 1e10f;
+    float t0C = 1e10f;
+    float eventtimeMC = 1e10f;
+    float posZMC = 0;
+    bool hasMCcoll = false;
+
+    for (auto& collision : collisions) {
+      hasMCcoll = false;
+      eventtimeMC = 1e10f;
+      t0A = 1e10f;
+      t0C = 1e10f;
+      posZMC = 0;
+      const float vertexPV = collision.posZ();
+      const float vertex_corr = vertexPV * invLightSpeedCm2NS;
+      constexpr float dummyTime = 30.; // Due to HW limitations time can be only within range (-25,25) ns, dummy time is around 32 ns
+      if (collision.has_mcCollision()) {
+        hasMCcoll = true;
+        const auto& collisionMC = collision.mcCollision();
+        eventtimeMC = collisionMC.t();
+        posZMC = collisionMC.posZ();
+      }
+      if (collision.has_foundFT0()) {
+        const auto& ft0 = collision.foundFT0();
+        const std::bitset<8>& triggers = ft0.triggerMask();
+        const bool ora = triggers[o2::ft0::Triggers::bitA];
+        const bool orc = triggers[o2::ft0::Triggers::bitC];
+
+        if (ora && ft0.timeA() < dummyTime) {
+          t0A = ft0.timeA();
+          if (hasMCcoll) {
+            const float diff = eventtimeMC - posZMC * invLightSpeedCm2NS + gRandom->Gaus(0.f, resoFT0A);
+            t0A = diff;
+          }
+          t0A += vertex_corr;
+        }
+        if (orc && ft0.timeC() < dummyTime) {
+          t0C = ft0.timeC();
+          if (hasMCcoll) {
+            const float diff = eventtimeMC + posZMC * invLightSpeedCm2NS + gRandom->Gaus(0.f, resoFT0C);
+            t0C = diff;
+          }
+          t0C -= vertex_corr;
+        }
+      }
+      LOGF(debug, " T0 collision time T0A = %f, T0C = %f", t0A, t0C);
+      if (addHistograms) {
+        histos.fill(HIST("t0A"), t0A);
+        histos.fill(HIST("t0C"), t0C);
+        histos.fill(HIST("t0AC"), (t0A + t0C) * 0.5f);
+        histos.fill(HIST("deltat0AC"), t0A - t0C);
+        if (hasMCcoll) {
+          histos.fill(HIST("MC/deltat0A"), (t0A - eventtimeMC) * 1000.f);
+          histos.fill(HIST("MC/deltat0C"), (t0C - eventtimeMC) * 1000.f);
+          histos.fill(HIST("MC/deltat0AC"), ((t0A + t0C) * 0.5f - eventtimeMC) * 1000.f);
+        }
+      }
       table(t0A, t0C);
     }
   }
+  PROCESS_SWITCH(ft0CorrectedTable, processWithBypassFT0timeInMC, "Process MC with bypass of the AO2D information. Use with care!", false);
 };
-WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
-{
-  return WorkflowSpec{adaptAnalysisTask<FT0CorrectedTable>(cfgc, TaskName{"ft0-corrected-table"})};
-}
+
+WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask<ft0CorrectedTable>(cfgc)}; }