Merge branch 'AliceO2Group:master' into master

Author: arvindkhuntia

PWGCF/MultiparticleCorrelations/Tasks/multiparticleCorrelationsMei.cxx

@@ -43,6 +43,7 @@
 
 #include <Rtypes.h>
 
+#include <array>
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
@@ -187,37 +188,37 @@ struct MultiparticleCorrelationsMei // this name is used in lower-case format to
   // *) Define and initialize all data members to be called in the main process* functions:
   // **) Task configuration:
   struct TaskConfiguration {
-    bool fProcess[eProcess_N] = {false}; // Set what to process. See enum EProcess for full description. Set via implicit variables within a PROCESS_SWITCH clause.
-    bool fDryRun = false;                // book all histos and run without filling and calculating anything
-  } tc;                                  // you have to prepend "tc." for all objects name in this group later in the code
+    std::array<bool, eProcess_N> fProcess{false}; // Set what to process. See enum EProcess for full description. Set via implicit variables within a PROCESS_SWITCH clause.
+    bool fDryRun = false;                         // book all histos and run without filling and calculating anything
+  } tc;                                           // you have to prepend "tc." for all objects name in this group later in the code
 
   // **) Particle histograms:
   struct ParticleHistograms {
-    TList* fParticleHistogramsList = NULL; //!<! list to hold all control particle histograms
-    TH1F* fParticleHistograms[eParticleHistograms_N][2][2] = {{{NULL}}};
+    TList* fParticleHistogramsList = nullptr; //!<! list to hold all control particle histograms
+    std::array<std::array<std::array<TH1F*, 2>, 2>, eParticleHistograms_N> fParticleHistograms{};
   } pc; // you have to prepend "pc." for all objects name in this group later in the code
 
   // *) Event histograms:
   struct EventHistograms {
-    TList* fEventHistogramsList = NULL;                            //!<! list to hold all event-level histograms
-    TH1F* fEventHistograms[eEventHistograms_N][2][2] = {{{NULL}}}; //! [ type - see enum EEventHistograms ][reco,sim][before, after event cuts]
-  } ec;                                                            // prepend "ec." for event counters
+    TList* fEventHistogramsList = nullptr;                                                  //!<! list to hold all event-level histograms
+    std::array<std::array<std::array<TH1F*, 2>, 2>, eEventHistograms_N> fEventHistograms{}; //! [ type - see enum EEventHistograms ][reco,sim][before, after event cuts]
+  } ec;                                                                                     // prepend "ec." for event counters
 
   // *) External histograms:
   struct ExternalHistograms {
-    TList* fExternalHistogramsList = NULL;
-    TH1D* fhistWeights = NULL;
+    TList* fExternalHistogramsList = nullptr;
+    TH1D* fhistWeights = nullptr;
   } ex;
 
   struct Observables {
-    TList* fObservablesList = NULL;
-    TProfile* fProfTwo[2][2] = {{NULL}}; //! [reco,sim][before, after event cuts]
+    TList* fObservablesList = nullptr;
+    std::array<std::array<TProfile*, 2>, 2> fProfTwo{}; //! [reco,sim][before, after event cuts]
   } obs;
 
   // *) Quality assurance histograms:
   struct QualityAssurance {
-    TList* fQualityAssuranceList = NULL; //!<! list to hold all qualityAssurance histograms
-    TH2F* fHistCentralityRecSim = NULL;
+    TList* fQualityAssuranceList = nullptr; //!<! list to hold all qualityAssurance histograms
+    TH2F* fHistCentralityRecSim = nullptr;
   } qa; // prepend "qa." for qa histograms
 
   // *) functions
@@ -552,6 +553,12 @@ struct MultiparticleCorrelationsMei // this name is used in lower-case format to
         break; // thisCent is already FT0C
     }
 
+    LOGF(info,
+         "centFT0C=%.6f  centFT0M=%.6f  centFV0A=%.6f",
+         collision.centFT0C(),
+         collision.centFT0M(),
+         collision.centFV0A());
+
     auto thisRefMult = collision.multTPC(); // use auto to determine the type
     switch (multiplicityTables) {
       case eMultTPC:
@@ -605,7 +612,7 @@ struct MultiparticleCorrelationsMei // this name is used in lower-case format to
         if (rm == eMC) {
           auto thisMCCollision = collision.mcCollision(); // corresponding MC truth simulated particle
           int multiplicitySim = static_cast<int>(tracks.size());
-          auto impactParameter = thisMCCollision.impactParameter() * 1e15;
+          auto impactParameter = thisMCCollision.impactParameter();
           LOGF(info,
                "Reco collision = %d, MC collision = %d, b = %f",
                collision.globalIndex(),

PWGJE/Tasks/jetDsSpecSubs.cxx

@@ -52,10 +52,11 @@ consteval float getValFromBin(int bin)
 enum BinExpColCntr { AllCollisions = 1,
                      Sel8ZCut = 2 };
 
-enum BinMCColCntr { AllMCCollisions = 1,
-                    SelectedMCCollisions = 2,
-                    AssociatedRecoCollisions = 3,
-                    SelectedAssociatedRecoCollisions = 4
+enum BinMCColCntr {
+  AllMCCollisions = 1,
+  EventSelection = 2,
+  VertexZCut = 3,
+  HasMCPDsJet = 4
 };
 
 enum BinMCJetCntr {
@@ -318,13 +319,20 @@ struct JetDsSpecSubs {
     // Detector-level sparse histograms
     registry.add(
       "hSparse_ds_mcd1",
-      ";m_{D_{S}}^{rec};#it{p}_{T,D_{S}}^{det};#it{p}_{T,jet}^{det};z^{D_{S},jet}_{||,det};Origin(D_{S});Matching status",
+      ";m_{D_{S}}^{rec};"
+      "#it{p}_{T,D_{S}}^{det};"
+      "#it{p}_{T,jet}^{det};"
+      "z^{D_{S},jet}_{||,det};"
+      "Origin(D_{S});"
+      "flagMcMatchRec;"
+      "Jet matching status",
       {HistType::kTHnSparseF,
        {{350, 1.6, 2.3},
         {100, 0., 50.},
         {100, 0., 100.},
         {200, 0., 1.},
         {3, -0.5, 2.5},
+        {21, -10.5, 10.5},
         {2, -0.5, 1.5}}});
 
     registry.add(
@@ -356,13 +364,20 @@ struct JetDsSpecSubs {
     // Particle-level sparse with origin and matching status
     registry.add(
       "hSparse_ds_mcp",
-      ";#it{p}_{T,D_{S}}^{part};#it{p}_{T,jet}^{part};z^{D_{S},jet}_{||,part};#DeltaR_{D_{S},jet}^{part};Origin(D_{S});Matching status",
+      ";#it{p}_{T,D_{S}}^{part};"
+      "#it{p}_{T,jet}^{part};"
+      "z^{D_{S},jet}_{||,part};"
+      "#DeltaR_{D_{S},jet}^{part};"
+      "Origin(D_{S});"
+      "flagMcMatchGen;"
+      "Jet matching status",
       {HistType::kTHnSparseF,
        {{100, 0., 50.},
         {100, 0., 100.},
         {200, 0., 1.},
         {200, 0., 1.},
         {3, -0.5, 2.5},
+        {21, -10.5, 10.5},
         {2, -0.5, 1.5}}});
 
     // Matched detector-level Ds-tagged jets
@@ -418,10 +433,10 @@ struct JetDsSpecSubs {
 
     // Counter labels
     auto mcCollisionCounter = registry.get<TH1>(HIST("hMCColCounter"));
-    mcCollisionCounter->GetXaxis()->SetBinLabel(BinMCColCntr::AllMCCollisions, "All MC coll.");
-    mcCollisionCounter->GetXaxis()->SetBinLabel(BinMCColCntr::SelectedMCCollisions, "Selected MC coll.");
-    mcCollisionCounter->GetXaxis()->SetBinLabel(BinMCColCntr::AssociatedRecoCollisions, "MC-associated reco coll.");
-    mcCollisionCounter->GetXaxis()->SetBinLabel(BinMCColCntr::SelectedAssociatedRecoCollisions, "Selected MC-associated reco coll.");
+    mcCollisionCounter->GetXaxis()->SetBinLabel(BinMCColCntr::AllMCCollisions, "All MC collisions");
+    mcCollisionCounter->GetXaxis()->SetBinLabel(BinMCColCntr::EventSelection, "Event selection");
+    mcCollisionCounter->GetXaxis()->SetBinLabel(BinMCColCntr::VertexZCut, "|z_{vtx}| < cut");
+    mcCollisionCounter->GetXaxis()->SetBinLabel(BinMCColCntr::HasMCPDsJet, "Has MCP D_{s}-jet");
 
     auto jetCounter = registry.get<TH1>(HIST("hMCJetCounter"));
     jetCounter->GetXaxis()->SetBinLabel(BinMCJetCntr::MCPJets, "MCP Ds-jets");
@@ -432,12 +447,12 @@ struct JetDsSpecSubs {
 
     // Matching-status labels
     auto hSparseMCD = registry.get<THnSparse>(HIST("hSparse_ds_mcd1"));
-    hSparseMCD->GetAxis(5)->SetBinLabel(1, "Unmatched");
-    hSparseMCD->GetAxis(5)->SetBinLabel(2, "Matched");
+    hSparseMCD->GetAxis(6)->SetBinLabel(1, "Unmatched");
+    hSparseMCD->GetAxis(6)->SetBinLabel(2, "Matched");
 
     auto hSparseMCP = registry.get<THnSparse>(HIST("hSparse_ds_mcp"));
-    hSparseMCP->GetAxis(5)->SetBinLabel(1, "Unmatched");
-    hSparseMCP->GetAxis(5)->SetBinLabel(2, "Matched");
+    hSparseMCP->GetAxis(6)->SetBinLabel(1, "Unmatched");
+    hSparseMCP->GetAxis(6)->SetBinLabel(2, "Matched");
   }
 
   void addMCPOnTheFlyHistograms()
@@ -755,17 +770,27 @@ struct JetDsSpecSubs {
       // All MC collisions
       registry.fill(HIST("hMCColCounter"), getValFromBin(BinMCColCntr::AllMCCollisions));
 
-      // MC collision selection
-      if (!jetderiveddatautilities::selectCollision(mccollision, eventSelectionBits) ||
-          !(std::abs(mccollision.posZ()) < vertexZCut)) {
+      // Event selection
+      if (!jetderiveddatautilities::selectCollision(mccollision, eventSelectionBits)) {
         continue;
       }
-      // Selected MC collisions
-      registry.fill(HIST("hMCColCounter"), getValFromBin(BinMCColCntr::SelectedMCCollisions));
+
+      registry.fill(HIST("hMCColCounter"), getValFromBin(BinMCColCntr::EventSelection));
+
+      // Vertex-z selection
+      if (std::abs(mccollision.posZ()) >= vertexZCut) {
+        continue;
+      }
+
+      registry.fill(HIST("hMCColCounter"), getValFromBin(BinMCColCntr::VertexZCut));
 
       // Particle-level jets belonging to the current MC collision
       const auto mcpJetsPerMCCollision = mcpjets.sliceBy(MCPJetsPerMCCollisionPreslice, mccollision.globalIndex());
 
+      if (mcpJetsPerMCCollision.size() > 0) {
+        registry.fill(HIST("hMCColCounter"), getValFromBin(BinMCColCntr::HasMCPDsJet));
+      }
+
       // Particle-level Ds-tagged jets
       for (const auto& mcpjet : mcpJetsPerMCCollision) {
 
@@ -806,6 +831,7 @@ struct JetDsSpecSubs {
           zParallelMCP,
           deltaRMCP,
           originMCP,
+          flagMcMatchGen,
           static_cast<float>(isMatchedMCP));
 
         // Store all particle-level Ds-tagged jets
@@ -984,14 +1010,15 @@ struct JetDsSpecSubs {
       registry.fill(HIST("h_ds_phi_mcd"), mcdcand.phi());
       registry.fill(HIST("h_ds_mass_mcd"), mcdcand.m());
 
-      // Detector-level sparse: mass, pT Ds, pT jet, z_parallel, origin, matching status
+      // Detector-level sparse: mass, pT Ds, pT jet, z_parallel, origin, flagMcMatchRec, matching status
       registry.fill(
         HIST("hSparse_ds_mcd1"),
         mcdcand.m(),
         mcdcand.pt(),
         mcdjet.pt(),
         zParallelMCD,
         originMCD,
+        flagMcMatchRec,
         static_cast<float>(isMatchedMCD));
 
       // Detector-level sparse: pT Ds, pT jet, DeltaR

PWGLF/Tasks/Strangeness/hStrangeCorrelation.cxx

@@ -125,6 +125,7 @@ struct HStrangeCorrelation {
     Configurable<bool> doCorrelationOmegaPlus{"doCorrelationOmegaPlus", false, "do OmegaPlus correlation"};
     Configurable<bool> doCorrelationPion{"doCorrelationPion", false, "do Pion correlation"};
     Configurable<bool> doGenEventSelection{"doGenEventSelection", true, "use event selections when performing closure test for the gen events"};
+    Configurable<bool> doClosureTestPureMC{"doClosureTestPureMC", false, "fill regular ClosureTest histograms without event or reconstructed-trigger selection, using MC vertex z and centrality 0.05; keep truth-particle selections"};
     Configurable<bool> selectINELgtZERO{"selectINELgtZERO", true, "select INEL>0 events"};
     Configurable<bool> selectINELgtONE{"selectINELgtONE", false, "select INEL>1 events (at least 2 charged particles in |eta| < 1)"};
     Configurable<float> zVertexCut{"zVertexCut", 10, "Cut on PV position"};
@@ -6181,71 +6182,82 @@ struct HStrangeCorrelation {
 
     float bestCollisionCentpercentile = -1;
     float bestCollisionVtxZ = 0.0f;
-    bool bestCollisionSel8 = false;
-    bool bestCollisionINELgtZERO = false;
-    bool bestCollisionINELgtONE = false;
-    bool bestCollisionNoSameBunchPileup = false;
-    bool bestCollisionGoodTriggerTVX = false;
-    bool bestCollisionGoodZvtxFT0vsPV = false;
-    bool isCollisionSelect = false;
-    int biggestNContribs = -1;
-    uint32_t bestCollisionTriggerPresenceMap = 0;
+    // Pure MC defines an inclusive generated-event reference, independent of
+    // reconstructed collisions and triggerPresenceMap. Particle/pair selections
+    // below still define the observable. PairLossK0 diagnostics above retain
+    // their own event selection.
+    if (masterConfigurations.doClosureTestPureMC) {
+      bestCollisionCentpercentile = 0.05f;
+      bestCollisionVtxZ = mcCollision.posZ();
+    } else {
+      bool bestCollisionSel8 = false;
+      bool bestCollisionINELgtZERO = false;
+      bool bestCollisionINELgtONE = false;
+      bool bestCollisionNoSameBunchPileup = false;
+      bool bestCollisionGoodTriggerTVX = false;
+      bool bestCollisionGoodZvtxFT0vsPV = false;
+      bool isCollisionSelect = false;
+      int biggestNContribs = -1;
+      uint32_t bestCollisionTriggerPresenceMap = 0;
 
-    for (auto const& recCollision : recCollisions) {
-      if (biggestNContribs < recCollision.numContrib()) {
-        biggestNContribs = recCollision.numContrib();
-        bestCollisionCentpercentile = masterConfigurations.doPPAnalysis ? recCollision.centFT0M() : recCollision.centFT0C();
-        if (masterConfigurations.applyNewMCSelection) {
-          isCollisionSelect = ((masterConfigurations.doPPAnalysis && isCollisionSelected(recCollision)) || (!masterConfigurations.doPPAnalysis && isCollisionSelectedPbPb(recCollision, false)));
-        } else {
-          bestCollisionSel8 = recCollision.sel8();
+      for (auto const& recCollision : recCollisions) {
+        if (biggestNContribs < recCollision.numContrib()) {
+          biggestNContribs = recCollision.numContrib();
+          bestCollisionCentpercentile = masterConfigurations.doPPAnalysis ? recCollision.centFT0M() : recCollision.centFT0C();
+          // Both branches fill the generated-level THns with this vertex position, so it
+          // is taken from the best collision regardless of which event selection is used.
           bestCollisionVtxZ = recCollision.posZ();
-          bestCollisionINELgtZERO = recCollision.isInelGt0();
-          bestCollisionINELgtONE = recCollision.isInelGt1();
-          bestCollisionNoSameBunchPileup = recCollision.selection_bit(o2::aod::evsel::kNoSameBunchPileup);
-          bestCollisionGoodTriggerTVX = recCollision.selection_bit(aod::evsel::kIsTriggerTVX);
-          bestCollisionGoodZvtxFT0vsPV = recCollision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV);
-        }
-        if (triggerPresenceMap.size() > 0) {
-          bestCollisionTriggerPresenceMap = triggerPresenceMap[recCollision.globalIndex()];
+          if (masterConfigurations.applyNewMCSelection) {
+            isCollisionSelect = ((masterConfigurations.doPPAnalysis && isCollisionSelected(recCollision)) || (!masterConfigurations.doPPAnalysis && isCollisionSelectedPbPb(recCollision, false)));
+          } else {
+            bestCollisionSel8 = recCollision.sel8();
+            bestCollisionINELgtZERO = recCollision.isInelGt0();
+            bestCollisionINELgtONE = recCollision.isInelGt1();
+            bestCollisionNoSameBunchPileup = recCollision.selection_bit(o2::aod::evsel::kNoSameBunchPileup);
+            bestCollisionGoodTriggerTVX = recCollision.selection_bit(aod::evsel::kIsTriggerTVX);
+            bestCollisionGoodZvtxFT0vsPV = recCollision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV);
+          }
+          if (triggerPresenceMap.size() > 0) {
+            bestCollisionTriggerPresenceMap = triggerPresenceMap[recCollision.globalIndex()];
+          }
         }
       }
-    }
-    // ________________________________________________
-    // skip if desired trigger not found
-    if (triggerPresenceMap.size() > 0 && !TESTBIT(bestCollisionTriggerPresenceMap, triggerBinToSelect)) {
-      return;
-    }
-
-    if (masterConfigurations.applyNewMCSelection) {
-      if (!isCollisionSelect) {
+      // ________________________________________________
+      // skip if desired trigger not found
+      if (triggerPresenceMap.size() > 0 && !TESTBIT(bestCollisionTriggerPresenceMap, triggerBinToSelect)) {
         return;
       }
-    } else {
-      if (masterConfigurations.doGenEventSelection) {
-        if (!bestCollisionSel8) {
-          return;
-        }
-        if (std::abs(bestCollisionVtxZ) > masterConfigurations.zVertexCut) {
-          return;
-        }
-        if (!bestCollisionINELgtZERO) {
-          return;
-        }
-        if (masterConfigurations.selectINELgtONE && !bestCollisionINELgtONE) {
-          return;
-        }
-        if (masterConfigurations.rejectSameBunchPileup && !bestCollisionNoSameBunchPileup) {
-          return;
-        }
-        if (masterConfigurations.requireGoodTriggerTVX && !bestCollisionGoodTriggerTVX) {
-          return;
-        }
-        if (masterConfigurations.requireGoodZvtxFT0vsPV && !bestCollisionGoodZvtxFT0vsPV) {
+
+      if (masterConfigurations.applyNewMCSelection) {
+        if (!isCollisionSelect) {
           return;
         }
-        if (bestCollisionCentpercentile > axisRanges[5][1] || bestCollisionCentpercentile < axisRanges[5][0]) {
-          return;
+      } else {
+        if (masterConfigurations.doGenEventSelection) {
+          if (!bestCollisionSel8) {
+            return;
+          }
+          if (std::abs(bestCollisionVtxZ) > masterConfigurations.zVertexCut) {
+            return;
+          }
+          if (!bestCollisionINELgtZERO) {
+            return;
+          }
+          if (masterConfigurations.selectINELgtONE && !bestCollisionINELgtONE) {
+            return;
+          }
+          if (masterConfigurations.rejectSameBunchPileup && !bestCollisionNoSameBunchPileup) {
+            return;
+          }
+          if (masterConfigurations.requireGoodTriggerTVX && !bestCollisionGoodTriggerTVX) {
+            return;
+          }
+          if (masterConfigurations.requireGoodZvtxFT0vsPV && !bestCollisionGoodZvtxFT0vsPV) {
+            return;
+          }
+          if (bestCollisionCentpercentile > axisRanges[5][1] || bestCollisionCentpercentile < axisRanges[5][0]) {
+            return;
+          }
         }
       }
     }