From 7d232f9b5a56a3c1a504dc3be404a0e364022819 Mon Sep 17 00:00:00 2001 From: Stefano Cannito Date: Wed, 28 May 2025 15:31:28 +0200 Subject: [PATCH 01/12] Investigating efficiencies with phi --- PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx index cbc97acf8b8..b982dfa066d 100644 --- a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx @@ -2322,6 +2322,19 @@ struct Phik0shortanalysis { mcEventHist.fill(HIST("h2RecMCEtaDistribution"), genmultiplicity, mcTrack.eta()); } + + for (const auto& mcParticle : mcParticlesThisColl) { + if (!mcParticle.isPhysicalPrimary() || std::abs(mcParticle.eta()) > trackConfigs.etaMax) + continue; + + auto pdgTrack = pdgDB->GetParticle(mcParticle.pdgCode()); + if (pdgTrack == nullptr) + continue; + if (pdgTrack->Charge() == trackConfigs.cfgCutCharge) + continue; + + mcEventHist.fill(HIST("h2GenMCEtaDistributionAssocReco"), genmultiplicity, mcParticle.eta()); + } } PROCESS_SWITCH(Phik0shortanalysis, processdNdetaWPhiMCReco, "Process function for dN/deta values in MCReco", false); @@ -2345,6 +2358,8 @@ struct Phik0shortanalysis { float genmultiplicity = mcCollision.centFT0M(); mcEventHist.fill(HIST("hGenMCMultiplicityPercent"), genmultiplicity); + if (isAssocColl) + mcEventHist.fill(HIST("hGenMCAssocRecoMultiplicityPercent"), genmultiplicity); for (const auto& mcParticle : mcParticles) { if (!mcParticle.isPhysicalPrimary() || std::abs(mcParticle.eta()) > trackConfigs.etaMax) @@ -2358,7 +2373,7 @@ struct Phik0shortanalysis { mcEventHist.fill(HIST("h2GenMCEtaDistribution"), genmultiplicity, mcParticle.eta()); if (isAssocColl) - mcEventHist.fill(HIST("h2GenMCEtaDistributionAssocReco"), genmultiplicity, mcParticle.eta()); + mcEventHist.fill(HIST("h2GenMCEtaDistributionAssocReco2"), genmultiplicity, mcParticle.eta()); } } From 02accab3f0f99d524d6a835d80115db89c4634f8 Mon Sep 17 00:00:00 2001 From: Stefano Cannito Date: Wed, 28 May 2025 15:32:57 +0200 Subject: [PATCH 02/12] Defined histo --- PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx | 1 + 1 file changed, 1 insertion(+) diff --git a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx index b982dfa066d..48cd0e12ea1 100644 --- a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx @@ -316,6 +316,7 @@ struct Phik0shortanalysis { mcEventHist.add("h2RecMCEtaDistribution", "Eta vs multiplicity in MCReco", kTH2F, {binnedmultAxis, etaAxis}); mcEventHist.add("h2GenMCEtaDistribution", "Eta vs multiplicity in MCGen", kTH2F, {binnedmultAxis, etaAxis}); mcEventHist.add("h2GenMCEtaDistributionAssocReco", "Eta vs multiplicity in MCGen Assoc Reco", kTH2F, {binnedmultAxis, etaAxis}); + mcEventHist.add("h2GenMCEtaDistributionAssocReco2", "Eta vs multiplicity in MCGen Assoc Reco", kTH2F, {binnedmultAxis, etaAxis}); // Phi topological/PID cuts dataPhiHist.add("h2DauTracksPhiDCAxyPreCutData", "Dcaxy distribution vs pt before DCAxy cut", kTH2F, {{100, 0.0, 5.0, "#it{p}_{T} (GeV/#it{c})"}, {2000, -0.05, 0.05, "DCA_{xy} (cm)"}}); From 46b645fb68e99a43dd5054ef816cfaf0582ced27 Mon Sep 17 00:00:00 2001 From: Stefano Cannito Date: Wed, 28 May 2025 15:35:45 +0200 Subject: [PATCH 03/12] Defined histo 2 --- PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx | 1 + 1 file changed, 1 insertion(+) diff --git a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx index 48cd0e12ea1..c09b05ba107 100644 --- a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx @@ -311,6 +311,7 @@ struct Phik0shortanalysis { mcEventHist.add("hGenMCVertexZ", "hGenMCVertexZ", kTH1F, {vertexZAxis}); mcEventHist.add("hGenMCMultiplicityPercent", "GenMC Multiplicity Percentile", kTH1F, {binnedmultAxis}); + mcEventHist.add("hGenMCAssocRecoMultiplicityPercent", "GenMC AssocReco Multiplicity Percentile", kTH1F, {binnedmultAxis}); // Eta distribution for dN/deta values estimation in MC mcEventHist.add("h2RecMCEtaDistribution", "Eta vs multiplicity in MCReco", kTH2F, {binnedmultAxis, etaAxis}); From c4f99bf5b146ed5180769ef1419948dbb7056659 Mon Sep 17 00:00:00 2001 From: Stefano Cannito Date: Fri, 4 Jul 2025 15:35:50 +0200 Subject: [PATCH 04/12] New procedure for deltay correlations --- .../Tasks/Strangeness/phik0shortanalysis.cxx | 284 +++++++++++++++++- 1 file changed, 276 insertions(+), 8 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx index c09b05ba107..c1875a0a622 100644 --- a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx @@ -154,16 +154,16 @@ struct Phik0shortanalysis { 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 on pion pT bins - Configurable> binspTPi{"binspTPi", {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> 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"}; // Configurables for delta y selection Configurable nBinsY{"nBinsY", 80, "Number of bins in y axis"}; - Configurable nBinsDeltaY{"nBinsDeltaY", 24, "Number of bins in deltay axis"}; + Configurable nBinsDeltaY{"nBinsDeltaY", 20, "Number of bins in deltay axis"}; Configurable cfgYAcceptance{"cfgYAcceptance", 0.5f, "Rapidity acceptance"}; Configurable cfgYAcceptanceSmear{"cfgYAcceptanceSmear", 0.8f, "Rapidity acceptance for smearing matrix study"}; Configurable cfgFCutOnDeltaY{"cfgFCutOnDeltaY", 0.5f, "First upper bound on Deltay selection"}; Configurable cfgSCutOnDeltaY{"cfgSCutOnDeltaY", 0.1f, "Second upper bound on Deltay selection"}; - Configurable> cfgDeltaYAcceptanceBins{"cfgDeltaYAcceptanceBins", {1.0f, 0.8f, 0.6f, 0.5f, 0.3f, 0.2f}, "Rapidity acceptance bins"}; + Configurable> cfgDeltaYAcceptanceBins{"cfgDeltaYAcceptanceBins", {0.5f}, "Rapidity acceptance bins"}; // Configurable for RecMC Configurable cfgiskNoITSROFrameBorder{"cfgiskNoITSROFrameBorder", false, "kNoITSROFrameBorder request on RecMC collisions"}; @@ -176,10 +176,13 @@ struct Phik0shortanalysis { // Configurables to choose the filling method Configurable fillMethodMultipleWeights{"fillMethodMultipleWeights", true, "Fill method Multiple Weights"}; Configurable fillMethodSingleWeight{"fillMethodSingleWeight", false, "Fill method Single Weight"}; + Configurable useEfficiency{"useEfficiency", false, "Use efficiency for filling histograms"}; // Configurable for CCDB + Configurable useCCDB{"useCCDB", false, "Use CCDB for corrections"}; Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "url of the ccdb repository to use"}; Configurable ccdbPurityPath{"ccdbPurityPath", "Users/s/scannito/PhiPuritiesData", "Correction path to file"}; + Configurable ccdbEfficiencyPath{"ccdbEfficiencyPath", "Users/s/scannito/Efficiencies", "Correction path to file"}; // Constants double massKa = o2::constants::physics::MassKPlus; @@ -248,6 +251,11 @@ struct Phik0shortanalysis { // Set of functions for phi purity std::vector> phiPurityFunctions = std::vector>(binsMult->size(), std::vector(binspTPhi->size(), nullptr)); + // Efficiecy maps + TH2F* effMapPhi; + TH2F* effMapK0S; + TH2F* effMapPion; + void init(InitContext&) { // Axes @@ -546,13 +554,22 @@ struct Phik0shortanalysis { mcPionHist.add("h3PiRapidityGenMC", "Rapidity for Pion for GenMC", kTH3F, {binnedmultAxis, binnedptPiAxis, yAxis}); // Initialize CCDB only if purity is requested in the task - if (fillMethodSingleWeight) { + if (useCCDB) { ccdb->setURL(ccdbUrl); ccdb->setCaching(true); ccdb->setLocalObjectValidityChecking(); ccdb->setFatalWhenNull(false); - getPhiPurityFunctionsFromCCDB(); + if (fillMethodSingleWeight) + getPhiPurityFunctionsFromCCDB(); + + if (useEfficiency) + getEfficiencyMapsFromCCDB(); + else { + effMapPhi = nullptr; + effMapK0S = nullptr; + effMapPion = nullptr; + } } } @@ -861,7 +878,7 @@ struct Phik0shortanalysis { { TList* listPhiPurityFunctions = ccdb->get(ccdbPurityPath); if (!listPhiPurityFunctions) - LOG(fatal) << "Problem getting TList object with phi purity functions!"; + LOG(error) << "Problem getting TList object with phi purity functions!"; for (size_t multIdx = 0; multIdx < binsMult->size() - 1; multIdx++) { for (size_t ptIdx = 0; ptIdx < binspTPhi->size() - 1; ptIdx++) { @@ -898,6 +915,29 @@ struct Phik0shortanalysis { return phiPurityFunctions[multIdx][pTIdx]->Eval(Phi.M()); } + void getEfficiencyMapsFromCCDB() + { + TList* listEfficiencyMaps = ccdb->get(ccdbEfficiencyPath); + if (!listEfficiencyMaps) + LOG(error) << "Problem getting TList object with efficiency maps!"; + + effMapPhi = static_cast(listEfficiencyMaps->FindObject("h2EfficiencyPhi")); + if (!effMapPhi) { + LOG(error) << "Problem getting efficiency map for Phi!"; + return; + } + effMapK0S = static_cast(listEfficiencyMaps->FindObject("h2EfficiencyK0S")); + if (!effMapK0S) { + LOG(error) << "Problem getting efficiency map for K0S!"; + return; + } + effMapPion = static_cast(listEfficiencyMaps->FindObject("h2EfficiencyPion")); + if (!effMapPion) { + LOG(error) << "Problem getting efficiency map for Pion!"; + return; + } + } + // Fill 2D invariant mass histogram for V0 and Phi template void fillInvMass2D(const T& V0, const std::vector& listPhi, float multiplicity, const std::vector& weights) @@ -2276,6 +2316,7 @@ struct Phik0shortanalysis { PROCESS_SWITCH(Phik0shortanalysis, processPhiPionMCGen, "Process function for Phi-Pion Correlations Efficiency correction in MCGen", false); + // dN/deta procedure void processdNdetaWPhiData(SelCollisions::iterator const& collision, FilteredTracks const& filteredTracks) { // Check if the event selection is passed @@ -2381,6 +2422,7 @@ struct Phik0shortanalysis { PROCESS_SWITCH(Phik0shortanalysis, processdNdetaWPhiMCGen, "Process function for dN/deta values in MCGen", false); + // 2D procedure void processPhiK0SPionData2D(SelCollisions::iterator const& collision, FullTracks const& fullTracks, FullV0s const& V0s, V0DauTracks const&) { // Check if the event selection is passed @@ -2738,11 +2780,11 @@ struct Phik0shortanalysis { float nSigmaTOFPi = (track.hasTOF() ? track.tofNSigmaPi() : -999); - closureMCPhiPionHist.fill(HIST("h6PhiPiMCClosure"), 0, genmultiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M()); + mcPhiPionHist.fill(HIST("h6PhiPiMCClosure"), 0, genmultiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M()); for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { if (std::abs(track.rapidity(massPi) - recPhi.Rapidity()) > cfgDeltaYAcceptanceBins->at(i)) continue; - closureMCPhiPionHist.fill(HIST("h6PhiPiMCClosure"), i + 1, genmultiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M()); + mcPhiPionHist.fill(HIST("h6PhiPiMCClosure"), i + 1, genmultiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M()); } } } @@ -2750,6 +2792,232 @@ struct Phik0shortanalysis { } PROCESS_SWITCH(Phik0shortanalysis, processPhiK0SPionMCReco2D, "Process function for Phi-K0S and Phi-Pion Correlations Efficiency correction in MCReco2D", false); + + // New analysis procedure + void processAllPartMCReco(SimCollisions::iterator const& collision, FullMCTracks const& fullMCTracks, FullMCV0s const& V0s, V0DauMCTracks const&, MCCollisions const&, aod::McParticles const& mcParticles) + { + for (const auto& collision : collisions) { + if (!acceptEventQA(collision, false)) + continue; + + if (!collision.has_mcCollision()) + continue; + + const auto& mcCollision = collision.mcCollision_as(); + float genmultiplicity = mcCollision.centFT0M(); + + // Defining positive and negative tracks for phi reconstruction + auto posThisColl = posMCTracks->sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); + auto negThisColl = negMCTracks->sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); + + for (const auto& track1 : posThisColl) { // loop over all selected tracks + if (!selectionTrackResonance(track1, false) || !selectionPIDKaonpTdependent(track1)) + continue; // topological and PID selection + + auto track1ID = track1.globalIndex(); + + if (!track1.has_mcParticle()) + continue; + auto mcTrack1 = track1.mcParticle_as(); + if (mcTrack1.pdgCode() != PDG_t::kKPlus || !mcTrack1.isPhysicalPrimary()) + continue; + + for (const auto& track2 : negThisColl) { + if (!selectionTrackResonance(track2, false) || !selectionPIDKaonpTdependent(track2)) + continue; // topological and PID selection + + auto track2ID = track2.globalIndex(); + if (track2ID == track1ID) + continue; // condition to avoid double counting of pair + + if (!track2.has_mcParticle()) + continue; + auto mcTrack2 = track2.mcParticle_as(); + if (mcTrack2.pdgCode() != PDG_t::kKMinus || !mcTrack2.isPhysicalPrimary()) + continue; + + float pTMother = -1.0f; + float yMother = -1.0f; + bool isMCMotherPhi = false; + for (const auto& motherOfMcTrack1 : mcTrack1.mothers_as()) { + for (const auto& motherOfMcTrack2 : mcTrack2.mothers_as()) { + if (motherOfMcTrack1.pdgCode() != motherOfMcTrack2.pdgCode()) + continue; + if (motherOfMcTrack1.globalIndex() != motherOfMcTrack2.globalIndex()) + continue; + if (motherOfMcTrack1.pdgCode() != o2::constants::physics::Pdg::kPhi) + continue; + + pTMother = motherOfMcTrack1.pt(); + yMother = motherOfMcTrack1.y(); + isMCMotherPhi = true; + } + } + + if (!isMCMotherPhi) + continue; + if (pTMother < minPhiPt || std::abs(yMother) > cfgYAcceptance) + continue; + + mcPhiHist.fill(HIST("h2PhieffInvMass"), genmultiplicity, recPhi.M()); + } + } + + // Defining V0s in the collision + auto v0sThisColl = V0s.sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); + + for (const auto& v0 : v0sThisColl) { + if (!v0.has_mcParticle()) + continue; + + auto v0mcparticle = v0.mcParticle(); + if (v0mcparticle.pdgCode() != PDG_t::kK0Short || !v0mcparticle.isPhysicalPrimary()) + continue; + + const auto& posDaughterTrack = v0.posTrack_as(); + const auto& negDaughterTrack = v0.negTrack_as(); + + if (!selectionV0(v0, posDaughterTrack, negDaughterTrack)) + continue; + if (v0Configs.cfgFurtherV0Selection && !furtherSelectionV0(v0, collision)) + continue; + if (std::abs(v0mcparticle.y()) > cfgYAcceptance) + continue; + + mcK0SHist.fill(HIST("h3K0SMCReco"), genmultiplicity, v0mcparticle.pt(), v0.mK0Short()); + } + + // Defining tracks in the collision + auto mcTracksThisColl = fullMCTracks.sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); + + for (const auto& track : mcTracksThisColl) { + // Pion selection + if (!selectionPion(track, false)) + continue; + + if (!track.has_mcParticle()) + continue; + + auto mcTrack = track.mcParticle_as(); + if (std::abs(mcTrack.pdgCode()) != PDG_t::kPiPlus) + continue; + + if (std::abs(mcTrack.y()) > cfgYAcceptance) + continue; + + // Primary pion selection + if (mcTrack.isPhysicalPrimary()) { + mcPionHist.fill(HIST("h3RecMCDCAxyPrimPi"), track.pt(), track.dcaXY()); + } else { + if (mcTrack.getProcess() == 4) { // Selection of secondary pions from weak decay + mcPionHist.fill(HIST("h3RecMCDCAxySecWeakDecayPi"), track.pt(), track.dcaXY()); + } else { // Selection of secondary pions from material interactions + mcPionHist.fill(HIST("h3RecMCDCAxySecMaterialPi"), track.pt(), track.dcaXY()); + } + continue; + } + + mcPionHist.fill(HIST("h3PiTPCMCReco"), genmultiplicity, mcTrack.pt(), track.tpcNSigmaPi()); + + if (track.pt() >= trackConfigs.pTToUseTOF && !track.hasTOF()) + continue; + + mcPionHist.fill(HIST("h4PiTPCTOFMCReco"), genmultiplicity, mcTrack.pt(), track.tpcNSigmaPi(), track.tofNSigmaPi()); + } + + // Defining McParticles in the collision + auto mcParticlesThisColl = mcParticles.sliceByCached(aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + + for (const auto& mcParticle : mcParticlesThisColl) { + if (std::abs(mcParticle.y()) > cfgYAcceptance) + continue; + + // Phi selection + if (mcParticle.pdgCode() != o2::constants::physics::Pdg::kPhi) + continue; + if (mcParticle.pt() < minPhiPt) + continue; + + mcPhiHist.fill(HIST("h1PhiGenMCAssocReco"), genmultiplicity); + + // K0S selection + if (mcParticle.pdgCode() != PDG_t::kK0Short) + continue; + if (!mcParticle.isPhysicalPrimary() || mcParticle.pt() < v0Configs.v0SettingMinPt) + continue; + + mcK0SHist.fill(HIST("h2K0SMCGenAssocReco"), genmultiplicity, mcParticle1.pt()); + + // Pion selection + if (std::abs(mcParticle.pdgCode()) != PDG_t::kPiPlus) + continue; + if (!mcParticle.isPhysicalPrimary() || mcParticle.pt() < trackConfigs.cMinPionPtcut) + continue; + + mcPionHist.fill(HIST("h2PiMCGenAssocReco"), genmultiplicity, mcParticle1.pt()); + } + } + } + + PROCESS_SWITCH(Phik0shortanalysis, processAllPartMCReco, "Process function for all particles in MCReco", false); + + void processAllPartMCGen(MCCollisions::iterator const& mcCollision, soa::SmallGroups const& collisions, aod::McParticles const& mcParticles) + { + if (std::abs(mcCollision.posZ()) > cutZVertex) + return; + if (!pwglf::isINELgtNmc(mcParticles, 0, pdgDB)) + return; + + bool isAssocColl = false; + for (const auto& collision : collisions) { + if (acceptEventQA(collision, false)) { + isAssocColl = true; + break; + } + } + + float genmultiplicity = mcCollision.centFT0M(); + mcEventHist.fill(HIST("hGenMCMultiplicityPercent"), genmultiplicity); + if (isAssocColl) + mcEventHist.fill(HIST("hGenMCAssocRecoMultiplicityPercent"), genmultiplicity); + + for (const auto& mcParticle : mcParticles) { + if (std::abs(mcParticle.y()) > cfgYAcceptance) + continue; + + // Phi selection + if (mcParticle.pdgCode() != o2::constants::physics::Pdg::kPhi) + continue; + if (mcParticle.pt() < minPhiPt) + continue; + + mcPhiHist.fill(HIST("h2PhiGenMCGenAssocReco"), genmultiplicity, mcParticle.pt()); + if (isAssocColl) + mcPhiHist.fill(HIST("h2PhiGenMCGenAssocReco2"), genmultiplicity, mcParticle.pt()); + + // K0S selection + if (mcParticle.pdgCode() != PDG_t::kK0Short) + continue; + if (!mcParticle.isPhysicalPrimary() || mcParticle.pt() < v0Configs.v0SettingMinPt) + continue; + + mcK0SHist.fill(HIST("h2K0SMCGenAssocReco"), genmultiplicity, mcParticle.pt()); + if (isAssocColl) + mcK0SHist.fill(HIST("h2K0SMCGenAssocReco2"), genmultiplicity, mcParticle.pt()); + + // Pion selection + if (std::abs(mcParticle.pdgCode()) != PDG_t::kPiPlus) + continue; + if (!mcParticle.isPhysicalPrimary() || mcParticle.pt() < trackConfigs.cMinPionPtcut) + continue; + + mcPionHist.fill(HIST("h2PiMCGenAssocReco"), genmultiplicity, mcParticle.pt()); + if (isAssocColl) + mcPionHist.fill(HIST("h2PiMCGenAssocReco2"), genmultiplicity, mcParticle.pt()); + } + } + + PROCESS_SWITCH(Phik0shortanalysis, processAllPartMCGen, "Process function for all particles in MCGen", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) From 5fe8f2b818d03cd95f3c0976f45904792f538b4c Mon Sep 17 00:00:00 2001 From: Stefano Cannito Date: Fri, 4 Jul 2025 16:55:12 +0200 Subject: [PATCH 05/12] Introduced deltayaxis explicitly --- .../Tasks/Strangeness/phik0shortanalysis.cxx | 199 ++---------------- 1 file changed, 17 insertions(+), 182 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx index c1875a0a622..8f1c03e50d4 100644 --- a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx @@ -265,7 +265,7 @@ struct Phik0shortanalysis { AxisSpec vertexZAxis = {100, -15.f, 15.f, "vrtx_{Z} [cm]"}; AxisSpec etaAxis = {16, -trackConfigs.etaMax, trackConfigs.etaMax, "#eta"}; AxisSpec yAxis = {nBinsY, -cfgYAcceptanceSmear, cfgYAcceptanceSmear, "#it{y}"}; - AxisSpec deltayAxis = {nBinsDeltaY, -1.2f, 1.2f, "#Delta#it{y}"}; + AxisSpec deltayAxis = {nBinsDeltaY, -1.0f, 1.0f, "#Delta#it{y}"}; AxisSpec multAxis = {120, 0.0f, 120.0f, "centFT0M"}; AxisSpec binnedmultAxis{(std::vector)binsMult, "centFT0M"}; AxisSpec binnedpTPhiAxis{(std::vector)binspTPhi, "#it{p}_{T} (GeV/#it{c})"}; @@ -553,6 +553,15 @@ struct Phik0shortanalysis { mcPionHist.add("h3PiRapidityGenMC", "Rapidity for Pion for GenMC", kTH3F, {binnedmultAxis, binnedptPiAxis, yAxis}); + // Histograms for new analysis procedure (to be finalized and renamed deleting other histograms) + dataPhiHist.add("h3PhiDataNewProc", "Invariant mass of Phi n Data", kTH3F, {binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); + dataPhiK0SHist.add("h5PhiK0SDataNewProc", "2D Invariant mass of Phi and K0Short for Data", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptK0SAxis, massK0SAxis, massPhiAxis}); + dataPhiPionHist.add("h6PhiPiDataNewProc", "Phi Invariant mass vs Pion nSigma TPC/TOF for Data", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, massPhiAxis}); + + closureMCPhiHist.add("h3PhiMCClosureNewProc", "Invariant mass of Phi", kTH3F, {binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); + closureMCPhiK0SHist.add("h5PhiK0SMCClosureNewProc", "2D Invariant mass of Phi and K0Short for MC Closure Test", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptK0SAxis, massK0SAxis, massPhiAxis}); + closureMCPhiPionHist.add("h6PhiPiMCClosureNewProc", "Phi Invariant mass vs Pion nSigma TPC/TOF for MC Closure Test", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, massPhiAxis}); + // Initialize CCDB only if purity is requested in the task if (useCCDB) { ccdb->setURL(ccdbUrl); @@ -2422,7 +2431,7 @@ struct Phik0shortanalysis { PROCESS_SWITCH(Phik0shortanalysis, processdNdetaWPhiMCGen, "Process function for dN/deta values in MCGen", false); - // 2D procedure + // New 2D analysis procedure void processPhiK0SPionData2D(SelCollisions::iterator const& collision, FullTracks const& fullTracks, FullV0s const& V0s, V0DauTracks const&) { // Check if the event selection is passed @@ -2439,8 +2448,6 @@ struct Phik0shortanalysis { bool isCountedPhi = false; bool isFilledhV0 = false; - double weight{1.0}; - // Loop over all positive tracks for (const auto& track1 : posThisColl) { if (!selectionTrackResonance(track1, true) || !selectionPIDKaonpTdependent(track1)) @@ -2473,10 +2480,7 @@ struct Phik0shortanalysis { isCountedPhi = true; } - if (fillMethodSingleWeight) - weight *= (1 - getPhiPurity(multiplicity, recPhi)); - - dataPhiHist.fill(HIST("h3PhipurData"), multiplicity, recPhi.Pt(), recPhi.M()); + dataPhiHist.fill(HIST("h3PhiDataNewProc"), multiplicity, recPhi.Pt(), recPhi.M()); // V0 already reconstructed by the builder for (const auto& v0 : V0s) { @@ -2503,12 +2507,7 @@ struct Phik0shortanalysis { if (std::abs(v0.yK0Short()) > cfgYAcceptance) continue; - dataPhiK0SHist.fill(HIST("h5PhiK0SData"), 0, multiplicity, v0.pt(), v0.mK0Short(), recPhi.M()); - for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { - if (std::abs(v0.yK0Short() - recPhi.Rapidity()) > cfgDeltaYAcceptanceBins->at(i)) - continue; - dataPhiK0SHist.fill(HIST("h5PhiK0SData"), i + 1, multiplicity, v0.pt(), v0.mK0Short(), recPhi.M()); - } + dataPhiK0SHist.fill(HIST("h5PhiK0SDataNewProc"), v0.yK0Short() - recPhi.Rapidity(), multiplicity, v0.pt(), v0.mK0Short(), recPhi.M()); } isFilledhV0 = true; @@ -2523,18 +2522,10 @@ struct Phik0shortanalysis { float nSigmaTOFPi = (track.hasTOF() ? track.tofNSigmaPi() : -999); - dataPhiPionHist.fill(HIST("h6PhiPiData"), 0, multiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M()); - for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { - if (std::abs(track.rapidity(massPi) - recPhi.Rapidity()) > cfgDeltaYAcceptanceBins->at(i)) - continue; - dataPhiPionHist.fill(HIST("h6PhiPiData"), i + 1, multiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M()); - } + dataPhiPionHist.fill(HIST("h6PhiPiDataNewProc"), track.rapidity(massPi) - recPhi.Rapidity(), multiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M()); } } } - - weight = 1 - weight; - dataEventHist.fill(HIST("hEventSelection"), 5, weight); // at least a Phi in the event } PROCESS_SWITCH(Phik0shortanalysis, processPhiK0SPionData2D, "Process function for Phi-K0S and Phi-Pion Correlations in Data2D", false); @@ -2558,8 +2549,6 @@ struct Phik0shortanalysis { bool isCountedPhi = false; - double weight{1.0}; - // Loop over all positive tracks for (const auto& track1 : posThisColl) { if (!selectionTrackResonance(track1, true) || !selectionPIDKaonpTdependent(track1)) @@ -2588,10 +2577,7 @@ struct Phik0shortanalysis { isCountedPhi = true; } - if (fillMethodSingleWeight) - weight *= (1 - getPhiPurity(genmultiplicity, recPhi)); - - closureMCPhiHist.fill(HIST("h3PhipurMCClosure"), genmultiplicity, recPhi.Pt(), recPhi.M()); + closureMCPhiHist.fill(HIST("h3PhiMCClosureNewProc"), genmultiplicity, recPhi.Pt(), recPhi.M()); // V0 already reconstructed by the builder for (const auto& v0 : V0s) { @@ -2614,12 +2600,7 @@ struct Phik0shortanalysis { if (std::abs(v0.yK0Short()) > cfgYAcceptance) continue; - closureMCPhiK0SHist.fill(HIST("h5PhiK0SMCClosure"), 0, genmultiplicity, v0.pt(), v0.mK0Short(), recPhi.M()); - for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { - if (std::abs(v0.yK0Short() - recPhi.Rapidity()) > cfgDeltaYAcceptanceBins->at(i)) - continue; - closureMCPhiK0SHist.fill(HIST("h5PhiK0SMCClosure"), i + 1, genmultiplicity, v0.pt(), v0.mK0Short(), recPhi.M()); - } + closureMCPhiK0SHist.fill(HIST("h5PhiK0SMCClosureNewProc"), v0.yK0Short() - recPhi.Rapidity(), genmultiplicity, v0.pt(), v0.mK0Short(), recPhi.M()); } // Loop over all primary pion candidates @@ -2640,160 +2621,14 @@ struct Phik0shortanalysis { float nSigmaTOFPi = (track.hasTOF() ? track.tofNSigmaPi() : -999); - closureMCPhiPionHist.fill(HIST("h6PhiPiMCClosure"), 0, genmultiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M()); - for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { - if (std::abs(track.rapidity(massPi) - recPhi.Rapidity()) > cfgDeltaYAcceptanceBins->at(i)) - continue; - closureMCPhiPionHist.fill(HIST("h6PhiPiMCClosure"), i + 1, genmultiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M()); - } + closureMCPhiPionHist.fill(HIST("h6PhiPiMCClosureNewProc"), track.rapidity(massPi) - recPhi.Rapidity(), genmultiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M()); } } } - - weight = 1 - weight; - mcEventHist.fill(HIST("hRecMCEventSelection"), 8, weight); // at least a Phi in the event } PROCESS_SWITCH(Phik0shortanalysis, processPhiK0SPionMCClosure2D, "Process function for Phi-K0S and Phi-Pion Correlations in MCClosure2D", false); - void processPhiK0SPionMCReco2D(SimCollisions::iterator const& collision, FullMCTracks const& fullMCTracks, FullMCV0s const& V0s, V0DauMCTracks const&, MCCollisions const&, aod::McParticles const&) - { - if (!acceptEventQA(collision, true)) - return; - - float multiplicity = collision.centFT0M(); - mcEventHist.fill(HIST("hRecMCMultiplicityPercent"), multiplicity); - - if (!collision.has_mcCollision()) - return; - mcEventHist.fill(HIST("hRecMCEventSelection"), 6); // with at least a gen collision - - const auto& mcCollision = collision.mcCollision_as(); - float genmultiplicity = mcCollision.centFT0M(); - mcEventHist.fill(HIST("hRecMCGenMultiplicityPercent"), genmultiplicity); - - // Defining positive and negative tracks for phi reconstruction - auto posThisColl = posMCTracks->sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); - auto negThisColl = negMCTracks->sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); - - bool isCountedPhi = false; - - // Loop over all positive tracks - for (const auto& track1 : posThisColl) { - if (!selectionTrackResonance(track1, false) || !selectionPIDKaonpTdependent(track1)) - continue; // topological and PID selection - - auto track1ID = track1.globalIndex(); - - if (!track1.has_mcParticle()) - continue; - auto mcTrack1 = track1.mcParticle_as(); - if (mcTrack1.pdgCode() != PDG_t::kKPlus || !mcTrack1.isPhysicalPrimary()) - continue; - - // Loop over all negative tracks - for (const auto& track2 : negThisColl) { - if (!selectionTrackResonance(track2, false) || !selectionPIDKaonpTdependent(track2)) - continue; // topological and PID selection - - auto track2ID = track2.globalIndex(); - if (track2ID == track1ID) - continue; // condition to avoid double counting of pair - - if (!track2.has_mcParticle()) - continue; - auto mcTrack2 = track2.mcParticle_as(); - if (mcTrack2.pdgCode() != PDG_t::kKMinus || !mcTrack2.isPhysicalPrimary()) - continue; - - bool isMCMotherPhi = false; - for (const auto& motherOfMcTrack1 : mcTrack1.mothers_as()) { - for (const auto& motherOfMcTrack2 : mcTrack2.mothers_as()) { - if (motherOfMcTrack1.pdgCode() != motherOfMcTrack2.pdgCode()) - continue; - if (motherOfMcTrack1.globalIndex() != motherOfMcTrack2.globalIndex()) - continue; - if (motherOfMcTrack1.pdgCode() != o2::constants::physics::Pdg::kPhi) - continue; - isMCMotherPhi = true; - } - } - if (!isMCMotherPhi) - continue; - - ROOT::Math::PxPyPzMVector recPhi = recMother(track1, track2, massKa, massKa); - if (recPhi.Pt() < minPhiPt || recPhi.Pt() > maxPhiPt) - continue; - - if (std::abs(recPhi.Rapidity()) > cfgYAcceptance) - continue; - - if (!isCountedPhi) { - mcEventHist.fill(HIST("hRecMCEventSelection"), 7); // at least a Phi in the event - isCountedPhi = true; - } - - // V0 already reconstructed by the builder - for (const auto& v0 : V0s) { - if (!v0.has_mcParticle()) { - continue; - } - - auto v0mcparticle = v0.mcParticle(); - if (v0mcparticle.pdgCode() != PDG_t::kK0Short || !v0mcparticle.isPhysicalPrimary()) - continue; - - const auto& posDaughterTrack = v0.posTrack_as(); - const auto& negDaughterTrack = v0.negTrack_as(); - - // Cut on V0 dynamic columns - if (!selectionV0(v0, posDaughterTrack, negDaughterTrack)) - continue; - if (v0Configs.cfgFurtherV0Selection && !furtherSelectionV0(v0, collision)) - continue; - - if (std::abs(v0.yK0Short()) > cfgYAcceptance) - continue; - - mcPhiK0SHist.fill(HIST("h5PhiK0SMCClosure"), 0, genmultiplicity, v0.pt(), v0.mK0Short(), recPhi.M()); - for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { - if (std::abs(v0.yK0Short() - recPhi.Rapidity()) > cfgDeltaYAcceptanceBins->at(i)) - continue; - mcPhiK0SHist.fill(HIST("h5PhiK0SMCClosure"), i + 1, genmultiplicity, v0.pt(), v0.mK0Short(), recPhi.M()); - } - } - - // Loop over all primary pion candidates - for (const auto& track : fullMCTracks) { - if (!track.has_mcParticle()) - continue; - - auto mcTrack = track.mcParticle_as(); - if (std::abs(mcTrack.pdgCode()) != PDG_t::kPiPlus || !mcTrack.isPhysicalPrimary()) - continue; - - if (!selectionPion(track, false)) - continue; - - if (std::abs(track.rapidity(massPi)) > cfgYAcceptance) - continue; - - float nSigmaTOFPi = (track.hasTOF() ? track.tofNSigmaPi() : -999); - - mcPhiPionHist.fill(HIST("h6PhiPiMCClosure"), 0, genmultiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M()); - for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { - if (std::abs(track.rapidity(massPi) - recPhi.Rapidity()) > cfgDeltaYAcceptanceBins->at(i)) - continue; - mcPhiPionHist.fill(HIST("h6PhiPiMCClosure"), i + 1, genmultiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M()); - } - } - } - } - } - - PROCESS_SWITCH(Phik0shortanalysis, processPhiK0SPionMCReco2D, "Process function for Phi-K0S and Phi-Pion Correlations Efficiency correction in MCReco2D", false); - - // New analysis procedure void processAllPartMCReco(SimCollisions::iterator const& collision, FullMCTracks const& fullMCTracks, FullMCV0s const& V0s, V0DauMCTracks const&, MCCollisions const&, aod::McParticles const& mcParticles) { for (const auto& collision : collisions) { From 756e245fb10f99009608177013b98d23172bce6e Mon Sep 17 00:00:00 2001 From: Stefano Cannito Date: Fri, 4 Jul 2025 18:02:18 +0200 Subject: [PATCH 06/12] Fixed histo naming --- .../Tasks/Strangeness/phik0shortanalysis.cxx | 109 ++++++++++-------- 1 file changed, 64 insertions(+), 45 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx index 8f1c03e50d4..4d389540731 100644 --- a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx @@ -13,47 +13,49 @@ /// \brief Analysis task for the Phi and K0S rapidity correlations analysis /// \author Stefano Cannito (stefano.cannito@cern.ch) +#include "PWGLF/DataModel/LFStrangenessTables.h" +#include "PWGLF/DataModel/mcCentrality.h" +#include "PWGLF/Utils/inelGt.h" + +#include "Common/Core/TrackSelection.h" +#include "Common/Core/trackUtilities.h" +#include "Common/DataModel/Centrality.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Multiplicity.h" +#include "Common/DataModel/PIDResponse.h" +#include "Common/DataModel/TrackSelectionTables.h" + +#include "CCDB/BasicCCDBManager.h" +#include "CommonConstants/PhysicsConstants.h" +#include "Framework/ASoAHelpers.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/AnalysisTask.h" +#include "Framework/HistogramRegistry.h" +#include "Framework/O2DatabasePDGPlugin.h" +#include "Framework/runDataProcessing.h" +#include "ReconstructionDataFormats/Track.h" + +#include +#include +#include +#include #include #include #include #include -#include -#include +#include #include #include -#include -#include -#include #include -#include +#include -#include -#include -#include -#include #include +#include +#include +#include #include #include - -#include "Framework/runDataProcessing.h" -#include "Framework/AnalysisTask.h" -#include "Common/DataModel/EventSelection.h" -#include "PWGLF/DataModel/LFStrangenessTables.h" -#include "Common/DataModel/PIDResponse.h" -#include "Framework/ASoAHelpers.h" -#include "CommonConstants/PhysicsConstants.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/HistogramRegistry.h" -#include "ReconstructionDataFormats/Track.h" -#include "Common/DataModel/Multiplicity.h" -#include "Common/DataModel/Centrality.h" -#include "Common/DataModel/TrackSelectionTables.h" -#include "Common/Core/trackUtilities.h" -#include "Common/Core/TrackSelection.h" -#include "Framework/O2DatabasePDGPlugin.h" -#include "PWGLF/Utils/inelGt.h" -#include "PWGLF/DataModel/mcCentrality.h" -#include "CCDB/BasicCCDBManager.h" +#include using namespace o2; using namespace o2::framework; @@ -554,7 +556,7 @@ struct Phik0shortanalysis { mcPionHist.add("h3PiRapidityGenMC", "Rapidity for Pion for GenMC", kTH3F, {binnedmultAxis, binnedptPiAxis, yAxis}); // Histograms for new analysis procedure (to be finalized and renamed deleting other histograms) - dataPhiHist.add("h3PhiDataNewProc", "Invariant mass of Phi n Data", kTH3F, {binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); + dataPhiHist.add("h3PhiDataNewProc", "Invariant mass of Phi in Data", kTH3F, {binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); dataPhiK0SHist.add("h5PhiK0SDataNewProc", "2D Invariant mass of Phi and K0Short for Data", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptK0SAxis, massK0SAxis, massPhiAxis}); dataPhiPionHist.add("h6PhiPiDataNewProc", "Phi Invariant mass vs Pion nSigma TPC/TOF for Data", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, massPhiAxis}); @@ -562,7 +564,24 @@ struct Phik0shortanalysis { closureMCPhiK0SHist.add("h5PhiK0SMCClosureNewProc", "2D Invariant mass of Phi and K0Short for MC Closure Test", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptK0SAxis, massK0SAxis, massPhiAxis}); closureMCPhiPionHist.add("h6PhiPiMCClosureNewProc", "Phi Invariant mass vs Pion nSigma TPC/TOF for MC Closure Test", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, massPhiAxis}); - // Initialize CCDB only if purity is requested in the task + mcPhiHist.add("h2PhiMCRecoNewProc", "Phi in MCReco", kTH2F, {binnedmultAxis, binnedpTPhiAxis}); + mcK0SHist.add("h2K0SMCRecoNewProc", "K0S in MCReco", kTH2F, {binnedmultAxis, binnedptK0SAxis}); + mcPionHist.add("h2PiMCRecoNewProc", "Pion in MCReco", kTH2F, {binnedmultAxis, binnedptPiAxis}); + mcPionHist.add("h2PiMCReco2NewProc", "Pion in MCReco", kTH2F, {binnedmultAxis, binnedptPiAxis}); + + mcPhiHist.add("h2PhiMCGenNewProc", "Phi in MCGen", kTH2F, {binnedmultAxis, binnedpTPhiAxis}); + mcK0SHist.add("h2K0SMCGenNewProc", "K0S in MCGen", kTH2F, {binnedmultAxis, binnedptK0SAxis}); + mcPionHist.add("h2PiMCGenNewProc", "Pion in MCGen", kTH2F, {binnedmultAxis, binnedptPiAxis}); + + mcPhiHist.add("h2PhiMCGenAssocRecoNewProc", "Phi in MCGen Associated MCReco", kTH2F, {binnedmultAxis, binnedpTPhiAxis}); + mcK0SHist.add("h2K0SMCGenAssocRecoNewProc", "K0S in MCGen Associated MCReco", kTH2F, {binnedmultAxis, binnedptK0SAxis}); + mcPionHist.add("h2PiMCGenAssocRecoNewProc", "Pion in MCGen Associated MCReco", kTH2F, {binnedmultAxis, binnedptPiAxis}); + + mcPhiHist.add("h2PhiMCGenAssocRecoCheckNewProc", "Phi in MCGen Associated MCReco Check", kTH2F, {binnedmultAxis, binnedpTPhiAxis}); + mcK0SHist.add("h2K0SMCGenAssocRecoCheckNewProc", "K0S in MCGen Associated MCReco Check", kTH2F, {binnedmultAxis, binnedptK0SAxis}); + mcPionHist.add("h2PiMCGenAssocRecoCheckNewProc", "Pion in MCGen Associated MCReco Check", kTH2F, {binnedmultAxis, binnedptPiAxis}); + + // Initialize CCDB only if purity or efficiencies are requested in the task if (useCCDB) { ccdb->setURL(ccdbUrl); ccdb->setCaching(true); @@ -2694,7 +2713,7 @@ struct Phik0shortanalysis { if (pTMother < minPhiPt || std::abs(yMother) > cfgYAcceptance) continue; - mcPhiHist.fill(HIST("h2PhieffInvMass"), genmultiplicity, recPhi.M()); + mcPhiHist.fill(HIST("h2PhiMCRecoNewProc"), genmultiplicity, recPhi.Pt()); } } @@ -2719,7 +2738,7 @@ struct Phik0shortanalysis { if (std::abs(v0mcparticle.y()) > cfgYAcceptance) continue; - mcK0SHist.fill(HIST("h3K0SMCReco"), genmultiplicity, v0mcparticle.pt(), v0.mK0Short()); + mcK0SHist.fill(HIST("h2K0SMCRecoNewProc"), genmultiplicity, v0mcparticle.pt()); } // Defining tracks in the collision @@ -2752,12 +2771,12 @@ struct Phik0shortanalysis { continue; } - mcPionHist.fill(HIST("h3PiTPCMCReco"), genmultiplicity, mcTrack.pt(), track.tpcNSigmaPi()); + mcPionHist.fill(HIST("h2PiMCRecoNewProc"), genmultiplicity, mcTrack.pt()); if (track.pt() >= trackConfigs.pTToUseTOF && !track.hasTOF()) continue; - mcPionHist.fill(HIST("h4PiTPCTOFMCReco"), genmultiplicity, mcTrack.pt(), track.tpcNSigmaPi(), track.tofNSigmaPi()); + mcPionHist.fill(HIST("h2PiMCReco2NewProc"), genmultiplicity, mcTrack.pt()); } // Defining McParticles in the collision @@ -2773,7 +2792,7 @@ struct Phik0shortanalysis { if (mcParticle.pt() < minPhiPt) continue; - mcPhiHist.fill(HIST("h1PhiGenMCAssocReco"), genmultiplicity); + mcPhiHist.fill(HIST("h2PhiMCGenAssocRecoCheckNewProc"), genmultiplicity, mcParticle.pt()); // K0S selection if (mcParticle.pdgCode() != PDG_t::kK0Short) @@ -2781,7 +2800,7 @@ struct Phik0shortanalysis { if (!mcParticle.isPhysicalPrimary() || mcParticle.pt() < v0Configs.v0SettingMinPt) continue; - mcK0SHist.fill(HIST("h2K0SMCGenAssocReco"), genmultiplicity, mcParticle1.pt()); + mcK0SHist.fill(HIST("h2K0SMCGenAssocRecoCheckNewProc"), genmultiplicity, mcParticle.pt()); // Pion selection if (std::abs(mcParticle.pdgCode()) != PDG_t::kPiPlus) @@ -2789,7 +2808,7 @@ struct Phik0shortanalysis { if (!mcParticle.isPhysicalPrimary() || mcParticle.pt() < trackConfigs.cMinPionPtcut) continue; - mcPionHist.fill(HIST("h2PiMCGenAssocReco"), genmultiplicity, mcParticle1.pt()); + mcPionHist.fill(HIST("h2PiMCGenAssocRecoCheckNewProc"), genmultiplicity, mcParticle.pt()); } } } @@ -2826,9 +2845,9 @@ struct Phik0shortanalysis { if (mcParticle.pt() < minPhiPt) continue; - mcPhiHist.fill(HIST("h2PhiGenMCGenAssocReco"), genmultiplicity, mcParticle.pt()); + mcPhiHist.fill(HIST("h2PhiMCGenNewProc"), genmultiplicity, mcParticle.pt()); if (isAssocColl) - mcPhiHist.fill(HIST("h2PhiGenMCGenAssocReco2"), genmultiplicity, mcParticle.pt()); + mcPhiHist.fill(HIST("h2PhiMCGenAssocRecoNewProc"), genmultiplicity, mcParticle.pt()); // K0S selection if (mcParticle.pdgCode() != PDG_t::kK0Short) @@ -2836,9 +2855,9 @@ struct Phik0shortanalysis { if (!mcParticle.isPhysicalPrimary() || mcParticle.pt() < v0Configs.v0SettingMinPt) continue; - mcK0SHist.fill(HIST("h2K0SMCGenAssocReco"), genmultiplicity, mcParticle.pt()); + mcK0SHist.fill(HIST("h2K0SMCGenNewProc"), genmultiplicity, mcParticle.pt()); if (isAssocColl) - mcK0SHist.fill(HIST("h2K0SMCGenAssocReco2"), genmultiplicity, mcParticle.pt()); + mcK0SHist.fill(HIST("h2K0SMCGenAssocRecoNewProc"), genmultiplicity, mcParticle.pt()); // Pion selection if (std::abs(mcParticle.pdgCode()) != PDG_t::kPiPlus) @@ -2846,9 +2865,9 @@ struct Phik0shortanalysis { if (!mcParticle.isPhysicalPrimary() || mcParticle.pt() < trackConfigs.cMinPionPtcut) continue; - mcPionHist.fill(HIST("h2PiMCGenAssocReco"), genmultiplicity, mcParticle.pt()); + mcPionHist.fill(HIST("h2PiMCGenNewProc"), genmultiplicity, mcParticle.pt()); if (isAssocColl) - mcPionHist.fill(HIST("h2PiMCGenAssocReco2"), genmultiplicity, mcParticle.pt()); + mcPionHist.fill(HIST("h2PiMCGenAssocRecoNewProc"), genmultiplicity, mcParticle.pt()); } } From e88703c5707561b0330a85bb071397bedd7ee834 Mon Sep 17 00:00:00 2001 From: Stefano Cannito Date: Sat, 5 Jul 2025 12:53:16 +0200 Subject: [PATCH 07/12] Reintroduced mixing event --- .../Tasks/Strangeness/phik0shortanalysis.cxx | 146 +++++++++++++++++- 1 file changed, 143 insertions(+), 3 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx index 4d389540731..5a3b0f280a6 100644 --- a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx @@ -180,6 +180,9 @@ struct Phik0shortanalysis { Configurable fillMethodSingleWeight{"fillMethodSingleWeight", false, "Fill method Single Weight"}; Configurable useEfficiency{"useEfficiency", false, "Use efficiency for filling histograms"}; + // Configurable for event mixing + Configurable cfgNoMixedEvents{"cfgNoMixedEvents", 5, "Number of mixed events per event"}; + // Configurable for CCDB Configurable useCCDB{"useCCDB", false, "Use CCDB for corrections"}; Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "url of the ccdb repository to use"}; @@ -230,11 +233,20 @@ struct Phik0shortanalysis { using V0DauTracks = soa::Join; using V0DauMCTracks = soa::Join; - // Defining the binning policy for mixed event - using BinningTypeVertexContributor = ColumnBinningPolicy; + // Defining binning policy, axis and pairs for mixed event + ConfigurableAxis axisVertexMixing{"axisVertexMixing", {20, -10, 10}, "Z vertex axis binning for mixing"}; + ConfigurableAxis axisCentralityMixing{"axisCentralityMixing", {20, 0, 100}, "Multiplicity percentil binning for mixing"}; + + using BinningTypeVertexCent = ColumnBinningPolicy; + BinningTypeVertexCent binningOnVertexAndCent{{axisVertexMixing, axisCentralityMixing}, true}; + + Pair pairPhiK0S{binningOnVertexAndCent, cfgNoMixedEvents, -1, &cache}; + SameKindPair pairPhiPion{binningOnVertexAndCent, cfgNoMixedEvents, -1, &cache}; + // Cache for manual slicing SliceCache cache; + // Positive and negative tracks partitions Partition posTracks = aod::track::signed1Pt > trackConfigs.cfgCutCharge; Partition negTracks = aod::track::signed1Pt < trackConfigs.cfgCutCharge; @@ -2648,7 +2660,7 @@ struct Phik0shortanalysis { PROCESS_SWITCH(Phik0shortanalysis, processPhiK0SPionMCClosure2D, "Process function for Phi-K0S and Phi-Pion Correlations in MCClosure2D", false); - void processAllPartMCReco(SimCollisions::iterator const& collision, FullMCTracks const& fullMCTracks, FullMCV0s const& V0s, V0DauMCTracks const&, MCCollisions const&, aod::McParticles const& mcParticles) + void processAllPartMCReco(SimCollisions const& collisions, FullMCTracks const& fullMCTracks, FullMCV0s const& V0s, V0DauMCTracks const&, MCCollisions const&, aod::McParticles const& mcParticles) { for (const auto& collision : collisions) { if (!acceptEventQA(collision, false)) @@ -2872,6 +2884,134 @@ struct Phik0shortanalysis { } PROCESS_SWITCH(Phik0shortanalysis, processAllPartMCGen, "Process function for all particles in MCGen", false); + + void processMixingEvent(SelCollisions const& collisions, FullTracks const& fullTracks, FullV0s const& V0s, V0DauTracks const&) + { + for (auto const& [collision1, tracks1, collision2, v0s2] : o2::soa::selfCombinations(binningOnPositions, cfgNoMixedEvents, -1, collisions, collisions)) { + if (!collision1.isInelGt0() || !collision2.isInelGt0()) + continue; + + // Defining V0s from collision1 + auto V0ThisColl = V0s.sliceByCached(aod::v0::collisionId, collision1.globalIndex(), cache); + + // Defining positive and negative tracks for phi reconstruction from collision1 and collision2, respectively + auto posThisColl = posTracks->sliceByCached(aod::track::collisionId, collision1.globalIndex(), cache); + auto negThisColl = negTracks->sliceByCached(aod::track::collisionId, collision2.globalIndex(), cache); + + for (const auto& v0 : V0ThisColl) { + const auto& posDaughterTrack = v0.posTrack_as(); + const auto& negDaughterTrack = v0.negTrack_as(); + + // Cut on V0 dynamic columns + if (!selectionV0(v0, posDaughterTrack, negDaughterTrack)) + continue; + + TLorentzVector recK0S; + recK0S.SetXYZM(v0.px(), v0.py(), v0.pz(), v0.mK0Short()); + if (std::abs(recK0S.Rapidity()) > cfgInclusiveDeltay) + continue; + + // Combinatorial background simulation + for (auto& [track1, track2] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(posThisColl, negThisColl))) { + if (!selectionTrackResonance(track1) || !selectionPIDKaon(track1) || !selectionTrackResonance(track2) || !selectionPIDKaon(track2)) + continue; // topological and PID selection + + TLorentzVector recPhi; + recPhi = recMother(track1, track2, massKa, massKa); + if (std::abs(recPhi.Rapidity()) > cfgInclusiveDeltay) + continue; + } + } + + // Defining positive and negative tracks for phi reconstruction + auto posThisColl = posTracks->sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); + auto negThisColl = negTracks->sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); + + bool isCountedPhi = false; + bool isFilledhV0 = false; + + // Loop over all positive tracks + for (const auto& track1 : posThisColl) { + if (!selectionTrackResonance(track1, true) || !selectionPIDKaonpTdependent(track1)) + continue; // topological and PID selection + + dataPhiHist.fill(HIST("hEta"), track1.eta()); + dataPhiHist.fill(HIST("hNsigmaKaonTPC"), track1.tpcInnerParam(), track1.tpcNSigmaKa()); + dataPhiHist.fill(HIST("hNsigmaKaonTOF"), track1.tpcInnerParam(), track1.tofNSigmaKa()); + + auto track1ID = track1.globalIndex(); + + // Loop over all negative tracks + for (const auto& track2 : negThisColl) { + if (!selectionTrackResonance(track2, true) || !selectionPIDKaonpTdependent(track2)) + continue; // topological and PID selection + + auto track2ID = track2.globalIndex(); + if (track2ID == track1ID) + continue; // condition to avoid double counting of pair + + ROOT::Math::PxPyPzMVector recPhi = recMother(track1, track2, massKa, massKa); + if (recPhi.Pt() < minPhiPt || recPhi.Pt() > maxPhiPt) + continue; + if (std::abs(recPhi.Rapidity()) > cfgYAcceptance) + continue; + + if (!isCountedPhi) { + dataEventHist.fill(HIST("hEventSelection"), 4); // at least a Phi candidate in the event + dataEventHist.fill(HIST("hMultiplicityPercentWithPhi"), multiplicity); + isCountedPhi = true; + } + + dataPhiHist.fill(HIST("h3PhiDataNewProc"), multiplicity, recPhi.Pt(), recPhi.M()); + + // V0 already reconstructed by the builder + for (const auto& v0 : V0s) { + const auto& posDaughterTrack = v0.posTrack_as(); + const auto& negDaughterTrack = v0.negTrack_as(); + + // Cut on V0 dynamic columns + if (!selectionV0(v0, posDaughterTrack, negDaughterTrack)) + continue; + if (v0Configs.cfgFurtherV0Selection && !furtherSelectionV0(v0, collision)) + continue; + + if (!isFilledhV0) { + dataK0SHist.fill(HIST("hDCAV0Daughters"), v0.dcaV0daughters()); + dataK0SHist.fill(HIST("hV0CosPA"), v0.v0cosPA()); + + // Filling the PID of the V0 daughters in the region of the K0 peak + if (lowMK0S < v0.mK0Short() && v0.mK0Short() < upMK0S) { + dataK0SHist.fill(HIST("hNSigmaPosPionFromK0S"), posDaughterTrack.tpcInnerParam(), posDaughterTrack.tpcNSigmaPi()); + dataK0SHist.fill(HIST("hNSigmaNegPionFromK0S"), negDaughterTrack.tpcInnerParam(), negDaughterTrack.tpcNSigmaPi()); + } + } + + if (std::abs(v0.yK0Short()) > cfgYAcceptance) + continue; + + dataPhiK0SHist.fill(HIST("h5PhiK0SDataNewProc"), v0.yK0Short() - recPhi.Rapidity(), multiplicity, v0.pt(), v0.mK0Short(), recPhi.M()); + } + + isFilledhV0 = true; + + // Loop over all primary pion candidates + for (const auto& track : fullTracks) { + if (!selectionPion(track, false)) + continue; + + if (std::abs(track.rapidity(massPi)) > cfgYAcceptance) + continue; + + float nSigmaTOFPi = (track.hasTOF() ? track.tofNSigmaPi() : -999); + + dataPhiPionHist.fill(HIST("h6PhiPiDataNewProc"), track.rapidity(massPi) - recPhi.Rapidity(), multiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M()); + } + } + } + } + } + + PROCESS_SWITCH(phik0shortanalysis, processMEPhiK0S, "Process Mixed Event for Phi-K0S Analysis", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) From 11467c69b1624eab40f16e0f2f928ee28b060d16 Mon Sep 17 00:00:00 2001 From: Stefano Cannito Date: Sat, 5 Jul 2025 14:40:56 +0200 Subject: [PATCH 08/12] Polished mixing event for both associated particles --- .../Tasks/Strangeness/phik0shortanalysis.cxx | 168 +++++++----------- 1 file changed, 60 insertions(+), 108 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx index 5a3b0f280a6..32f00abd45d 100644 --- a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx @@ -79,6 +79,8 @@ struct Phik0shortanalysis { HistogramRegistry dataPhiPionHist{"dataPhiPionHist", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; HistogramRegistry mcPhiPionHist{"mcPhiPionHist", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; HistogramRegistry closureMCPhiPionHist{"closureMCPhiPionHist", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry mePhiK0SHist{"mePhiK0SHist", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry mePhiPionHist{"mePhiPionHist", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; // Configurable for event selection Configurable cutZVertex{"cutZVertex", 10.0f, "Accepted z-vertex range (cm)"}; @@ -569,12 +571,12 @@ struct Phik0shortanalysis { // Histograms for new analysis procedure (to be finalized and renamed deleting other histograms) dataPhiHist.add("h3PhiDataNewProc", "Invariant mass of Phi in Data", kTH3F, {binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); - dataPhiK0SHist.add("h5PhiK0SDataNewProc", "2D Invariant mass of Phi and K0Short for Data", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptK0SAxis, massK0SAxis, massPhiAxis}); - dataPhiPionHist.add("h6PhiPiDataNewProc", "Phi Invariant mass vs Pion nSigma TPC/TOF for Data", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, massPhiAxis}); + dataPhiK0SHist.add("h5PhiK0SDataNewProc", "2D Invariant mass of Phi and K0Short in Data", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptK0SAxis, massK0SAxis, massPhiAxis}); + dataPhiPionHist.add("h6PhiPiDataNewProc", "Phi Invariant mass vs Pion nSigma TPC/TOF in Data", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, massPhiAxis}); - closureMCPhiHist.add("h3PhiMCClosureNewProc", "Invariant mass of Phi", kTH3F, {binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); - closureMCPhiK0SHist.add("h5PhiK0SMCClosureNewProc", "2D Invariant mass of Phi and K0Short for MC Closure Test", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptK0SAxis, massK0SAxis, massPhiAxis}); - closureMCPhiPionHist.add("h6PhiPiMCClosureNewProc", "Phi Invariant mass vs Pion nSigma TPC/TOF for MC Closure Test", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, massPhiAxis}); + closureMCPhiHist.add("h3PhiMCClosureNewProc", "Invariant mass of Phi in MC Closure test", kTH3F, {binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); + closureMCPhiK0SHist.add("h5PhiK0SMCClosureNewProc", "2D Invariant mass of Phi and K0Short in MC Closure Test", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptK0SAxis, massK0SAxis, massPhiAxis}); + closureMCPhiPionHist.add("h6PhiPiMCClosureNewProc", "Phi Invariant mass vs Pion nSigma TPC/TOF in MC Closure Test", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, massPhiAxis}); mcPhiHist.add("h2PhiMCRecoNewProc", "Phi in MCReco", kTH2F, {binnedmultAxis, binnedpTPhiAxis}); mcK0SHist.add("h2K0SMCRecoNewProc", "K0S in MCReco", kTH2F, {binnedmultAxis, binnedptK0SAxis}); @@ -593,6 +595,9 @@ struct Phik0shortanalysis { mcK0SHist.add("h2K0SMCGenAssocRecoCheckNewProc", "K0S in MCGen Associated MCReco Check", kTH2F, {binnedmultAxis, binnedptK0SAxis}); mcPionHist.add("h2PiMCGenAssocRecoCheckNewProc", "Pion in MCGen Associated MCReco Check", kTH2F, {binnedmultAxis, binnedptPiAxis}); + mePhiK0SHist.add("h5PhiK0SMENewProc", "2D Invariant mass of Phi and K0Short in ME", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptK0SAxis, massK0SAxis, massPhiAxis}); + mePhiPionHist.add("h6PhiPiMENewProc", "Phi Invariant mass vs Pion nSigma TPC/TOF in ME", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, massPhiAxis}); + // Initialize CCDB only if purity or efficiencies are requested in the task if (useCCDB) { ccdb->setURL(ccdbUrl); @@ -2885,133 +2890,80 @@ struct Phik0shortanalysis { PROCESS_SWITCH(Phik0shortanalysis, processAllPartMCGen, "Process function for all particles in MCGen", false); - void processMixingEvent(SelCollisions const& collisions, FullTracks const& fullTracks, FullV0s const& V0s, V0DauTracks const&) + void processPhiK0SMixingEvent(SelCollisions const& collisions, FullTracks const& fullTracks, FullV0s const& V0s, V0DauTracks const&) { - for (auto const& [collision1, tracks1, collision2, v0s2] : o2::soa::selfCombinations(binningOnPositions, cfgNoMixedEvents, -1, collisions, collisions)) { - if (!collision1.isInelGt0() || !collision2.isInelGt0()) - continue; + for (auto const& [collision1, tracks1, collision2, v0s2] : pairPhiK0S) { + float multiplicity = collision1.centFT0M(); - // Defining V0s from collision1 - auto V0ThisColl = V0s.sliceByCached(aod::v0::collisionId, collision1.globalIndex(), cache); + auto posMixColl = posTracks->sliceByCached(aod::track::collisionId, collision1.globalIndex(), cache); + auto negMixColl = negTracks->sliceByCached(aod::track::collisionId, collision1.globalIndex(), cache); - // Defining positive and negative tracks for phi reconstruction from collision1 and collision2, respectively - auto posThisColl = posTracks->sliceByCached(aod::track::collisionId, collision1.globalIndex(), cache); - auto negThisColl = negTracks->sliceByCached(aod::track::collisionId, collision2.globalIndex(), cache); + for (const auto& [track1, track2, v0] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(posMixColl, negMixColl, v0s2))) { + if (!selectionTrackResonance(track1, true) || !selectionPIDKaonpTdependent(track1)) + continue; + if (!selectionTrackResonance(track2, true) || !selectionPIDKaonpTdependent(track2)) + continue; + if (track1.globalIndex() == track2.globalIndex()) + continue; + + ROOT::Math::PxPyPzMVector recPhi = recMother(track1, track2, massKa, massKa); + if (recPhi.Pt() < minPhiPt) + continue; + if (std::abs(recPhi.Rapidity()) > cfgYAcceptance) + continue; - for (const auto& v0 : V0ThisColl) { const auto& posDaughterTrack = v0.posTrack_as(); const auto& negDaughterTrack = v0.negTrack_as(); - // Cut on V0 dynamic columns if (!selectionV0(v0, posDaughterTrack, negDaughterTrack)) continue; - - TLorentzVector recK0S; - recK0S.SetXYZM(v0.px(), v0.py(), v0.pz(), v0.mK0Short()); - if (std::abs(recK0S.Rapidity()) > cfgInclusiveDeltay) + if (v0Configs.cfgFurtherV0Selection && !furtherSelectionV0(v0, collision2)) + continue; + if (std::abs(v0.yK0Short()) > cfgYAcceptance) continue; - // Combinatorial background simulation - for (auto& [track1, track2] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(posThisColl, negThisColl))) { - if (!selectionTrackResonance(track1) || !selectionPIDKaon(track1) || !selectionTrackResonance(track2) || !selectionPIDKaon(track2)) - continue; // topological and PID selection - - TLorentzVector recPhi; - recPhi = recMother(track1, track2, massKa, massKa); - if (std::abs(recPhi.Rapidity()) > cfgInclusiveDeltay) - continue; - } + mePhiK0SHist.fill(HIST("h5PhiK0SMENewProc"), v0.yK0Short() - recPhi.Rapidity(), multiplicity, v0.pt(), v0.mK0Short(), recPhi.M()); } + } + } - // Defining positive and negative tracks for phi reconstruction - auto posThisColl = posTracks->sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); - auto negThisColl = negTracks->sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); - - bool isCountedPhi = false; - bool isFilledhV0 = false; - - // Loop over all positive tracks - for (const auto& track1 : posThisColl) { - if (!selectionTrackResonance(track1, true) || !selectionPIDKaonpTdependent(track1)) - continue; // topological and PID selection - - dataPhiHist.fill(HIST("hEta"), track1.eta()); - dataPhiHist.fill(HIST("hNsigmaKaonTPC"), track1.tpcInnerParam(), track1.tpcNSigmaKa()); - dataPhiHist.fill(HIST("hNsigmaKaonTOF"), track1.tpcInnerParam(), track1.tofNSigmaKa()); - - auto track1ID = track1.globalIndex(); - - // Loop over all negative tracks - for (const auto& track2 : negThisColl) { - if (!selectionTrackResonance(track2, true) || !selectionPIDKaonpTdependent(track2)) - continue; // topological and PID selection - - auto track2ID = track2.globalIndex(); - if (track2ID == track1ID) - continue; // condition to avoid double counting of pair - - ROOT::Math::PxPyPzMVector recPhi = recMother(track1, track2, massKa, massKa); - if (recPhi.Pt() < minPhiPt || recPhi.Pt() > maxPhiPt) - continue; - if (std::abs(recPhi.Rapidity()) > cfgYAcceptance) - continue; - - if (!isCountedPhi) { - dataEventHist.fill(HIST("hEventSelection"), 4); // at least a Phi candidate in the event - dataEventHist.fill(HIST("hMultiplicityPercentWithPhi"), multiplicity); - isCountedPhi = true; - } - - dataPhiHist.fill(HIST("h3PhiDataNewProc"), multiplicity, recPhi.Pt(), recPhi.M()); - - // V0 already reconstructed by the builder - for (const auto& v0 : V0s) { - const auto& posDaughterTrack = v0.posTrack_as(); - const auto& negDaughterTrack = v0.negTrack_as(); - - // Cut on V0 dynamic columns - if (!selectionV0(v0, posDaughterTrack, negDaughterTrack)) - continue; - if (v0Configs.cfgFurtherV0Selection && !furtherSelectionV0(v0, collision)) - continue; - - if (!isFilledhV0) { - dataK0SHist.fill(HIST("hDCAV0Daughters"), v0.dcaV0daughters()); - dataK0SHist.fill(HIST("hV0CosPA"), v0.v0cosPA()); - - // Filling the PID of the V0 daughters in the region of the K0 peak - if (lowMK0S < v0.mK0Short() && v0.mK0Short() < upMK0S) { - dataK0SHist.fill(HIST("hNSigmaPosPionFromK0S"), posDaughterTrack.tpcInnerParam(), posDaughterTrack.tpcNSigmaPi()); - dataK0SHist.fill(HIST("hNSigmaNegPionFromK0S"), negDaughterTrack.tpcInnerParam(), negDaughterTrack.tpcNSigmaPi()); - } - } + PROCESS_SWITCH(phik0shortanalysis, processPhiK0SMixingEvent, "Process Mixed Event for Phi-K0S Analysis", false); - if (std::abs(v0.yK0Short()) > cfgYAcceptance) - continue; + void processPhiPionMixingEvent(SelCollisions const& collisions, FullTracks const& fullTracks, FullV0s const& V0s, V0DauTracks const&) + { + for (auto const& [collision1, tracks1, collision2, tracks2] : pairPhiPion) { + float multiplicity = collision1.centFT0M(); - dataPhiK0SHist.fill(HIST("h5PhiK0SDataNewProc"), v0.yK0Short() - recPhi.Rapidity(), multiplicity, v0.pt(), v0.mK0Short(), recPhi.M()); - } + auto posMixColl = posTracks->sliceByCached(aod::track::collisionId, collision1.globalIndex(), cache); + auto negMixColl = negTracks->sliceByCached(aod::track::collisionId, collision1.globalIndex(), cache); - isFilledhV0 = true; + for (const auto& [track1, track2, track] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(posMixColl, negMixColl, tracks2))) { + if (!selectionTrackResonance(track1, true) || !selectionPIDKaonpTdependent(track1)) + continue; + if (!selectionTrackResonance(track2, true) || !selectionPIDKaonpTdependent(track2)) + continue; + if (track1.globalIndex() == track2.globalIndex()) + continue; - // Loop over all primary pion candidates - for (const auto& track : fullTracks) { - if (!selectionPion(track, false)) - continue; + ROOT::Math::PxPyPzMVector recPhi = recMother(track1, track2, massKa, massKa); + if (recPhi.Pt() < minPhiPt) + continue; + if (std::abs(recPhi.Rapidity()) > cfgYAcceptance) + continue; - if (std::abs(track.rapidity(massPi)) > cfgYAcceptance) - continue; + if (!selectionPion(track, false)) + continue; + if (std::abs(track.rapidity(massPi)) > cfgYAcceptance) + continue; - float nSigmaTOFPi = (track.hasTOF() ? track.tofNSigmaPi() : -999); + float nSigmaTOFPi = (track.hasTOF() ? track.tofNSigmaPi() : -999); - dataPhiPionHist.fill(HIST("h6PhiPiDataNewProc"), track.rapidity(massPi) - recPhi.Rapidity(), multiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M()); - } - } + mePhiPionHist.fill(HIST("h6PhiPiMENewProc"), track.rapidity(massPi) - recPhi.Rapidity(), multiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M()); } } } - PROCESS_SWITCH(phik0shortanalysis, processMEPhiK0S, "Process Mixed Event for Phi-K0S Analysis", false); + PROCESS_SWITCH(phik0shortanalysis, processPhiPionMixingEvent, "Process Mixed Event for Phi-Pion Analysis", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) From 0c6ff733255905a39834e9cb49df61b223396cef Mon Sep 17 00:00:00 2001 From: Stefano Cannito Date: Sat, 5 Jul 2025 19:53:39 +0200 Subject: [PATCH 09/12] Online efficiency correction --- .../Tasks/Strangeness/phik0shortanalysis.cxx | 90 ++++++++++--------- 1 file changed, 48 insertions(+), 42 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx index 32f00abd45d..41d4c30f992 100644 --- a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx @@ -161,7 +161,7 @@ struct Phik0shortanalysis { 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"}; // Configurables for delta y selection - Configurable nBinsY{"nBinsY", 80, "Number of bins in y axis"}; + Configurable nBinsY{"nBinsY", 20, "Number of bins in y axis"}; Configurable nBinsDeltaY{"nBinsDeltaY", 20, "Number of bins in deltay axis"}; Configurable cfgYAcceptance{"cfgYAcceptance", 0.5f, "Rapidity acceptance"}; Configurable cfgYAcceptanceSmear{"cfgYAcceptanceSmear", 0.8f, "Rapidity acceptance for smearing matrix study"}; @@ -180,7 +180,7 @@ struct Phik0shortanalysis { // Configurables to choose the filling method Configurable fillMethodMultipleWeights{"fillMethodMultipleWeights", true, "Fill method Multiple Weights"}; Configurable fillMethodSingleWeight{"fillMethodSingleWeight", false, "Fill method Single Weight"}; - Configurable useEfficiency{"useEfficiency", false, "Use efficiency for filling histograms"}; + Configurable applyEfficiency{"applyEfficiency", false, "Use efficiency for filling histograms"}; // Configurable for event mixing Configurable cfgNoMixedEvents{"cfgNoMixedEvents", 5, "Number of mixed events per event"}; @@ -268,9 +268,9 @@ struct Phik0shortanalysis { std::vector> phiPurityFunctions = std::vector>(binsMult->size(), std::vector(binspTPhi->size(), nullptr)); // Efficiecy maps - TH2F* effMapPhi; - TH2F* effMapK0S; - TH2F* effMapPion; + TH3F* effMapPhi; + TH3F* effMapK0S; + TH3F* effMapPion; void init(InitContext&) { @@ -280,7 +280,7 @@ struct Phik0shortanalysis { AxisSpec sigmassPhiAxis = {nBinsMPhi, lowMPhi, upMPhi, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; AxisSpec vertexZAxis = {100, -15.f, 15.f, "vrtx_{Z} [cm]"}; AxisSpec etaAxis = {16, -trackConfigs.etaMax, trackConfigs.etaMax, "#eta"}; - AxisSpec yAxis = {nBinsY, -cfgYAcceptanceSmear, cfgYAcceptanceSmear, "#it{y}"}; + AxisSpec yAxis = {nBinsY, -cfgYAcceptance, cfgYAcceptance, "#it{y}"}; AxisSpec deltayAxis = {nBinsDeltaY, -1.0f, 1.0f, "#Delta#it{y}"}; AxisSpec multAxis = {120, 0.0f, 120.0f, "centFT0M"}; AxisSpec binnedmultAxis{(std::vector)binsMult, "centFT0M"}; @@ -578,22 +578,22 @@ struct Phik0shortanalysis { closureMCPhiK0SHist.add("h5PhiK0SMCClosureNewProc", "2D Invariant mass of Phi and K0Short in MC Closure Test", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptK0SAxis, massK0SAxis, massPhiAxis}); closureMCPhiPionHist.add("h6PhiPiMCClosureNewProc", "Phi Invariant mass vs Pion nSigma TPC/TOF in MC Closure Test", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, massPhiAxis}); - mcPhiHist.add("h2PhiMCRecoNewProc", "Phi in MCReco", kTH2F, {binnedmultAxis, binnedpTPhiAxis}); - mcK0SHist.add("h2K0SMCRecoNewProc", "K0S in MCReco", kTH2F, {binnedmultAxis, binnedptK0SAxis}); - mcPionHist.add("h2PiMCRecoNewProc", "Pion in MCReco", kTH2F, {binnedmultAxis, binnedptPiAxis}); - mcPionHist.add("h2PiMCReco2NewProc", "Pion in MCReco", kTH2F, {binnedmultAxis, binnedptPiAxis}); + mcPhiHist.add("h3PhiMCRecoNewProc", "Phi in MCReco", kTH3F, {binnedmultAxis, binnedpTPhiAxis, yAxis}); + mcK0SHist.add("h3K0SMCRecoNewProc", "K0S in MCReco", kTH3F, {binnedmultAxis, binnedptK0SAxis, yAxis}); + mcPionHist.add("h3PiMCRecoNewProc", "Pion in MCReco", kTH3F, {binnedmultAxis, binnedptPiAxis, yAxis}); + mcPionHist.add("h3PiMCReco2NewProc", "Pion in MCReco", kTH3F, {binnedmultAxis, binnedptPiAxis, yAxis}); - mcPhiHist.add("h2PhiMCGenNewProc", "Phi in MCGen", kTH2F, {binnedmultAxis, binnedpTPhiAxis}); - mcK0SHist.add("h2K0SMCGenNewProc", "K0S in MCGen", kTH2F, {binnedmultAxis, binnedptK0SAxis}); - mcPionHist.add("h2PiMCGenNewProc", "Pion in MCGen", kTH2F, {binnedmultAxis, binnedptPiAxis}); + mcPhiHist.add("h3PhiMCGenNewProc", "Phi in MCGen", kTH3F, {binnedmultAxis, binnedpTPhiAxis, yAxis}); + mcK0SHist.add("h3K0SMCGenNewProc", "K0S in MCGen", kTH3F, {binnedmultAxis, binnedptK0SAxis, yAxis}); + mcPionHist.add("h3PiMCGenNewProc", "Pion in MCGen", kTH3F, {binnedmultAxis, binnedptPiAxis, yAxis}); - mcPhiHist.add("h2PhiMCGenAssocRecoNewProc", "Phi in MCGen Associated MCReco", kTH2F, {binnedmultAxis, binnedpTPhiAxis}); - mcK0SHist.add("h2K0SMCGenAssocRecoNewProc", "K0S in MCGen Associated MCReco", kTH2F, {binnedmultAxis, binnedptK0SAxis}); - mcPionHist.add("h2PiMCGenAssocRecoNewProc", "Pion in MCGen Associated MCReco", kTH2F, {binnedmultAxis, binnedptPiAxis}); + mcPhiHist.add("h3PhiMCGenAssocRecoNewProc", "Phi in MCGen Associated MCReco", kTH3F, {binnedmultAxis, binnedpTPhiAxis, yAxis}); + mcK0SHist.add("h3K0SMCGenAssocRecoNewProc", "K0S in MCGen Associated MCReco", kTH3F, {binnedmultAxis, binnedptK0SAxis, yAxis}); + mcPionHist.add("h3PiMCGenAssocRecoNewProc", "Pion in MCGen Associated MCReco", kTH3F, {binnedmultAxis, binnedptPiAxis, yAxis}); - mcPhiHist.add("h2PhiMCGenAssocRecoCheckNewProc", "Phi in MCGen Associated MCReco Check", kTH2F, {binnedmultAxis, binnedpTPhiAxis}); - mcK0SHist.add("h2K0SMCGenAssocRecoCheckNewProc", "K0S in MCGen Associated MCReco Check", kTH2F, {binnedmultAxis, binnedptK0SAxis}); - mcPionHist.add("h2PiMCGenAssocRecoCheckNewProc", "Pion in MCGen Associated MCReco Check", kTH2F, {binnedmultAxis, binnedptPiAxis}); + mcPhiHist.add("h3PhiMCGenAssocRecoCheckNewProc", "Phi in MCGen Associated MCReco Check", kTH3F, {binnedmultAxis, binnedpTPhiAxis, yAxis}); + mcK0SHist.add("h3K0SMCGenAssocRecoCheckNewProc", "K0S in MCGen Associated MCReco Check", kTH3F, {binnedmultAxis, binnedptK0SAxis, yAxis}); + mcPionHist.add("h3PiMCGenAssocRecoCheckNewProc", "Pion in MCGen Associated MCReco Check", kTH3F, {binnedmultAxis, binnedptPiAxis, yAxis}); mePhiK0SHist.add("h5PhiK0SMENewProc", "2D Invariant mass of Phi and K0Short in ME", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptK0SAxis, massK0SAxis, massPhiAxis}); mePhiPionHist.add("h6PhiPiMENewProc", "Phi Invariant mass vs Pion nSigma TPC/TOF in ME", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, massPhiAxis}); @@ -608,7 +608,7 @@ struct Phik0shortanalysis { if (fillMethodSingleWeight) getPhiPurityFunctionsFromCCDB(); - if (useEfficiency) + if (applyEfficiency) getEfficiencyMapsFromCCDB(); else { effMapPhi = nullptr; @@ -966,17 +966,17 @@ struct Phik0shortanalysis { if (!listEfficiencyMaps) LOG(error) << "Problem getting TList object with efficiency maps!"; - effMapPhi = static_cast(listEfficiencyMaps->FindObject("h2EfficiencyPhi")); + effMapPhi = static_cast(listEfficiencyMaps->FindObject("h3EfficiencyPhi")); if (!effMapPhi) { LOG(error) << "Problem getting efficiency map for Phi!"; return; } - effMapK0S = static_cast(listEfficiencyMaps->FindObject("h2EfficiencyK0S")); + effMapK0S = static_cast(listEfficiencyMaps->FindObject("h3EfficiencyK0S")); if (!effMapK0S) { LOG(error) << "Problem getting efficiency map for K0S!"; return; } - effMapPion = static_cast(listEfficiencyMaps->FindObject("h2EfficiencyPion")); + effMapPion = static_cast(listEfficiencyMaps->FindObject("h3EfficiencyPion")); if (!effMapPion) { LOG(error) << "Problem getting efficiency map for Pion!"; return; @@ -2516,7 +2516,8 @@ struct Phik0shortanalysis { isCountedPhi = true; } - dataPhiHist.fill(HIST("h3PhiDataNewProc"), multiplicity, recPhi.Pt(), recPhi.M()); + float weightPhi = applyEfficiency ? 1.0f / (effMapPhi->Interpolate(multiplicity, recPhi.Pt(), recPhi.Rapidity())) : 1.0f; + dataPhiHist.fill(HIST("h3PhiDataNewProc"), multiplicity, recPhi.Pt(), recPhi.M(), weightPhi); // V0 already reconstructed by the builder for (const auto& v0 : V0s) { @@ -2543,7 +2544,8 @@ struct Phik0shortanalysis { if (std::abs(v0.yK0Short()) > cfgYAcceptance) continue; - dataPhiK0SHist.fill(HIST("h5PhiK0SDataNewProc"), v0.yK0Short() - recPhi.Rapidity(), multiplicity, v0.pt(), v0.mK0Short(), recPhi.M()); + float weightPhiK0S = applyEfficiency ? 1.0f / (effMapPhi->Interpolate(multiplicity, recPhi.Pt(), recPhi.Rapidity()) * effMapK0S->Interpolate(multiplicity, v0.pt(), v0.yK0Short())) : 1.0f; + dataPhiK0SHist.fill(HIST("h5PhiK0SDataNewProc"), v0.yK0Short() - recPhi.Rapidity(), multiplicity, v0.pt(), v0.mK0Short(), recPhi.M(), weightPhiK0S); } isFilledhV0 = true; @@ -2558,7 +2560,8 @@ struct Phik0shortanalysis { float nSigmaTOFPi = (track.hasTOF() ? track.tofNSigmaPi() : -999); - dataPhiPionHist.fill(HIST("h6PhiPiDataNewProc"), track.rapidity(massPi) - recPhi.Rapidity(), multiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M()); + float weightPhiPion = applyEfficiency ? 1.0f / (effMapPhi->Interpolate(multiplicity, recPhi.Pt(), recPhi.Rapidity()) * effMapPion->Interpolate(multiplicity, track.pt(), track.rapidity(massPi))) : 1.0f; + dataPhiPionHist.fill(HIST("h6PhiPiDataNewProc"), track.rapidity(massPi) - recPhi.Rapidity(), multiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M(), weightPhiPion); } } } @@ -2613,7 +2616,8 @@ struct Phik0shortanalysis { isCountedPhi = true; } - closureMCPhiHist.fill(HIST("h3PhiMCClosureNewProc"), genmultiplicity, recPhi.Pt(), recPhi.M()); + float weightPhi = applyEfficiency ? 1.0f / (effMapPhi->Interpolate(genmultiplicity, recPhi.Pt(), recPhi.Rapidity())) : 1.0f; + closureMCPhiHist.fill(HIST("h3PhiMCClosureNewProc"), genmultiplicity, recPhi.Pt(), recPhi.M(), weightPhi); // V0 already reconstructed by the builder for (const auto& v0 : V0s) { @@ -2636,7 +2640,8 @@ struct Phik0shortanalysis { if (std::abs(v0.yK0Short()) > cfgYAcceptance) continue; - closureMCPhiK0SHist.fill(HIST("h5PhiK0SMCClosureNewProc"), v0.yK0Short() - recPhi.Rapidity(), genmultiplicity, v0.pt(), v0.mK0Short(), recPhi.M()); + float weightPhiK0S = applyEfficiency ? 1.0f / (effMapPhi->Interpolate(genmultiplicity, recPhi.Pt(), recPhi.Rapidity()) * effMapK0S->Interpolate(genmultiplicity, v0.pt(), v0.yK0Short())) : 1.0f; + closureMCPhiK0SHist.fill(HIST("h5PhiK0SMCClosureNewProc"), v0.yK0Short() - recPhi.Rapidity(), genmultiplicity, v0.pt(), v0.mK0Short(), recPhi.M(), weightPhiK0S); } // Loop over all primary pion candidates @@ -2657,7 +2662,8 @@ struct Phik0shortanalysis { float nSigmaTOFPi = (track.hasTOF() ? track.tofNSigmaPi() : -999); - closureMCPhiPionHist.fill(HIST("h6PhiPiMCClosureNewProc"), track.rapidity(massPi) - recPhi.Rapidity(), genmultiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M()); + float weightPhiPion = applyEfficiency ? 1.0f / (effMapPhi->Interpolate(genmultiplicity, recPhi.Pt(), recPhi.Rapidity()) * effMapPion->Interpolate(genmultiplicity, track.pt(), track.rapidity(massPi))) : 1.0f; + closureMCPhiPionHist.fill(HIST("h6PhiPiMCClosureNewProc"), track.rapidity(massPi) - recPhi.Rapidity(), genmultiplicity, track.pt(), track.tpcNSigmaPi(), nSigmaTOFPi, recPhi.M(), weightPhiPion); } } } @@ -2730,7 +2736,7 @@ struct Phik0shortanalysis { if (pTMother < minPhiPt || std::abs(yMother) > cfgYAcceptance) continue; - mcPhiHist.fill(HIST("h2PhiMCRecoNewProc"), genmultiplicity, recPhi.Pt()); + mcPhiHist.fill(HIST("h3PhiMCRecoNewProc"), genmultiplicity, recPhi.Pt(), recPhi.Rapidity()); } } @@ -2755,7 +2761,7 @@ struct Phik0shortanalysis { if (std::abs(v0mcparticle.y()) > cfgYAcceptance) continue; - mcK0SHist.fill(HIST("h2K0SMCRecoNewProc"), genmultiplicity, v0mcparticle.pt()); + mcK0SHist.fill(HIST("h3K0SMCRecoNewProc"), genmultiplicity, v0mcparticle.pt(), v0mcparticle.y()); } // Defining tracks in the collision @@ -2788,12 +2794,12 @@ struct Phik0shortanalysis { continue; } - mcPionHist.fill(HIST("h2PiMCRecoNewProc"), genmultiplicity, mcTrack.pt()); + mcPionHist.fill(HIST("h3PiMCRecoNewProc"), genmultiplicity, mcTrack.pt(), mcTrack.y()); if (track.pt() >= trackConfigs.pTToUseTOF && !track.hasTOF()) continue; - mcPionHist.fill(HIST("h2PiMCReco2NewProc"), genmultiplicity, mcTrack.pt()); + mcPionHist.fill(HIST("h3PiMCReco2NewProc"), genmultiplicity, mcTrack.pt(), mcTrack.y()); } // Defining McParticles in the collision @@ -2809,7 +2815,7 @@ struct Phik0shortanalysis { if (mcParticle.pt() < minPhiPt) continue; - mcPhiHist.fill(HIST("h2PhiMCGenAssocRecoCheckNewProc"), genmultiplicity, mcParticle.pt()); + mcPhiHist.fill(HIST("h3PhiMCGenAssocRecoCheckNewProc"), genmultiplicity, mcParticle.pt(), mcParticle.y()); // K0S selection if (mcParticle.pdgCode() != PDG_t::kK0Short) @@ -2817,7 +2823,7 @@ struct Phik0shortanalysis { if (!mcParticle.isPhysicalPrimary() || mcParticle.pt() < v0Configs.v0SettingMinPt) continue; - mcK0SHist.fill(HIST("h2K0SMCGenAssocRecoCheckNewProc"), genmultiplicity, mcParticle.pt()); + mcK0SHist.fill(HIST("h3K0SMCGenAssocRecoCheckNewProc"), genmultiplicity, mcParticle.pt(), mcParticle.y()); // Pion selection if (std::abs(mcParticle.pdgCode()) != PDG_t::kPiPlus) @@ -2825,7 +2831,7 @@ struct Phik0shortanalysis { if (!mcParticle.isPhysicalPrimary() || mcParticle.pt() < trackConfigs.cMinPionPtcut) continue; - mcPionHist.fill(HIST("h2PiMCGenAssocRecoCheckNewProc"), genmultiplicity, mcParticle.pt()); + mcPionHist.fill(HIST("h3PiMCGenAssocRecoCheckNewProc"), genmultiplicity, mcParticle.pt(), mcParticle.y()); } } } @@ -2862,9 +2868,9 @@ struct Phik0shortanalysis { if (mcParticle.pt() < minPhiPt) continue; - mcPhiHist.fill(HIST("h2PhiMCGenNewProc"), genmultiplicity, mcParticle.pt()); + mcPhiHist.fill(HIST("h3PhiMCGenNewProc"), genmultiplicity, mcParticle.pt(), mcParticle.y()); if (isAssocColl) - mcPhiHist.fill(HIST("h2PhiMCGenAssocRecoNewProc"), genmultiplicity, mcParticle.pt()); + mcPhiHist.fill(HIST("h3PhiMCGenAssocRecoNewProc"), genmultiplicity, mcParticle.pt(), mcParticle.y()); // K0S selection if (mcParticle.pdgCode() != PDG_t::kK0Short) @@ -2872,9 +2878,9 @@ struct Phik0shortanalysis { if (!mcParticle.isPhysicalPrimary() || mcParticle.pt() < v0Configs.v0SettingMinPt) continue; - mcK0SHist.fill(HIST("h2K0SMCGenNewProc"), genmultiplicity, mcParticle.pt()); + mcK0SHist.fill(HIST("h3K0SMCGenNewProc"), genmultiplicity, mcParticle.pt(), mcParticle.y()); if (isAssocColl) - mcK0SHist.fill(HIST("h2K0SMCGenAssocRecoNewProc"), genmultiplicity, mcParticle.pt()); + mcK0SHist.fill(HIST("h3K0SMCGenAssocRecoNewProc"), genmultiplicity, mcParticle.pt(), mcParticle.y()); // Pion selection if (std::abs(mcParticle.pdgCode()) != PDG_t::kPiPlus) @@ -2882,9 +2888,9 @@ struct Phik0shortanalysis { if (!mcParticle.isPhysicalPrimary() || mcParticle.pt() < trackConfigs.cMinPionPtcut) continue; - mcPionHist.fill(HIST("h2PiMCGenNewProc"), genmultiplicity, mcParticle.pt()); + mcPionHist.fill(HIST("h3PiMCGenNewProc"), genmultiplicity, mcParticle.pt(), mcParticle.y()); if (isAssocColl) - mcPionHist.fill(HIST("h2PiMCGenAssocRecoNewProc"), genmultiplicity, mcParticle.pt()); + mcPionHist.fill(HIST("h3PiMCGenAssocRecoNewProc"), genmultiplicity, mcParticle.pt(), mcParticle.y()); } } From b6980a5851c338ac9ca92c29f58f83ba56e98676 Mon Sep 17 00:00:00 2001 From: Stefano Cannito Date: Sat, 5 Jul 2025 20:05:45 +0200 Subject: [PATCH 10/12] Finner pT binning for single-particle efficiency --- .../Tasks/Strangeness/phik0shortanalysis.cxx | 163 +++++++++--------- 1 file changed, 82 insertions(+), 81 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx index 41d4c30f992..d5e793a6f17 100644 --- a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx @@ -284,11 +284,12 @@ struct Phik0shortanalysis { AxisSpec deltayAxis = {nBinsDeltaY, -1.0f, 1.0f, "#Delta#it{y}"}; AxisSpec multAxis = {120, 0.0f, 120.0f, "centFT0M"}; AxisSpec binnedmultAxis{(std::vector)binsMult, "centFT0M"}; + AxisSpec pTPhiAxis = {120, 0.0f, 12.0f, "#it{p}_{T} (GeV/#it{c})"}; AxisSpec binnedpTPhiAxis{(std::vector)binspTPhi, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec ptK0SAxis = {60, 0.0f, 6.0f, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedptK0SAxis{(std::vector)binspTK0S, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec ptPiAxis = {30, 0.0f, 3.0f, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedptPiAxis{(std::vector)binspTPi, "#it{p}_{T} (GeV/#it{c})"}; + 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 pTPiAxis = {50, 0.0f, 5.0f, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTPiAxis{(std::vector)binspTPi, "#it{p}_{T} (GeV/#it{c})"}; // Histograms // Number of events per selection @@ -396,66 +397,66 @@ struct Phik0shortanalysis { dataK0SHist.add("hNSigmaNegPionFromK0S", "hNSigmaNegPionFromK0Short", kTH2F, {{100, 0.0, 5.0, "#it{p} (GeV/#it{c})"}, {100, -10.0f, 10.0f}}); // 2D mass of Phi and K0S for Data - dataPhiK0SHist.add("h5PhiK0SData", "2D Invariant mass of Phi and K0Short for Data", kTHnSparseF, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedptK0SAxis, massK0SAxis, sigmassPhiAxis}); + dataPhiK0SHist.add("h5PhiK0SData", "2D Invariant mass of Phi and K0Short for Data", kTHnSparseF, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTK0SAxis, massK0SAxis, sigmassPhiAxis}); dataPhiK0SHist.get(HIST("h5PhiK0SData"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { dataPhiK0SHist.get(HIST("h5PhiK0SData"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", cfgDeltaYAcceptanceBins->at(i))); } // 1D mass of K0S for Data - dataPhiK0SHist.add("h3PhiK0SSEIncNew", "Invariant mass of K0Short for Same Event Inclusive", kTH3F, {binnedmultAxis, binnedptK0SAxis, massK0SAxis}); - dataPhiK0SHist.add("h3PhiK0SSEFCutNew", "Invariant mass of K0Short for Same Event Deltay < FirstCut", kTH3F, {binnedmultAxis, binnedptK0SAxis, massK0SAxis}); - dataPhiK0SHist.add("h3PhiK0SSESCutNew", "Invariant mass of K0Short for Same Event Deltay < SecondCut", kTH3F, {binnedmultAxis, binnedptK0SAxis, massK0SAxis}); + dataPhiK0SHist.add("h3PhiK0SSEIncNew", "Invariant mass of K0Short for Same Event Inclusive", kTH3F, {binnedmultAxis, binnedpTK0SAxis, massK0SAxis}); + dataPhiK0SHist.add("h3PhiK0SSEFCutNew", "Invariant mass of K0Short for Same Event Deltay < FirstCut", kTH3F, {binnedmultAxis, binnedpTK0SAxis, massK0SAxis}); + dataPhiK0SHist.add("h3PhiK0SSESCutNew", "Invariant mass of K0Short for Same Event Deltay < SecondCut", kTH3F, {binnedmultAxis, binnedpTK0SAxis, massK0SAxis}); // K0S rapidity in Data - dataK0SHist.add("h3K0SRapidityData", "K0Short rapidity for Data", kTH3F, {binnedmultAxis, binnedptK0SAxis, yAxis}); + dataK0SHist.add("h3K0SRapidityData", "K0Short rapidity for Data", kTH3F, {binnedmultAxis, binnedpTK0SAxis, yAxis}); // RecMC K0S coupled to Phi - mcPhiK0SHist.add("h4PhiK0SMCReco", "K0S coupled to Phi in MCReco", kTHnSparseF, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedptK0SAxis, massK0SAxis}); + mcPhiK0SHist.add("h4PhiK0SMCReco", "K0S coupled to Phi in MCReco", kTHnSparseF, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTK0SAxis, massK0SAxis}); mcPhiK0SHist.get(HIST("h4PhiK0SMCReco"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { mcPhiK0SHist.get(HIST("h4PhiK0SMCReco"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", cfgDeltaYAcceptanceBins->at(i))); } // GenMC K0S coupled to Phi - mcPhiK0SHist.add("h3PhiK0SMCGen", "K0S coupled toPhi in MCGen", kTH3F, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedptK0SAxis}); + mcPhiK0SHist.add("h3PhiK0SMCGen", "K0S coupled toPhi in MCGen", kTH3F, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTK0SAxis}); mcPhiK0SHist.get(HIST("h3PhiK0SMCGen"))->GetXaxis()->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { mcPhiK0SHist.get(HIST("h3PhiK0SMCGen"))->GetXaxis()->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", cfgDeltaYAcceptanceBins->at(i))); } - mcPhiK0SHist.add("h3PhiK0SMCGenAssocReco", "K0S coupled toPhi in MCGen Associated MCReco Collision", kTH3F, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedptK0SAxis}); + mcPhiK0SHist.add("h3PhiK0SMCGenAssocReco", "K0S coupled toPhi in MCGen Associated MCReco Collision", kTH3F, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTK0SAxis}); mcPhiK0SHist.get(HIST("h3PhiK0SMCGenAssocReco"))->GetXaxis()->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { mcPhiK0SHist.get(HIST("h3PhiK0SMCGenAssocReco"))->GetXaxis()->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", cfgDeltaYAcceptanceBins->at(i))); } // 2D mass of Phi and K0S for Closure Test - closureMCPhiK0SHist.add("h5PhiK0SMCClosure", "2D Invariant mass of Phi and K0Short for MC Closure Test", kTHnSparseF, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedptK0SAxis, massK0SAxis, sigmassPhiAxis}); + closureMCPhiK0SHist.add("h5PhiK0SMCClosure", "2D Invariant mass of Phi and K0Short for MC Closure Test", kTHnSparseF, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTK0SAxis, massK0SAxis, sigmassPhiAxis}); closureMCPhiK0SHist.get(HIST("h5PhiK0SMCClosure"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { closureMCPhiK0SHist.get(HIST("h5PhiK0SMCClosure"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", cfgDeltaYAcceptanceBins->at(i))); } // 1D mass of K0S for Closure Test - closureMCPhiK0SHist.add("h3ClosureMCPhiK0SSEIncNew", "Invariant mass of K0Short for Inclusive for Closure Test", kTH3F, {binnedmultAxis, binnedptK0SAxis, massK0SAxis}); - closureMCPhiK0SHist.add("h3ClosureMCPhiK0SSEFCutNew", "Invariant mass of K0Short for Deltay < FirstCut for Closure Test", kTH3F, {binnedmultAxis, binnedptK0SAxis, massK0SAxis}); - closureMCPhiK0SHist.add("h3ClosureMCPhiK0SSESCutNew", "Invariant mass of K0Short for Deltay < SecondCut for Closure Test", kTH3F, {binnedmultAxis, binnedptK0SAxis, massK0SAxis}); + closureMCPhiK0SHist.add("h3ClosureMCPhiK0SSEIncNew", "Invariant mass of K0Short for Inclusive for Closure Test", kTH3F, {binnedmultAxis, binnedpTK0SAxis, massK0SAxis}); + closureMCPhiK0SHist.add("h3ClosureMCPhiK0SSEFCutNew", "Invariant mass of K0Short for Deltay < FirstCut for Closure Test", kTH3F, {binnedmultAxis, binnedpTK0SAxis, massK0SAxis}); + closureMCPhiK0SHist.add("h3ClosureMCPhiK0SSESCutNew", "Invariant mass of K0Short for Deltay < SecondCut for Closure Test", kTH3F, {binnedmultAxis, binnedpTK0SAxis, massK0SAxis}); // Phi mass vs Pion NSigma dE/dx for Data - dataPhiPionHist.add("h6PhiPiData", "Phi Invariant mass vs Pion nSigma TPC/TOF for Data", kTHnSparseF, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, sigmassPhiAxis}); + dataPhiPionHist.add("h6PhiPiData", "Phi Invariant mass vs Pion nSigma TPC/TOF for Data", kTHnSparseF, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, sigmassPhiAxis}); dataPhiPionHist.get(HIST("h6PhiPiData"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { dataPhiPionHist.get(HIST("h6PhiPiData"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", cfgDeltaYAcceptanceBins->at(i))); } // Pion NSigma dE/dx for Data - dataPhiPionHist.add("h4PhiPiSEIncNew", "Pion nSigma TPC/TOF for Same Event Inclusive", kTHnSparseF, {binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); - dataPhiPionHist.add("h4PhiPiSEFCutNew", "Pion nSigma TPC/TOF for Same Event Deltay < FirstCut", kTHnSparseF, {binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); - dataPhiPionHist.add("h4PhiPiSESCutNew", "Pion nSigma TPC/TOF for Same Event Deltay < SecondCut", kTHnSparseF, {binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); + dataPhiPionHist.add("h4PhiPiSEIncNew", "Pion nSigma TPC/TOF for Same Event Inclusive", kTHnSparseF, {binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); + dataPhiPionHist.add("h4PhiPiSEFCutNew", "Pion nSigma TPC/TOF for Same Event Deltay < FirstCut", kTHnSparseF, {binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); + dataPhiPionHist.add("h4PhiPiSESCutNew", "Pion nSigma TPC/TOF for Same Event Deltay < SecondCut", kTHnSparseF, {binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); // Pion rapidity in Data - dataPionHist.add("h3PiRapidityData", "Pion rapidity for Data", kTH3F, {binnedmultAxis, binnedptPiAxis, yAxis}); + dataPionHist.add("h3PiRapidityData", "Pion rapidity for Data", kTH3F, {binnedmultAxis, binnedpTPiAxis, yAxis}); // DCA plots for pions in Data dataPionHist.add("h2TracksPiDCAxyPreCutData", "Dcaxy distribution vs pt before DCAxy cut", kTH2F, {{100, 0.0, 5.0, "#it{p}_{T} (GeV/#it{c})"}, {2000, -0.05, 0.05, "DCA_{xy} (cm)"}}); @@ -470,135 +471,135 @@ struct Phik0shortanalysis { mcPionHist.add("h2TracksPiDCAzPostCutMCReco", "Dcaz distribution vs pt after DCAxy cut", kTH2F, {{100, 0.0, 5.0, "#it{p}_{T} (GeV/#it{c})"}, {2000, -0.05, 0.05, "DCA_{z} (cm)"}}); // DCA plots for pions in MCReco distinguishing Primaries, Secondaries from Weak Decay and Secondaries from Material - mcPionHist.add("h3RecMCDCAxyPrimPi", "Dcaxy distribution vs pt for Primary Pions", kTH2F, {binnedptPiAxis, {2000, -0.05, 0.05, "DCA_{xy} (cm)"}}); - mcPionHist.add("h3RecMCDCAxySecWeakDecayPi", "Dcaz distribution vs pt for Secondary Pions from Weak Decay", kTH2F, {binnedptPiAxis, {2000, -0.05, 0.05, "DCA_{xy} (cm)"}}); - mcPionHist.add("h3RecMCDCAxySecMaterialPi", "Dcaxy distribution vs pt for Secondary Pions from Material", kTH2F, {binnedptPiAxis, {2000, -0.05, 0.05, "DCA_{xy} (cm)"}}); + mcPionHist.add("h3RecMCDCAxyPrimPi", "Dcaxy distribution vs pt for Primary Pions", kTH2F, {binnedpTPiAxis, {2000, -0.05, 0.05, "DCA_{xy} (cm)"}}); + mcPionHist.add("h3RecMCDCAxySecWeakDecayPi", "Dcaz distribution vs pt for Secondary Pions from Weak Decay", kTH2F, {binnedpTPiAxis, {2000, -0.05, 0.05, "DCA_{xy} (cm)"}}); + mcPionHist.add("h3RecMCDCAxySecMaterialPi", "Dcaxy distribution vs pt for Secondary Pions from Material", kTH2F, {binnedpTPiAxis, {2000, -0.05, 0.05, "DCA_{xy} (cm)"}}); // RecMC Pion coupled to Phi with TPC - mcPhiPionHist.add("h4PhiPiTPCMCReco", "Pion coupled to Phi in MCReco (TPC)", kTHnSparseF, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}}); + mcPhiPionHist.add("h4PhiPiTPCMCReco", "Pion coupled to Phi in MCReco (TPC)", kTHnSparseF, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}}); mcPhiPionHist.get(HIST("h4PhiPiTPCMCReco"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { mcPhiPionHist.get(HIST("h4PhiPiTPCMCReco"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", cfgDeltaYAcceptanceBins->at(i))); } // RecMC Pion coupled to Phi with TPC and TOF - mcPhiPionHist.add("h5PhiPiTPCTOFMCReco", "Pion coupled to Phi in MCReco (TPC and TOF)", kTHnSparseF, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); + mcPhiPionHist.add("h5PhiPiTPCTOFMCReco", "Pion coupled to Phi in MCReco (TPC and TOF)", kTHnSparseF, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); mcPhiPionHist.get(HIST("h5PhiPiTPCTOFMCReco"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { mcPhiPionHist.get(HIST("h5PhiPiTPCTOFMCReco"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", cfgDeltaYAcceptanceBins->at(i))); } - mcPhiPionHist.add("h3PhiPiMCGen", "Pion coupled to Phi in MCGen", kTH3F, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedptPiAxis}); + mcPhiPionHist.add("h3PhiPiMCGen", "Pion coupled to Phi in MCGen", kTH3F, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis}); mcPhiPionHist.get(HIST("h3PhiPiMCGen"))->GetXaxis()->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { mcPhiPionHist.get(HIST("h3PhiPiMCGen"))->GetXaxis()->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", cfgDeltaYAcceptanceBins->at(i))); } - mcPhiPionHist.add("h3PhiPiMCGenAssocReco", "Pion coupled to Phi in MCGen Associated Reco Collision", kTH3F, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedptPiAxis}); + mcPhiPionHist.add("h3PhiPiMCGenAssocReco", "Pion coupled to Phi in MCGen Associated Reco Collision", kTH3F, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis}); mcPhiPionHist.get(HIST("h3PhiPiMCGenAssocReco"))->GetXaxis()->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { mcPhiPionHist.get(HIST("h3PhiPiMCGenAssocReco"))->GetXaxis()->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", cfgDeltaYAcceptanceBins->at(i))); } // Phi mass vs Pion NSigma dE/dx for Closure Test - closureMCPhiPionHist.add("h6PhiPiMCClosure", "Phi Invariant mass vs Pion nSigma TPC/TOF for MC Closure Test", kTHnSparseF, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, sigmassPhiAxis}); + closureMCPhiPionHist.add("h6PhiPiMCClosure", "Phi Invariant mass vs Pion nSigma TPC/TOF for MC Closure Test", kTHnSparseF, {{static_cast(cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, sigmassPhiAxis}); closureMCPhiPionHist.get(HIST("h6PhiPiMCClosure"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < cfgDeltaYAcceptanceBins->size(); i++) { closureMCPhiPionHist.get(HIST("h6PhiPiMCClosure"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", cfgDeltaYAcceptanceBins->at(i))); } // Phi mass vs Pion NSigma dE/dx for Closure Test - closureMCPhiPionHist.add("h4ClosureMCPhiPiSEIncNew", "Pion nSigma TPC/TOF for Inclusive for Closure Test", kTHnSparseF, {binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); - closureMCPhiPionHist.add("h4ClosureMCPhiPiSEFCutNew", "Pion nSigma TPC/TOF for Deltay < FirstCut for Closure Test", kTHnSparseF, {binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); - closureMCPhiPionHist.add("h4ClosureMCPhiPiSESCutNew", "Pion nSigma TPC/TOF for Deltay < SecondCut for Closure Test", kTHnSparseF, {binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); + closureMCPhiPionHist.add("h4ClosureMCPhiPiSEIncNew", "Pion nSigma TPC/TOF for Inclusive for Closure Test", kTHnSparseF, {binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); + closureMCPhiPionHist.add("h4ClosureMCPhiPiSEFCutNew", "Pion nSigma TPC/TOF for Deltay < FirstCut for Closure Test", kTHnSparseF, {binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); + closureMCPhiPionHist.add("h4ClosureMCPhiPiSESCutNew", "Pion nSigma TPC/TOF for Deltay < SecondCut for Closure Test", kTHnSparseF, {binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); // MCPhi invariant mass for computing efficiencies and MCnormalisation mcPhiHist.add("h2PhieffInvMass", "Invariant mass of Phi for Efficiency (no K0S/Pi)", kTH2F, {binnedmultAxis, massPhiAxis}); - mcPhiHist.add("h3PhieffK0SInvMassInc", "Invariant mass of Phi for Efficiency (K0S) Inclusive", kTH3F, {binnedmultAxis, binnedptK0SAxis, massPhiAxis}); - mcPhiHist.add("h3PhieffK0SInvMassFCut", "Invariant mass of Phi for Efficiency (K0S) Deltay < FirstCut", kTH3F, {binnedmultAxis, binnedptK0SAxis, massPhiAxis}); - mcPhiHist.add("h3PhieffK0SInvMassSCut", "Invariant mass of Phi for Efficiency (K0S) Deltay < SecondCut", kTH3F, {binnedmultAxis, binnedptK0SAxis, massPhiAxis}); + mcPhiHist.add("h3PhieffK0SInvMassInc", "Invariant mass of Phi for Efficiency (K0S) Inclusive", kTH3F, {binnedmultAxis, binnedpTK0SAxis, massPhiAxis}); + mcPhiHist.add("h3PhieffK0SInvMassFCut", "Invariant mass of Phi for Efficiency (K0S) Deltay < FirstCut", kTH3F, {binnedmultAxis, binnedpTK0SAxis, massPhiAxis}); + mcPhiHist.add("h3PhieffK0SInvMassSCut", "Invariant mass of Phi for Efficiency (K0S) Deltay < SecondCut", kTH3F, {binnedmultAxis, binnedpTK0SAxis, massPhiAxis}); - mcPhiHist.add("h3PhieffPiInvMassInc", "Invariant mass of Phi for Efficiency (Pi) Inclusive", kTH3F, {binnedmultAxis, binnedptPiAxis, massPhiAxis}); - mcPhiHist.add("h3PhieffPiInvMassFCut", "Invariant mass of Phi for Efficiency (Pi) Deltay < FirstCut", kTH3F, {binnedmultAxis, binnedptPiAxis, massPhiAxis}); - mcPhiHist.add("h3PhieffPiInvMassSCut", "Invariant mass of Phi for Efficiency (Pi) Deltay < SecondCut", kTH3F, {binnedmultAxis, binnedptPiAxis, massPhiAxis}); + mcPhiHist.add("h3PhieffPiInvMassInc", "Invariant mass of Phi for Efficiency (Pi) Inclusive", kTH3F, {binnedmultAxis, binnedpTPiAxis, massPhiAxis}); + mcPhiHist.add("h3PhieffPiInvMassFCut", "Invariant mass of Phi for Efficiency (Pi) Deltay < FirstCut", kTH3F, {binnedmultAxis, binnedpTPiAxis, massPhiAxis}); + mcPhiHist.add("h3PhieffPiInvMassSCut", "Invariant mass of Phi for Efficiency (Pi) Deltay < SecondCut", kTH3F, {binnedmultAxis, binnedpTPiAxis, massPhiAxis}); // GenMC Phi and Phi coupled to K0S and Pion mcPhiHist.add("h1PhiGenMC", "Phi for GenMC", kTH1F, {binnedmultAxis}); mcPhiHist.add("h1PhiGenMCAssocReco", "Phi for GenMC Associated Reco Collision", kTH1F, {binnedmultAxis}); - mcPhiHist.add("h2PhieffK0SGenMCInc", "Phi coupled to K0Short for GenMC Inclusive", kTH2F, {binnedmultAxis, binnedptK0SAxis}); - mcPhiHist.add("h2PhieffK0SGenMCFCut", "Phi coupled to K0Short for GenMC Deltay < FirstCut", kTH2F, {binnedmultAxis, binnedptK0SAxis}); - mcPhiHist.add("h2PhieffK0SGenMCSCut", "Phi coupled to K0Short for GenMC Deltay < SecondCut", kTH2F, {binnedmultAxis, binnedptK0SAxis}); + mcPhiHist.add("h2PhieffK0SGenMCInc", "Phi coupled to K0Short for GenMC Inclusive", kTH2F, {binnedmultAxis, binnedpTK0SAxis}); + mcPhiHist.add("h2PhieffK0SGenMCFCut", "Phi coupled to K0Short for GenMC Deltay < FirstCut", kTH2F, {binnedmultAxis, binnedpTK0SAxis}); + mcPhiHist.add("h2PhieffK0SGenMCSCut", "Phi coupled to K0Short for GenMC Deltay < SecondCut", kTH2F, {binnedmultAxis, binnedpTK0SAxis}); - mcPhiHist.add("h2PhieffK0SGenMCIncAssocReco", "Phi coupled to K0Short for GenMC Inclusive Associated Reco Collision", kTH2F, {binnedmultAxis, binnedptK0SAxis}); - mcPhiHist.add("h2PhieffK0SGenMCFCutAssocReco", "Phi coupled to K0Short for GenMC Deltay < FirstCut Associated Reco Collision", kTH2F, {binnedmultAxis, binnedptK0SAxis}); - mcPhiHist.add("h2PhieffK0SGenMCSCutAssocReco", "Phi coupled to K0Short for GenMC Deltay < SecondCut Associated Reco Collision", kTH2F, {binnedmultAxis, binnedptK0SAxis}); + mcPhiHist.add("h2PhieffK0SGenMCIncAssocReco", "Phi coupled to K0Short for GenMC Inclusive Associated Reco Collision", kTH2F, {binnedmultAxis, binnedpTK0SAxis}); + mcPhiHist.add("h2PhieffK0SGenMCFCutAssocReco", "Phi coupled to K0Short for GenMC Deltay < FirstCut Associated Reco Collision", kTH2F, {binnedmultAxis, binnedpTK0SAxis}); + mcPhiHist.add("h2PhieffK0SGenMCSCutAssocReco", "Phi coupled to K0Short for GenMC Deltay < SecondCut Associated Reco Collision", kTH2F, {binnedmultAxis, binnedpTK0SAxis}); - mcPhiHist.add("h2PhieffPiGenMCInc", "Phi coupled to Pion for GenMC Inclusive", kTH2F, {binnedmultAxis, binnedptPiAxis}); - mcPhiHist.add("h2PhieffPiGenMCFCut", "Phi coupled to Pion for GenMC Deltay < FirstCut", kTH2F, {binnedmultAxis, binnedptPiAxis}); - mcPhiHist.add("h2PhieffPiGenMCSCut", "Phi coupled to Pion for GenMC Deltay < SecondCut", kTH2F, {binnedmultAxis, binnedptPiAxis}); + mcPhiHist.add("h2PhieffPiGenMCInc", "Phi coupled to Pion for GenMC Inclusive", kTH2F, {binnedmultAxis, binnedpTPiAxis}); + mcPhiHist.add("h2PhieffPiGenMCFCut", "Phi coupled to Pion for GenMC Deltay < FirstCut", kTH2F, {binnedmultAxis, binnedpTPiAxis}); + mcPhiHist.add("h2PhieffPiGenMCSCut", "Phi coupled to Pion for GenMC Deltay < SecondCut", kTH2F, {binnedmultAxis, binnedpTPiAxis}); - mcPhiHist.add("h2PhieffPiGenMCIncAssocReco", "Phi coupled to Pion for GenMC Inclusive Associated Reco Collision", kTH2F, {binnedmultAxis, binnedptPiAxis}); - mcPhiHist.add("h2PhieffPiGenMCFCutAssocReco", "Phi coupled to Pion for GenMC Deltay < FirstCut Associated Reco Collision", kTH2F, {binnedmultAxis, binnedptPiAxis}); - mcPhiHist.add("h2PhieffPiGenMCSCutAssocReco", "Phi coupled to Pion for GenMC Deltay < SecondCut Associated Reco Collision", kTH2F, {binnedmultAxis, binnedptPiAxis}); + mcPhiHist.add("h2PhieffPiGenMCIncAssocReco", "Phi coupled to Pion for GenMC Inclusive Associated Reco Collision", kTH2F, {binnedmultAxis, binnedpTPiAxis}); + mcPhiHist.add("h2PhieffPiGenMCFCutAssocReco", "Phi coupled to Pion for GenMC Deltay < FirstCut Associated Reco Collision", kTH2F, {binnedmultAxis, binnedpTPiAxis}); + mcPhiHist.add("h2PhieffPiGenMCSCutAssocReco", "Phi coupled to Pion for GenMC Deltay < SecondCut Associated Reco Collision", kTH2F, {binnedmultAxis, binnedpTPiAxis}); // Rapidity smearing matrix for Phi mcPhiHist.add("h3PhiRapiditySmearing", "Rapidity Smearing Matrix for Phi", kTH3F, {binnedmultAxis, yAxis, yAxis}); // MCK0S invariant mass and GenMC K0S for computing efficiencies - mcK0SHist.add("h3K0SMCReco", "K0S for MCReco", kTH3F, {binnedmultAxis, binnedptK0SAxis, massK0SAxis}); + mcK0SHist.add("h3K0SMCReco", "K0S for MCReco", kTH3F, {binnedmultAxis, binnedpTK0SAxis, massK0SAxis}); - mcK0SHist.add("h2K0SMCGen", "K0S for MCGen", kTH2F, {binnedmultAxis, binnedptK0SAxis}); - mcK0SHist.add("h2K0SMCGenAssocReco", "K0S for MCGen Associated Reco Collision", kTH2F, {binnedmultAxis, binnedptK0SAxis}); + mcK0SHist.add("h2K0SMCGen", "K0S for MCGen", kTH2F, {binnedmultAxis, binnedpTK0SAxis}); + mcK0SHist.add("h2K0SMCGenAssocReco", "K0S for MCGen Associated Reco Collision", kTH2F, {binnedmultAxis, binnedpTK0SAxis}); // Rapidity smearing matrix for K0S and rapidity in GenMC - mcK0SHist.add("h4K0SRapiditySmearing", "Rapidity Smearing Matrix for K0Short", kTHnSparseF, {binnedmultAxis, binnedptK0SAxis, yAxis, yAxis}); + mcK0SHist.add("h4K0SRapiditySmearing", "Rapidity Smearing Matrix for K0Short", kTHnSparseF, {binnedmultAxis, binnedpTK0SAxis, yAxis, yAxis}); - mcK0SHist.add("h3K0SRapidityGenMC", "Rapidity for K0Short for GenMC", kTH3F, {binnedmultAxis, binnedptK0SAxis, yAxis}); + mcK0SHist.add("h3K0SRapidityGenMC", "Rapidity for K0Short for GenMC", kTH3F, {binnedmultAxis, binnedpTK0SAxis, yAxis}); // MCPion invariant mass and GenMC Pion for computing efficiencies - mcPionHist.add("h3PiTPCMCReco", "Pion for MCReco (TPC)", kTH3F, {binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}}); - mcPionHist.add("h4PiTPCTOFMCReco", "Pion for MCReco (TPC and TOF)", kTHnSparseF, {binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); + mcPionHist.add("h3PiTPCMCReco", "Pion for MCReco (TPC)", kTH3F, {binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}}); + mcPionHist.add("h4PiTPCTOFMCReco", "Pion for MCReco (TPC and TOF)", kTHnSparseF, {binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); - mcPionHist.add("h2PiMCGen", "Pion for GenMC", kTH2F, {binnedmultAxis, binnedptPiAxis}); - mcPionHist.add("h2PiMCGenAssocReco", "Pion for GenMC Associated Reco Collision", kTH2F, {binnedmultAxis, binnedptPiAxis}); + mcPionHist.add("h2PiMCGen", "Pion for GenMC", kTH2F, {binnedmultAxis, binnedpTPiAxis}); + mcPionHist.add("h2PiMCGenAssocReco", "Pion for GenMC Associated Reco Collision", kTH2F, {binnedmultAxis, binnedpTPiAxis}); // Rapidity smearing matrix for Pion and rapidity in GenMC - mcPionHist.add("h4PiRapiditySmearing", "Rapidity Smearing Matrix for Pion", kTHnSparseF, {binnedmultAxis, binnedptPiAxis, yAxis, yAxis}); + mcPionHist.add("h4PiRapiditySmearing", "Rapidity Smearing Matrix for Pion", kTHnSparseF, {binnedmultAxis, binnedpTPiAxis, yAxis, yAxis}); - mcPionHist.add("h3PiRapidityGenMC", "Rapidity for Pion for GenMC", kTH3F, {binnedmultAxis, binnedptPiAxis, yAxis}); + mcPionHist.add("h3PiRapidityGenMC", "Rapidity for Pion for GenMC", kTH3F, {binnedmultAxis, binnedpTPiAxis, yAxis}); // Histograms for new analysis procedure (to be finalized and renamed deleting other histograms) dataPhiHist.add("h3PhiDataNewProc", "Invariant mass of Phi in Data", kTH3F, {binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); - dataPhiK0SHist.add("h5PhiK0SDataNewProc", "2D Invariant mass of Phi and K0Short in Data", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptK0SAxis, massK0SAxis, massPhiAxis}); - dataPhiPionHist.add("h6PhiPiDataNewProc", "Phi Invariant mass vs Pion nSigma TPC/TOF in Data", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, massPhiAxis}); + dataPhiK0SHist.add("h5PhiK0SDataNewProc", "2D Invariant mass of Phi and K0Short in Data", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedpTK0SAxis, massK0SAxis, massPhiAxis}); + dataPhiPionHist.add("h6PhiPiDataNewProc", "Phi Invariant mass vs Pion nSigma TPC/TOF in Data", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, massPhiAxis}); closureMCPhiHist.add("h3PhiMCClosureNewProc", "Invariant mass of Phi in MC Closure test", kTH3F, {binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); - closureMCPhiK0SHist.add("h5PhiK0SMCClosureNewProc", "2D Invariant mass of Phi and K0Short in MC Closure Test", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptK0SAxis, massK0SAxis, massPhiAxis}); - closureMCPhiPionHist.add("h6PhiPiMCClosureNewProc", "Phi Invariant mass vs Pion nSigma TPC/TOF in MC Closure Test", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, massPhiAxis}); + closureMCPhiK0SHist.add("h5PhiK0SMCClosureNewProc", "2D Invariant mass of Phi and K0Short in MC Closure Test", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedpTK0SAxis, massK0SAxis, massPhiAxis}); + closureMCPhiPionHist.add("h6PhiPiMCClosureNewProc", "Phi Invariant mass vs Pion nSigma TPC/TOF in MC Closure Test", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, massPhiAxis}); - mcPhiHist.add("h3PhiMCRecoNewProc", "Phi in MCReco", kTH3F, {binnedmultAxis, binnedpTPhiAxis, yAxis}); - mcK0SHist.add("h3K0SMCRecoNewProc", "K0S in MCReco", kTH3F, {binnedmultAxis, binnedptK0SAxis, yAxis}); - mcPionHist.add("h3PiMCRecoNewProc", "Pion in MCReco", kTH3F, {binnedmultAxis, binnedptPiAxis, yAxis}); - mcPionHist.add("h3PiMCReco2NewProc", "Pion in MCReco", kTH3F, {binnedmultAxis, binnedptPiAxis, yAxis}); + mePhiK0SHist.add("h5PhiK0SMENewProc", "2D Invariant mass of Phi and K0Short in ME", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedpTK0SAxis, massK0SAxis, massPhiAxis}); + mePhiPionHist.add("h6PhiPiMENewProc", "Phi Invariant mass vs Pion nSigma TPC/TOF in ME", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, massPhiAxis}); - mcPhiHist.add("h3PhiMCGenNewProc", "Phi in MCGen", kTH3F, {binnedmultAxis, binnedpTPhiAxis, yAxis}); - mcK0SHist.add("h3K0SMCGenNewProc", "K0S in MCGen", kTH3F, {binnedmultAxis, binnedptK0SAxis, yAxis}); - mcPionHist.add("h3PiMCGenNewProc", "Pion in MCGen", kTH3F, {binnedmultAxis, binnedptPiAxis, yAxis}); + mcPhiHist.add("h3PhiMCRecoNewProc", "Phi in MCReco", kTH3F, {binnedmultAxis, pTPhiAxis, yAxis}); + mcK0SHist.add("h3K0SMCRecoNewProc", "K0S in MCReco", kTH3F, {binnedmultAxis, pTK0SAxis, yAxis}); + mcPionHist.add("h3PiMCRecoNewProc", "Pion in MCReco", kTH3F, {binnedmultAxis, pTPiAxis, yAxis}); + mcPionHist.add("h3PiMCReco2NewProc", "Pion in MCReco", kTH3F, {binnedmultAxis, pTPiAxis, yAxis}); - mcPhiHist.add("h3PhiMCGenAssocRecoNewProc", "Phi in MCGen Associated MCReco", kTH3F, {binnedmultAxis, binnedpTPhiAxis, yAxis}); - mcK0SHist.add("h3K0SMCGenAssocRecoNewProc", "K0S in MCGen Associated MCReco", kTH3F, {binnedmultAxis, binnedptK0SAxis, yAxis}); - mcPionHist.add("h3PiMCGenAssocRecoNewProc", "Pion in MCGen Associated MCReco", kTH3F, {binnedmultAxis, binnedptPiAxis, yAxis}); + mcPhiHist.add("h3PhiMCGenNewProc", "Phi in MCGen", kTH3F, {binnedmultAxis, pTPhiAxis, yAxis}); + mcK0SHist.add("h3K0SMCGenNewProc", "K0S in MCGen", kTH3F, {binnedmultAxis, pTK0SAxis, yAxis}); + mcPionHist.add("h3PiMCGenNewProc", "Pion in MCGen", kTH3F, {binnedmultAxis, pTPiAxis, yAxis}); - mcPhiHist.add("h3PhiMCGenAssocRecoCheckNewProc", "Phi in MCGen Associated MCReco Check", kTH3F, {binnedmultAxis, binnedpTPhiAxis, yAxis}); - mcK0SHist.add("h3K0SMCGenAssocRecoCheckNewProc", "K0S in MCGen Associated MCReco Check", kTH3F, {binnedmultAxis, binnedptK0SAxis, yAxis}); - mcPionHist.add("h3PiMCGenAssocRecoCheckNewProc", "Pion in MCGen Associated MCReco Check", kTH3F, {binnedmultAxis, binnedptPiAxis, yAxis}); + mcPhiHist.add("h3PhiMCGenAssocRecoNewProc", "Phi in MCGen Associated MCReco", kTH3F, {binnedmultAxis, pTPhiAxis, yAxis}); + mcK0SHist.add("h3K0SMCGenAssocRecoNewProc", "K0S in MCGen Associated MCReco", kTH3F, {binnedmultAxis, pTK0SAxis, yAxis}); + mcPionHist.add("h3PiMCGenAssocRecoNewProc", "Pion in MCGen Associated MCReco", kTH3F, {binnedmultAxis, pTPiAxis, yAxis}); - mePhiK0SHist.add("h5PhiK0SMENewProc", "2D Invariant mass of Phi and K0Short in ME", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptK0SAxis, massK0SAxis, massPhiAxis}); - mePhiPionHist.add("h6PhiPiMENewProc", "Phi Invariant mass vs Pion nSigma TPC/TOF in ME", kTHnSparseF, {deltayAxis, binnedmultAxis, binnedptPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, massPhiAxis}); + mcPhiHist.add("h3PhiMCGenAssocRecoCheckNewProc", "Phi in MCGen Associated MCReco Check", kTH3F, {binnedmultAxis, pTPhiAxis, yAxis}); + mcK0SHist.add("h3K0SMCGenAssocRecoCheckNewProc", "K0S in MCGen Associated MCReco Check", kTH3F, {binnedmultAxis, pTK0SAxis, yAxis}); + mcPionHist.add("h3PiMCGenAssocRecoCheckNewProc", "Pion in MCGen Associated MCReco Check", kTH3F, {binnedmultAxis, pTPiAxis, yAxis}); - // Initialize CCDB only if purity or efficiencies are requested in the task + // Initialize CCDB only if purity or efficiencies are requested in the task if (useCCDB) { ccdb->setURL(ccdbUrl); ccdb->setCaching(true); From d4e1a0b446c56e81ccb75786d5d7e27e2389afdb Mon Sep 17 00:00:00 2001 From: Stefano Cannito Date: Mon, 7 Jul 2025 12:40:11 +0200 Subject: [PATCH 11/12] Study event loss --- .../Tasks/Strangeness/phik0shortanalysis.cxx | 24 ++++++++++++------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx index d5e793a6f17..74f9ff2cb0b 100644 --- a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx @@ -337,6 +337,7 @@ struct Phik0shortanalysis { mcEventHist.add("hGenMCVertexZ", "hGenMCVertexZ", kTH1F, {vertexZAxis}); mcEventHist.add("hGenMCMultiplicityPercent", "GenMC Multiplicity Percentile", kTH1F, {binnedmultAxis}); mcEventHist.add("hGenMCAssocRecoMultiplicityPercent", "GenMC AssocReco Multiplicity Percentile", kTH1F, {binnedmultAxis}); + mcEventHist.add("hGenMCRecoMultiplicityPercent", "GenMCReco Multiplicity Percentile", kTH1F, {binnedmultAxis}); // Eta distribution for dN/deta values estimation in MC mcEventHist.add("h2RecMCEtaDistribution", "Eta vs multiplicity in MCReco", kTH2F, {binnedmultAxis, etaAxis}); @@ -599,7 +600,7 @@ struct Phik0shortanalysis { mcK0SHist.add("h3K0SMCGenAssocRecoCheckNewProc", "K0S in MCGen Associated MCReco Check", kTH3F, {binnedmultAxis, pTK0SAxis, yAxis}); mcPionHist.add("h3PiMCGenAssocRecoCheckNewProc", "Pion in MCGen Associated MCReco Check", kTH3F, {binnedmultAxis, pTPiAxis, yAxis}); - // Initialize CCDB only if purity or efficiencies are requested in the task + // Initialize CCDB only if purity or efficiencies are requested in the task if (useCCDB) { ccdb->setURL(ccdbUrl); ccdb->setCaching(true); @@ -2846,20 +2847,25 @@ struct Phik0shortanalysis { if (!pwglf::isINELgtNmc(mcParticles, 0, pdgDB)) return; - bool isAssocColl = false; + float genmultiplicity = mcCollision.centFT0M(); + + uint64_t numberAssocColl = 0; for (const auto& collision : collisions) { if (acceptEventQA(collision, false)) { - isAssocColl = true; - break; + mcEventHist.fill(HIST("hGenMCRecoMultiplicityPercent"), genmultiplicity); // Event split numerator + numberAssocColl++; } } - float genmultiplicity = mcCollision.centFT0M(); + // The inclusive number of events is the event loss denominator, + // while the number of associated events is the event loss numerator mcEventHist.fill(HIST("hGenMCMultiplicityPercent"), genmultiplicity); - if (isAssocColl) + if (numberAssocColl > 0) mcEventHist.fill(HIST("hGenMCAssocRecoMultiplicityPercent"), genmultiplicity); for (const auto& mcParticle : mcParticles) { + // The inclusive number of particles is the signal loss denominator, + // while the number of associated particles is the signal loss numerator if (std::abs(mcParticle.y()) > cfgYAcceptance) continue; @@ -2870,7 +2876,7 @@ struct Phik0shortanalysis { continue; mcPhiHist.fill(HIST("h3PhiMCGenNewProc"), genmultiplicity, mcParticle.pt(), mcParticle.y()); - if (isAssocColl) + if (numberAssocColl > 0) mcPhiHist.fill(HIST("h3PhiMCGenAssocRecoNewProc"), genmultiplicity, mcParticle.pt(), mcParticle.y()); // K0S selection @@ -2880,7 +2886,7 @@ struct Phik0shortanalysis { continue; mcK0SHist.fill(HIST("h3K0SMCGenNewProc"), genmultiplicity, mcParticle.pt(), mcParticle.y()); - if (isAssocColl) + if (numberAssocColl > 0) mcK0SHist.fill(HIST("h3K0SMCGenAssocRecoNewProc"), genmultiplicity, mcParticle.pt(), mcParticle.y()); // Pion selection @@ -2890,7 +2896,7 @@ struct Phik0shortanalysis { continue; mcPionHist.fill(HIST("h3PiMCGenNewProc"), genmultiplicity, mcParticle.pt(), mcParticle.y()); - if (isAssocColl) + if (numberAssocColl > 0) mcPionHist.fill(HIST("h3PiMCGenAssocRecoNewProc"), genmultiplicity, mcParticle.pt(), mcParticle.y()); } } From 8120c60bbe36c1a834ae80a5c6e13cee1d8a7828 Mon Sep 17 00:00:00 2001 From: Stefano Cannito Date: Tue, 8 Jul 2025 10:17:42 +0200 Subject: [PATCH 12/12] Fixed partitioning in mixed event --- .../Tasks/Strangeness/phik0shortanalysis.cxx | 51 +++++++++++-------- 1 file changed, 29 insertions(+), 22 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx index 74f9ff2cb0b..3a82e3c1c97 100644 --- a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx @@ -235,16 +235,13 @@ struct Phik0shortanalysis { using V0DauTracks = soa::Join; using V0DauMCTracks = soa::Join; - // Defining binning policy, axis and pairs for mixed event + // Defining binning policy and axis for mixed event ConfigurableAxis axisVertexMixing{"axisVertexMixing", {20, -10, 10}, "Z vertex axis binning for mixing"}; ConfigurableAxis axisCentralityMixing{"axisCentralityMixing", {20, 0, 100}, "Multiplicity percentil binning for mixing"}; using BinningTypeVertexCent = ColumnBinningPolicy; BinningTypeVertexCent binningOnVertexAndCent{{axisVertexMixing, axisCentralityMixing}, true}; - Pair pairPhiK0S{binningOnVertexAndCent, cfgNoMixedEvents, -1, &cache}; - SameKindPair pairPhiPion{binningOnVertexAndCent, cfgNoMixedEvents, -1, &cache}; - // Cache for manual slicing SliceCache cache; @@ -2738,7 +2735,7 @@ struct Phik0shortanalysis { if (pTMother < minPhiPt || std::abs(yMother) > cfgYAcceptance) continue; - mcPhiHist.fill(HIST("h3PhiMCRecoNewProc"), genmultiplicity, recPhi.Pt(), recPhi.Rapidity()); + mcPhiHist.fill(HIST("h3PhiMCRecoNewProc"), genmultiplicity, pTMother, yMother); } } @@ -2905,21 +2902,26 @@ struct Phik0shortanalysis { void processPhiK0SMixingEvent(SelCollisions const& collisions, FullTracks const& fullTracks, FullV0s const& V0s, V0DauTracks const&) { + auto tracksV0sTuple = std::make_tuple(fullTracks, V0s); + Pair pairPhiK0S{binningOnVertexAndCent, cfgNoMixedEvents, -1, collisions, tracksV0sTuple, &cache}; + for (auto const& [collision1, tracks1, collision2, v0s2] : pairPhiK0S) { float multiplicity = collision1.centFT0M(); - auto posMixColl = posTracks->sliceByCached(aod::track::collisionId, collision1.globalIndex(), cache); - auto negMixColl = negTracks->sliceByCached(aod::track::collisionId, collision1.globalIndex(), cache); + Partition posMixTracks = aod::track::signed1Pt > trackConfigs.cfgCutCharge; + posMixTracks.bindTable(tracks1); + Partition negMixTracks = aod::track::signed1Pt < trackConfigs.cfgCutCharge; + negMixTracks.bindTable(tracks1); - for (const auto& [track1, track2, v0] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(posMixColl, negMixColl, v0s2))) { - if (!selectionTrackResonance(track1, true) || !selectionPIDKaonpTdependent(track1)) + for (const auto& [posTrack1, negTrack1, v0] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(posMixTracks, negMixTracks, v0s2))) { + if (!selectionTrackResonance(posTrack1, true) || !selectionPIDKaonpTdependent(posTrack1)) continue; - if (!selectionTrackResonance(track2, true) || !selectionPIDKaonpTdependent(track2)) + if (!selectionTrackResonance(negTrack1, true) || !selectionPIDKaonpTdependent(negTrack1)) continue; - if (track1.globalIndex() == track2.globalIndex()) + if (posTrack1.globalIndex() == negTrack1.globalIndex()) continue; - ROOT::Math::PxPyPzMVector recPhi = recMother(track1, track2, massKa, massKa); + ROOT::Math::PxPyPzMVector recPhi = recMother(posTrack1, negTrack1, massKa, massKa); if (recPhi.Pt() < minPhiPt) continue; if (std::abs(recPhi.Rapidity()) > cfgYAcceptance) @@ -2940,25 +2942,30 @@ struct Phik0shortanalysis { } } - PROCESS_SWITCH(phik0shortanalysis, processPhiK0SMixingEvent, "Process Mixed Event for Phi-K0S Analysis", false); + PROCESS_SWITCH(Phik0shortanalysis, processPhiK0SMixingEvent, "Process Mixed Event for Phi-K0S Analysis", false); - void processPhiPionMixingEvent(SelCollisions const& collisions, FullTracks const& fullTracks, FullV0s const& V0s, V0DauTracks const&) + void processPhiPionMixingEvent(SelCollisions const& collisions, FullTracks const& fullTracks) { + auto tracksTuple = std::make_tuple(fullTracks); + SameKindPair pairPhiPion{binningOnVertexAndCent, cfgNoMixedEvents, -1, collisions, tracksTuple, &cache}; + for (auto const& [collision1, tracks1, collision2, tracks2] : pairPhiPion) { float multiplicity = collision1.centFT0M(); - auto posMixColl = posTracks->sliceByCached(aod::track::collisionId, collision1.globalIndex(), cache); - auto negMixColl = negTracks->sliceByCached(aod::track::collisionId, collision1.globalIndex(), cache); + Partition posMixTracks = aod::track::signed1Pt > trackConfigs.cfgCutCharge; + posMixTracks.bindTable(tracks1); + Partition negMixTracks = aod::track::signed1Pt < trackConfigs.cfgCutCharge; + negMixTracks.bindTable(tracks1); - for (const auto& [track1, track2, track] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(posMixColl, negMixColl, tracks2))) { - if (!selectionTrackResonance(track1, true) || !selectionPIDKaonpTdependent(track1)) + for (const auto& [posTrack1, negTrack1, track] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(posMixTracks, negMixTracks, tracks2))) { + if (!selectionTrackResonance(posTrack1, true) || !selectionPIDKaonpTdependent(posTrack1)) continue; - if (!selectionTrackResonance(track2, true) || !selectionPIDKaonpTdependent(track2)) + if (!selectionTrackResonance(negTrack1, true) || !selectionPIDKaonpTdependent(negTrack1)) continue; - if (track1.globalIndex() == track2.globalIndex()) + if (posTrack1.globalIndex() == negTrack1.globalIndex()) continue; - ROOT::Math::PxPyPzMVector recPhi = recMother(track1, track2, massKa, massKa); + ROOT::Math::PxPyPzMVector recPhi = recMother(posTrack1, negTrack1, massKa, massKa); if (recPhi.Pt() < minPhiPt) continue; if (std::abs(recPhi.Rapidity()) > cfgYAcceptance) @@ -2976,7 +2983,7 @@ struct Phik0shortanalysis { } } - PROCESS_SWITCH(phik0shortanalysis, processPhiPionMixingEvent, "Process Mixed Event for Phi-Pion Analysis", false); + PROCESS_SWITCH(Phik0shortanalysis, processPhiPionMixingEvent, "Process Mixed Event for Phi-Pion Analysis", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)