Merge branch 'master' into Update_InitializerQA

Author: mjkim525

ALICE3/DataModel/OTFMCParticle.h

@@ -21,6 +21,8 @@
 
 #include <Framework/AnalysisDataModel.h>
 
+#include <cstdint>
+
 namespace o2::aod
 {
 

ALICE3/Macros/drawFastTracker.C

@@ -14,16 +14,25 @@
 
 #include <DataFormatsParameters/GRPMagField.h>
 #include <DetectorsBase/Propagator.h>
+#include <Framework/Logger.h>
+#include <ReconstructionDataFormats/Track.h>
 #include <ReconstructionDataFormats/Vertex.h>
 
 #include <TAxis.h>
 #include <TCanvas.h>
 #include <TDatabasePDG.h>
 #include <TEfficiency.h>
 #include <TGraph.h>
-#include <TH1F.h>
+#include <TH1.h>
 #include <TLatex.h>
 #include <TLorentzVector.h>
+#include <TParticlePDG.h>
+#include <TString.h>
+
+#include <RtypesCore.h>
+
+#include <cstddef>
+#include <vector>
 
 void drawFastTracker(float magneticField = 5.f, // in units of kGauss
                      const int nch = 100,       // number of charged particles per unit rapidity

ALICE3/Macros/testFastTracker.C

@@ -15,10 +15,10 @@
 
 #include "ALICE3/Core/FastTracker.h"
 
-#include <CCDB/BasicCCDBManager.h>
-#include <DataFormatsParameters/GRPLHCIFData.h>
 #include <Framework/Logger.h>
 
+#include <string>
+
 void testFastTracker(std::string geometryFile = "a3geo.ini")
 {
 

ALICE3/Tasks/alice3TrackingPerformance.cxx

@@ -13,7 +13,7 @@
 ///
 /// \brief This task produces the tracking performance
 ///
-/// \author Nicolò Jacazio, Universita del Piemonte Orientale (IT)
+/// \author Nicolò Jacazio, Università del Piemonte Orientale (IT)
 /// \since  May 27, 2025
 ///
 
@@ -46,7 +46,9 @@ std::map<int, std::shared_ptr<TH1>> particlePtDistribution;
 std::map<int, std::shared_ptr<TH1>> particleEtaDistribution;
 std::map<int, std::shared_ptr<TH1>> ptDistribution;
 std::map<int, std::shared_ptr<TH2>> ptResolutionVsPt;
+std::map<int, std::shared_ptr<TProfile2D>> ptResolutionVsEta;
 std::map<int, std::shared_ptr<TH2>> invPtResolutionVsPt;
+std::map<int, std::shared_ptr<TProfile2D>> invPtResolutionVsEta;
 std::map<int, std::shared_ptr<TH2>> dcaXyResolutionVsPt;
 std::map<int, std::shared_ptr<TH2>> dcaZResolutionVsPt;
 
@@ -57,26 +59,30 @@ struct Alice3TrackingPerformance {
 
   void init(o2::framework::InitContext&)
   {
-    const AxisSpec axisPt{100, 0, 10, "p_{T} (GeV/c)"};
+    const AxisSpec axisPt{500, 0, 100, "#it{p}_{T} (GeV/#it{c})"};
     const AxisSpec axisEta{100, etaRange.value.first, etaRange.value.second, "#eta"};
-    const AxisSpec axisPtDelta{100, -1, 1, "p_{T}^{gen} - p_{T}^{reco} (GeV/c)"};
-    const AxisSpec axisInvPtDelta{100, -1, 1, "1./p_{T}^{gen} - 1./p_{T}^{reco} (GeV/c)^{-1}"};
+    const AxisSpec axisPtDelta{100, -1, 1, "(#it{p}_{T}^{reco} - #it{p}_{T}^{gen}) / #it{p}_{T}^{gen}"};
+    const AxisSpec axisInvPtDelta{100, -1, 1, "1./#it{p}_{T}^{gen} - 1./#it{p}_{T}^{reco} (GeV/#it{c})^{-1}"};
     const AxisSpec axisDcaXy{100, -1, 1, "DCA_{xy} (cm)"};
     const AxisSpec axisDcaZ{100, -1, 1, "DCA_{z} (cm)"};
     particlePdgCodes = histos.add<TH1>("particlePdgCodes", "", kTH1D, {AxisSpec{100, -0.5, 99.5, "PDG Code"}});
     for (const int& pdg : pdgCodes.value) {
-      std::string tag = Form("_%d", pdg);
+      std::string prefix = Form("%i", pdg);
       if (pdg < 0) {
-        tag = Form("_m%d", -pdg);
+        prefix = Form("m%i", -pdg);
       }
-      particlePtDistribution[pdg] = histos.add<TH1>("particlePtDistribution" + tag, "", kTH1D, {axisPt});
-      particleEtaDistribution[pdg] = histos.add<TH1>("particleEtaDistribution" + tag, "", kTH1D, {axisEta});
+      const std::string tag = "_" + prefix;
+      prefix += "/";
+      particlePtDistribution[pdg] = histos.add<TH1>(prefix + "particlePtDistribution" + tag, "", kTH1D, {axisPt});
+      particleEtaDistribution[pdg] = histos.add<TH1>(prefix + "particleEtaDistribution" + tag, "", kTH1D, {axisEta});
 
-      ptDistribution[pdg] = histos.add<TH1>("ptDistribution" + tag, "", kTH1D, {axisPt});
-      ptResolutionVsPt[pdg] = histos.add<TH2>("ptResolutionVsPt" + tag, "", kTH2D, {axisPt, axisPtDelta});
-      invPtResolutionVsPt[pdg] = histos.add<TH2>("invPtResolutionVsPt" + tag, "", kTH2D, {axisPt, axisInvPtDelta});
-      dcaXyResolutionVsPt[pdg] = histos.add<TH2>("dcaXyResolutionVsPt" + tag, "", kTH2D, {axisPt, axisDcaXy});
-      dcaZResolutionVsPt[pdg] = histos.add<TH2>("dcaZResolutionVsPt" + tag, "", kTH2D, {axisPt, axisDcaZ});
+      ptDistribution[pdg] = histos.add<TH1>(prefix + "ptDistribution" + tag, "", kTH1D, {axisPt});
+      ptResolutionVsPt[pdg] = histos.add<TH2>(prefix + "ptResolutionVsPt" + tag, "", kTH2D, {axisPt, axisPtDelta});
+      ptResolutionVsEta[pdg] = histos.add<TProfile2D>(prefix + "ptResolutionVsEta" + tag, "", kTProfile2D, {axisPt, axisEta});
+      invPtResolutionVsPt[pdg] = histos.add<TH2>(prefix + "invPtResolutionVsPt" + tag, "", kTH2D, {axisPt, axisInvPtDelta});
+      invPtResolutionVsEta[pdg] = histos.add<TProfile2D>(prefix + "invPtResolutionVsEta" + tag, "", kTProfile2D, {axisPt, axisEta});
+      dcaXyResolutionVsPt[pdg] = histos.add<TH2>(prefix + "dcaXyResolutionVsPt" + tag, "", kTH2D, {axisPt, axisDcaXy});
+      dcaZResolutionVsPt[pdg] = histos.add<TH2>(prefix + "dcaZResolutionVsPt" + tag, "", kTH2D, {axisPt, axisDcaZ});
     }
   }
 
@@ -110,26 +116,32 @@ struct Alice3TrackingPerformance {
       particleEtaDistribution[mcParticle.pdgCode()]->Fill(mcParticle.eta());
     }
     for (const auto& track : tracks) {
-      ptDistribution[0]->Fill(track.pt());
       if (!track.has_mcParticle()) {
         continue;
       }
       const auto& mcParticle = track.mcParticle();
-      ptResolutionVsPt[0]->Fill(mcParticle.pt(), mcParticle.pt() - track.pt());
-      invPtResolutionVsPt[0]->Fill(mcParticle.pt(), 1.f / mcParticle.pt() - 1.f / track.pt());
-      dcaXyResolutionVsPt[0]->Fill(mcParticle.pt(), track.dcaXY());
-      dcaZResolutionVsPt[0]->Fill(mcParticle.pt(), track.dcaZ());
+      const float ptResolution = (track.pt() - mcParticle.pt()) / mcParticle.pt();
+      const float invptResolution = 1.f / track.pt() - 1.f / mcParticle.pt();
+
+      auto fillResolutionHistograms = [&](const int p) {
+        ptDistribution[p]->Fill(track.pt());
+        ptResolutionVsPt[p]->Fill(mcParticle.pt(), ptResolution);
+        ptResolutionVsEta[p]->Fill(mcParticle.pt(), mcParticle.eta(), ptResolution);
+        invPtResolutionVsPt[p]->Fill(mcParticle.pt(), invptResolution);
+        invPtResolutionVsEta[p]->Fill(mcParticle.pt(), mcParticle.eta(), invptResolution);
+        dcaXyResolutionVsPt[p]->Fill(mcParticle.pt(), track.dcaXY());
+        dcaZResolutionVsPt[p]->Fill(mcParticle.pt(), track.dcaZ());
+      };
+
+      fillResolutionHistograms(0);
+
       if (!isParticleSelected(mcParticle)) {
         continue;
       }
       if (ptResolutionVsPt.find(mcParticle.pdgCode()) == ptResolutionVsPt.end()) {
         continue;
       }
-      ptDistribution[mcParticle.pdgCode()]->Fill(mcParticle.pt());
-      ptResolutionVsPt[mcParticle.pdgCode()]->Fill(mcParticle.pt(), mcParticle.pt() - track.pt());
-      invPtResolutionVsPt[mcParticle.pdgCode()]->Fill(mcParticle.pt(), 1.f / mcParticle.pt() - 1.f / track.pt());
-      dcaXyResolutionVsPt[mcParticle.pdgCode()]->Fill(mcParticle.pt(), track.dcaXY());
-      dcaZResolutionVsPt[mcParticle.pdgCode()]->Fill(mcParticle.pt(), track.dcaZ());
+      fillResolutionHistograms(mcParticle.pdgCode());
     }
   }
 };

Common/DataModel/Multiplicity.h

@@ -26,20 +26,19 @@ namespace o2::aod
 {
 namespace mult
 {
-DECLARE_SOA_COLUMN(MultFV0A, multFV0A, float);           //!
-DECLARE_SOA_COLUMN(MultFV0AOuter, multFV0AOuter, float); //!
-DECLARE_SOA_COLUMN(MultFV0C, multFV0C, float);           //!
-DECLARE_SOA_COLUMN(MultFT0A, multFT0A, float);           //!
-DECLARE_SOA_COLUMN(MultFT0C, multFT0C, float);           //!
-DECLARE_SOA_COLUMN(MultFDDA, multFDDA, float);           //!
-DECLARE_SOA_COLUMN(MultFDDC, multFDDC, float);           //!
-DECLARE_SOA_COLUMN(MultZNA, multZNA, float);             //!
-DECLARE_SOA_COLUMN(MultZNC, multZNC, float);             //!
-DECLARE_SOA_COLUMN(MultZEM1, multZEM1, float);           //!
-DECLARE_SOA_COLUMN(MultZEM2, multZEM2, float);           //!
-DECLARE_SOA_COLUMN(MultZPA, multZPA, float);             //!
-DECLARE_SOA_COLUMN(MultZPC, multZPC, float);             //!
-DECLARE_SOA_DYNAMIC_COLUMN(MultFV0M, multFV0M,           //!
+DECLARE_SOA_COLUMN(MultFV0A, multFV0A, float); //!
+DECLARE_SOA_COLUMN(MultFV0C, multFV0C, float); //!
+DECLARE_SOA_COLUMN(MultFT0A, multFT0A, float); //!
+DECLARE_SOA_COLUMN(MultFT0C, multFT0C, float); //!
+DECLARE_SOA_COLUMN(MultFDDA, multFDDA, float); //!
+DECLARE_SOA_COLUMN(MultFDDC, multFDDC, float); //!
+DECLARE_SOA_COLUMN(MultZNA, multZNA, float);   //!
+DECLARE_SOA_COLUMN(MultZNC, multZNC, float);   //!
+DECLARE_SOA_COLUMN(MultZEM1, multZEM1, float); //!
+DECLARE_SOA_COLUMN(MultZEM2, multZEM2, float); //!
+DECLARE_SOA_COLUMN(MultZPA, multZPA, float);   //!
+DECLARE_SOA_COLUMN(MultZPC, multZPC, float);   //!
+DECLARE_SOA_DYNAMIC_COLUMN(MultFV0M, multFV0M, //!
                            [](float multFV0A, float multFV0C) -> float { return multFV0A + multFV0C; });
 DECLARE_SOA_DYNAMIC_COLUMN(MultFT0M, multFT0M, //!
                            [](float multFT0A, float multFT0C) -> float { return multFT0A + multFT0C; });
@@ -100,6 +99,10 @@ DECLARE_SOA_COLUMN(TimeToPrevious, timeToPrevious, float);       //!
 DECLARE_SOA_COLUMN(TimeToNext, timeToNext, float);               //!
 DECLARE_SOA_COLUMN(TimeToNeNext, timeToNeNext, float);           //!
 
+// Extra information from FIT detectors
+DECLARE_SOA_COLUMN(MultFV0AOuter, multFV0AOuter, float);     //! FV0 without innermost ring
+DECLARE_SOA_COLUMN(FT0TriggerMask, ft0TriggerMask, uint8_t); //!
+
 } // namespace mult
 DECLARE_SOA_TABLE(FV0Mults, "AOD", "FV0MULT", //! Multiplicity with the FV0 detector
                   mult::MultFV0A, mult::MultFV0C,
@@ -126,6 +129,11 @@ DECLARE_SOA_TABLE(PVMults, "AOD", "PVMULT", //! Multiplicity from the PV contrib
                   mult::IsInelGt1<mult::MultNTracksPVeta1>);
 DECLARE_SOA_TABLE(MFTMults, "AOD", "MFTMULT", //! Multiplicity with MFT
                   mult::MFTNalltracks, mult::MFTNtracks);
+
+DECLARE_SOA_TABLE(FITExtraMults, "AOD", "FITEXTRAMULT", //! Extra information from FIT detectors
+                  mult::MultFV0AOuter,
+                  mult::FT0TriggerMask);
+
 using BarrelMults = soa::Join<TrackletMults, TPCMults, PVMults>;
 using Mults = soa::Join<BarrelMults, FV0Mults, FT0Mults, FDDMults, ZDCMults>;
 using MultsRun3 = soa::Join<TPCMults, PVMults, FV0Mults, FT0Mults, FDDMults, ZDCMults>;

Common/Tasks/centralityStudy.cxx

@@ -20,6 +20,7 @@
 #include "Common/DataModel/Multiplicity.h"
 
 #include <CCDB/BasicCCDBManager.h>
+#include <DataFormatsFIT/Triggers.h>
 #include <DataFormatsParameters/GRPECSObject.h>
 #include <Framework/AnalysisDataModel.h>
 #include <Framework/AnalysisHelpers.h>
@@ -91,6 +92,7 @@ struct centralityStudy {
   Configurable<bool> requireIsVertexTOFmatched{"requireIsVertexTOFmatched", false, "require events with at least one of vertex contributors matched to TOF"};
   Configurable<bool> requireIsVertexTRDmatched{"requireIsVertexTRDmatched", false, "require events with at least one of vertex contributors matched to TRD"};
   Configurable<bool> rejectSameBunchPileup{"rejectSameBunchPileup", true, "reject collisions in case of pileup with another collision in the same foundBC"};
+  Configurable<bool> rejectIsFlangeEvent{"rejectIsFlangeEvent", false, "At least one channel with -350 TDC < time < -450 TDC"};
 
   Configurable<bool> rejectITSinROFpileupStandard{"rejectITSinROFpileupStandard", false, "reject collisions in case of in-ROF ITS pileup (standard)"};
   Configurable<bool> rejectITSinROFpileupStrict{"rejectITSinROFpileupStrict", false, "reject collisions in case of in-ROF ITS pileup (strict)"};
@@ -201,8 +203,12 @@ struct centralityStudy {
       histos.get<TH1>(HIST("hCollisionSelection"))->GetXaxis()->SetBinLabel(11, "Neighbour rejection");
       histos.get<TH1>(HIST("hCollisionSelection"))->GetXaxis()->SetBinLabel(12, "no ITS in-ROF pileup (standard)");
       histos.get<TH1>(HIST("hCollisionSelection"))->GetXaxis()->SetBinLabel(13, "no ITS in-ROF pileup (strict)");
+      histos.get<TH1>(HIST("hCollisionSelection"))->GetXaxis()->SetBinLabel(14, "is UPC event");
+      histos.get<TH1>(HIST("hCollisionSelection"))->GetXaxis()->SetBinLabel(15, "rejectCollInTimeRangeNarrow");
+      histos.get<TH1>(HIST("hCollisionSelection"))->GetXaxis()->SetBinLabel(16, "em/upc rejection");
+      histos.get<TH1>(HIST("hCollisionSelection"))->GetXaxis()->SetBinLabel(17, "isFlangeEvent");
 
-      histos.add("hFT0A_Collisions", "hFT0C_Collisions", kTH1D, {axisMultUltraFineFT0A});
+      histos.add("hFT0A_Collisions", "hFT0A_Collisions", kTH1D, {axisMultUltraFineFT0A});
       histos.add("hFT0C_Collisions", "hFT0C_Collisions", kTH1D, {axisMultUltraFineFT0C});
       histos.add("hFT0M_Collisions", "hFT0M_Collisions", kTH1D, {axisMultUltraFineFT0M});
       histos.add("hFV0A_Collisions", "hFV0A_Collisions", kTH1D, {axisMultUltraFineFV0A});
@@ -372,6 +378,10 @@ struct centralityStudy {
       getHist(TH1, histPath + "hCollisionSelection")->GetXaxis()->SetBinLabel(11, "Neighbour rejection");
       getHist(TH1, histPath + "hCollisionSelection")->GetXaxis()->SetBinLabel(12, "no ITS in-ROF pileup (standard)");
       getHist(TH1, histPath + "hCollisionSelection")->GetXaxis()->SetBinLabel(13, "no ITS in-ROF pileup (strict)");
+      getHist(TH1, histPath + "hCollisionSelection")->GetXaxis()->SetBinLabel(14, "is UPC event");
+      getHist(TH1, histPath + "hCollisionSelection")->GetXaxis()->SetBinLabel(15, "rejectCollInTimeRangeNarrow");
+      getHist(TH1, histPath + "hCollisionSelection")->GetXaxis()->SetBinLabel(16, "em/upc rejection");
+      getHist(TH1, histPath + "hCollisionSelection")->GetXaxis()->SetBinLabel(17, "isFlangeEvent");
 
       histPointers.insert({histPath + "hFT0C_Collisions", histos.add((histPath + "hFT0C_Collisions").c_str(), "hFT0C_Collisions", {kTH1D, {{axisMultUltraFineFT0C}}})});
       histPointers.insert({histPath + "hFT0A_Collisions", histos.add((histPath + "hFT0A_Collisions").c_str(), "hFT0A_Collisions", {kTH1D, {{axisMultUltraFineFT0A}}})});
@@ -608,7 +618,7 @@ struct centralityStudy {
     if (!passRejectCollInTimeRangeNarrow) {
       return;
     }
-    histos.fill(HIST("hCollisionSelection"), 14 /* Not ITS ROF pileup (strict) */);
+    histos.fill(HIST("hCollisionSelection"), 14 /* Reject collision in narrow time range */);
     getHist(TH1, histPath + "hCollisionSelection")->Fill(14);
 
     if (collision.multFT0C() < upcRejection.maxFT0CforZNACselection &&
@@ -627,6 +637,18 @@ struct centralityStudy {
     histos.fill(HIST("hCollisionSelection"), 15 /* pass em/upc rejection */);
     getHist(TH1, histPath + "hCollisionSelection")->Fill(15);
 
+    if (rejectIsFlangeEvent) {
+      if constexpr (requires { collision.ft0TriggerMask(); }) {
+        constexpr int IsFlangeEventId = 7;
+        std::bitset<8> ft0TriggerMask = collision.ft0TriggerMask();
+        if (ft0TriggerMask[IsFlangeEventId]) {
+          return;
+        }
+      }
+    }
+    histos.fill(HIST("hCollisionSelection"), 16 /* reject flange events */);
+    getHist(TH1, histPath + "hCollisionSelection")->Fill(16);
+
     // if we got here, we also finally fill the FT0C histogram, please
     histos.fill(HIST("hNPVContributors"), collision.multNTracksPV());
     histos.fill(HIST("hFT0A_Collisions"), collision.multFT0A() * scaleSignalFT0C);
@@ -789,22 +811,22 @@ struct centralityStudy {
     }
   }
 
-  void processCollisions(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultsGlobal, aod::MultSelections, aod::Mults2BC, aod::FV0AOuterMults>::iterator const& collision, aod::MultBCs const&)
+  void processCollisions(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultsGlobal, aod::MultSelections, aod::Mults2BC, aod::FITExtraMults>::iterator const& collision, aod::MultBCs const&)
   {
     genericProcessCollision(collision);
   }
 
-  void processCollisionsWithResolutionStudy(soa::Join<aod::MultsRun3, aod::MFTMults, aod::Mult2MCExtras, aod::MultsExtra, aod::MultsGlobal, aod::MultSelections, aod::Mults2BC, aod::FV0AOuterMults>::iterator const& collision, soa::Join<aod::MultMCExtras, aod::MultHepMCHIs> const&)
+  void processCollisionsWithResolutionStudy(soa::Join<aod::MultsRun3, aod::MFTMults, aod::Mult2MCExtras, aod::MultsExtra, aod::MultsGlobal, aod::MultSelections, aod::Mults2BC, aod::FITExtraMults>::iterator const& collision, soa::Join<aod::MultMCExtras, aod::MultHepMCHIs> const&)
   {
     genericProcessCollision(collision);
   }
 
-  void processCollisionsWithCentrality(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal, aod::Mults2BC, aod::FV0AOuterMults>::iterator const& collision, aod::MultBCs const&)
+  void processCollisionsWithCentrality(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal, aod::Mults2BC, aod::FITExtraMults>::iterator const& collision, aod::MultBCs const&)
   {
     genericProcessCollision(collision);
   }
 
-  void processCollisionsWithCentralityWithNeighbours(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal, aod::MultNeighs, aod::FV0AOuterMults>::iterator const& collision)
+  void processCollisionsWithCentralityWithNeighbours(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal, aod::MultNeighs, aod::FITExtraMults>::iterator const& collision)
   {
     genericProcessCollision(collision);
   }