From eaf54a9a81c35001d78842a8b9cc3416b866a550 Mon Sep 17 00:00:00 2001 From: scannito Date: Mon, 21 Sep 2026 13:31:12 +0200 Subject: [PATCH 1/5] New tables and productions for (anti)Lambda and Omega --- .../DataModel/LFPhiStrangeCorrelationTables.h | 161 ++++--- .../Strangeness/phiStrangeCorrelator.cxx | 447 +++++++++++++----- 2 files changed, 407 insertions(+), 201 deletions(-) diff --git a/PWGLF/DataModel/LFPhiStrangeCorrelationTables.h b/PWGLF/DataModel/LFPhiStrangeCorrelationTables.h index d4fddd28771..44f552a0f6d 100644 --- a/PWGLF/DataModel/LFPhiStrangeCorrelationTables.h +++ b/PWGLF/DataModel/LFPhiStrangeCorrelationTables.h @@ -29,12 +29,6 @@ DECLARE_SOA_COLUMN(DefaultSel, defaultSel, bool); DECLARE_SOA_COLUMN(PhimesonSel, phimesonSel, bool); } // namespace lf_selection_event -/*DECLARE_SOA_TABLE(PhiStrangeDefEvtSelDataLike, "AOD", "DEFEVTSELDATA", - lf_selection_event::DefaultSel); - -DECLARE_SOA_TABLE(PhiStrangeDefEvtSelMcGen, "AOD", "DEFEVTSELMCGEN", - lf_selection_event::DefaultSel);*/ - DECLARE_SOA_TABLE(PhiStrangeEvtSelDataLike, "AOD", "EVTSELDATA", lf_selection_event::DefaultSel, lf_selection_event::PhimesonSel); @@ -43,28 +37,6 @@ DECLARE_SOA_TABLE(PhiStrangeEvtSelMcGen, "AOD", "EVTSELMCGEN", lf_selection_event::DefaultSel, lf_selection_event::PhimesonSel); -/*namespace lf_selection_default_collision -{ -DECLARE_SOA_COLUMN(DefaultSel, defaultSel, bool); -} // namespace lf_selection_default_collision - -DECLARE_SOA_TABLE(DefaultSelectionData, "AOD", "DEFSELDATA", - lf_selection_default_collision::DefaultSel); - -DECLARE_SOA_TABLE(DefaultSelectionMcGen, "AOD", "DEFSELMCGEN", - lf_selection_default_collision::DefaultSel); - -namespace lf_selection_phi_collision -{ -DECLARE_SOA_COLUMN(PhimesonSel, phimesonSel, bool); -} // namespace lf_selection_phi_collision - -DECLARE_SOA_TABLE(PhimesonSelectionData, "AOD", "PHIINCOLLDATA", - lf_selection_phi_collision::PhimesonSel); - -DECLARE_SOA_TABLE(PhimesonSelectionMcGen, "AOD", "PHIINCOLLMCGEN", - lf_selection_phi_collision::PhimesonSel);*/ - namespace lf_selection_phi_candidate { DECLARE_SOA_INDEX_COLUMN(Collision, collision); @@ -89,7 +61,7 @@ DECLARE_SOA_TABLE(PhimesonCandidatesData, "AOD", "PHICANDDATA", lf_selection_phi_candidate::Phi, lf_selection_phi_candidate::InMassRegion); -DECLARE_SOA_TABLE(PhimesonCandidatesMcReco, "AOD", "PHICANDMCRECO", +DECLARE_SOA_TABLE(PhimesonCandidatesMcReco, "AOD", "PHICANDMCREC", soa::Index<>, lf_selection_phi_candidate::CollisionId, lf_selection_phi_candidate::M, @@ -107,7 +79,7 @@ DECLARE_SOA_TABLE(PhimesonCandidatesMcGen, "AOD", "PHICANDMCGEN", lf_selection_phi_candidate::Phi, lf_selection_phi_candidate::InMassRegion); -namespace lf_selection_k0s_reduced +namespace lf_selection_strange_reduced { DECLARE_SOA_INDEX_COLUMN(Collision, collision); @@ -120,58 +92,97 @@ DECLARE_SOA_DYNAMIC_COLUMN(InMassRegion, inMassRegion, [](float m, float minM, float maxM) -> bool { return (m >= minM && m <= maxM); }); -} // namespace lf_selection_k0s_reduced +} // namespace lf_selection_strange_reduced DECLARE_SOA_TABLE(K0sReducedCandidatesData, "AOD", "K0SCANDDATA", soa::Index<>, - lf_selection_k0s_reduced::CollisionId, - lf_selection_k0s_reduced::M, - lf_selection_k0s_reduced::Pt, - lf_selection_k0s_reduced::Y, - lf_selection_k0s_reduced::Phi, - lf_selection_k0s_reduced::InMassRegion); - -DECLARE_SOA_TABLE(K0sReducedCandidatesMcReco, "AOD", "K0SCANDMCRECO", + lf_selection_strange_reduced::CollisionId, + lf_selection_strange_reduced::M, + lf_selection_strange_reduced::Pt, + lf_selection_strange_reduced::Y, + lf_selection_strange_reduced::Phi, + lf_selection_strange_reduced::InMassRegion); + +DECLARE_SOA_TABLE(K0sReducedCandidatesMcReco, "AOD", "K0SCANDMCREC", soa::Index<>, - lf_selection_k0s_reduced::CollisionId, - lf_selection_k0s_reduced::M, - lf_selection_k0s_reduced::Pt, - lf_selection_k0s_reduced::Y, - lf_selection_k0s_reduced::Phi, - lf_selection_k0s_reduced::InMassRegion); - -namespace lf_selection_xi_reduced -{ -DECLARE_SOA_INDEX_COLUMN(Collision, collision); - -DECLARE_SOA_COLUMN(M, m, float); -DECLARE_SOA_COLUMN(Pt, pt, float); -DECLARE_SOA_COLUMN(Y, y, float); -DECLARE_SOA_COLUMN(Phi, phi, float); - -DECLARE_SOA_DYNAMIC_COLUMN(InMassRegion, inMassRegion, - [](float m, float minM, float maxM) -> bool { - return (m >= minM && m <= maxM); - }); -} // namespace lf_selection_xi_reduced + lf_selection_strange_reduced::CollisionId, + lf_selection_strange_reduced::M, + lf_selection_strange_reduced::Pt, + lf_selection_strange_reduced::Y, + lf_selection_strange_reduced::Phi, + lf_selection_strange_reduced::InMassRegion); + +DECLARE_SOA_TABLE(LambdaReducedCandidatesData, "AOD", "LAMBDACANDDATA", + soa::Index<>, + lf_selection_strange_reduced::CollisionId, + lf_selection_strange_reduced::M, + lf_selection_strange_reduced::Pt, + lf_selection_strange_reduced::Y, + lf_selection_strange_reduced::Phi, + lf_selection_strange_reduced::InMassRegion); + +DECLARE_SOA_TABLE(LambdaReducedCandidatesMcReco, "AOD", "LAMBDACANDMCREC", + soa::Index<>, + lf_selection_strange_reduced::CollisionId, + lf_selection_strange_reduced::M, + lf_selection_strange_reduced::Pt, + lf_selection_strange_reduced::Y, + lf_selection_strange_reduced::Phi, + lf_selection_strange_reduced::InMassRegion); + +DECLARE_SOA_TABLE(AntiLambdaReducedCandidatesData, "AOD", "ALAMBCANDDATA", + soa::Index<>, + lf_selection_strange_reduced::CollisionId, + lf_selection_strange_reduced::M, + lf_selection_strange_reduced::Pt, + lf_selection_strange_reduced::Y, + lf_selection_strange_reduced::Phi, + lf_selection_strange_reduced::InMassRegion); + +DECLARE_SOA_TABLE(AntiLambdaReducedCandidatesMcReco, "AOD", "ALAMBCANDMCREC", + soa::Index<>, + lf_selection_strange_reduced::CollisionId, + lf_selection_strange_reduced::M, + lf_selection_strange_reduced::Pt, + lf_selection_strange_reduced::Y, + lf_selection_strange_reduced::Phi, + lf_selection_strange_reduced::InMassRegion); DECLARE_SOA_TABLE(XiReducedCandidatesData, "AOD", "XICANDDATA", soa::Index<>, - lf_selection_xi_reduced::CollisionId, - lf_selection_xi_reduced::M, - lf_selection_xi_reduced::Pt, - lf_selection_xi_reduced::Y, - lf_selection_xi_reduced::Phi, - lf_selection_xi_reduced::InMassRegion); - -DECLARE_SOA_TABLE(XiReducedCandidatesMcReco, "AOD", "XICANDMCRECO", + lf_selection_strange_reduced::CollisionId, + lf_selection_strange_reduced::M, + lf_selection_strange_reduced::Pt, + lf_selection_strange_reduced::Y, + lf_selection_strange_reduced::Phi, + lf_selection_strange_reduced::InMassRegion); + +DECLARE_SOA_TABLE(XiReducedCandidatesMcReco, "AOD", "XICANDMCREC", + soa::Index<>, + lf_selection_strange_reduced::CollisionId, + lf_selection_strange_reduced::M, + lf_selection_strange_reduced::Pt, + lf_selection_strange_reduced::Y, + lf_selection_strange_reduced::Phi, + lf_selection_strange_reduced::InMassRegion); + +DECLARE_SOA_TABLE(OmegaReducedCandidatesData, "AOD", "OMEGACANDDATA", + soa::Index<>, + lf_selection_strange_reduced::CollisionId, + lf_selection_strange_reduced::M, + lf_selection_strange_reduced::Pt, + lf_selection_strange_reduced::Y, + lf_selection_strange_reduced::Phi, + lf_selection_strange_reduced::InMassRegion); + +DECLARE_SOA_TABLE(OmegaReducedCandidatesMcReco, "AOD", "OMEGACANDMCREC", soa::Index<>, - lf_selection_xi_reduced::CollisionId, - lf_selection_xi_reduced::M, - lf_selection_xi_reduced::Pt, - lf_selection_xi_reduced::Y, - lf_selection_xi_reduced::Phi, - lf_selection_xi_reduced::InMassRegion); + lf_selection_strange_reduced::CollisionId, + lf_selection_strange_reduced::M, + lf_selection_strange_reduced::Pt, + lf_selection_strange_reduced::Y, + lf_selection_strange_reduced::Phi, + lf_selection_strange_reduced::InMassRegion); namespace lf_selection_pion_track { @@ -209,7 +220,7 @@ DECLARE_SOA_TABLE(PionTracksData, "AOD", "PITRACKSDATA", lf_selection_pion_track::HasTOF, lf_selection_pion_track::NSigmaTOF>); -DECLARE_SOA_TABLE(PionTracksMcReco, "AOD", "PITRACKSMCRECO", +DECLARE_SOA_TABLE(PionTracksMcReco, "AOD", "PITRACKSMCREC", soa::Index<>, lf_selection_pion_track::CollisionId, lf_selection_pion_track::NSigmaTPC, diff --git a/PWGLF/TableProducer/Strangeness/phiStrangeCorrelator.cxx b/PWGLF/TableProducer/Strangeness/phiStrangeCorrelator.cxx index 816c35150b5..dfdfec8627e 100644 --- a/PWGLF/TableProducer/Strangeness/phiStrangeCorrelator.cxx +++ b/PWGLF/TableProducer/Strangeness/phiStrangeCorrelator.cxx @@ -238,7 +238,7 @@ struct PhiMesonCandProducer { continue; } - const auto& mcParticles = mcParticlesOpt.value().get(); + const auto& mcParticles = mcParticlesOpt->get(); const auto track1McParticle = mcParticles.rawIteratorAt(track1.mcParticleId()); if (track1McParticle.pdgCode() != PDG_t::kKPlus || !track1McParticle.isPhysicalPrimary()) { continue; @@ -259,7 +259,7 @@ struct PhiMesonCandProducer { continue; } - const auto& mcParticles = mcParticlesOpt.value().get(); + const auto& mcParticles = mcParticlesOpt->get(); const auto track2McParticle = mcParticles.rawIteratorAt(track2.mcParticleId()); if (track2McParticle.pdgCode() != PDG_t::kKMinus || !track2McParticle.isPhysicalPrimary()) { continue; @@ -285,7 +285,7 @@ struct PhiMesonCandProducer { continue; } - const auto& mcParticles = mcParticlesOpt.value().get(); + const auto& mcParticles = mcParticlesOpt->get(); const auto track1McParticle = mcParticles.rawIteratorAt(track1.mcParticleId()); const auto track2McParticle = mcParticles.rawIteratorAt(track2.mcParticleId()); @@ -403,11 +403,21 @@ struct PhiMesonCandProducer { PROCESS_SWITCH(PhiMesonCandProducer, processMCGen, "Process function to select Phi meson candidates in MCGen", false); }; -struct K0sReducedCandProducer { - // Produce the table with the K0s candidates information +struct V0ReducedCandProducer { + enum V0Type { kK0s = 0, + kLambda, + kAntiLambda }; + + // Produce the table with the V0 candidates information Produces k0sReducedCandidatesData; Produces k0sReducedCandidatesMcReco; + Produces lambdaReducedCandidatesData; + Produces lambdaReducedCandidatesMcReco; + + Produces antilambdaReducedCandidatesData; + Produces antilambdaReducedCandidatesMcReco; + HistogramRegistry histos{"k0sReducedCandidates", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; // Configurable on multiplicity bins @@ -417,6 +427,7 @@ struct K0sReducedCandProducer { struct : ConfigurableGroup { Configurable etaMax{"etaMax", 0.8f, "eta max"}; Configurable nSigmaCutTPCSecPion{"nSigmaCutTPCSecPion", 4.0f, "Value of the TPC Nsigma cut for secondary Pions"}; + Configurable nSigmaCutTPCSecProton{"nSigmaCutTPCSecProton", 4.0f, "Value of the TPC Nsigma cut for secondary Protons"}; Configurable minTPCnClsFound{"minTPCnClsFound", 70, "min number of found TPC clusters"}; Configurable minNCrossedRowsTPC{"minNCrossedRowsTPC", 70, "min number of TPC crossed rows"}; @@ -425,25 +436,37 @@ struct K0sReducedCandProducer { // Configurables for V0 selection struct : ConfigurableGroup { - Configurable v0SettingCosPA{"v0SettingCosPA", 0.98f, "V0 CosPA"}; - Configurable v0SettingRadius{"v0SettingRadius", 0.5f, "V0 decay radius"}; - Configurable v0SettingDCAV0Dau{"v0SettingDCAV0Dau", 1.0f, "DCA V0 Daughters"}; - Configurable v0SettingDCAPosToPV{"v0SettingDCAPosToPV", 0.1f, "DCA Pos To PV"}; - Configurable v0SettingDCANegToPV{"v0SettingDCANegToPV", 0.1f, "DCA Neg To PV"}; - Configurable v0SettingMinPt{"v0SettingMinPt", 0.1f, "V0 min pt"}; + Configurable decayRadius{"decayRadius", 0.5f, "V0 decay radius"}; + Configurable dcaV0Dau{"dcaV0Dau", 1.0f, "DCA V0 Daughters"}; + Configurable dcaPosToPV{"dcaPosToPV", 0.1f, "DCA Pos To PV"}; + Configurable dcaNegToPV{"dcaNegToPV", 0.1f, "DCA Neg To PV"}; - Configurable cfgFurtherV0Selection{"cfgFurtherV0Selection", false, "Further V0 selection"}; - Configurable ctauK0s{"ctauK0s", 20.0f, "C tau K0s(cm)"}; - Configurable paramArmenterosCut{"paramArmenterosCut", 0.2f, "parameter Armenteros Cut"}; - Configurable v0rejK0s{"v0rejK0s", 0.005f, "V0 rej K0s"}; + Configurable furtherV0Selection{"furtherV0Selection", false, "Further V0 selection"}; - Configurable> rangeMK0sSignal{"rangeMK0sSignal", {0.47f, 0.53f}, "K0S mass range for signal extraction"}; + Configurable yAcceptance{"yAcceptance", 0.5f, "Rapidity acceptance"}; - Configurable cfgYAcceptance{"cfgYAcceptance", 0.5f, "Rapidity acceptance"}; - } v0Configs; + struct : ConfigurableGroup { + Configurable cosPA{"cosPA", 0.98f, "V0 CosPA"}; + Configurable ctau{"ctau", 20.0f, "C tau K0s(cm)"}; + Configurable rejMass{"rejMass", 0.005f, "V0 rej K0s"}; + + Configurable paramArmenterosCut{"paramArmenterosCut", 0.2f, "Parameter for Armenteros Cut for K0S"}; + + Configurable minPt{"minPt", 0.1f, "K0S min pt"}; + Configurable> binspTK0S{"binspTK0S", {0.1, 0.5, 0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for K0S"}; + Configurable> rangeMK0sSignal{"rangeMK0sSignal", {0.47f, 0.53f}, "K0S mass range for signal extraction"}; + } k0sConfigs; + + struct : ConfigurableGroup { + Configurable cosPA{"cosPA", 0.98f, "V0 CosPA"}; + Configurable ctau{"ctau", 7.89f, "C tau Lambda(cm)"}; + Configurable rejMass{"rejMass", 0.005f, "V0 rej Lambda"}; - // Configurable on K0S pT bins - Configurable> binspTK0S{"binspTK0S", {0.1, 0.5, 0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for K0S"}; + Configurable minPt{"minPt", 0.1f, "Lambda min pt"}; + Configurable> binspTLambda{"binspTLambda", {0.1, 0.5, 0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for Lambda"}; + Configurable> rangeMLambdaSignal{"rangeMLambdaSignal", {1.11f, 1.12f}, "Lambda mass range for signal extraction"}; + } lambdaConfigs; + } v0Configs; // Constants static constexpr double MassK0S = o2::constants::physics::MassK0Short; @@ -454,9 +477,9 @@ struct K0sReducedCandProducer { Filter collisionFilter = aod::lf_selection_event::defaultSel == true; // Defining filters on V0s (cannot filter on dynamic columns) - Filter v0PreFilter = (nabs(aod::v0data::dcapostopv) > v0Configs.v0SettingDCAPosToPV && - nabs(aod::v0data::dcanegtopv) > v0Configs.v0SettingDCANegToPV && - aod::v0data::dcaV0daughters < v0Configs.v0SettingDCAV0Dau); + Filter v0PreFilter = (nabs(aod::v0data::dcapostopv) > v0Configs.dcaPosToPV && + nabs(aod::v0data::dcanegtopv) > v0Configs.dcaNegToPV && + aod::v0data::dcaV0daughters < v0Configs.dcaV0Dau); // Defining the type of the collisions for data and MC using SelCollisions = soa::Join; @@ -469,16 +492,35 @@ struct K0sReducedCandProducer { using FullV0s = soa::Filtered; using FullMCV0s = soa::Filtered>; - using V0DauTracks = soa::Join; + using V0DauTracks = soa::Join; using V0DauMCTracks = soa::Join; void init(InitContext&) { AxisSpec binnedmultAxis{(std::vector)binsMult, "centFT0M"}; - AxisSpec binnedpTK0SAxis{(std::vector)binspTK0S, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTK0SAxis{(std::vector)v0Configs.k0sConfigs.binspTK0S, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTLambdaAxis{(std::vector)v0Configs.lambdaConfigs.binspTLambda, "#it{p}_{T} (GeV/#it{c})"}; AxisSpec massK0SAxis = {200, 0.45f, 0.55f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; + AxisSpec massLambdaAxis = {200, 1.08f, 1.15f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; histos.add("h3K0sCandidatesMass", "K^{0}_{S} candidate invariant mass", kTH3F, {binnedmultAxis, binnedpTK0SAxis, massK0SAxis}); + histos.add("h3LambdaCandidatesMass", "#Lambda candidate invariant mass", kTH3F, {binnedmultAxis, binnedpTK0SAxis, massLambdaAxis}); + histos.add("h3AntiLambdaCandidatesMass", "#bar{#Lambda} candidate invariant mass", kTH3F, {binnedmultAxis, binnedpTK0SAxis, massLambdaAxis}); + } + + template + constexpr int getPdgCode() + { + if constexpr (v0Type == kK0S) { + return PDG_t::kK0Short; + } else if constexpr (v0Type == kLambda) { + return PDG_t::kLambda0; + } else if constexpr (v0Type == kAntiLambda) { + return PDG_t::kLambda0Bar; + } else { + static_assert(v0Type == kK0S || v0Type == kLambda || v0Type == kAntiLambda, "Unsupported particle type in getPdgCode"); + return 0; + } } // Single track selection for strangeness sector @@ -505,7 +547,7 @@ struct K0sReducedCandProducer { } // V0 selection - template + template bool selectionV0(const T1& v0, const T2& collision) { using V0DauTrackType = std::conditional_t; @@ -518,88 +560,158 @@ struct K0sReducedCandProducer { } if constexpr (!isMC) { - if (std::abs(posDaughterTrack.tpcNSigmaPi()) > trackConfigs.nSigmaCutTPCSecPion) { - return false; - } - if (std::abs(negDaughterTrack.tpcNSigmaPi()) > trackConfigs.nSigmaCutTPCSecPion) { - return false; + if constexpr (v0Type == kK0s) { + if (std::abs(posDaughterTrack.tpcNSigmaPi()) > trackConfigs.nSigmaCutTPCSecPion) { + return false; + } + if (std::abs(negDaughterTrack.tpcNSigmaPi()) > trackConfigs.nSigmaCutTPCSecPion) { + return false; + } + } else if constexpr (v0Type == kLambda) { + if (std::abs(posDaughterTrack.tpcNSigmaPr()) > trackConfigs.nSigmaCutTPCSecProton) { + return false; + } + if (std::abs(negDaughterTrack.tpcNSigmaPi()) > trackConfigs.nSigmaCutTPCSecPion) { + return false; + } + } else if constexpr (v0Type == kAntiLambda) { + if (std::abs(posDaughterTrack.tpcNSigmaPi()) > trackConfigs.nSigmaCutTPCSecPion) { + return false; + } + if (std::abs(negDaughterTrack.tpcNSigmaPr()) > trackConfigs.nSigmaCutTPCSecProton) { + return false; + } } } - if (v0.v0cosPA() < v0Configs.v0SettingCosPA) { + if (v0.v0radius() < v0Configs.decayRadius) { return false; } - if (v0.v0radius() < v0Configs.v0SettingRadius) { + if (std::abs(v0.rapidity(v0Type)) > v0Configs.yAcceptance) { return false; } - if (v0.pt() < v0Configs.v0SettingMinPt) { + + const auto& cfgs = [&]() -> const auto& { + if constexpr (v0Type == kK0s) { + return v0Configs.k0sConfigs; + } else if constexpr (v0Type == kLambda || v0Type == kAntiLambda) { + return v0Configs.lambdaConfigs; + } + }(); + + if (v0.v0cosPA() < cfgs.cosPA) { + return false; + } + if (v0.pt() < cfgs.minPt) { return false; } - if (v0Configs.cfgFurtherV0Selection) { - if (v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * MassK0S > v0Configs.ctauK0s) { - return false; - } - if (v0.qtarm() < (v0Configs.paramArmenterosCut * std::abs(v0.alpha()))) { + if (v0Configs.furtherV0Selection) { + constexpr float assumedMass = v0Type == kK0s ? MassK0S : MassLambda; + if (v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * assumedMass > cfgs.ctau) { return false; } - if (std::abs(v0.mLambda() - MassLambda) < v0Configs.v0rejK0s) { - return false; + + if constexpr (v0Type == kK0s) { + if (std::abs(v0.mLambda() - MassLambda) < cfgs.rejMass || + std::abs(v0.mAntiLambda() - MassLambda) < cfgs.rejMass) { + return false; + } + if (v0.qtarm() < (cfgs.paramArmenterosCut * std::abs(v0.alpha()))) { + return false; + } + } else { + if (std::abs(v0.mK0Short() - MassK0S) < cfgs.rejMass) { + return false; + } } } - if (std::abs(v0.yK0Short()) > v0Configs.cfgYAcceptance) { - return false; + return true; + } + + template + void processV0Type(TColl const& collision, TV0 const& v0, std::optional> mcParticlesOpt = std::nullopt) + { + // Cut on V0 dynamic columns + if (!selectionV0(v0, collision)) { + return; } - return true; + if constexpr (isMC) { + if (!v0.has_mcParticle() || !mcParticlesOpt) { + return; + } + + const auto& mcParticles = mcParticlesOpt->get(); + const auto& v0McParticle = mcParticles.rawIteratorAt(v0.mcParticleId()); + if (v0McParticle.pdgCode() != getPdgCode() || !v0McParticle.isPhysicalPrimary()) { + return; + } + + if constexpr (v0Type == kK0s) { + k0sReducedCandidatesMcReco(collision.globalIndex(), v0.mK0Short(), v0McParticle.pt(), v0McParticle.y(), v0McParticle.phi()); + } else if constexpr (v0Type == kLambda) { + lambdaReducedCandidatesMcReco(collision.globalIndex(), v0.mLambda(), v0McParticle.pt(), v0McParticle.y(), v0McParticle.phi()); + } else if constexpr (v0Type == kAntiLambda) { + antilambdaReducedCandidatesMcReco(collision.globalIndex(), v0.mAntiLambda(), v0McParticle.pt(), v0McParticle.y(), v0McParticle.phi()); + } + } else { + if constexpr (v0Type == kK0s) { + histos.fill(HIST("h3K0sCandidatesMass"), collision.centFT0M(), v0.pt(), v0.mK0Short()); + k0sReducedCandidatesData(collision.globalIndex(), v0.mK0Short(), v0.pt(), v0.yK0Short(), v0.phi()); + } else if constexpr (v0Type == kLambda) { + histos.fill(HIST("h3LambdaCandidatesMass"), collision.centFT0M(), v0.pt(), v0.mLambda()); + lambdaReducedCandidatesData(collision.globalIndex(), v0.mLambda(), v0.pt(), v0.yLambda(), v0.phi()); + } else if constexpr (v0Type == kAntiLambda) { + histos.fill(HIST("h3AntiLambdaCandidatesMass"), collision.centFT0M(), v0.pt(), v0.mAntiLambda()); + antilambdaReducedCandidatesData(collision.globalIndex(), v0.mAntiLambda(), v0.pt(), v0.yLambda(), v0.phi()); + // histos.fill(HIST("h3LambdaCandidatesMass"), collision.centFT0M(), v0.pt(), v0.mAntiLambda()); + // lambdaReducedCandidatesData(collision.globalIndex(), v0.mAntiLambda(), v0.pt(), v0.yLambda(), v0.phi()); + } + } + } + + template + void evaluateAllHypotheses(TColl const& collision, TV0 const& v0, std::optional> mcParticlesOpt = std::nullopt) + { + (processV0Type(collision, v0, mcParticlesOpt), ...); } // void processData(SelCollisions::iterator const& collision, FullV0s const& V0s, V0DauTracks const&) void processData(FilteredSelCollisions::iterator const& collision, FullV0s const& V0s, V0DauTracks const&) { for (const auto& v0 : V0s) { - // Cut on V0 dynamic columns - if (!selectionV0(v0, collision)) { - continue; - } - - histos.fill(HIST("h3K0sCandidatesMass"), collision.centFT0M(), v0.pt(), v0.mK0Short()); - - k0sReducedCandidatesData(collision.globalIndex(), v0.mK0Short(), v0.pt(), v0.yK0Short(), v0.phi()); + evaluateAllHypotheses(collision, v0); } } - PROCESS_SWITCH(K0sReducedCandProducer, processData, "Process function to select reduced K0s candidates in Data or in McReco (w/o McTruth) analysis", true); + PROCESS_SWITCH(V0ReducedCandProducer, processData, "Process function to select reduced K0s candidates in Data or in McReco (w/o McTruth) analysis", true); // void processMCReco(SimCollisions::iterator const& collision, FullMCV0s const& V0s, V0DauMCTracks const&, aod::McParticles const& mcParticles) void processMCReco(FilteredSimCollisions::iterator const& collision, FullMCV0s const& V0s, V0DauMCTracks const&, aod::McParticles const& mcParticles) { for (const auto& v0 : V0s) { - if (!selectionV0(v0, collision)) { - continue; - } - if (!v0.has_mcParticle()) { - continue; - } - - const auto& v0McParticle = mcParticles.rawIteratorAt(v0.mcParticleId()); - if (std::abs(v0McParticle.pdgCode()) != PDG_t::kK0Short || !v0McParticle.isPhysicalPrimary()) { - continue; - } - - k0sReducedCandidatesMcReco(collision.globalIndex(), v0.mK0Short(), v0McParticle.pt(), v0McParticle.y(), v0McParticle.phi()); + evaluateAllHypotheses(collision, v0, mcParticles); } } - PROCESS_SWITCH(K0sReducedCandProducer, processMCReco, "Process function to select reduced K0s candidates in MCReco w MC truth", false); + PROCESS_SWITCH(V0ReducedCandProducer, processMCReco, "Process function to select reduced K0s candidates in MCReco w MC truth", false); }; -struct XiReducedCandProducer { +struct CascadeReducedCandProducer { + enum CascadeType { kXi = 0, + kAntiXi, + kOmega, + kAntiOmega }; + // Produce the table with the Xi candidates information Produces xiReducedCandidatesData; Produces xiReducedCandidatesMcReco; + Produces omegaReducedCandidatesData; + Produces omegaReducedCandidatesMcReco; + HistogramRegistry histos{"xiReducedCandidates", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; // Configurable on multiplicity bins @@ -609,6 +721,7 @@ struct XiReducedCandProducer { struct : ConfigurableGroup { Configurable etaMax{"etaMax", 0.8f, "eta max"}; Configurable nSigmaCutTPCSecPion{"nSigmaCutTPCSecPion", 4.0f, "Value of the TPC Nsigma cut for secondary Pions"}; + Configurable nSigmaCutTPCSecKaon{"nSigmaCutTPCSecKaon", 4.0f, "Value of the TPC Nsigma cut for secondary Kaons"}; Configurable nSigmaCutTPCSecProton{"nSigmaCutTPCSecProton", 4.0f, "Value of the TPC Nsigma cut for secondary Protons"}; Configurable minTPCnClsFound{"minTPCnClsFound", 70, "min number of found TPC clusters"}; @@ -618,35 +731,48 @@ struct XiReducedCandProducer { // Configurables for Cascade selection struct : ConfigurableGroup { - Configurable cascSettingV0CosPA{"cascSettingV0CosPA", 0.98f, "V0 CosPA"}; - Configurable cascSettingCosPA{"cascSettingCosPA", 0.98f, "Cascade CosPA"}; - Configurable cascSettingV0Radius{"cascSettingV0Radius", 0.5f, "V0 decay radius"}; - Configurable cascSettingRadius{"cascSettingRadius", 0.5f, "Cascade decay radius"}; - Configurable cascSettingDCAV0Dau{"cascSettingDCAV0Dau", 1.0f, "DCA V0 Daughters"}; - Configurable cascSettingDCACascDau{"cascSettingDCACascDau", 1.0f, "DCA Cascade Daughters"}; - Configurable cascSettingDCAPosToPV{"cascSettingDCAPosToPV", 0.1f, "DCA Pos To PV"}; - Configurable cascSettingDCANegToPV{"cascSettingDCANegToPV", 0.1f, "DCA Neg To PV"}; - Configurable cascSettingDCABachToPV{"cascSettingDCABachToPV", 0.1f, "DCA Bach To PV"}; - Configurable cascSettingMinPt{"cascSettingMinPt", 0.8f, "Cascade min pt"}; - - Configurable cfgYAcceptance{"cfgYAcceptance", 0.5f, "Rapidity acceptance"}; + Configurable dcaV0Dau{"dcaV0Dau", 1.0f, "DCA V0 Daughters"}; + Configurable dcaCascDau{"dcaCascDau", 1.0f, "DCA Cascade Daughters"}; + Configurable dcaPosToPV{"dcaPosToPV", 0.1f, "DCA Pos To PV"}; + Configurable dcaNegToPV{"dcaNegToPV", 0.1f, "DCA Neg To PV"}; + Configurable dcaBachToPV{"dcaBachToPV", 0.1f, "DCA Bach To PV"}; + + Configurable yAcceptance{"yAcceptance", 0.5f, "Rapidity acceptance"}; + + struct : ConfigurableGroup { + Configurable v0CosPA{"v0CosPA", 0.98f, "V0 CosPA"}; + Configurable cosPA{"cosPA", 0.98f, "Cascade CosPA"}; + Configurable v0Radius{"v0Radius", 0.5f, "V0 decay radius"}; + Configurable radius{"radius", 0.5f, "Cascade decay radius"}; + + Configurable minPt{"minPt", 0.8f, "Cascade min pt"}; + Configurable> binspTXi{"binspTXi", {0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for Xi"}; + } xiConfigs; + + struct : ConfigurableGroup { + Configurable v0CosPA{"v0CosPA", 0.98f, "V0 CosPA"}; + Configurable cosPA{"cosPA", 0.98f, "Cascade CosPA"}; + Configurable v0Radius{"v0Radius", 0.5f, "V0 decay radius"}; + Configurable radius{"radius", 0.5f, "Cascade decay radius"}; + + Configurable minPt{"minPt", 0.8f, "Cascade min pt"}; + Configurable> binspTOmega{"binspTOmega", {0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for Omega"}; + } omegaConfigs; } cascadeConfigs; - // Configurables for Xi pT bins - Configurable> binspTXi{"binspTXi", {0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for Xi"}; - // Constants static constexpr double MassXi = o2::constants::physics::MassXiMinus; + static constexpr double MassOmega = o2::constants::physics::MassOmegaMinus; // Filter on default selected collisions Filter collisionFilter = aod::lf_selection_event::defaultSel == true; // Defining filters on Cascades (cannot filter on dynamic columns) - Filter cascadePreFilter = (nabs(aod::cascdata::dcapostopv) > cascadeConfigs.cascSettingDCAPosToPV && - nabs(aod::cascdata::dcanegtopv) > cascadeConfigs.cascSettingDCANegToPV && - nabs(aod::cascdata::dcabachtopv) > cascadeConfigs.cascSettingDCABachToPV && - aod::cascdata::dcaV0daughters < cascadeConfigs.cascSettingDCAV0Dau && - aod::cascdata::dcacascdaughters < cascadeConfigs.cascSettingDCACascDau); + Filter cascadePreFilter = (nabs(aod::cascdata::dcapostopv) > cascadeConfigs.dcaPosToPV && + nabs(aod::cascdata::dcanegtopv) > cascadeConfigs.dcaNegToPV && + nabs(aod::cascdata::dcabachtopv) > cascadeConfigs.dcaBachToPV && + aod::cascdata::dcaV0daughters < cascadeConfigs.dcaV0Dau && + aod::cascdata::dcacascdaughters < cascadeConfigs.dcaCascDau); // Defining the type of the collisions for data and MC using SelCollisions = soa::Join; @@ -659,16 +785,36 @@ struct XiReducedCandProducer { using FullCascades = soa::Filtered; using FullMCCascades = soa::Filtered>; - using DauTracks = soa::Join; + using DauTracks = soa::Join; using DauMCTracks = soa::Join; void init(InitContext&) { AxisSpec binnedmultAxis{(std::vector)binsMult, "centFT0M"}; - AxisSpec binnedpTXiAxis{(std::vector)binspTXi, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTXiAxis{(std::vector)cascadeConfigs.xiConfigs.binspTXi, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTOmegaAxis{(std::vector)cascadeConfigs.omegaConfigs.binspTOmega, "#it{p}_{T} (GeV/#it{c})"}; AxisSpec massXiAxis = {200, 1.2f, 1.4f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; + AxisSpec massOmegaAxis = {200, 1.6f, 1.8f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; histos.add("h3XiCandidatesMass", "#Xi candidate invariant mass", kTH3F, {binnedmultAxis, binnedpTXiAxis, massXiAxis}); + histos.add("h3OmegaCandidatesMass", "#Omega candidate invariant mass", kTH3F, {binnedmultAxis, binnedpTOmegaAxis, massOmegaAxis}); + } + + template + constexpr int getPdgCode() + { + if constexpr (cascadeType == kXi) { + return PDG_t::kXiMinus; + } else if constexpr (cascadeType == kAntiXi) { + return PDG_t::kXiPlusBar; + } else if constexpr (cascadeType == kOmega) { + return PDG_t::kOmegaMinus; + } else if constexpr (cascadeType == kAntiOmega) { + return PDG_t::kOmegaPlusBar; + } else { + static_assert(cascadeType == kXi || cascadeType == kAntiXi || cascadeType == kOmega || cascadeType == kAntiOmega, "Unsupported particle type in getPdgCode"); + return 0; + } } // Single track selection for strangeness sector @@ -695,9 +841,19 @@ struct XiReducedCandProducer { } // Cascade selection - template + template bool selectionCascade(const T1& cascade, const T2& collision) { + if constexpr (cascadeType == kXi || cascadeType == kOmega) { + if (cascade.sign() > 0) { + return false; // Matter must have negative charge + } + } else { + if (cascade.sign() < 0) { + return false; // Anti-matter must have positive charge + } + } + using DauTrackType = std::conditional_t; const auto& posDaughterTrack = cascade.template posTrack_as(); @@ -709,14 +865,14 @@ struct XiReducedCandProducer { } if constexpr (!isMC) { - if (cascade.sign() < 0) { + if constexpr (cascadeType == kXi || cascadeType == kOmega) { if (std::abs(posDaughterTrack.tpcNSigmaPr()) > trackConfigs.nSigmaCutTPCSecProton) { return false; } if (std::abs(negDaughterTrack.tpcNSigmaPi()) > trackConfigs.nSigmaCutTPCSecPion) { return false; } - } else if (cascade.sign() > 0) { + } else { if (std::abs(posDaughterTrack.tpcNSigmaPi()) > trackConfigs.nSigmaCutTPCSecPion) { return false; } @@ -724,73 +880,112 @@ struct XiReducedCandProducer { return false; } } - if (std::abs(bachDaughterTrack.tpcNSigmaPi()) > trackConfigs.nSigmaCutTPCSecPion) { - return false; + + if constexpr (cascadeType == kXi || cascadeType == kAntiXi) { + if (std::abs(bachDaughterTrack.tpcNSigmaPi()) > trackConfigs.nSigmaCutTPCSecPion) { + return false; + } + } else if constexpr (cascadeType == kOmega || cascadeType == kAntiOmega) { + if (std::abs(bachDaughterTrack.tpcNSigmaKa()) > trackConfigs.nSigmaCutTPCSecKaon) { + return false; + } } } + if (std::abs(cascade.rapidity(cascadeType)) > cascadeConfigs.yAcceptance) { + return false; + } + + const auto& cfgs = [&]() -> const auto& { + if constexpr (cascadeType == kXi || cascadeType == kAntiXi) { + return cascadeConfigs.xiConfigs; + } else if constexpr (cascadeType == kOmega || cascadeType == kAntiOmega) { + return cascadeConfigs.omegaConfigs; + } + }(); + const auto& pvx = collision.posX(); const auto& pvy = collision.posY(); const auto& pvz = collision.posZ(); - if (cascade.v0cosPA(pvx, pvy, pvz) < cascadeConfigs.cascSettingV0CosPA) { + if (cascade.v0cosPA(pvx, pvy, pvz) < cfgs.v0CosPA) { return false; } - if (cascade.casccosPA(pvx, pvy, pvz) < cascadeConfigs.cascSettingCosPA) { + if (cascade.casccosPA(pvx, pvy, pvz) < cfgs.cosPA) { return false; } - if (cascade.v0radius() < cascadeConfigs.cascSettingV0Radius) { + if (cascade.v0radius() < cfgs.v0Radius) { return false; } - if (cascade.cascradius() < cascadeConfigs.cascSettingRadius) { + if (cascade.cascradius() < cfgs.radius) { return false; } - if (cascade.pt() < cascadeConfigs.cascSettingMinPt) { + if (cascade.pt() < cfgs.minPt) { return false; } - if (std::abs(cascade.yXi()) > cascadeConfigs.cfgYAcceptance) { - return false; - } return true; } - void processData(FilteredSelCollisions::iterator const& collision, FullCascades const& cascades, DauTracks const&) + template + void processCascadeType(TColl const& collision, TCascade const& cascade, std::optional> mcParticlesOpt = std::nullopt) { - for (const auto& cascade : cascades) { - // Cut on cascade dynamic columns - if (!selectionCascade(cascade, collision)) { - continue; + // Cut on Cascade dynamic columns + if (!selectionCascade(cascade, collision)) { + return; + } + + if constexpr (isMC) { + if (!cascade.has_mcParticle() || !mcParticlesOpt) { + return; } - histos.fill(HIST("h3XiCandidatesMass"), collision.centFT0M(), cascade.pt(), cascade.mXi()); + const auto& mcParticles = mcParticlesOpt->get(); + const auto& cascadeMcParticle = mcParticles.rawIteratorAt(cascade.mcParticleId()); + if (cascadeMcParticle.pdgCode() != getPdgCode() || !cascadeMcParticle.isPhysicalPrimary()) { + return; + } - xiReducedCandidatesData(collision.globalIndex(), cascade.mXi(), cascade.pt(), cascade.yXi(), cascade.phi()); + if constexpr (cascadeType == kXi || cascadeType == kAntiXi) { + xiReducedCandidatesMcReco(collision.globalIndex(), cascade.mXi(), cascadeMcParticle.pt(), cascadeMcParticle.y(), cascadeMcParticle.phi()); + } else if constexpr (cascadeType == kOmega || cascadeType == kAntiOmega) { + omegaReducedCandidatesMcReco(collision.globalIndex(), cascade.mOmega(), cascadeMcParticle.pt(), cascadeMcParticle.y(), cascadeMcParticle.phi()); + } + } else { + if constexpr (cascadeType == kXi || cascadeType == kAntiXi) { + histos.fill(HIST("h3XiCandidatesMass"), collision.centFT0M(), cascade.pt(), cascade.mXi()); + xiReducedCandidatesData(collision.globalIndex(), cascade.mXi(), cascade.pt(), cascade.yXi(), cascade.phi()); + } else if constexpr (cascadeType == kOmega || cascadeType == kAntiOmega) { + histos.fill(HIST("h3OmegaCandidatesMass"), collision.centFT0M(), cascade.pt(), cascade.mOmega()); + omegaReducedCandidatesData(collision.globalIndex(), cascade.mOmega(), cascade.pt(), cascade.yOmega(), cascade.phi()); + } } } - PROCESS_SWITCH(XiReducedCandProducer, processData, "Process function to select reduced Xi candidates in Data or in McReco (w/o McTruth) analysis", true); + template + void evaluateAllHypotheses(TColl const& collision, TCascade const& cascade, std::optional> mcParticlesOpt = std::nullopt) + { + (processCascadeType(collision, cascade, mcParticlesOpt), ...); + } - void processMCReco(FilteredSimCollisions::iterator const& collision, FullMCCascades const& cascades, DauMCTracks const&, aod::McParticles const& mcParticles) + void + processData(FilteredSelCollisions::iterator const& collision, FullCascades const& cascades, DauTracks const&) { for (const auto& cascade : cascades) { - if (!selectionCascade(cascade, collision)) { - continue; - } - if (!cascade.has_mcParticle()) { - continue; - } + evaluateAllHypotheses(collision, cascade); + } + } - const auto& cascadeMcParticle = mcParticles.rawIteratorAt(cascade.mcParticleId()); - if (std::abs(cascadeMcParticle.pdgCode()) != PDG_t::kXiMinus || !cascadeMcParticle.isPhysicalPrimary()) { - continue; - } + PROCESS_SWITCH(CascadeReducedCandProducer, processData, "Process function to select reduced Xi candidates in Data or in McReco (w/o McTruth) analysis", true); - xiReducedCandidatesMcReco(collision.globalIndex(), cascade.mXi(), cascadeMcParticle.pt(), cascadeMcParticle.y(), cascadeMcParticle.phi()); + void processMCReco(FilteredSimCollisions::iterator const& collision, FullMCCascades const& cascades, DauMCTracks const&, aod::McParticles const& mcParticles) + { + for (const auto& cascade : cascades) { + evaluateAllHypotheses(collision, cascade, mcParticles); } } - PROCESS_SWITCH(XiReducedCandProducer, processMCReco, "Process function to select reduced Xi candidates in MCReco w MC truth", false); + PROCESS_SWITCH(CascadeReducedCandProducer, processMCReco, "Process function to select reduced Xi candidates in MCReco w MC truth", false); }; struct PionTrackProducer { @@ -1323,8 +1518,8 @@ struct EventSelectionProducer { WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc), - adaptAnalysisTask(cfgc), - adaptAnalysisTask(cfgc), + adaptAnalysisTask(cfgc), + adaptAnalysisTask(cfgc), adaptAnalysisTask(cfgc), adaptAnalysisTask(cfgc)}; } From 99ac69e7bb1de47963dc2708b33c3264fad4f57d Mon Sep 17 00:00:00 2001 From: scannito Date: Tue, 22 Sep 2026 11:19:43 +0200 Subject: [PATCH 2/5] Fix building --- .../Strangeness/phiStrangeCorrelator.cxx | 102 ++- .../Strangeness/phiStrangeCorrelation.cxx | 634 ++---------------- 2 files changed, 96 insertions(+), 640 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/phiStrangeCorrelator.cxx b/PWGLF/TableProducer/Strangeness/phiStrangeCorrelator.cxx index dfdfec8627e..53fc5ed541a 100644 --- a/PWGLF/TableProducer/Strangeness/phiStrangeCorrelator.cxx +++ b/PWGLF/TableProducer/Strangeness/phiStrangeCorrelator.cxx @@ -404,7 +404,7 @@ struct PhiMesonCandProducer { }; struct V0ReducedCandProducer { - enum V0Type { kK0s = 0, + enum V0Type { kK0S = 0, kLambda, kAntiLambda }; @@ -446,23 +446,23 @@ struct V0ReducedCandProducer { Configurable yAcceptance{"yAcceptance", 0.5f, "Rapidity acceptance"}; struct : ConfigurableGroup { - Configurable cosPA{"cosPA", 0.98f, "V0 CosPA"}; - Configurable ctau{"ctau", 20.0f, "C tau K0s(cm)"}; - Configurable rejMass{"rejMass", 0.005f, "V0 rej K0s"}; + Configurable cosPAK0S{"cosPAK0S", 0.98f, "K0S CosPA"}; + Configurable ctauK0S{"ctauK0S", 20.0f, "C tau K0s(cm)"}; + Configurable rejMassK0S{"rejMassK0S", 0.005f, "V0 rej K0s"}; - Configurable paramArmenterosCut{"paramArmenterosCut", 0.2f, "Parameter for Armenteros Cut for K0S"}; + Configurable paramArmenterosCutK0S{"paramArmenterosCutK0S", 0.2f, "Parameter for Armenteros Cut for K0S"}; - Configurable minPt{"minPt", 0.1f, "K0S min pt"}; + Configurable minPtK0S{"minPtK0S", 0.1f, "K0S min pt"}; Configurable> binspTK0S{"binspTK0S", {0.1, 0.5, 0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for K0S"}; Configurable> rangeMK0sSignal{"rangeMK0sSignal", {0.47f, 0.53f}, "K0S mass range for signal extraction"}; } k0sConfigs; struct : ConfigurableGroup { - Configurable cosPA{"cosPA", 0.98f, "V0 CosPA"}; - Configurable ctau{"ctau", 7.89f, "C tau Lambda(cm)"}; - Configurable rejMass{"rejMass", 0.005f, "V0 rej Lambda"}; + Configurable cosPALambda{"cosPALambda", 0.98f, "Lambda CosPA"}; + Configurable ctauLambda{"ctauLambda", 7.89f, "C tau Lambda(cm)"}; + Configurable rejMassLambda{"rejMassLambda", 0.005f, "V0 rej Lambda"}; - Configurable minPt{"minPt", 0.1f, "Lambda min pt"}; + Configurable minPtLambda{"minPtLambda", 0.1f, "Lambda min pt"}; Configurable> binspTLambda{"binspTLambda", {0.1, 0.5, 0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for Lambda"}; Configurable> rangeMLambdaSignal{"rangeMLambdaSignal", {1.11f, 1.12f}, "Lambda mass range for signal extraction"}; } lambdaConfigs; @@ -560,7 +560,7 @@ struct V0ReducedCandProducer { } if constexpr (!isMC) { - if constexpr (v0Type == kK0s) { + if constexpr (v0Type == kK0S) { if (std::abs(posDaughterTrack.tpcNSigmaPi()) > trackConfigs.nSigmaCutTPCSecPion) { return false; } @@ -591,37 +591,33 @@ struct V0ReducedCandProducer { return false; } - const auto& cfgs = [&]() -> const auto& { - if constexpr (v0Type == kK0s) { - return v0Configs.k0sConfigs; - } else if constexpr (v0Type == kLambda || v0Type == kAntiLambda) { - return v0Configs.lambdaConfigs; - } - }(); + const float cutCosPA = (v0Type == kK0S) ? v0Configs.k0sConfigs.cosPAK0S : v0Configs.lambdaConfigs.cosPALambda; + const float cutMinPt = (v0Type == kK0S) ? v0Configs.k0sConfigs.minPtK0S : v0Configs.lambdaConfigs.minPtLambda; + const float cutCtau = (v0Type == kK0S) ? v0Configs.k0sConfigs.ctauK0S : v0Configs.lambdaConfigs.ctauLambda; - if (v0.v0cosPA() < cfgs.cosPA) { + if (v0.v0cosPA() < cutCosPA) { return false; } - if (v0.pt() < cfgs.minPt) { + if (v0.pt() < cutMinPt) { return false; } if (v0Configs.furtherV0Selection) { - constexpr float assumedMass = v0Type == kK0s ? MassK0S : MassLambda; - if (v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * assumedMass > cfgs.ctau) { + constexpr float assumedMass = v0Type == kK0S ? MassK0S : MassLambda; + if (v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * assumedMass > cutCtau) { return false; } - if constexpr (v0Type == kK0s) { - if (std::abs(v0.mLambda() - MassLambda) < cfgs.rejMass || - std::abs(v0.mAntiLambda() - MassLambda) < cfgs.rejMass) { + if constexpr (v0Type == kK0S) { + if (std::abs(v0.mLambda() - MassLambda) < v0Configs.k0sConfigs.rejMassK0S || + std::abs(v0.mAntiLambda() - MassLambda) < v0Configs.k0sConfigs.rejMassK0S) { return false; } - if (v0.qtarm() < (cfgs.paramArmenterosCut * std::abs(v0.alpha()))) { + if (v0.qtarm() < (v0Configs.k0sConfigs.paramArmenterosCutK0S * std::abs(v0.alpha()))) { return false; } } else { - if (std::abs(v0.mK0Short() - MassK0S) < cfgs.rejMass) { + if (std::abs(v0.mK0Short() - MassK0S) < v0Configs.lambdaConfigs.rejMassLambda) { return false; } } @@ -649,7 +645,7 @@ struct V0ReducedCandProducer { return; } - if constexpr (v0Type == kK0s) { + if constexpr (v0Type == kK0S) { k0sReducedCandidatesMcReco(collision.globalIndex(), v0.mK0Short(), v0McParticle.pt(), v0McParticle.y(), v0McParticle.phi()); } else if constexpr (v0Type == kLambda) { lambdaReducedCandidatesMcReco(collision.globalIndex(), v0.mLambda(), v0McParticle.pt(), v0McParticle.y(), v0McParticle.phi()); @@ -657,7 +653,7 @@ struct V0ReducedCandProducer { antilambdaReducedCandidatesMcReco(collision.globalIndex(), v0.mAntiLambda(), v0McParticle.pt(), v0McParticle.y(), v0McParticle.phi()); } } else { - if constexpr (v0Type == kK0s) { + if constexpr (v0Type == kK0S) { histos.fill(HIST("h3K0sCandidatesMass"), collision.centFT0M(), v0.pt(), v0.mK0Short()); k0sReducedCandidatesData(collision.globalIndex(), v0.mK0Short(), v0.pt(), v0.yK0Short(), v0.phi()); } else if constexpr (v0Type == kLambda) { @@ -682,17 +678,17 @@ struct V0ReducedCandProducer { void processData(FilteredSelCollisions::iterator const& collision, FullV0s const& V0s, V0DauTracks const&) { for (const auto& v0 : V0s) { - evaluateAllHypotheses(collision, v0); + evaluateAllHypotheses(collision, v0); } } - PROCESS_SWITCH(V0ReducedCandProducer, processData, "Process function to select reduced K0s candidates in Data or in McReco (w/o McTruth) analysis", true); + PROCESS_SWITCH(V0ReducedCandProducer, processData, "Process function to select reduced K0S candidates in Data or in McReco (w/o McTruth) analysis", true); // void processMCReco(SimCollisions::iterator const& collision, FullMCV0s const& V0s, V0DauMCTracks const&, aod::McParticles const& mcParticles) void processMCReco(FilteredSimCollisions::iterator const& collision, FullMCV0s const& V0s, V0DauMCTracks const&, aod::McParticles const& mcParticles) { for (const auto& v0 : V0s) { - evaluateAllHypotheses(collision, v0, mcParticles); + evaluateAllHypotheses(collision, v0, mcParticles); } } @@ -740,22 +736,22 @@ struct CascadeReducedCandProducer { Configurable yAcceptance{"yAcceptance", 0.5f, "Rapidity acceptance"}; struct : ConfigurableGroup { - Configurable v0CosPA{"v0CosPA", 0.98f, "V0 CosPA"}; - Configurable cosPA{"cosPA", 0.98f, "Cascade CosPA"}; - Configurable v0Radius{"v0Radius", 0.5f, "V0 decay radius"}; - Configurable radius{"radius", 0.5f, "Cascade decay radius"}; + Configurable v0CosPAXi{"v0CosPAXi", 0.98f, "Xi V0 CosPA"}; + Configurable cosPAXi{"cosPAXi", 0.98f, "Xi CosPA"}; + Configurable v0RadiusXi{"v0RadiusXi", 0.5f, "V0 decay radius"}; + Configurable radiusXi{"radiusXi", 0.5f, "Xi decay radius"}; - Configurable minPt{"minPt", 0.8f, "Cascade min pt"}; + Configurable minPtXi{"minPtXi", 0.8f, "Xi min pt"}; Configurable> binspTXi{"binspTXi", {0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for Xi"}; } xiConfigs; struct : ConfigurableGroup { - Configurable v0CosPA{"v0CosPA", 0.98f, "V0 CosPA"}; - Configurable cosPA{"cosPA", 0.98f, "Cascade CosPA"}; - Configurable v0Radius{"v0Radius", 0.5f, "V0 decay radius"}; - Configurable radius{"radius", 0.5f, "Cascade decay radius"}; + Configurable v0CosPAOmega{"v0CosPAOmega", 0.98f, "Omega V0 CosPA"}; + Configurable cosPAOmega{"cosPAOmega", 0.98f, "Omega CosPA"}; + Configurable v0RadiusOmega{"v0RadiusOmega", 0.5f, "V0 decay radius"}; + Configurable radiusOmega{"radiusOmega", 0.5f, "Omega decay radius"}; - Configurable minPt{"minPt", 0.8f, "Cascade min pt"}; + Configurable minPtOmega{"minPtOmega", 0.8f, "Omega min pt"}; Configurable> binspTOmega{"binspTOmega", {0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for Omega"}; } omegaConfigs; } cascadeConfigs; @@ -896,31 +892,29 @@ struct CascadeReducedCandProducer { return false; } - const auto& cfgs = [&]() -> const auto& { - if constexpr (cascadeType == kXi || cascadeType == kAntiXi) { - return cascadeConfigs.xiConfigs; - } else if constexpr (cascadeType == kOmega || cascadeType == kAntiOmega) { - return cascadeConfigs.omegaConfigs; - } - }(); + const float cutV0CosPA = (cascadeType == kXi || cascadeType == kAntiXi) ? cascadeConfigs.xiConfigs.v0CosPAXi : cascadeConfigs.omegaConfigs.v0CosPAOmega; + const float cutCosPA = (cascadeType == kXi || cascadeType == kAntiXi) ? cascadeConfigs.xiConfigs.cosPAXi : cascadeConfigs.omegaConfigs.cosPAOmega; + const float cutV0Radius = (cascadeType == kXi || cascadeType == kAntiXi) ? cascadeConfigs.xiConfigs.v0RadiusXi : cascadeConfigs.omegaConfigs.v0RadiusOmega; + const float cutRadius = (cascadeType == kXi || cascadeType == kAntiXi) ? cascadeConfigs.xiConfigs.radiusXi : cascadeConfigs.omegaConfigs.radiusOmega; + const float cutMinPt = (cascadeType == kXi || cascadeType == kAntiXi) ? cascadeConfigs.xiConfigs.minPtXi : cascadeConfigs.omegaConfigs.minPtOmega; const auto& pvx = collision.posX(); const auto& pvy = collision.posY(); const auto& pvz = collision.posZ(); - if (cascade.v0cosPA(pvx, pvy, pvz) < cfgs.v0CosPA) { + if (cascade.v0cosPA(pvx, pvy, pvz) < cutV0CosPA) { return false; } - if (cascade.casccosPA(pvx, pvy, pvz) < cfgs.cosPA) { + if (cascade.casccosPA(pvx, pvy, pvz) < cutCosPA) { return false; } - if (cascade.v0radius() < cfgs.v0Radius) { + if (cascade.v0radius() < cutV0Radius) { return false; } - if (cascade.cascradius() < cfgs.radius) { + if (cascade.cascradius() < cutRadius) { return false; } - if (cascade.pt() < cfgs.minPt) { + if (cascade.pt() < cutMinPt) { return false; } diff --git a/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx b/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx index 7f5b35b17da..3cdb2ead077 100644 --- a/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx +++ b/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx @@ -245,6 +245,7 @@ struct PhiStrangeCorrelation { Configurable useEffInterpolation{"useEffInterpolation", false, "If true, interpolates efficiency map, else uses bin center"}; Configurable applyPhiEfficiency{"applyPhiEfficiency", false, "Apply efficiency for Phi candidates"}; Configurable propagateEffError{"propagateEffError", false, "Propagate efficiency error"}; + Configurable perPeriodEfficiency{"perPeriodEfficiency", false, "Use per period efficiency maps"}; } efficiencyConfigs; // Configurable for event mixing @@ -329,6 +330,8 @@ struct PhiStrangeCorrelation { // Buffer for mixed event, organized as a vector of deques, one for each multiplicity bin, containing the past events with their particles of interest needed for mixing std::vector> eventBuffer; + int runNumber{-1}; + void init(InitContext&) { AxisSpec vertexZAxis = {100, -cutZVertex, cutZVertex, "vrtx_{Z} [cm]"}; // TO BE REMOVED @@ -419,7 +422,9 @@ struct PhiStrangeCorrelation { /*for (int i = 0; i < ParticleOfInterestSize; ++i) { loadEfficiencyMapFromCCDB(static_cast(i)); }*/ - loadEfficiencyMaps(); + if (!efficiencyConfigs.perPeriodEfficiency) { + loadEfficiencyMaps(); + } } eventBuffer.resize(binsMult->size() - 1); @@ -444,6 +449,25 @@ struct PhiStrangeCorrelation { LOG(fatal) << "Could not load efficiency map (neither TH3 nor TH2) for " << particleName << " from CCDB!"; } + void fetchSingleEfficiencyMapPerPeriodFromCCDB(EffMapPtr& effMap, std::string_view particleName, int runNumber) + { + std::string path = fmt::format("{}{}/{}", ccdbEfficiencyPath.value, particleName, runNumber); + + if (auto map3D = std::shared_ptr(ccdb->getForRun(path, runNumber))) { + effMap = map3D; + LOG(info) << "Efficiency map (TH3) for " << particleName << " loaded from CCDB for run " << runNumber; + return; + } + + if (auto map2D = std::shared_ptr(ccdb->getForRun(path, runNumber))) { + effMap = map2D; + LOG(info) << "Efficiency map (TH2) for " << particleName << " loaded from CCDB for run " << runNumber; + return; + } + + LOG(fatal) << "Could not load efficiency map (neither TH3 nor TH2) for " << particleName << " from CCDB for run " << runNumber; + } + void loadEfficiencyMaps() { // Load the Trigger (Phi) map if requested by analysis method @@ -459,6 +483,21 @@ struct PhiStrangeCorrelation { } } + void loadEfficiencyMapsPerPeriod(int runNumber) + { + // Load the Trigger (Phi) map if requested by analysis method + if (efficiencyConfigs.applyPhiEfficiency) { + fetchSingleEfficiencyMapPerPeriodFromCCDB(effMapPhi, "Phi", runNumber); + } + + // Only load the associated maps that are explicitly enabled + for (size_t i = 0; i < kAssocPartSize; ++i) { + if (activeCorrelationTypes->at(i)) { + fetchSingleEfficiencyMapPerPeriodFromCCDB(effMapsAssoc[i], AssocParticleLabels[i], runNumber); + } + } + } + // Compute weight based on efficiencies template std::pair computeWeightAndError(const BoundEffMaps&... boundEffMaps) @@ -711,157 +750,7 @@ struct PhiStrangeCorrelation { else fillSideband(); }); - - /*static_for<0, kPhiMassRegions - 1>([&](auto i_idx) { - constexpr unsigned int Idx = i_idx.value; - const auto& [minMassPhi, maxMassPhi] = phiMassRegions[Idx]; - if (!phiCand.inMassRegion(minMassPhi, maxMassPhi)) { - return; - } - - if constexpr (PartType == kK0S) { - if constexpr (IsME) { - if constexpr (Idx == kSignalRegion) - customFillTHn(HIST("phiK0S/h5PhiK0SDataMESignal"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); - else - customFillTHn(HIST("phiK0S/h5PhiK0SDataMESideband"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); - } else { - if constexpr (Idx == kSignalRegion) - customFillTHn(HIST("phiK0S/h5PhiK0SDataSignal"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); - else - customFillTHn(HIST("phiK0S/h5PhiK0SDataSideband"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); - } - } else if constexpr (PartType == kXi) { - if constexpr (IsME) { - if constexpr (Idx == kSignalRegion) - customFillTHn(HIST("phiXi/h5PhiXiDataMESignal"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); - else - customFillTHn(HIST("phiXi/h5PhiXiDataMESideband"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); - } else { - if constexpr (Idx == kSignalRegion) - customFillTHn(HIST("phiXi/h5PhiXiDataSignal"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); - else - customFillTHn(HIST("phiXi/h5PhiXiDataSideband"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); - } - } else if constexpr (PartType == kPion) { - if constexpr (IsME) { - if constexpr (Idx == kSignalRegion) - customFillTHn(HIST("phiPi/h5PhiPiDataMESignal"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); - else - customFillTHn(HIST("phiPi/h5PhiPiDataMESideband"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); - } else { - if constexpr (Idx == kSignalRegion) - customFillTHn(HIST("phiPi/h5PhiPiDataSignal"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); - else - customFillTHn(HIST("phiPi/h5PhiPiDataSideband"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); - } - } - });*/ } - - /*if (analysisMode == kMassvsMass) { - auto fillMass = [&](auto histID, auto assocVal) { - customFillTHn(histID, weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), phiCand.m(), assocVal); - }; - - if constexpr (PartType == kK0S) { - if constexpr (IsME) { - fillMass(HIST("phiK0S/h6PhiK0SDataME"), assoc.m()); - } else { - fillMass(HIST("phiK0S/h6PhiK0SData"), assoc.m()); - } - } else if constexpr (PartType == kXi) { - if constexpr (IsME) { - fillMass(HIST("phiXi/h6PhiXiDataME"), assoc.m()); - } else { - fillMass(HIST("phiXi/h6PhiXiData"), assoc.m()); - } - } else if constexpr (PartType == kPion) { - if constexpr (IsME) { - fillMass(HIST("phiPi/h6PhiPiTPCDataME"), assoc.nSigmaTPC()); - fillMass(HIST("phiPi/h6PhiPiTOFDataME"), assoc.nSigmaTOF()); - } else { - fillMass(HIST("phiPi/h6PhiPiTPCData"), assoc.nSigmaTPC()); - fillMass(HIST("phiPi/h6PhiPiTOFData"), assoc.nSigmaTOF()); - } - } - } else if (analysisMode == kDeltaYvsDeltaPhi) { - static_for<0, kPhiMassRegions - 1>([&](auto i_idx) { - constexpr unsigned int Idx = i_idx.value; - const auto& [minMassPhi, maxMassPhi] = phiMassRegions[Idx]; - if (!phiCand.inMassRegion(minMassPhi, maxMassPhi)) { - return; - } - - auto fillDelta = [&](auto histID) { - customFillTHn(histID, weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); - }; - - if constexpr (PartType == kK0S) { - if constexpr (IsME) { - if constexpr (Idx == kSignalRegion) - fillDelta(HIST("phiK0S/h5PhiK0SDataMESignal")); - else - fillDelta(HIST("phiK0S/h5PhiK0SDataMESideband")); - } else { - if constexpr (Idx == kSignalRegion) - fillDelta(HIST("phiK0S/h5PhiK0SDataSignal")); - else - fillDelta(HIST("phiK0S/h5PhiK0SDataSideband")); - } - } else if constexpr (PartType == kXi) { - if constexpr (IsME) { - if constexpr (Idx == kSignalRegion) - fillDelta(HIST("phiXi/h5PhiXiDataMESignal")); - else - fillDelta(HIST("phiXi/h5PhiXiDataMESideband")); - } else { - if constexpr (Idx == kSignalRegion) - fillDelta(HIST("phiXi/h5PhiXiDataSignal")); - else - fillDelta(HIST("phiXi/h5PhiXiDataSideband")); - } - } else if constexpr (PartType == kPion) { - if constexpr (IsME) { - if constexpr (Idx == kSignalRegion) - fillDelta(HIST("phiPi/h5PhiPiDataMESignal")); - else - fillDelta(HIST("phiPi/h5PhiPiDataMESideband")); - } else { - if constexpr (Idx == kSignalRegion) - fillDelta(HIST("phiPi/h5PhiPiDataSignal")); - else - fillDelta(HIST("phiPi/h5PhiPiDataSideband")); - } - }*/ - - /*if constexpr (PartType == kK0S) { - if constexpr (IsME) { - auto t = std::make_tuple(HIST("phiK0S/h5PhiK0SDataMESignal"), HIST("phiK0S/h5PhiK0SDataMESideband")); - fillDelta(std::get(t)); - } else { - auto t = std::make_tuple(HIST("phiK0S/h5PhiK0SDataSignal"), HIST("phiK0S/h5PhiK0SDataSideband")); - fillDelta(std::get(t)); - } - } else if constexpr (PartType == kXi) { - if constexpr (IsME) { - auto t = std::make_tuple(HIST("phiXi/h5PhiXiDataMESignal"), HIST("phiXi/h5PhiXiDataMESideband")); - fillDelta(std::get(t)); - } else { - auto t = std::make_tuple(HIST("phiXi/h5PhiXiDataSignal"), HIST("phiXi/h5PhiXiDataSideband")); - fillDelta(std::get(t)); - } - } else if constexpr (PartType == kPion) { - if constexpr (IsME) { - auto t = std::make_tuple(HIST("phiPi/h5PhiPiDataMESignal"), HIST("phiPi/h5PhiPiDataMESideband")); - fillDelta(std::get(t)); - } else { - auto t = std::make_tuple(HIST("phiPi/h5PhiPiDataSignal"), HIST("phiPi/h5PhiPiDataSideband")); - fillDelta(std::get(t)); - } - }*/ - //}); - //} } template @@ -892,6 +781,12 @@ struct PhiStrangeCorrelation { { float multiplicity = collision.centFT0M(); + auto bc = collision.template bc_as(); + + if (efficiencyConfigs.applyEfficiency && efficiencyConfigs.perPeriodEfficiency) { + loadEfficiencyMapsPerPeriod(bc.runNumber()); + } + for (const auto& phiCand : phiCandidates) { if (efficiencyConfigs.applyEfficiency && efficiencyConfigs.applyPhiEfficiency && phiCand.pt() >= binspTPhi->back()) { continue; @@ -909,7 +804,8 @@ struct PhiStrangeCorrelation { aod::PhimesonCandidatesData const& phiCandidates, aod::K0sReducedCandidatesData const& k0sReduced, aod::XiReducedCandidatesData const& xiReduced, - aod::PionTracksData const& pionTracks) + aod::PionTracksData const& pionTracks, + aod::BCs const&) { processPhiAssocSE(collision, phiCandidates, makeAssocInput(k0sReduced), @@ -1006,394 +902,6 @@ struct PhiStrangeCorrelation { PROCESS_SWITCH(PhiStrangeCorrelation, processPhiPionMEMCWithPDG, "Process function for Phi-Pion 2D Correlations in MC with PDG ME", true); - /*template - void processPhiAssocSE(TCollision const& collision, TPhiCands const& phiCandidates, TK0SCands const& k0sReduced, TXiCands const& xiReduced, TPionCands const& pionTracks) - { - float multiplicity = collision.centFT0M(); - - const std::array, 2> phiMassRegions = {phiConfigs.rangeMPhiSignal, phiConfigs.rangeMPhiSideband}; - - const bool applyK0sMassCut = (analysisMode == kDeltaYvsDeltaPhi) && k0sConfigs.selectK0sInSigRegion; - const auto& [minMassK0s, maxMassK0s] = k0sConfigs.rangeMK0sSignal.value; - auto isK0sValid = [&](const auto& k0s) { - return (!efficiencyConfigs.applyEfficiency || k0s.pt() < binspTK0S->back()) && (!applyK0sMassCut || k0s.inMassRegion(minMassK0s, maxMassK0s)); - }; - - const bool applyXiMassCut = (analysisMode == kDeltaYvsDeltaPhi) && xiConfigs.selectXiInSigRegion; - const auto& [minMassXi, maxMassXi] = xiConfigs.rangeMXiSignal.value; - auto isXiValid = [&](const auto& xi) { - return (!efficiencyConfigs.applyEfficiency || xi.pt() < binspTXi->back()) && (!applyXiMassCut || xi.inMassRegion(minMassXi, maxMassXi)); - }; - - const bool applyPionNSigmaCut = (analysisMode == kDeltaYvsDeltaPhi) && pionConfigs.selectPionInSigRegion; - const float& pidTPCMax = pionConfigs.pidTPCMax; - const float& pidTOFMax = pionConfigs.pidTOFMax; - // const float& tofPIDThreshold = pionConfigs.tofPIDThreshold; - - auto isPionValid = [&](const auto& pion) { - return (!efficiencyConfigs.applyEfficiency || pion.pt() < binspTPi->back()) && (!applyPionNSigmaCut || pion.inNSigmaRegion(pidTPCMax, pidTOFMax)); - }; - - for (const auto& phiCand : phiCandidates) { - if (efficiencyConfigs.applyEfficiency && efficiencyConfigs.applyPhiEfficiency && phiCand.pt() >= binspTPhi->back()) - continue; - - auto weightPhi = computeWeightAndError(BoundEfficiencyMap(effMapPhi, multiplicity, phiCand.pt(), phiCand.y())); - - // histos.fill(HIST("phi/h3PhiData"), multiplicity, phiCand.pt(), phiCand.m(), weightPhi); - customFillHist(HIST("phi/h3PhiData"), weightPhi, multiplicity, phiCand.pt(), phiCand.m()); - - auto processCorrelations = [&](auto fillK0S, auto fillXi, auto fillPion) { - if (activeCorrelationTypes->at(kK0S)) { - // Loop over all reduced K0S candidates - for (const auto& k0s : k0sReduced) { - if (!isK0sValid(k0s)) - continue; - - // auto weightPhiK0S = computeWeightAndError(BoundEfficiencyMap(effMapPhi, multiplicity, phiCand.pt(), phiCand.y()), - // BoundEfficiencyMap(effMapsAssoc[kK0S], multiplicity, k0s.pt(), k0s.y())); - - fillK0S(k0s, computeAssocWeight(multiplicity, phiCand, k0s)); - } - } - - if (activeCorrelationTypes->at(kXi)) { - // Loop over all reduced Xi candidates - for (const auto& xi : xiReduced) { - if (!isXiValid(xi)) - continue; - - // auto weightPhiXi = computeWeightAndError(BoundEfficiencyMap(effMapPhi, multiplicity, phiCand.pt(), phiCand.y()), - // BoundEfficiencyMap(effMapsAssoc[kXi], multiplicity, xi.pt(), xi.y())); - - fillXi(xi, computeAssocWeight(multiplicity, phiCand, xi)); - } - } - - if (activeCorrelationTypes->at(kPion)) { - // Loop over all primary pion candidates - for (const auto& pionTrack : pionTracks) { - if (!isPionValid(pionTrack)) - continue; - - // auto weightPhiPion = computeWeightAndError(BoundEfficiencyMap(effMapPhi, multiplicity, phiCand.pt(), phiCand.y()), - // BoundEfficiencyMap(effMapsAssoc[kPion], multiplicity, pionTrack.pt(), pionTrack.y())); - - fillPion(pionTrack, computeAssocWeight(multiplicity, phiCand, pionTrack)); - } - } - }; - - if (analysisMode == kMassvsMass) { - auto k0sHistID = HIST("phiK0S/h6PhiK0SData"); - auto xiHistID = HIST("phiXi/h6PhiXiData"); - auto piTPCHistID = HIST("phiPi/h6PhiPiTPCData"); - auto piTOFHistID = HIST("phiPi/h6PhiPiTOFData"); - - processCorrelations( - //[&](const auto& k0s, float w) { - // histos.fill(k0sHistID, multiplicity, phiCand.pt(), k0s.pt(), phiCand.y() - k0s.y(), phiCand.m(), k0s.m(), w); - [&](const auto& k0s, const std::pair& w) { - customFillTHn(k0sHistID, w, multiplicity, phiCand.pt(), k0s.pt(), phiCand.y() - k0s.y(), phiCand.m(), k0s.m()); - }, - //[&](const auto& xi, float w) { - [&](const auto& xi, const std::pair& w) { - customFillTHn(xiHistID, w, multiplicity, phiCand.pt(), xi.pt(), phiCand.y() - xi.y(), phiCand.m(), xi.m()); - }, - //[&](const auto& pion, float w) { - // histos.fill(piTPCHistID, multiplicity, phiCand.pt(), pion.pt(), phiCand.y() - pion.y(), phiCand.m(), pion.nSigmaTPC(), w); - // histos.fill(piTOFHistID, multiplicity, phiCand.pt(), pion.pt(), phiCand.y() - pion.y(), phiCand.m(), pion.nSigmaTOF(), w); - [&](const auto& pion, const std::pair& w) { - customFillTHn(piTPCHistID, w, multiplicity, phiCand.pt(), pion.pt(), phiCand.y() - pion.y(), phiCand.m(), pion.nSigmaTPC()); - customFillTHn(piTOFHistID, w, multiplicity, phiCand.pt(), pion.pt(), phiCand.y() - pion.y(), phiCand.m(), pion.nSigmaTOF()); - }); - } else if (analysisMode == kDeltaYvsDeltaPhi) { - auto k0sHistID = std::make_tuple(HIST("phiK0S/h5PhiK0SDataSignal"), HIST("phiK0S/h5PhiK0SDataSideband")); - auto xiHistID = std::make_tuple(HIST("phiXi/h5PhiXiDataSignal"), HIST("phiXi/h5PhiXiDataSideband")); - auto piHistID = std::make_tuple(HIST("phiPi/h5PhiPiDataSignal"), HIST("phiPi/h5PhiPiDataSideband")); - - static_for<0, kPhiMassRegions - 1>([&](auto i_idx) { - constexpr unsigned int Idx = i_idx.value; - - const auto& [minMassPhi, maxMassPhi] = phiMassRegions[Idx]; - if (!phiCand.inMassRegion(minMassPhi, maxMassPhi)) - return; - - // auto k0sHistID = HIST("phiK0S/h5PhiK0SData") + HIST(PhiMassRegionLabels[Idx]); - // auto piHistID = HIST("phiPi/h5PhiPiData") + HIST(PhiMassRegionLabels[Idx]); - - processCorrelations( - //[&](const auto& k0s, float w) { - // histos.fill(std::get(k0sHistID), multiplicity, phiCand.pt(), k0s.pt(), phiCand.y() - k0s.y(), getDeltaPhi(phiCand.phi(), k0s.phi()), w); - [&](const auto& k0s, const std::pair& w) { - customFillTHn(std::get(k0sHistID), w, multiplicity, phiCand.pt(), k0s.pt(), phiCand.y() - k0s.y(), getDeltaPhi(phiCand.phi(), k0s.phi())); - }, - //[&](const auto& xi, float w) { - // histos.fill(std::get(xiHistID), multiplicity, phiCand.pt(), xi.pt(), phiCand.y() - xi.y(), getDeltaPhi(phiCand.phi(), xi.phi()), w); - [&](const auto& xi, const std::pair& w) { - customFillTHn(std::get(xiHistID), w, multiplicity, phiCand.pt(), xi.pt(), phiCand.y() - xi.y(), getDeltaPhi(phiCand.phi(), xi.phi())); - }, - //[&](const auto& pion, float w) { - // histos.fill(std::get(piHistID), multiplicity, phiCand.pt(), pion.pt(), phiCand.y() - pion.y(), getDeltaPhi(phiCand.phi(), pion.phi()), w); - [&](const auto& pion, const std::pair& w) { - customFillTHn(std::get(piHistID), w, multiplicity, phiCand.pt(), pion.pt(), phiCand.y() - pion.y(), getDeltaPhi(phiCand.phi(), pion.phi())); - }); - }); - } - } - } - - void processPhiAssocSEDataLike(SelCollisions::iterator const& collision, aod::PhimesonCandidatesData const& phiCandidates, aod::K0sReducedCandidatesData const& k0sReduced, aod::XiReducedCandidatesData const& xiReduced, aod::PionTracksData const& pionTracks) - { - processPhiAssocSE(collision, phiCandidates, k0sReduced, xiReduced, pionTracks); - } - - PROCESS_SWITCH(PhiStrangeCorrelation, processPhiAssocSEDataLike, "Process function for Phi-Associated 2D Correlations in Data or MC w/o PDG SE", true); - - void processPhiAssocSEMCWithPDG(SimCollisions::iterator const& collision, aod::PhimesonCandidatesMcReco const& phiCandidates, aod::K0sReducedCandidatesMcReco const& k0sReduced, aod::XiReducedCandidatesMcReco const& xiReduced, aod::PionTracksMcReco const& pionTracks) - { - processPhiAssocSE(collision, phiCandidates, k0sReduced, xiReduced, pionTracks); - } - - PROCESS_SWITCH(PhiStrangeCorrelation, processPhiAssocSEMCWithPDG, "Process function for Phi-Associated 2D Correlations in MC with PDG SE", true); - - template - void processPhiK0SME(TCollisions const& collisions, TPhiCands const& phiCandidates, TK0SCands const& k0sReduced) - { - const std::array, 2> phiMassRegions = {phiConfigs.rangeMPhiSignal, phiConfigs.rangeMPhiSideband}; - - const bool applyK0sMassCut = (analysisMode == kDeltaYvsDeltaPhi) && k0sConfigs.selectK0sInSigRegion; - const auto& [minMassK0s, maxMassK0s] = k0sConfigs.rangeMK0sSignal.value; - - auto isK0sValid = [&](const auto& k0s) { - return (!efficiencyConfigs.applyEfficiency || k0s.pt() < binspTK0S->back()) && (!applyK0sMassCut || k0s.inMassRegion(minMassK0s, maxMassK0s)); - }; - - auto tuplePhiK0S = std::make_tuple(phiCandidates, k0sReduced); - Pair pairPhiK0S{binningOnVertexAndCent, cfgNoMixedEvents, -1, collisions, tuplePhiK0S, &cache}; - - for (const auto& [c1, phiCands, c2, k0sRed] : pairPhiK0S) { - - float multiplicity = c1.centFT0M(); - - for (const auto& [phiCand, k0s] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(phiCands, k0sRed))) { - if (efficiencyConfigs.applyEfficiency && efficiencyConfigs.applyPhiEfficiency && phiCand.pt() >= binspTPhi->back()) - continue; - if (!isK0sValid(k0s)) - continue; - - auto processCorrelations = [&](auto fillK0S) { - // auto weightPhiK0S = computeWeightAndError(BoundEfficiencyMap(effMapPhi, multiplicity, phiCand.pt(), phiCand.y()), - // BoundEfficiencyMap(effMapsAssoc[kK0S], multiplicity, k0s.pt(), k0s.y())); - fillK0S(k0s, computeAssocWeight(multiplicity, phiCand, k0s)); - }; - - if (analysisMode == kMassvsMass) { - auto k0sHistID = HIST("phiK0S/h6PhiK0SDataME"); - - processCorrelations( - //[&](const auto& k0s, float w) { - // histos.fill(k0sHistID, multiplicity, phiCand.pt(), k0s.pt(), phiCand.y() - k0s.y(), phiCand.m(), k0s.m(), w); - [&](const auto& k0s, const std::pair& w) { - customFillTHn(k0sHistID, w, multiplicity, phiCand.pt(), k0s.pt(), phiCand.y() - k0s.y(), phiCand.m(), k0s.m()); - }); - } else if (analysisMode == kDeltaYvsDeltaPhi) { - auto k0sHistID = std::make_tuple(HIST("phiK0S/h5PhiK0SDataMESignal"), HIST("phiK0S/h5PhiK0SDataMESideband")); - - static_for<0, kPhiMassRegions - 1>([&](auto i_idx) { - constexpr unsigned int Idx = i_idx.value; - - const auto& [minMassPhi, maxMassPhi] = phiMassRegions[Idx]; - if (!phiCand.inMassRegion(minMassPhi, maxMassPhi)) - return; - - processCorrelations( - //[&](const auto& k0s, float w) { - // histos.fill(std::get(k0sHistID), multiplicity, phiCand.pt(), k0s.pt(), phiCand.y() - k0s.y(), getDeltaPhi(phiCand.phi(), k0s.phi()), w); - [&](const auto& k0s, const std::pair& w) { - customFillTHn(std::get(k0sHistID), w, multiplicity, phiCand.pt(), k0s.pt(), phiCand.y() - k0s.y(), getDeltaPhi(phiCand.phi(), k0s.phi())); - }); - }); - } - } - } - } - - // PROCESS_SWITCH(PhiStrangeCorrelation, processPhiK0SME, "Process function for Phi-K0S and Deltay and Deltaphi 2D Correlations in Data ME", false); - - void processPhiK0SMEDataLike(SelCollisions const& collisions, aod::PhimesonCandidatesData const& phiCandidates, aod::K0sReducedCandidatesData const& k0sReduced) - { - processPhiK0SME(collisions, phiCandidates, k0sReduced); - } - - PROCESS_SWITCH(PhiStrangeCorrelation, processPhiK0SMEDataLike, "Process function for Phi-K0S 2D Correlations in Data or MC w/o PDG ME", true); - - void processPhiK0SMEMCWithPDG(SimCollisions const& collisions, aod::PhimesonCandidatesMcReco const& phiCandidates, aod::K0sReducedCandidatesMcReco const& k0sReduced) - { - processPhiK0SME(collisions, phiCandidates, k0sReduced); - } - - PROCESS_SWITCH(PhiStrangeCorrelation, processPhiK0SMEMCWithPDG, "Process function for Phi-K0S 2D Correlations in MC with PDG ME", true); - - template - void processPhiXiME(TCollisions const& collisions, TPhiCands const& phiCandidates, TXiCands const& xiReduced) - { - const std::array, 2> phiMassRegions = {phiConfigs.rangeMPhiSignal, phiConfigs.rangeMPhiSideband}; - - const bool applyXiMassCut = (analysisMode == kDeltaYvsDeltaPhi) && xiConfigs.selectXiInSigRegion; - const auto& [minMassXi, maxMassXi] = xiConfigs.rangeMXiSignal.value; - - auto isXiValid = [&](const auto& xi) { - return (!efficiencyConfigs.applyEfficiency || xi.pt() < binspTXi->back()) && (!applyXiMassCut || xi.inMassRegion(minMassXi, maxMassXi)); - }; - - auto tuplePhiXi = std::make_tuple(phiCandidates, xiReduced); - Pair pairPhiXi{binningOnVertexAndCent, cfgNoMixedEvents, -1, collisions, tuplePhiXi, &cache}; - - for (const auto& [c1, phiCands, c2, xiRed] : pairPhiXi) { - - float multiplicity = c1.centFT0M(); - - for (const auto& [phiCand, xi] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(phiCands, xiRed))) { - if (efficiencyConfigs.applyEfficiency && efficiencyConfigs.applyPhiEfficiency && phiCand.pt() >= binspTPhi->back()) - continue; - if (!isXiValid(xi)) - continue; - - auto processCorrelations = [&](auto fillXi) { - // auto weightPhiXi = computeWeightAndError(BoundEfficiencyMap(effMapPhi, multiplicity, phiCand.pt(), phiCand.y()), - // BoundEfficiencyMap(effMapsAssoc[kXi], multiplicity, xi.pt(), xi.y())); - fillXi(xi, computeAssocWeight(multiplicity, phiCand, xi)); - }; - - if (analysisMode == kMassvsMass) { - auto xiHistID = HIST("phiXi/h6PhiXiDataME"); - - processCorrelations( - //[&](const auto& xi, float w) { - // histos.fill(xiHistID, multiplicity, phiCand.pt(), xi.pt(), phiCand.y() - xi.y(), phiCand.m(), xi.m(), w); - [&](const auto& xi, const std::pair& w) { - customFillTHn(xiHistID, w, multiplicity, phiCand.pt(), xi.pt(), phiCand.y() - xi.y(), phiCand.m(), xi.m()); - }); - } else if (analysisMode == kDeltaYvsDeltaPhi) { - auto xiHistID = std::make_tuple(HIST("phiXi/h5PhiXiDataMESignal"), HIST("phiXi/h5PhiXiDataMESideband")); - - static_for<0, kPhiMassRegions - 1>([&](auto i_idx) { - constexpr unsigned int Idx = i_idx.value; - - const auto& [minMassPhi, maxMassPhi] = phiMassRegions[Idx]; - if (!phiCand.inMassRegion(minMassPhi, maxMassPhi)) - return; - - processCorrelations( - //[&](const auto& xi, float w) { - // histos.fill(std::get(xiHistID), multiplicity, phiCand.pt(), xi.pt(), phiCand.y() - xi.y(), getDeltaPhi(phiCand.phi(), xi.phi()), w); - [&](const auto& xi, const std::pair& w) { - customFillTHn(std::get(xiHistID), w, multiplicity, phiCand.pt(), xi.pt(), phiCand.y() - xi.y(), getDeltaPhi(phiCand.phi(), xi.phi())); - }); - }); - } - } - } - } - - void processPhiXiMEDataLike(SelCollisions const& collisions, aod::PhimesonCandidatesData const& phiCandidates, aod::XiReducedCandidatesData const& xiReduced) - { - processPhiXiME(collisions, phiCandidates, xiReduced); - } - - PROCESS_SWITCH(PhiStrangeCorrelation, processPhiXiMEDataLike, "Process function for Phi-Xi 2D Correlations in Data or MC w/o PDG ME", true); - - void processPhiXiMEMCWithPDG(SimCollisions const& collisions, aod::PhimesonCandidatesMcReco const& phiCandidates, aod::XiReducedCandidatesMcReco const& xiReduced) - { - processPhiXiME(collisions, phiCandidates, xiReduced); - } - - PROCESS_SWITCH(PhiStrangeCorrelation, processPhiXiMEMCWithPDG, "Process function for Phi-Xi 2D Correlations in MC with PDG ME", true); - - template - void processPhiPionME(TCollisions const& collisions, TPhiCands const& phiCandidates, TPionCands const& pionTracks) - { - const std::array, 2> phiMassRegions = {phiConfigs.rangeMPhiSignal, phiConfigs.rangeMPhiSideband}; - - const bool applyPionNSigmaCut = (analysisMode == kDeltaYvsDeltaPhi) && pionConfigs.selectPionInSigRegion; - const float& pidTPCMax = pionConfigs.pidTPCMax; - const float& pidTOFMax = pionConfigs.pidTOFMax; - // const float& tofPIDThreshold = pionConfigs.tofPIDThreshold; - - auto isPionValid = [&](const auto& pion) { - return (!efficiencyConfigs.applyEfficiency || pion.pt() < binspTPi->back()) && (!applyPionNSigmaCut || pion.inNSigmaRegion(pidTPCMax, pidTOFMax)); - }; - - auto tuplePhiPion = std::make_tuple(phiCandidates, pionTracks); - Pair pairPhiPion{binningOnVertexAndCent, cfgNoMixedEvents, -1, collisions, tuplePhiPion, &cache}; - - for (const auto& [c1, phiCands, c2, piTracks] : pairPhiPion) { - - float multiplicity = c1.centFT0M(); - - for (const auto& [phiCand, piTrack] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(phiCands, piTracks))) { - if (efficiencyConfigs.applyEfficiency && efficiencyConfigs.applyPhiEfficiency && phiCand.pt() >= binspTPhi->back()) - continue; - if (!isPionValid(piTrack)) - continue; - - auto processCorrelations = [&](auto fillPion) { - // auto weightPhiPion = computeWeightAndError(BoundEfficiencyMap(effMapPhi, multiplicity, phiCand.pt(), phiCand.y()), - // BoundEfficiencyMap(effMapsAssoc[kPion], multiplicity, piTrack.pt(), piTrack.y())); - fillPion(piTrack, computeAssocWeight(multiplicity, phiCand, piTrack)); - }; - - if (analysisMode == kMassvsMass) { - auto piTPCHistID = HIST("phiPi/h6PhiPiTPCDataME"); - auto piTOFHistID = HIST("phiPi/h6PhiPiTOFDataME"); - - processCorrelations( - //[&](const auto& pion, float w) { - // histos.fill(piTPCHistID, multiplicity, phiCand.pt(), pion.pt(), phiCand.y() - pion.y(), phiCand.m(), pion.nSigmaTPC(), w); - // histos.fill(piTOFHistID, multiplicity, phiCand.pt(), pion.pt(), phiCand.y() - pion.y(), phiCand.m(), pion.nSigmaTOF(), w); - [&](const auto& pion, const std::pair& w) { - customFillTHn(piTPCHistID, w, multiplicity, phiCand.pt(), pion.pt(), phiCand.y() - pion.y(), phiCand.m(), pion.nSigmaTPC()); - customFillTHn(piTOFHistID, w, multiplicity, phiCand.pt(), pion.pt(), phiCand.y() - pion.y(), phiCand.m(), pion.nSigmaTOF()); - }); - } else if (analysisMode == kDeltaYvsDeltaPhi) { - auto piHistID = std::make_tuple(HIST("phiPi/h5PhiPiDataMESignal"), HIST("phiPi/h5PhiPiDataMESideband")); - - static_for<0, kPhiMassRegions - 1>([&](auto i_idx) { - constexpr unsigned int Idx = i_idx.value; - - const auto& [minMassPhi, maxMassPhi] = phiMassRegions[Idx]; - if (!phiCand.inMassRegion(minMassPhi, maxMassPhi)) - return; - - processCorrelations( - //[&](const auto& pion, float w) { - // histos.fill(std::get(piHistID), multiplicity, phiCand.pt(), pion.pt(), phiCand.y() - pion.y(), getDeltaPhi(phiCand.phi(), pion.phi()), w); - [&](const auto& pion, const std::pair& w) { - customFillTHn(std::get(piHistID), w, multiplicity, phiCand.pt(), pion.pt(), phiCand.y() - pion.y(), getDeltaPhi(phiCand.phi(), pion.phi())); - }); - }); - } - } - } - } - - // PROCESS_SWITCH(PhiStrangeCorrelation, processPhiPionME, "Process function for Phi-Pion Deltay and Deltaphi 2D Correlations in Data ME", false); - - void processPhiPionMEDataLike(SelCollisions const& collisions, aod::PhimesonCandidatesData const& phiCandidates, aod::PionTracksData const& pionTracks) - { - processPhiPionME(collisions, phiCandidates, pionTracks); - } - - PROCESS_SWITCH(PhiStrangeCorrelation, processPhiPionMEDataLike, "Process function for Phi-Pion 2D Correlations in Data or MC w/o PDG ME", true); - - void processPhiPionMEMCWithPDG(SimCollisions const& collisions, aod::PhimesonCandidatesMcReco const& phiCandidates, aod::PionTracksMcReco const& pionTracks) - { - processPhiPionME(collisions, phiCandidates, pionTracks); - } - - PROCESS_SWITCH(PhiStrangeCorrelation, processPhiPionMEMCWithPDG, "Process function for Phi-Pion 2D Correlations in MC with PDG ME", true);*/ - void processParticleEfficiency(MCCollisions const& mcCollisions, SimCollisions const& collisions, aod::PhimesonCandidatesMcReco const& phiCandidates, @@ -1401,27 +909,6 @@ struct PhiStrangeCorrelation { aod::XiReducedCandidatesMcReco const& xiReduced, aod::PionTracksMcReco const& pionTracks, aod::McParticles const& mcParticles) { - /*const bool applyK0sMassCut = (analysisMode == kDeltaYvsDeltaPhi) && k0sConfigs.selectK0sInSigRegion; - const auto& [minMassK0s, maxMassK0s] = k0sConfigs.rangeMK0sSignal.value; - auto isK0sValid = [&](const auto& k0s) { - return !applyK0sMassCut || k0s.inMassRegion(minMassK0s, maxMassK0s); - }; - - const bool applyXiMassCut = (analysisMode == kDeltaYvsDeltaPhi) && xiConfigs.selectXiInSigRegion; - const auto& [minMassXi, maxMassXi] = xiConfigs.rangeMXiSignal.value; - auto isXiValid = [&](const auto& xi) { - return !applyXiMassCut || xi.inMassRegion(minMassXi, maxMassXi); - }; - - const bool applyPionNSigmaCut = (analysisMode == kDeltaYvsDeltaPhi) && pionConfigs.selectPionInSigRegion; - const float& pidTPCMax = pionConfigs.pidTPCMax; - const float& pidTOFMax = pionConfigs.pidTOFMax; - // const float& tofPIDThreshold = pionConfigs.tofPIDThreshold; - - auto isPionValid = [&](const auto& pion) { - return !applyPionNSigmaCut || pion.inNSigmaRegion(pidTPCMax, pidTOFMax); - };*/ - std::unordered_map> collsGrouped; collsGrouped.reserve(mcCollisions.size()); @@ -1480,31 +967,6 @@ struct PhiStrangeCorrelation { fillRecoAssocSpecies(makeAssocInput(xiReduced), HIST("xi/h4XiMCReco")); fillRecoAssocSpecies(makeAssocInput(pionTracks), HIST("pi/h4PiMCReco")); - /*const auto k0sThisColl = k0sReduced.sliceBy(preslices.k0sMcRecoPerCollision, collision.globalIndex()); - const auto xiThisColl = xiReduced.sliceBy(preslices.xiMcRecoPerCollision, collision.globalIndex()); - const auto pionTracksThisColl = pionTracks.sliceBy(preslices.pionTrackMcRecoPerCollision, collision.globalIndex()); - - for (const auto& k0s : k0sThisColl) { - if (!isAssocValid(k0s)) - continue; - - histos.fill(HIST("k0s/h4K0SMCReco"), collision.posZ(), mcCollision.centFT0M(), k0s.pt(), k0s.y()); - } - - for (const auto& xi : xiThisColl) { - if (!isAssocValid(xi)) - continue; - - histos.fill(HIST("xi/h4XiMCReco"), collision.posZ(), mcCollision.centFT0M(), xi.pt(), xi.y()); - } - - for (const auto& pionTrack : pionTracksThisColl) { - if (!isAssocValid(pionTrack)) - continue; - - histos.fill(HIST("pi/h4PiMCReco"), collision.posZ(), mcCollision.centFT0M(), pionTrack.pt(), pionTrack.y()); - }*/ - numberAssocColls++; } } From fea3e9dfd814ec12d29aacce04a9cc2107c9065e Mon Sep 17 00:00:00 2001 From: scannito Date: Wed, 23 Sep 2026 13:39:17 +0200 Subject: [PATCH 3/5] Introduced per-run efficiency fetching --- .../Strangeness/phiStrangeCorrelation.cxx | 95 ++++++++++++++++--- 1 file changed, 80 insertions(+), 15 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx b/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx index 3cdb2ead077..2e5e6398308 100644 --- a/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx +++ b/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx @@ -55,6 +55,7 @@ #include #include #include +#include #include #include #include @@ -330,7 +331,7 @@ struct PhiStrangeCorrelation { // Buffer for mixed event, organized as a vector of deques, one for each multiplicity bin, containing the past events with their particles of interest needed for mixing std::vector> eventBuffer; - int runNumber{-1}; + int mLastRunNumber{-1}; void init(InitContext&) { @@ -430,7 +431,32 @@ struct PhiStrangeCorrelation { eventBuffer.resize(binsMult->size() - 1); } - void fetchSingleEfficiencyMapFromCCDB(EffMapPtr& effMap, std::string_view particleName) + void fetchSingleEfficiencyMapFromCCDB(EffMapPtr& effMap, std::string_view particleName, std::optional runNumber = std::nullopt) + { + std::string path = fmt::format("{}{}", ccdbEfficiencyPath.value, particleName); + + auto fetchFromCCDB = [&]() -> std::shared_ptr { + auto mapPtr = runNumber ? ccdb->getForRun(path, *runNumber) : ccdb->get(path); + return std::shared_ptr(mapPtr); + }; + + if (auto map3D = fetchFromCCDB.operator()()) { + effMap = map3D; + LOG(debug) << "Efficiency map (TH3) for " << particleName << " loaded from CCDB"; + return; + } + + if (auto map2D = fetchFromCCDB.operator()()) { + effMap = map2D; + LOG(debug) << "Efficiency map (TH2) for " << particleName << " loaded from CCDB"; + return; + } + + std::string runSuffix = runNumber ? fmt::format(" for run {}", *runNumber) : ""; + LOG(fatal) << "Could not load efficiency map (neither TH3 nor TH2) for " << particleName << " from CCDB" << runSuffix << "!"; + } + + /*void fetchSingleEfficiencyMapFromCCDB(EffMapPtr& effMap, std::string_view particleName) { std::string path = fmt::format("{}{}", ccdbEfficiencyPath.value, particleName); @@ -451,7 +477,7 @@ struct PhiStrangeCorrelation { void fetchSingleEfficiencyMapPerPeriodFromCCDB(EffMapPtr& effMap, std::string_view particleName, int runNumber) { - std::string path = fmt::format("{}{}/{}", ccdbEfficiencyPath.value, particleName, runNumber); + std::string path = fmt::format("{}{}", ccdbEfficiencyPath.value, particleName); if (auto map3D = std::shared_ptr(ccdb->getForRun(path, runNumber))) { effMap = map3D; @@ -466,9 +492,37 @@ struct PhiStrangeCorrelation { } LOG(fatal) << "Could not load efficiency map (neither TH3 nor TH2) for " << particleName << " from CCDB for run " << runNumber; + }*/ + + void loadEfficiencyMaps(std::optional runNumber = std::nullopt) + { + if (runNumber) { + if (*runNumber == mLastRunNumber) { + return; + } + mLastRunNumber = *runNumber; + } + + // Load the Trigger (Phi) map if requested by analysis method + if (efficiencyConfigs.applyPhiEfficiency) { + fetchSingleEfficiencyMapFromCCDB(effMapPhi, "Phi", runNumber); + } + + // Only load the associated maps that are explicitly enabled + for (size_t i = 0; i < kAssocPartSize; ++i) { + if (activeCorrelationTypes->at(i)) { + fetchSingleEfficiencyMapFromCCDB(effMapsAssoc[i], AssocParticleLabels[i], runNumber); + } + } + + if (runNumber) { + LOG(info) << "Efficiency maps successfully updated from CCDB for run " << *runNumber; + } else { + LOG(info) << "Global efficiency maps successfully loaded from CCDB"; + } } - void loadEfficiencyMaps() + /*void loadEfficiencyMaps() { // Load the Trigger (Phi) map if requested by analysis method if (efficiencyConfigs.applyPhiEfficiency) { @@ -496,7 +550,7 @@ struct PhiStrangeCorrelation { fetchSingleEfficiencyMapPerPeriodFromCCDB(effMapsAssoc[i], AssocParticleLabels[i], runNumber); } } - } + }*/ // Compute weight based on efficiencies template @@ -781,10 +835,9 @@ struct PhiStrangeCorrelation { { float multiplicity = collision.centFT0M(); - auto bc = collision.template bc_as(); - if (efficiencyConfigs.applyEfficiency && efficiencyConfigs.perPeriodEfficiency) { - loadEfficiencyMapsPerPeriod(bc.runNumber()); + auto bc = collision.template bc_as(); + loadEfficiencyMaps(bc.runNumber()); } for (const auto& phiCand : phiCandidates) { @@ -819,7 +872,8 @@ struct PhiStrangeCorrelation { aod::PhimesonCandidatesMcReco const& phiCandidates, aod::K0sReducedCandidatesMcReco const& k0sReduced, aod::XiReducedCandidatesMcReco const& xiReduced, - aod::PionTracksMcReco const& pionTracks) + aod::PionTracksMcReco const& pionTracks, + aod::BCs const&) { processPhiAssocSE(collision, phiCandidates, makeAssocInput(k0sReduced), @@ -838,6 +892,11 @@ struct PhiStrangeCorrelation { for (const auto& [c1, phiCands, c2, assocRed] : pairPhiAssoc) { float multiplicity = c1.centFT0M(); + if (efficiencyConfigs.applyEfficiency && efficiencyConfigs.perPeriodEfficiency) { + auto bc = c1.template bc_as(); + loadEfficiencyMaps(bc.runNumber()); + } + for (const auto& [phiCand, assoc] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(phiCands, assocRed))) { if (efficiencyConfigs.applyEfficiency && efficiencyConfigs.applyPhiEfficiency && phiCand.pt() >= binspTPhi->back()) { continue; @@ -850,7 +909,8 @@ struct PhiStrangeCorrelation { void processPhiK0SMEDataLike(SelCollisions const& collisions, aod::PhimesonCandidatesData const& phiCandidates, - aod::K0sReducedCandidatesData const& k0sReduced) + aod::K0sReducedCandidatesData const& k0sReduced, + aod::BCs const&) { processPhiAssocME(collisions, phiCandidates, k0sReduced); } @@ -859,7 +919,8 @@ struct PhiStrangeCorrelation { void processPhiK0SMEMCWithPDG(SimCollisions const& collisions, aod::PhimesonCandidatesMcReco const& phiCandidates, - aod::K0sReducedCandidatesMcReco const& k0sReduced) + aod::K0sReducedCandidatesMcReco const& k0sReduced, + aod::BCs const&) { processPhiAssocME(collisions, phiCandidates, k0sReduced); } @@ -868,7 +929,8 @@ struct PhiStrangeCorrelation { void processPhiXiMEDataLike(SelCollisions const& collisions, aod::PhimesonCandidatesData const& phiCandidates, - aod::XiReducedCandidatesData const& xiReduced) + aod::XiReducedCandidatesData const& xiReduced, + aod::BCs const&) { processPhiAssocME(collisions, phiCandidates, xiReduced); } @@ -877,7 +939,8 @@ struct PhiStrangeCorrelation { void processPhiXiMEMCWithPDG(SimCollisions const& collisions, aod::PhimesonCandidatesMcReco const& phiCandidates, - aod::XiReducedCandidatesMcReco const& xiReduced) + aod::XiReducedCandidatesMcReco const& xiReduced, + aod::BCs const&) { processPhiAssocME(collisions, phiCandidates, xiReduced); } @@ -886,7 +949,8 @@ struct PhiStrangeCorrelation { void processPhiPionMEDataLike(SelCollisions const& collisions, aod::PhimesonCandidatesData const& phiCandidates, - aod::PionTracksData const& pionTracks) + aod::PionTracksData const& pionTracks, + aod::BCs const&) { processPhiAssocME(collisions, phiCandidates, pionTracks); } @@ -895,7 +959,8 @@ struct PhiStrangeCorrelation { void processPhiPionMEMCWithPDG(SimCollisions const& collisions, aod::PhimesonCandidatesMcReco const& phiCandidates, - aod::PionTracksMcReco const& pionTracks) + aod::PionTracksMcReco const& pionTracks, + aod::BCs const&) { processPhiAssocME(collisions, phiCandidates, pionTracks); } From 31147cfa6318675c08177f290473ff4d7221313c Mon Sep 17 00:00:00 2001 From: scannito Date: Wed, 23 Sep 2026 16:12:14 +0200 Subject: [PATCH 4/5] Completed analysis task with (anti)Lambda and Omega cases --- .../Strangeness/phiStrangeCorrelation.cxx | 322 +++++++++++++----- 1 file changed, 245 insertions(+), 77 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx b/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx index 2e5e6398308..405edb6f64d 100644 --- a/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx +++ b/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx @@ -77,7 +77,10 @@ enum AnalysisMode { enum AssociatedParticleType { kK0S = 0, + kLambda, + kAntiLambda, kXi, + kOmega, kPion, kAssocPartSize }; @@ -93,12 +96,20 @@ constexpr int getPdgCode() { if constexpr (PartType == kK0S) { return PDG_t::kK0Short; + } else if constexpr (PartType == kLambda) { + return PDG_t::kLambda0; + } else if constexpr (PartType == kAntiLambda) { + return PDG_t::kLambda0Bar; } else if constexpr (PartType == kXi) { return PDG_t::kXiMinus; + } else if constexpr (PartType == kOmega) { + return PDG_t::kOmegaMinus; } else if constexpr (PartType == kPion) { return PDG_t::kPiPlus; } else { - static_assert(PartType == kK0S || PartType == kXi || PartType == kPion, "Unsupported particle type in getPdgCode"); + static_assert(PartType == kK0S || PartType == kLambda || PartType == kAntiLambda || + PartType == kXi || PartType == kOmega || PartType == kPion, + "Unsupported particle type in getPdgCode"); return 0; } } @@ -200,12 +211,24 @@ struct PhiStrangeCorrelation { Configurable> rangeMK0sSignal{"rangeMK0sSignal", {0.47f, 0.53f}, "K0S mass range for signal extraction"}; } k0sConfigs; + // Configurables for Lambda selection + struct : ConfigurableGroup { + Configurable selectLambdaInSigRegion{"selectLambdaInSigRegion", true, "Select Lambda candidates in signal region"}; + Configurable> rangeMLambdaSignal{"rangeMLambdaSignal", {1.11f, 1.12f}, "Lambda mass range for signal extraction"}; + } lambdaConfigs; + // Configurables for Xi selection struct : ConfigurableGroup { Configurable selectXiInSigRegion{"selectXiInSigRegion", true, "Select Xi candidates in signal region"}; Configurable> rangeMXiSignal{"rangeMXiSignal", {1.31f, 1.33f}, "Xi mass range for signal extraction"}; } xiConfigs; + // Configurables for Omega selection + struct : ConfigurableGroup { + Configurable selectOmegaInSigRegion{"selectOmegaInSigRegion", true, "Select Omega candidates in signal region"}; + Configurable> rangeMOmegaSignal{"rangeMOmegaSignal", {1.66f, 1.68f}, "Omega mass range for signal extraction"}; + } omegaConfigs; + // Configurables for Pions selection struct : ConfigurableGroup { Configurable selectPionInSigRegion{"selectPionInSigRegion", true, "Select Pion candidates in signal region"}; @@ -222,15 +245,23 @@ struct PhiStrangeCorrelation { Configurable> binspTK0S{"binspTK0S", {0.1, 0.5, 0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for K0S"}; Configurable> binspTK0SExt{"binspTK0SExt", {0.0, 0.1, 0.5, 0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for K0S extended for MC Gen"}; + // Configurable on Lambda pT bins + Configurable> binspTLambda{"binspTLambda", {0.1, 0.5, 0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for Lambda"}; + Configurable> binspTLambdaExt{"binspTLambdaExt", {0.0, 0.1, 0.5, 0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for Lambda extended for MC Gen"}; + // Configurable on Xi pT bins Configurable> binspTXi{"binspTXi", {0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for Xi"}; Configurable> binspTXiExt{"binspTXiExt", {0.0, 0.4, 0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for Xi extended for MC Gen"}; + // Configurable on Omega pT bins + Configurable> binspTOmega{"binspTOmega", {0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for Omega"}; + Configurable> binspTOmegaExt{"binspTOmegaExt", {0.0, 0.4, 0.8, 1.2, 1.6, 2.0, 2.5, 3.0, 4.0, 6.0}, "pT bin limits for Omega extended for MC Gen"}; + // Configurable on pion pT bins Configurable> binspTPi{"binspTPi", {0.2, 0.3, 0.4, 0.5, 0.6, 0.8, 1.0, 1.2, 1.5, 2.0, 3.0}, "pT bin limits for Pions"}; Configurable> binspTPiExt{"binspTPiExt", {0.0, 0.2, 0.3, 0.4, 0.5, 0.6, 0.8, 1.0, 1.2, 1.5, 2.0, 3.0}, "pT bin limits for Pions extended for MC Gen"}; - Configurable> activeCorrelationTypes{"activeCorrelationTypes", {true, false, true}, "Enable correlation types: 0 - K0S, 1 - Xi, 2 - Pion"}; + Configurable> activeCorrelationTypes{"activeCorrelationTypes", {true, false, false, false, false, true}, "Enable correlation types: 0 - K0S, 1 - Lambda, 2 - AntiLambda, 3 - Xi, 4 - Omega, 5 - Pion"}; // Configurables for delta y selection struct : ConfigurableGroup { @@ -260,7 +291,9 @@ struct PhiStrangeCorrelation { struct : ConfigurableGroup { Configurable minPhiPt{"minPhiPt", 0.4f, "Minimum pT for Phi candidates"}; Configurable v0SettingMinPt{"v0SettingMinPt", 0.1f, "V0 min pt"}; + Configurable lambdaSettingMinPt{"lambdaSettingMinPt", 0.2f, "Lambda min pt"}; Configurable cascadeSettingMinPt{"cascadeSettingMinPt", 0.8f, "Cascade min pt"}; + Configurable omegaSettingMinPt{"omegaSettingMinPt", 0.8f, "Omega min pt"}; Configurable cMinPionPtcut{"cMinPionPtcut", 0.2f, "Track minimum pt cut"}; Configurable bypassPtCut{"bypassPtCut", false, "Bypass the minimum pt cut at MCGen level"}; } minPtMcGenConfigs; @@ -285,9 +318,18 @@ struct PhiStrangeCorrelation { Preslice k0sDataPerCollision = aod::v0::collisionId; Preslice k0sMcRecoPerCollision = aod::v0::collisionId; + Preslice lambdaDataPerCollision = aod::v0::collisionId; + Preslice lambdaMcRecoPerCollision = aod::v0::collisionId; + + Preslice antiLambdaDataPerCollision = aod::v0::collisionId; + Preslice antiLambdaMcRecoPerCollision = aod::v0::collisionId; + Preslice xiDataPerCollision = aod::cascade::collisionId; Preslice xiMcRecoPerCollision = aod::cascade::collisionId; + Preslice omegaDataPerCollision = aod::cascade::collisionId; + Preslice omegaMcRecoPerCollision = aod::cascade::collisionId; + Preslice pionTrackDataPerCollision = aod::track::collisionId; Preslice pionTrackMcRecoPerCollision = aod::track::collisionId; @@ -311,7 +353,7 @@ struct PhiStrangeCorrelation { BinningTypeVertexCent binningOnVertexAndCent{{axisVertexMixing, axisCentralityMixing}, true}; static constexpr std::array PhiMassRegionLabels{"Signal", "Sideband"}; - static constexpr std::array AssocParticleLabels{"K0S", "Xi", "Pi"}; + static constexpr std::array AssocParticleLabels{"K0S", "Lambda", "AntiLambda", "Xi", "Omega", "Pi"}; // Light structures to store only the necessary information for the correlation analysis at MCGen level struct MiniParticle { @@ -324,7 +366,10 @@ struct PhiStrangeCorrelation { float multiplicity{}; std::vector phiParticles; std::vector k0sParticles; + std::vector lambdaParticles; + std::vector antilambdaParticles; std::vector xiParticles; + std::vector omegaParticles; std::vector pionParticles; }; @@ -349,10 +394,18 @@ struct PhiStrangeCorrelation { AxisSpec pTK0SAxis = {100, 0.0f, 10.0f, "#it{p}_{T} (GeV/#it{c})"}; AxisSpec binnedpTK0SAxis{(std::vector)binspTK0S, "#it{p}_{T} (GeV/#it{c})"}; AxisSpec binnedpTK0SAxisExt{(std::vector)binspTK0SExt, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec massLambdaAxis = {200, 1.1f, 1.13f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; + AxisSpec pTLambdaAxis = {100, 0.0f, 10.0f, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTLambdaAxis{(std::vector)binspTLambda, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTLambdaAxisExt{(std::vector)binspTLambdaExt, "#it{p}_{T} (GeV/#it{c})"}; AxisSpec massXiAxis = {200, 1.3f, 1.4f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; AxisSpec pTXiAxis = {100, 0.0f, 10.0f, "#it{p}_{T} (GeV/#it{c})"}; AxisSpec binnedpTXiAxis{(std::vector)binspTXi, "#it{p}_{T} (GeV/#it{c})"}; AxisSpec binnedpTXiAxisExt{(std::vector)binspTXiExt, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec massOmegaAxis = {200, 1.65f, 1.7f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; + AxisSpec pTOmegaAxis = {100, 0.0f, 10.0f, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTOmegaAxis{(std::vector)binspTOmega, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTOmegaAxisExt{(std::vector)binspTOmegaExt, "#it{p}_{T} (GeV/#it{c})"}; AxisSpec nSigmaPiAxis = {100, -10.0f, 10.0f, "N#sigma #pi"}; AxisSpec pTPiAxis = {50, 0.0f, 5.0f, "#it{p}_{T} (GeV/#it{c})"}; AxisSpec binnedpTPiAxis{(std::vector)binspTPi, "#it{p}_{T} (GeV/#it{c})"}; @@ -361,22 +414,30 @@ struct PhiStrangeCorrelation { histos.add("phi/h3PhiData", "Invariant mass of Phi in Data", kTH3F, {binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); histos.add("phiK0S/h6PhiK0SData", "Invariant mass of Phi vs Invariant mass of K0Short in Data", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTK0SAxis, deltayAxis, massPhiAxis, massK0SAxis}); + histos.add("phiLambda/h6PhiLambdaData", "Invariant mass of Phi vs Invariant mass of Lambda in Data", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTLambdaAxis, deltayAxis, massPhiAxis, massLambdaAxis}); histos.add("phiXi/h6PhiXiData", "Invariant mass of Phi vs Invariant mass of Xi in Data", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTXiAxis, deltayAxis, massPhiAxis, massXiAxis}); + histos.add("phiOmega/h6PhiOmegaData", "Invariant mass of Phi vs Invariant mass of Omega in Data", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTOmegaAxis, deltayAxis, massPhiAxis, massOmegaAxis}); histos.add("phiPi/h6PhiPiTPCData", "Invariant mass of Phi vs nSigmaTPC Pion in Data", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTPiAxis, deltayAxis, massPhiAxis, nSigmaPiAxis}); histos.add("phiPi/h6PhiPiTOFData", "Invariant mass of Phi vs nSigmaTOF Pion in Data", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTPiAxis, deltayAxis, massPhiAxis, nSigmaPiAxis}); histos.add("phiK0S/h6PhiK0SDataME", "Invariant mass of Phi vs Invariant mass of K0Short in Data ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTK0SAxis, deltayAxis, massPhiAxis, massK0SAxis}); + histos.add("phiLambda/h6PhiLambdaDataME", "Invariant mass of Phi vs Invariant mass of Lambda in Data ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTLambdaAxis, deltayAxis, massPhiAxis, massLambdaAxis}); histos.add("phiXi/h6PhiXiDataME", "Invariant mass of Phi vs Invariant mass of Xi in Data ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTXiAxis, deltayAxis, massPhiAxis, massXiAxis}); + histos.add("phiOmega/h6PhiOmegaDataME", "Invariant mass of Phi vs Invariant mass of Omega in Data ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTOmegaAxis, deltayAxis, massPhiAxis, massOmegaAxis}); histos.add("phiPi/h6PhiPiTPCDataME", "Invariant mass of Phi vs nSigmaTPC Pion in Data ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTPiAxis, deltayAxis, massPhiAxis, nSigmaPiAxis}); histos.add("phiPi/h6PhiPiTOFDataME", "Invariant mass of Phi vs nSigmaTOF Pion in Data ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTPiAxis, deltayAxis, massPhiAxis, nSigmaPiAxis}); for (const auto& label : PhiMassRegionLabels) { histos.add(fmt::format("phiK0S/h5PhiK0SData{}", label).c_str(), "Deltay vs deltaphi for Phi and K0Short in Data", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTK0SAxis, deltayAxis, deltaphiAxis}); + histos.add(fmt::format("phiLambda/h5PhiLambdaData{}", label).c_str(), "Deltay vs deltaphi for Phi and Lambda in Data", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTLambdaAxis, deltayAxis, deltaphiAxis}); histos.add(fmt::format("phiXi/h5PhiXiData{}", label).c_str(), "Deltay vs deltaphi for Phi and Xi in Data", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTXiAxis, deltayAxis, deltaphiAxis}); + histos.add(fmt::format("phiOmega/h5PhiOmegaData{}", label).c_str(), "Deltay vs deltaphi for Phi and Omega in Data", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTOmegaAxis, deltayAxis, deltaphiAxis}); histos.add(fmt::format("phiPi/h5PhiPiData{}", label).c_str(), "Deltay vs deltaphi for Phi and Pion in Data", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTPiAxis, deltayAxis, deltaphiAxis}); histos.add(fmt::format("phiK0S/h5PhiK0SDataME{}", label).c_str(), "Deltay vs deltaphi for Phi and K0Short in Data ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTK0SAxis, deltayAxis, deltaphiAxis}); + histos.add(fmt::format("phiLambda/h5PhiLambdaDataME{}", label).c_str(), "Deltay vs deltaphi for Phi and Lambda in Data ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTLambdaAxis, deltayAxis, deltaphiAxis}); histos.add(fmt::format("phiXi/h5PhiXiDataME{}", label).c_str(), "Deltay vs deltaphi for Phi and Xi in Data ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTXiAxis, deltayAxis, deltaphiAxis}); + histos.add(fmt::format("phiOmega/h5PhiOmegaDataME{}", label).c_str(), "Deltay vs deltaphi for Phi and Omega in Data ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTOmegaAxis, deltayAxis, deltaphiAxis}); histos.add(fmt::format("phiPi/h5PhiPiDataME{}", label).c_str(), "Deltay vs deltaphi for Phi and Pion in Data ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxis, binnedpTPiAxis, deltayAxis, deltaphiAxis}); } @@ -395,10 +456,22 @@ struct PhiStrangeCorrelation { histos.add("k0s/h3K0SMCGen", "K0S in MC Gen", kTH3F, {binnedmultAxis, binnedpTK0SAxis, yAxis}); histos.add("k0s/h4K0SMCGenAssocReco", "K0S in MC Gen Assoc Reco", kTHnSparseF, {vertexZAxis, binnedmultAxis, binnedpTK0SAxis, yAxis}); + histos.add("lambda/h4LambdaMCReco", "Lambda in MC Reco", kTHnSparseF, {vertexZAxis, binnedmultAxis, binnedpTLambdaAxis, yAxis}); + histos.add("lambda/h3LambdaMCGen", "Lambda in MC Gen", kTH3F, {binnedmultAxis, binnedpTLambdaAxis, yAxis}); + histos.add("lambda/h4LambdaMCGenAssocReco", "Lambda in MC Gen Assoc Reco", kTHnSparseF, {vertexZAxis, binnedmultAxis, binnedpTLambdaAxis, yAxis}); + + histos.add("antilambda/h4AntiLambdaMCReco", "AntiLambda in MC Reco", kTHnSparseF, {vertexZAxis, binnedmultAxis, binnedpTLambdaAxis, yAxis}); + histos.add("antilambda/h3AntiLambdaMCGen", "AntiLambda in MC Gen", kTH3F, {binnedmultAxis, binnedpTLambdaAxis, yAxis}); + histos.add("antilambda/h4AntiLambdaMCGenAssocReco", "AntiLambda in MC Gen Assoc Reco", kTHnSparseF, {vertexZAxis, binnedmultAxis, binnedpTLambdaAxis, yAxis}); + histos.add("xi/h4XiMCReco", "Xi in MC Reco", kTHnSparseF, {vertexZAxis, binnedmultAxis, binnedpTXiAxis, yAxis}); histos.add("xi/h3XiMCGen", "Xi in MC Gen", kTH3F, {binnedmultAxis, binnedpTXiAxis, yAxis}); histos.add("xi/h4XiMCGenAssocReco", "Xi in MC Gen Assoc Reco", kTHnSparseF, {vertexZAxis, binnedmultAxis, binnedpTXiAxis, yAxis}); + histos.add("omega/h4OmegaMCReco", "Omega in MC Reco", kTHnSparseF, {vertexZAxis, binnedmultAxis, binnedpTOmegaAxis, yAxis}); + histos.add("omega/h3OmegaMCGen", "Omega in MC Gen", kTH3F, {binnedmultAxis, binnedpTOmegaAxis, yAxis}); + histos.add("omega/h4OmegaMCGenAssocReco", "Omega in MC Gen Assoc Reco", kTHnSparseF, {vertexZAxis, binnedmultAxis, binnedpTOmegaAxis, yAxis}); + histos.add("pi/h4PiMCReco", "Pion in MC Reco", kTHnSparseF, {vertexZAxis, binnedmultAxis, binnedpTPiAxis, yAxis}); histos.add("pi/h3PiMCGen", "Pion in MC Gen", kTH3F, {binnedmultAxis, binnedpTPiAxis, yAxis}); histos.add("pi/h4PiMCGenAssocReco", "Pion in MC Gen Assoc Reco", kTHnSparseF, {vertexZAxis, binnedmultAxis, binnedpTPiAxis, yAxis}); @@ -406,11 +479,15 @@ struct PhiStrangeCorrelation { histos.add("phi/h3PhiMCClosureGen", "Phi in MC Gen for MC Closure Test", kTH3F, {binnedmultAxis, binnedpTPhiAxisExt, yAxis}); histos.add("phiK0S/h5PhiK0SClosureMCGen", "Deltay vs deltaphi for Phi and K0Short in MCGen", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTK0SAxisExt, deltayAxis, deltaphiAxis}); + histos.add("phiLambda/h5PhiLambdaClosureMCGen", "Deltay vs deltaphi for Phi and Lambda in MCGen", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTLambdaAxisExt, deltayAxis, deltaphiAxis}); histos.add("phiXi/h5PhiXiClosureMCGen", "Deltay vs deltaphi for Phi and Xi in MCGen", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTXiAxisExt, deltayAxis, deltaphiAxis}); + histos.add("phiOmega/h5PhiOmegaClosureMCGen", "Deltay vs deltaphi for Phi and Omega in MCGen", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTOmegaAxisExt, deltayAxis, deltaphiAxis}); histos.add("phiPi/h5PhiPiClosureMCGen", "Deltay vs deltaphi for Phi and Pion in MCGen", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTPiAxisExt, deltayAxis, deltaphiAxis}); histos.add("phiK0S/h5PhiK0SClosureMCGenME", "Deltay vs deltaphi for Phi and K0Short in MCGen ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTK0SAxisExt, deltayAxis, deltaphiAxis}); + histos.add("phiLambda/h5PhiLambdaClosureMCGenME", "Deltay vs deltaphi for Phi and Lambda in MCGen ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTLambdaAxisExt, deltayAxis, deltaphiAxis}); histos.add("phiXi/h5PhiXiClosureMCGenME", "Deltay vs deltaphi for Phi and Xi in MCGen ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTXiAxisExt, deltayAxis, deltaphiAxis}); + histos.add("phiOmega/h5PhiOmegaClosureMCGenME", "Deltay vs deltaphi for Phi and Omega in MCGen ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTOmegaAxisExt, deltayAxis, deltaphiAxis}); histos.add("phiPi/h5PhiPiClosureMCGenME", "Deltay vs deltaphi for Phi and Pion in MCGen ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTPiAxisExt, deltayAxis, deltaphiAxis}); // Load efficiency maps from CCDB @@ -456,44 +533,6 @@ struct PhiStrangeCorrelation { LOG(fatal) << "Could not load efficiency map (neither TH3 nor TH2) for " << particleName << " from CCDB" << runSuffix << "!"; } - /*void fetchSingleEfficiencyMapFromCCDB(EffMapPtr& effMap, std::string_view particleName) - { - std::string path = fmt::format("{}{}", ccdbEfficiencyPath.value, particleName); - - if (auto map3D = std::shared_ptr(ccdb->get(path))) { - effMap = map3D; - LOG(info) << "Efficiency map (TH3) for " << particleName << " loaded from CCDB"; - return; - } - - if (auto map2D = std::shared_ptr(ccdb->get(path))) { - effMap = map2D; - LOG(info) << "Efficiency map (TH2) for " << particleName << " loaded from CCDB"; - return; - } - - LOG(fatal) << "Could not load efficiency map (neither TH3 nor TH2) for " << particleName << " from CCDB!"; - } - - void fetchSingleEfficiencyMapPerPeriodFromCCDB(EffMapPtr& effMap, std::string_view particleName, int runNumber) - { - std::string path = fmt::format("{}{}", ccdbEfficiencyPath.value, particleName); - - if (auto map3D = std::shared_ptr(ccdb->getForRun(path, runNumber))) { - effMap = map3D; - LOG(info) << "Efficiency map (TH3) for " << particleName << " loaded from CCDB for run " << runNumber; - return; - } - - if (auto map2D = std::shared_ptr(ccdb->getForRun(path, runNumber))) { - effMap = map2D; - LOG(info) << "Efficiency map (TH2) for " << particleName << " loaded from CCDB for run " << runNumber; - return; - } - - LOG(fatal) << "Could not load efficiency map (neither TH3 nor TH2) for " << particleName << " from CCDB for run " << runNumber; - }*/ - void loadEfficiencyMaps(std::optional runNumber = std::nullopt) { if (runNumber) { @@ -522,36 +561,6 @@ struct PhiStrangeCorrelation { } } - /*void loadEfficiencyMaps() - { - // Load the Trigger (Phi) map if requested by analysis method - if (efficiencyConfigs.applyPhiEfficiency) { - fetchSingleEfficiencyMapFromCCDB(effMapPhi, "Phi"); - } - - // Only load the associated maps that are explicitly enabled - for (size_t i = 0; i < kAssocPartSize; ++i) { - if (activeCorrelationTypes->at(i)) { - fetchSingleEfficiencyMapFromCCDB(effMapsAssoc[i], AssocParticleLabels[i]); - } - } - } - - void loadEfficiencyMapsPerPeriod(int runNumber) - { - // Load the Trigger (Phi) map if requested by analysis method - if (efficiencyConfigs.applyPhiEfficiency) { - fetchSingleEfficiencyMapPerPeriodFromCCDB(effMapPhi, "Phi", runNumber); - } - - // Only load the associated maps that are explicitly enabled - for (size_t i = 0; i < kAssocPartSize; ++i) { - if (activeCorrelationTypes->at(i)) { - fetchSingleEfficiencyMapPerPeriodFromCCDB(effMapsAssoc[i], AssocParticleLabels[i], runNumber); - } - } - }*/ - // Compute weight based on efficiencies template std::pair computeWeightAndError(const BoundEffMaps&... boundEffMaps) @@ -618,12 +627,20 @@ struct PhiStrangeCorrelation { { if constexpr (PartType == kK0S) { return preslices.k0sMcRecoPerCollision; + } else if constexpr (PartType == kLambda) { + return preslices.lambdaMcRecoPerCollision; + } else if constexpr (PartType == kAntiLambda) { + return preslices.antiLambdaMcRecoPerCollision; } else if constexpr (PartType == kXi) { return preslices.xiMcRecoPerCollision; + } else if constexpr (PartType == kOmega) { + return preslices.omegaMcRecoPerCollision; } else if constexpr (PartType == kPion) { return preslices.pionTrackMcRecoPerCollision; } else { - static_assert(PartType == kK0S || PartType == kXi || PartType == kPion, "Unsupported particle type in getPreslice"); + static_assert(PartType == kK0S || PartType == kLambda || PartType == kAntiLambda || + PartType == kXi || PartType == kOmega || PartType == kPion, + "Unsupported particle type in getPreslice"); return preslices.k0sMcRecoPerCollision; } } @@ -633,12 +650,18 @@ struct PhiStrangeCorrelation { { if constexpr (PartType == kK0S) { return minPtMcGenConfigs.v0SettingMinPt.value; + } else if constexpr (PartType == kLambda || PartType == kAntiLambda) { + return minPtMcGenConfigs.lambdaSettingMinPt.value; } else if constexpr (PartType == kXi) { return minPtMcGenConfigs.cascadeSettingMinPt.value; + } else if constexpr (PartType == kOmega) { + return minPtMcGenConfigs.omegaSettingMinPt.value; } else if constexpr (PartType == kPion) { return minPtMcGenConfigs.cMinPionPtcut.value; } else { - static_assert(PartType == kK0S || PartType == kXi || PartType == kPion, "Unsupported particle type in getMinGenPt"); + static_assert(PartType == kK0S || PartType == kLambda || PartType == kAntiLambda || + PartType == kXi || PartType == kOmega || PartType == kPion, + "Unsupported particle type in getMinGenPt"); return 0.f; } } @@ -716,16 +739,26 @@ struct PhiStrangeCorrelation { const bool applyMassCut = (analysisMode == kDeltaYvsDeltaPhi) && k0sConfigs.selectK0sInSigRegion; const auto& [minMass, maxMass] = k0sConfigs.rangeMK0sSignal.value; return (!efficiencyConfigs.applyEfficiency || assoc.pt() < binspTK0S->back()) && (!applyMassCut || assoc.inMassRegion(minMass, maxMass)); + } else if constexpr (PartType == kLambda || PartType == kAntiLambda) { + const bool applyMassCut = (analysisMode == kDeltaYvsDeltaPhi) && lambdaConfigs.selectLambdaInSigRegion; + const auto& [minMass, maxMass] = lambdaConfigs.rangeMLambdaSignal.value; + return (!efficiencyConfigs.applyEfficiency || assoc.pt() < binspTLambda->back()) && (!applyMassCut || assoc.inMassRegion(minMass, maxMass)); } else if constexpr (PartType == kXi) { const bool applyMassCut = (analysisMode == kDeltaYvsDeltaPhi) && xiConfigs.selectXiInSigRegion; const auto& [minMass, maxMass] = xiConfigs.rangeMXiSignal.value; return (!efficiencyConfigs.applyEfficiency || assoc.pt() < binspTXi->back()) && (!applyMassCut || assoc.inMassRegion(minMass, maxMass)); + } else if constexpr (PartType == kOmega) { + const bool applyMassCut = (analysisMode == kDeltaYvsDeltaPhi) && omegaConfigs.selectOmegaInSigRegion; + const auto& [minMass, maxMass] = omegaConfigs.rangeMOmegaSignal.value; + return (!efficiencyConfigs.applyEfficiency || assoc.pt() < binspTOmega->back()) && (!applyMassCut || assoc.inMassRegion(minMass, maxMass)); } else if constexpr (PartType == kPion) { const bool applyNSigmaCut = (analysisMode == kDeltaYvsDeltaPhi) && pionConfigs.selectPionInSigRegion; return (!efficiencyConfigs.applyEfficiency || assoc.pt() < binspTPi->back()) && (!applyNSigmaCut || assoc.inNSigmaRegion(pionConfigs.pidTPCMax, pionConfigs.pidTOFMax)); } else { - static_assert(PartType == kK0S || PartType == kXi || PartType == kPion, "Unsupported particle type in isAssocValid"); + static_assert(PartType == kK0S || PartType == kLambda || PartType == kAntiLambda || + PartType == kXi || PartType == kOmega || PartType == kPion, + "Unsupported particle type in isAssocValid"); return false; } } @@ -748,12 +781,24 @@ struct PhiStrangeCorrelation { } else { customFillTHn(HIST("phiK0S/h6PhiK0SData"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), phiCand.m(), assoc.m()); } + } else if constexpr (PartType == kLambda || PartType == kAntiLambda) { + if constexpr (IsME) { + customFillTHn(HIST("phiLambda/h6PhiLambdaDataME"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), phiCand.m(), assoc.m()); + } else { + customFillTHn(HIST("phiLambda/h6PhiLambdaData"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), phiCand.m(), assoc.m()); + } } else if constexpr (PartType == kXi) { if constexpr (IsME) { customFillTHn(HIST("phiXi/h6PhiXiDataME"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), phiCand.m(), assoc.m()); } else { customFillTHn(HIST("phiXi/h6PhiXiData"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), phiCand.m(), assoc.m()); } + } else if constexpr (PartType == kOmega) { + if constexpr (IsME) { + customFillTHn(HIST("phiOmega/h6PhiOmegaDataME"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), phiCand.m(), assoc.m()); + } else { + customFillTHn(HIST("phiOmega/h6PhiOmegaData"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), phiCand.m(), assoc.m()); + } } else if constexpr (PartType == kPion) { if constexpr (IsME) { customFillTHn(HIST("phiPi/h6PhiPiTPCDataME"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), phiCand.m(), assoc.nSigmaTPC()); @@ -775,6 +820,14 @@ struct PhiStrangeCorrelation { fillSignal = [&]() { customFillTHn(HIST("phiK0S/h5PhiK0SDataSignal"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); }; fillSideband = [&]() { customFillTHn(HIST("phiK0S/h5PhiK0SDataSideband"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); }; } + } else if constexpr (PartType == kLambda || PartType == kAntiLambda) { + if constexpr (IsME) { + fillSignal = [&]() { customFillTHn(HIST("phiLambda/h5PhiLambdaDataMESignal"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); }; + fillSideband = [&]() { customFillTHn(HIST("phiLambda/h5PhiLambdaDataMESideband"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); }; + } else { + fillSignal = [&]() { customFillTHn(HIST("phiLambda/h5PhiLambdaDataSignal"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); }; + fillSideband = [&]() { customFillTHn(HIST("phiLambda/h5PhiLambdaDataSideband"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); }; + } } else if constexpr (PartType == kXi) { if constexpr (IsME) { fillSignal = [&]() { customFillTHn(HIST("phiXi/h5PhiXiDataMESignal"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); }; @@ -783,6 +836,14 @@ struct PhiStrangeCorrelation { fillSignal = [&]() { customFillTHn(HIST("phiXi/h5PhiXiDataSignal"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); }; fillSideband = [&]() { customFillTHn(HIST("phiXi/h5PhiXiDataSideband"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); }; } + } else if constexpr (PartType == kOmega) { + if constexpr (IsME) { + fillSignal = [&]() { customFillTHn(HIST("phiOmega/h5PhiOmegaDataMESignal"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); }; + fillSideband = [&]() { customFillTHn(HIST("phiOmega/h5PhiOmegaDataMESideband"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); }; + } else { + fillSignal = [&]() { customFillTHn(HIST("phiOmega/h5PhiOmegaDataSignal"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); }; + fillSideband = [&]() { customFillTHn(HIST("phiOmega/h5PhiOmegaDataSideband"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); }; + } } else if constexpr (PartType == kPion) { if constexpr (IsME) { fillSignal = [&]() { customFillTHn(HIST("phiPi/h5PhiPiDataMESignal"), weight, multiplicity, phiCand.pt(), assoc.pt(), phiCand.y() - assoc.y(), getDeltaPhi(phiCand.phi(), assoc.phi())); }; @@ -856,13 +917,19 @@ struct PhiStrangeCorrelation { void processPhiAssocSEDataLike(SelCollisions::iterator const& collision, aod::PhimesonCandidatesData const& phiCandidates, aod::K0sReducedCandidatesData const& k0sReduced, + aod::LambdaReducedCandidatesData const& lambdaReduced, + aod::AntiLambdaReducedCandidatesData const& antilambdaReduced, aod::XiReducedCandidatesData const& xiReduced, + aod::OmegaReducedCandidatesData const& omegaReduced, aod::PionTracksData const& pionTracks, aod::BCs const&) { processPhiAssocSE(collision, phiCandidates, makeAssocInput(k0sReduced), + makeAssocInput(lambdaReduced), + makeAssocInput(antilambdaReduced), makeAssocInput(xiReduced), + makeAssocInput(omegaReduced), makeAssocInput(pionTracks)); } @@ -871,13 +938,19 @@ struct PhiStrangeCorrelation { void processPhiAssocSEMCWithPDG(SimCollisions::iterator const& collision, aod::PhimesonCandidatesMcReco const& phiCandidates, aod::K0sReducedCandidatesMcReco const& k0sReduced, + aod::LambdaReducedCandidatesMcReco const& lambdaReduced, + aod::AntiLambdaReducedCandidatesMcReco const& antilambdaReduced, aod::XiReducedCandidatesMcReco const& xiReduced, + aod::OmegaReducedCandidatesMcReco const& omegaReduced, aod::PionTracksMcReco const& pionTracks, aod::BCs const&) { processPhiAssocSE(collision, phiCandidates, makeAssocInput(k0sReduced), + makeAssocInput(lambdaReduced), + makeAssocInput(antilambdaReduced), makeAssocInput(xiReduced), + makeAssocInput(omegaReduced), makeAssocInput(pionTracks)); } @@ -927,6 +1000,46 @@ struct PhiStrangeCorrelation { PROCESS_SWITCH(PhiStrangeCorrelation, processPhiK0SMEMCWithPDG, "Process function for Phi-K0S 2D Correlations in MC with PDG ME", true); + void processPhiLambdaMEDataLike(SelCollisions const& collisions, + aod::PhimesonCandidatesData const& phiCandidates, + aod::LambdaReducedCandidatesData const& lambdaReduced, + aod::BCs const&) + { + processPhiAssocME(collisions, phiCandidates, lambdaReduced); + } + + PROCESS_SWITCH(PhiStrangeCorrelation, processPhiLambdaMEDataLike, "Process function for Phi-Lambda 2D Correlations in Data or MC w/o PDG ME", true); + + void processPhiLambdaMEMCWithPDG(SimCollisions const& collisions, + aod::PhimesonCandidatesMcReco const& phiCandidates, + aod::LambdaReducedCandidatesMcReco const& lambdaReduced, + aod::BCs const&) + { + processPhiAssocME(collisions, phiCandidates, lambdaReduced); + } + + PROCESS_SWITCH(PhiStrangeCorrelation, processPhiLambdaMEMCWithPDG, "Process function for Phi-Lambda 2D Correlations in MC with PDG ME", true); + + void processPhiAntiLambdaMEDataLike(SelCollisions const& collisions, + aod::PhimesonCandidatesData const& phiCandidates, + aod::AntiLambdaReducedCandidatesData const& antilambdaReduced, + aod::BCs const&) + { + processPhiAssocME(collisions, phiCandidates, antilambdaReduced); + } + + PROCESS_SWITCH(PhiStrangeCorrelation, processPhiAntiLambdaMEDataLike, "Process function for Phi-AntiLambda 2D Correlations in Data or MC w/o PDG ME", true); + + void processPhiAntiLambdaMEMCWithPDG(SimCollisions const& collisions, + aod::PhimesonCandidatesMcReco const& phiCandidates, + aod::AntiLambdaReducedCandidatesMcReco const& antilambdaReduced, + aod::BCs const&) + { + processPhiAssocME(collisions, phiCandidates, antilambdaReduced); + } + + PROCESS_SWITCH(PhiStrangeCorrelation, processPhiAntiLambdaMEMCWithPDG, "Process function for Phi-AntiLambda 2D Correlations in MC with PDG ME", true); + void processPhiXiMEDataLike(SelCollisions const& collisions, aod::PhimesonCandidatesData const& phiCandidates, aod::XiReducedCandidatesData const& xiReduced, @@ -947,6 +1060,26 @@ struct PhiStrangeCorrelation { PROCESS_SWITCH(PhiStrangeCorrelation, processPhiXiMEMCWithPDG, "Process function for Phi-Xi 2D Correlations in MC with PDG ME", true); + void processPhiOmegaMEDataLike(SelCollisions const& collisions, + aod::PhimesonCandidatesData const& phiCandidates, + aod::OmegaReducedCandidatesData const& omegaReduced, + aod::BCs const&) + { + processPhiAssocME(collisions, phiCandidates, omegaReduced); + } + + PROCESS_SWITCH(PhiStrangeCorrelation, processPhiOmegaMEDataLike, "Process function for Phi-Omega 2D Correlations in Data or MC w/o PDG ME", true); + + void processPhiOmegaMEMCWithPDG(SimCollisions const& collisions, + aod::PhimesonCandidatesMcReco const& phiCandidates, + aod::OmegaReducedCandidatesMcReco const& omegaReduced, + aod::BCs const&) + { + processPhiAssocME(collisions, phiCandidates, omegaReduced); + } + + PROCESS_SWITCH(PhiStrangeCorrelation, processPhiOmegaMEMCWithPDG, "Process function for Phi-Omega 2D Correlations in MC with PDG ME", true); + void processPhiPionMEDataLike(SelCollisions const& collisions, aod::PhimesonCandidatesData const& phiCandidates, aod::PionTracksData const& pionTracks, @@ -971,7 +1104,10 @@ struct PhiStrangeCorrelation { SimCollisions const& collisions, aod::PhimesonCandidatesMcReco const& phiCandidates, aod::K0sReducedCandidatesMcReco const& k0sReduced, + aod::LambdaReducedCandidatesMcReco const& lambdaReduced, + aod::AntiLambdaReducedCandidatesMcReco const& antilambdaReduced, aod::XiReducedCandidatesMcReco const& xiReduced, + aod::OmegaReducedCandidatesMcReco const& omegaReduced, aod::PionTracksMcReco const& pionTracks, aod::McParticles const& mcParticles) { std::unordered_map> collsGrouped; @@ -1029,7 +1165,10 @@ struct PhiStrangeCorrelation { }; fillRecoAssocSpecies(makeAssocInput(k0sReduced), HIST("k0s/h4K0SMCReco")); + fillRecoAssocSpecies(makeAssocInput(lambdaReduced), HIST("lambda/h4LambdaMCReco")); + fillRecoAssocSpecies(makeAssocInput(antilambdaReduced), HIST("antilambda/h4AntiLambdaMCReco")); fillRecoAssocSpecies(makeAssocInput(xiReduced), HIST("xi/h4XiMCReco")); + fillRecoAssocSpecies(makeAssocInput(omegaReduced), HIST("omega/h4OmegaMCReco")); fillRecoAssocSpecies(makeAssocInput(pionTracks), HIST("pi/h4PiMCReco")); numberAssocColls++; @@ -1099,9 +1238,18 @@ struct PhiStrangeCorrelation { case getPdgCode(): fillGenAssocSpecies.template operator()(HIST("k0s/h3K0SMCGen"), HIST("k0s/h4K0SMCGenAssocReco")); break; + case getPdgCode(): + fillGenAssocSpecies.template operator()(HIST("lambda/h3LambdaMCGen"), HIST("lambda/h4LambdaMCGenAssocReco")); + break; + case getPdgCode(): + fillGenAssocSpecies.template operator()(HIST("antilambda/h3AntiLambdaMCGen"), HIST("antilambda/h4AntiLambdaMCGenAssocReco")); + break; case getPdgCode(): fillGenAssocSpecies.template operator()(HIST("xi/h3XiMCGen"), HIST("xi/h4XiMCGenAssocReco")); break; + case getPdgCode(): + fillGenAssocSpecies.template operator()(HIST("omega/h3OmegaMCGen"), HIST("omega/h4OmegaMCGenAssocReco")); + break; case getPdgCode(): fillGenAssocSpecies.template operator()(HIST("pi/h3PiMCGen"), HIST("pi/h4PiMCGenAssocReco")); break; @@ -1240,7 +1388,10 @@ struct PhiStrangeCorrelation { std::vector phiParticles; std::vector k0sParticles; + std::vector lambdaParticles; + std::vector antilambdaParticles; std::vector xiParticles; + std::vector omegaParticles; std::vector pionParticles; // Preliminary loop to fill vectors of particles of interest for the current event, applying pt and y cuts @@ -1282,9 +1433,18 @@ struct PhiStrangeCorrelation { case getPdgCode(): fillPartCollection.template operator()(k0sParticles); break; + case getPdgCode(): + fillPartCollection.template operator()(lambdaParticles); + break; + case getPdgCode(): + fillPartCollection.template operator()(antilambdaParticles); + break; case getPdgCode(): fillPartCollection.template operator()(xiParticles); break; + case getPdgCode(): + fillPartCollection.template operator()(omegaParticles); + break; case getPdgCode(): fillPartCollection.template operator()(pionParticles); break; @@ -1294,10 +1454,13 @@ struct PhiStrangeCorrelation { } const bool skipK0s = !activeCorrelationTypes->at(kK0S) || k0sParticles.empty(); + const bool skipLambda = !activeCorrelationTypes->at(kLambda) || lambdaParticles.empty(); + const bool skipAntiLambda = !activeCorrelationTypes->at(kAntiLambda) || antilambdaParticles.empty(); const bool skipXi = !activeCorrelationTypes->at(kXi) || xiParticles.empty(); + const bool skipOmega = !activeCorrelationTypes->at(kOmega) || omegaParticles.empty(); const bool skipPion = !activeCorrelationTypes->at(kPion) || pionParticles.empty(); - if (phiParticles.empty() && skipK0s && skipXi && skipPion) { + if (phiParticles.empty() && skipK0s && skipLambda && skipAntiLambda && skipXi && skipOmega && skipPion) { return; } @@ -1307,7 +1470,8 @@ struct PhiStrangeCorrelation { } // Same Event Correlations - std::array*, kAssocPartSize> currentAssocParticles{&k0sParticles, &xiParticles, &pionParticles}; + std::array*, kAssocPartSize> currentAssocParticles{&k0sParticles, &lambdaParticles, &antilambdaParticles, + &xiParticles, &omegaParticles, &pionParticles}; for (const auto& phiParticle : phiParticles) { histos.fill(HIST("phi/h3PhiMCClosureGen"), multiplicity, phiParticle.pt, phiParticle.y); @@ -1329,7 +1493,8 @@ struct PhiStrangeCorrelation { // Mixed Event Correlations for (const auto& pastEvent : eventBuffer[multBin]) { - std::array*, kAssocPartSize> pastAssocParticles{&pastEvent.k0sParticles, &pastEvent.xiParticles, &pastEvent.pionParticles}; + std::array*, kAssocPartSize> pastAssocParticles{&pastEvent.k0sParticles, &pastEvent.lambdaParticles, &pastEvent.antilambdaParticles, + &pastEvent.xiParticles, &pastEvent.omegaParticles, &pastEvent.pionParticles}; // Loop over past events in the same multiplicity bin and fill histograms with all combinations of current phi particles and past associated particles for (const auto& phiParticle : phiParticles) { @@ -1353,7 +1518,10 @@ struct PhiStrangeCorrelation { currentEvent.multiplicity = multiplicity; currentEvent.phiParticles = std::move(phiParticles); currentEvent.k0sParticles = std::move(k0sParticles); + currentEvent.lambdaParticles = std::move(lambdaParticles); + currentEvent.antilambdaParticles = std::move(antilambdaParticles); currentEvent.xiParticles = std::move(xiParticles); + currentEvent.omegaParticles = std::move(omegaParticles); currentEvent.pionParticles = std::move(pionParticles); eventBuffer[multBin].push_front(std::move(currentEvent)); From 03be0543b54dfe96fe7cb7b3732e7a4a3c3c67d6 Mon Sep 17 00:00:00 2001 From: scannito Date: Wed, 23 Sep 2026 22:00:13 +0200 Subject: [PATCH 5/5] Axes + non-existing histos fix --- PWGLF/TableProducer/Strangeness/phiStrangeCorrelator.cxx | 4 ++-- PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx | 2 ++ 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/phiStrangeCorrelator.cxx b/PWGLF/TableProducer/Strangeness/phiStrangeCorrelator.cxx index 53fc5ed541a..907bfb71011 100644 --- a/PWGLF/TableProducer/Strangeness/phiStrangeCorrelator.cxx +++ b/PWGLF/TableProducer/Strangeness/phiStrangeCorrelator.cxx @@ -504,8 +504,8 @@ struct V0ReducedCandProducer { AxisSpec massLambdaAxis = {200, 1.08f, 1.15f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; histos.add("h3K0sCandidatesMass", "K^{0}_{S} candidate invariant mass", kTH3F, {binnedmultAxis, binnedpTK0SAxis, massK0SAxis}); - histos.add("h3LambdaCandidatesMass", "#Lambda candidate invariant mass", kTH3F, {binnedmultAxis, binnedpTK0SAxis, massLambdaAxis}); - histos.add("h3AntiLambdaCandidatesMass", "#bar{#Lambda} candidate invariant mass", kTH3F, {binnedmultAxis, binnedpTK0SAxis, massLambdaAxis}); + histos.add("h3LambdaCandidatesMass", "#Lambda candidate invariant mass", kTH3F, {binnedmultAxis, binnedpTLambdaAxis, massLambdaAxis}); + histos.add("h3AntiLambdaCandidatesMass", "#bar{#Lambda} candidate invariant mass", kTH3F, {binnedmultAxis, binnedpTLambdaAxis, massLambdaAxis}); } template diff --git a/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx b/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx index 405edb6f64d..3db46f77cd6 100644 --- a/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx +++ b/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx @@ -480,12 +480,14 @@ struct PhiStrangeCorrelation { histos.add("phiK0S/h5PhiK0SClosureMCGen", "Deltay vs deltaphi for Phi and K0Short in MCGen", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTK0SAxisExt, deltayAxis, deltaphiAxis}); histos.add("phiLambda/h5PhiLambdaClosureMCGen", "Deltay vs deltaphi for Phi and Lambda in MCGen", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTLambdaAxisExt, deltayAxis, deltaphiAxis}); + histos.add("phiAntiLambda/h5PhiAntiLambdaClosureMCGen", "Deltay vs deltaphi for Phi and AntiLambda in MCGen", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTLambdaAxisExt, deltayAxis, deltaphiAxis}); histos.add("phiXi/h5PhiXiClosureMCGen", "Deltay vs deltaphi for Phi and Xi in MCGen", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTXiAxisExt, deltayAxis, deltaphiAxis}); histos.add("phiOmega/h5PhiOmegaClosureMCGen", "Deltay vs deltaphi for Phi and Omega in MCGen", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTOmegaAxisExt, deltayAxis, deltaphiAxis}); histos.add("phiPi/h5PhiPiClosureMCGen", "Deltay vs deltaphi for Phi and Pion in MCGen", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTPiAxisExt, deltayAxis, deltaphiAxis}); histos.add("phiK0S/h5PhiK0SClosureMCGenME", "Deltay vs deltaphi for Phi and K0Short in MCGen ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTK0SAxisExt, deltayAxis, deltaphiAxis}); histos.add("phiLambda/h5PhiLambdaClosureMCGenME", "Deltay vs deltaphi for Phi and Lambda in MCGen ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTLambdaAxisExt, deltayAxis, deltaphiAxis}); + histos.add("phiAntiLambda/h5PhiAntiLambdaClosureMCGenME", "Deltay vs deltaphi for Phi and AntiLambda in MCGen ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTLambdaAxisExt, deltayAxis, deltaphiAxis}); histos.add("phiXi/h5PhiXiClosureMCGenME", "Deltay vs deltaphi for Phi and Xi in MCGen ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTXiAxisExt, deltayAxis, deltaphiAxis}); histos.add("phiOmega/h5PhiOmegaClosureMCGenME", "Deltay vs deltaphi for Phi and Omega in MCGen ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTOmegaAxisExt, deltayAxis, deltaphiAxis}); histos.add("phiPi/h5PhiPiClosureMCGenME", "Deltay vs deltaphi for Phi and Pion in MCGen ME", kTHnSparseF, {binnedmultAxis, binnedpTPhiAxisExt, binnedpTPiAxisExt, deltayAxis, deltaphiAxis});