From 39ce9d15bfbd2592e1680ee09d3dd96a9442eda6 Mon Sep 17 00:00:00 2001 From: Sara Pucillo Date: Thu, 27 Aug 2026 11:35:29 +0200 Subject: [PATCH 1/3] Add RCTSelectionFlags --- .../cascadeAnalysisLightIonsDerivedData.cxx | 47 +++++++++++++++---- 1 file changed, 39 insertions(+), 8 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index 5dba2604ec0..07d5e47f735 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -19,6 +19,7 @@ #include "PWGLF/DataModel/LFStrangenessTables.h" #include "Common/CCDB/EventSelectionParams.h" +#include "Common/CCDB/RCTSelectionFlags.h" #include "Common/Core/RecoDecay.h" #include @@ -48,6 +49,8 @@ using namespace o2::framework::expressions; using namespace o2::constants::math; using namespace o2::constants::physics; +using namespace o2::aod::rctsel; + using SelCollisions = soa::Join; using SimCollisions = soa::Join; using CascadeCandidates = soa::Join; @@ -137,6 +140,15 @@ struct CascadeAnalysisLightIonsDerivedData { ConfigurableAxis axisNch{"axisNch", {500, 0.0f, +5000.0f}, "Number of charged particles"}; ConfigurableAxis axisMult{"axisMult", {500, 0.0f, +100000.0f}, "Multiplicity"}; + struct : ConfigurableGroup { + std::string prefix = "rctConfigurations"; // JSON group name + Configurable cfgRCTLabel{"cfgRCTLabel", "", "Which detector condition requirements? (CBT, CBT_hadronPID, CBT_electronPID, CBT_calo, CBT_muon, CBT_muon_glo)"}; + Configurable cfgCheckZDC{"cfgCheckZDC", false, "Include ZDC flags in the bit selection (for Pb-Pb only)"}; + Configurable cfgTreatLimitedAcceptanceAsBad{"cfgTreatLimitedAcceptanceAsBad", false, "reject all events where the detectors relevant for the specified Runlist are flagged as LimitedAcceptance"}; + } rctConfigurations; + + RCTFlagsChecker rctFlagsChecker{rctConfigurations.cfgRCTLabel.value}; + // Centrality estimator Configurable centralityEstimator{"centralityEstimator", 0, "0 = FT0C, 1 = FTOM, 2 = FV0A, 3 = NGlobal"}; @@ -172,6 +184,9 @@ struct CascadeAnalysisLightIonsDerivedData { const AxisSpec nsigmaTOFAxis{200, -10, 10, "n#sigma_{TOF}"}; const AxisSpec nsigmaTPCAxis{200, -10, 10, "n#sigma_{TPC}"}; + // Initialise the RCTFlagsChecker + rctFlagsChecker.init(rctConfigurations.cfgRCTLabel.value, rctConfigurations.cfgCheckZDC, rctConfigurations.cfgTreatLimitedAcceptanceAsBad); + // Histograms for data if (doprocessData) { registryData.add("number_of_events_data", "number of events in data", HistType::kTH1D, {{20, -0.5f, +19.5f}}); @@ -185,7 +200,8 @@ struct CascadeAnalysisLightIonsDerivedData { registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(8, "kIsVertexTOFmatched"); registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(9, "kIsVertexTRDmatched"); registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(10, "kNoSameBunchPileup"); - registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(11, "kINELgr0"); + registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(11, "RCT flags"); + registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(12, "kINELgr0"); registryData.add("number_of_events_data_vs_centrality", "number of events in data vs centrality", HistType::kTH2D, {{20, -0.5f, +19.5f}, {101, 0.0f, 101.0f}}); registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(1, "All collisions"); @@ -198,7 +214,8 @@ struct CascadeAnalysisLightIonsDerivedData { registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(8, "kIsVertexTOFmatched"); registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(9, "kIsVertexTRDmatched"); registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(10, "kNoSameBunchPileup"); - registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(11, "kINELgr0"); + registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(11, "RCT flags"); + registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(12, "kINELgr0"); registryData.get(HIST("number_of_events_data_vs_centrality"))->GetYaxis()->SetTitle("Centrality (%)"); // QC Histograms @@ -248,7 +265,8 @@ struct CascadeAnalysisLightIonsDerivedData { registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(8, "kIsVertexTOFmatched"); registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(9, "kIsVertexTRDmatched"); registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(10, "kNoSameBunchPileup"); - registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(11, "kINELgr0"); + registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(11, "RCT flags"); + registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(12, "kINELgr0"); registryMC.add("number_of_events_mc_rec_vs_centrality", "number of events in mc_rec vs centrality", HistType::kTH2D, {{20, -0.5f, +19.5f}, {101, 0.0f, 101.0f}}); registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(1, "All collisions"); @@ -261,7 +279,8 @@ struct CascadeAnalysisLightIonsDerivedData { registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(8, "kIsVertexTOFmatched"); registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(9, "kIsVertexTRDmatched"); registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(10, "kNoSameBunchPileup"); - registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(11, "kINELgr0"); + registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(11, "RCT flags"); + registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(12, "kINELgr0"); registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetYaxis()->SetTitle("Centrality (%)"); // QC Histograms @@ -836,11 +855,17 @@ struct CascadeAnalysisLightIonsDerivedData { registryData.fill(HIST("number_of_events_data"), 9 /* Not at same bunch pile-up */); registryData.fill(HIST("number_of_events_data_vs_centrality"), 9, centrality); + if (!rctConfigurations.cfgRCTLabel.value.empty() && !rctFlagsChecker(collision)) { + return false; + } + registryData.fill(HIST("number_of_events_data"), 10 /* Pass CBT condition */); + registryData.fill(HIST("number_of_events_data_vs_centrality"), 10, centrality); + if (requireInel0 && collision.multNTracksPVeta1() < 1) { return; } - registryData.fill(HIST("number_of_events_data"), 10 /* INEL > 0 */); - registryData.fill(HIST("number_of_events_data_vs_centrality"), 10, centrality); + registryData.fill(HIST("number_of_events_data"), 11 /* INEL > 0 */); + registryData.fill(HIST("number_of_events_data_vs_centrality"), 11, centrality); // Store the Zvtx registryQC.fill(HIST("hVertexZdata"), collision.posZ()); @@ -985,11 +1010,17 @@ struct CascadeAnalysisLightIonsDerivedData { registryMC.fill(HIST("number_of_events_mc_rec"), 9 /* Not at same bunch pile-up */); registryMC.fill(HIST("number_of_events_mc_rec_vs_centrality"), 9, centralityMcRec); + if (!rctConfigurations.cfgRCTLabel.value.empty() && !rctFlagsChecker(collision)) { + return false; + } + registryMC.fill(HIST("number_of_events_mc_rec"), 10 /* Pass CBT condition */); + registryMC.fill(HIST("number_of_events_mc_rec_vs_centrality"), 10, centralityMcRec); + if (requireInel0 && RecCol.multNTracksPVeta1() < 1) { return; } - registryMC.fill(HIST("number_of_events_mc_rec"), 10 /* INEL > 0 */); - registryMC.fill(HIST("number_of_events_mc_rec_vs_centrality"), 10, centralityMcRec); + registryMC.fill(HIST("number_of_events_mc_rec"), 11 /* INEL > 0 */); + registryMC.fill(HIST("number_of_events_mc_rec_vs_centrality"), 11, centralityMcRec); // Store the Zvtx registryQC.fill(HIST("hVertexZRec"), RecCol.posZ()); From 0699fd215d047351982926ac38ed008379c14339 Mon Sep 17 00:00:00 2001 From: Sara Pucillo Date: Thu, 27 Aug 2026 12:06:45 +0200 Subject: [PATCH 2/3] Fix RCT selection build errors --- .../cascadeAnalysisLightIonsDerivedData.cxx | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index 07d5e47f735..eeab5969358 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -75,7 +75,7 @@ struct CascadeAnalysisLightIonsDerivedData { o2::ccdb::CcdbApi ccdbApi; Service ccdb; - int mRunNumber; + int mRunNumber{-1}; // Define histogram registries HistogramRegistry registryData{"registryData", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; @@ -856,7 +856,7 @@ struct CascadeAnalysisLightIonsDerivedData { registryData.fill(HIST("number_of_events_data_vs_centrality"), 9, centrality); if (!rctConfigurations.cfgRCTLabel.value.empty() && !rctFlagsChecker(collision)) { - return false; + return; } registryData.fill(HIST("number_of_events_data"), 10 /* Pass CBT condition */); registryData.fill(HIST("number_of_events_data_vs_centrality"), 10, centrality); @@ -1010,8 +1010,8 @@ struct CascadeAnalysisLightIonsDerivedData { registryMC.fill(HIST("number_of_events_mc_rec"), 9 /* Not at same bunch pile-up */); registryMC.fill(HIST("number_of_events_mc_rec_vs_centrality"), 9, centralityMcRec); - if (!rctConfigurations.cfgRCTLabel.value.empty() && !rctFlagsChecker(collision)) { - return false; + if (!rctConfigurations.cfgRCTLabel.value.empty() && !rctFlagsChecker(RecCol)) { + return; } registryMC.fill(HIST("number_of_events_mc_rec"), 10 /* Pass CBT condition */); registryMC.fill(HIST("number_of_events_mc_rec_vs_centrality"), 10, centralityMcRec); @@ -1092,7 +1092,7 @@ struct CascadeAnalysisLightIonsDerivedData { bool isTrueMCCascadeDecay = false; bool isCorrectLambdaDecay = false; - if (isPhysPrim && (isXiMC || isOmegaMC)) + if (isXiMC || isOmegaMC) isTrueMCCascade = true; if (isTrueMCCascade && ((casc.sign() > 0 && cascMC.pdgCodePositive() == PDG_t::kPiPlus && cascMC.pdgCodeNegative() == PDG_t::kProtonBar) || (casc.sign() < 0 && cascMC.pdgCodePositive() == PDG_t::kProton && cascMC.pdgCodeNegative() == PDG_t::kPiMinus))) isCorrectLambdaDecay = true; From 11aaa33494cef00f23be8ddef5488793d3468e3c Mon Sep 17 00:00:00 2001 From: spucillo <93769017+spucillo@users.noreply.github.com> Date: Fri, 9 Oct 2026 15:44:05 +0200 Subject: [PATCH 3/3] Update MC centrality --- .../cascadeAnalysisLightIonsDerivedData.cxx | 193 ++++++++++++++---- 1 file changed, 150 insertions(+), 43 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index 33d3c9c51b0..bde34b181eb 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -17,6 +17,7 @@ #include "PWGLF/DataModel/LFStrangenessPIDTables.h" #include "PWGLF/DataModel/LFStrangenessTables.h" +#include "PWGLF/DataModel/mcCentrality.h" #include "Common/CCDB/EventSelectionParams.h" #include "Common/CCDB/RCTSelectionFlags.h" @@ -56,7 +57,7 @@ using SimCollisions = soa::Join; using CascadeMCCandidates = soa::Join; using DaughterTracks = soa::Join; -using CollisionMCTrueTable = soa::Join; +using CollisionMCTrueTable = soa::Join; using CascadeMCCores = soa::Join; struct CascadeAnalysisLightIonsDerivedData { @@ -151,6 +152,7 @@ struct CascadeAnalysisLightIonsDerivedData { // Centrality estimator Configurable centralityEstimator{"centralityEstimator", 0, "0 = FT0C, 1 = FTOM, 2 = FV0A, 3 = NGlobal"}; + Configurable useMcCentrality{"useMcCentrality", false, "Use MC centrality?"}; // List of estimators enum Option { kFT0C, @@ -299,6 +301,8 @@ struct CascadeAnalysisLightIonsDerivedData { // Multiplicity Histograms registryMC.add("hCentEstimator_truerec", "hCentEstimator_truerec", HistType::kTH1D, {{101, 0.0f, 101.0f}}); registryMC.add("hCentralityVsNch_truerec", "hCentralityVsNch_truerec", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisNch}); + if (useMcCentrality) + registryMC.add("hEventVsGenCentrality_truerec", "hEventVsGenCentrality_truerec", HistType::kTH2D, {{101, 0.0f, 101.0f}, {101, 0.0f, 101.0f}}); if (centralityEstimator == Option::kNGlobal) registryMC.add("hCentralityVsMultiplicity_truerec", "hCentralityVsMultiplicity_truerec", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisNch}); else @@ -322,27 +326,46 @@ struct CascadeAnalysisLightIonsDerivedData { // QC Histograms registryQC.add("hVertexZGen", "hVertexZGen", HistType::kTH1D, {{vertexZAxis}}); // Histograms for xi (mc) - registryMC.add("h2dGenXiMinusVsMultMC_RecoedEvt", "h2dGenXiMinusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); - registryMC.add("h2dGenXiPlusVsMultMC_RecoedEvt", "h2dGenXiPlusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); - registryMC.add("h2dGenXiMinusVsMultMC", "h2dGenXiMinusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); - registryMC.add("h2dGenXiPlusVsMultMC", "h2dGenXiPlusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); registryMC.add("h2dGenXiMinus", "h2dGenXiMinus", HistType::kTH2D, {centAxis, ptAxis}); registryMC.add("h2dGenXiPlus", "h2dGenXiPlus", HistType::kTH2D, {centAxis, ptAxis}); // Histograms for omega (mc) - registryMC.add("h2dGenOmegaMinusVsMultMC_RecoedEvt", "h2dGenOmegaMinusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); - registryMC.add("h2dGenOmegaPlusVsMultMC_RecoedEvt", "h2dGenOmegaPlusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); - registryMC.add("h2dGenOmegaMinusVsMultMC", "h2dGenOmegaMinusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); - registryMC.add("h2dGenOmegaPlusVsMultMC", "h2dGenOmegaPlusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); registryMC.add("h2dGenOmegaMinus", "h2dGenOmegaMinus", HistType::kTH2D, {centAxis, ptAxis}); registryMC.add("h2dGenOmegaPlus", "h2dGenOmegaPlus", HistType::kTH2D, {centAxis, ptAxis}); - // Histograms for event loss/splitting - registryMC.add("hGenEvents", "hGenEvents", HistType::kTH2D, {{axisNch}, {4, -0.5f, +3.5f}}); - registryMC.get(HIST("hGenEvents"))->GetYaxis()->SetBinLabel(1, "All gen. events"); - registryMC.get(HIST("hGenEvents"))->GetYaxis()->SetBinLabel(2, "All gen. events in INEL > 0"); - registryMC.get(HIST("hGenEvents"))->GetYaxis()->SetBinLabel(3, "Gen. with at least 1 rec. events"); - registryMC.get(HIST("hGenEvents"))->GetYaxis()->SetBinLabel(4, "Gen. with at least 1 rec. events in INEL > 0"); + if (useMcCentrality) { + registryMC.add("h2dGenXiMinusVsMcCentrality_RecoedEvt", "h2dGenXiMinusVsMcCentrality_RecoedEvt", HistType::kTH2D, {axisCentEstimator, ptAxis}); + registryMC.add("h2dGenXiPlusVsMcCentrality_RecoedEvt", "h2dGenXiPlusVsMcCentrality_RecoedEvt", HistType::kTH2D, {axisCentEstimator, ptAxis}); + registryMC.add("h2dGenXiMinusVsMcCentrality", "h2dGenXiMinusVsMcCentrality", HistType::kTH2D, {axisCentEstimator, ptAxis}); + registryMC.add("h2dGenXiPlusVsMcCentrality", "h2dGenXiPlusVsMcCentrality", HistType::kTH2D, {axisCentEstimator, ptAxis}); + + registryMC.add("h2dGenOmegaMinusVsMcCentrality_RecoedEvt", "h2dGenOmegaMinusVsMcCentrality_RecoedEvt", HistType::kTH2D, {axisCentEstimator, ptAxis}); + registryMC.add("h2dGenOmegaPlusVsMcCentrality_RecoedEvt", "h2dGenOmegaPlusVsMcCentrality_RecoedEvt", HistType::kTH2D, {axisCentEstimator, ptAxis}); + registryMC.add("h2dGenOmegaMinusVsMcCentrality", "h2dGenOmegaMinusVsMcCentrality", HistType::kTH2D, {axisCentEstimator, ptAxis}); + registryMC.add("h2dGenOmegaPlusVsMcCentrality", "h2dGenOmegaPlusVsMcCentrality", HistType::kTH2D, {axisCentEstimator, ptAxis}); + + registryMC.add("hGenEventsVsMcCentrality", "hGenEventsVsMcCentrality", HistType::kTH2D, {axisCentEstimator, {4, -0.5f, +3.5f}}); + registryMC.get(HIST("hGenEventsVsMcCentrality"))->GetYaxis()->SetBinLabel(1, "All gen. events"); + registryMC.get(HIST("hGenEventsVsMcCentrality"))->GetYaxis()->SetBinLabel(2, "All gen. events in INEL > 0"); + registryMC.get(HIST("hGenEventsVsMcCentrality"))->GetYaxis()->SetBinLabel(3, "Gen. with at least 1 rec. events"); + registryMC.get(HIST("hGenEventsVsMcCentrality"))->GetYaxis()->SetBinLabel(4, "Gen. with at least 1 rec. events in INEL > 0"); + } else { + registryMC.add("h2dGenXiMinusVsMultMC_RecoedEvt", "h2dGenXiMinusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); + registryMC.add("h2dGenXiPlusVsMultMC_RecoedEvt", "h2dGenXiPlusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); + registryMC.add("h2dGenXiMinusVsMultMC", "h2dGenXiMinusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); + registryMC.add("h2dGenXiPlusVsMultMC", "h2dGenXiPlusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); + + registryMC.add("h2dGenOmegaMinusVsMultMC_RecoedEvt", "h2dGenOmegaMinusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); + registryMC.add("h2dGenOmegaPlusVsMultMC_RecoedEvt", "h2dGenOmegaPlusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); + registryMC.add("h2dGenOmegaMinusVsMultMC", "h2dGenOmegaMinusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); + registryMC.add("h2dGenOmegaPlusVsMultMC", "h2dGenOmegaPlusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); + + registryMC.add("hGenEvents", "hGenEvents", HistType::kTH2D, {axisNch, {4, -0.5f, +3.5f}}); + registryMC.get(HIST("hGenEvents"))->GetYaxis()->SetBinLabel(1, "All gen. events"); + registryMC.get(HIST("hGenEvents"))->GetYaxis()->SetBinLabel(2, "All gen. events in INEL > 0"); + registryMC.get(HIST("hGenEvents"))->GetYaxis()->SetBinLabel(3, "Gen. with at least 1 rec. events"); + registryMC.get(HIST("hGenEvents"))->GetYaxis()->SetBinLabel(4, "Gen. with at least 1 rec. events in INEL > 0"); + } registryMC.add("hGenEventCentrality", "hGenEventCentrality", kTH1D, {{101, 0.0f, 101.0f}}); registryMC.add("hCentralityVsNcoll_beforeEvSel", "hCentralityVsNcoll_beforeEvSel", HistType::kTH2D, {centAxis, {50, -0.5f, 49.5f}}); @@ -684,12 +707,29 @@ struct CascadeAnalysisLightIonsDerivedData { if (applyZVtxSelOnMCPV && std::fabs(mcCollision.posZ()) > zVtx) continue; - registryMC.fill(HIST("hGenEvents"), mcCollision.multMCNParticlesEta05(), 0 /* all gen. events*/); + float centralityMC = -1.f; + if (centralityEstimator == Option::kFT0C) + centralityMC = mcCollision.centFT0C(); + if (centralityEstimator == Option::kFT0M) + centralityMC = mcCollision.centFT0M(); + if (centralityEstimator == Option::kFV0A) + centralityMC = mcCollision.centFV0A(); + if (centralityEstimator == Option::kNGlobal) + centralityMC = mcCollision.centNGlobal(); + + if (useMcCentrality) + registryMC.fill(HIST("hGenEventsVsMcCentrality"), centralityMC, 0 /* all gen. events*/); + else + registryMC.fill(HIST("hGenEvents"), mcCollision.multMCNParticlesEta05(), 0 /* all gen. events*/); if (requireInel0OnMC && mcCollision.multMCNParticlesEta10() < 1) { continue; } - registryMC.fill(HIST("hGenEvents"), mcCollision.multMCNParticlesEta05(), 1 /* all gen. events in INEL > 0*/); + + if (useMcCentrality) + registryMC.fill(HIST("hGenEventsVsMcCentrality"), centralityMC, 1 /* all gen. events in INEL > 0*/); + else + registryMC.fill(HIST("hGenEvents"), mcCollision.multMCNParticlesEta05(), 1 /* all gen. events in INEL > 0*/); auto groupedCollisions = getGroupedCollisions(collisions, mcCollision.globalIndex()); // Check if there is at least one of the reconstructed collisions associated to this MC collision @@ -740,14 +780,18 @@ struct CascadeAnalysisLightIonsDerivedData { if (biggestNContribs < collision.multPVTotalContributors()) { biggestNContribs = collision.multPVTotalContributors(); - if (centralityEstimator == Option::kFT0C) - centralitydata = collision.centFT0C(); - if (centralityEstimator == Option::kFT0M) - centralitydata = collision.centFT0M(); - if (centralityEstimator == Option::kFV0A) - centralitydata = collision.centFV0A(); - if (centralityEstimator == Option::kNGlobal) - centralitydata = collision.centNGlobal(); + if (useMcCentrality) { + centralitydata = centralityMC; + } else { + if (centralityEstimator == Option::kFT0C) + centralitydata = collision.centFT0C(); + if (centralityEstimator == Option::kFT0M) + centralitydata = collision.centFT0M(); + if (centralityEstimator == Option::kFV0A) + centralitydata = collision.centFV0A(); + if (centralityEstimator == Option::kNGlobal) + centralitydata = collision.centNGlobal(); + } } nCollisions++; @@ -761,8 +805,13 @@ struct CascadeAnalysisLightIonsDerivedData { registryQC.fill(HIST("hVertexZGen"), mcCollision.posZ()); if (atLeastOne) { - registryMC.fill(HIST("hGenEvents"), mcCollision.multMCNParticlesEta05(), 2 /* at least 1 rec. event*/); - registryMC.fill(HIST("hGenEvents"), mcCollision.multMCNParticlesEta05(), 3 /* at least 1 rec. event in INEL > 0*/); + if (useMcCentrality) { + registryMC.fill(HIST("hGenEventsVsMcCentrality"), centralityMC, 2 /* at least 1 rec. event*/); + registryMC.fill(HIST("hGenEventsVsMcCentrality"), centralityMC, 3 /* at least 1 rec. event in INEL > 0*/); + } else { + registryMC.fill(HIST("hGenEvents"), mcCollision.multMCNParticlesEta05(), 2 /* at least 1 rec. event*/); + registryMC.fill(HIST("hGenEvents"), mcCollision.multMCNParticlesEta05(), 3 /* at least 1 rec. event in INEL > 0*/); + } registryMC.fill(HIST("hGenEventCentrality"), centralitydata); } } @@ -955,6 +1004,25 @@ struct CascadeAnalysisLightIonsDerivedData { multiplicityMcRec = RecCol.multNTracksGlobal(); } + if (useMcCentrality) { + const float recoCentrality = centralityMcRec; + centralityMcRec = -1.f; + + if (RecCol.has_straMCCollision()) { + auto mcCollision = RecCol.template straMCCollision_as(); + if (centralityEstimator == Option::kFT0C) + centralityMcRec = mcCollision.centFT0C(); + if (centralityEstimator == Option::kFT0M) + centralityMcRec = mcCollision.centFT0M(); + if (centralityEstimator == Option::kFV0A) + centralityMcRec = mcCollision.centFV0A(); + if (centralityEstimator == Option::kNGlobal) + centralityMcRec = mcCollision.centNGlobal(); + } + + registryMC.fill(HIST("hEventVsGenCentrality_truerec"), recoCentrality, centralityMcRec); + } + registryMC.fill(HIST("number_of_events_mc_rec_vs_centrality"), 0, centralityMcRec); // event selections @@ -1148,47 +1216,86 @@ struct CascadeAnalysisLightIonsDerivedData { } float centralityMC = 100.5f; + float centralityMCtrue = -1.f; + + if (centralityEstimator == Option::kFT0C) + centralityMCtrue = mcCollision.centFT0C(); + if (centralityEstimator == Option::kFT0M) + centralityMCtrue = mcCollision.centFT0M(); + if (centralityEstimator == Option::kFV0A) + centralityMCtrue = mcCollision.centFV0A(); + if (centralityEstimator == Option::kNGlobal) + centralityMCtrue = mcCollision.centNGlobal(); if (listBestCollisionIdx[mcCollision.globalIndex()] > -1) { auto collision = RecCols.iteratorAt(listBestCollisionIdx[mcCollision.globalIndex()]); - if (centralityEstimator == Option::kFT0C) - centralityMC = collision.centFT0C(); - if (centralityEstimator == Option::kFT0M) - centralityMC = collision.centFT0M(); - if (centralityEstimator == Option::kFV0A) - centralityMC = collision.centFV0A(); - if (centralityEstimator == Option::kNGlobal) - centralityMC = collision.centNGlobal(); + + if (useMcCentrality) { + centralityMC = centralityMCtrue; + } else { + if (centralityEstimator == Option::kFT0C) + centralityMC = collision.centFT0C(); + if (centralityEstimator == Option::kFT0M) + centralityMC = collision.centFT0M(); + if (centralityEstimator == Option::kFV0A) + centralityMC = collision.centFV0A(); + if (centralityEstimator == Option::kNGlobal) + centralityMC = collision.centNGlobal(); + } if (cascMC.pdgCode() == kXiMinus && std::abs(cascMC.rapidityMC(0)) < rapcut) { - registryMC.fill(HIST("h2dGenXiMinusVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); + if (useMcCentrality) + registryMC.fill(HIST("h2dGenXiMinusVsMcCentrality_RecoedEvt"), centralityMCtrue, ptmc); + else + registryMC.fill(HIST("h2dGenXiMinusVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); } if (cascMC.pdgCode() == kXiPlusBar && std::abs(cascMC.rapidityMC(0)) < rapcut) { - registryMC.fill(HIST("h2dGenXiPlusVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); + if (useMcCentrality) + registryMC.fill(HIST("h2dGenXiPlusVsMcCentrality_RecoedEvt"), centralityMCtrue, ptmc); + else + registryMC.fill(HIST("h2dGenXiPlusVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); } if (cascMC.pdgCode() == kOmegaMinus && std::abs(cascMC.rapidityMC(2)) < rapcut) { - registryMC.fill(HIST("h2dGenOmegaMinusVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); + if (useMcCentrality) + registryMC.fill(HIST("h2dGenOmegaMinusVsMcCentrality_RecoedEvt"), centralityMCtrue, ptmc); + else + registryMC.fill(HIST("h2dGenOmegaMinusVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); } if (cascMC.pdgCode() == kOmegaPlusBar && std::abs(cascMC.rapidityMC(2)) < rapcut) { - registryMC.fill(HIST("h2dGenOmegaPlusVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); + if (useMcCentrality) + registryMC.fill(HIST("h2dGenOmegaPlusVsMcCentrality_RecoedEvt"), centralityMCtrue, ptmc); + else + registryMC.fill(HIST("h2dGenOmegaPlusVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); } } if (cascMC.pdgCode() == kXiMinus && std::abs(cascMC.rapidityMC(0)) < rapcut) { registryMC.fill(HIST("h2dGenXiMinus"), centralityMC, ptmc); - registryMC.fill(HIST("h2dGenXiMinusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); + if (useMcCentrality) + registryMC.fill(HIST("h2dGenXiMinusVsMcCentrality"), centralityMCtrue, ptmc); + else + registryMC.fill(HIST("h2dGenXiMinusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); } if (cascMC.pdgCode() == kXiPlusBar && std::abs(cascMC.rapidityMC(0)) < rapcut) { registryMC.fill(HIST("h2dGenXiPlus"), centralityMC, ptmc); - registryMC.fill(HIST("h2dGenXiPlusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); + if (useMcCentrality) + registryMC.fill(HIST("h2dGenXiPlusVsMcCentrality"), centralityMCtrue, ptmc); + else + registryMC.fill(HIST("h2dGenXiPlusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); } if (cascMC.pdgCode() == kOmegaMinus && std::abs(cascMC.rapidityMC(2)) < rapcut) { registryMC.fill(HIST("h2dGenOmegaMinus"), centralityMC, ptmc); - registryMC.fill(HIST("h2dGenOmegaMinusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); + if (useMcCentrality) + registryMC.fill(HIST("h2dGenOmegaMinusVsMcCentrality"), centralityMCtrue, ptmc); + else + registryMC.fill(HIST("h2dGenOmegaMinusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); } if (cascMC.pdgCode() == kOmegaPlusBar && std::abs(cascMC.rapidityMC(2)) < rapcut) { registryMC.fill(HIST("h2dGenOmegaPlus"), centralityMC, ptmc); - registryMC.fill(HIST("h2dGenOmegaPlusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); + if (useMcCentrality) + registryMC.fill(HIST("h2dGenOmegaPlusVsMcCentrality"), centralityMCtrue, ptmc); + else + registryMC.fill(HIST("h2dGenOmegaPlusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); } } // cascMC loop }