diff --git a/PWGCF/TwoParticleCorrelations/Tasks/lambdaOrAntiLambdaProducerWithSpin.cxx b/PWGCF/TwoParticleCorrelations/Tasks/lambdaOrAntiLambdaProducerWithSpin.cxx index 13e8add711b..72a7a8cca45 100644 --- a/PWGCF/TwoParticleCorrelations/Tasks/lambdaOrAntiLambdaProducerWithSpin.cxx +++ b/PWGCF/TwoParticleCorrelations/Tasks/lambdaOrAntiLambdaProducerWithSpin.cxx @@ -32,6 +32,7 @@ #include #include #include +#include #include #include @@ -123,6 +124,21 @@ DECLARE_SOA_COLUMN(NegTrackId, negTrackId, int64_t); DECLARE_SOA_COLUMN(Alpha, alpha, float); DECLARE_SOA_COLUMN(QtArm, qtArm, float); +// Compatible with the K0Short mass window; not a truth label +DECLARE_SOA_COLUMN(IsKShortCompatible, isKShortCompatible, bool); + +// Positive daughter: TPC momentum, dE/dx signal, and PID +DECLARE_SOA_COLUMN(PosTPCMomentum, posTPCMomentum, float); +DECLARE_SOA_COLUMN(PosTPCSignal, posTPCSignal, float); +DECLARE_SOA_COLUMN(PosTPCNSigmaPr, posTPCNSigmaPr, float); +DECLARE_SOA_COLUMN(PosTPCNSigmaPi, posTPCNSigmaPi, float); + +// Negative daughter: TPC momentum, dE/dx signal, and PID +DECLARE_SOA_COLUMN(NegTPCMomentum, negTPCMomentum, float); +DECLARE_SOA_COLUMN(NegTPCSignal, negTPCSignal, float); +DECLARE_SOA_COLUMN(NegTPCNSigmaPr, negTPCNSigmaPr, float); +DECLARE_SOA_COLUMN(NegTPCNSigmaPi, negTPCNSigmaPi, float); + } // namespace lambdaorantilambda DECLARE_SOA_TABLE(LambdaOrAntiLambdas, @@ -176,7 +192,19 @@ DECLARE_SOA_TABLE(LambdaOrAntiLambdas, lambdaorantilambda::NegTrackId, lambdaorantilambda::Alpha, - lambdaorantilambda::QtArm); + lambdaorantilambda::QtArm, + + lambdaorantilambda::IsKShortCompatible, + + lambdaorantilambda::PosTPCMomentum, + lambdaorantilambda::PosTPCSignal, + lambdaorantilambda::PosTPCNSigmaPr, + lambdaorantilambda::PosTPCNSigmaPi, + + lambdaorantilambda::NegTPCMomentum, + lambdaorantilambda::NegTPCSignal, + lambdaorantilambda::NegTPCNSigmaPr, + lambdaorantilambda::NegTPCNSigmaPi); namespace lambdahyperon { @@ -210,6 +238,18 @@ DECLARE_SOA_COLUMN(PionDcaToPV, pionDcaToPV, float); DECLARE_SOA_COLUMN(V0Radius, v0Radius, float); DECLARE_SOA_COLUMN(Alpha, alpha, float); DECLARE_SOA_COLUMN(QtArm, qtArm, float); + +// Positive daughter +DECLARE_SOA_COLUMN(PosTPCMomentum, posTPCMomentum, float); +DECLARE_SOA_COLUMN(PosTPCSignal, posTPCSignal, float); +DECLARE_SOA_COLUMN(PosTPCNSigmaPr, posTPCNSigmaPr, float); +DECLARE_SOA_COLUMN(PosTPCNSigmaPi, posTPCNSigmaPi, float); + +// Negative daughter +DECLARE_SOA_COLUMN(NegTPCMomentum, negTPCMomentum, float); +DECLARE_SOA_COLUMN(NegTPCSignal, negTPCSignal, float); +DECLARE_SOA_COLUMN(NegTPCNSigmaPr, negTPCNSigmaPr, float); +DECLARE_SOA_COLUMN(NegTPCNSigmaPi, negTPCNSigmaPi, float); } // namespace lambdahyperon DECLARE_SOA_TABLE(Lambdas, "AOD", "LAMBDAS", o2::soa::Index<>, @@ -222,7 +262,11 @@ DECLARE_SOA_TABLE(Lambdas, "AOD", "LAMBDAS", o2::soa::Index<>, lambdahyperon::PosTrackId, lambdahyperon::NegTrackId, lambdahyperon::CosPA, lambdahyperon::DcaDau, lambdahyperon::DcaV0ToPV, lambdahyperon::ProtonDcaToPV, lambdahyperon::PionDcaToPV, - lambdahyperon::V0Radius, lambdahyperon::Alpha, lambdahyperon::QtArm); + lambdahyperon::V0Radius, lambdahyperon::Alpha, lambdahyperon::QtArm, + lambdahyperon::PosTPCMomentum, lambdahyperon::PosTPCSignal, + lambdahyperon::PosTPCNSigmaPr, lambdahyperon::PosTPCNSigmaPi, + lambdahyperon::NegTPCMomentum, lambdahyperon::NegTPCSignal, + lambdahyperon::NegTPCNSigmaPr, lambdahyperon::NegTPCNSigmaPi); DECLARE_SOA_TABLE(AntiLambdas, "AOD", "ANTILAMBDAS", o2::soa::Index<>, lambdahyperon::CollisionId, @@ -234,7 +278,11 @@ DECLARE_SOA_TABLE(AntiLambdas, "AOD", "ANTILAMBDAS", o2::soa::Index<>, lambdahyperon::PosTrackId, lambdahyperon::NegTrackId, lambdahyperon::CosPA, lambdahyperon::DcaDau, lambdahyperon::DcaV0ToPV, lambdahyperon::ProtonDcaToPV, lambdahyperon::PionDcaToPV, - lambdahyperon::V0Radius, lambdahyperon::Alpha, lambdahyperon::QtArm); + lambdahyperon::V0Radius, lambdahyperon::Alpha, lambdahyperon::QtArm, + lambdahyperon::PosTPCMomentum, lambdahyperon::PosTPCSignal, + lambdahyperon::PosTPCNSigmaPr, lambdahyperon::PosTPCNSigmaPi, + lambdahyperon::NegTPCMomentum, lambdahyperon::NegTPCSignal, + lambdahyperon::NegTPCNSigmaPr, lambdahyperon::NegTPCNSigmaPi); // ===================================================================== // MC-reconstructed Lambda/anti-Lambda candidates @@ -305,6 +353,9 @@ DECLARE_SOA_COLUMN(PieDcaToPV, pieDcaToPV, float); DECLARE_SOA_COLUMN(PieTPCCrossedRows, pieTPCCrossedRows, int); DECLARE_SOA_COLUMN(PieTPCNSigma, pieTPCNSigma, float); +// KShort Mass Campatability +DECLARE_SOA_COLUMN(IsKShortCompatible, isKShortCompatible, bool); + } // namespace mcrecolambda DECLARE_SOA_TABLE(McRecoLambdaCandidates, @@ -365,7 +416,8 @@ DECLARE_SOA_TABLE(McRecoLambdaCandidates, mcrecolambda::PiePhi, mcrecolambda::PieDcaToPV, mcrecolambda::PieTPCCrossedRows, - mcrecolambda::PieTPCNSigma); + mcrecolambda::PieTPCNSigma, + mcrecolambda::IsKShortCompatible); // ===================================================================== // MC-generated Lambda/anti-Lambda candidates @@ -409,6 +461,7 @@ struct LambdaOrAntiLambdaProducerWithSpin { Configurable minTPCCrossedRows{"minTPCCrossedRows", 70, "Minimum number of TPC crossed rows"}; Configurable maxTPCNSigma{"maxTPCNSigma", 3.0f, "Maximum absolute TPC PID n-sigma"}; + Configurable kShortRejectionWindow{"kShortRejectionWindow", 0.001f, "K0Short mass rejection half-window (GeV/c2)"}; ConfigurableAxis axisInvariantMass{"axisInvariantMass", {100, 1.08f, 1.2f}, "Invariant-mass axis"}; ConfigurableAxis axisLambdaAntiLambdaPt{"axisLambdaAntiLambdaPt", {200, 0.f, 10.f}, "LambdaAntiLambda transverse-momentum axis"}; @@ -466,6 +519,16 @@ struct LambdaOrAntiLambdaProducerWithSpin { rLambdaOrAntiLambda.add("Pion/hPhi", "Pion azimuth;#varphi;entries", HistType::kTH1F, {{72, 0.f, o2::constants::math::TwoPI}}); rLambdaOrAntiLambda.add("Pion/hDcaToPV", "Pion DCA to PV;DCA (cm);entries", HistType::kTH1F, {{200, 0.f, 10.f}}); + // Positive daughter: measured signal and both PID hypotheses + rLambdaOrAntiLambda.add("Positive/hTPCdEdxVsP", "Positive daughter;p_{TPC} (GeV/c);TPC dE/dx (arb. units)", HistType::kTH2F, {{200, 0.f, 10.f}, {500, 0.f, 1000.f}}); + rLambdaOrAntiLambda.add("Positive/hTPCNSigmaPrVsP", "Positive daughter, proton hypothesis;p_{TPC} (GeV/c);TPC n#sigma_{p}", HistType::kTH2F, {{200, 0.f, 10.f}, {200, -10.f, 10.f}}); + rLambdaOrAntiLambda.add("Positive/hTPCNSigmaPiVsP", "Positive daughter, pion hypothesis;p_{TPC} (GeV/c);TPC n#sigma_{#pi}", HistType::kTH2F, {{200, 0.f, 10.f}, {200, -10.f, 10.f}}); + + // Negative daughter: measured signal and both PID hypotheses + rLambdaOrAntiLambda.add("Negative/hTPCdEdxVsP", "Negative daughter;p_{TPC} (GeV/c);TPC dE/dx (arb. units)", HistType::kTH2F, {{200, 0.f, 10.f}, {500, 0.f, 1000.f}}); + rLambdaOrAntiLambda.add("Negative/hTPCNSigmaPrVsP", "Negative daughter, antiproton hypothesis;p_{TPC} (GeV/c);TPC n#sigma_{#bar{p}}", HistType::kTH2F, {{200, 0.f, 10.f}, {200, -10.f, 10.f}}); + rLambdaOrAntiLambda.add("Negative/hTPCNSigmaPiVsP", "Negative daughter, pion hypothesis;p_{TPC} (GeV/c);TPC n#sigma_{#pi}", HistType::kTH2F, {{200, 0.f, 10.f}, {200, -10.f, 10.f}}); + // Armenteros-Podolanski rLambdaOrAntiLambda.add("Armenteros/hAlpha", "Armenteros #alpha;#alpha;entries", HistType::kTH1F, {{200, -1.f, 1.f}}); rLambdaOrAntiLambda.add("Armenteros/hQtArm", "Armenteros q_{T};q_{T} (GeV/c);entries", HistType::kTH1F, {{200, 0.f, 0.4f}}); @@ -494,6 +557,9 @@ struct LambdaOrAntiLambdaProducerWithSpin { continue; } + const bool isKShortCompatible = + std::abs(v0.mK0Short() - o2::constants::physics::MassK0Short) <= kShortRejectionWindow.value; + const bool isLambda = std::abs(posTrack.tpcNSigmaPr()) < maxTPCNSigma && std::abs(negTrack.tpcNSigmaPi()) < maxTPCNSigma; @@ -575,7 +641,22 @@ struct LambdaOrAntiLambdaProducerWithSpin { // Armenteros-Podolanski v0.alpha(), - v0.qtarm()); + v0.qtarm(), + + // K0 Mass Comaptablity test + isKShortCompatible, + + // Positive daughter: measured signal and both PID hypotheses + posTrack.tpcInnerParam(), + posTrack.tpcSignal(), + posTrack.tpcNSigmaPr(), + posTrack.tpcNSigmaPi(), + + // Negative daughter: measured signal and both PID hypotheses + negTrack.tpcInnerParam(), + negTrack.tpcSignal(), + negTrack.tpcNSigmaPr(), + negTrack.tpcNSigmaPi()); rLambdaOrAntiLambda.fill(HIST("Event/hCentrality"), collision.centFT0M()); @@ -619,6 +700,16 @@ struct LambdaOrAntiLambdaProducerWithSpin { rLambdaOrAntiLambda.fill(HIST("Armenteros/hAlpha"), v0.alpha()); rLambdaOrAntiLambda.fill(HIST("Armenteros/hQtArm"), v0.qtarm()); rLambdaOrAntiLambda.fill(HIST("Armenteros/hAlphaVsQt"), v0.alpha(), v0.qtarm()); + + // Positive daughter: before PID selection + rLambdaOrAntiLambda.fill(HIST("Positive/hTPCdEdxVsP"), posTrack.tpcInnerParam(), posTrack.tpcSignal()); + rLambdaOrAntiLambda.fill(HIST("Positive/hTPCNSigmaPrVsP"), posTrack.tpcInnerParam(), posTrack.tpcNSigmaPr()); + rLambdaOrAntiLambda.fill(HIST("Positive/hTPCNSigmaPiVsP"), posTrack.tpcInnerParam(), posTrack.tpcNSigmaPi()); + + // Negative daughter: before PID selection + rLambdaOrAntiLambda.fill(HIST("Negative/hTPCdEdxVsP"), negTrack.tpcInnerParam(), negTrack.tpcSignal()); + rLambdaOrAntiLambda.fill(HIST("Negative/hTPCNSigmaPrVsP"), negTrack.tpcInnerParam(), negTrack.tpcNSigmaPr()); + rLambdaOrAntiLambda.fill(HIST("Negative/hTPCNSigmaPiVsP"), negTrack.tpcInnerParam(), negTrack.tpcNSigmaPi()); } } void processDummy(aod::Collisions const&) {} @@ -680,6 +771,16 @@ struct LambdaAntiLambdaSelector { rSelected.add((prefix + "/Armenteros/hAlpha").c_str(), "Armenteros #alpha;#alpha;entries", HistType::kTH1F, {{200, -1.f, 1.f}}); rSelected.add((prefix + "/Armenteros/hQtArm").c_str(), "Armenteros q_{T};q_{T} (GeV/c);entries", HistType::kTH1F, {{200, 0.f, 0.4f}}); rSelected.add((prefix + "/Armenteros/hAlphaVsQt").c_str(), "Armenteros-Podolanski;#alpha;q_{T} (GeV/c)", HistType::kTH2F, {{200, -1.f, 1.f}, {200, 0.f, 0.4f}}); + + // Positive daughter + rSelected.add((prefix + "/Positive/hTPCdEdxVsP").c_str(), "Positive daughter;p_{TPC} (GeV/c);TPC dE/dx (arb. units)", HistType::kTH2F, {{200, 0.f, 10.f}, {500, 0.f, 1000.f}}); + rSelected.add((prefix + "/Positive/hTPCNSigmaPrVsP").c_str(), "Positive daughter, proton hypothesis;p_{TPC} (GeV/c);TPC n#sigma_{p}", HistType::kTH2F, {{200, 0.f, 10.f}, {200, -10.f, 10.f}}); + rSelected.add((prefix + "/Positive/hTPCNSigmaPiVsP").c_str(), "Positive daughter, pion hypothesis;p_{TPC} (GeV/c);TPC n#sigma_{#pi}", HistType::kTH2F, {{200, 0.f, 10.f}, {200, -10.f, 10.f}}); + + // Negative daughter + rSelected.add((prefix + "/Negative/hTPCdEdxVsP").c_str(), "Negative daughter;p_{TPC} (GeV/c);TPC dE/dx (arb. units)", HistType::kTH2F, {{200, 0.f, 10.f}, {500, 0.f, 1000.f}}); + rSelected.add((prefix + "/Negative/hTPCNSigmaPrVsP").c_str(), "Negative daughter, antiproton hypothesis;p_{TPC} (GeV/c);TPC n#sigma_{#bar{p}}", HistType::kTH2F, {{200, 0.f, 10.f}, {200, -10.f, 10.f}}); + rSelected.add((prefix + "/Negative/hTPCNSigmaPiVsP").c_str(), "Negative daughter, pion hypothesis;p_{TPC} (GeV/c);TPC n#sigma_{#pi}", HistType::kTH2F, {{200, 0.f, 10.f}, {200, -10.f, 10.f}}); } void init(InitContext const&) @@ -720,6 +821,14 @@ struct LambdaAntiLambdaSelector { rSelected.fill(HIST("Lambda/Armenteros/hAlpha"), candidate.alpha()); rSelected.fill(HIST("Lambda/Armenteros/hQtArm"), candidate.qtArm()); rSelected.fill(HIST("Lambda/Armenteros/hAlphaVsQt"), candidate.alpha(), candidate.qtArm()); + + rSelected.fill(HIST("Lambda/Positive/hTPCdEdxVsP"), candidate.posTPCMomentum(), candidate.posTPCSignal()); + rSelected.fill(HIST("Lambda/Positive/hTPCNSigmaPrVsP"), candidate.posTPCMomentum(), candidate.posTPCNSigmaPr()); + rSelected.fill(HIST("Lambda/Positive/hTPCNSigmaPiVsP"), candidate.posTPCMomentum(), candidate.posTPCNSigmaPi()); + + rSelected.fill(HIST("Lambda/Negative/hTPCdEdxVsP"), candidate.negTPCMomentum(), candidate.negTPCSignal()); + rSelected.fill(HIST("Lambda/Negative/hTPCNSigmaPrVsP"), candidate.negTPCMomentum(), candidate.negTPCNSigmaPr()); + rSelected.fill(HIST("Lambda/Negative/hTPCNSigmaPiVsP"), candidate.negTPCMomentum(), candidate.negTPCNSigmaPi()); } else { rSelected.fill(HIST("AntiLambda/Event/hCentrality"), candidate.centrality()); rSelected.fill(HIST("AntiLambda/Event/hMultiplicity"), candidate.multiplicity()); @@ -748,6 +857,14 @@ struct LambdaAntiLambdaSelector { rSelected.fill(HIST("AntiLambda/Armenteros/hAlpha"), candidate.alpha()); rSelected.fill(HIST("AntiLambda/Armenteros/hQtArm"), candidate.qtArm()); rSelected.fill(HIST("AntiLambda/Armenteros/hAlphaVsQt"), candidate.alpha(), candidate.qtArm()); + + rSelected.fill(HIST("AntiLambda/Positive/hTPCdEdxVsP"), candidate.posTPCMomentum(), candidate.posTPCSignal()); + rSelected.fill(HIST("AntiLambda/Positive/hTPCNSigmaPrVsP"), candidate.posTPCMomentum(), candidate.posTPCNSigmaPr()); + rSelected.fill(HIST("AntiLambda/Positive/hTPCNSigmaPiVsP"), candidate.posTPCMomentum(), candidate.posTPCNSigmaPi()); + + rSelected.fill(HIST("AntiLambda/Negative/hTPCdEdxVsP"), candidate.negTPCMomentum(), candidate.negTPCSignal()); + rSelected.fill(HIST("AntiLambda/Negative/hTPCNSigmaPrVsP"), candidate.negTPCMomentum(), candidate.negTPCNSigmaPr()); + rSelected.fill(HIST("AntiLambda/Negative/hTPCNSigmaPiVsP"), candidate.negTPCMomentum(), candidate.negTPCNSigmaPi()); } } // ================================================================ @@ -845,7 +962,7 @@ struct LambdaAntiLambdaSelector { Configurable minLambdaPt{"minLambdaPt", 0.5f, "Minimum Lambda pT (GeV/c)"}; - Configurable maxLambdaPt{"maxLambdaPt", 4.5f, "Maximum Lambda pT (GeV/c)"}; + Configurable maxLambdaPt{"maxLambdaPt", 5.0f, "Maximum Lambda pT (GeV/c)"}; Configurable maxLambdaRapidity{"maxLambdaRapidity", 0.5f, "Maximum absolute Lambda rapidity"}; @@ -860,6 +977,12 @@ struct LambdaAntiLambdaSelector { aod::lambdaorantilambda::pt < maxLambdaPt&& nabs(aod::lambdaorantilambda::rapidity) < maxLambdaRapidity; + // ===================================================================== + // Applying KShort Mass Compatablilty Filtere + // ===================================================================== + + Filter kShortRejectionFilter = + aod::lambdaorantilambda::isKShortCompatible == false; // All compatible filters above are combined with logical AND. using SelectedLambdaOrAntiLambdas = soa::Filtered; @@ -916,7 +1039,17 @@ struct LambdaAntiLambdaSelector { candidate.v0Radius(), candidate.alpha(), - candidate.qtArm()); + candidate.qtArm(), + + candidate.posTPCMomentum(), + candidate.posTPCSignal(), + candidate.posTPCNSigmaPr(), + candidate.posTPCNSigmaPi(), + + candidate.negTPCMomentum(), + candidate.negTPCSignal(), + candidate.negTPCNSigmaPr(), + candidate.negTPCNSigmaPi()); } // ============================================================ @@ -959,7 +1092,17 @@ struct LambdaAntiLambdaSelector { candidate.v0Radius(), candidate.alpha(), - candidate.qtArm()); + candidate.qtArm(), + + candidate.posTPCMomentum(), + candidate.posTPCSignal(), + candidate.posTPCNSigmaPr(), + candidate.posTPCNSigmaPi(), + + candidate.negTPCMomentum(), + candidate.negTPCSignal(), + candidate.negTPCNSigmaPr(), + candidate.negTPCNSigmaPi()); } } void processDummy(aod::Collisions const&) {} @@ -979,6 +1122,7 @@ struct LambdaAntiLambdaMcRecoTableProducer { // ================================================================ Configurable maxTPCNSigma{"maxTPCNSigma", 3.f, "Maximum TPC PID n-sigma"}; + Configurable kShortRejectionWindow{"kShortRejectionWindow", 0.001f, "K0Short mass rejection half-window (GeV/c2)"}; // ================================================================ // Lambda/anti-Lambda invariant-mass selection @@ -1009,6 +1153,9 @@ struct LambdaAntiLambdaMcRecoTableProducer { auto posTrack = v0.posTrack_as(); auto negTrack = v0.negTrack_as(); + const bool isKShortCompatible = + std::abs(v0.mK0Short() - o2::constants::physics::MassK0Short) <= kShortRejectionWindow.value; + const bool isLambda = std::abs(posTrack.tpcNSigmaPr()) < maxTPCNSigma && std::abs(negTrack.tpcNSigmaPi()) < maxTPCNSigma; @@ -1140,7 +1287,8 @@ struct LambdaAntiLambdaMcRecoTableProducer { pionTrack.phi(), pionDcaToPV, static_cast(pionTrack.tpcNClsCrossedRows()), - pionTrack.tpcNSigmaPi()); + pionTrack.tpcNSigmaPi(), + isKShortCompatible); } } @@ -1228,7 +1376,7 @@ struct LambdaAntiLambdaEfficiencyPlots { // ================================================================ Configurable minLambdaPt{"minLambdaPt", 0.5f, "Minimum Lambda pT"}; - Configurable maxLambdaPt{"maxLambdaPt", 4.5f, "Maximum Lambda pT"}; + Configurable maxLambdaPt{"maxLambdaPt", 5.0f, "Maximum Lambda pT"}; Configurable maxLambdaRapidity{"maxLambdaRapidity", 0.5f, "Maximum absolute Lambda rapidity"}; Filter mcRecoKinematicFilter = aod::mcrecolambda::recoPt > minLambdaPt&& @@ -1247,6 +1395,13 @@ struct LambdaAntiLambdaEfficiencyPlots { nabs(aod::mcrecolambda::proEta) < maxDaughterEta&& nabs(aod::mcrecolambda::pieEta) < maxDaughterEta&& aod::mcrecolambda::proTPCCrossedRows >= minTPCCrossedRows&& aod::mcrecolambda::pieTPCCrossedRows >= minTPCCrossedRows; + Configurable minLambdaMass{"minLambdaMass", 1.11f, "Minimum Lambda mass (GeV/c2)"}; + Configurable maxLambdaMass{"maxLambdaMass", 1.12f, "Maximum Lambda mass (GeV/c2)"}; + + Filter mcRecoMassFilter = aod::mcrecolambda::massLambda >= minLambdaMass && aod::mcrecolambda::massLambda <= maxLambdaMass; + + Filter mcRecoKShortRejectionFilter = aod::mcrecolambda::isKShortCompatible == false; + void addEfficiencyPlotsHistograms(std::string const& particle) { const std::string recoDirectory = particle + "/Reco/"; @@ -1375,14 +1530,18 @@ struct LambdaAntiLambdaSelectionCutFlow { // Lambda kinematics Configurable minLambdaPt{"minLambdaPt", 0.5f, "Minimum Lambda pT"}; - Configurable maxLambdaPt{"maxLambdaPt", 4.5f, "Maximum Lambda pT"}; + Configurable maxLambdaPt{"maxLambdaPt", 5.0f, "Maximum Lambda pT"}; Configurable maxLambdaRapidity{"maxLambdaRapidity", 0.5f, "Maximum absolute Lambda rapidity"}; + // Lambda Mass Cuts + Configurable minLambdaMass{"minLambdaMass", 1.11f, "Minimum Lambda mass (GeV/c2)"}; + Configurable maxLambdaMass{"maxLambdaMass", 1.12f, "Maximum Lambda mass (GeV/c2)"}; + void init(InitContext const&) { AxisSpec eventCutAxis{3, -0.5, 2.5, "Event-selection stage"}; - AxisSpec lambdaCutAxis{8, -0.5, 7.5, "Candidate-selection stage"}; + AxisSpec lambdaCutAxis{10, -0.5, 9.5, "Candidate-selection stage"}; cutFlowRegistry.add("Event/hCutFlow", "Event cut flow;Selection;Collisions", HistType::kTH1D, {eventCutAxis}); cutFlowRegistry.add("Lambda/hCutFlow", "Lambda cut flow;Selection;Candidates", HistType::kTH1D, {lambdaCutAxis}); @@ -1407,6 +1566,8 @@ struct LambdaAntiLambdaSelectionCutFlow { histogram->GetXaxis()->SetBinLabel(6, "TPC crossed rows"); histogram->GetXaxis()->SetBinLabel(7, "V0 topology"); histogram->GetXaxis()->SetBinLabel(8, "Lambda kinematics"); + histogram->GetXaxis()->SetBinLabel(9, "K0Short rejection"); + histogram->GetXaxis()->SetBinLabel(10, "Lambda mass window"); } } @@ -1487,6 +1648,17 @@ struct LambdaAntiLambdaSelectionCutFlow { continue; } fillStage(7.f); + + if (candidate.isKShortCompatible()) { + continue; + } + fillStage(8.f); + + if (candidate.massLambda() < minLambdaMass.value || + candidate.massLambda() > maxLambdaMass.value) { + continue; + } + fillStage(9.f); } } void processDummy(aod::Collisions const&) {} @@ -1526,6 +1698,11 @@ struct LambdaAntiLambdaPairAnalysis { Configurable sameEventShortRangePairMaxDeltaRapidity{"sameEventShortRangePairMaxDeltaRapidity", 0.5f, "ShortRangePai Maximum absolute rapidity difference for same-event pairs"}; Configurable sameEventShortRangePairMaxDeltaPhi{"sameEventShortRangePairMaxDeltaPhi", 1.047f, "ShortRangePai Maximum absolute wrapped phi difference for same-event pairs"}; // Pi/3 =1.047 + // For JackKnife Method of Error estemation + Configurable jackknife{"jackknife", false, "Enable leave-one-group-out jackknife"}; + Configurable jackknifeExcludedGroup{"jackknifeExcludedGroup", 0, "Group to exclude: 0 to 9"}; + static constexpr int NJackknifeGroups = 10; + void addHistograms(TString const& candidate1, TString const& candidate2) { //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Same-Event~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -1727,6 +1904,9 @@ struct LambdaAntiLambdaPairAnalysis { addHistograms("Lambda", "AntiLambda"); addHistograms("Lambda", "Lambda"); addHistograms("AntiLambda", "AntiLambda"); + if (jackknife.value && (jackknifeExcludedGroup.value < 0 || jackknifeExcludedGroup.value >= NJackknifeGroups)) { + LOGF(fatal, "jackknifeExcludedGroup must be between 0 and 9"); + } } ROOT::Math::PxPyPzMVector daughterInParentRestFrame(float parentLambdaPx, float parentLambdaPy, float parentLambdaPz, float parentLambdaMass, float daughterProtonPx, float daughterProtonPy, float daughterProtonPz, float daughterProtonMass) @@ -2264,6 +2444,9 @@ struct LambdaAntiLambdaPairAnalysis { static constexpr int MinimumSameSpeciesCandidates = 2; for (auto const& collision : collisions) { + if (jackknife.value && collision.globalIndex() % NJackknifeGroups == jackknifeExcludedGroup.value) { + continue; + } const auto lambdasThisCollision = lambdas.sliceBy(lambdasPerCollision, collision.globalIndex()); const auto antiLambdasThisCollision = antiLambdas.sliceBy(antiLambdasPerCollision, collision.globalIndex()); @@ -2290,6 +2473,9 @@ struct LambdaAntiLambdaPairAnalysis { int mixedEventCounter = 0; for (auto const& [collision1, collision2] : combinations(CombinationsStrictlyUpperIndexPolicy(collisions, collisions))) { + if (jackknife.value && (collision1.globalIndex() % NJackknifeGroups == jackknifeExcludedGroup.value || collision2.globalIndex() % NJackknifeGroups == jackknifeExcludedGroup.value)) { + continue; + } const float deltaMultiplicity = std::abs(static_cast(collision1.multNTracksPV()) - static_cast(collision2.multNTracksPV()));