Merge branch 'AliceO2Group:master' into master

Author: Shunsuke-Kurita

.github/workflows/mega-linter.yml

@@ -47,6 +47,16 @@ jobs:
           VALIDATE_ALL_CODEBASE: false
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
+      # Upload MegaLinter artifacts
+      - name: Archive production artifacts
+        uses: actions/upload-artifact@v4
+        if: success() || failure()
+        with:
+          name: MegaLinter reports
+          path: |
+            megalinter-reports
+            mega-linter.log
+
       # Create or delete the cleanup branch
       - name: Update cleanup branch
         if: ${{ github.event.repository.owner.login == 'AliceO2Group' }}

Common/Core/RecoDecay.h

@@ -935,6 +935,16 @@ struct RecoDecay {
       for (auto& iPart : arrayIds[-stage]) { // check all the particles that were the mothers at the previous stage
         auto particleMother = particlesMC.rawIteratorAt(iPart - particlesMC.offset());
         if (particleMother.has_mothers()) {
+
+          // we exit immediately if searchUpToQuark is false and the first mother is a parton (an hadron should never be the mother of a parton)
+          if (!searchUpToQuark) {
+            auto mother = particlesMC.rawIteratorAt(particleMother.mothersIds().front() - particlesMC.offset());
+            auto PDGParticleIMother = std::abs(mother.pdgCode()); // PDG code of the mother
+            if (PDGParticleIMother < 9 || (PDGParticleIMother > 20 && PDGParticleIMother < 38)) {
+              return OriginType::Prompt;
+            }
+          }
+
           for (auto iMother = particleMother.mothersIds().front(); iMother <= particleMother.mothersIds().back(); ++iMother) { // loop over the mother particles of the analysed particle
             if (std::find(arrayIdsStage.begin(), arrayIdsStage.end(), iMother) != arrayIdsStage.end()) {                       // if a mother is still present in the vector, do not check it again
               continue;

Common/TableProducer/qVectorsTable.cxx

@@ -80,6 +80,7 @@ struct qVectorsTable {
   Configurable<float> cfgMaxPtOnTPC{"cfgMaxPtOnTPC", 5., "maximum transverse momentum selection for TPC tracks participating in Q-vector reconstruction"};
   Configurable<int> cfgCorrLevel{"cfgCorrLevel", 4, "calibration step: 0 = no corr, 1 = gain corr, 2 = rectr, 3 = twist, 4 = full"};
   Configurable<std::vector<int>> cfgnMods{"cfgnMods", {2, 3}, "Modulation of interest"};
+  Configurable<float> cfgMaxCentrality{"cfgMaxCentrality", 100.f, "max. centrality for Q vector calibration"};
 
   Configurable<std::string> cfgGainEqPath{"cfgGainEqPath", "Users/j/junlee/Qvector/GainEq", "CCDB path for gain equalization constants"};
   Configurable<std::string> cfgQvecCalibPath{"cfgQvecCalibPath", "Analysis/EventPlane/QVecCorrections", "CCDB pasth for Q-vecteor calibration constants"};
@@ -522,14 +523,14 @@ struct qVectorsTable {
       coll.centFV0A()};
     cent = centAllEstim[cfgCentEsti];
     bool IsCalibrated = true;
-    if (cent < 0. || cent > 90.) {
+    if (cent < 0. || cent > cfgMaxCentrality) {
       cent = 110.;
       IsCalibrated = false;
     }
     for (std::size_t id = 0; id < cfgnMods->size(); id++) {
       int ind = cfgnMods->at(id);
       CalQvec(ind, coll, tracks, qvecRe, qvecIm, qvecAmp, TrkBPosLabel, TrkBNegLabel, TrkBTotLabel);
-      if (cent < 90.) {
+      if (cent < cfgMaxCentrality) {
         for (auto i{0u}; i < kBTot + 1; i++) {
           helperEP.DoRecenter(qvecRe[(kBTot + 1) * 4 * id + i * 4 + 1], qvecIm[(kBTot + 1) * 4 * id + i * 4 + 1],
                               objQvec.at(id)->GetBinContent(static_cast<int>(cent) + 1, 1, i + 1), objQvec.at(id)->GetBinContent(static_cast<int>(cent) + 1, 2, i + 1));

DPG/Tasks/AOTTrack/PID/HMPID/qaHMPID.cxx

@@ -14,7 +14,18 @@
 #include "Framework/runDataProcessing.h"
 #include "Framework/AnalysisTask.h"
 #include "Framework/AnalysisDataModel.h"
+#include "Framework/HistogramRegistry.h"
+#include "Framework/RunningWorkflowInfo.h"
+#include "ReconstructionDataFormats/TrackParametrization.h"
+#include "Common/DataModel/PIDResponse.h"
+#include "Common/Core/PID/PIDTOF.h"
+#include "Common/TableProducer/PID/pidTOFBase.h"
+#include "ReconstructionDataFormats/PID.h"
+#include "Common/Core/trackUtilities.h"
+#include "ReconstructionDataFormats/DCA.h"
 #include "Framework/ASoAHelpers.h"
+#include "Framework/ASoA.h"
+#include "Common/DataModel/EventSelection.h"
 #include "Common/DataModel/TrackSelectionTables.h"
 
 #include <TTree.h>
@@ -23,7 +34,56 @@ using namespace o2;
 using namespace o2::framework;
 using namespace o2::framework::expressions;
 
+namespace o2::aod
+{
+
+namespace variables_table // declaration of columns to create
+{
+DECLARE_SOA_COLUMN(ChAngle, chAngle, float);
+DECLARE_SOA_COLUMN(Phi, phi, float);
+DECLARE_SOA_COLUMN(Eta, eta, float);
+DECLARE_SOA_COLUMN(MomHMPID, momMPID, float);
+DECLARE_SOA_COLUMN(MomTrackX, momTrackX, float);
+DECLARE_SOA_COLUMN(MomTrackY, momTrackY, float);
+DECLARE_SOA_COLUMN(MomTrackZ, momTrackZ, float);
+DECLARE_SOA_COLUMN(Xtrack, xtrack, float);
+DECLARE_SOA_COLUMN(Ytrack, ytrack, float);
+DECLARE_SOA_COLUMN(Xmip, xmip, float);
+DECLARE_SOA_COLUMN(Ymip, ymip, float);
+DECLARE_SOA_COLUMN(Nphotons, nphotons, float);
+DECLARE_SOA_COLUMN(ChargeMIP, chargeMIP, float);
+DECLARE_SOA_COLUMN(ClusterSize, clustersize, float);
+DECLARE_SOA_COLUMN(Chamber, chamber, float);
+DECLARE_SOA_COLUMN(Photons_charge, photons_charge, float);
+
+DECLARE_SOA_COLUMN(EtaTrack, etatrack, float);
+DECLARE_SOA_COLUMN(PhiTrack, phitrack, float);
+
+DECLARE_SOA_COLUMN(ITSNcluster, itsNcluster, float);
+DECLARE_SOA_COLUMN(TPCNcluster, tpcNcluster, float);
+DECLARE_SOA_COLUMN(TPCNClsCrossedRows, tpcNClsCrossedRows, float);
+DECLARE_SOA_COLUMN(TPCchi2, tpcChi2, float);
+DECLARE_SOA_COLUMN(ITSchi2, itsChi2, float);
+
+DECLARE_SOA_COLUMN(DCAxy, dcaxy, float);
+DECLARE_SOA_COLUMN(DCAz, dcaz, float);
+
+} // namespace variables_table
+
+DECLARE_SOA_TABLE(HMPID_analysis, "AOD", "HMPIDANALYSIS",
+                  variables_table::ChAngle, variables_table::Phi, variables_table::Eta, variables_table::MomHMPID,
+                  variables_table::MomTrackX, variables_table::MomTrackY, variables_table::MomTrackZ,
+                  variables_table::Xtrack, variables_table::Ytrack, variables_table::Xmip,
+                  variables_table::Ymip, variables_table::Nphotons, variables_table::ChargeMIP, variables_table::ClusterSize,
+                  variables_table::Chamber, variables_table::Photons_charge, variables_table::EtaTrack, variables_table::PhiTrack,
+                  variables_table::ITSNcluster, variables_table::TPCNcluster, variables_table::TPCNClsCrossedRows,
+                  variables_table::TPCchi2, variables_table::ITSchi2, variables_table::DCAxy, variables_table::DCAz);
+} // namespace o2::aod
+
 struct pidHmpidQa {
+
+  Produces<aod::HMPID_analysis> HMPID_analysis;
+
   HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject};
   Configurable<int> nBinsP{"nBinsP", 500, "Number of momentum bins"};
   Configurable<float> minP{"minP", 0.01f, "Minimum momentum plotted (GeV/c)"};
@@ -73,21 +133,31 @@ struct pidHmpidQa {
   void process(const aod::HMPIDs& hmpids,
                const TrackCandidates& /*tracks*/,
                const aod::Collisions& /*colls*/)
+
   {
 
     for (const auto& t : hmpids) {
       if (t.track_as<TrackCandidates>().isGlobalTrack() != (uint8_t) true) {
         continue;
       }
-      if (abs(t.track_as<TrackCandidates>().dcaXY()) > maxDCA) {
+
+      const auto& track = t.track_as<TrackCandidates>();
+
+      if (!track.hasITS() || !track.hasTPC() || !track.hasTOF()) {
         continue;
       }
 
+      HMPID_analysis(t.hmpidSignal(), t.track_as<TrackCandidates>().phi(), t.track_as<TrackCandidates>().eta(), t.hmpidMom(),
+                     track.px(), track.py(), track.pz(), t.hmpidXTrack(), t.hmpidYTrack(), t.hmpidXMip(),
+                     t.hmpidYMip(), t.hmpidNPhotons(), t.hmpidQMip(), (t.hmpidClusSize() % 1000000) / 1000, t.hmpidClusSize() / 1000000,
+                     *t.hmpidPhotsCharge(), track.eta(), track.phi(), track.itsNCls(), track.tpcNClsFound(), track.tpcNClsCrossedRows(),
+                     track.tpcChi2NCl(), track.itsChi2NCl(), track.dcaXY(), track.dcaZ());
+
       histos.fill(HIST("hmpidSignal"), t.hmpidSignal());
       histos.fill(HIST("PhivsEta"), t.track_as<TrackCandidates>().eta(), t.track_as<TrackCandidates>().phi());
       histos.fill(HIST("hmpidMomvsTrackMom"), t.track_as<TrackCandidates>().p(), abs(t.hmpidMom()));
       histos.fill(HIST("hmpidCkovvsMom"), abs(t.hmpidMom()), t.hmpidSignal());
-      histos.fill(HIST("hmpidXTrack"), t.hmpidYTrack());
+      histos.fill(HIST("hmpidXTrack"), t.hmpidXTrack());
       histos.fill(HIST("hmpidYTrack"), t.hmpidYTrack());
       histos.fill(HIST("hmpidXMip"), t.hmpidXMip());
       histos.fill(HIST("hmpidYMip"), t.hmpidYMip());

DPG/Tasks/AOTTrack/qaEfficiency.cxx

@@ -925,24 +925,11 @@ struct QaEfficiency {
   }
   bool isFinal(const o2::aod::McParticles::iterator& mcParticle)
   {
-    // Example conditions to determine if a particle is final (tertiary)
-    // Here, we assume that final state particles are those not originating from primary vertex
-    // and not further decaying into other particles
-    // Check if the particle has no daughters
-    if (!mcParticle.has_daughters()) {
-
-      // Check if the particle is not a primary particle
-      if (!mcParticle.isPhysicalPrimary()) {
-        // Check if the particle is produced in a secondary decay
-        if (mcParticle.getProcess() == 4) {
-          // Get the mother particle's index and the mother particle itself
-          auto mothers = mcParticle.mothers_as<o2::aod::McParticles>();
-          for (const auto& mother : mothers) {
-            // Check if the mother particle is not primary and produced in a weak decay
-            if (!mother.isPhysicalPrimary() && mother.getProcess() == 4) {
-              return true; // Consider it as a tertiary particle
-            }
-          }
+    if (!mcParticle.has_daughters() && !mcParticle.isPhysicalPrimary() && mcParticle.getProcess() == 4) {
+      auto mothers = mcParticle.mothers_as<o2::aod::McParticles>();
+      for (const auto& mother : mothers) {
+        if (!mother.isPhysicalPrimary() && mother.getProcess() == 4) {
+          return true;
         }
       }
     }

EventFiltering/Zorro.cxx

@@ -15,6 +15,8 @@
 #include <algorithm>
 #include <map>
 
+#include <TList.h>
+
 #include "CCDB/BasicCCDBManager.h"
 #include "CommonDataFormat/InteractionRecord.h"
 
@@ -35,44 +37,56 @@ int findBin(TH1* hist, const std::string& label)
 
 void Zorro::populateHistRegistry(o2::framework::HistogramRegistry& histRegistry, int runNumber, std::string prefix)
 {
-  if (mRunNumberHistos == runNumber) {
+  int runId{-1};
+  for (size_t i{0}; i < mRunNumberHistos.size(); ++i) {
+    if (mRunNumberHistos[i] == runNumber) {
+      runId = i;
+      break;
+    }
+  }
+  if (runId > -1) {
+    /// Support jobs running on non-continuous run numbers
+    mAnalysedTriggers = mAnalysedTriggersList[runId];
+    mAnalysedTriggersOfInterest = mAnalysedTriggersOfInterestList[runId];
     return;
   }
-  mRunNumberHistos = runNumber;
   if (mSelections) {
-    mAnalysedTriggers = histRegistry.add<TH1>((std::to_string(mRunNumberHistos) + "/" + prefix + "AnalysedTriggers").data(), "", o2::framework::HistType::kTH1D, {{mSelections->GetNbinsX() - 2, -0.5, mSelections->GetNbinsX() - 2.5}});
+    mAnalysedTriggers = histRegistry.add<TH1>((std::to_string(runNumber) + "/" + prefix + "AnalysedTriggers").data(), "", o2::framework::HistType::kTH1D, {{mSelections->GetNbinsX() - 2, -0.5, mSelections->GetNbinsX() - 2.5}}).get();
     for (int iBin{2}; iBin < mSelections->GetNbinsX(); ++iBin) { // Exclude first and last bins as they are total number of analysed and selected events, respectively
       mAnalysedTriggers->GetXaxis()->SetBinLabel(iBin - 1, mSelections->GetXaxis()->GetBinLabel(iBin));
     }
-    std::shared_ptr<TH1> selections = histRegistry.add<TH1>((std::to_string(mRunNumberHistos) + "/" + prefix + "Selections").data(), "", o2::framework::HistType::kTH1D, {{mSelections->GetNbinsX(), -0.5, static_cast<double>(mSelections->GetNbinsX() - 0.5)}});
+    std::shared_ptr<TH1> selections = histRegistry.add<TH1>((std::to_string(runNumber) + "/" + prefix + "Selections").data(), "", o2::framework::HistType::kTH1D, {{mSelections->GetNbinsX(), -0.5, static_cast<double>(mSelections->GetNbinsX() - 0.5)}});
     for (int iBin{1}; iBin <= mSelections->GetNbinsX(); ++iBin) {
       selections->GetXaxis()->SetBinLabel(iBin, mSelections->GetXaxis()->GetBinLabel(iBin));
       selections->SetBinContent(iBin, mSelections->GetBinContent(iBin));
       selections->SetBinError(iBin, mSelections->GetBinError(iBin));
     }
   }
   if (mScalers) {
-    std::shared_ptr<TH1> scalers = histRegistry.add<TH1>((std::to_string(mRunNumberHistos) + "/" + prefix + "Scalers").data(), "", o2::framework::HistType::kTH1D, {{mScalers->GetNbinsX(), -0.5, static_cast<double>(mScalers->GetNbinsX() - 0.5)}});
+    std::shared_ptr<TH1> scalers = histRegistry.add<TH1>((std::to_string(runNumber) + "/" + prefix + "Scalers").data(), "", o2::framework::HistType::kTH1D, {{mScalers->GetNbinsX(), -0.5, static_cast<double>(mScalers->GetNbinsX() - 0.5)}});
     for (int iBin{1}; iBin <= mScalers->GetNbinsX(); ++iBin) {
       scalers->GetXaxis()->SetBinLabel(iBin, mScalers->GetXaxis()->GetBinLabel(iBin));
       scalers->SetBinContent(iBin, mScalers->GetBinContent(iBin));
       scalers->SetBinError(iBin, mScalers->GetBinError(iBin));
     }
   }
   if (mInspectedTVX) {
-    std::shared_ptr<TH1> inspectedTVX = histRegistry.add<TH1>((std::to_string(mRunNumberHistos) + "/" + prefix + "InspectedTVX").data(), "", o2::framework::HistType::kTH1D, {{mInspectedTVX->GetNbinsX(), -0.5, static_cast<double>(mInspectedTVX->GetNbinsX() - 0.5)}});
+    std::shared_ptr<TH1> inspectedTVX = histRegistry.add<TH1>((std::to_string(runNumber) + "/" + prefix + "InspectedTVX").data(), "", o2::framework::HistType::kTH1D, {{mInspectedTVX->GetNbinsX(), -0.5, static_cast<double>(mInspectedTVX->GetNbinsX() - 0.5)}});
     for (int iBin{1}; iBin <= mInspectedTVX->GetNbinsX(); ++iBin) {
       inspectedTVX->GetXaxis()->SetBinLabel(iBin, mInspectedTVX->GetXaxis()->GetBinLabel(iBin));
       inspectedTVX->SetBinContent(iBin, mInspectedTVX->GetBinContent(iBin));
       inspectedTVX->SetBinError(iBin, mInspectedTVX->GetBinError(iBin));
     }
   }
   if (mTOIs.size()) {
-    mAnalysedTriggersOfInterest = histRegistry.add<TH1>((std::to_string(mRunNumberHistos) + "/" + prefix + "AnalysedTriggersOfInterest").data(), "", o2::framework::HistType::kTH1D, {{static_cast<int>(mTOIs.size()), -0.5, static_cast<double>(mTOIs.size() - 0.5)}});
+    mAnalysedTriggersOfInterest = histRegistry.add<TH1>((std::to_string(runNumber) + "/" + prefix + "AnalysedTriggersOfInterest").data(), "", o2::framework::HistType::kTH1D, {{static_cast<int>(mTOIs.size()), -0.5, static_cast<double>(mTOIs.size() - 0.5)}}).get();
     for (size_t i{0}; i < mTOIs.size(); ++i) {
       mAnalysedTriggersOfInterest->GetXaxis()->SetBinLabel(i + 1, mTOIs[i].data());
     }
   }
+  mAnalysedTriggersList.push_back(mAnalysedTriggers);
+  mAnalysedTriggersOfInterestList.push_back(mAnalysedTriggersOfInterest);
+  mRunNumberHistos.push_back(runNumber);
 }
 
 std::vector<int> Zorro::initCCDB(o2::ccdb::BasicCCDBManager* ccdb, int runNumber, uint64_t timestamp, std::string tois, int bcRange)
@@ -91,9 +105,11 @@ std::vector<int> Zorro::initCCDB(o2::ccdb::BasicCCDBManager* ccdb, int runNumber
   mZorroHelpers = mCCDB->getSpecific<std::vector<ZorroHelper>>(mBaseCCDBPath + "ZorroHelpers", timestamp, metadata);
   std::sort(mZorroHelpers->begin(), mZorroHelpers->end(), [](const auto& a, const auto& b) { return std::min(a.bcAOD, a.bcEvSel) < std::min(b.bcAOD, b.bcEvSel); });
   mBCranges.clear();
+  mAccountedBCranges.clear();
   for (auto helper : *mZorroHelpers) {
     mBCranges.emplace_back(InteractionRecord::long2IR(std::min(helper.bcAOD, helper.bcEvSel)), InteractionRecord::long2IR(std::max(helper.bcAOD, helper.bcEvSel)));
   }
+  mAccountedBCranges.resize(mBCranges.size(), false);
 
   mLastBCglobalId = 0;
   mLastSelectedIdx = 0;
@@ -123,24 +139,25 @@ std::bitset<128> Zorro::fetch(uint64_t bcGlobalId, uint64_t tolerance)
 {
   mLastResult.reset();
   o2::dataformats::IRFrame bcFrame{InteractionRecord::long2IR(bcGlobalId) - tolerance, InteractionRecord::long2IR(bcGlobalId) + tolerance};
-  if (bcGlobalId < mLastBCglobalId) {
+  if (bcGlobalId < mLastBCglobalId) { /// Handle the possible discontinuity in the BC processed by the analyses
     mLastSelectedIdx = 0;
   }
+  uint64_t lastSelectedIdx = mLastSelectedIdx;
   mLastBCglobalId = bcGlobalId;
   for (size_t i = mLastSelectedIdx; i < mBCranges.size(); i++) {
     if (!mBCranges[i].isOutside(bcFrame)) {
       for (int iMask{0}; iMask < 2; ++iMask) {
         for (int iTOI{0}; iTOI < 64; ++iTOI) {
           if (mZorroHelpers->at(i).selMask[iMask] & (1ull << iTOI)) {
             mLastResult.set(iMask * 64 + iTOI, 1);
-            if (mAnalysedTriggers) {
+            if (mAnalysedTriggers && !mAccountedBCranges[i]) {
               mAnalysedTriggers->Fill(iMask * 64 + iTOI);
             }
           }
         }
       }
-      mLastSelectedIdx = i;
-      return mLastResult;
+      mAccountedBCranges[i] = true;
+      mLastSelectedIdx = mLastSelectedIdx == lastSelectedIdx-- ? i : mLastSelectedIdx; /// Decrease lastSelectedIdx to make sure this check is valid only in its first instance
     } else if (mBCranges[i].getMax() < bcFrame.getMin()) {
       mLastSelectedIdx = i;
     } else if (mBCranges[i].getMin() > bcFrame.getMax()) {
@@ -166,4 +183,4 @@ bool Zorro::isSelected(uint64_t bcGlobalId, uint64_t tolerance)
     }
   }
   return false;
-}
+}

EventFiltering/Zorro.h

@@ -32,7 +32,7 @@ class BasicCCDBManager;
 }; // namespace o2
 
 struct ZorroHelper {
-  uint64_t bcAOD, bcEvSel, trigMask[2], selMask[2];
+  ULong64_t bcAOD, bcEvSel, trigMask[2], selMask[2];
   ClassDefNV(ZorroHelper, 1);
 };
 
@@ -59,16 +59,21 @@ class Zorro
  private:
   std::string mBaseCCDBPath = "Users/m/mpuccio/EventFiltering/OTS/";
   int mRunNumber = 0;
-  int mRunNumberHistos = 0;
+  TH1* mAnalysedTriggers;           /// Accounting for all triggers in the current run
+  TH1* mAnalysedTriggersOfInterest; /// Accounting for triggers of interest in the current run
+
+  std::vector<int> mRunNumberHistos;
+  std::vector<TH1*> mAnalysedTriggersList;           /// Per run histograms
+  std::vector<TH1*> mAnalysedTriggersOfInterestList; /// Per run histograms
+
   int mBCtolerance = 100;
   uint64_t mLastBCglobalId = 0;
   uint64_t mLastSelectedIdx = 0;
   TH1D* mScalers = nullptr;
   TH1D* mSelections = nullptr;
   TH1D* mInspectedTVX = nullptr;
-  std::shared_ptr<TH1> mAnalysedTriggers;
-  std::shared_ptr<TH1> mAnalysedTriggersOfInterest;
   std::bitset<128> mLastResult;
+  std::vector<bool> mAccountedBCranges; /// Avoid double accounting of inspected BC ranges
   std::vector<o2::dataformats::IRFrame> mBCranges;
   std::vector<ZorroHelper>* mZorroHelpers = nullptr;
   std::vector<std::string> mTOIs;
@@ -77,4 +82,4 @@ class Zorro
   o2::ccdb::BasicCCDBManager* mCCDB = nullptr;
 };
 
-#endif // EVENTFILTERING_ZORRO_H_
+#endif // EVENTFILTERING_ZORRO_H_