diff --git a/PWGCF/TwoParticleCorrelations/Tasks/lambdaR2Correlation.cxx b/PWGCF/TwoParticleCorrelations/Tasks/lambdaR2Correlation.cxx index a8fdbe2e45c..3a33f4718c2 100644 --- a/PWGCF/TwoParticleCorrelations/Tasks/lambdaR2Correlation.cxx +++ b/PWGCF/TwoParticleCorrelations/Tasks/lambdaR2Correlation.cxx @@ -97,10 +97,7 @@ DECLARE_SOA_COLUMN(Rap, rap, float); DECLARE_SOA_COLUMN(Mass, mass, float); DECLARE_SOA_COLUMN(PosTrackId, posTrackId, int64_t); DECLARE_SOA_COLUMN(NegTrackId, negTrackId, int64_t); -DECLARE_SOA_COLUMN(CosPA, cosPA, float); -DECLARE_SOA_COLUMN(DcaDau, dcaDau, float); -DECLARE_SOA_COLUMN(V0Type, v0Type, int8_t); -DECLARE_SOA_COLUMN(V0PrmScd, v0PrmScd, int8_t); +DECLARE_SOA_COLUMN(PartType, partType, int8_t); DECLARE_SOA_COLUMN(CorrFact, corrFact, float); } // namespace lambdatrack DECLARE_SOA_TABLE(LambdaTracks, "AOD", "LAMBDATRACKS", o2::soa::Index<>, @@ -115,13 +112,40 @@ DECLARE_SOA_TABLE(LambdaTracks, "AOD", "LAMBDATRACKS", o2::soa::Index<>, lambdatrack::Mass, lambdatrack::PosTrackId, lambdatrack::NegTrackId, - lambdatrack::CosPA, - lambdatrack::DcaDau, - lambdatrack::V0Type, - lambdatrack::V0PrmScd, + lambdatrack::PartType, lambdatrack::CorrFact); using LambdaTrack = LambdaTracks::iterator; +namespace kaontrack +{ +DECLARE_SOA_INDEX_COLUMN(LambdaCollision, lambdaCollision); +DECLARE_SOA_COLUMN(Px, px, float); +DECLARE_SOA_COLUMN(Py, py, float); +DECLARE_SOA_COLUMN(Pz, pz, float); +DECLARE_SOA_COLUMN(Pt, pt, float); +DECLARE_SOA_COLUMN(Eta, eta, float); +DECLARE_SOA_COLUMN(Phi, phi, float); +DECLARE_SOA_COLUMN(Rap, rap, float); +DECLARE_SOA_COLUMN(Mass, mass, float); +DECLARE_SOA_COLUMN(KaonTrackId, kaonTrackId, int64_t); +DECLARE_SOA_COLUMN(PartType, partType, int8_t); +DECLARE_SOA_COLUMN(CorrFact, corrFact, float); +} // namespace kaontrack +DECLARE_SOA_TABLE(KaonTracks, "AOD", "KAONTRACKS", o2::soa::Index<>, + kaontrack::LambdaCollisionId, + kaontrack::Px, + kaontrack::Py, + kaontrack::Pz, + kaontrack::Pt, + kaontrack::Eta, + kaontrack::Phi, + kaontrack::Rap, + kaontrack::Mass, + kaontrack::KaonTrackId, + kaontrack::PartType, + kaontrack::CorrFact); +using KaonTrack = KaonTracks::iterator; + namespace lambdatrackext { DECLARE_SOA_COLUMN(LambdaSharingDaughter, lambdaSharingDaughter, bool); @@ -151,12 +175,28 @@ DECLARE_SOA_TABLE(LambdaMcGenTracks, "AOD", "LMCGENTRACKS", o2::soa::Index<>, lambdatrack::Mass, lambdatrack::PosTrackId, lambdatrack::NegTrackId, - lambdatrack::V0Type, - lambdatrack::CosPA, - lambdatrack::DcaDau, - lambdatrack::V0PrmScd, + lambdatrack::PartType, lambdatrack::CorrFact); using LambdaMcGenTrack = LambdaMcGenTracks::iterator; + +namespace kaonmcgentrack +{ +DECLARE_SOA_INDEX_COLUMN(LambdaMcGenCollision, lambdaMcGenCollision); +} +DECLARE_SOA_TABLE(KaonMcGenTracks, "AOD", "KMCGENTRACKS", o2::soa::Index<>, + kaonmcgentrack::LambdaMcGenCollisionId, + o2::aod::mcparticle::Px, + o2::aod::mcparticle::Py, + o2::aod::mcparticle::Pz, + kaontrack::Pt, + kaontrack::Eta, + kaontrack::Phi, + kaontrack::Rap, + kaontrack::Mass, + kaontrack::KaonTrackId, + kaontrack::PartType, + kaontrack::CorrFact); +using KaonMcGenTrack = KaonMcGenTracks::iterator; } // namespace o2::aod enum CollisionLabels { @@ -168,30 +208,29 @@ enum CollisionLabels { enum TrackLabels { kTracksBeforeHasMcParticle = 1, kAllV0Tracks, - kV0KShortMassRej, - kNotLambdaNotAntiLambda, + kPassV0KinCuts, + kPassV0TopoSel, + kPassK0ShortMassRej, kV0IsBothLambdaAntiLambda, - kNotLambdaAfterSel, + kNotLambdaNotAntiLambda, kV0IsLambdaOrAntiLambda, kPassV0DauTrackSel, - kPassV0KinCuts, - kPassV0TopoSel, kAllSelPassed, - kPrimaryLambda, - kSecondaryLambda, - kLambdaDauNotMcParticle, - kLambdaNotPrPiMinus, - kAntiLambdaNotAntiPrPiPlus, - kPassTrueLambdaSel, kEffCorrPtCent, kEffCorrPtRapCent, + kMatchEffCorr, kNoEffCorr, - kPFCorrPtCent, - kPFCorrPtRapCent, - kNoPFCorr, kGenTotAccLambda, kGenLambdaNoDau, - kGenLambdaToPrPi +}; + +enum KaonLabels { + kKaonAllChargedTracks = 1, + kKaonPassKinSel, + kKaonPassGlobalSel, + kKaonPassDcaSel, + kKaonPassElRejSel, + kKaonPassAllSel }; enum CentEstType { @@ -199,20 +238,24 @@ enum CentEstType { kCentFT0C }; -enum RunType { - kRun3 = 0, - kRun2 -}; - enum ParticleType { kLambda = 0, - kAntiLambda + kAntiLambda, + kKaonPlus, + kKaonMinus }; enum ParticlePairType { kLambdaAntiLambda = 0, kLambdaLambda, - kAntiLambdaAntiLambda + kAntiLambdaAntiLambda, + kLambdaKaonPlus, + kLambdaKaonMinus, + kAntiLambdaKaonPlus, + kAntiLambdaKaonMinus, + kKaonPlusKaonMinus, + kKaonPlusKaonPlus, + kKaonMinusKaonMinus }; enum ShareDauLambda { @@ -236,24 +279,14 @@ enum CorrHistDim { ThreeDimCorr }; -enum PrmScdType { - kPrimary = 0, - kSecondary -}; - -enum PrmScdPairType { - kPP = 0, - kPS, - kSP, - kSS -}; - struct LambdaTableProducer { // Table Producers Produces lambdaCollisionTable; Produces lambdaTrackTable; + Produces kaonTrackTable; Produces lambdaMCGenCollisionTable; Produces lambdaMCGenTrackTable; + Produces kaonMCGenTrackTable; // Centrality Axis ConfigurableAxis cCentBins{"cCentBins", {VARIABLE_WIDTH, 0.0f, 10.0f, 20.0f, 50.f, 80.0f, 100.f}, "Variable Centrality Bins"}; @@ -265,8 +298,6 @@ struct LambdaTableProducer { Configurable cMinCent{"cMinCent", 0., "Minumum Centrality"}; Configurable cMaxCent{"cMaxCent", 100.0, "Maximum Centrality"}; Configurable cSel8Trig{"cSel8Trig", true, "Sel8 (T0A + T0C) Selection Run3"}; - Configurable cInt7Trig{"cInt7Trig", false, "kINT7 MB Trigger"}; - Configurable cSel7Trig{"cSel7Trig", false, "Sel7 (V0A + V0C) Selection Run2"}; Configurable cTriggerTvxSel{"cTriggerTvxSel", false, "Trigger Time and Vertex Selection"}; Configurable cTFBorder{"cTFBorder", false, "Timeframe Border Selection"}; Configurable cNoItsROBorder{"cNoItsROBorder", false, "No ITSRO Border Cut"}; @@ -277,55 +308,54 @@ struct LambdaTableProducer { // Tracks Configurable cTrackMinPt{"cTrackMinPt", 0.1, "p_{T} minimum"}; - Configurable cTrackMaxPt{"cTrackMaxPt", 999.0, "p_{T} maximum"}; Configurable cTrackEtaCut{"cTrackEtaCut", 0.8, "Pseudorapidity cut"}; Configurable cMinTpcCrossedRows{"cMinTpcCrossedRows", 70, "TPC Min Crossed Rows"}; Configurable cTpcNsigmaCut{"cTpcNsigmaCut", 3.0, "TPC NSigma Selection Cut"}; Configurable cRemoveAmbiguousTracks{"cRemoveAmbiguousTracks", false, "Remove Ambiguous Tracks"}; + // Kaon Tracks + Configurable cKaonMinPt{"cKaonMinPt", 0.4, "Kaon Min pT"}; + Configurable cKaonMaxPt{"cKaonMaxPt", 2.2, "Kaon Max pT"}; + Configurable cKaonRapCut{"cKaonRapCut", 0.5, "Kaon |y| cut"}; + Configurable cKaonGlobalSel{"cKaonGlobalSel", true, "Global Track"}; + Configurable cKaonDcaXYCut{"cKaonDcaXYCut", 0.1, "DcaXY Cut"}; + Configurable cKaonDcaZCut{"cKaonDcaZCut", 1., "DcaXY Cut"}; + Configurable cTpcElRejCutMin{"cTpcElRejCutMin", -3., "Electron Rejection Cut Minimum"}; + Configurable cTpcElRejCutMax{"cTpcElRejCutMax", 5., "Electron Rejection Cut Maximum"}; + Configurable cKaonTpcNSigmaCut{"cKaonTpcNSigmaCut", 2, "TPC Kaon NSigma Cut"}; + Configurable cTpcRejCut{"cTpcRejCut", 3, "TPC Rej Cut"}; + Configurable cKaonTofNSigmaCut{"cKaonTofNSigmaCut", 2, "TOF Kaon NSigma Cut"}; + Configurable cTofRejCut{"cTofRejCut", 3, "TOF Rej Cut"}; + Configurable cKaonTpcPtSel{"cKaonTpcPtSel", 0.6, "Kaon TPC pT cutoff"}; + // V0s - Configurable cMinDcaProtonToPV{"cMinDcaProtonToPV", 0.02, "Minimum Proton DCAr to PV"}; - Configurable cMinDcaPionToPV{"cMinDcaPionToPV", 0.06, "Minimum Pion DCAr to PV"}; - Configurable cMinV0DcaDaughters{"cMinV0DcaDaughters", 0., "Minimum DCA between V0 daughters"}; - Configurable cMaxV0DcaDaughters{"cMaxV0DcaDaughters", 1., "Maximum DCA between V0 daughters"}; - Configurable cMinDcaV0ToPV{"cMinDcaV0ToPV", 0.0, "Minimum DCA V0 to PV"}; + Configurable cMinDcaProtonToPV{"cMinDcaProtonToPV", 0.01, "Minimum Proton DCAr to PV"}; + Configurable cMinDcaPionToPV{"cMinDcaPionToPV", 0.1, "Minimum Pion DCAr to PV"}; + Configurable cMaxDcaV0Daughters{"cMaxDcaV0Daughters", 1., "Maximum DCA between V0 daughters"}; Configurable cMaxDcaV0ToPV{"cMaxDcaV0ToPV", 999.0, "Maximum DCA V0 to PV"}; Configurable cMinV0TransRadius{"cMinV0TransRadius", 0.5, "Minimum V0 radius from PV"}; - Configurable cMaxV0TransRadius{"cMaxV0TransRadius", 999.0, "Maximum V0 radius from PV"}; - Configurable cMinV0CTau{"cMinV0CTau", 0.0, "Minimum ctau"}; Configurable cMaxV0CTau{"cMaxV0CTau", 30.0, "Maximum ctau"}; Configurable cMinV0CosPA{"cMinV0CosPA", 0.995, "Minimum V0 CosPA to PV"}; Configurable cKshortRejMassWindow{"cKshortRejMassWindow", 0.01, "Reject K0Short Candidates"}; - Configurable cKshortRejFlag{"cKshortRejFlag", true, "K0short Mass Rej Flag"}; - - // V0s kinmatic acceptance - Configurable cV0MassWindow{"cV0MassWindow", 0.007, "V0 Mass Window"}; - Configurable cMinV0Pt{"cMinV0Pt", 0.6, "Minimum V0 pT"}; - Configurable cMaxV0Pt{"cMaxV0Pt", 3.6, "Minimum V0 pT"}; - Configurable cMaxV0Rap{"cMaxV0Rap", 0.5, "|rap| cut"}; - Configurable cDoEtaAnalysis{"cDoEtaAnalysis", false, "Do Eta Analysis"}; - Configurable cV0TypeSelFlag{"cV0TypeSelFlag", true, "V0 Type Selection Flag"}; - Configurable cV0TypeSelection{"cV0TypeSelection", 1, "V0 Type Selection"}; - // V0s MC - Configurable cHasMcFlag{"cHasMcFlag", true, "Has Mc Tag"}; - Configurable cSelectTrueLambda{"cSelectTrueLambda", false, "Select True Lambda"}; - Configurable cSelMCPSV0{"cSelMCPSV0", false, "Select Primary/Secondary V0"}; - Configurable cCheckRecoDauFlag{"cCheckRecoDauFlag", true, "Check for reco daughter PID"}; - Configurable cGenDecayChannel{"cGenDecayChannel", true, "Gen Level Decay Channel Flag"}; + // V0s acceptance + Configurable cLambdaMassWindow{"cLambdaMassWindow", 0.007, "Lambda Mass Window"}; + Configurable cLambdaMinPt{"cLambdaMinPt", 0.6, "Minimum Lambda pT"}; + Configurable cLambdaMaxPt{"cLambdaMaxPt", 3.6, "Minimum Lambda pT"}; + Configurable cLambdaRapCut{"cLambdaRapCut", 0.5, "Lambda |rap| cut"}; + Configurable cV0TypeSelection{"cV0TypeSelection", 1, "V0 Type Selection"}; // Efficiency Correction - Configurable cCorrectionFlag{"cCorrectionFlag", false, "Correction Flag"}; + Configurable cGetCorrectionFlag{"cGetCorrectionFlag", false, "Apply correction flag"}; Configurable cGetEffFact{"cGetEffFact", false, "Get Efficiency Factor Flag"}; - Configurable cGetPrimFrac{"cGetPrimFrac", false, "Get Primary Fraction Flag"}; Configurable cGetMatchEff{"cGetMatchEff", false, "Get Matching Efficiency Flag"}; Configurable cCorrFactHist{"cCorrFactHist", 0, "Efficiency Factor Histogram"}; - Configurable cPrimFracHist{"cPrimFracHist", 0, "Primary Fraction Histogram"}; // CCDB Configurable cUrlCCDB{"cUrlCCDB", "http://alice-ccdb.cern.ch", "ALICE CCDB URL"}; - Configurable cPathCCDB{"cPathCCDB", "Users/y/ypatley/LHC22oPass7/LambdaCorrectionFactor", "Path for ccdb-object"}; - Configurable cPathCCDBMatchEff{"cPathCCDBMatchEff", "Users/y/ypatley/LHC22oPass7/ITSTPCMatchEff", "Path for ccdb-object for matching efficiency"}; + Configurable cPathCCDBRecoEff{"cPathCCDBRecoEff", "Users/y/ypatley/LBF/PP/RecoEfficiency", "Path for ccdb-object for reco efficiency"}; + Configurable cPathCCDBMatchEff{"cPathCCDBMatchEff", "Users/y/ypatley/LBF/PP/MatchEfficiency", "Path for ccdb-object for matching efficiency"}; + Configurable nolaterthan{"nolaterthan", std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count(), "latest acceptable timestamp of creation for the object"}; // Initialize CCDB Service Service ccdb; @@ -334,23 +364,25 @@ struct LambdaTableProducer { HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject}; // initialize corr_factor objects - std::vector> vCorrFactStrings = {{"hEffVsPtCentLambda", "hEffVsPtCentAntiLambda"}, - {"hEffVsPtYCentLambda", "hEffVsPtYCentAntiLambda"}, - {"hEffVsPtEtaCentLambda", "hEffVsPtEtaCentAntiLambda"}}; - - // initialize corr_factor objects - std::vector> vPrimFracStrings = {{"hPrimFracVsPtCentLambda", "hPrimFracVsPtCentAntiLambda"}, - {"hPrimFracVsPtYCentLambda", "hPrimFracVsPtYCentAntiLambda"}, - {"hPrimFracVsPtEtaCentLambda", "hPrimFracVsPtEtaCentAntiLambda"}}; + std::vector> vCorrFactStrings = {{"hEffVsPtCentLambda", "hEffVsPtCentAntiLambda", "hEffVsPtCentKaonPlus", "hEffVsPtCentKaonMinus"}, + {"hEffVsPtYCentLambda", "hEffVsPtYCentAntiLambda", "hEffVsPtYCentKaonPlus", "hEffVsPtYCentKaonMinus"}}; // Initialize Global Variables float cent = 0., mult = 0.; + TList *ccdbObjRecoEff, *ccdbObjMatchEff; + static constexpr std::string_view SubDir[] = {"QA/Lambda/", "QA/AntiLambda/", "QA/KaonPlus/", "QA/KaonMinus/"}; void init(InitContext const&) { // Set CCDB url ccdb->setURL(cUrlCCDB.value); ccdb->setCaching(true); + ccdb->setLocalObjectValidityChecking(); + ccdb->setCreatedNotAfter(nolaterthan.value); + + // Get CCDB object + ccdbObjRecoEff = ccdb->getForTimeStamp(cPathCCDBRecoEff.value, nolaterthan.value); + ccdbObjMatchEff = ccdb->getForTimeStamp(cPathCCDBMatchEff.value, nolaterthan.value); // initialize axis specifications const AxisSpec axisCols(5, 0.5, 5.5, ""); @@ -374,16 +406,16 @@ struct LambdaTableProducer { const AxisSpec axisDcaProngPV(5000, -50., 50., "dca (cm)"); const AxisSpec axisDcaDau(75, 0., 1.5, "Daug DCA (#sigma)"); const AxisSpec axisCTau(2000, 0, 200, "c#tau (cm)"); - const AxisSpec axisGCTau(2000, 0, 200, "#gammac#tau (cm)"); const AxisSpec axisAlpha(40, -1, 1, "#alpha"); const AxisSpec axisQtarm(40, 0, 0.4, "q_{T}"); const AxisSpec axisITSTPCTrackPt(100, 0, 10, "p_{T} (GeV/#it{c})"); const AxisSpec axisTrackPt(40, 0, 4, "p_{T} (GeV/#it{c})"); const AxisSpec axisTrackDCA(200, -1, 1, "dca_{XY} (cm)"); - const AxisSpec axisMomPID(80, 0, 4, "p (GeV/#it{c})"); - const AxisSpec axisNsigma(401, -10.025, 10.025, {"n#sigma"}); - const AxisSpec axisdEdx(360, 20, 200, "#frac{dE}{dx}"); + const AxisSpec axisMomPID(80, 0, 4, "p_{T} (GeV/#it{c})"); + const AxisSpec axisTrackNsigma(401, -10.025, 10.025, {"n#sigma"}); + const AxisSpec axisTrackdEdx(360, 20, 200, "#frac{dE}{dx}"); + const AxisSpec axisTrackTofSignal(240, 0, 1.2, "#beta"); // Create Histograms. // Event histograms @@ -393,12 +425,14 @@ struct LambdaTableProducer { // QA histos.add("Tracks/h1f_tracks_info", "# of tracks", kTH1F, {axisTrks}); + histos.add("Tracks/h1f_kaon_sel", "Kaon selection", kTH1F, {axisTrks}); histos.add("Tracks/h2f_armpod_before_sel", "Armentros-Podolanski Plot", kTH2F, {axisAlpha, axisQtarm}); histos.add("Tracks/h2f_armpod_after_sel", "Armentros-Podolanski Plot", kTH2F, {axisAlpha, axisQtarm}); histos.add("Tracks/h1f_lambda_pt_vs_invm", "p_{T} vs M_{#Lambda}", kTH2F, {axisV0Mass, axisV0Pt}); histos.add("Tracks/h1f_antilambda_pt_vs_invm", "p_{T} vs M_{#bar{#Lambda}}", kTH2F, {axisV0Mass, axisV0Pt}); histos.add("Tracks/h2f_itstrack_centpt", "h2f_itstrack_centpt", kTH2F, {axisVarCent, axisITSTPCTrackPt}); histos.add("Tracks/h2f_itstpctrack_centpt", "h2f_itstpctrack_centpt", kTH2F, {axisVarCent, axisITSTPCTrackPt}); + histos.add("Tracks/h2f_itstpctoftrack_centpt", "h2f_itstpctoftrack_centpt", kTH2F, {axisVarCent, axisITSTPCTrackPt}); // QA Lambda histos.add("QA/Lambda/h2f_qt_vs_alpha", "Armentros-Podolanski Plot", kTH2F, {axisAlpha, axisQtarm}); @@ -409,40 +443,30 @@ struct LambdaTableProducer { histos.add("QA/Lambda/h1f_V0_cospa", "cos(#theta_{PA})", kTH1F, {axisCosPA}); histos.add("QA/Lambda/h1f_V0_radius", "V_{0} Decay Radius in XY plane", kTH1F, {axisRadius}); histos.add("QA/Lambda/h1f_V0_ctau", "V_{0} c#tau", kTH1F, {axisCTau}); - histos.add("QA/Lambda/h1f_V0_gctau", "V_{0} #gammac#tau", kTH1F, {axisGCTau}); - - histos.add("QA/Lambda/h1f_pos_prong_pt", "Pos-Prong p_{T}", kTH1F, {axisTrackPt}); - histos.add("QA/Lambda/h1f_neg_prong_pt", "Neg-Prong p_{T}", kTH1F, {axisTrackPt}); - histos.add("QA/Lambda/h1f_pos_prong_eta", "Pos-Prong #eta-distribution", kTH1F, {axisV0Eta}); - histos.add("QA/Lambda/h1f_neg_prong_eta", "Neg-Prong #eta-distribution", kTH1F, {axisV0Eta}); - histos.add("QA/Lambda/h1f_pos_prong_phi", "Pos-Prong #phi-distribution", kTH1F, {axisV0Phi}); - histos.add("QA/Lambda/h1f_neg_prong_phi", "Neg-Prong #phi-distribution", kTH1F, {axisV0Phi}); - histos.add("QA/Lambda/h2f_pos_prong_xisqperclustertpc", "#chi^{2}/cluster TPC", kTH2F, {axisTrackPt, {200, 0, 50}}); - histos.add("QA/Lambda/h2f_pos_prong_xisqperclusterits", "#chi^{2}/cluster ITS", kTH2F, {axisTrackPt, {200, 0, 50}}); - histos.add("QA/Lambda/h2f_neg_prong_xisqperclustertpc", "#chi^{2}/cluster TPC", kTH2F, {axisTrackPt, {200, 0, 50}}); - histos.add("QA/Lambda/h2f_neg_prong_xisqperclusterits", "#chi^{2}/cluster ITS", kTH2F, {axisTrackPt, {200, 0, 50}}); - histos.add("QA/Lambda/h2f_pos_prong_dcaXY_vs_pt", "DCA vs p_{T}", kTH2F, {axisTrackPt, axisTrackDCA}); histos.add("QA/Lambda/h2f_neg_prong_dcaXY_vs_pt", "DCA vs p_{T}", kTH2F, {axisTrackPt, axisTrackDCA}); - histos.add("QA/Lambda/h2f_pos_prong_dEdx_vs_p", "TPC Signal Pos-Prong", kTH2F, {axisMomPID, axisdEdx}); - histos.add("QA/Lambda/h2f_neg_prong_dEdx_vs_p", "TPC Signal Neg-Prong", kTH2F, {axisMomPID, axisdEdx}); - histos.add("QA/Lambda/h2f_pos_prong_tpc_nsigma_pr_vs_p", "TPC n#sigma Pos Prong", kTH2F, {axisMomPID, axisNsigma}); - histos.add("QA/Lambda/h2f_neg_prong_tpc_nsigma_pr_vs_p", "TPC n#sigma Neg Prong", kTH2F, {axisMomPID, axisNsigma}); - histos.add("QA/Lambda/h2f_pos_prong_tpc_nsigma_pi_vs_p", "TPC n#sigma Pos Prong", kTH2F, {axisMomPID, axisNsigma}); - histos.add("QA/Lambda/h2f_neg_prong_tpc_nsigma_pi_vs_p", "TPC n#sigma Neg Prong", kTH2F, {axisMomPID, axisNsigma}); - - // Kinematic Histograms - histos.add("McRec/Lambda/hPt", "Transverse Momentum", kTH1F, {axisV0Pt}); - histos.add("McRec/Lambda/hEta", "Pseudorapidity", kTH1F, {axisV0Eta}); - histos.add("McRec/Lambda/hRap", "Rapidity", kTH1F, {axisV0Rap}); - histos.add("McRec/Lambda/hPhi", "Azimuthal Angle", kTH1F, {axisV0Phi}); + histos.add("QA/Lambda/h2f_pos_prong_dEdx_vs_p", "TPC Signal Pos-Prong", kTH2F, {axisMomPID, axisTrackdEdx}); + histos.add("QA/Lambda/h2f_neg_prong_dEdx_vs_p", "TPC Signal Neg-Prong", kTH2F, {axisMomPID, axisTrackdEdx}); + histos.add("QA/Lambda/h2f_pos_prong_tpc_nsigma_pr_vs_p", "TPC n#sigma Pos Prong", kTH2F, {axisMomPID, axisTrackNsigma}); + histos.add("QA/Lambda/h2f_neg_prong_tpc_nsigma_pr_vs_p", "TPC n#sigma Neg Prong", kTH2F, {axisMomPID, axisTrackNsigma}); + histos.add("QA/Lambda/h2f_pos_prong_tpc_nsigma_pi_vs_p", "TPC n#sigma Pos Prong", kTH2F, {axisMomPID, axisTrackNsigma}); + histos.add("QA/Lambda/h2f_neg_prong_tpc_nsigma_pi_vs_p", "TPC n#sigma Neg Prong", kTH2F, {axisMomPID, axisTrackNsigma}); + + // QA Kaons + histos.add("QA/KaonPlus/hdEdX", "dE/dx vs pT", kTH2F, {axisMomPID, axisTrackdEdx}); + histos.add("QA/KaonPlus/hTOFSignal", "#beta_{TOF} vs p_{T}", kTH2F, {axisMomPID, axisTrackTofSignal}); + histos.add("QA/KaonPlus/hTPCNSigma", "n#sigma_{TPC} vs p_{T}", kTH2F, {axisMomPID, axisTrackNsigma}); + histos.add("QA/KaonPlus/hTOFNSigma", "n#sigma_{TOF} vs p_{T}", kTH2F, {axisMomPID, axisTrackNsigma}); // QA Anti-Lambda histos.addClone("QA/Lambda/", "QA/AntiLambda/"); histos.addClone("McRec/Lambda/", "McRec/AntiLambda/"); + // QA KaonMinus + histos.addClone("QA/KaonPlus/", "QA/KaonMinus/"); + // MC Generated Histograms - if (doprocessMCRun3 || doprocessMCRun2 || doprocessMCRecoRun3 || doprocessMCRecoRun2) { + if (doprocessMCRecoGen || doprocessMCReco) { // McReco Histos histos.add("Tracks/h2f_tracks_pid_before_sel", "PIDs", kTH2F, {axisPID, axisV0Pt}); histos.add("Tracks/h2f_tracks_pid_after_sel", "PIDs", kTH2F, {axisPID, axisV0Pt}); @@ -459,39 +483,22 @@ struct LambdaTableProducer { histos.addClone("McRec/", "McGen/"); - histos.add("McGen/Lambda/Proton/hPt", "Proton p_{T}", kTH1F, {axisTrackPt}); - histos.add("McGen/Lambda/Proton/hEta", "Proton #eta", kTH1F, {axisV0Eta}); - histos.add("McGen/Lambda/Proton/hRap", "Proton y", kTH1F, {axisV0Rap}); - histos.add("McGen/Lambda/Proton/hPhi", "Proton #phi", kTH1F, {axisV0Phi}); - - histos.addClone("McGen/Lambda/Proton/", "McGen/Lambda/Pion/"); - histos.addClone("McGen/Lambda/Proton/", "McGen/AntiLambda/Proton/"); - histos.addClone("McGen/Lambda/Pion/", "McGen/AntiLambda/Pion/"); - // set bin lables specific to MC histos.get(HIST("Events/h1f_collisions_info"))->GetXaxis()->SetBinLabel(CollisionLabels::kTotColBeforeHasMcCollision, "kTotColBeforeHasMcCollision"); histos.get(HIST("McGen/h1f_collisions_info"))->GetXaxis()->SetBinLabel(CollisionLabels::kTotCol, "kTotCol"); histos.get(HIST("McGen/h1f_collisions_info"))->GetXaxis()->SetBinLabel(CollisionLabels::kPassSelCol, "kPassSelCol"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kTracksBeforeHasMcParticle, "kTracksBeforeHasMcParticle"); - histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPrimaryLambda, "kPrimaryLambda"); - histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kSecondaryLambda, "kSecondaryLambda"); - histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kLambdaDauNotMcParticle, "kLambdaDauNotMcParticle"); - histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kLambdaNotPrPiMinus, "kLambdaNotPrPiMinus"); - histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kAntiLambdaNotAntiPrPiPlus, "kAntiLambdaNotAntiPrPiPlus"); - histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPassTrueLambdaSel, "kPassTrueLambdaSel"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kGenTotAccLambda, "kGenTotAccLambda"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kGenLambdaNoDau, "kGenLambdaNoDau"); - histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kGenLambdaToPrPi, "kGenLambdaToPrPi"); } // set bin labels histos.get(HIST("Events/h1f_collisions_info"))->GetXaxis()->SetBinLabel(CollisionLabels::kTotCol, "kTotCol"); histos.get(HIST("Events/h1f_collisions_info"))->GetXaxis()->SetBinLabel(CollisionLabels::kPassSelCol, "kPassSelCol"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kAllV0Tracks, "kAllV0Tracks"); - histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kV0KShortMassRej, "kV0KShortMassRej"); + histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPassK0ShortMassRej, "kPassK0ShortMassRej"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kNotLambdaNotAntiLambda, "kNotLambdaNotAntiLambda"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kV0IsBothLambdaAntiLambda, "kV0IsBothLambdaAntiLambda"); - histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kNotLambdaAfterSel, "kNotLambdaAfterSel"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kV0IsLambdaOrAntiLambda, "kV0IsLambdaOrAntiLambda"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPassV0DauTrackSel, "kPassV0DauTrackSel"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPassV0KinCuts, "kPassV0KinCuts"); @@ -499,38 +506,33 @@ struct LambdaTableProducer { histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kAllSelPassed, "kAllSelPassed"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kEffCorrPtCent, "kEffCorrPtCent"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kEffCorrPtRapCent, "kEffCorrPtRapCent"); + histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kMatchEffCorr, "kMatchEffCorr"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kNoEffCorr, "kNoEffCorr"); - histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPFCorrPtCent, "kPFCorrPtCent"); - histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPFCorrPtRapCent, "kPFCorrPtRapCent"); - histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kNoPFCorr, "kNoPFCorr"); + + histos.get(HIST("Tracks/h1f_kaon_sel"))->GetXaxis()->SetBinLabel(KaonLabels::kKaonAllChargedTracks, "kKaonAllChargedTracks"); + histos.get(HIST("Tracks/h1f_kaon_sel"))->GetXaxis()->SetBinLabel(KaonLabels::kKaonPassKinSel, "kKaonPassKinSel"); + histos.get(HIST("Tracks/h1f_kaon_sel"))->GetXaxis()->SetBinLabel(KaonLabels::kKaonPassGlobalSel, "kKaonPassGlobalSel"); + histos.get(HIST("Tracks/h1f_kaon_sel"))->GetXaxis()->SetBinLabel(KaonLabels::kKaonPassDcaSel, "kKaonPassDcaSel"); + histos.get(HIST("Tracks/h1f_kaon_sel"))->GetXaxis()->SetBinLabel(KaonLabels::kKaonPassElRejSel, "kKaonPassElRejSel"); + histos.get(HIST("Tracks/h1f_kaon_sel"))->GetXaxis()->SetBinLabel(KaonLabels::kKaonPassAllSel, "kKaonPassAllSel"); } - template + template bool selCollision(C const& col) { - // VtxZ Selection + // Vz Selection if (col.posZ() <= cMinZVtx || col.posZ() >= cMaxZVtx) { return false; } - if constexpr (run == kRun3) { // Run3 Min-Bias Trigger - // select centrality estimator - if (cCentEstimator == kCentFT0M) { - cent = col.centFT0M(); - } else if (cCentEstimator == kCentFT0C) { - cent = col.centFT0C(); - } - if (cSel8Trig && !col.sel8()) { - return false; - } - } else { // Run2 Min-Bias Trigger - cent = col.centRun2V0M(); - if (cInt7Trig && !col.alias_bit(kINT7)) { - return false; - } - if (cSel7Trig && !col.sel7()) { - return false; - } + // Run 3 Min-Bias Trigger + if (cSel8Trig && !col.sel8()) { + return false; + } + if (cCentEstimator == kCentFT0M) { + cent = col.centFT0M(); + } else if (cCentEstimator == kCentFT0C) { + cent = col.centFT0C(); } if (cent <= cMinCent || cent >= cMaxCent) { // select centrality percentile class @@ -571,390 +573,274 @@ struct LambdaTableProducer { return true; } - // Kinematic Selection - bool kinCutSelection(float const& pt, float const& rap, float const& ptMin, float const& ptMax, float const& rapMax) - { - if (pt <= ptMin || pt >= ptMax || rap >= rapMax) { - return false; - } - - return true; - } - - // Track Selection - template - bool selTrack(T const& track) - { - if (!kinCutSelection(track.pt(), std::abs(track.eta()), cTrackMinPt, cTrackMaxPt, cTrackEtaCut)) { - return false; - } - - if (track.tpcNClsCrossedRows() <= cMinTpcCrossedRows) { - return false; - } - - return true; - } - - // Daughter Track Selection + // Ambiguous track rejection template - bool selDaughterTracks(V const& v0, T const&, ParticleType const& v0Type) + bool hasAmbiguousDaughters(V const& v0, T const&) { auto posTrack = v0.template posTrack_as(); auto negTrack = v0.template negTrack_as(); - if (!selTrack(posTrack) || !selTrack(negTrack)) { - return false; - } + auto posTrackCompCols = posTrack.compatibleCollIds(); + auto negTrackCompCols = negTrack.compatibleCollIds(); - // Apply DCA Selection on Daughter Tracks Based on Lambda/AntiLambda daughters - float dcaProton = 0., dcaPion = 0.; - if (v0Type == kLambda) { - dcaProton = std::abs(v0.dcapostopv()); - dcaPion = std::abs(v0.dcanegtopv()); - } else if (v0Type == kAntiLambda) { - dcaPion = std::abs(v0.dcapostopv()); - dcaProton = std::abs(v0.dcanegtopv()); + // Check if daughter tracks belongs to more than one collision (Ambiguous Tracks) + if (posTrackCompCols.size() > 1 || negTrackCompCols.size() > 1) { + return true; } - if (dcaProton < cMinDcaProtonToPV || dcaPion < cMinDcaPionToPV) { - return false; + // Check if compatible collision index matches the track collision index + if (((posTrackCompCols.size() != 0) && (posTrackCompCols[0] != posTrack.collisionId())) || + ((negTrackCompCols.size() != 0) && (negTrackCompCols[0] != negTrack.collisionId()))) { + return true; } - return true; + // Pass as not ambiguous + return false; } - template - bool topoCutSelection(C const& col, V const& v0, T const&) + template + bool selLambdaDauTracks(const V& v0, const T& postrack, const T& negtrack, ParticleType& partType) { - // DCA - if (v0.dcaV0daughters() <= cMinV0DcaDaughters || v0.dcaV0daughters() >= cMaxV0DcaDaughters) { + // Kinematic selection + if (postrack.pt() <= cTrackMinPt || negtrack.pt() <= cTrackMinPt || std::abs(postrack.eta()) >= cTrackEtaCut || std::abs(negtrack.eta()) >= cTrackEtaCut || postrack.tpcNClsCrossedRows() <= cMinTpcCrossedRows || negtrack.tpcNClsCrossedRows() <= cMinTpcCrossedRows) { return false; } - if (v0.dcav0topv() <= cMinDcaV0ToPV || v0.dcav0topv() >= cMaxDcaV0ToPV) { + // Apply DCA Selection on Daughter Tracks Based on Lambda/AntiLambda daughters + if (partType == kLambda) { + if (std::abs(v0.dcapostopv()) <= cMinDcaProtonToPV || std::abs(v0.dcanegtopv()) <= cMinDcaPionToPV) { + return false; + } + } else if (partType == kAntiLambda) { + if (std::abs(v0.dcapostopv()) <= cMinDcaPionToPV || std::abs(v0.dcanegtopv()) <= cMinDcaProtonToPV) { + return false; + } + } else { return false; } - if (v0.v0radius() <= cMinV0TransRadius || v0.v0radius() >= cMaxV0TransRadius) { - return false; - } + // Daughter track PID [Dau1 = PosTrack, Dau2 = NegTrack] + float tpcNSigmaDau1 = 0., tpcNSigmaDau2 = 0.; - // ctau - float ctau = v0.distovertotmom(col.posX(), col.posY(), col.posZ()) * MassLambda0; - if (ctau <= cMinV0CTau || ctau >= cMaxV0CTau) { + if (partType == kLambda) { + tpcNSigmaDau1 = postrack.tpcNSigmaPr(); + tpcNSigmaDau2 = negtrack.tpcNSigmaPi(); + } else if (partType == kAntiLambda) { + tpcNSigmaDau1 = postrack.tpcNSigmaPi(); + tpcNSigmaDau2 = negtrack.tpcNSigmaPr(); + } else { + LOGF(fatal, "Particle call not Lambda !!!"); return false; } - // cosine of pointing angle - if (v0.v0cosPA() <= cMinV0CosPA) { + if (std::abs(tpcNSigmaDau1) >= cTpcNsigmaCut || std::abs(tpcNSigmaDau2) >= cTpcNsigmaCut) { return false; } - // all selection criterion passed (Return True) return true; } - template - bool selLambdaDauWithTpcPid(T const& postrack, T const& negtrack) + template + bool selLambda(C const& collision, V const& v0, T const& tracks, ParticleType& partType) { - bool returnFlag = false; - float tpcNSigmaPr = 0., tpcNSigmaPi = 0.; - - switch (part) { - // postrack = Proton, negtrack = Pion - case kLambda: - tpcNSigmaPr = postrack.tpcNSigmaPr(); - tpcNSigmaPi = negtrack.tpcNSigmaPi(); - break; - - // negtrack = Proton, postrack = Pion - case kAntiLambda: - tpcNSigmaPr = negtrack.tpcNSigmaPr(); - tpcNSigmaPi = postrack.tpcNSigmaPi(); - break; + // Initialize daughter tracks + auto postrack = v0.template posTrack_as(); + auto negtrack = v0.template negTrack_as(); + + // Kinematic selections + if (v0.pt() <= cLambdaMinPt || v0.pt() >= cLambdaMaxPt || std::abs(v0.yLambda()) >= cLambdaRapCut) { + return false; } - if (std::abs(tpcNSigmaPr) < cTpcNsigmaCut && std::abs(tpcNSigmaPi) < cTpcNsigmaCut) { - returnFlag = true; + histos.fill(HIST("Tracks/h1f_tracks_info"), kPassV0KinCuts); + + // Decay length + float ctauLambda = v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * MassLambda0; + + // Topological selections + if (v0.dcaV0daughters() >= cMaxDcaV0Daughters || v0.dcav0topv() >= cMaxDcaV0ToPV || v0.v0radius() <= cMinV0TransRadius || v0.v0Type() != cV0TypeSelection || ctauLambda >= cMaxV0CTau || v0.v0cosPA() <= cMinV0CosPA) { + return false; } - return returnFlag; - } + histos.fill(HIST("Tracks/h1f_tracks_info"), kPassV0TopoSel); - template - bool selLambdaMassWindow(V const& v0, T const&, ParticleType& v0type) - { - // Kshort mass rejection hypothesis - if (cKshortRejFlag && (std::abs(v0.mK0Short() - MassK0Short) <= cKshortRejMassWindow)) { - histos.fill(HIST("Tracks/h1f_tracks_info"), kV0KShortMassRej); + // K0s mass rejection + if (std::abs(v0.mK0Short() - MassK0Short) <= cKshortRejMassWindow) { return false; } - // initialize daughter tracks - auto postrack = v0.template posTrack_as(); - auto negtrack = v0.template negTrack_as(); + histos.fill(HIST("Tracks/h1f_tracks_info"), kPassK0ShortMassRej); - // initialize selection flags + // Apply Lambda Mass Hypothesis bool lambdaFlag = false, antiLambdaFlag = false; - // get v0 track as lambda - if ((std::abs(v0.mLambda() - MassLambda0) <= cV0MassWindow) && (selLambdaDauWithTpcPid(postrack, negtrack))) { + // Check for Lambda + if (std::abs(v0.mLambda() - MassLambda0) < cLambdaMassWindow) { lambdaFlag = true; - v0type = kLambda; + partType = kLambda; } - // get v0 track as anti-lambda - if (((std::abs(v0.mAntiLambda() - MassLambda0) <= cV0MassWindow)) && (selLambdaDauWithTpcPid(postrack, negtrack))) { + // Check for AntiLambda + if (std::abs(v0.mAntiLambda() - MassLambda0) < cLambdaMassWindow) { antiLambdaFlag = true; - v0type = kAntiLambda; + partType = kAntiLambda; } - if (!lambdaFlag && !antiLambdaFlag) { // neither Lambda nor Anti-Lambda - histos.fill(HIST("Tracks/h1f_tracks_info"), kNotLambdaNotAntiLambda); - return false; - } else if (lambdaFlag && antiLambdaFlag) { // check if the track is identified as lambda and anti-lambda both (DISCARD THIS TRACK) + // Check if the v0 is both Lambda and Anti-Lambda or neither + if (lambdaFlag && antiLambdaFlag) { histos.fill(HIST("Tracks/h1f_tracks_info"), kV0IsBothLambdaAntiLambda); return false; - } - - if (lambdaFlag || antiLambdaFlag) { - return true; - } - - histos.fill(HIST("Tracks/h1f_tracks_info"), kNotLambdaAfterSel); - - return false; - } - - template - bool selV0Particle(C const& col, V const& v0, T const& tracks, ParticleType& v0Type) - { - // Apply Lambda Mass Hypothesis - if (!selLambdaMassWindow(v0, tracks, v0Type)) { + } else if (!lambdaFlag && !antiLambdaFlag) { + histos.fill(HIST("Tracks/h1f_tracks_info"), kNotLambdaNotAntiLambda); return false; } histos.fill(HIST("Tracks/h1f_tracks_info"), kV0IsLambdaOrAntiLambda); - // Apply Daughter Track Selection - if (!selDaughterTracks(v0, tracks, v0Type)) { + // Select Lambda daughters + if (!selLambdaDauTracks(v0, postrack, negtrack, partType)) { return false; } histos.fill(HIST("Tracks/h1f_tracks_info"), kPassV0DauTrackSel); - // Apply Kinematic Selection - float rap = 0.; - if (!cDoEtaAnalysis) { - rap = std::abs(v0.yLambda()); - } else { - rap = std::abs(v0.eta()); - } - - if (!kinCutSelection(v0.pt(), rap, cMinV0Pt, cMaxV0Pt, cMaxV0Rap)) { + // Remove lambda with ambiguous daughters + if (cRemoveAmbiguousTracks && hasAmbiguousDaughters(v0, tracks)) { return false; } - histos.fill(HIST("Tracks/h1f_tracks_info"), kPassV0KinCuts); - - // Apply Topological Selection - if (!topoCutSelection(col, v0, tracks)) { - return false; - } - - histos.fill(HIST("Tracks/h1f_tracks_info"), kPassV0TopoSel); - // All Selection Criterion Passed return true; } - template - bool hasAmbiguousDaughters(V const& v0, T const&) + template + bool selKaonTrack(T const& track, float const& rap) { - auto posTrack = v0.template posTrack_as(); - auto negTrack = v0.template negTrack_as(); - - auto posTrackCompCols = posTrack.compatibleCollIds(); - auto negTrackCompCols = negTrack.compatibleCollIds(); - - // Check if daughter tracks belongs to more than one collision (Ambiguous Tracks) - if (posTrackCompCols.size() > 1 || negTrackCompCols.size() > 1) { - return true; + // Kinematic selection + if (track.pt() <= cKaonMinPt || track.pt() >= cKaonMaxPt || std::abs(rap) >= cKaonRapCut) { + return false; } - // Check if compatible collision index matches the track collision index - if (((posTrackCompCols.size() != 0) && (posTrackCompCols[0] != posTrack.collisionId())) || - ((negTrackCompCols.size() != 0) && (negTrackCompCols[0] != negTrack.collisionId()))) { - return true; - } + histos.fill(HIST("Tracks/h1f_kaon_sel"), kKaonPassKinSel); - // Pass as not ambiguous - return false; - } + // Global track selection + if (cKaonGlobalSel && !track.isGlobalTrackWoDCA()) { + return false; + } - template - PrmScdType isPrimaryV0(V const& v0) - { - auto mcpart = v0.template mcParticle_as(); + histos.fill(HIST("Tracks/h1f_kaon_sel"), kKaonPassGlobalSel); - // check for secondary lambda - if (!mcpart.isPhysicalPrimary()) { - histos.fill(HIST("Tracks/h1f_tracks_info"), kSecondaryLambda); - return kSecondary; + // Dca selection + if (std::abs(track.dcaXY()) >= cKaonDcaXYCut || std::abs(track.dcaZ()) >= cKaonDcaZCut) { + return false; } - histos.fill(HIST("Tracks/h1f_tracks_info"), kPrimaryLambda); - return kPrimary; - } - - template - bool selTrueMcRecLambda(V const& v0, T const&) - { - auto mcpart = v0.template mcParticle_as(); + histos.fill(HIST("Tracks/h1f_kaon_sel"), kKaonPassDcaSel); - // check if Lambda/AntiLambda - if (std::abs(mcpart.pdgCode()) != kLambda0) { + // Electron rejection + if (std::abs(track.tpcNSigmaPi()) > cTpcRejCut && std::abs(track.tpcNSigmaKa()) > cTpcRejCut && std::abs(track.tpcNSigmaPr()) > cTpcRejCut && track.tpcNSigmaEl() > cTpcElRejCutMin && track.tpcNSigmaEl() < cTpcElRejCutMax) { return false; } - // Check for daughters - if (cCheckRecoDauFlag) { - auto postrack = v0.template posTrack_as(); - auto negtrack = v0.template negTrack_as(); + histos.fill(HIST("Tracks/h1f_kaon_sel"), kKaonPassElRejSel); - // check if the daughters have corresponding mcparticle - if (!postrack.has_mcParticle() || !negtrack.has_mcParticle()) { - histos.fill(HIST("Tracks/h1f_tracks_info"), kLambdaDauNotMcParticle); + // Kaon PID TPC + TOF + if (track.hasTOF()) { + if (std::abs(track.tofNSigmaKa()) >= cKaonTofNSigmaCut || std::abs(track.tofNSigmaPi()) < cTofRejCut || std::abs(track.tofNSigmaPr()) < cTofRejCut || std::abs(track.tpcNSigmaKa()) >= cKaonTpcNSigmaCut) { return false; } - - auto mcpostrack = postrack.template mcParticle_as(); - auto mcnegtrack = negtrack.template mcParticle_as(); - - if (mcpart.pdgCode() == kLambda0) { - if (mcpostrack.pdgCode() != kProton || mcnegtrack.pdgCode() != kPiMinus) { - histos.fill(HIST("Tracks/h1f_tracks_info"), kLambdaNotPrPiMinus); - return false; - } - } else if (mcpart.pdgCode() == kLambda0Bar) { - if (mcpostrack.pdgCode() != kPiPlus || mcnegtrack.pdgCode() != kProtonBar) { - histos.fill(HIST("Tracks/h1f_tracks_info"), kAntiLambdaNotAntiPrPiPlus); - return false; - } + } else { + if (track.pt() >= cKaonTpcPtSel || std::abs(track.tpcNSigmaKa()) >= cKaonTpcNSigmaCut || std::abs(track.tpcNSigmaPi()) < cTpcRejCut || std::abs(track.tpcNSigmaPr()) < cTpcRejCut) { + return false; } } + histos.fill(HIST("Tracks/h1f_kaon_sel"), kKaonPassAllSel); + return true; } + // Correction factors template - float getCorrectionFactors(V const& v0, T const&) + float getCorrectionFactors(V const& v, T const&, float const& rap) { - // Check for efficiency correction flag - if (!cCorrectionFlag) { - return 1.; - } - - // Get from CCDB - auto ccdbObj = ccdb->getForTimeStamp(cPathCCDB.value, -1); - - // Check CCDB Object - if (!ccdbObj) { - LOGF(warning, "CCDB OBJECT NOT FOUND"); - return 1.; - } - - // initialize efficiency factor and primary fraction values - float effCorrFact = 1., primFrac = 1., matchEffFact = 1.; - float rap = (cDoEtaAnalysis) ? v0.eta() : v0.yLambda(); + // Initialize efficiency factor + float effCorrFact = 1., matchEffFact = 1.; // Get Efficiency Factor if (cGetEffFact) { - TObject* objEff = reinterpret_cast(ccdbObj->FindObject(Form("%s", vCorrFactStrings[cCorrFactHist][part].c_str()))); - TH1F* histEff = reinterpret_cast(objEff->Clone()); - if (histEff->GetDimension() == TwoDimCorr) { - histos.fill(HIST("Tracks/h1f_tracks_info"), kEffCorrPtCent); - effCorrFact = histEff->GetBinContent(histEff->FindBin(cent, v0.pt())); - } else if (histEff->GetDimension() == ThreeDimCorr) { - histos.fill(HIST("Tracks/h1f_tracks_info"), kEffCorrPtRapCent); - effCorrFact = histEff->GetBinContent(histEff->FindBin(cent, v0.pt(), rap)); - } else { - histos.fill(HIST("Tracks/h1f_tracks_info"), kNoEffCorr); - LOGF(warning, "CCDB OBJECT IS NOT A HISTOGRAM !!!"); - effCorrFact = 1.; - } - delete histEff; - } - - // Get Primary Fraction - // (The dimension of this could be different than efficiency because of large errors !!!) - if (cGetPrimFrac) { - TObject* objPrm = reinterpret_cast(ccdbObj->FindObject(Form("%s", vPrimFracStrings[cPrimFracHist][part].c_str()))); - TH1F* histPrm = reinterpret_cast(objPrm->Clone()); - if (histPrm->GetDimension() == TwoDimCorr) { - histos.fill(HIST("Tracks/h1f_tracks_info"), kPFCorrPtCent); - primFrac = histPrm->GetBinContent(histPrm->FindBin(cent, v0.pt())); - } else if (histPrm->GetDimension() == ThreeDimCorr) { - histos.fill(HIST("Tracks/h1f_tracks_info"), kPFCorrPtRapCent); - primFrac = histPrm->GetBinContent(histPrm->FindBin(cent, v0.pt(), rap)); + TObject* objEff = reinterpret_cast(ccdbObjRecoEff->FindObject(Form("%s", vCorrFactStrings[cCorrFactHist][part].c_str()))); + // check object + if (!objEff) { + LOGF(fatal, "Reco efficiency object not found !"); } else { - histos.fill(HIST("Tracks/h1f_tracks_info"), kNoPFCorr); - LOGF(warning, "CCDB OBJECT IS NOT A HISTOGRAM !!!"); - primFrac = 1.; + TH1F* histEff = reinterpret_cast(objEff->Clone()); + if (histEff->GetDimension() == TwoDimCorr) { + histos.fill(HIST("Tracks/h1f_tracks_info"), kEffCorrPtCent); + effCorrFact = histEff->GetBinContent(histEff->FindBin(cent, v.pt())); + } else if (histEff->GetDimension() == ThreeDimCorr) { + histos.fill(HIST("Tracks/h1f_tracks_info"), kEffCorrPtRapCent); + effCorrFact = histEff->GetBinContent(histEff->FindBin(cent, v.pt(), rap)); + } else { + histos.fill(HIST("Tracks/h1f_tracks_info"), kNoEffCorr); + LOGF(warning, "CCDB OBJECT IS NOT A HISTOGRAM !!!"); + effCorrFact = 1.; + } + delete histEff; } - delete histPrm; } // Get Matching Efficiency Correction if (cGetMatchEff) { - auto posTrack = v0.template posTrack_as(); - auto negTrack = v0.template negTrack_as(); - auto ccdbObjMatchEff = ccdb->getForTimeStamp(cPathCCDBMatchEff.value, -1); - TObject* objMatchEff = reinterpret_cast(ccdbObjMatchEff->FindObject("hITSTPCMatchingEfficiency")); - TH1F* histMatchEff = reinterpret_cast(objMatchEff->Clone()); - float posTrackMatchEff = histMatchEff->GetBinContent(histMatchEff->FindBin(cent, posTrack.pt())); - float negTrackMatchEff = histMatchEff->GetBinContent(histMatchEff->FindBin(cent, negTrack.pt())); - matchEffFact = posTrackMatchEff * negTrackMatchEff; - delete histMatchEff; - } - - return primFrac * effCorrFact * matchEffFact; - } + TObject* objITSTPCMatchEff = reinterpret_cast(ccdbObjMatchEff->FindObject("hITSTPCMatchingEfficiency")); + TObject* objITSTPCTOFMatchEff = reinterpret_cast(ccdbObjMatchEff->FindObject("hITSTPCTOFMatchingEfficiency")); + if (!objITSTPCMatchEff || !objITSTPCTOFMatchEff) { + LOGF(fatal, "Matching efficiency object not found !"); + } else { + TH1F* histITSTPCMatchEff = reinterpret_cast(objITSTPCMatchEff->Clone()); + TH1F* histITSTPCTOFMatchEff = reinterpret_cast(objITSTPCTOFMatchEff->Clone()); + // Lambda / Anti-Lambda + if constexpr (part == kLambda || part == kAntiLambda) { + auto posTrack = v.template posTrack_as(); + auto negTrack = v.template negTrack_as(); + float posTrackMatchEff = histITSTPCMatchEff->GetBinContent(histITSTPCMatchEff->FindBin(cent, posTrack.pt())); + float negTrackMatchEff = histITSTPCMatchEff->GetBinContent(histITSTPCMatchEff->FindBin(cent, negTrack.pt())); + matchEffFact = posTrackMatchEff * negTrackMatchEff; + } + // K+ /K- + if constexpr (part == kKaonPlus || part == kKaonMinus) { + float trackItsTpcMatchEff = histITSTPCMatchEff->GetBinContent(histITSTPCMatchEff->FindBin(cent, v.pt())); + float trackItsTpcTofMatchEff = histITSTPCTOFMatchEff->GetBinContent(histITSTPCTOFMatchEff->FindBin(cent, v.pt())); + matchEffFact = trackItsTpcMatchEff * trackItsTpcTofMatchEff; + } - template - void fillLambdaMothers(V const& v0, T const&, PrmScdType const& ps) - { - auto mcpart = v0.template mcParticle_as(); - auto lambdaMothers = mcpart.template mothers_as(); - if (ps == kPrimary) { - histos.fill(HIST("Tracks/h2f_primary_lambda_mothers_pdg"), lambdaMothers[0].pdgCode(), v0.pt()); - } else { - histos.fill(HIST("Tracks/h2f_secondary_lambda_mothers_pdg"), lambdaMothers[0].pdgCode(), v0.pt()); + histos.fill(HIST("Tracks/h1f_tracks_info"), kMatchEffCorr); + delete histITSTPCMatchEff; + delete histITSTPCTOFMatchEff; + } } + + return effCorrFact * matchEffFact; } + // Lambda QA template void fillLambdaQAHistos(C const& col, V const& v0, T const&) { - static constexpr std::string_view SubDir[] = {"QA/Lambda/", "QA/AntiLambda/"}; - - // daugthers + // Daugthers auto postrack = v0.template posTrack_as(); auto negtrack = v0.template negTrack_as(); - float mass = 0.; + // Mass + float mass = 0.; if constexpr (part == kLambda) { mass = v0.mLambda(); } else { mass = v0.mAntiLambda(); } - // ctau - float e = RecoDecay::e(v0.px(), v0.py(), v0.pz(), mass); - float gamma = e / mass; + // Decay length float ctau = v0.distovertotmom(col.posX(), col.posY(), col.posZ()) * MassLambda0; - float gctau = ctau * gamma; histos.fill(HIST(SubDir[part]) + HIST("h2f_qt_vs_alpha"), v0.alpha(), v0.qtarm()); histos.fill(HIST(SubDir[part]) + HIST("h1f_dca_V0_daughters"), v0.dcaV0daughters()); @@ -964,19 +850,6 @@ struct LambdaTableProducer { histos.fill(HIST(SubDir[part]) + HIST("h1f_V0_cospa"), v0.v0cosPA()); histos.fill(HIST(SubDir[part]) + HIST("h1f_V0_radius"), v0.v0radius()); histos.fill(HIST(SubDir[part]) + HIST("h1f_V0_ctau"), ctau); - histos.fill(HIST(SubDir[part]) + HIST("h1f_V0_gctau"), gctau); - - histos.fill(HIST(SubDir[part]) + HIST("h1f_pos_prong_pt"), postrack.pt()); - histos.fill(HIST(SubDir[part]) + HIST("h1f_pos_prong_eta"), postrack.eta()); - histos.fill(HIST(SubDir[part]) + HIST("h1f_pos_prong_phi"), postrack.phi()); - histos.fill(HIST(SubDir[part]) + HIST("h2f_pos_prong_xisqperclusterits"), postrack.pt(), postrack.itsChi2NCl()); - histos.fill(HIST(SubDir[part]) + HIST("h2f_pos_prong_xisqperclustertpc"), postrack.pt(), postrack.tpcChi2NCl()); - histos.fill(HIST(SubDir[part]) + HIST("h1f_neg_prong_pt"), negtrack.pt()); - histos.fill(HIST(SubDir[part]) + HIST("h1f_neg_prong_eta"), negtrack.eta()); - histos.fill(HIST(SubDir[part]) + HIST("h1f_neg_prong_phi"), negtrack.phi()); - histos.fill(HIST(SubDir[part]) + HIST("h2f_neg_prong_xisqperclusterits"), negtrack.pt(), negtrack.itsChi2NCl()); - histos.fill(HIST(SubDir[part]) + HIST("h2f_neg_prong_xisqperclustertpc"), negtrack.pt(), negtrack.tpcChi2NCl()); - histos.fill(HIST(SubDir[part]) + HIST("h2f_pos_prong_dcaXY_vs_pt"), postrack.pt(), postrack.dcaXY()); histos.fill(HIST(SubDir[part]) + HIST("h2f_neg_prong_dcaXY_vs_pt"), negtrack.pt(), negtrack.dcaXY()); histos.fill(HIST(SubDir[part]) + HIST("h2f_pos_prong_dEdx_vs_p"), postrack.tpcInnerParam(), postrack.tpcSignal()); @@ -987,19 +860,19 @@ struct LambdaTableProducer { histos.fill(HIST(SubDir[part]) + HIST("h2f_neg_prong_tpc_nsigma_pi_vs_p"), negtrack.tpcInnerParam(), negtrack.tpcNSigmaPi()); } - // Fill Lambda Kinematic Histograms - template - void fillKinematicHists(float const& pt, float const& eta, float const& y, float const& phi) + // Kaon QA + template + void fillKaonQA(T const& track) { - static constexpr std::string_view SubDirRG[] = {"McRec/", "McGen/"}; - static constexpr std::string_view SubDirPart[] = {"Lambda/", "AntiLambda/"}; - - histos.fill(HIST(SubDirRG[rg]) + HIST(SubDirPart[part]) + HIST("hPt"), pt); - histos.fill(HIST(SubDirRG[rg]) + HIST(SubDirPart[part]) + HIST("hEta"), eta); - histos.fill(HIST(SubDirRG[rg]) + HIST(SubDirPart[part]) + HIST("hRap"), y); - histos.fill(HIST(SubDirRG[rg]) + HIST(SubDirPart[part]) + HIST("hPhi"), phi); + histos.fill(HIST(SubDir[part]) + HIST("hdEdX"), track.pt(), track.tpcSignal()); + histos.fill(HIST(SubDir[part]) + HIST("hTPCNSigma"), track.pt(), track.tpcNSigmaKa()); + if (track.hasTOF()) { + histos.fill(HIST(SubDir[part]) + HIST("hTOFSignal"), track.pt(), track.beta()); + histos.fill(HIST(SubDir[part]) + HIST("hTOFNSigma"), track.pt(), track.tofNSigmaKa()); + } } + // Get matching efficiency template void getMatchEffHist(T const& tracks) { @@ -1017,19 +890,23 @@ struct LambdaTableProducer { if (track.pt() > cTrackMinPt && std::abs(track.eta()) < cTrackEtaCut && track.hasITS() && track.hasTPC() && track.isQualityTrackITS() && track.isQualityTrackTPC()) { histos.fill(HIST("Tracks/h2f_itstpctrack_centpt"), cent, track.pt()); } + // ITS+TPC+TOF track + if (track.pt() > cTrackMinPt && std::abs(track.eta()) < cTrackEtaCut && track.hasITS() && track.hasTPC() && track.isQualityTrackITS() && track.isQualityTrackTPC() && track.hasTOF()) { + histos.fill(HIST("Tracks/h2f_itstpctoftrack_centpt"), cent, track.pt()); + } } } // Reconstructed Level Tables - template - void fillLambdaRecoTables(C const& collision, V const& v0tracks, T const& tracks) + template + void fillLambdaRecoTables(C const& collision, B const&, V const& v0tracks, T const& tracks) { // Total Collisions histos.fill(HIST("Events/h1f_collisions_info"), kTotCol); // Select Collision (Only for Data... McRec has been selected already !!!) if constexpr (dmc == kData) { - if (!selCollision(collision)) { + if (!selCollision(collision)) { return; } } @@ -1043,17 +920,16 @@ struct LambdaTableProducer { lambdaCollisionTable(cent, mult, collision.posX(), collision.posY(), collision.posZ()); // initialize v0track objects - ParticleType v0Type = kLambda; - PrmScdType v0PrmScdType = kPrimary; - float mass = 0., corr_fact = 1.; + ParticleType partType = kLambda; + float lambdaMass = 0., lambdaCorrFact = 1.; - // Loop over V0s + // Loop over V0s to select Lambda for (auto const& v0 : v0tracks) { - // daugthers + // Daugthers auto postrack = v0.template posTrack_as(); auto negtrack = v0.template negTrack_as(); - // check for corresponding MCGen Particle + // Check for corresponding MCGen Particle if constexpr (dmc == kMC) { histos.fill(HIST("Tracks/h1f_tracks_info"), kTracksBeforeHasMcParticle); if (!v0.has_mcParticle() || !postrack.has_mcParticle() || !negtrack.has_mcParticle()) { // check corresponding MC particle @@ -1064,185 +940,160 @@ struct LambdaTableProducer { histos.fill(HIST("Tracks/h1f_tracks_info"), kAllV0Tracks); histos.fill(HIST("Tracks/h2f_armpod_before_sel"), v0.alpha(), v0.qtarm()); - // Select V0 Particle as Lambda/AntiLambda - if (!selV0Particle(collision, v0, tracks, v0Type)) { - continue; - } - - // Select V0 Type Selection - if (cV0TypeSelFlag && v0.v0Type() != cV0TypeSelection) { + // Select V0 as Lambda/AntiLambda + if (!selLambda(collision, v0, tracks, partType)) { continue; } // We have v0 as lambda histos.fill(HIST("Tracks/h1f_tracks_info"), kAllSelPassed); + histos.fill(HIST("Tracks/h2f_armpod_after_sel"), v0.alpha(), v0.qtarm()); - // Remove lambda with ambiguous daughters (Only for run3) - if constexpr (run == kRun3) { - if (cRemoveAmbiguousTracks && hasAmbiguousDaughters(v0, tracks)) { - continue; - } + // Get Lambda mass and correction factor + lambdaMass = (partType == kLambda) ? v0.mLambda() : v0.mAntiLambda(); + if (cGetCorrectionFlag) { + lambdaCorrFact = (partType == kLambda) ? getCorrectionFactors(v0, tracks, v0.yLambda()) : getCorrectionFactors(v0, tracks, v0.yLambda()); } - // Get Lambda mass and kinematic variables - mass = (v0Type == kLambda) ? v0.mLambda() : v0.mAntiLambda(); - - // do MC analysis - if constexpr (dmc == kMC) { - histos.fill(HIST("Tracks/h2f_tracks_pid_before_sel"), v0.mcParticle().pdgCode(), v0.pt()); + // fill lambda qa + if (partType == kLambda) { + histos.fill(HIST("Tracks/h1f_lambda_pt_vs_invm"), lambdaMass, v0.pt()); + fillLambdaQAHistos(collision, v0, tracks); + } else { + histos.fill(HIST("Tracks/h1f_antilambda_pt_vs_invm"), lambdaMass, v0.pt()); + fillLambdaQAHistos(collision, v0, tracks); + } - // Get Primary/Secondary Lambda - if (cSelMCPSV0) { - v0PrmScdType = isPrimaryV0(v0); - } + // Fill Lambda/AntiLambda Table + lambdaTrackTable(lambdaCollisionTable.lastIndex(), v0.px(), v0.py(), v0.pz(), + v0.pt(), v0.eta(), v0.phi(), v0.yLambda(), lambdaMass, + v0.template posTrack_as().index(), v0.template negTrack_as().index(), + (int8_t)partType, lambdaCorrFact); + } - // check for true Lambda/Anti-Lambda - if (cSelectTrueLambda && !selTrueMcRecLambda(v0, tracks)) { + // Loop over tracks to select Kaon + float kaonCorrFact = 0.; + for (auto const& track : tracks) { + // Check corresponding MC particle + if constexpr (dmc == kMC) { + if (!track.has_mcParticle()) { continue; } - - // get mothers information - fillLambdaMothers(v0, tracks, v0PrmScdType); - - histos.fill(HIST("Tracks/h1f_tracks_info"), kPassTrueLambdaSel); - histos.fill(HIST("Tracks/h2f_tracks_pid_after_sel"), v0.mcParticle().pdgCode(), v0.pt()); } - histos.fill(HIST("Tracks/h2f_armpod_after_sel"), v0.alpha(), v0.qtarm()); + // All charged tracks + histos.fill(HIST("Tracks/h1f_kaon_sel"), kKaonAllChargedTracks); - // get correction factors - corr_fact = (v0Type == kLambda) ? getCorrectionFactors(v0, tracks) : getCorrectionFactors(v0, tracks); + // Kaon rapidity + std::array mom = {track.px(), track.py(), track.pz()}; + float rap = RecoDecay::y(mom, MassKPlus); + if (!selKaonTrack(track, rap)) { // Kaon selection + continue; + } - // fill lambda qa - if (v0Type == kLambda) { - histos.fill(HIST("Tracks/h1f_lambda_pt_vs_invm"), mass, v0.pt()); - fillLambdaQAHistos(collision, v0, tracks); - fillKinematicHists(v0.pt(), v0.eta(), v0.yLambda(), v0.phi()); + // K+ / K- + if (track.sign() >= 0) { + fillKaonQA(track); + partType = kKaonPlus; + } else if (track.sign() <= 0) { + fillKaonQA(track); + partType = kKaonMinus; } else { - histos.fill(HIST("Tracks/h1f_antilambda_pt_vs_invm"), mass, v0.pt()); - fillLambdaQAHistos(collision, v0, tracks); - fillKinematicHists(v0.pt(), v0.eta(), v0.yLambda(), v0.phi()); + continue; } - // Fill Lambda/AntiLambda Table - lambdaTrackTable(lambdaCollisionTable.lastIndex(), v0.px(), v0.py(), v0.pz(), - v0.pt(), v0.eta(), v0.phi(), v0.yLambda(), mass, - v0.template posTrack_as().index(), v0.template negTrack_as().index(), - v0.v0cosPA(), v0.dcaV0daughters(), (int8_t)v0Type, v0PrmScdType, corr_fact); + // Get Kaon correction factor + if (cGetCorrectionFlag) { + kaonCorrFact = (partType == kKaonPlus) ? getCorrectionFactors(track, track, rap) : getCorrectionFactors(track, track, rap); + } + + // Fill table + kaonTrackTable(lambdaCollisionTable.lastIndex(), track.px(), track.py(), track.pz(), + track.pt(), track.eta(), track.phi(), rap, MassKaonCharged, + track.globalIndex(), (int8_t)partType, kaonCorrFact); } } // MC Generater Level Tables - template + template void fillLambdaMcGenTables(C const& mcCollision, M const& mcParticles) { // Fill McGen Collision Table lambdaMCGenCollisionTable(cent, mult, mcCollision.posX(), mcCollision.posY(), mcCollision.posZ()); // initialize track objects - ParticleType v0Type = kLambda; - PrmScdType v0PrmScdType = kPrimary; - float rap = 0.; + ParticleType partType = kLambda; // Loop over MC particles for (auto const& mcpart : mcParticles) { - // check for Lambda first - if (mcpart.pdgCode() == kLambda0) { - v0Type = kLambda; - } else if (mcpart.pdgCode() == kLambda0Bar) { - v0Type = kAntiLambda; + // Check for Primary Lambda/Anti-Lambda/K+/K- + if (mcpart.isPhysicalPrimary() && mcpart.pdgCode() == kLambda0) { + partType = kLambda; + } else if (mcpart.isPhysicalPrimary() && mcpart.pdgCode() == kLambda0Bar) { + partType = kAntiLambda; + } else if (mcpart.isPhysicalPrimary() && mcpart.pdgCode() == kKPlus) { + partType = kKaonPlus; + } else if (mcpart.isPhysicalPrimary() && mcpart.pdgCode() == kKMinus) { + partType = kKaonMinus; } else { continue; } - // check for Primary Lambda/AntiLambda - if (mcpart.isPhysicalPrimary()) { - v0PrmScdType = kPrimary; - } else { - v0PrmScdType = kSecondary; - } + // Fill Lambda Table + if (partType == kLambda || partType == kAntiLambda) { + // Kinematic selection + if (mcpart.pt() <= cLambdaMinPt || mcpart.pt() >= cLambdaMaxPt || std::abs(mcpart.y()) >= cLambdaRapCut) { + continue; + } - // Decide Eta/Rap - if (!cDoEtaAnalysis) { - rap = mcpart.y(); - } else { - rap = mcpart.eta(); - } + histos.fill(HIST("Tracks/h1f_tracks_info"), kGenTotAccLambda); - // Apply Kinematic Acceptance - if (!kinCutSelection(mcpart.pt(), std::abs(rap), cMinV0Pt, cMaxV0Pt, cMaxV0Rap)) { - continue; - } - - histos.fill(HIST("Tracks/h1f_tracks_info"), kGenTotAccLambda); + // get daughter track info and check for decay channel flag + if (!mcpart.has_daughters()) { + histos.fill(HIST("Tracks/h1f_tracks_info"), kGenLambdaNoDau); + continue; + } + auto dautracks = mcpart.template daughters_as(); + std::vector daughterPDGs, daughterIDs; + for (auto const& dautrack : dautracks) { + daughterPDGs.push_back(dautrack.pdgCode()); + daughterIDs.push_back(dautrack.globalIndex()); + } - // get daughter track info and check for decay channel flag - if (!mcpart.has_daughters()) { - histos.fill(HIST("Tracks/h1f_tracks_info"), kGenLambdaNoDau); - continue; - } - auto dautracks = mcpart.template daughters_as(); - std::vector daughterPDGs, daughterIDs; - std::vector vDauPt, vDauEta, vDauRap, vDauPhi; - for (auto const& dautrack : dautracks) { - daughterPDGs.push_back(dautrack.pdgCode()); - daughterIDs.push_back(dautrack.globalIndex()); - vDauPt.push_back(dautrack.pt()); - vDauEta.push_back(dautrack.eta()); - vDauRap.push_back(dautrack.y()); - vDauPhi.push_back(dautrack.phi()); - } - if (cGenDecayChannel) { // check decay channel - if (v0Type == kLambda) { - if (daughterPDGs[0] != kProton || daughterPDGs[1] != kPiMinus) { - continue; - } - } else if (v0Type == kAntiLambda) { - if (daughterPDGs[0] != kProtonBar || daughterPDGs[1] != kPiPlus) { - continue; - } + if (partType == kLambda) { + histos.fill(HIST("McGen/h1f_lambda_daughter_PDG"), daughterPDGs[0]); + histos.fill(HIST("McGen/h1f_lambda_daughter_PDG"), daughterPDGs[1]); + histos.fill(HIST("McGen/h1f_lambda_daughter_PDG"), mcpart.pdgCode()); + } else { + histos.fill(HIST("McGen/h1f_antilambda_daughter_PDG"), daughterPDGs[0]); + histos.fill(HIST("McGen/h1f_antilambda_daughter_PDG"), daughterPDGs[1]); + histos.fill(HIST("McGen/h1f_antilambda_daughter_PDG"), mcpart.pdgCode()); } + // Fill table + lambdaMCGenTrackTable(lambdaMCGenCollisionTable.lastIndex(), mcpart.px(), mcpart.py(), mcpart.pz(), + mcpart.pt(), mcpart.eta(), mcpart.phi(), mcpart.y(), RecoDecay::m(mcpart.p(), mcpart.e()), + daughterIDs[0], daughterIDs[1], (int8_t)partType, 1.); } - histos.fill(HIST("Tracks/h1f_tracks_info"), kGenLambdaToPrPi); - - if (v0Type == kLambda) { - histos.fill(HIST("McGen/h1f_lambda_daughter_PDG"), daughterPDGs[0]); - histos.fill(HIST("McGen/h1f_lambda_daughter_PDG"), daughterPDGs[1]); - histos.fill(HIST("McGen/h1f_lambda_daughter_PDG"), mcpart.pdgCode()); - histos.fill(HIST("McGen/Lambda/Proton/hPt"), vDauPt[0]); - histos.fill(HIST("McGen/Lambda/Proton/hEta"), vDauEta[0]); - histos.fill(HIST("McGen/Lambda/Proton/hRap"), vDauRap[0]); - histos.fill(HIST("McGen/Lambda/Proton/hPhi"), vDauPhi[0]); - histos.fill(HIST("McGen/Lambda/Pion/hPt"), vDauPt[1]); - histos.fill(HIST("McGen/Lambda/Pion/hEta"), vDauEta[1]); - histos.fill(HIST("McGen/Lambda/Pion/hRap"), vDauRap[1]); - histos.fill(HIST("McGen/Lambda/Pion/hPhi"), vDauPhi[1]); - fillKinematicHists(mcpart.pt(), mcpart.eta(), mcpart.y(), mcpart.phi()); - } else { - histos.fill(HIST("McGen/h1f_antilambda_daughter_PDG"), daughterPDGs[0]); - histos.fill(HIST("McGen/h1f_antilambda_daughter_PDG"), daughterPDGs[1]); - histos.fill(HIST("McGen/h1f_antilambda_daughter_PDG"), mcpart.pdgCode()); - histos.fill(HIST("McGen/AntiLambda/Pion/hPt"), vDauPt[0]); - histos.fill(HIST("McGen/AntiLambda/Pion/hEta"), vDauEta[0]); - histos.fill(HIST("McGen/AntiLambda/Pion/hRap"), vDauRap[0]); - histos.fill(HIST("McGen/AntiLambda/Pion/hPhi"), vDauPhi[0]); - histos.fill(HIST("McGen/AntiLambda/Proton/hPt"), vDauPt[1]); - histos.fill(HIST("McGen/AntiLambda/Proton/hEta"), vDauEta[1]); - histos.fill(HIST("McGen/AntiLambda/Proton/hRap"), vDauRap[1]); - histos.fill(HIST("McGen/AntiLambda/Proton/hPhi"), vDauPhi[1]); - fillKinematicHists(mcpart.pt(), mcpart.eta(), mcpart.y(), mcpart.phi()); - } + // Fill Kaon Table + if (partType == kKaonPlus || partType == kKaonMinus) { + // Kinematic selection + if (mcpart.pt() <= cKaonMinPt || mcpart.pt() >= cKaonMaxPt || std::abs(mcpart.y()) >= cKaonRapCut) { + continue; + } + + // histos.fill(HIST("KaonTracks/h1f_tracks_info"), kGenAccKaon); - // Fill Lambda McGen Table - lambdaMCGenTrackTable(lambdaMCGenCollisionTable.lastIndex(), mcpart.px(), mcpart.py(), mcpart.pz(), + // Fill table + kaonMCGenTrackTable(lambdaMCGenCollisionTable.lastIndex(), mcpart.px(), mcpart.py(), mcpart.pz(), mcpart.pt(), mcpart.eta(), mcpart.phi(), mcpart.y(), RecoDecay::m(mcpart.p(), mcpart.e()), - daughterIDs[0], daughterIDs[1], (int8_t)v0Type, -999., -999., v0PrmScdType, 1.); + mcpart.globalIndex(), (int8_t)partType, 1.); + } } } - template - void analyzeMcRecoGen(M const& mcCollision, C const& collisions, V const& V0s, T const& tracks, P const& mcParticles) + template + void analyzeMcRecoGen(M const& mcCollision, C const& collisions, B const& bc, V const& V0s, T const& tracks, P const& mcParticles) { // Number of Rec Collisions Associated to the McGen Collision int nRecCols = collisions.size(); @@ -1255,50 +1106,43 @@ struct LambdaTableProducer { } histos.fill(HIST("McGen/h1f_collisions_info"), kTotCol); // Check the reco collision - if (!collisions.begin().has_mcCollision() || !selCollision(collisions.begin()) || collisions.begin().mcCollisionId() != mcCollision.globalIndex()) { + if (!collisions.begin().has_mcCollision() || !selCollision(collisions.begin()) || collisions.begin().mcCollisionId() != mcCollision.globalIndex()) { return; } histos.fill(HIST("McGen/h1f_collisions_info"), kPassSelCol); histos.fill(HIST("McGen/h2f_collision_posZ"), mcCollision.posZ(), collisions.begin().posZ()); - auto v0Tracks = V0s.sliceBy(perCollision, collisions.begin().globalIndex()); - fillLambdaRecoTables(collisions.begin(), v0Tracks, tracks); - fillLambdaMcGenTables(mcCollision, mcParticles); + auto v0Tracks = V0s.sliceBy(v0sPerCollision, collisions.begin().globalIndex()); + auto tracksThisCollision = tracks.sliceBy(tracksPerCollision, collisions.begin().globalIndex()); + fillLambdaRecoTables(collisions.begin(), bc, v0Tracks, tracksThisCollision); + fillLambdaMcGenTables(mcCollision, mcParticles); } - // Collision, tracks and V0s - using CollisionsRun3 = soa::Join; - using CollisionsRun2 = soa::Join; - using Tracks = soa::Join; - using TracksRun2 = soa::Join; + // BC, Collision, tracks and V0s + using BCsRun3 = soa::Join; + using Collisions = soa::Join; + using Tracks = soa::Join; using TracksMC = soa::Join; - using TracksMCRun2 = soa::Join; using McV0Tracks = soa::Join; SliceCache cache; - Preslice> perCollision = aod::v0data::collisionId; + Preslice> v0sPerCollision = aod::v0data::collisionId; + Preslice tracksPerCollision = aod::track::collisionId; - void processDummy(CollisionsRun3::iterator const&) {} + void processDummy(Collisions::iterator const&) {} PROCESS_SWITCH(LambdaTableProducer, processDummy, "Dummy Process", true); - void processDataRun3(CollisionsRun3::iterator const& collision, aod::V0Datas const& V0s, Tracks const& tracks) + void processData(Collisions::iterator const& collision, BCsRun3 const& bc, aod::V0Datas const& V0s, Tracks const& tracks) { - fillLambdaRecoTables(collision, V0s, tracks); + fillLambdaRecoTables(collision, bc, V0s, tracks); } - PROCESS_SWITCH(LambdaTableProducer, processDataRun3, "Process for Run3 DATA", false); + PROCESS_SWITCH(LambdaTableProducer, processData, "Process for DATA", false); - void processDataRun2(CollisionsRun2::iterator const& collision, aod::V0Datas const& V0s, TracksRun2 const& tracks) - { - fillLambdaRecoTables(collision, V0s, tracks); - } - - PROCESS_SWITCH(LambdaTableProducer, processDataRun2, "Process for Run2 DATA", false); - - void processMatchEffData(CollisionsRun3::iterator const& collision, Tracks const& tracks) + void processMatchEffData(Collisions::iterator const& collision, Tracks const& tracks) { // check collision - if (!selCollision(collision)) { + if (!selCollision(collision)) { return; } // Get Matching Efficiency @@ -1307,34 +1151,22 @@ struct LambdaTableProducer { PROCESS_SWITCH(LambdaTableProducer, processMatchEffData, "Process for Matching Efficieny Calculation", false); - void processMCRecoRun3(soa::Join::iterator const& collision, aod::McCollisions const&, - McV0Tracks const& V0s, TracksMC const& tracks, aod::McParticles const&) - { - // check collision - if (!selCollision(collision)) { - return; - } - fillLambdaRecoTables(collision, V0s, tracks); - } - - PROCESS_SWITCH(LambdaTableProducer, processMCRecoRun3, "Process for Run3 McReco DATA", false); - - void processMCRecoRun2(soa::Join::iterator const& collision, aod::McCollisions const&, - McV0Tracks const& V0s, TracksMCRun2 const& tracks, aod::McParticles const&) + void processMCReco(soa::Join::iterator const& collision, aod::McCollisions const&, BCsRun3 const& bc, + McV0Tracks const& V0s, TracksMC const& tracks, aod::McParticles const&) { // check collision - if (!selCollision(collision)) { + if (!selCollision(collision)) { return; } - fillLambdaRecoTables(collision, V0s, tracks); + fillLambdaRecoTables(collision, bc, V0s, tracks); } - PROCESS_SWITCH(LambdaTableProducer, processMCRecoRun2, "Process for Run2 McReco DATA", false); + PROCESS_SWITCH(LambdaTableProducer, processMCReco, "Process for McReco DATA", false); - void processMatchEffMCReco(soa::Join::iterator const& collision, aod::McCollisions const&, TracksMC const& tracks, aod::McParticles const&) + void processMatchEffMCReco(soa::Join::iterator const& collision, aod::McCollisions const&, TracksMC const& tracks, aod::McParticles const&) { // check collision - if (!selCollision(collision)) { + if (!selCollision(collision)) { return; } // Get Matching Efficiency @@ -1343,25 +1175,15 @@ struct LambdaTableProducer { PROCESS_SWITCH(LambdaTableProducer, processMatchEffMCReco, "Process for Matching Efficieny Calculation at MC Reconstructed Level", false); - void processMCRun3(aod::McCollisions::iterator const& mcCollision, - soa::SmallGroups> const& collisions, - McV0Tracks const& V0s, TracksMC const& tracks, - aod::McParticles const& mcParticles) + void processMCRecoGen(aod::McCollisions::iterator const& mcCollision, + soa::SmallGroups> const& collisions, BCsRun3 const& bc, + McV0Tracks const& V0s, TracksMC const& tracks, + aod::McParticles const& mcParticles) { - analyzeMcRecoGen(mcCollision, collisions, V0s, tracks, mcParticles); + analyzeMcRecoGen(mcCollision, collisions, bc, V0s, tracks, mcParticles); } - PROCESS_SWITCH(LambdaTableProducer, processMCRun3, "Process for Run3 MC RecoGen", false); - - void processMCRun2(aod::McCollisions::iterator const& mcCollision, - soa::SmallGroups> const& collisions, - McV0Tracks const& V0s, TracksMCRun2 const& tracks, - aod::McParticles const& mcParticles) - { - analyzeMcRecoGen(mcCollision, collisions, V0s, tracks, mcParticles); - } - - PROCESS_SWITCH(LambdaTableProducer, processMCRun2, "Process for Run2 MC RecoGen", false); + PROCESS_SWITCH(LambdaTableProducer, processMCRecoGen, "Process for MC RecoGen", false); }; struct LambdaTracksExtProducer { @@ -1371,11 +1193,6 @@ struct LambdaTracksExtProducer { // Configurables Configurable cAcceptAllLambda{"cAcceptAllLambda", false, "Accept all Lambda"}; Configurable cRejAllLambdaShaDau{"cRejAllLambdaShaDau", true, "Reject all Lambda sharing daughters"}; - Configurable cSelLambdaMassPdg{"cSelLambdaMassPdg", false, "Select Lambda closest to Pdg Mass"}; - Configurable cSelLambdaTScore{"cSelLambdaTScore", false, "Select Lambda based on t-score"}; - Configurable cA{"cA", 0.6, "a * |lambdaMass - lambdaPdgMass|"}; - Configurable cB{"cB", 0.6, "b * DcaPrPi"}; - Configurable cC{"cC", 0.6, "c * Cos(theta_{PA})"}; // Histogram Registry. HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject}; @@ -1401,12 +1218,7 @@ struct LambdaTracksExtProducer { // InvMass, DcaDau and CosPA histos.add("Reco/h1f_lambda_invmass", "M_{p#pi}", kTH1F, {axisMass}); - histos.add("Reco/h1f_lambda_cospa", "cos(#theta_{PA})", kTH1F, {axisCPA}); - histos.add("Reco/h1f_lambda_dcadau", "DCA_{p#pi} at V0 Decay Vertex", kTH1F, {axisDcaDau}); histos.add("Reco/h1f_antilambda_invmass", "M_{p#pi}", kTH1F, {axisMass}); - histos.add("Reco/h1f_antilambda_cospa", "cos(#theta_{PA})", kTH1F, {axisCPA}); - histos.add("Reco/h1f_antilambda_dcadau", "DCA_{p#pi} at V0 Decay Vertex", kTH1F, {axisDcaDau}); - histos.addClone("Reco/", "SharingDau/"); } @@ -1415,14 +1227,10 @@ struct LambdaTracksExtProducer { { static constexpr std::string_view SubDir[] = {"Reco/", "SharingDau/"}; - if (track.v0Type() == kLambda) { + if (track.partType() == kLambda) { histos.fill(HIST(SubDir[sd]) + HIST("h1f_lambda_invmass"), track.mass()); - histos.fill(HIST(SubDir[sd]) + HIST("h1f_lambda_dcadau"), track.dcaDau()); - histos.fill(HIST(SubDir[sd]) + HIST("h1f_lambda_cospa"), track.cosPA()); } else { histos.fill(HIST(SubDir[sd]) + HIST("h1f_antilambda_invmass"), track.mass()); - histos.fill(HIST(SubDir[sd]) + HIST("h1f_antilambda_dcadau"), track.dcaDau()); - histos.fill(HIST(SubDir[sd]) + HIST("h1f_antilambda_cospa"), track.cosPA()); } } @@ -1435,19 +1243,15 @@ struct LambdaTracksExtProducer { int nTotLambda = 0, nTotAntiLambda = 0, nSelLambda = 0, nSelAntiLambda = 0; for (auto const& lambda : tracks) { - bool lambdaMinDeltaMassFlag = true, lambdaMinTScoreFlag = true; bool lambdaSharingDauFlag = false, trueLambdaFlag = false; std::vector vSharedDauLambdaIndex; - float tLambda = 0., tTrack = 0.; - if (lambda.v0Type() == kLambda) { + if (lambda.partType() == kLambda) { ++nTotLambda; - } else if (lambda.v0Type() == kAntiLambda) { + } else if (lambda.partType() == kAntiLambda) { ++nTotAntiLambda; } - tLambda = (cA * std::abs(lambda.mass() - MassLambda0)) + (cB * lambda.dcaDau()) + (cC * std::abs(lambda.cosPA() - 1.)); - for (auto const& track : tracks) { // check lambda index (don't analyze same lambda track !!!) if (lambda.index() == track.index()) { @@ -1460,24 +1264,13 @@ struct LambdaTracksExtProducer { lambdaSharingDauFlag = true; // Fill DEta-DPhi Histogram - if ((lambda.v0Type() == kLambda && track.v0Type() == kAntiLambda) || (lambda.v0Type() == kAntiLambda && track.v0Type() == kLambda)) { + if ((lambda.partType() == kLambda && track.partType() == kAntiLambda) || (lambda.partType() == kAntiLambda && track.partType() == kLambda)) { histos.fill(HIST("h2d_n2_etaphi_LaP_LaM"), lambda.eta() - track.eta(), RecoDecay::constrainAngle((lambda.phi() - track.phi()), -PIHalf)); - } else if (lambda.v0Type() == kLambda && track.v0Type() == kLambda) { + } else if (lambda.partType() == kLambda && track.partType() == kLambda) { histos.fill(HIST("h2d_n2_etaphi_LaP_LaP"), lambda.eta() - track.eta(), RecoDecay::constrainAngle((lambda.phi() - track.phi()), -PIHalf)); - } else if (lambda.v0Type() == kAntiLambda && track.v0Type() == kAntiLambda) { + } else if (lambda.partType() == kAntiLambda && track.partType() == kAntiLambda) { histos.fill(HIST("h2d_n2_etaphi_LaM_LaM"), lambda.eta() - track.eta(), RecoDecay::constrainAngle((lambda.phi() - track.phi()), -PIHalf)); } - - // decision based on mass closest to PdgMass of Lambda - if (std::abs(lambda.mass() - MassLambda0) > std::abs(track.mass() - MassLambda0)) { - lambdaMinDeltaMassFlag = false; - } - - // decisions based on t-score - tTrack = (cA * std::abs(track.mass() - MassLambda0)) + (cB * track.dcaDau()) + (cC * std::abs(track.cosPA() - 1.)); - if (tLambda > tTrack) { - lambdaMinTScoreFlag = false; - } } } @@ -1492,17 +1285,13 @@ struct LambdaTracksExtProducer { trueLambdaFlag = true; } else if (cRejAllLambdaShaDau && !lambdaSharingDauFlag) { // Reject all lambda sharing daughter trueLambdaFlag = true; - } else if (cSelLambdaMassPdg && lambdaMinDeltaMassFlag) { // Select lambda closest to pdg mass - trueLambdaFlag = true; - } else if (cSelLambdaTScore && lambdaMinTScoreFlag) { // Select lambda based on t-score - trueLambdaFlag = true; } // Multiplicity of selected lambda if (trueLambdaFlag) { - if (lambda.v0Type() == kLambda) { + if (lambda.partType() == kLambda) { ++nSelLambda; - } else if (lambda.v0Type() == kAntiLambda) { + } else if (lambda.partType() == kAntiLambda) { ++nSelAntiLambda; } } @@ -1534,19 +1323,18 @@ struct LambdaTracksExtProducer { struct LambdaR2Correlation { // Global Configurables - Configurable cNPtBins{"cNPtBins", 34, "N pT Bins"}; - Configurable cMinPt{"cMinPt", 0.8, "pT Min"}; - Configurable cMaxPt{"cMaxPt", 4.2, "pT Max"}; - Configurable cNRapBins{"cNRapBins", 20, "N Rapidity Bins"}; + Configurable cLambdaNPtBins{"cLambdaNPtBins", 34, "N pT Bins"}; + Configurable cLambdaPtMin{"cLambdaPtMin", 0.7, "Lambda pT Min"}; + Configurable cLambdaPtMax{"cLambdaPtMax", 3.4, "Lambda pT Max"}; + Configurable cKaonNPtBins{"cKaonNPtBins", 20, "N pT Bins"}; + Configurable cKaonPtMin{"cKaonPtMin", 0.4, "Kaon pT Min"}; + Configurable cKaonPtMax{"cKaonPtMax", 2.4, "Kaon pT Max"}; + + Configurable cNRapBins{"cNRapBins", 10, "N Rapidity Bins"}; Configurable cMinRap{"cMinRap", -0.5, "Minimum Rapidity"}; Configurable cMaxRap{"cMaxRap", 0.5, "Maximum Rapidity"}; Configurable cNPhiBins{"cNPhiBins", 36, "N Phi Bins"}; - Configurable cAnaSecondaries{"cAnaSecondaries", false, "Analysze Secondaries"}; Configurable cAnaPairs{"cAnaPairs", false, "Analyze Pairs Flag"}; - Configurable cAnaSecondaryPairs{"cAnaSecondaryPairs", false, "Analyze Secondary Pairs Flag"}; - - // Eta/Rap Analysis - Configurable cDoEtaAnalysis{"cDoEtaAnalysis", false, "Eta/Rap Analysis Flag"}; // Centrality Axis ConfigurableAxis cCentBins{"cCentBins", {VARIABLE_WIDTH, 0.0f, 10.0f, 20.0f, 50.f, 80.0f, 100.f}, "Variable Mult-Bins"}; @@ -1587,12 +1375,12 @@ struct LambdaR2Correlation { const AxisSpec axisChMult(200, 0, 200, "N_{ch}"); const AxisSpec axisMult(10, 0, 10, "N_{#Lambda}"); const AxisSpec axisMass(100, 1.06, 1.16, "M_{#Lambda} (GeV/#it{c}^{2})"); - const AxisSpec axisPt(cNPtBins, cMinPt, cMaxPt, "p_{T} (GeV/#it{c})"); + const AxisSpec axisPtLambda(cLambdaNPtBins, cLambdaPtMin, cLambdaPtMax, "p_{T} (GeV/#it{c})"); + const AxisSpec axisPtKaon(cKaonNPtBins, cKaonPtMin, cKaonPtMax, "p_{T} (GeV/#it{c})"); const AxisSpec axisEta(cNRapBins, cMinRap, cMaxRap, "#eta"); const AxisSpec axisRap(cNRapBins, cMinRap, cMaxRap, "y"); const AxisSpec axisPhi(cNPhiBins, 0., TwoPI, "#varphi (rad)"); const AxisSpec axisRapPhi(knrapphibins, kminrapphi, kmaxrapphi, "y #varphi"); - const AxisSpec axisQinv(100, 0, 10, "q_{inv} (GeV/#it{c})"); // Create Histograms. // Event @@ -1604,56 +1392,42 @@ struct LambdaR2Correlation { // Efficiency Histograms // Single Particle Efficiencies - histos.add("Reco/Primary/Efficiency/h2f_n1_centpt_LaP", "#rho_{1}^{#Lambda}", kTH2F, {axisCent, axisPt}); - histos.add("Reco/Primary/Efficiency/h2f_n1_centpt_LaM", "#rho_{1}^{#bar{#Lambda}}", kTH2F, {axisCent, axisPt}); - histos.add("Reco/Primary/Efficiency/h3f_n1_centptrap_LaP", "#rho_{1}^{#Lambda}", kTH3F, {axisCent, axisPt, axisRap}); - histos.add("Reco/Primary/Efficiency/h3f_n1_centptrap_LaM", "#rho_{1}^{#bar{#Lambda}}", kTH3F, {axisCent, axisPt, axisRap}); + histos.add("Reco/Efficiency/h2f_n1_centpt_LaP", "#rho_{1}^{#Lambda}", kTH2F, {axisCent, axisPtLambda}); + histos.add("Reco/Efficiency/h2f_n1_centpt_LaM", "#rho_{1}^{#bar{#Lambda}}", kTH2F, {axisCent, axisPtLambda}); + histos.add("Reco/Efficiency/h2f_n1_centpt_KaP", "#rho_{1}^{K^{#plus}}", kTH2F, {axisCent, axisPtKaon}); + histos.add("Reco/Efficiency/h2f_n1_centpt_KaM", "#rho_{1}^{K^{#minus}}", kTH2F, {axisCent, axisPtKaon}); + histos.add("Reco/Efficiency/h3f_n1_centptrap_LaP", "#rho_{1}^{#Lambda}", kTH3F, {axisCent, axisPtLambda, axisRap}); + histos.add("Reco/Efficiency/h3f_n1_centptrap_LaM", "#rho_{1}^{#bar{#Lambda}}", kTH3F, {axisCent, axisPtLambda, axisRap}); + histos.add("Reco/Efficiency/h3f_n1_centptrap_KaP", "#rho_{1}^{K^{#plus}}", kTH3F, {axisCent, axisPtKaon, axisRap}); + histos.add("Reco/Efficiency/h3f_n1_centptrap_KaM", "#rho_{1}^{K^{#minus}}", kTH3F, {axisCent, axisPtKaon, axisRap}); // Single and Two Particle Densities // 1D Histograms - histos.add("Reco/Primary/h3f_n1_centmasspt_LaP", "#rho_{1}^{#Lambda}", kTH3F, {axisCent, axisMass, axisPt}); - histos.add("Reco/Primary/h3f_n1_centmasspt_LaM", "#rho_{1}^{#bar{#Lambda}}", kTH3F, {axisCent, axisMass, axisPt}); - histos.add("Reco/Primary/h4f_n1_ptrapphi_LaP", "#rho_{1}^{#Lambda}", kTHnSparseF, {axisCent, axisPt, axisRap, axisPhi}); - histos.add("Reco/Primary/h4f_n1_ptrapphi_LaM", "#rho_{1}^{#bar{#Lambda}}", kTHnSparseF, {axisCent, axisPt, axisRap, axisPhi}); + histos.add("Reco/h3f_n1_centmasspt_LaP", "#rho_{1}^{#Lambda}", kTH3F, {axisCent, axisMass, axisPtLambda}); + histos.add("Reco/h3f_n1_centmasspt_LaM", "#rho_{1}^{#bar{#Lambda}}", kTH3F, {axisCent, axisMass, axisPtLambda}); + histos.add("Reco/h4f_n1_ptrapphi_LaP", "#rho_{1}^{#Lambda}", kTHnSparseF, {axisCent, axisPtLambda, axisRap, axisPhi}); + histos.add("Reco/h4f_n1_ptrapphi_LaM", "#rho_{1}^{#bar{#Lambda}}", kTHnSparseF, {axisCent, axisPtLambda, axisRap, axisPhi}); + histos.add("Reco/h4f_n1_ptrapphi_KaP", "#rho_{1}^{K^{#plus}}", kTHnSparseF, {axisCent, axisPtKaon, axisRap, axisPhi}); + histos.add("Reco/h4f_n1_ptrapphi_KaM", "#rho_{1}^{K^{#minus}}", kTHnSparseF, {axisCent, axisPtKaon, axisRap, axisPhi}); // rho1 for R2 RapPhi - histos.add("Reco/Primary/h3f_n1_rapphi_LaP", "#rho_{1}^{#Lambda}", kTH3F, {axisCent, axisRap, axisPhi}); - histos.add("Reco/Primary/h3f_n1_rapphi_LaM", "#rho_{1}^{#bar{#Lambda}}", kTH3F, {axisCent, axisRap, axisPhi}); - - // rho1 for Q_{inv} - histos.add("Reco/Primary/h3f_n1_ptrapphi_LaP", "#rho_{1}^{#Lambda}", kTH3F, {axisCent, axisPt, axisRapPhi}); - histos.add("Reco/Primary/h3f_n1_ptrapphi_LaM", "#rho_{1}^{#bar{#Lambda}}", kTH3F, {axisCent, axisPt, axisRapPhi}); - - // Clone Singles Primary/Secondary Histogram - if (cAnaSecondaries) { - histos.addClone("Reco/Primary/", "Reco/Secondary/"); - } + histos.add("Reco/h3f_n1_rapphi_LaP", "#rho_{1}^{#Lambda}", kTH3F, {axisCent, axisRap, axisPhi}); + histos.add("Reco/h3f_n1_rapphi_LaM", "#rho_{1}^{#bar{#Lambda}}", kTH3F, {axisCent, axisRap, axisPhi}); + histos.add("Reco/h3f_n1_rapphi_KaP", "#rho_{1}^{K^{#plus}}", kTH3F, {axisCent, axisRap, axisPhi}); + histos.add("Reco/h3f_n1_rapphi_KaM", "#rho_{1}^{K^{#minus}}", kTH3F, {axisCent, axisRap, axisPhi}); if (cAnaPairs) { - // rho2 for numerator of R2 - histos.add("Reco/PP/h3f_n2_raprap_LaP_LaM", "#rho_{2}^{#Lambda#bar{#Lambda}}", kTH3F, {axisCent, axisRap, axisRap}); - histos.add("Reco/PP/h3f_n2_raprap_LaP_LaP", "#rho_{2}^{#Lambda#Lambda}", kTH3F, {axisCent, axisRap, axisRap}); - histos.add("Reco/PP/h3f_n2_raprap_LaM_LaM", "#rho_{2}^{#bar{#Lambda}#bar{#Lambda}}", kTH3F, {axisCent, axisRap, axisRap}); - histos.add("Reco/PP/h3f_n2_phiphi_LaP_LaM", "#rho_{2}^{#Lambda#bar{#Lambda}}", kTH3F, {axisCent, axisPhi, axisPhi}); - histos.add("Reco/PP/h3f_n2_phiphi_LaP_LaP", "#rho_{2}^{#Lambda#Lambda}", kTH3F, {axisCent, axisPhi, axisPhi}); - histos.add("Reco/PP/h3f_n2_phiphi_LaM_LaM", "#rho_{2}^{#bar{#Lambda}#bar{#Lambda}}", kTH3F, {axisCent, axisPhi, axisPhi}); - // rho2 for R2 Rap1Phi1Rap2Phi2 - histos.add("Reco/PP/h3f_n2_rapphi_LaP_LaM", "#rho_{2}^{#Lambda#bar{#Lambda}}", kTH3F, {axisCent, axisRapPhi, axisRapPhi}); - histos.add("Reco/PP/h3f_n2_rapphi_LaP_LaP", "#rho_{2}^{#Lambda#Lambda}", kTH3F, {axisCent, axisRapPhi, axisRapPhi}); - histos.add("Reco/PP/h3f_n2_rapphi_LaM_LaM", "#rho_{2}^{#bar{#Lambda}#bar{#Lambda}}", kTH3F, {axisCent, axisRapPhi, axisRapPhi}); - - // rho2 for R2 Qinv - histos.add("Reco/PP/h3f_n2_qinv_LaP_LaM", "#rho_{2}^{#Lambda#bar{#Lambda}}", kTHnSparseF, {axisCent, axisPt, axisRapPhi, axisQinv}); - histos.add("Reco/PP/h3f_n2_qinv_LaP_LaP", "#rho_{2}^{#Lambda#Lambda}", kTHnSparseF, {axisCent, axisPt, axisRapPhi, axisQinv}); - histos.add("Reco/PP/h3f_n2_qinv_LaM_LaM", "#rho_{2}^{#bar{#Lambda}#bar{#Lambda}}", kTHnSparseF, {axisCent, axisPt, axisRapPhi, axisQinv}); - - // Clone Pairs Histograms - if (cAnaSecondaryPairs) { - histos.addClone("Reco/PP/", "Reco/PS/"); - histos.addClone("Reco/PP/", "Reco/SP/"); - histos.addClone("Reco/PP/", "Reco/SS/"); - } + histos.add("Reco/h3f_n2_rapphi_LaP_LaM", "#rho_{2}^{#Lambda#bar{#Lambda}}", kTH3F, {axisCent, axisRapPhi, axisRapPhi}); + histos.add("Reco/h3f_n2_rapphi_LaP_LaP", "#rho_{2}^{#Lambda#Lambda}", kTH3F, {axisCent, axisRapPhi, axisRapPhi}); + histos.add("Reco/h3f_n2_rapphi_LaM_LaM", "#rho_{2}^{#bar{#Lambda}#bar{#Lambda}}", kTH3F, {axisCent, axisRapPhi, axisRapPhi}); + histos.add("Reco/h3f_n2_rapphi_LaP_KaM", "#rho_{2}^{#LambdaK^{#minus}}", kTH3F, {axisCent, axisRapPhi, axisRapPhi}); + histos.add("Reco/h3f_n2_rapphi_LaP_KaP", "#rho_{2}^{#LambdaK^{#plus}}", kTH3F, {axisCent, axisRapPhi, axisRapPhi}); + histos.add("Reco/h3f_n2_rapphi_LaM_KaM", "#rho_{2}^{#bar{#Lambda}K^{#plus}}", kTH3F, {axisCent, axisRapPhi, axisRapPhi}); + histos.add("Reco/h3f_n2_rapphi_LaM_KaP", "#rho_{2}^{#bar{#Lambda}K^{#minus}}", kTH3F, {axisCent, axisRapPhi, axisRapPhi}); + histos.add("Reco/h3f_n2_rapphi_KaP_KaM", "#rho_{2}^{#LambdaK^{#minus}}", kTH3F, {axisCent, axisRapPhi, axisRapPhi}); + histos.add("Reco/h3f_n2_rapphi_KaP_KaP", "#rho_{2}^{#LambdaK^{#plus}}", kTH3F, {axisCent, axisRapPhi, axisRapPhi}); + histos.add("Reco/h3f_n2_rapphi_KaM_KaM", "#rho_{2}^{#bar{#Lambda}K^{#plus}}", kTH3F, {axisCent, axisRapPhi, axisRapPhi}); } // MCGen @@ -1678,49 +1452,34 @@ struct LambdaR2Correlation { return rapphibin; } - template - void fillPairHistos(U& p1, U& p2) + template + void fillPairHistos(T1& p1, T2& p2) { static constexpr std::string_view SubDirRecGen[] = {"Reco/", "McGen/"}; - static constexpr std::string_view SubDirPrmScd[] = {"PP/", "PS/", "SP/", "SS/"}; - static constexpr std::string_view SubDirHist[] = {"LaP_LaM", "LaP_LaP", "LaM_LaM"}; - - float rap1 = (cDoEtaAnalysis) ? p1.eta() : p1.rap(); - float rap2 = (cDoEtaAnalysis) ? p2.eta() : p2.rap(); + static constexpr std::string_view SubDirHist[] = {"LaP_LaM", "LaP_LaP", "LaM_LaM", "LaP_KaP", "LaP_KaM", "LaM_KaP", "LaM_KaM", "KaP_KaM", "KaP_KaP", "KaM_KaM"}; - int rapbin1 = static_cast((rap1 - kminrap) / rapbinwidth); - int rapbin2 = static_cast((rap2 - kminrap) / rapbinwidth); + int rapbin1 = static_cast((p1.rap() - kminrap) / rapbinwidth); + int rapbin2 = static_cast((p2.rap() - kminrap) / rapbinwidth); int phibin1 = static_cast(p1.phi() / phibinwidth); int phibin2 = static_cast(p2.phi() / phibinwidth); float corfac = p1.corrFact() * p2.corrFact(); - // fill rho2 histograms - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST(SubDirPrmScd[psp]) + HIST("h3f_n2_raprap_") + HIST(SubDirHist[part_pair]), cent, rap1, rap2, corfac); - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST(SubDirPrmScd[psp]) + HIST("h3f_n2_phiphi_") + HIST(SubDirHist[part_pair]), cent, p1.phi(), p2.phi(), corfac); - if (rapbin1 >= 0 && rapbin2 >= 0 && phibin1 >= 0 && phibin2 >= 0 && rapbin1 < nrapbins && rapbin2 < nrapbins && phibin1 < nphibins && phibin2 < nphibins) { int rapphix = rapbin1 * nphibins + phibin1; int rapphiy = rapbin2 * nphibins + phibin2; - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST(SubDirPrmScd[psp]) + HIST("h3f_n2_rapphi_") + HIST(SubDirHist[part_pair]), cent, rapphix + 0.5, rapphiy + 0.5, corfac); + histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("h3f_n2_rapphi_") + HIST(SubDirHist[part_pair]), cent, rapphix + 0.5, rapphiy + 0.5, corfac); } - - // qinv histograms - q = RecoDecay::p((p1.px() - p2.px()), (p1.py() - p2.py()), (p1.pz() - p2.pz())); - e = RecoDecay::e(p1.px(), p1.py(), p1.pz(), MassLambda0) - RecoDecay::e(p2.px(), p2.py(), p2.pz(), MassLambda0); - qinv = std::sqrt(-RecoDecay::m2(q, e)); - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST(SubDirPrmScd[psp]) + HIST("h3f_n2_qinv_") + HIST(SubDirHist[part_pair]), cent, p1.pt(), getRapPhiBin(p1.rap(), p1.phi()), qinv, corfac); } - template + template void analyzeSingles(T const& tracks) { static constexpr std::string_view SubDirRecGen[] = {"Reco/", "McGen/"}; - static constexpr std::string_view SubDirPrmScd[] = {"Primary/", "Secondary/"}; - static constexpr std::string_view SubDirHist[] = {"LaP", "LaM"}; + static constexpr std::string_view SubDirHist[] = {"LaP", "LaM", "KaP", "KaM"}; int ntrk = 0; @@ -1729,58 +1488,58 @@ struct LambdaR2Correlation { ++ntrk; // Efficiency Plots - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST(SubDirPrmScd[pst]) + HIST("Efficiency/h2f_n1_centpt_") + HIST(SubDirHist[part]), cent, track.pt()); - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST(SubDirPrmScd[pst]) + HIST("Efficiency/h3f_n1_centptrap_") + HIST(SubDirHist[part]), cent, track.pt(), track.rap()); + histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("Efficiency/h2f_n1_centpt_") + HIST(SubDirHist[part]), cent, track.pt()); + histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("Efficiency/h3f_n1_centptrap_") + HIST(SubDirHist[part]), cent, track.pt(), track.rap()); // QA Plots - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST(SubDirPrmScd[pst]) + HIST("h3f_n1_centmasspt_") + HIST(SubDirHist[part]), cent, track.mass(), track.pt()); - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST(SubDirPrmScd[pst]) + HIST("h4f_n1_ptrapphi_") + HIST(SubDirHist[part]), cent, track.pt(), track.rap(), track.phi(), track.corrFact()); + if (part == kLambda || part == kAntiLambda) { + histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("h3f_n1_centmasspt_") + HIST(SubDirHist[part]), cent, track.mass(), track.pt()); + } + histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("h4f_n1_ptrapphi_") + HIST(SubDirHist[part]), cent, track.pt(), track.rap(), track.phi(), track.corrFact()); // Rho1 for N1RapPhi - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST(SubDirPrmScd[pst]) + HIST("h3f_n1_rapphi_") + HIST(SubDirHist[part]), cent, track.rap(), track.phi(), track.corrFact()); - - // Rho1 for Q_{inv} - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST(SubDirPrmScd[pst]) + HIST("h3f_n1_ptrapphi_") + HIST(SubDirHist[part]), cent, track.pt(), getRapPhiBin(track.rap(), track.phi()), track.corrFact()); + histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("h3f_n1_rapphi_") + HIST(SubDirHist[part]), cent, track.rap(), track.phi(), track.corrFact()); } // fill multiplicity histograms if (ntrk != 0) { if (part == kLambda) { histos.fill(HIST("Event/") + HIST(SubDirRecGen[rec_gen]) + HIST("h2f_lambda_mult"), cent, ntrk); - } else { + } else if (part == kAntiLambda) { histos.fill(HIST("Event/") + HIST(SubDirRecGen[rec_gen]) + HIST("h2f_antilambda_mult"), cent, ntrk); } } } - template - void analyzePairs(T const& trks_1, T const& trks_2) + template + void analyzePairs(T1 const& trks_1, T2 const& trks_2) { for (auto const& trk_1 : trks_1) { for (auto const& trk_2 : trks_2) { // check for same index for Lambda-Lambda / AntiLambda-AntiLambda - if (samelambda && ((trk_1.index() == trk_2.index()))) { + if (same && ((trk_1.index() == trk_2.index()))) { continue; } - fillPairHistos(trk_1, trk_2); + fillPairHistos(trk_1, trk_2); } } } using LambdaCollisions = aod::LambdaCollisions; using LambdaTracks = soa::Join; + using KaonTracks = aod::KaonTracks; SliceCache cache; - Partition partPrimLambdaTracks = (aod::lambdatrack::v0Type == (int8_t)kLambda) && (aod::lambdatrackext::trueLambdaFlag == true) && (aod::lambdatrack::v0PrmScd == (int8_t)kPrimary); - Partition partPrimAntiLambdaTracks = (aod::lambdatrack::v0Type == (int8_t)kAntiLambda) && (aod::lambdatrackext::trueLambdaFlag == true) && (aod::lambdatrack::v0PrmScd == (int8_t)kPrimary); - Partition partSecdLambdaTracks = (aod::lambdatrack::v0Type == (int8_t)kLambda) && (aod::lambdatrackext::trueLambdaFlag == true) && (aod::lambdatrack::v0PrmScd == (int8_t)kSecondary); - Partition partSecdAntiLambdaTracks = (aod::lambdatrack::v0Type == (int8_t)kAntiLambda) && (aod::lambdatrackext::trueLambdaFlag == true) && (aod::lambdatrack::v0PrmScd == (int8_t)kSecondary); + Partition partLambdaTracks = (aod::lambdatrack::partType == (int8_t)kLambda) && (aod::lambdatrackext::trueLambdaFlag == true); + Partition partAntiLambdaTracks = (aod::lambdatrack::partType == (int8_t)kAntiLambda) && (aod::lambdatrackext::trueLambdaFlag == true); + Partition partKaonPlusTracks = (aod::kaontrack::partType == (int8_t)kKaonPlus); + Partition partKaonMinusTracks = (aod::kaontrack::partType == (int8_t)kKaonMinus); void processDummy(aod::LambdaCollisions::iterator const&) {} PROCESS_SWITCH(LambdaR2Correlation, processDummy, "Dummy Process", true); - void processDataReco(LambdaCollisions::iterator const& collision, LambdaTracks const&) + void processDataReco(LambdaCollisions::iterator const& collision, LambdaTracks const&, KaonTracks const&) { histos.fill(HIST("Event/Reco/h1f_collision_posz"), collision.posZ()); histos.fill(HIST("Event/Reco/h1f_ft0m_mult_percentile"), collision.cent()); @@ -1788,37 +1547,28 @@ struct LambdaR2Correlation { cent = collision.cent(); - auto lambdaPrimTracks = partPrimLambdaTracks->sliceByCached(aod::lambdatrack::lambdaCollisionId, collision.globalIndex(), cache); - auto antiLambdaPrimTracks = partPrimAntiLambdaTracks->sliceByCached(aod::lambdatrack::lambdaCollisionId, collision.globalIndex(), cache); - auto lambdaSecdTracks = partSecdLambdaTracks->sliceByCached(aod::lambdatrack::lambdaCollisionId, collision.globalIndex(), cache); - auto antiLambdaSecdTracks = partSecdAntiLambdaTracks->sliceByCached(aod::lambdatrack::lambdaCollisionId, collision.globalIndex(), cache); + auto lambdaTracks = partLambdaTracks->sliceByCached(aod::lambdatrack::lambdaCollisionId, collision.globalIndex(), cache); + auto antiLambdaTracks = partAntiLambdaTracks->sliceByCached(aod::lambdatrack::lambdaCollisionId, collision.globalIndex(), cache); + auto kaonPlusTracks = partKaonPlusTracks->sliceByCached(aod::kaontrack::lambdaCollisionId, collision.globalIndex(), cache); + auto kaonMinusTracks = partKaonMinusTracks->sliceByCached(aod::kaontrack::lambdaCollisionId, collision.globalIndex(), cache); - analyzeSingles(lambdaPrimTracks); - analyzeSingles(antiLambdaPrimTracks); - - if (cAnaSecondaries) { - analyzeSingles(lambdaSecdTracks); - analyzeSingles(antiLambdaSecdTracks); - } + analyzeSingles(lambdaTracks); + analyzeSingles(antiLambdaTracks); + analyzeSingles(kaonPlusTracks); + analyzeSingles(kaonMinusTracks); if (cAnaPairs) { - // Primary Pairs Only - analyzePairs(lambdaPrimTracks, antiLambdaPrimTracks); - analyzePairs(lambdaPrimTracks, lambdaPrimTracks); - analyzePairs(antiLambdaPrimTracks, antiLambdaPrimTracks); - - // Secondary Pairs - if (cAnaSecondaryPairs) { - analyzePairs(lambdaPrimTracks, antiLambdaSecdTracks); - analyzePairs(lambdaPrimTracks, lambdaSecdTracks); - analyzePairs(antiLambdaPrimTracks, antiLambdaSecdTracks); - analyzePairs(lambdaSecdTracks, antiLambdaPrimTracks); - analyzePairs(lambdaSecdTracks, lambdaPrimTracks); - analyzePairs(antiLambdaSecdTracks, antiLambdaPrimTracks); - analyzePairs(lambdaSecdTracks, antiLambdaSecdTracks); - analyzePairs(lambdaSecdTracks, lambdaSecdTracks); - analyzePairs(antiLambdaSecdTracks, antiLambdaSecdTracks); - } + // Pairs Only + analyzePairs(lambdaTracks, antiLambdaTracks); + analyzePairs(lambdaTracks, lambdaTracks); + analyzePairs(antiLambdaTracks, antiLambdaTracks); + analyzePairs(lambdaTracks, kaonPlusTracks); + analyzePairs(lambdaTracks, kaonMinusTracks); + analyzePairs(antiLambdaTracks, kaonPlusTracks); + analyzePairs(antiLambdaTracks, kaonMinusTracks); + analyzePairs(kaonPlusTracks, kaonMinusTracks); + analyzePairs(kaonPlusTracks, kaonPlusTracks); + analyzePairs(kaonMinusTracks, kaonMinusTracks); } } @@ -1826,14 +1576,15 @@ struct LambdaR2Correlation { using LambdaMcGenCollisions = aod::LambdaMcGenCollisions; using LambdaMcGenTracks = aod::LambdaMcGenTracks; + using KaonMcGenTracks = aod::KaonMcGenTracks; SliceCache cachemc; - Partition partMcPrimLambdaTracks = (aod::lambdatrack::v0Type == (int8_t)kLambda) && (aod::lambdatrack::v0PrmScd == (int8_t)kPrimary); - Partition partMcPrimAntiLambdaTracks = (aod::lambdatrack::v0Type == (int8_t)kAntiLambda) && (aod::lambdatrack::v0PrmScd == (int8_t)kPrimary); - Partition partMcSecdLambdaTracks = (aod::lambdatrack::v0Type == (int8_t)kLambda) && (aod::lambdatrack::v0PrmScd == (int8_t)kSecondary); - Partition partMcSecdAntiLambdaTracks = (aod::lambdatrack::v0Type == (int8_t)kAntiLambda) && (aod::lambdatrack::v0PrmScd == (int8_t)kSecondary); + Partition partMcLambdaTracks = (aod::lambdatrack::partType == (int8_t)kLambda); + Partition partMcAntiLambdaTracks = (aod::lambdatrack::partType == (int8_t)kAntiLambda); + Partition partMcKaonPlusTracks = (aod::kaontrack::partType == (int8_t)kKaonPlus); + Partition partMcKaonMinusTracks = (aod::kaontrack::partType == (int8_t)kKaonMinus); - void processMCGen(LambdaMcGenCollisions::iterator const& mcgencol, LambdaMcGenTracks const&) + void processMCGen(LambdaMcGenCollisions::iterator const& mcgencol, LambdaMcGenTracks const&, KaonMcGenTracks const&) { histos.fill(HIST("Event/McGen/h1f_collision_posz"), mcgencol.posZ()); histos.fill(HIST("Event/McGen/h1f_ft0m_mult_percentile"), mcgencol.cent()); @@ -1841,37 +1592,27 @@ struct LambdaR2Correlation { cent = mcgencol.cent(); - auto lambdaPrimTracks = partMcPrimLambdaTracks->sliceByCached(aod::lambdamcgentrack::lambdaMcGenCollisionId, mcgencol.globalIndex(), cachemc); - auto antiLambdaPrimTracks = partMcPrimAntiLambdaTracks->sliceByCached(aod::lambdamcgentrack::lambdaMcGenCollisionId, mcgencol.globalIndex(), cachemc); - auto lambdaSecdTracks = partMcSecdLambdaTracks->sliceByCached(aod::lambdamcgentrack::lambdaMcGenCollisionId, mcgencol.globalIndex(), cachemc); - auto antiLambdaSecdTracks = partMcSecdAntiLambdaTracks->sliceByCached(aod::lambdamcgentrack::lambdaMcGenCollisionId, mcgencol.globalIndex(), cachemc); - - analyzeSingles(lambdaPrimTracks); - analyzeSingles(antiLambdaPrimTracks); + auto lambdaTracks = partMcLambdaTracks->sliceByCached(aod::lambdamcgentrack::lambdaMcGenCollisionId, mcgencol.globalIndex(), cache); + auto antiLambdaTracks = partMcAntiLambdaTracks->sliceByCached(aod::lambdamcgentrack::lambdaMcGenCollisionId, mcgencol.globalIndex(), cache); + auto kaonPlusTracks = partMcKaonPlusTracks->sliceByCached(aod::kaonmcgentrack::lambdaMcGenCollisionId, mcgencol.globalIndex(), cache); + auto kaonMinusTracks = partMcKaonMinusTracks->sliceByCached(aod::kaonmcgentrack::lambdaMcGenCollisionId, mcgencol.globalIndex(), cache); - if (cAnaSecondaries) { - analyzeSingles(lambdaSecdTracks); - analyzeSingles(antiLambdaSecdTracks); - } + analyzeSingles(lambdaTracks); + analyzeSingles(antiLambdaTracks); + analyzeSingles(kaonPlusTracks); + analyzeSingles(kaonMinusTracks); if (cAnaPairs) { - // Primary Pairs Only - analyzePairs(lambdaPrimTracks, antiLambdaPrimTracks); - analyzePairs(lambdaPrimTracks, lambdaPrimTracks); - analyzePairs(antiLambdaPrimTracks, antiLambdaPrimTracks); - - // Secondary Pairs - if (cAnaSecondaryPairs) { - analyzePairs(lambdaPrimTracks, antiLambdaSecdTracks); - analyzePairs(lambdaPrimTracks, lambdaSecdTracks); - analyzePairs(antiLambdaPrimTracks, antiLambdaSecdTracks); - analyzePairs(lambdaSecdTracks, antiLambdaPrimTracks); - analyzePairs(lambdaSecdTracks, lambdaPrimTracks); - analyzePairs(antiLambdaSecdTracks, antiLambdaPrimTracks); - analyzePairs(lambdaSecdTracks, antiLambdaSecdTracks); - analyzePairs(lambdaSecdTracks, lambdaSecdTracks); - analyzePairs(antiLambdaSecdTracks, antiLambdaSecdTracks); - } + analyzePairs(lambdaTracks, antiLambdaTracks); + analyzePairs(lambdaTracks, lambdaTracks); + analyzePairs(antiLambdaTracks, antiLambdaTracks); + analyzePairs(lambdaTracks, kaonPlusTracks); + analyzePairs(lambdaTracks, kaonMinusTracks); + analyzePairs(antiLambdaTracks, kaonPlusTracks); + analyzePairs(antiLambdaTracks, kaonMinusTracks); + analyzePairs(kaonPlusTracks, kaonMinusTracks); + analyzePairs(kaonPlusTracks, kaonPlusTracks); + analyzePairs(kaonMinusTracks, kaonMinusTracks); } }