diff --git a/PWGHF/Core/SelectorCuts.h b/PWGHF/Core/SelectorCuts.h index 9c19920dadb..1bb1495a6d6 100644 --- a/PWGHF/Core/SelectorCuts.h +++ b/PWGHF/Core/SelectorCuts.h @@ -755,7 +755,7 @@ static const std::vector labelsCutVar = {"pT Ka from Omegac"}; namespace hf_cuts_xic_to_xi_pi { -static constexpr int NBinsPt = 11; +static constexpr int NBinsPt = 12; static constexpr int NCutVars = 28; // default values for the pT bin edges (can be used to configure histogram axis) // offset by 1 from the bin numbers in cuts array @@ -771,22 +771,24 @@ constexpr double BinsPt[NBinsPt + 1] = { 10.0, 12.0, 16.0, - 24.0}; + 24.0, + 50.0}; const auto vecBinsPt = std::vector{BinsPt, BinsPt + NBinsPt + 1}; // default values for the cuts -constexpr double Cuts[NBinsPt][NCutVars] = {{0.2, 0.99, 0.97, 0.99, 0.99, 0.1, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 0 < pt < 1 */ - {0.5, 0.99, 0.97, 0.99, 0.99, 0.1, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 1 < pt < 2 */ - {0.5, 0.99, 0.97, 0.99, 0.99, 0.1, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 2 < pt < 3 */ - {0.5, 0.99, 0.97, 0.99, 0.99, 0.1, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 3 < pt < 4 */ - {0.5, 0.99, 0.97, 0.99, 0.99, 0.1, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 4 < pt < 5 */ - {0.5, 0.99, 0.97, 0.99, 0.99, 0.1, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 5 < pt < 6 */ - {0.5, 0.99, 0.97, 0.99, 0.99, 0.1, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 6 < pt < 8 */ - {0.5, 0.99, 0.97, 0.99, 0.99, 0.1, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 8 < pt < 10 */ - {0.5, 0.99, 0.97, 0.99, 0.99, 0.1, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 10 < pt < 12 */ - {0.5, 0.99, 0.97, 0.99, 0.99, 0.1, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 12 < pt < 16 */ - {0.5, 0.99, 0.97, 0.99, 0.99, 0.1, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}}; /* 16 < pt < 24 */ +constexpr double Cuts[NBinsPt][NCutVars] = {{0.2, 0.97, 0.97, 0.99, 0.99, 2.0, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 0 < pt < 1 */ + {0.5, 0.97, 0.97, 0.99, 0.99, 2.0, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 1 < pt < 2 */ + {0.5, 0.97, 0.97, 0.99, 0.99, 2.0, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 2 < pt < 3 */ + {0.5, 0.97, 0.97, 0.99, 0.99, 2.0, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 3 < pt < 4 */ + {0.5, 0.97, 0.97, 0.99, 0.99, 2.0, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 4 < pt < 5 */ + {0.5, 0.97, 0.97, 0.99, 0.99, 2.0, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 5 < pt < 6 */ + {0.5, 0.97, 0.97, 0.99, 0.99, 2.0, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 6 < pt < 8 */ + {0.5, 0.97, 0.97, 0.99, 0.99, 2.0, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 8 < pt < 10 */ + {0.5, 0.97, 0.97, 0.99, 0.99, 2.0, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 10 < pt < 12 */ + {0.5, 0.97, 0.97, 0.99, 0.99, 2.0, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 12 < pt < 16 */ + {0.5, 0.97, 0.97, 0.99, 0.99, 2.0, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}, /* 16 < pt < 24 */ + {0.5, 0.97, 0.97, 0.99, 0.99, 2.0, 0.2, 1.0, 0.04, 0.06, 0.06, 0.05, 0.3, 70, 60, 100, 120, 250, 250, 0.4, 100, 300, 0., 0., 1.5, 0., 0., 0.4}}; /* 24 < pt < 50 -> Implemented just for test*/ // row labels static const std::vector labelsPt = { @@ -800,14 +802,16 @@ static const std::vector labelsPt = { "pT bin 7", "pT bin 8", "pT bin 9", - "pT bin 10"}; + "pT bin 10", + "pT bin 11"}; // column labels static const std::vector labelsCutVar = {"ptPiFromCharmBaryon", "cosPACasc", "cosPAV0", "cosPaCascToXic", "cosPaV0ToCasc", - "dcaCharmBaryonDau", "dcaCascDau", "dcaV0Dau", "dcaXYToPvCascDau", "dcaXYToPvV0Dau0", "dcaXYToPvV0Dau1", "kfDcaXYPiFromXic", "kfDcaXYCascToPv", - "chi2GeoXic", "chi2GeoCasc", "chi2GeoV0", - "chi2TopoXicToPv", "chi2TopoPiFromXicToPv", "chi2TopoCascToPv", "chi2TopoV0ToPv", "chi2TopoV0ToCasc", "chi2TopoCascToXic", - "cascldl", "v0ldl", "decayLenXYXic", "decayLenXYCasc", "decayLenXYLambda", "cTauXic"}; + "dcaCharmBaryonDau", "dcaCascDau", "dcaV0Dau", "dcaXYToPvCascDau", "dcaXYToPvV0Dau0", + "dcaXYToPvV0Dau1", "kfDcaXYPiFromXic", "kfDcaXYCascToPv", "chi2GeoXic", "chi2GeoCasc", + "chi2GeoV0", "chi2TopoXicToPv", "chi2TopoPiFromXicToPv", "chi2TopoCascToPv", "chi2TopoV0ToPv", + "chi2TopoV0ToCasc", "chi2TopoCascToXic", "cascldl", "v0ldl", "decayLenXYXic", + "decayLenXYCasc", "decayLenXYLambda", "cTauXic"}; } // namespace hf_cuts_xic_to_xi_pi namespace hf_cuts_xic_to_p_k_pi @@ -859,93 +863,6 @@ static const std::vector labelsPt = { static const std::vector labelsCutVar = {"m", "pT p", "pT K", "pT Pi", "chi2PCA", "decay length", "cos pointing angle", "decLengthXY", "normDecLXY", "ct", "impParXY"}; } // namespace hf_cuts_xic_to_p_k_pi -namespace hf_cuts_to_xi_pi -{ -static constexpr int NBinsPt = 13; -static constexpr int NCutVars = 26; -// default values for the pT bin edges (can be used to configure histogram axis) -// offset by 1 from the bin numbers in cuts array -constexpr double BinsPt[NBinsPt + 1] = { - 0., - 1., - 2., - 3., - 4., - 5., - 6., - 7., - 8., - 9., - 10., - 11., - 12., - 20.}; -auto vecBinsPt = std::vector{BinsPt, BinsPt + NBinsPt + 1}; - -// default values for the cuts -constexpr double Cuts[NBinsPt][NCutVars] = { - {2.0, 3.1, 0.01, 0.01, 0.2, 0.15, 1.0, 1.0, 2.0, 0.06, 0.06, 0.04, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.97, 0.97, 0.6, 1.2, 1.0, 0.8}, - {2.0, 3.1, 0.01, 0.01, 0.2, 0.15, 1.0, 1.0, 2.0, 0.06, 0.06, 0.04, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.97, 0.97, 0.6, 1.2, 1.0, 0.8}, - {2.0, 3.1, 0.01, 0.01, 0.2, 0.15, 1.0, 1.0, 2.0, 0.06, 0.06, 0.04, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.97, 0.97, 0.6, 1.2, 1.0, 0.8}, - {2.0, 3.1, 0.01, 0.01, 0.2, 0.15, 1.0, 1.0, 2.0, 0.06, 0.06, 0.04, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.97, 0.97, 0.6, 1.2, 1.0, 0.8}, - {2.0, 3.1, 0.01, 0.01, 0.2, 0.15, 1.0, 1.0, 2.0, 0.06, 0.06, 0.04, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.97, 0.97, 0.6, 1.2, 1.0, 0.8}, - {2.0, 3.1, 0.01, 0.01, 0.2, 0.15, 1.0, 1.0, 2.0, 0.06, 0.06, 0.04, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.97, 0.97, 0.6, 1.2, 1.0, 0.8}, - {2.0, 3.1, 0.01, 0.01, 0.2, 0.15, 1.0, 1.0, 2.0, 0.06, 0.06, 0.04, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.97, 0.97, 0.6, 1.2, 1.0, 0.8}, - {2.0, 3.1, 0.01, 0.01, 0.2, 0.15, 1.0, 1.0, 2.0, 0.06, 0.06, 0.04, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.97, 0.97, 0.6, 1.2, 1.0, 0.8}, - {2.0, 3.1, 0.01, 0.01, 0.2, 0.15, 1.0, 1.0, 2.0, 0.06, 0.06, 0.04, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.97, 0.97, 0.6, 1.2, 1.0, 0.8}, - {2.0, 3.1, 0.01, 0.01, 0.2, 0.15, 1.0, 1.0, 2.0, 0.06, 0.06, 0.04, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.97, 0.97, 0.6, 1.2, 1.0, 0.8}, - {2.0, 3.1, 0.01, 0.01, 0.2, 0.15, 1.0, 1.0, 2.0, 0.06, 0.06, 0.04, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.97, 0.97, 0.6, 1.2, 1.0, 0.8}, - {2.0, 3.1, 0.01, 0.01, 0.2, 0.15, 1.0, 1.0, 2.0, 0.06, 0.06, 0.04, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.97, 0.97, 0.6, 1.2, 1.0, 0.8}, - {2.0, 3.1, 0.01, 0.01, 0.2, 0.15, 1.0, 1.0, 2.0, 0.06, 0.06, 0.04, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.0, 10.0, 0.97, 0.97, 0.6, 1.2, 1.0, 0.8}, -}; - -// row labels -static const std::vector labelsPt = { - "pT bin 0", - "pT bin 1", - "pT bin 2", - "pT bin 3", - "pT bin 4", - "pT bin 5", - "pT bin 6", - "pT bin 7", - "pT bin 8", - "pT bin 9", - "pT bin 10", - "pT bin 11", - "pT bin 12"}; - -// column labels -static const std::vector labelsCutVar = { - "mCharmBaryonMin", - "mCharmBaryonMax", - "massWindowCascade", - "massWindowV0", // Invariant mass - "ptCharmBachelorMin", - "ptBachelorMin", // pt of daughter - "dcaCascDauMax", - "dcaV0DauMax", - "dcaCharmBaryonDauMax", // dca between daughters - "dcaxyV0PosDauToPvMin", - "dcaxyV0NegDauToPvMin", - "dcaxyBachToPvMin", // DCAXY(impact parameter) - "impactParXYCharmBachelorMin", - "impactParXYCharmBachelorMax", - "impactParZCharmBachelorMin", - "impactParZCharmBachelorMax", // DCAXY(impact parameter) - "impactParXYCascMin", - "impactParXYCascMax", - "impactParZCascMin", - "impactParZCascMax", // DCAXY(impact parameter) - "cosPaCascMin", - "cosPaV0Min", // CosPa - "radiusCascMin", - "radiusV0Min", // radius - "etaTrackLFDauMax", - "etaTrackCharmBachMax" // eta cut to daughter tracks -}; -} // namespace hf_cuts_to_xi_pi - namespace hf_cuts_xic_to_xi_pi_pi { static constexpr int NBinsPt = 13; diff --git a/PWGHF/D2H/Tasks/taskXic0ToXiPi.cxx b/PWGHF/D2H/Tasks/taskXic0ToXiPi.cxx index c9c09f94859..510a5045916 100644 --- a/PWGHF/D2H/Tasks/taskXic0ToXiPi.cxx +++ b/PWGHF/D2H/Tasks/taskXic0ToXiPi.cxx @@ -165,6 +165,15 @@ struct HfTaskXic0ToXiPi { registry.add("hMassVsPtVsYVsCentVsPtPion", "Thn for Xic0 candidates with Cent&pTpi", HistType::kTHnSparseD, axesWithCent); registry.get(HIST("hBdtScoreVsMassVsPtVsYVsCentVsPtPion"))->Sumw2(); registry.get(HIST("hMassVsPtVsYVsCentVsPtPion"))->Sumw2(); + } else { + const AxisSpec thnAxisPromptScore{thnConfigAxisPromptScore, "BDT score prompt."}; + const AxisSpec thnAxisPtPion{thnConfigAxisPtPion, "Pt of Pion from Xic0."}; + std::vector const axesWithBdtWithoutCent = {thnAxisPromptScore, thnAxisMass, thnAxisPt, thnAxisY, thnAxisPtPion, thnConfigAxisNumPvContr}; + std::vector const axesWithoutCent = {thnAxisMass, thnAxisPt, thnAxisY, thnAxisPtPion, thnConfigAxisNumPvContr}; + registry.add("hBdtScoreVsMassVsPtVsYVsPtPion", "Thn for Xic0 candidates with BDT&Cent&pTpi", HistType::kTHnSparseD, axesWithBdtWithoutCent); + registry.add("hMassVsPtVsYVsPtPion", "Thn for Xic0 candidates with Cent&pTpi", HistType::kTHnSparseD, axesWithoutCent); + registry.get(HIST("hBdtScoreVsMassVsPtVsYVsPtPion"))->Sumw2(); + registry.get(HIST("hMassVsPtVsYVsPtPion"))->Sumw2(); } } @@ -192,22 +201,41 @@ struct HfTaskXic0ToXiPi { double const ptXic = RecoDecay::pt(candidate.pxCharmBaryon(), candidate.pyCharmBaryon()); double const ptPiFromXic = RecoDecay::pt(candidate.pxBachFromCharmBaryon(), candidate.pyBachFromCharmBaryon()); if constexpr (ApplyMl) { - registry.fill(HIST("hBdtScoreVsMassVsPtVsYVsCentVsPtPion"), - candidate.mlProbToXiPi()[0], - candidate.invMassCharmBaryon(), - ptXic, - yCharmBaryon, - centrality, - ptPiFromXic, - numPvContributors); + if constexpr (UseCentrality) { + registry.fill(HIST("hBdtScoreVsMassVsPtVsYVsCentVsPtPion"), + candidate.mlProbToXiPi()[0], + candidate.invMassCharmBaryon(), + ptXic, + yCharmBaryon, + centrality, + ptPiFromXic, + numPvContributors); + } else { + registry.fill(HIST("hBdtScoreVsMassVsPtVsYVsPtPion"), + candidate.mlProbToXiPi()[0], + candidate.invMassCharmBaryon(), + ptXic, + yCharmBaryon, + ptPiFromXic, + numPvContributors); + } } else { - registry.fill(HIST("hMassVsPtVsYVsCentVsPtPion"), - candidate.invMassCharmBaryon(), - ptXic, - yCharmBaryon, - centrality, - ptPiFromXic, - numPvContributors); + if constexpr (UseCentrality) { + registry.fill(HIST("hMassVsPtVsYVsCentVsPtPion"), + candidate.invMassCharmBaryon(), + ptXic, + yCharmBaryon, + centrality, + ptPiFromXic, + numPvContributors); + } else { + registry.fill(HIST("hMassVsPtVsYVsPtPion"), + candidate.invMassCharmBaryon(), + ptXic, + yCharmBaryon, + ptPiFromXic, + numPvContributors); + } } } @@ -348,7 +376,7 @@ struct HfTaskXic0ToXiPi { } } } - PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithKFParticle, "process HfTaskXic0ToXiPi with KFParticle", true); + PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithKFParticle, "process HfTaskXic0ToXiPi with KFParticle", false); void processDataWithDCAFitterMl(Xic0CandsMl const& candidates, CollisionsWithEvSels const& collisions) diff --git a/PWGHF/TableProducer/candidateCreatorXic0Omegac0Qa.cxx b/PWGHF/TableProducer/candidateCreatorXic0Omegac0Qa.cxx index 8474b3f1414..78eb469c92c 100644 --- a/PWGHF/TableProducer/candidateCreatorXic0Omegac0Qa.cxx +++ b/PWGHF/TableProducer/candidateCreatorXic0Omegac0Qa.cxx @@ -84,52 +84,56 @@ struct HfCandidateCreatorXic0Omegac0Qa { // Configurables struct : ConfigurableGroup { - // Switch for filling histograms - // ----------------------------- - Configurable fillHistograms{"fillHistograms", true, "fill validation plots"}; - // Magnetic field setting from CCDB - // -------------------------------- - Configurable isRun2{"isRun2", false, "enable Run2 or Run3 GRP objects for magnetic field"}; - Configurable ccdbUrl{"ccdbUrl", "https://alice-ccdb.cern.ch", "url of the ccdb object"}; - Configurable ccdbPathLut{"ccdbPathLut", "GLO/Param/MatLUT", "Path for LUT parameterization"}; - Configurable ccdbPathGrp{"ccdbPathGrp", "GLO/GRP/GRP", "path of the group file (Run2)"}; - Configurable ccdbPathGrpMag{"ccdbPathGrpMag", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object (Run3)"}; - - // Options for V0 building + // Options for internal V0 building // ...Initial values taken from PWGLF/Utiles/strangenessBuilderModule.h // --------------------------------------------------------------------- - Configurable minCrossedRowsForV0Building{"minCrossedRowsForV0Building", 50, "minimun TPC crossed rows for daughter tracks. Used for internal V0 Building"}; - Configurable dcanegtopvForV0Building{"dcanegtopvForV0Building", .1, "DCV Neg to PV"}; - Configurable dcapostopvForV0Building{"dcapostopvForV0Building", .1, "DCV Pos To PV"}; - Configurable v0cospaForV0Building{"v0cospaForV0Building", 0.95, "V0 CosPA"}; - Configurable dcav0dauForV0Building{"dcav0dauForV0Building", 1.0, "DCA V0 Daughters"}; - Configurable v0radiusForV0Building{"v0radiusForV0Building", 0.9, "v0radius"}; - Configurable maxDaughterEtaForV0Building{"maxDaughterEtaForV0Building", 5.0, "Maximun daughter eta (in abs value)"}; + Configurable minCrossedRowsFromLF{"minCrossedRowsFromLF", 50, "minimun TPC crossed rows for daughter tracks. Used for internal V0 Building"}; + Configurable dcanegtopvFromLF{"dcanegtopvFromLF", .1, "DCV Neg to PV"}; + Configurable dcapostopvFromLF{"dcapostopvFromLF", .1, "DCV Pos To PV"}; + Configurable v0cospaFromLF{"v0cospaFromLF", 0.95, "V0 CosPA"}; + Configurable dcav0dauFromLF{"dcav0dauFromLF", 1.0, "DCA V0 Daughters"}; + Configurable v0radiusFromLF{"v0radiusFromLF", 0.9, "v0radius"}; + Configurable maxDaughterEtaFromLF{"maxDaughterEtaFromLF", 5.0, "Maximun daughter eta (in abs value)"}; // Options for internal cascade building // ...Initial values taken from PWGLF/Utiles/strangenessBuilderModule.h // -------------------------------------------------------------------- - Configurable minCrossedRowsForCascadeBuilding{"minCrossedRowsForCascadeBuilding", 50, "minimun TPC crossed rows for daughter tracks. Used for internal Cascade Building"}; - Configurable dcabachtopvForCascadeBuilding{"dcabachtopvForCascadeBuilding", .1, "DCV Bach to PV"}; - Configurable cascradiusForCascadeBuilding{"cascradiusForCascadeBuilding", .1, "DCV Bach to PV"}; - Configurable casccospaForCascadeBuilding{"casccospaForCascadeBuilding", 0.95, "Cascade CosPA"}; - Configurable dcacascdauForCascadeBuilding{"dcacascdauForCascadeBuilding", 1.0, "DCA cascade daughters"}; - Configurable lambdaMassWindowForCascadeBuilding{"lambdaMassWindowForCascadeBuilding", 0.10, "Distance from Lambda mass(does not apply to KF path)"}; - Configurable maxDaughterEtaForCascadeBuilding{"maxDaughterEtaForCascadeBuilding", 5.0, "Maximun daughter eta (in abs value)"}; + Configurable dcabachtopvFromLF{"dcabachtopvFromLF", .1, "DCV Bach to PV"}; + Configurable cascradiusFromLF{"cascradiusFromLF", .1, "DCV Bach to PV"}; + Configurable casccospaFromLF{"casccospaFromLF", 0.95, "Cascade CosPA"}; + Configurable dcacascdauFromLF{"dcacascdauFromLF", 1.0, "DCA cascade daughters"}; + Configurable lambdaMassWindowFromLF{"lambdaMassWindowFromLF", 0.10, "Distance from Lambda mass(does not apply to KF path)"}; // Options for internal cascade building - KF Building specifics // ...Initial values taken from PWGLF/Utiles/strangenessBuilderModule.h // -------------------------------------------------------------------- - Configurable kfTuneForOmega{"kfTuneForOmega", false, "if enabled, take main cascade properties from omega fit instread of Xi fit(=default)"}; - Configurable kfConstructMethod{"kfConstructMethod", 2, "2 : Daughter particle masses stay fixed in construction process"}; - Configurable kfUseV0MassConstraint{"kfUseV0MassConstraint", true, "KF : Use Lambda mass constraint"}; - Configurable kfUseCascadeMassConstraint{"kfUseCascadeMassConstraint", false, "KF : Use Cascade mass constraint - WARNING : Not adequate for inv mass analysis of Xi"}; - Configurable kfDoDCAFitterPreMinimV0{"kfDoDCAFitterPreMinimV0", true, "KF : do DCAFitter pre-optimization before KF fit to include material correction for V0"}; - Configurable kfDoDCAFitterPreMinimCasc{"kfDoDCAFitterPreMinimCasc", true, "KF : do DCAFitter pre-optimization before KF fit to include material correction for Xi"}; + Configurable kfTuneForOmegaFromLF{"kfTuneForOmegaFromLF", false, "if enabled, take main cascade properties from omega fit instread of Xi fit(=default)"}; + Configurable kfConstructMethodFromLF{"kfConstructMethodFromLF", 2, "2 : Daughter particle masses stay fixed in construction process"}; + Configurable kfUseV0MassConstraintFromLF{"kfUseV0MassConstraintFromLF", false, "KF : Use Lambda mass constraint"}; + Configurable kfUseCascadeMassConstraintFromLF{"kfUseCascadeMassConstraintFromLF", false, "KF : Use Cascade mass constraint - WARNING : Not adequate for inv mass analysis of Xi"}; + Configurable kfDoDCAFitterPreMinimV0FromLF{"kfDoDCAFitterPreMinimV0FromLF", true, "KF : do DCAFitter pre-optimization before KF fit to include material correction for V0"}; + Configurable kfDoDCAFitterPreMinimCascFromLF{"kfDoDCAFitterPreMinimCascFromLF", true, "KF : do DCAFitter pre-optimization before KF fit to include material correction for Xi"}; + } LFConfigs; + + // For cascade building using LF strangeness builder + o2::pwglf::strangenessBuilderHelper straHelper; + + // Configurables + struct : ConfigurableGroup { + // Switch for filling histograms + // ----------------------------- + Configurable fillHistograms{"fillHistograms", true, "fill validation plots"}; + // Magnetic field setting from CCDB + // -------------------------------- + Configurable isRun2{"isRun2", false, "enable Run2 or Run3 GRP objects for magnetic field"}; + Configurable ccdbUrl{"ccdbUrl", "https://alice-ccdb.cern.ch", "url of the ccdb object"}; + Configurable ccdbPathLut{"ccdbPathLut", "GLO/Param/MatLUT", "Path for LUT parameterization"}; + Configurable ccdbPathGrp{"ccdbPathGrp", "GLO/GRP/GRP", "path of the group file (Run2)"}; + Configurable ccdbPathGrpMag{"ccdbPathGrpMag", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object (Run3)"}; // Cascade pre selection // -------------------- - Configurable doCascadePreselection{"doCascadePreselection", false, "Use invariant mass and dcaXY cuts to preselect cascade candidates"}; + Configurable doCascadePreselection{"doCascadePreselection", true, "Use invariant mass and dcaXY cuts to preselect cascade candidates"}; Configurable massToleranceCascade{"massToleranceCascade", 0.01, "Invariant mass tolerance for cascades"}; Configurable dcaXYToPVCascadeMax{"dcaXYToPVCascadeMax", 3, "Max cascade DCA to PV in XY plane"}; Configurable dcaV0DaughtersMax{"dcaV0DaughtersMax", 1.0, "Max DCA of V0 daughter"}; @@ -140,22 +144,21 @@ struct HfCandidateCreatorXic0Omegac0Qa { Configurable propagateToPCA{"propagateToPCA", true, "Create tracks version propagated to PCA"}; Configurable maxR{"maxR", 200., "Reject PCA's above this radius"}; Configurable maxDZIni{"maxDZIni", 4., "Reject (if>0) PCA candidate if tracks DZ exceeds this threshold"}; + Configurable maxDXYIni{"maxDXYIni", 4., "Reject (if>0) PCA candidate if tracks DXY exceeds this threshold"}; Configurable minParamChange{"minParamChange", 1.e-3, "Stop iteration if largest change of any X is smaller than this"}; Configurable minRelChi2Change{"minRelChi2Change", 0.9, "Stop iteration if Chi2/Chi2old > this"}; - Configurable useAbsDCA{"useAbsDCA", false, "Minimise abs. distance rather than chi2"}; - Configurable useWeightedFinalPCA{"useWeightedFinalPCA", false, "Recalculate vertex position using track covariance, effective only if useAbsDCA is true"}; + Configurable maxChi2{"maxChi2", 100, "Discard vertices with Chi2/Nprongs > this(or sum {DCAi^2}/Nprongs for abs. distance minimization)"}; + Configurable useAbsDCA{"useAbsDCA", true, "Minimise abs. distance rather than chi2"}; + Configurable useWeightedFinalPCA{"useWeightedFinalPCA", true, "Recalculate vertex position using track covariance, effective only if useAbsDCA is true"}; // Options for KFParticle // ---------------------- - Configurable rejDiffCollTrack{"rejDiffCollTrack", true, "Reject tracks comming from different collisions(effective only for KFParticle w/o derived data)"}; - Configurable kfDoCascadePreselection{"kfDoCascadePreselection", false, "Use invariant mass and dcaXY cuts to preselect cascade candidates"}; - // Configurable kfConstrainTopoV0ToCasc{"kfConstrainTopoV0ToCasc", false, "KF : Use Lambda topo constraint"}; // -> Not sure if this will be used... - Configurable kfConstrainInvMassV0{"kfConstrainInvMassV0", true, "use mass constraint for cascade"}; - Configurable kfConstrainInvMassCasc{"kfConstrainInvMassCasc", true, "use mass constraint for cascade"}; - // Configurable kfConstrainTopoCascToCharmBaryon{"kfConstrainTopoCascToCharmBaryon", true, "use topo constraint for cascade"}; - Configurable kfConstrainInvMassCharmBaryon{"kfConstrainInvMassCharmBaryon", false, "constrain invariant mass of charm baryon candidate"}; - // Configurable constrainTopoCascToChramBaryon{"constrainTopoCascToChramBaryon", false, "constrain Casc to Charm Baryon"}; - // Configurable kfConstrainTopoCharmBaryon{"kfConstrainTopoCharmBaryon", false, "constrain charm baryon candidate to decay vertex"}; + // V0 cuts + Configurable lambdaMassWindow{"lambdaMassWindow", 0.0075, "Distance from LambdaMass"}; + // For KF Particle operation + Configurable kfConstructMethod{"kfConstructMethod", 2, "KF Construct method"}; + Configurable kfUseV0MassConstraint{"kfUseV0MassConstraint", false, "KF: Use lambda mass constraint"}; + Configurable kfUseCascadeMassConstraint{"kfUseCascadeMassConstraint", false, "KF: Use lambda mass constraint"}; // Options for QA histogram binning // ----------------------------- @@ -206,7 +209,6 @@ struct HfCandidateCreatorXic0Omegac0Qa { int runNumber{0}; double magneticField{0.}; - // float massCharmBaryonCand{0.}; enum CharmBaryonCandCounter { All = 0, HfFlagPass, @@ -215,31 +217,25 @@ struct HfCandidateCreatorXic0Omegac0Qa { // Table aliases using SelectedCollisions = soa::Join; + using TracksWCovIU = soa::Join; using TracksWCovDcaExtraPidPrPiKa = soa::Join; + using TracksWCovExtraPidIU = soa::Join; HistogramRegistry registry{"hists"}; OutputObj zorroSummary{"zorroSummary"}; HfEventSelection hfEvSel; - // For cascade building - o2::pwglf::strangenessBuilderHelper straHelper; + // PDG Id of daughter tracks & V0s & cascades & charm baryons - Used in KFParticle + int pdgIdOfV0DauPos, pdgIdOfV0DauNeg, pdgIdOfBach, pdgIdOfCharmBach; + int pdgIdOfAntiV0DauPos, pdgIdOfAntiV0DauNeg, pdgIdOfAntiBach, pdgIdOfAntiCharmBach; + int pdgIdOfV0, pdgIdOfCascade, pdgIdOfCharmBaryon; + + // Track PID - Used in DCAFitter + int trackPidOfCascade; - // For candidate reconstruction in different PID hypothesis - // Each decay channel assgined by following hf_cand_casc_lf_DecayType2Prong enum - // Index 0: Xic0/Omegac0 -> Xi- Pi+ Index 1: Omegac0 -> Omega- Pi+ Index 2: Omegac0 -> Omega- K+ - // Xi- -> Lambda0 pi-, Omeag- -> Lambda0 K- - // Lambda0 -> Pr+ Pi- - std::array pdgOfCharmBaryon = {+kXiC0, +kOmegaC0, +kOmegaC0}; // -> This need to be fixed...? +kXiC0, +kOmegaC0, +kOmegaC0, +kOmeagC0 - std::array pdgOfCharmBach = {+kPiPlus, +kPiPlus, +kKPlus}; - std::array pdgOfCascade = {+kXiMinus, +kOmegaMinus, +kOmegaMinus}; - std::array pdgOfBach = {+kPiMinus, +kKMinus, +kKMinus}; - std::array pdgOfV0 = {+kLambda0, +kLambda0, +kLambda0}; - std::array pdgOfV0DauPos = {+kProton, +kProton, +kProton}; - std::array pdgOfV0DauNeg = {+kPiMinus, +kPiMinus, +kPiMinus}; - - std::array trackPidOfCascade = {o2::track::PID::XiMinus, o2::track::PID::OmegaMinus, o2::track::PID::OmegaMinus}; - std::array massOfCascades = {MassXiMinus, MassOmegaMinus, MassOmegaMinus}; - std::array massOfCharmBach = {MassPiPlus, MassPiPlus, MassKPlus}; + // Mass of daughter tracks & V0s & cascades & charm baryons; + int massOfV0DauPos, massOfV0DauNeg, massOfBach, massOfCharmBach; + int massOfV0, massOfCascade, massOfCharmBaryon; // Pointer of histograms for QA std::shared_ptr hInvMassCharmBaryonToXiPi, hInvMassCharmBaryonToOmegaPi, hInvMassCharmBaryonToOmegaKa; @@ -282,6 +278,81 @@ struct HfCandidateCreatorXic0Omegac0Qa { LOGP(fatal, "More than one process fucntion for CollMonitoring was enabled. Please choose only one process function"); } + // Assign pdg & mass hypothesis for each decay channel + if (xipiEnabledDca || xipiEnabledKf) { + pdgIdOfV0DauPos = kProton; + pdgIdOfV0DauNeg = kPiMinus; + pdgIdOfBach = kPiMinus; + pdgIdOfCharmBach = kPiPlus; + + pdgIdOfAntiV0DauPos = kPiPlus; + pdgIdOfAntiV0DauNeg = kProton; + pdgIdOfAntiBach = kPiPlus; + pdgIdOfAntiCharmBach = kPiMinus; + + pdgIdOfV0 = kLambda0; + pdgIdOfCascade = kXiMinus; + pdgIdOfCharmBaryon = kXiC0; + + trackPidOfCascade = o2::track::PID::XiMinus; + massOfCharmBach = o2::constants::physics::MassPiPlus; + massOfV0 = o2::constants::physics::MassLambda; + massOfCascade = o2::constants::physics::MassXiMinus; + } else if (omegapiEnabledDca || omegapiEnabledKf) { + pdgIdOfV0DauPos = kProton; + pdgIdOfV0DauNeg = kPiMinus; + pdgIdOfBach = kKMinus; + pdgIdOfCharmBach = kPiPlus; + + pdgIdOfAntiV0DauPos = kPiPlus; + pdgIdOfAntiV0DauNeg = kProton; + pdgIdOfAntiBach = kKPlus; + pdgIdOfAntiCharmBach = kPiMinus; + + pdgIdOfV0 = kLambda0; + pdgIdOfCascade = kOmegaMinus; + pdgIdOfCharmBaryon = kOmegaC0; + + trackPidOfCascade = o2::track::PID::OmegaMinus; + massOfCharmBach = o2::constants::physics::MassPiPlus; + massOfV0 = o2::constants::physics::MassLambda; + massOfCascade = o2::constants::physics::MassOmegaMinus; + } else if (omegakaEnabledDca || omegakaEnabledKf) { + pdgIdOfV0DauPos = kProton; + pdgIdOfV0DauNeg = kPiMinus; + pdgIdOfBach = kKMinus; + pdgIdOfCharmBach = kKPlus; + + pdgIdOfAntiV0DauPos = kPiPlus; + pdgIdOfAntiV0DauNeg = kProton; + pdgIdOfAntiBach = kKPlus; + pdgIdOfAntiCharmBach = kKMinus; + + pdgIdOfV0 = kLambda0; + pdgIdOfCascade = kOmegaMinus; + pdgIdOfCharmBaryon = kOmegaC0; + + trackPidOfCascade = o2::track::PID::OmegaMinus; + massOfCharmBach = o2::constants::physics::MassKPlus; + massOfV0 = o2::constants::physics::MassLambda; + massOfCascade = o2::constants::physics::MassOmegaMinus; + } + LOGF(info, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"); + LOGF(info, "PDG ID of V0 positive daughter: %d", pdgIdOfV0DauPos); + LOGF(info, "PDG ID of V0 negative daughter: %d", pdgIdOfV0DauNeg); + LOGF(info, "PDG ID of Bachelor: %d", pdgIdOfBach); + LOGF(info, "PDG ID of Charm Bachelor: %d", pdgIdOfCharmBach); + LOGF(info, "----------"); + LOGF(info, "PDG ID of anti V0 positive daughter: %d", pdgIdOfAntiV0DauPos); + LOGF(info, "PDG ID of anti V0 negative daughter: %d", pdgIdOfAntiV0DauNeg); + LOGF(info, "PDG ID of anti Bachelor: %d", pdgIdOfAntiBach); + LOGF(info, "PDG ID of anti Charm Bachelor: %d", pdgIdOfAntiCharmBach); + LOGF(info, "----------"); + LOGF(info, "PDG ID of V0: %d", pdgIdOfV0); + LOGF(info, "PDG ID of Cascade: %d", pdgIdOfCascade); + LOGF(info, "PDG ID of Charm Baryon: %d", pdgIdOfCharmBaryon); + LOGF(info, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"); + // Add histogram to indicate which sv method was used registry.add("hVertexerType", "Use KF or DCAFitterN;Vertexer type;entries", {kTH1F, {{2, 0.0, 2.0}}}); registry.get(HIST("hVertexerType"))->GetXaxis()->SetBinLabel(1 + aod::hf_cand::VertexerType::DCAFitter, "DCAFitter"); @@ -300,22 +371,22 @@ struct HfCandidateCreatorXic0Omegac0Qa { // -------------------------------------------- // Settings for internal V0 building - straHelper.v0selections.minCrossedRows = configs.minCrossedRowsForV0Building; - straHelper.v0selections.dcanegtopv = configs.dcanegtopvForV0Building; - straHelper.v0selections.dcapostopv = configs.dcapostopvForV0Building; - straHelper.v0selections.v0cospa = configs.v0cospaForV0Building; - straHelper.v0selections.dcav0dau = configs.dcav0dauForV0Building; - straHelper.v0selections.v0radius = configs.v0radiusForV0Building; - straHelper.v0selections.maxDaughterEta = configs.maxDaughterEtaForV0Building; + straHelper.v0selections.minCrossedRows = LFConfigs.minCrossedRowsFromLF; + straHelper.v0selections.dcanegtopv = LFConfigs.dcanegtopvFromLF; + straHelper.v0selections.dcapostopv = LFConfigs.dcapostopvFromLF; + straHelper.v0selections.v0cospa = LFConfigs.v0cospaFromLF; + straHelper.v0selections.dcav0dau = LFConfigs.dcav0dauFromLF; + straHelper.v0selections.v0radius = LFConfigs.v0radiusFromLF; + straHelper.v0selections.maxDaughterEta = LFConfigs.maxDaughterEtaFromLF; // Settings for internal Cascade building - straHelper.cascadeselections.minCrossedRows = configs.minCrossedRowsForCascadeBuilding; - straHelper.cascadeselections.dcabachtopv = configs.dcabachtopvForCascadeBuilding; - straHelper.cascadeselections.cascradius = configs.cascradiusForCascadeBuilding; - straHelper.cascadeselections.casccospa = configs.casccospaForCascadeBuilding; - straHelper.cascadeselections.dcacascdau = configs.dcacascdauForCascadeBuilding; - straHelper.cascadeselections.lambdaMassWindow = configs.lambdaMassWindowForCascadeBuilding; - straHelper.cascadeselections.maxDaughterEta = configs.maxDaughterEtaForCascadeBuilding; + straHelper.cascadeselections.minCrossedRows = LFConfigs.minCrossedRowsFromLF; + straHelper.cascadeselections.dcabachtopv = LFConfigs.dcabachtopvFromLF; + straHelper.cascadeselections.cascradius = LFConfigs.cascradiusFromLF; + straHelper.cascadeselections.casccospa = LFConfigs.casccospaFromLF; + straHelper.cascadeselections.dcacascdau = LFConfigs.dcacascdauFromLF; + straHelper.cascadeselections.lambdaMassWindow = LFConfigs.lambdaMassWindowFromLF; + straHelper.cascadeselections.maxDaughterEta = LFConfigs.maxDaughterEtaFromLF; // Fitter setting straHelper.fitter.setPropagateToPCA(configs.propagateToPCA); @@ -332,7 +403,10 @@ struct HfCandidateCreatorXic0Omegac0Qa { df.setPropagateToPCA(configs.propagateToPCA); df.setMaxR(configs.maxR); df.setMaxDZIni(configs.maxDZIni); + df.setMaxDXYIni(configs.maxDXYIni); df.setMinParamChange(configs.minParamChange); + df.setMinRelChi2Change(configs.minRelChi2Change); + df.setMaxChi2(configs.maxChi2); df.setUseAbsDCA(configs.useAbsDCA); df.setWeightedFinalPCA(configs.useWeightedFinalPCA); } @@ -405,7 +479,8 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::HfCascLf2Prongs const& candidates, aod::Cascades const&, // -> Internal cascade building aod::V0s const&, // -> Internal v0 building - TracksWCovDcaExtraPidPrPiKa const&, + aod::TracksWCovDca const& tracks, + TracksWCovIU const& lfTracks, aod::BCsWithTimestamps const&, Hist& hInvMassCharmBaryon, Hist& hCandCounter) @@ -451,9 +526,9 @@ struct HfCandidateCreatorXic0Omegac0Qa { //------------------Intenal Cascade building------------------ auto cascAodElement = cand.cascade_as(); auto v0AodElement = cascAodElement.v0_as(); - auto posTrack = v0AodElement.posTrack_as(); - auto negTrack = v0AodElement.negTrack_as(); - auto bachTrack = cascAodElement.bachelor_as(); + auto posTrack = lfTracks.rawIteratorAt(v0AodElement.posTrackId()); + auto negTrack = lfTracks.rawIteratorAt(v0AodElement.negTrackId()); + auto bachTrack = lfTracks.rawIteratorAt(cascAodElement.bachelorId()); // Make cascade starting from V0 // If success, fill Cascade and V0 information for reconstruction @@ -465,59 +540,46 @@ struct HfCandidateCreatorXic0Omegac0Qa { false, // calculateBachelorBaryonVariable false, // useCascadeMomentumAtPV true)) { - LOG(info) << "!This cascade cannot be rebuilt(cascade ID : " << cand.cascadeId() << "/ collision ID : " << collision.globalIndex(); + // LOG(info) << "!This cascade cannot be rebuilt(cascade ID : " << cand.cascadeId() << "/ collision ID : " << collision.globalIndex(); continue; } else { float storeMass = (decayChannel == 0) ? straHelper.cascade.massXi : straHelper.cascade.massOmega; float storePt = RecoDecay::pt(straHelper.cascade.cascadeMomentum); registry.fill(HIST("hCascMass"), storeMass); registry.fill(HIST("hCascPt"), storePt); - } - - //------------------Cascade pre selection------------------ - float massCasc = (decayChannel == 0) ? straHelper.cascade.massXi : straHelper.cascade.massOmega; - - // Perform cascade pre selection - if (configs.doCascadePreselection) { - - // pre selection of dcaXY - // FIXME does cascadeDCAxy represents dcaXYtoPV? - if (std::abs(straHelper.cascade.cascadeDCAxy) > configs.dcaXYToPVCascadeMax) { - continue; - } - - // pre selection on invariant mass - if (std::abs(massCasc - massOfCascades[decayChannel]) > configs.massToleranceCascade) { - continue; + if (configs.fillHistograms) { + hCandCounter->Fill(CascReconstructed); } } - if (configs.fillHistograms) { - hCandCounter->Fill(CascReconstructed); - } - //------------------------------Info of V0 and cascade------------------------------ - // -> This quantities are used for physical properties of selected candidates - // -> Not used for candidate creation + // V0 quantities from LF strangeness builder std::array vertexV0 = {straHelper.cascade.v0Position[0], straHelper.cascade.v0Position[1], straHelper.cascade.v0Position[2]}; std::array pVecV0 = {straHelper.cascade.v0Momentum[0], straHelper.cascade.v0Momentum[1], straHelper.cascade.v0Momentum[2]}; std::array pVecV0DauPos = {straHelper.cascade.positiveMomentum[0], straHelper.cascade.positiveMomentum[1], straHelper.cascade.positiveMomentum[2]}; std::array pVecV0DauNeg = {straHelper.cascade.negativeMomentum[0], straHelper.cascade.negativeMomentum[1], straHelper.cascade.negativeMomentum[2]}; - int chargeCasc = straHelper.cascade.charge > 0 ? 1 : -1; - std::array vertexCasc = {straHelper.cascade.cascadePosition[0], straHelper.cascade.cascadePosition[1], straHelper.cascade.cascadePosition[2]}; - std::array pVecCasc = {straHelper.cascade.cascadeMomentum[0], straHelper.cascade.cascadeMomentum[1], straHelper.cascade.cascadeMomentum[2]}; - std::array covCasc = {0.}; - - //------------------------------Create cascade track------------------------------ + // pseudo rapidity - V0 daughters + // float pseudorapV0Dau0 = RecoDecay::eta(pVecV0DauPos); + // float pseudorapV0Dau1 = RecoDecay::eta(pVecV0DauNeg); - constexpr std::size_t NElementsCovMatrix{6u}; - constexpr std::array MomInd = {9, 13, 14, 18, 19, 20}; // Momentum index? - for (auto i = 0u; i < NElementsCovMatrix; i++) { - covCasc[i] = straHelper.cascade.covariance[i]; + // Cascade quantities from LF strangeness builder + int chargeCasc = straHelper.cascade.charge; + std::array vertexCasc(straHelper.cascade.cascadePosition); + std::array const pVecCasc(straHelper.cascade.cascadeMomentum); + std::array covCasc = {0.}; + constexpr int NumCovElement = 6; + constexpr int MomInd[NumCovElement] = {9, 13, 14, 18, 19, 20}; + for (int i = 0; i < NumCovElement; i++) { covCasc[MomInd[i]] = straHelper.cascade.covariance[MomInd[i]]; + covCasc[i] = straHelper.cascade.covariance[i]; } + // pseudo rapidity - cascade bachelor + // float pseudorapCascBachelor = RecoDecay::eta(straHelper.cascade.bachelorMomentum); + + //------------------------------Create cascade track------------------------------ + o2::track::TrackParCov trackCasc; if (chargeCasc < 0) { // Xi- or Omega- trackCasc = o2::track::TrackParCov(vertexCasc, pVecCasc, covCasc, -1, true); @@ -528,25 +590,19 @@ struct HfCandidateCreatorXic0Omegac0Qa { } trackCasc.setAbsCharge(1); - trackCasc.setPID(trackPidOfCascade[decayChannel]); + trackCasc.setPID(trackPidOfCascade); //------------------------------Fit SV & Create Charm Baryon track------------------------------ // Perform secondary vertex fitting - auto trackCharmBachelor = cand.prong0_as(); + auto trackCharmBachelor = tracks.rawIteratorAt(cand.prong0Id()); auto trackParCovCharmBachelor = getTrackParCov(trackCharmBachelor); try { if (df.process(trackCasc, trackParCovCharmBachelor) == 0) { continue; } - } catch (const std::runtime_error& e) { - LOG(info) << "Run time error found : " << e.what() << ".DCAFitter cannot work with this candidate. SKIP!"; - continue; - } - - // Propagate tracks to vertex - df.propagateTracksToVertex(); - if (!df.isPropagateTracksToVertexDone()) { + } catch (std::runtime_error& e) { + LOG(error) << "Execption caught in charm DCA Fitter process call: " << e.what(); continue; } @@ -571,7 +627,6 @@ struct HfCandidateCreatorXic0Omegac0Qa { // get SV Properties auto const& secondaryVertex = df.getPCACandidate(); - auto chi2SV = df.getChi2AtPCACandidate(); auto covMatrixSV = df.calcPCACovMatrixFlat(); // DCAxy and DCAz. Computed with propagatToDCABxByBz method @@ -595,13 +650,25 @@ struct HfCandidateCreatorXic0Omegac0Qa { o2::dataformats::DCA impactParameterCasc, impactParameterCharmBach; o2::base::Propagator::Instance()->propagateToDCABxByBz(primaryVertex, trackCasc, 2.f, matCorr, &impactParameterCasc); // trackCasc is TrackParCov object o2::base::Propagator::Instance()->propagateToDCABxByBz(primaryVertex, trackParCovCharmBachelor, 2.f, matCorr, &impactParameterCharmBach); + // float impactParCharmBachFromCharmBayonXY = impactParameterCharmBach.getY(); + // float impactParCharmBachFromCharmBayonZ = impactParameterCharmBach.getZ(); + + // get v0 invariant mass - from LF Table + float mLambda = straHelper.v0.massLambda; // from LF Table - // get v0 invariant mass - float massLambda = straHelper.v0.massLambda; + // get Casc mass - from LF Table + float mCasc = 0.; + if constexpr (decayChannel == hf_cand_casc_lf::DecayType2Prong::XiczeroOmegaczeroToXiPi) { + mCasc = straHelper.cascade.massXi; + } else if constexpr (decayChannel == hf_cand_casc_lf::DecayType2Prong::OmegaczeroToOmegaPi) { + mCasc = straHelper.cascade.massOmega; + } else if constexpr (decayChannel == hf_cand_casc_lf::DecayType2Prong::OmegaczeroToOmegaK) { + mCasc = straHelper.cascade.massOmega; + } - // Get Charm baryon invarian mass + // get Charm baryon invariant mass auto arrMomenta = std::array{pVecCascAsD, pVecCharmBachAsD}; - float massCharmBaryonCand = RecoDecay::m(arrMomenta, std::array{massOfCascades[decayChannel], massOfCharmBach[decayChannel]}); + float massCharmBaryonCand = RecoDecay::m(arrMomenta, std::array{massOfCascade, massOfCharmBach}); if (configs.fillHistograms) { hInvMassCharmBaryon->Fill(massCharmBaryonCand); } @@ -619,7 +686,6 @@ struct HfCandidateCreatorXic0Omegac0Qa { float decLenV0 = RecoDecay::distance(vertexCasc, vertexV0); float decLenCasc = RecoDecay::distance(vtxCoordCharmBaryon, vertexCasc); float decLenCharmBaryon = RecoDecay::distance(pvCoord, vtxCoordCharmBaryon); - // get uncertainty of the decay length -> Used in previous code... float phi, theta; getPointDirection(std::array{primaryVertex.getX(), primaryVertex.getY(), primaryVertex.getZ()}, secondaryVertex, phi, theta); auto errorDecayLength = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, theta) + getRotatedCovMatrixXX(covMatrixSV, phi, theta)); @@ -627,7 +693,7 @@ struct HfCandidateCreatorXic0Omegac0Qa { // calcuate ctau float ctV0 = RecoDecay::ct(pVecV0, decLenV0, MassLambda0); - float ctCasc = RecoDecay::ct(pVecCasc, decLenCasc, massOfCascades[decayChannel]); + float ctCasc = RecoDecay::ct(pVecCasc, decLenCasc, massOfCascade); float ctOmegac0 = RecoDecay::ct(pVecCharmBaryon, decLenCharmBaryon, MassOmegaC0); float ctXic0 = RecoDecay::ct(pVecCharmBaryon, decLenCharmBaryon, MassXiC0); @@ -668,7 +734,7 @@ struct HfCandidateCreatorXic0Omegac0Qa { std::sqrt(impactParameterCasc.getSigmaY2()), std::sqrt(impactParameterCharmBach.getSigmaY2()), cascAodElement.v0Id(), v0AodElement.posTrackId(), v0AodElement.negTrackId(), cand.cascadeId(), trackCharmBachelor.globalIndex(), cand.prong0Id(), - massLambda, massCasc, massCharmBaryonCand, + mLambda, mCasc, massCharmBaryonCand, cpaV0, cpaCharmBaryon, cpaCasc, cpaxyV0, cpaxyCharmBaryon, cpaxyCasc, ctOmegac0, ctCasc, ctV0, ctXic0, @@ -697,7 +763,7 @@ struct HfCandidateCreatorXic0Omegac0Qa { std::sqrt(impactParameterCasc.getSigmaY2()), std::sqrt(impactParameterCharmBach.getSigmaY2()), cascAodElement.v0Id(), v0AodElement.posTrackId(), v0AodElement.negTrackId(), cand.cascadeId(), trackCharmBachelor.globalIndex(), cand.prong0Id(), - massLambda, massCasc, massCharmBaryonCand, + mLambda, mCasc, massCharmBaryonCand, cpaV0, cpaCharmBaryon, cpaCasc, cpaxyV0, cpaxyCharmBaryon, cpaxyCasc, ctOmegac0, ctCasc, ctV0, @@ -726,7 +792,7 @@ struct HfCandidateCreatorXic0Omegac0Qa { std::sqrt(impactParameterCasc.getSigmaY2()), std::sqrt(impactParameterCharmBach.getSigmaY2()), cascAodElement.v0Id(), v0AodElement.posTrackId(), v0AodElement.negTrackId(), cand.cascadeId(), trackCharmBachelor.globalIndex(), cand.prong0Id(), - massLambda, massCasc, massCharmBaryonCand, + mLambda, mCasc, massCharmBaryonCand, cpaV0, cpaCharmBaryon, cpaCasc, cpaxyV0, cpaxyCharmBaryon, cpaxyCasc, ctOmegac0, ctCasc, ctV0, @@ -749,7 +815,8 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::HfCascLf2Prongs const& candidates, aod::Cascades const&, // -> Implemented for internal cascade building aod::V0s const&, // -> Implemented for internal cascade building - TracksWCovDcaExtraPidPrPiKa const&, + TracksWCovDcaExtraPidPrPiKa const& tracks, + TracksWCovExtraPidIU const& lfTracks, aod::BCsWithTimestamps const&, Hist& hInvMassCharmBaryon, Hist& hCandCounter) @@ -794,9 +861,9 @@ struct HfCandidateCreatorXic0Omegac0Qa { //------------------Intenal Cascade building------------------ auto cascAodElement = cand.cascade_as(); auto v0AodElement = cascAodElement.v0_as(); - auto posTrack = v0AodElement.posTrack_as(); - auto negTrack = v0AodElement.negTrack_as(); - auto bachTrack = cascAodElement.bachelor_as(); + auto posTrack = lfTracks.rawIteratorAt(v0AodElement.posTrackId()); + auto negTrack = lfTracks.rawIteratorAt(v0AodElement.negTrackId()); + auto bachTrack = lfTracks.rawIteratorAt(cascAodElement.bachelorId()); // Make cascade starting from V0 // If success, fill Cascade and V0 information for reconstruction @@ -806,12 +873,12 @@ struct HfCandidateCreatorXic0Omegac0Qa { negTrack, bachTrack, false, // calculateBachelorBaryonVariables - configs.kfConstructMethod, - configs.kfTuneForOmega, - configs.kfUseV0MassConstraint, - configs.kfUseCascadeMassConstraint, - configs.kfDoDCAFitterPreMinimV0, - configs.kfDoDCAFitterPreMinimCasc)) { + LFConfigs.kfConstructMethodFromLF, + LFConfigs.kfTuneForOmegaFromLF, + LFConfigs.kfUseV0MassConstraintFromLF, + LFConfigs.kfUseCascadeMassConstraintFromLF, + LFConfigs.kfDoDCAFitterPreMinimV0FromLF, + LFConfigs.kfDoDCAFitterPreMinimCascFromLF)) { LOG(info) << "This cascade cannot be rebuilt"; continue; } else { @@ -819,194 +886,221 @@ struct HfCandidateCreatorXic0Omegac0Qa { float storePt = RecoDecay::pt(straHelper.cascade.cascadeMomentum); registry.fill(HIST("hCascMass"), storeMass); registry.fill(HIST("hCascPt"), storePt); + if (configs.fillHistograms) { + hCandCounter->Fill(CascReconstructed); + } } //------------------------------Cascade pre-selection------------------------------ - float massCasc = (decayChannel == 0) ? straHelper.cascade.massXi : straHelper.cascade.massOmega; - - if (configs.kfDoCascadePreselection) { - - // pre selection of dcaXY - // FIXME does cascadeDCAxy represents dcaxytoPV? - if (std::abs(straHelper.cascade.cascadeDCAxy) > configs.dcaXYToPVCascadeMax) { - continue; - } - // pre selection on dcaV0Daughters - if (std::abs(straHelper.cascade.v0DaughterDCA) > configs.dcaV0DaughtersMax) { - continue; - } - // pre selection on dcaCascDaughters - if (std::abs(straHelper.cascade.cascadeDaughterDCA) > configs.dcaCascDaughtersMax) { - continue; - } - // pre selection on invariantmass - if (std::abs(massCasc - massOfCascades[decayChannel]) > configs.massToleranceCascade) { - continue; + // ! only for Xic0, Omegac0 -> Omega K + if constexpr (decayChannel == hf_cand_casc_lf::DecayType2Prong::OmegaczeroToOmegaK) { + if (configs.doCascadePreselection) { + if (std::abs(straHelper.cascade.cascadeDCAxy) > configs.dcaXYToPVCascadeMax) { + continue; + } + // pre selection on dcaV0Daughters + if (std::abs(straHelper.cascade.v0DaughterDCA) > configs.dcaV0DaughtersMax) { + continue; + } + // pre selection on dcaCascDaughters + if (std::abs(straHelper.cascade.cascadeDaughterDCA) > configs.dcaCascDaughtersMax) { + continue; + } + // pre selection on invariantmass + if (std::abs(straHelper.cascade.massOmega - massOfCascade) > configs.massToleranceCascade) { + continue; + } } } - if (configs.fillHistograms) { - hCandCounter->Fill(CascReconstructed); - } - - //------------------------------Info of V0 and Cascade------------------------------ - // -> This quantities are used for physical properties of selected candidates - // -> Not used for candidate creation - // auto chargeCasc = casc.sign() > 0 ? 1 : -1; - // std::array vertexV0 = {casc.xlambda(), casc.ylambda(), casc.zlambda()}; - // std::array pVecV0 = {casc.pxlambda(), casc.pylambda(), casc.pzlambda()}; - // std::array vertexCasc = {casc.x(), casc.y(), casc.z()}; - // std::array pVecCasc = {casc.px(), casc.py(), casc.pz()}; + //----------Create charm bayron as KF Partible object starting from V0---------- - std::array vertexV0 = {straHelper.cascade.v0Position[0], straHelper.cascade.v0Position[1], straHelper.cascade.v0Position[2]}; - std::array pVecV0 = {straHelper.cascade.v0Momentum[0], straHelper.cascade.v0Momentum[1], straHelper.cascade.v0Momentum[2]}; - std::array pVecV0DauPos = {straHelper.cascade.positiveMomentum[0], straHelper.cascade.positiveMomentum[1], straHelper.cascade.positiveMomentum[2]}; - std::array pVecV0DauNeg = {straHelper.cascade.negativeMomentum[0], straHelper.cascade.negativeMomentum[1], straHelper.cascade.negativeMomentum[2]}; + // Create KFParticle object of V0 Daughter & Bachelor + const KFPTrack kfTrack0 = createKFPTrackFromTrack(posTrack); + const KFPTrack kfTrack1 = createKFPTrackFromTrack(negTrack); + const KFPTrack kfTrackBach = createKFPTrackFromTrack(bachTrack); - int chargeCasc = straHelper.cascade.charge > 0 ? 1 : -1; - std::array vertexCasc = {straHelper.cascade.cascadePosition[0], straHelper.cascade.cascadePosition[1], straHelper.cascade.cascadePosition[2]}; - std::array pVecCasc = {straHelper.cascade.cascadeMomentum[0], straHelper.cascade.cascadeMomentum[1], straHelper.cascade.cascadeMomentum[2]}; - std::array covCasc = {0.}; + bool isAnti = (bachTrack.signed1Pt() > 0 ? true : false); - //------------------------------Create Charm Baryon as KF Particle object------------------------------ - - // initialize primary vertex - KFPVertex kfpVertex = createKFPVertexFromCollision(collision); - float covMatrixPV[6]; - kfpVertex.GetCovarianceMatrix(covMatrixPV); - KFParticle kfPv(kfpVertex); // -> For calculation of DCAs to PV - - //~~~~~create charm bachelor track into KFParticle object~~~~~// - auto trackCharmBachelor = cand.prong0_as(); - KFPTrack kfpTrackCharmBachelor = createKFPTrackFromTrack(trackCharmBachelor); - KFParticle kfCharmBachelor(kfpTrackCharmBachelor, pdgOfCharmBach[decayChannel]); - - //~~~~~create Cascade as KFParticle object~~~~~// - // -> This process is essential in building Charm baryon via KFParticle package. - // Since we don't have any information given from other tables about Charm baryon, - // only way to construct Charm baryon is to construct Charm baryon from it's daughters. - constexpr std::size_t NElementsStateVectorCasc{6}; - std::array xyzpxpypzCasc = {vertexCasc[0], vertexCasc[1], vertexCasc[2], pVecCasc[0], pVecCasc[1], pVecCasc[2]}; - float parPosMomCasc[NElementsStateVectorCasc]; - std::copy(xyzpxpypzCasc.begin(), xyzpxpypzCasc.end(), parPosMomCasc); - - KFParticle kfCasc; - // kfCasc.Create(parPosMomCasc, casc.kfTrackCovMat(), casc.sign(), massCasc); - kfCasc.Create(parPosMomCasc, straHelper.cascade.covariance, straHelper.cascade.charge, massCasc); - if (configs.kfConstrainInvMassCasc) { - kfCasc.SetNonlinearMassConstraint(massOfCascades[decayChannel]); - } + KFParticle kfPos(kfTrack0, (isAnti ? pdgIdOfAntiV0DauPos : pdgIdOfV0DauPos)); + KFParticle kfNeg(kfTrack1, (isAnti ? pdgIdOfAntiV0DauNeg : pdgIdOfV0DauNeg)); + KFParticle kfBach(kfTrackBach, (isAnti ? pdgIdOfAntiBach : pdgIdOfBach)); + KFParticle kfBachRej(kfTrackBach, (isAnti ? pdgIdOfAntiBach : pdgIdOfBach)); // Rej -> Used for Omegac0->OmegaPi only - //~~~~~~Create Charm Baryon as KFParticle object~~~~~// - KFParticle kfCharmBaryon; - const KFParticle* kfDaughterCharmBaryon[2] = {&kfCharmBachelor, &kfCasc}; - kfCharmBaryon.SetConstructMethod(configs.kfConstructMethod); + // ~~~~~~~Construct V0 with KF~~~~~~~ + const KFParticle* v0Daughters[2] = {&kfPos, &kfNeg}; + KFParticle kfV0; + kfV0.SetConstructMethod(configs.kfConstructMethod); try { - kfCharmBaryon.Construct(kfDaughterCharmBaryon, 2); + kfV0.Construct(v0Daughters, 2); } catch (std::runtime_error& e) { - LOG(debug) << "Failed to construct Charm Baryon : " << e.what(); + LOG(debug) << "Failed to construct v0" << e.what(); continue; } - // Get covariance matrix of Charm Baryon - auto covMatrixCharmBaryon = kfCharmBaryon.CovarianceMatrix(); - - // transport Charm Baryon daughters to Charm Baryon to decay vertex - // FIXME Is this process necessary? - float secondaryVertex[3] = {kfCharmBaryon.GetX(), kfCharmBaryon.GetY(), kfCharmBaryon.GetZ()}; - kfCasc.TransportToPoint(secondaryVertex); - kfCharmBachelor.TransportToPoint(secondaryVertex); - - // Fill histogram - if (configs.fillHistograms) { - hCandCounter->Fill(VertexFit); - hInvMassCharmBaryon->Fill(kfCharmBaryon.GetMass()); + // Require lambda pre-selection before mass constraint + float massLam, sigMassLam; + kfV0.GetMass(massLam, sigMassLam); + if (std::abs(massLam - MassLambda0) > configs.lambdaMassWindow) { + continue; + } + if (sigMassLam <= 0) { + continue; + } + if ((kfV0.GetNDF() <= 0) || (kfV0.GetChi2() <= 0)) { + continue; } - // Transport cascade and charm baryon to decay vertex(just to be sure) - kfCharmBaryon.TransportToDecayVertex(); - kfCasc.TransportToDecayVertex(); - - //!~~~~~Extra calculations for QA~~~~~~!// - /// These quantities were calculated to fill in existing output tables & QA purpose - /// In the future, these calculation can be skipped? This must be dicussed. - - /// Extra calculation for V0 daughters - KFPTrack kfpTrackV0Pos = createKFPTrackFromTrack(posTrack); - KFPTrack kfpTrackV0Neg = createKFPTrackFromTrack(negTrack); - - int pdgV0Pos = (trackCharmBachelor.sign() > 0) ? kProton : kPiPlus; - int pdgV0Neg = (trackCharmBachelor.sign() > 0) ? kPiMinus : -kProton; - - KFParticle kfV0Pos(kfpTrackV0Pos, pdgV0Pos); - KFParticle kfV0Neg(kfpTrackV0Neg, pdgV0Neg); + // Set mass constraint to lambda + KFParticle kfV0MassConstrained = kfV0; + kfV0MassConstrained.SetNonlinearMassConstraint(massOfV0); + if (configs.kfUseV0MassConstraint) { + kfV0 = kfV0MassConstrained; + } + kfV0.TransportToDecayVertex(); - auto trackParCovV0Pos = getTrackParCovFromKFP(kfV0Pos, kfV0Pos.GetPDG(), 1); - auto trackParCovV0Neg = getTrackParCovFromKFP(kfV0Neg, kfV0Neg.GetPDG(), -1); + //~~~~~~~Construct cascade with KF~~~~~~~ + const KFParticle* cascDaughters[2] = {&kfBach, &kfV0}; + const KFParticle* cascDaughtersRej[2] = {&kfBachRej, &kfV0}; + KFParticle kfCasc, kfCascRej; - /// Extra calculations for V0 - KFParticle kfV0; - float xyzpxpypzV0[6] = {vertexV0[0], vertexV0[1], vertexV0[2], pVecV0[0], pVecV0[1], pVecV0[2]}; - kfV0.Create(xyzpxpypzV0, straHelper.cascade.kfTrackCovarianceV0, 0, MassLambda0); - if (configs.kfConstrainInvMassV0) { - kfV0.SetNonlinearMassConstraint(MassLambda); + kfCasc.SetConstructMethod(configs.kfConstructMethod); + try { + kfCasc.Construct(cascDaughters, 2); + } catch (std::runtime_error& e) { + LOG(debug) << "Failed to construct Cascade: " << e.what(); } - float kfMassV0, kfSigMassV0; - kfV0.GetMass(kfMassV0, kfSigMassV0); + float massCasc, sigMassCasc, massCascRej, sigMassCascRej; + kfCasc.GetMass(massCasc, sigMassCasc); - KFParticle kfV0ConstrainedToPv = kfV0; - KFParticle kfV0ConstrainedToCasc = kfV0; - kfV0ConstrainedToPv.SetProductionVertex(kfPv); - kfV0ConstrainedToCasc.SetProductionVertex(kfCasc); - - /// Extra calculations for bachelor - KFPTrack kfpTrackBach = createKFPTrackFromTrack(bachTrack); - KFParticle kfBach(kfpTrackBach, pdgOfBach[decayChannel]); + if (sigMassCasc <= 0) { + continue; + } + if (std::abs(massCasc - massCasc) > configs.massToleranceCascade) { + continue; + } + if (kfCasc.GetNDF() <= 0 || kfCasc.GetChi2() <= 0) { + continue; + } - KFParticle kfBachConstrainedToPv = kfBach; - KFParticle kfBachConstrainedToCasc = kfBach; - kfBachConstrainedToPv.SetProductionVertex(kfPv); - kfBachConstrainedToCasc.SetProductionVertex(kfCasc); + // perform cascade building on casc_rej - only for Omega + if constexpr (decayChannel != hf_cand_casc_lf::DecayType2Prong::XiczeroOmegaczeroToXiPi) { + kfCascRej.SetConstructMethod(configs.kfConstructMethod); + try { + kfCascRej.Construct(cascDaughtersRej, 2); + } catch (std::runtime_error& e) { + LOG(debug) << "Failed to construct Cascade_rej: " << e.what(); + } - auto trackParCovBach = getTrackParCovFromKFP(kfBachConstrainedToCasc, kfBachConstrainedToCasc.GetPDG(), bachTrack.sign()); + kfCascRej.GetMass(massCascRej, sigMassCascRej); + } - /// Extra calculations for casc - float kfMassCasc, kfSigMassCasc; - kfCasc.GetMass(kfMassCasc, kfSigMassCasc); + // Set mass constraint to cascade + KFParticle kfCascMassConstrained = kfCasc; + kfCascMassConstrained.SetNonlinearMassConstraint(massOfCascade); + if (configs.kfUseCascadeMassConstraint) { + kfCasc = kfCascMassConstrained; + } + kfCasc.TransportToDecayVertex(); - KFParticle kfCascConstrainedToPv = kfCasc; - KFParticle kfCascConstrainedToCharmBaryon = kfCasc; - kfCascConstrainedToPv.SetProductionVertex(kfPv); - kfCascConstrainedToCharmBaryon.SetProductionVertex(kfCharmBaryon); + //~~~~~~~Construct Charm Baryon with KF~~~~~~~ + auto trackCharmBachelor = tracks.rawIteratorAt(cand.prong0Id()); + const KFPTrack kfTrackCharmBach = createKFPTrackFromTrack(trackCharmBachelor); + const KFParticle kfCharmBach(kfTrackCharmBach, (isAnti ? pdgIdOfAntiCharmBach : pdgIdOfCharmBach)); + const KFParticle* charmBaryonDaughters[2] = {&kfCharmBach, &kfCasc}; - /// Extra calculation for charm bachelor - KFParticle kfCharmBachelorConstrainedToPv = kfCharmBachelor; - KFParticle kfCharmBachelorConstrainedToCharmBaryon = kfCharmBachelor; - kfCharmBachelorConstrainedToPv.SetProductionVertex(kfPv); - kfCharmBachelorConstrainedToCharmBaryon.SetProductionVertex(kfCharmBaryon); + KFParticle kfCharmBaryon; + kfCharmBaryon.SetConstructMethod(configs.kfConstructMethod); + try { + kfCharmBaryon.Construct(charmBaryonDaughters, 2); + } catch (std::runtime_error& e) { + LOG(debug) << "Failed to construct Charm baryon: " << e.what(); + } - /// Extra calculation for charm baryon - float kfMassCharmBaryon, kfSigMassCharmBaryon; - kfCharmBaryon.GetMass(kfMassCharmBaryon, kfSigMassCharmBaryon); + float massCharmBaryon, sigMassCharmBaryon; + kfCharmBaryon.GetMass(massCharmBaryon, sigMassCharmBaryon); + if (sigMassCharmBaryon <= 0) { + continue; + } + if (kfCharmBaryon.GetNDF() <= 0 || kfCharmBaryon.GetChi2() <= 0) { + continue; + } + kfCharmBaryon.TransportToDecayVertex(); + if (configs.fillHistograms) { + hCandCounter->Fill(VertexFit); + hInvMassCharmBaryon->Fill(massCharmBaryon); + } - KFParticle kfCharmBaryonConstrainedToPv = kfCharmBaryon; - kfCharmBaryonConstrainedToPv.SetProductionVertex(kfPv); + // Set production vertex + // PV + const KFPVertex kfVertex = createKFPVertexFromCollision(collision); + const KFParticle kfPv(kfVertex); + const KFParticle kfPosOrigin = kfPos; + const KFParticle kfNegOrigin = kfNeg; + + // To V0 + kfPos.SetProductionVertex(kfV0); + kfNeg.SetProductionVertex(kfV0); + + // To Casc + KFParticle kfBachToCasc = kfBach; + KFParticle kfV0ToCasc = kfV0; + kfBach.SetProductionVertex(kfCasc); + kfV0ToCasc.SetProductionVertex(kfCasc); + + // To Charm baryon + KFParticle kfCascToCharmBaryon = kfCasc; + KFParticle kfCharmBachToCharmBaryon = kfCharmBach; + kfCascToCharmBaryon.SetProductionVertex(kfCharmBaryon); + kfCharmBachToCharmBaryon.SetProductionVertex(kfCharmBaryon); + + // To Pv + KFParticle kfV0ToPv = kfV0; + KFParticle kfCascToPv = kfCasc; + KFParticle kfCharmBachToPv = kfCharmBach; + KFParticle kfCharmBaryonToPv = kfCharmBaryon; + kfV0ToPv.SetProductionVertex(kfPv); + kfCascToPv.SetProductionVertex(kfPv); + kfCharmBachToPv.SetProductionVertex(kfPv); + kfCharmBaryonToPv.SetProductionVertex(kfPv); + + //----------Reconstruct information after vertex fit---------- + std::array vertexV0 = {kfV0.GetX(), kfV0.GetY(), kfV0.GetZ()}; + std::array vertexCasc = {kfCasc.GetX(), kfCasc.GetY(), kfCasc.GetZ()}; + + std::array pVecV0DauPos = {kfPos.GetPx(), kfPos.GetPy(), kfPos.GetPz()}; + std::array pVecV0DauNeg = {kfNeg.GetPx(), kfNeg.GetPy(), kfNeg.GetPz()}; + std::array pVecV0 = {kfV0.GetPx(), kfV0.GetPy(), kfV0.GetPz()}; + std::array pVecBach = {kfBachToCasc.GetPx(), kfBachToCasc.GetPy(), kfBachToCasc.GetPz()}; + std::array pVecCharmBachelorAsD = {kfCharmBachToCharmBaryon.GetPx(), kfCharmBachToCharmBaryon.GetPy(), kfCharmBachToCharmBaryon.GetPz()}; + std::array pVecCharmBaryon = {kfCharmBaryon.GetPx(), kfCharmBaryon.GetPy(), kfCharmBaryon.GetPy()}; + + auto* covVtxCharmBaryon = kfCharmBaryon.CovarianceMatrix(); + float covMatrixPv[6]; + kfVertex.GetCovarianceMatrix(covMatrixPv); - //------------------------------Calculate physical quantities and fill candidate table------------------------------ + std::array pvCoord = {collision.posX(), collision.posY(), collision.posZ()}; - // Get updated daughter tracks after vertex fit - o2::track::TrackParCov trackParCovCasc = getTrackParCovFromKFP(kfCascConstrainedToCharmBaryon, kfCascConstrainedToCharmBaryon.GetPDG(), kfBach.GetQ()); + auto trackParCovV0DauPos = getTrackParCovFromKFP(kfPos, kfPos.GetPDG(), 1); + auto trackParCovV0DauNeg = getTrackParCovFromKFP(kfNeg, kfNeg.GetPDG(), -1); + auto trackParCovBach = getTrackParCovFromKFP(kfBachToCasc, kfBachToCasc.GetPDG(), (isAnti ? 1 : -1)); + auto trackParCovCharmBach = getTrackParCovFromKFP(kfCharmBachToCharmBaryon, kfCharmBachToCharmBaryon.GetPDG(), (isAnti ? -1 : 1)); + auto trackParCovCasc = getTrackParCovFromKFP(kfCascToCharmBaryon, kfCascToCharmBaryon.GetPDG(), (isAnti ? 1 : -1)); + trackParCovV0DauPos.setAbsCharge(1); + trackParCovV0DauNeg.setAbsCharge(1); + trackParCovBach.setAbsCharge(1); + trackParCovCharmBach.setAbsCharge(1); trackParCovCasc.setAbsCharge(1); - o2::track::TrackParCov trackParCovCharmBachelor = getTrackParCovFromKFP(kfCharmBachelorConstrainedToCharmBaryon, kfCharmBachelorConstrainedToCharmBaryon.GetPDG(), -kfBach.GetQ()); - trackParCovCharmBachelor.setAbsCharge(1); + + //----------Calculate physical quantities and fill candidate table---------- // impact parameters std::array impactParameterV0DauPos; std::array impactParameterV0DauNeg; std::array impactParameterBach; - o2::base::Propagator::Instance()->propagateToDCABxByBz({collision.posX(), collision.posY(), collision.posZ()}, trackParCovV0Pos, 2.f, matCorr, &impactParameterV0DauPos); - o2::base::Propagator::Instance()->propagateToDCABxByBz({collision.posX(), collision.posY(), collision.posZ()}, trackParCovV0Neg, 2.f, matCorr, &impactParameterV0DauNeg); + o2::base::Propagator::Instance()->propagateToDCABxByBz({collision.posX(), collision.posY(), collision.posZ()}, trackParCovV0DauPos, 2.f, matCorr, &impactParameterV0DauPos); + o2::base::Propagator::Instance()->propagateToDCABxByBz({collision.posX(), collision.posY(), collision.posZ()}, trackParCovV0DauNeg, 2.f, matCorr, &impactParameterV0DauNeg); o2::base::Propagator::Instance()->propagateToDCABxByBz({collision.posX(), collision.posY(), collision.posZ()}, trackParCovBach, 2.f, matCorr, &impactParameterBach); float dcaxyV0DauPos = impactParameterV0DauPos[0]; float dcaxyV0DauNeg = impactParameterV0DauNeg[0]; @@ -1018,21 +1112,17 @@ struct HfCandidateCreatorXic0Omegac0Qa { o2::dataformats::DCA impactParameterCasc, impactParameterCharmBachelor; auto primaryVertex = getPrimaryVertex(collision); o2::base::Propagator::Instance()->propagateToDCABxByBz(primaryVertex, trackParCovCasc, 2.f, matCorr, &impactParameterCasc); - o2::base::Propagator::Instance()->propagateToDCABxByBz(primaryVertex, trackParCovCharmBachelor, 2.f, matCorr, &impactParameterCharmBachelor); + o2::base::Propagator::Instance()->propagateToDCABxByBz(primaryVertex, trackParCovCharmBach, 2.f, matCorr, &impactParameterCharmBachelor); // get Chi2Topo/NDF - float chi2NdfTopoV0ToPv = kfV0ConstrainedToPv.GetChi2() / kfV0ConstrainedToPv.GetNDF(); - float chi2NdfTopoV0ToCasc = kfV0ConstrainedToPv.GetChi2() / kfV0ConstrainedToPv.GetNDF(); - float chi2NdfTopoBachToPv = kfBachConstrainedToPv.GetChi2() / kfBachConstrainedToPv.GetNDF(); - float chi2NdfTopoBachToCasc = kfBachConstrainedToCasc.GetChi2() / kfBachConstrainedToCasc.GetNDF(); - float chi2NdfTopoCascToPv = kfCascConstrainedToPv.GetChi2() / kfCascConstrainedToPv.GetNDF(); - float chi2NdfTopoCascToCharmBaryon = kfCascConstrainedToCharmBaryon.GetChi2() / kfCascConstrainedToCharmBaryon.GetNDF(); - float chi2NdfTopoCharmBachelorToPv = kfCharmBachelorConstrainedToPv.GetChi2() / kfCharmBachelorConstrainedToPv.GetNDF(); - float chi2NdfTopoCharmBachelorToCharmBaryon = kfCharmBachelorConstrainedToCharmBaryon.GetChi2() / kfCharmBachelorConstrainedToCharmBaryon.GetNDF(); - float chi2NdfTopoCharmBaryonToPv = kfCharmBachelorConstrainedToPv.GetChi2() / kfCharmBachelorConstrainedToPv.GetNDF(); - - float deviationCharmBachelorToPv = kfCalculateChi2ToPrimaryVertex(kfCharmBachelor, kfPv); - float chi2NdfBach = kfBach.GetChi2() / kfBach.GetNDF(); + float chi2NdfTopoV0ToPv = kfV0ToPv.GetChi2() / kfV0ToPv.GetNDF(); + float chi2NdfTopoCascToPv = kfCascToPv.GetChi2() / kfCascToPv.GetNDF(); + float chi2NdfTopoCharmBachToPv = kfCharmBachToPv.GetChi2() / kfCharmBachToPv.GetNDF(); + float chi2NdfTopoCharmBaryonToPv = kfCharmBaryonToPv.GetChi2() / kfCharmBaryonToPv.GetNDF(); + float chi2NdfTopoBachToCasc = kfBachToCasc.GetChi2() / kfBachToCasc.GetNDF(); + float chi2NdfTopoV0ToCasc = kfV0ToCasc.GetChi2() / kfV0ToCasc.GetNDF(); + float chi2NdfTopoCharmBachToCharmBaryon = kfCharmBachToCharmBaryon.GetChi2() / kfCharmBachToCharmBaryon.GetChi2(); + float chi2NdfTopoCascToCharmBaryon = kfCascToCharmBaryon.GetChi2() / kfCascToCharmBaryon.GetChi2(); // get ldl float ldlV0 = ldlFromKF(kfV0, kfPv); @@ -1040,21 +1130,21 @@ struct HfCandidateCreatorXic0Omegac0Qa { float ldlCharmBaryon = ldlFromKF(kfCharmBaryon, kfPv); // get DCAs - float kfDcaV0Daughters = kfV0Pos.GetDistanceFromParticle(kfV0Neg); - float kfDcaCascDaughters = kfBachConstrainedToCasc.GetDistanceFromParticle(kfV0ConstrainedToCasc); - float kfDcaCharmBaryonDaughters = kfCharmBachelorConstrainedToCharmBaryon.GetDistanceFromParticle(kfCascConstrainedToCharmBaryon); - float kfDcaXYCharmBachelorToPv = kfCharmBachelorConstrainedToCharmBaryon.GetDistanceFromVertexXY(kfPv); - float kfDcaXYCascToPv = kfCascConstrainedToCharmBaryon.GetDistanceFromVertexXY(kfPv); + float kfDcaV0Daughters = kfNeg.GetDistanceFromParticle(kfPos); + float kfDcaCascDaughters = kfBachToCasc.GetDistanceFromParticle(kfV0ToCasc); + float kfDcaCharmBaryonDaughters = kfCharmBachToCharmBaryon.GetDistanceFromParticle(kfCascToCharmBaryon); + float kfDcaXYCharmBachelorToPv = kfCharmBachToCharmBaryon.GetDistanceFromVertexXY(kfPv); + float kfDcaXYCascToPv = kfCascToCharmBaryon.GetDistanceFromVertexXY(kfPv); // get decay length - In XY float decayLXYV0, errDecayLXYV0; - kfV0ConstrainedToCasc.GetDecayLengthXY(decayLXYV0, errDecayLXYV0); + kfV0ToCasc.GetDecayLengthXY(decayLXYV0, errDecayLXYV0); float decayLXYCasc, errDecayLXYCasc; - kfCascConstrainedToCharmBaryon.GetDecayLengthXY(decayLXYCasc, decayLXYCasc); + kfCascToCharmBaryon.GetDecayLengthXY(decayLXYCasc, errDecayLXYCasc); float decayLXYCharmBaryon, errDecayLXYCharmBaryon; - kfCharmBaryonConstrainedToPv.GetDecayLengthXY(decayLXYCharmBaryon, errDecayLXYCharmBaryon); + kfCharmBaryonToPv.GetDecayLengthXY(decayLXYCharmBaryon, errDecayLXYCharmBaryon); // get decay length - In XYZ float decayLV0 = RecoDecay::distance(std::array{kfCasc.GetX(), kfCasc.GetY(), kfCasc.GetZ()}, std::array{kfV0.GetX(), kfV0.GetY(), kfV0.GetZ()}); @@ -1063,12 +1153,10 @@ struct HfCandidateCreatorXic0Omegac0Qa { double phiCharmBaryon, thetaCharmBaryon; getPointDirection(std::array{kfV0.GetX(), kfV0.GetY(), kfV0.GetZ()}, std::array{kfCharmBaryon.GetX(), kfCharmBaryon.GetY(), kfCharmBaryon.GetZ()}, phiCharmBaryon, thetaCharmBaryon); - float errDecayLCharmBaryon = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phiCharmBaryon, thetaCharmBaryon) + getRotatedCovMatrixXX(covMatrixCharmBaryon, phiCharmBaryon, thetaCharmBaryon)); + float errDecayLCharmBaryon = std::sqrt(getRotatedCovMatrixXX(covMatrixPv, phiCharmBaryon, thetaCharmBaryon) + getRotatedCovMatrixXX(covVtxCharmBaryon, phiCharmBaryon, thetaCharmBaryon)); // get cosine of pointing angle - std::array pvCoord = {collision.posX(), collision.posY(), collision.posZ()}; - // float cosPaV0ToPv = casc.v0cosPA(collision.posX(), collision.posY(), collision.posZ()); - float cosPaV0ToPv = RecoDecay::cpa(pvCoord, vertexV0, pVecV0); + float cosPaV0ToPv = cpaFromKF(kfV0, kfPv); float cosPaCascToPv = cpaFromKF(kfCasc, kfPv); float cosPaCharmBaryonToPv = cpaFromKF(kfCharmBaryon, kfPv); @@ -1076,33 +1164,34 @@ struct HfCandidateCreatorXic0Omegac0Qa { float cosPaXYCascToPv = cpaXYFromKF(kfCasc, kfPv); float cosPaXYCharmBaryonToPv = cpaXYFromKF(kfCharmBaryon, kfPv); - float cosPaV0ToCasc = RecoDecay::cpa(vertexCasc, vertexV0, pVecV0); + float cosPaV0ToCasc = cpaFromKF(kfV0, kfCasc); float cosPaCascToCharmBaryon = cpaFromKF(kfCasc, kfCharmBaryon); float cosPaXYV0ToCasc = RecoDecay::cpaXY(vertexCasc, vertexV0, pVecV0); float cosPaXYCascToCharmBaryon = cpaXYFromKF(kfCasc, kfCharmBaryon); + float deviationCharmBachToPv = kfCalculateChi2ToPrimaryVertex(kfCharmBaryon, kfPv); // -> For Omegac0 + // KF pT, eta - float ptCasc = kfCascConstrainedToCharmBaryon.GetPt(); - float ptCharmBachelor = kfCharmBachelorConstrainedToCharmBaryon.GetPt(); + float ptCasc = kfCascToCharmBaryon.GetPt(); + float ptCharmBachelor = kfCharmBachToCharmBaryon.GetPt(); float ptCharmBaryon = kfCharmBaryon.GetPt(); float yCharmBaryon = kfCharmBaryon.GetRapidity(); - // get KF cosThetaStar(?) - float cosThetaStarCharmBachelorXic0, cosThetaStarCharmBachelorOmegac0; + // get KF cosThetaStar + float cosThetaStarCharmBachelor; if constexpr (decayChannel == hf_cand_casc_lf::DecayType2Prong::XiczeroOmegaczeroToXiPi) { - cosThetaStarCharmBachelorXic0 = cosThetaStarFromKF(0, pdgOfCharmBaryon[decayChannel], pdgOfCascade[decayChannel], pdgOfCharmBach[decayChannel], kfCascConstrainedToCharmBaryon, kfCharmBachelorConstrainedToCharmBaryon); - cosThetaStarCharmBachelorOmegac0 = cosThetaStarFromKF(0, pdgOfCharmBaryon[decayChannel + 1], pdgOfCascade[decayChannel], pdgOfCharmBach[decayChannel], kfCascConstrainedToCharmBaryon, kfCharmBachelorConstrainedToCharmBaryon); - } else if constexpr (decayChannel == hf_cand_casc_lf::DecayType2Prong::OmegaczeroToOmegaPi) { - cosThetaStarCharmBachelorOmegac0 = cosThetaStarFromKF(0, pdgOfCharmBaryon[decayChannel + 1], pdgOfCascade[decayChannel], pdgOfCharmBach[decayChannel], kfCascConstrainedToCharmBaryon, kfCharmBachelorConstrainedToCharmBaryon); - } else if constexpr (decayChannel == hf_cand_casc_lf::DecayType2Prong::OmegaczeroToOmegaK) { - cosThetaStarCharmBachelorXic0 = cosThetaStarFromKF(0, +kXiC0, pdgOfCascade[decayChannel], pdgOfCharmBach[decayChannel], kfCascConstrainedToCharmBaryon, kfCharmBachelorConstrainedToCharmBaryon); - cosThetaStarCharmBachelorOmegac0 = cosThetaStarFromKF(0, +kOmegaC0, pdgOfCascade[decayChannel], pdgOfCharmBach[decayChannel], kfCascConstrainedToCharmBaryon, kfCharmBachelorConstrainedToCharmBaryon); + cosThetaStarCharmBachelor = cosThetaStarFromKF(0, pdgIdOfCharmBaryon, pdgIdOfCharmBach, pdgIdOfCascade, kfCharmBachToCharmBaryon, kfCascToCharmBaryon); + } + float cosThetaStarKaFromOmegac0, cosThetaStarKaFromXic0; // -> Only requeted to be calculated and filled for Xic0/Omegac0 -> Omega K + if constexpr (decayChannel == hf_cand_casc_lf::DecayType2Prong::OmegaczeroToOmegaK) { + cosThetaStarKaFromOmegac0 = cosThetaStarFromKF(0, 4332, 321, 3334, kfCharmBachToCharmBaryon, kfCascToCharmBaryon); + cosThetaStarKaFromXic0 = cosThetaStarFromKF(0, 4132, 321, 3334, kfCharmBachToCharmBaryon, kfCascToCharmBaryon); } // KF ct - float ctV0 = kfV0ConstrainedToCasc.GetLifeTime(); - float ctCasc = kfCascConstrainedToCharmBaryon.GetLifeTime(); - float ctCharmBaryon = kfCharmBachelorConstrainedToPv.GetLifeTime(); + float ctV0 = kfV0ToCasc.GetLifeTime(); + float ctCasc = kfCascToCharmBaryon.GetLifeTime(); + float ctCharmBaryon = kfCharmBaryonToPv.GetLifeTime(); //------------------------------Calculate physical quantities and fill candidate table------------------------------ @@ -1110,53 +1199,50 @@ struct HfCandidateCreatorXic0Omegac0Qa { if constexpr (decayChannel == hf_cand_casc_lf::DecayType2Prong::XiczeroOmegaczeroToXiPi) { cursors.rowCandToXiPiKf(collision.globalIndex(), // Global index of collision pvCoord[0], pvCoord[1], pvCoord[2], // coordination of PV - kfCasc.GetX(), kfCasc.GetY(), kfCasc.GetZ(), // Decay position of kfCasc + vertexCasc[0], vertexCasc[1], vertexCasc[2], // Decay position of kfCasc vertexV0[0], vertexV0[1], vertexV0[2], bachTrack.sign(), - covMatrixCharmBaryon[0], covMatrixCharmBaryon[1], covMatrixCharmBaryon[2], covMatrixCharmBaryon[3], covMatrixCharmBaryon[4], covMatrixCharmBaryon[5], - kfCharmBaryon.GetPx(), kfCharmBaryon.GetPy(), kfCharmBaryon.GetPz(), // x, y, z momentum of charm baryon - kfCascConstrainedToCharmBaryon.GetPx(), kfCascConstrainedToCharmBaryon.GetPy(), kfCascConstrainedToCharmBaryon.GetPz(), - kfCharmBachelorConstrainedToCharmBaryon.GetPx(), kfCharmBachelorConstrainedToCharmBaryon.GetPy(), kfCharmBachelorConstrainedToCharmBaryon.GetPz(), + covVtxCharmBaryon[0], covVtxCharmBaryon[1], covVtxCharmBaryon[2], covVtxCharmBaryon[3], covVtxCharmBaryon[4], covVtxCharmBaryon[5], + pVecCharmBaryon[0], pVecCharmBaryon[1], pVecCharmBaryon[2], // x, y, z momentum of charm baryon + kfCascToCharmBaryon.GetPx(), kfCascToCharmBaryon.GetPy(), kfCascToCharmBaryon.GetPz(), + pVecCharmBachelorAsD[0], pVecCharmBachelorAsD[1], pVecCharmBachelorAsD[2], pVecV0[0], pVecV0[1], pVecV0[2], - kfBachConstrainedToCasc.GetPx(), kfBachConstrainedToCasc.GetPy(), kfBachConstrainedToCasc.GetPz(), + pVecBach[0], pVecBach[1], pVecBach[2], pVecV0DauPos[0], pVecV0DauPos[1], pVecV0DauPos[2], pVecV0DauNeg[0], pVecV0DauNeg[1], pVecV0DauNeg[2], cascAodElement.v0Id(), v0AodElement.posTrackId(), v0AodElement.negTrackId(), cand.cascadeId(), trackCharmBachelor.globalIndex(), cand.prong0Id(), - kfMassV0, kfMassCasc, kfMassCharmBaryon, + massLam, massCasc, massCharmBaryon, cosPaV0ToPv, cosPaCascToPv, - // cosPaCharmBaryonToPv, cosPaXYV0ToPv, cosPaXYCharmBaryonToPv, cosPaXYCascToPv, ctCasc, ctV0, ctCharmBaryon, - kfV0Pos.GetEta(), kfV0Neg.GetEta(), kfBach.GetEta(), kfCharmBachelorConstrainedToCharmBaryon.GetEta(), + kfPos.GetEta(), kfNeg.GetEta(), kfBach.GetEta(), kfCharmBachToCharmBaryon.GetEta(), kfCharmBaryon.GetEta(), kfCasc.GetEta(), kfV0.GetEta(), dcaxyV0DauPos, dcaxyV0DauNeg, dcaxyBach, kfDcaCascDaughters, kfDcaV0Daughters, kfDcaCharmBaryonDaughters, kfDcaXYCharmBachelorToPv, kfDcaXYCascToPv, - kfV0.GetChi2(), kfCasc.GetChi2(), kfCharmBaryon.GetChi2(), - /*FIXME chi2 of mass constrained, V0 and casc*/ kfV0.GetChi2(), kfCasc.GetChi2(), + kfV0.GetChi2(), kfCasc.GetChi2(), kfCharmBaryon.GetChi2(), kfV0MassConstrained.GetChi2(), kfCascMassConstrained.GetChi2(), ldlV0, ldlCasc, // ldlCharmBaryon, - chi2NdfTopoV0ToPv, chi2NdfTopoCascToPv, chi2NdfTopoCharmBachelorToPv, chi2NdfTopoCharmBaryonToPv, + chi2NdfTopoV0ToPv, chi2NdfTopoCascToPv, chi2NdfTopoCharmBachToPv, chi2NdfTopoCharmBaryonToPv, chi2NdfTopoV0ToCasc, chi2NdfTopoCascToCharmBaryon, decayLXYV0, decayLXYCasc, decayLXYCharmBaryon, cosPaV0ToCasc, cosPaCascToCharmBaryon, // cosPaXYV0ToCasc, cosPaXYCascToCharmBaryon, yCharmBaryon, // ptCharmBachelor, ptCharmBaryon, - cosThetaStarCharmBachelorXic0, - kfV0.GetNDF(), kfCasc.GetNDF(), kfCharmBaryon.GetNDF(), /*FIXME chi2, NDF of mass constrained V0/casc*/ kfV0.GetNDF(), kfCasc.GetNDF(), - kfV0.GetChi2() / kfV0.GetNDF(), kfCasc.GetChi2() / kfCasc.GetNDF(), kfCharmBaryon.GetChi2() / kfCharmBaryon.GetNDF(), /*FIXME chi2, NDF of mass constrained V0/casc*/ kfV0.GetChi2() / kfV0.GetNDF(), kfV0.GetChi2() / kfV0.GetNDF()); - + cosThetaStarCharmBachelor, + kfV0.GetNDF(), kfCasc.GetNDF(), kfCharmBaryon.GetNDF(), kfV0MassConstrained.GetNDF(), kfCascMassConstrained.GetNDF(), + kfV0.GetChi2() / kfV0.GetNDF(), kfCasc.GetChi2() / kfCasc.GetNDF(), kfCharmBaryon.GetChi2() / kfCharmBaryon.GetNDF(), kfV0MassConstrained.GetChi2() / kfV0MassConstrained.GetNDF(), kfCascMassConstrained.GetChi2() / kfCascMassConstrained.GetNDF()); } else if constexpr (decayChannel == hf_cand_casc_lf::DecayType2Prong::OmegaczeroToOmegaPi) { cursors.rowCandToOmegaPi(collision.globalIndex(), pvCoord[0], pvCoord[1], pvCoord[2], - /*vertexCharmBaryonFromFitter. For KF, this is 0*/ 0.f, 0.f, 0.f, - kfCasc.GetX(), kfCasc.GetY(), kfCasc.GetZ(), + 0.f, 0.f, 0.f, // -> vertexCharmBaryonFromFitter. For KF, this is 0 + vertexCasc[0], vertexCasc[1], vertexCasc[2], vertexV0[0], vertexV0[1], vertexV0[2], trackCharmBachelor.sign(), - covMatrixCharmBaryon[0], covMatrixCharmBaryon[1], covMatrixCharmBaryon[2], covMatrixCharmBaryon[3], covMatrixCharmBaryon[4], covMatrixCharmBaryon[5], + covVtxCharmBaryon[0], covVtxCharmBaryon[1], covVtxCharmBaryon[2], covVtxCharmBaryon[3], covVtxCharmBaryon[4], covVtxCharmBaryon[5], kfCharmBaryon.GetPx(), kfCharmBaryon.GetPy(), kfCharmBaryon.GetPz(), - kfCascConstrainedToCharmBaryon.GetPx(), kfCascConstrainedToCharmBaryon.GetPy(), kfCascConstrainedToCharmBaryon.GetPz(), - kfCharmBachelorConstrainedToCharmBaryon.GetPx(), kfCharmBachelorConstrainedToCharmBaryon.GetPy(), kfCharmBachelorConstrainedToCharmBaryon.GetPz(), + kfCascToCharmBaryon.GetPx(), kfCascToCharmBaryon.GetPy(), kfCascToCharmBaryon.GetPz(), + kfCharmBachToCharmBaryon.GetPx(), kfCharmBachToCharmBaryon.GetPy(), kfCharmBachToCharmBaryon.GetPz(), pVecV0[0], pVecV0[1], pVecV0[2], - kfBachConstrainedToCasc.GetPx(), kfBachConstrainedToCasc.GetPy(), kfBachConstrainedToCasc.GetPz(), + pVecBach[0], pVecBach[1], pVecBach[2], pVecV0DauPos[0], pVecV0DauPos[1], pVecV0DauPos[2], pVecV0DauNeg[0], pVecV0DauNeg[1], pVecV0DauNeg[2], impactParameterCasc.getY(), impactParameterCharmBachelor.getY(), @@ -1164,10 +1250,10 @@ struct HfCandidateCreatorXic0Omegac0Qa { std::sqrt(impactParameterCasc.getSigmaY2()), std::sqrt(impactParameterCharmBachelor.getSigmaY2()), cascAodElement.v0Id(), v0AodElement.posTrackId(), v0AodElement.negTrackId(), cand.cascadeId(), trackCharmBachelor.globalIndex(), cand.prong0Id(), - kfMassV0, kfMassCasc, kfMassCharmBaryon, + massLam, massCasc, massCharmBaryon, cosPaV0ToPv, cosPaCharmBaryonToPv, cosPaCascToPv, cosPaXYV0ToPv, cosPaXYCharmBaryonToPv, cosPaXYCascToPv, ctCharmBaryon, ctCasc, ctV0, - kfV0Pos.GetEta(), kfV0Neg.GetEta(), kfBach.GetEta(), kfCharmBachelorConstrainedToCharmBaryon.GetEta(), + kfPos.GetEta(), kfNeg.GetEta(), kfBach.GetEta(), kfCharmBachToCharmBaryon.GetEta(), kfCharmBaryon.GetEta(), kfCasc.GetEta(), kfV0.GetEta(), dcaxyV0DauPos, dcaxyV0DauNeg, dcaxyBach, dcazV0DauPos, dcazV0DauNeg, dcazBach, @@ -1175,47 +1261,47 @@ struct HfCandidateCreatorXic0Omegac0Qa { decayLCharmBaryon, decayLCasc, decayLV0, errDecayLCharmBaryon, errDecayLXYCharmBaryon, cand.hfflag()); cursors.rowCandToOmegaPiKf(kfDcaXYCharmBachelorToPv, kfDcaXYCascToPv, - /*V0 chi2. Taken from LF*/ kfV0.GetChi2(), kfCasc.GetChi2(), kfCharmBaryon.GetChi2(), /*Mass constraint only done when requested*/ kfV0.GetChi2(), /*Mass constraint only done when requested*/ kfCasc.GetChi2(), + kfV0.GetChi2(), kfCasc.GetChi2(), kfCharmBaryon.GetChi2(), kfV0MassConstrained.GetChi2(), kfCascMassConstrained.GetChi2(), ldlV0, ldlCasc, ldlCharmBaryon, - chi2NdfTopoV0ToPv, chi2NdfTopoCascToPv, chi2NdfTopoCharmBachelorToPv, chi2NdfTopoCharmBaryonToPv, deviationCharmBachelorToPv, + chi2NdfTopoV0ToPv, chi2NdfTopoCascToPv, chi2NdfTopoCharmBachToPv, chi2NdfTopoCharmBaryonToPv, deviationCharmBachToPv, chi2NdfTopoV0ToCasc, chi2NdfTopoCascToCharmBaryon, decayLXYV0, decayLXYCasc, decayLXYCharmBaryon, cosPaV0ToCasc, cosPaCascToCharmBaryon, cosPaXYV0ToCasc, cosPaXYCascToCharmBaryon, kfCharmBaryon.GetRapidity(), ptCharmBachelor, ptCharmBaryon, - cosThetaStarCharmBachelorOmegac0, - kfV0.GetNDF(), kfCasc.GetNDF(), kfCharmBaryon.GetNDF(), /*Mass constraint only done when requested*/ kfV0.GetNDF(), /*Mass constraint only done when requested*/ kfCasc.GetNDF(), + cosThetaStarKaFromOmegac0, + kfV0.GetNDF(), kfCasc.GetNDF(), kfCharmBaryon.GetNDF(), kfV0MassConstrained.GetNDF(), kfCascMassConstrained.GetNDF(), kfV0.GetChi2() / kfV0.GetNDF(), kfCasc.Chi2() / kfCasc.GetNDF(), kfCharmBaryon.GetChi2() / kfCharmBaryon.GetNDF(), - /*Mass constraint only done when requested*/ kfV0.GetChi2() / kfV0.GetNDF(), kfCasc.Chi2() / kfCasc.GetNDF(), - /*FIXME casc-rej not calculated. For now, fill in mass of KFCasc*/ kfCasc.GetMass()); + kfV0MassConstrained.GetChi2() / kfV0.GetNDF(), kfCascMassConstrained.Chi2() / kfCasc.GetNDF(), + massCascRej); } else { cursors.rowCandToOmegaKaKf(collision.globalIndex(), collision.posX(), collision.posY(), collision.posZ(), kfPv.GetX(), kfPv.GetY(), kfPv.GetZ(), - vertexV0[0], vertexV0[1], vertexV0[2], - pVecV0[0], pVecV0[1], pVecV0[2], - vertexCasc[0], vertexCasc[1], vertexCasc[2], - pVecCasc[0], pVecCasc[1], pVecCasc[2], - vertexV0[0], vertexV0[1], vertexV0[2], - pVecV0[0], pVecV0[1], pVecV0[2], + straHelper.cascade.v0Position[0], straHelper.cascade.v0Position[1], straHelper.cascade.v0Position[2], + straHelper.cascade.v0Momentum[0], straHelper.cascade.v0Momentum[1], straHelper.cascade.v0Momentum[2], + straHelper.cascade.cascadePosition[0], straHelper.cascade.cascadePosition[1], straHelper.cascade.cascadePosition[2], + straHelper.cascade.cascadeMomentum[0], straHelper.cascade.cascadeMomentum[1], straHelper.cascade.cascadeMomentum[2], + kfV0.GetX(), kfV0.GetY(), kfV0.GetZ(), + kfV0.GetPx(), kfV0.GetPy(), kfV0.GetPz(), kfCasc.GetX(), kfCasc.GetY(), kfCasc.GetZ(), kfCasc.GetPx(), kfCasc.GetPy(), kfCasc.GetPz(), kfCharmBaryon.GetX(), kfCharmBaryon.GetY(), kfCharmBaryon.GetZ(), kfCharmBaryon.GetPx(), kfCharmBaryon.GetPy(), kfCharmBaryon.GetPz(), straHelper.cascade.charge, - kfV0Pos.GetEta(), kfV0Neg.GetEta(), kfBach.GetEta(), kfCharmBachelor.GetEta(), kfV0.GetEta(), kfCasc.GetEta(), kfCharmBaryon.GetEta(), kfCharmBaryon.GetRapidity(), + kfPos.GetEta(), kfNeg.GetEta(), kfBach.GetEta(), kfCharmBach.GetEta(), kfV0.GetEta(), kfCasc.GetEta(), kfCharmBaryon.GetEta(), kfCharmBaryon.GetRapidity(), impactParameterCharmBachelor.getY(), std::sqrt(impactParameterCharmBachelor.getSigmaY2()), impactParameterCasc.getY(), std::sqrt(impactParameterCasc.getSigmaY2()), kfDcaV0Daughters, kfDcaCascDaughters, kfDcaCharmBaryonDaughters, cosPaV0ToPv, cosPaCascToPv, cosPaCharmBaryonToPv, cosPaXYV0ToPv, cosPaXYCascToPv, cosPaXYCharmBaryonToPv, cosPaV0ToCasc, cosPaCascToCharmBaryon, cosPaXYV0ToCasc, cosPaXYCascToCharmBaryon, kfV0.GetChi2() / kfV0.GetNDF(), kfCasc.GetChi2() / kfCasc.GetNDF(), kfCharmBaryon.GetChi2() / kfCharmBaryon.GetNDF(), - /*FIXME mass constraint is optional*/ kfV0.GetChi2() / kfV0.GetNDF(), kfCasc.GetChi2() / kfCasc.GetNDF(), - chi2NdfTopoV0ToCasc, chi2NdfTopoBachToCasc, chi2NdfTopoCharmBachelorToCharmBaryon, chi2NdfTopoCascToCharmBaryon, // Topological constraints to mother - chi2NdfTopoV0ToPv, chi2NdfTopoCascToPv, chi2NdfTopoCharmBachelorToPv, chi2NdfTopoCharmBaryonToPv, // Topological constraints to PV + kfV0MassConstrained.GetChi2() / kfV0MassConstrained.GetNDF(), kfCascMassConstrained.GetChi2() / kfCascMassConstrained.GetNDF(), + chi2NdfTopoV0ToCasc, chi2NdfTopoBachToCasc, chi2NdfTopoCharmBachToCharmBaryon, chi2NdfTopoCascToCharmBaryon, // Topological constraints to mother + chi2NdfTopoV0ToPv, chi2NdfTopoCascToPv, chi2NdfTopoCharmBachToPv, chi2NdfTopoCharmBaryonToPv, // Topological constraints to PV ldlV0, ldlCasc, ldlCharmBaryon, decayLXYV0, decayLXYCasc, decayLXYCharmBaryon, - kfMassV0, kfSigMassV0, kfMassCasc, kfSigMassCasc, /*FIXME no -rej has been made*/ kfMassCasc, /*FIXME no -rej has been made*/ kfSigMassCasc, kfMassCharmBaryon, kfSigMassCharmBaryon, + massLam, sigMassLam, massCasc, sigMassCasc, massCascRej, sigMassCascRej, massCharmBaryon, sigMassCharmBaryon, ptCharmBaryon, ptCharmBachelor, ptCasc, - cosThetaStarCharmBachelorOmegac0, cosThetaStarCharmBachelorXic0, ctV0, ctCasc, ctCharmBaryon, + cosThetaStarKaFromOmegac0, cosThetaStarKaFromXic0, ctV0, ctCasc, ctCharmBaryon, cascAodElement.v0Id(), v0AodElement.posTrackId(), v0AodElement.negTrackId(), cand.cascadeId(), cand.prong0Id(), trackCharmBachelor.globalIndex()); } } // end candidate loop @@ -1234,10 +1320,11 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::HfCascLf2Prongs const& candidates, aod::Cascades const& cascades, aod::V0s const& v0s, - TracksWCovDcaExtraPidPrPiKa const& tracks, + aod::TracksWCovDca const& tracks, + TracksWCovIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToXiPi, hCandidateCounterToXiPi); + runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToXiPi, hCandidateCounterToXiPi); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToXiPiWithDCAFitterNoCent, "Charm candidte reconstruction with Xi Pi via DcaFitter method, no centrality", true); @@ -1259,10 +1346,11 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::HfCascLf2Prongs const& candidates, aod::Cascades const& cascades, aod::V0s const& v0s, - TracksWCovDcaExtraPidPrPiKa const& tracks, + aod::TracksWCovDca const& tracks, + TracksWCovIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToXiPi, hCandidateCounterToXiPi); + runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToXiPi, hCandidateCounterToXiPi); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToXiPiWithDCAFitterCentFT0C, "Charm candidate reconstruction with Xi Pi via DcaFitter method, centrality selection on FT0C", false); @@ -1270,10 +1358,11 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::HfCascLf2Prongs const& candidates, aod::Cascades const& cascades, aod::V0s const& v0s, - TracksWCovDcaExtraPidPrPiKa const& tracks, + aod::TracksWCovDca const& tracks, + TracksWCovIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToXiPi, hCandidateCounterToXiPi); + runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToXiPi, hCandidateCounterToXiPi); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToXiPiWithDCAFitterCentFT0M, "Charm candidate reconstruction with Xi Pi via DcaFitter method, centrality selection on FT0M", false); @@ -1284,10 +1373,11 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::HfCascLf2Prongs const& candidates, aod::Cascades const& cascades, aod::V0s const& v0s, - TracksWCovDcaExtraPidPrPiKa const& tracks, + aod::TracksWCovDca const& tracks, + TracksWCovIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaPi, hCandidateCounterToOmegaPi); + runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaPi, hCandidateCounterToOmegaPi); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToOmegaPiWithDCAFitterNoCent, "Charm candidte reconstruction with Omega Pi via DcaFitter method, no centrality", false); @@ -1295,10 +1385,11 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::HfCascLf2Prongs const& candidates, aod::Cascades const& cascades, aod::V0s const& v0s, - TracksWCovDcaExtraPidPrPiKa const& tracks, + aod::TracksWCovDca const& tracks, + TracksWCovIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaPi, hCandidateCounterToOmegaPi); + runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaPi, hCandidateCounterToOmegaPi); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToOmegaPiWithDCAFitterCentFT0C, "Charm candidate reconstruction with Omega Pi via DcaFitter method, centrality selection on FT0C", false); @@ -1306,10 +1397,11 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::HfCascLf2Prongs const& candidates, aod::Cascades const& cascades, aod::V0s const& v0s, - TracksWCovDcaExtraPidPrPiKa const& tracks, + aod::TracksWCovDca const& tracks, + TracksWCovIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaPi, hInvMassCharmBaryonToOmegaPi); + runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaPi, hInvMassCharmBaryonToOmegaPi); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToOmegaPiWithDCAFitterCentFT0M, "Charm candidate reconstruction with Omega Pi via DcaFitter method, centrality selection on FT0M", false); @@ -1320,10 +1412,11 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::HfCascLf2Prongs const& candidates, aod::Cascades const& cascades, aod::V0s const& v0s, - TracksWCovDcaExtraPidPrPiKa const& tracks, + aod::TracksWCovDca const& tracks, + TracksWCovIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaKa, hCandidateCounterToOmegaKa); + runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaKa, hCandidateCounterToOmegaKa); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToOmegaKaWithDCAFitterNoCent, "Charm candidte reconstruction with Omega Ka via DcaFitter method, no centrality", false); @@ -1331,10 +1424,11 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::HfCascLf2Prongs const& candidates, aod::Cascades const& cascades, aod::V0s const& v0s, - TracksWCovDcaExtraPidPrPiKa const& tracks, + aod::TracksWCovDca const& tracks, + TracksWCovIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaKa, hCandidateCounterToOmegaKa); + runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaKa, hCandidateCounterToOmegaKa); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToOmegaKaWithDCAFitterCentFT0C, "Charm candidate reconstruction with Omega Ka via DcaFitter method, centrality selection on FT0C", false); @@ -1342,10 +1436,11 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::HfCascLf2Prongs const& candidates, aod::Cascades const& cascades, aod::V0s const& v0s, - TracksWCovDcaExtraPidPrPiKa const& tracks, + aod::TracksWCovDca const& tracks, + TracksWCovIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaKa, hCandidateCounterToOmegaPi); + runCreatorWithDCAFitter(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaKa, hCandidateCounterToOmegaPi); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToOmegaKaWithDCAFitterCentFT0M, "Charm candidate reconstruction with Omega Ka via DcaFitter method, centrality selection on FT0M", false); @@ -1363,9 +1458,10 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::Cascades const& cascades, aod::V0s const& v0s, TracksWCovDcaExtraPidPrPiKa const& tracks, + TracksWCovExtraPidIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToXiPi, hCandidateCounterToXiPi); + runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToXiPi, hCandidateCounterToXiPi); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToXiPiWithKFParticleNoCent, "Charm Baryon decaying to Xi Pi reconstruction via KFParticle method, no centrality", false); @@ -1374,9 +1470,10 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::Cascades const& cascades, aod::V0s const& v0s, TracksWCovDcaExtraPidPrPiKa const& tracks, + TracksWCovExtraPidIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToXiPi, hCandidateCounterToXiPi); + runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToXiPi, hCandidateCounterToXiPi); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToXiPiWithKFParticleCentFT0C, "Charm Baryon decaying to Xi Pi reconstruction via KFParticle method, centrality on FT0C", false); @@ -1385,9 +1482,10 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::Cascades const& cascades, aod::V0s const& v0s, TracksWCovDcaExtraPidPrPiKa const& tracks, + TracksWCovExtraPidIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToXiPi, hCandidateCounterToXiPi); + runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToXiPi, hCandidateCounterToXiPi); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToXiPiWithKFParticleCentFT0M, "Charm Baryon decaying to Xi Pireconstruction via KFParticle method, centrality on FT0M", false); @@ -1399,9 +1497,10 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::Cascades const& cascades, aod::V0s const& v0s, TracksWCovDcaExtraPidPrPiKa const& tracks, + TracksWCovExtraPidIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaPi, hCandidateCounterToOmegaPi); + runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaPi, hCandidateCounterToOmegaPi); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToOmegaPiWithKFParticleNoCent, "Charm Baryon decaying to Omega Pi reconstruction via KFParticle method, no centrality", false); @@ -1410,9 +1509,10 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::Cascades const& cascades, aod::V0s const& v0s, TracksWCovDcaExtraPidPrPiKa const& tracks, + TracksWCovExtraPidIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaPi, hCandidateCounterToOmegaPi); + runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaPi, hCandidateCounterToOmegaPi); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToOmegaPiWithKFParticleCentFT0C, "Charm Baryon decaying to Omega Pi reconstruction via KFParticle method, centrality on FT0C", false); @@ -1421,9 +1521,10 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::Cascades const& cascades, aod::V0s const& v0s, TracksWCovDcaExtraPidPrPiKa const& tracks, + TracksWCovExtraPidIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaPi, hCandidateCounterToOmegaPi); + runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaPi, hCandidateCounterToOmegaPi); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToOmegaPiWithKFParticleCentFT0M, "Charm Baryong decaying to Omega Pi reconstruction via KFParticle method, centrality on FT0M", false); @@ -1435,9 +1536,10 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::Cascades const& cascades, aod::V0s const& v0s, TracksWCovDcaExtraPidPrPiKa const& tracks, + TracksWCovExtraPidIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaKa, hCandidateCounterToOmegaKa); + runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaKa, hCandidateCounterToOmegaKa); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToOmegaKaWithKFParticleNoCent, "Charm Baryon decaying to Omega Ka reconstruction via KFParticle method, no centrality", false); @@ -1446,9 +1548,10 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::Cascades const& cascades, aod::V0s const& v0s, TracksWCovDcaExtraPidPrPiKa const& tracks, + TracksWCovExtraPidIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaKa, hCandidateCounterToOmegaKa); + runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaKa, hCandidateCounterToOmegaKa); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToOmegaKaWithKFParticleCentFT0C, "Charm Baryon decaying to Omega Ka reconstruction via KFParticle method, centrality on FT0C", false); @@ -1457,9 +1560,10 @@ struct HfCandidateCreatorXic0Omegac0Qa { aod::Cascades const& cascades, aod::V0s const& v0s, TracksWCovDcaExtraPidPrPiKa const& tracks, + TracksWCovExtraPidIU const& lfTracks, aod::BCsWithTimestamps const& bcsWithTimestamps) { - runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaKa, hCandidateCounterToOmegaKa); + runCreatorWithKfParticle(collisions, candidates, cascades, v0s, tracks, lfTracks, bcsWithTimestamps, hInvMassCharmBaryonToOmegaKa, hCandidateCounterToOmegaKa); } PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0Qa, processToOmegaKaWithKFParticleCentFT0M, "Charm Baryong decaying to Omega Ka reconstruction via KFParticle method, centrality on FT0M", false); @@ -1520,6 +1624,7 @@ struct HfCandidateCreatorXic0Omegac0Qa { struct HfCandidateCreatorXic0Omegac0QaMc { + // Cursor to fill tables struct : ProducesGroup { Produces rowMcMatchRecXicToXiPi; @@ -1533,6 +1638,7 @@ struct HfCandidateCreatorXic0Omegac0QaMc { } cursors; + // Configurables struct : ConfigurableGroup { Configurable rejectBackground{"rejectBackground", true, "Reject particles from background events"}; // -> Used for only Xic0 @@ -1557,6 +1663,7 @@ struct HfCandidateCreatorXic0Omegac0QaMc { std::array pdgOfBachelor{+kPiMinus, +kPiMinus, +kKMinus, +kKMinus}; // Table aliases + using TracksWMcIU = soa::Join; using McCollisionsNoCents = soa::Join; using McCollisionsFT0Cs = soa::Join; using McCollisionsFT0Ms = soa::Join; @@ -1583,17 +1690,8 @@ struct HfCandidateCreatorXic0Omegac0QaMc { // Add histograms for QA if (configs.fillMcHistograms) { - registry.add("hDebugStatusRec", "hDebugStatusRec", {HistType::kTH1D, {{NumberMcMatchFlag, 0, NumberMcMatchFlag}}}); - registry.add("hDebugStatusGen", "hDebugStatusGen", {HistType::kTH1D, {{NumberMcMatchFlag, 0, NumberMcMatchFlag}}}); - TString labels[McMatchFlag::NumberMcMatchFlag]; - labels[McMatchFlag::None] = "None"; - labels[McMatchFlag::CharmBaryonUnmatched] = "CharmBaryonUnmatched"; - labels[McMatchFlag::CascUnmatched] = "CascUnmatched"; - labels[McMatchFlag::V0Unmatched] = "V0Unmatched"; - for (int iBin = 0; iBin < McMatchFlag::NumberMcMatchFlag; iBin++) { - registry.get(HIST("hDebugStatusRec"))->GetXaxis()->SetBinLabel(iBin + 1, labels[iBin]); - registry.get(HIST("hDebugStatusGen"))->GetXaxis()->SetBinLabel(iBin + 1, labels[iBin]); - } + registry.add("hGenCharmBaryonPtRapidityTight", "Generated charm baryon #it{p}_{T};#if{p}_{T} (GeV/#it{c});entries", {HistType::kTH1D, {{20, 0.0, 20.0}}}); + registry.add("hGenCharmBaryonPtRapidityLoose", "Generated charm baryon #it{p}_{T};#if{p}_{T} (GeV/#it{c});entries", {HistType::kTH1D, {{20, 0.0, 20.0}}}); } } @@ -1643,7 +1741,7 @@ struct HfCandidateCreatorXic0Omegac0QaMc { template void runXic0Omegac0Mc(TRecoCand const& candidates, - TracksWMc const& tracks, + TracksWMcIU const&, aod::McParticles const& mcParticles, Colls const& collsWithMcLabels, McCollisions const& mcCollisions, @@ -1676,15 +1774,15 @@ struct HfCandidateCreatorXic0Omegac0QaMc { collisionMatched = false; std::vector idxBhadMothers{}; - auto arrayDaughters = std::array{candidate.template bachelorFromCharmBaryon_as(), - candidate.template bachelor_as(), - candidate.template posTrack_as(), - candidate.template negTrack_as()}; - auto arrayDaughtersCasc = std::array{candidate.template bachelor_as(), - candidate.template posTrack_as(), - candidate.template negTrack_as()}; - auto arrayDaughtersV0 = std::array{candidate.template posTrack_as(), - candidate.template negTrack_as()}; + auto arrayDaughters = std::array{candidate.template bachelorFromCharmBaryon_as(), + candidate.template bachelor_as(), + candidate.template posTrack_as(), + candidate.template negTrack_as()}; + auto arrayDaughtersCasc = std::array{candidate.template bachelor_as(), + candidate.template posTrack_as(), + candidate.template negTrack_as()}; + auto arrayDaughtersV0 = std::array{candidate.template posTrack_as(), + candidate.template negTrack_as()}; // Reject particles from background events if (configs.rejectBackground) { @@ -1741,15 +1839,18 @@ struct HfCandidateCreatorXic0Omegac0QaMc { } else { fillRecoMcTableByDecayChannel(flag, debug, origin, collisionMatched, -1.f, 0); } + if (debug == McMatchFlag::CascUnmatched || debug == McMatchFlag::V0Unmatched) { + LOGF(info, "WARNING: Charm baryon decays in the expected final state but the condition on the intermediate states are not fullfilled"); + } } // candidate loop /////////////////////////////// // Match generated particles // /////////////////////////////// - for (auto const& mcCollision : mcCollisions) { + for (const auto& mcCollision : mcCollisions) { - auto const mcParticlesPerMcColl = mcParticles.sliceBy(mcParticlesPerMcCollision, mcCollision.globalIndex()); + const auto& mcParticlesPerMcColl = mcParticles.sliceBy(mcParticlesPerMcCollision, mcCollision.globalIndex()); float centrality{-1.f}; uint16_t rejectionMask{0}; @@ -1758,17 +1859,20 @@ struct HfCandidateCreatorXic0Omegac0QaMc { if constexpr (centEstimator == o2::hf_centrality::CentralityEstimator::None) { const auto collSlice = collsWithMcLabels.sliceBy(colPerMcCollision, mcCollision.globalIndex()); rejectionMask = hfEvSelMc.getHfMcCollisionRejectionMask(mcCollision, collSlice, centrality); + nSplitColl = collSlice.size(); } else if constexpr (centEstimator == o2::hf_centrality::CentralityEstimator::FT0C) { const auto collSlice = collsWithMcLabels.sliceBy(colPerMcCollisionFT0C, mcCollision.globalIndex()); rejectionMask = hfEvSelMc.getHfMcCollisionRejectionMask(mcCollision, collSlice, centrality); + nSplitColl = collSlice.size(); } else if constexpr (centEstimator == o2::hf_centrality::CentralityEstimator::FT0M) { const auto collSlice = collsWithMcLabels.sliceBy(colPerMcCollisionFT0M, mcCollision.globalIndex()); rejectionMask = hfEvSelMc.getHfMcCollisionRejectionMask(mcCollision, collSlice, centrality); + nSplitColl = collSlice.size(); } - hfEvSelMc.fillHistograms(mcCollision, rejectionMask); + hfEvSelMc.fillHistograms(mcCollision, rejectionMask, nSplitColl); - if (rejectionMask != 0) { // none of the event selection was satisfied(?) -> Reject all particles from this event + if (rejectionMask != 0) { // At least one event selection not satisfied --> Reject all particles from this event for (unsigned int i = 0; i < mcParticlesPerMcColl.size(); ++i) { fillGenMcTableByDecayChannel(0, 0, 0, 0, -999., -999., RecoDecay::OriginType::None, -1); } @@ -1824,17 +1928,17 @@ struct HfCandidateCreatorXic0Omegac0QaMc { } } // charm daughter loop - // Check if charm is prompt or non-prompt if (flag != 0) { origin = RecoDecay::getCharmHadronOrigin(mcParticles, particle, false, &idxBhadMothers); - } - if (std::abs(yCharmBaryonGen) < kYCutTight) { - // Fill in some QA histogram. Will be implemented later - } - if (std::abs(yCharmBaryonGen) < kYCutLoose) { - // Fill in some QA histograms. Will be implemented later + if (std::abs(yCharmBaryonGen) < kYCutTight) { + registry.fill(HIST("hGenCharmBaryonPtRapidityTight"), ptCharmBaryonGen); + } + if (std::abs(yCharmBaryonGen) < kYCutLoose) { + registry.fill(HIST("hGenCharmBaryonPtRapidityLoose"), ptCharmBaryonGen); + } } + // Check if charm is prompt or non-prompt if (origin == RecoDecay::OriginType::NonPrompt) { fillGenMcTableByDecayChannel(flag, debugGenCharmBaryon, debugGenCasc, debugGenV0, ptCharmBaryonGen, yCharmBaryonGen, origin, idxBhadMothers[0]); } else { @@ -1862,7 +1966,7 @@ struct HfCandidateCreatorXic0Omegac0QaMc { //~~~~To Xi Pi~~~~// //~~~~~~~~~~~~~~~~// void processMcXicToXiPiWithDCAFitterNoCent(aod::HfCandToXiPi const& candidates, - aod::TracksWMc const& tracks, + TracksWMcIU const& tracks, aod::McParticles const& mcParticles, aod::McCollisions const& mcCollisions, McCollisionsNoCents const& collsWithMcLabels, @@ -1873,7 +1977,7 @@ struct HfCandidateCreatorXic0Omegac0QaMc { PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0QaMc, processMcXicToXiPiWithDCAFitterNoCent, "Perform MC matching of DCAFitter reconstructed Xic0 to Xi Pi. No cents", false); void processMcXicToXiPiWithDCAFitterCentFT0C(aod::HfCandToXiPi const& candidates, - aod::TracksWMc const& tracks, + TracksWMcIU const& tracks, aod::McParticles const& mcParticles, aod::McCollisions const& mcCollisions, McCollisionsFT0Cs const& collsWithMcLabels, @@ -1884,7 +1988,7 @@ struct HfCandidateCreatorXic0Omegac0QaMc { PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0QaMc, processMcXicToXiPiWithDCAFitterCentFT0C, "Perform MC matching of DCAFitter reconstructed Xic0 to Xi Pi. Cents with FT0C", false); void processMcXicToXiPiWithDCAFitterCentFT0M(aod::HfCandToXiPi const& candidates, - aod::TracksWMc const& tracks, + TracksWMcIU const& tracks, aod::McParticles const& mcParticles, McCollisionsCentFT0Ms const& mcCollisions, McCollisionsFT0Ms const& collsWithMcLabels, @@ -1895,7 +1999,7 @@ struct HfCandidateCreatorXic0Omegac0QaMc { PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0QaMc, processMcXicToXiPiWithDCAFitterCentFT0M, "Perform MC matching of DCAFitter reconstructed Xic0 to Xi Pi. Cents with FT0M", false); void processMcOmegacToXiPiWithDCAFitterNoCent(aod::HfCandToXiPi const& candidates, - aod::TracksWMc const& tracks, + TracksWMcIU const& tracks, aod::McParticles const& mcParticles, aod::McCollisions const& mcCollisions, McCollisionsNoCents const& collsWithMcLabels, @@ -1906,7 +2010,7 @@ struct HfCandidateCreatorXic0Omegac0QaMc { PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0QaMc, processMcOmegacToXiPiWithDCAFitterNoCent, "Perform MC matching of DCAFitter reconstructed Omegac0 to Xi Pi. No cents", false); void processMcOmegacToXiPiWithDCAFitterCentFT0C(aod::HfCandToXiPi const& candidates, - aod::TracksWMc const& tracks, + TracksWMcIU const& tracks, aod::McParticles const& mcParticles, aod::McCollisions const& mcCollisions, McCollisionsFT0Cs const& collsWithMcLabels, @@ -1917,7 +2021,7 @@ struct HfCandidateCreatorXic0Omegac0QaMc { PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0QaMc, processMcOmegacToXiPiWithDCAFitterCentFT0C, "Perform MC matching of DCAFitter reconstructed Omeagc0 to Xi Pi. Cents with FT0C", false); void processMcOmegacToXiPiWithDCAFitterCentFT0M(aod::HfCandToXiPi const& candidates, - aod::TracksWMc const& tracks, + TracksWMcIU const& tracks, aod::McParticles const& mcParticles, McCollisionsCentFT0Ms const& mcCollisions, McCollisionsFT0Ms const& collsWithMcLabels, @@ -1931,7 +2035,7 @@ struct HfCandidateCreatorXic0Omegac0QaMc { //~~~~To Omega Pi~~~~// //~~~~~~~~~~~~~~~~~~~// void processMcOmegacToOmegaPiWithDCAFitterNoCent(aod::HfCandToOmegaPi const& candidates, - aod::TracksWMc const& tracks, + TracksWMcIU const& tracks, aod::McParticles const& mcParticles, aod::McCollisions const& mcCollisions, McCollisionsNoCents const& collsWithMcLabels, @@ -1942,7 +2046,7 @@ struct HfCandidateCreatorXic0Omegac0QaMc { PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0QaMc, processMcOmegacToOmegaPiWithDCAFitterNoCent, "Perform MC matching of DCAFitter reconstructed Omegac0 to Omega Pi. No cents", false); void processMcOmegacToOmegaPiWithDCAFitterCentFT0C(aod::HfCandToOmegaPi const& candidates, - aod::TracksWMc const& tracks, + TracksWMcIU const& tracks, aod::McParticles const& mcParticles, aod::McCollisions const& mcCollisions, McCollisionsFT0Cs const& collsWithMcLabels, @@ -1953,7 +2057,7 @@ struct HfCandidateCreatorXic0Omegac0QaMc { PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0QaMc, processMcOmegacToOmegaPiWithDCAFitterCentFT0C, "Perform MC matching of DCAFitter reconstructed Omegac0 to Omega Pi. Cents with FT0C", false); void processMcOmegacToOmegaPiWithDCAFitterCentFT0M(aod::HfCandToOmegaPi const& candidates, - aod::TracksWMc const& tracks, + TracksWMcIU const& tracks, aod::McParticles const& mcParticles, McCollisionsCentFT0Ms const& mcCollisions, McCollisionsFT0Ms const& collsWithMcLabels, @@ -1967,7 +2071,7 @@ struct HfCandidateCreatorXic0Omegac0QaMc { //~~~~To Omega Ka~~~~// //~~~~~~~~~~~~~~~~~~// void processMcOmegacToOmegaKaWithDCAFitterNoCent(aod::HfCandToOmegaK const& candidates, - aod::TracksWMc const& tracks, + TracksWMcIU const& tracks, aod::McParticles const& mcParticles, aod::McCollisions const& mcCollisions, McCollisionsNoCents const& collsWithMcLabels, @@ -1978,7 +2082,7 @@ struct HfCandidateCreatorXic0Omegac0QaMc { PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0QaMc, processMcOmegacToOmegaKaWithDCAFitterNoCent, "Perform MC matching of DCAFitter reconstructed Omegac0 to Omega Ka. No cents", false); void processMcOmegacToOmegaKaWithDCAFitterCentFT0C(aod::HfCandToOmegaK const& candidates, - aod::TracksWMc const& tracks, + TracksWMcIU const& tracks, aod::McParticles const& mcParticles, aod::McCollisions const& mcCollisions, McCollisionsFT0Cs const& collsWithMcLabels, @@ -1989,7 +2093,7 @@ struct HfCandidateCreatorXic0Omegac0QaMc { PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0QaMc, processMcOmegacToOmegaKaWithDCAFitterCentFT0C, "Perform MC matching of DCAFitter reconstructed Omegac0 to Omega Ka. Cents with FT0C", false); void processMcOmegacToOmegaKaWithDCAFitterCentFT0M(aod::HfCandToOmegaK const& candidates, - aod::TracksWMc const& tracks, + TracksWMcIU const& tracks, aod::McParticles const& mcParticles, McCollisionsCentFT0Ms const& mcCollisions, McCollisionsFT0Ms const& collsWithMcLabels, @@ -2005,7 +2109,7 @@ struct HfCandidateCreatorXic0Omegac0QaMc { /// /// ///////////////////////////////////////////////////// void processMcXicToXiPiWithKFParticleNoCent(aod::HfCandToXiPiKf const& candidates, - aod::TracksWMc const& tracks, + TracksWMcIU const& tracks, aod::McParticles const& mcParticles, aod::McCollisions const& mcCollisions, McCollisionsNoCents const& collsWithMcLabels, @@ -2013,7 +2117,7 @@ struct HfCandidateCreatorXic0Omegac0QaMc { { runXic0Omegac0Mc(candidates, tracks, mcParticles, collsWithMcLabels, mcCollisions, bcs); } - PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0QaMc, processMcXicToXiPiWithKFParticleNoCent, "Perform MC matching of DCAFitter reconstructed Xic0 to Xi Pi. No cents", false); + PROCESS_SWITCH(HfCandidateCreatorXic0Omegac0QaMc, processMcXicToXiPiWithKFParticleNoCent, "Perform MC matching of KFParticle reconstructed Xic0 to Xi Pi. No cents", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) diff --git a/PWGHF/TableProducer/candidateSelectorToXiPiQa.cxx b/PWGHF/TableProducer/candidateSelectorToXiPiQa.cxx index cfd835857e7..1fadcabb6ae 100644 --- a/PWGHF/TableProducer/candidateSelectorToXiPiQa.cxx +++ b/PWGHF/TableProducer/candidateSelectorToXiPiQa.cxx @@ -15,6 +15,7 @@ /// \author Jinhyun Park , Pusan National University /// \author Krista Smith , Pusan National University +#include "PWGHF/Core/HfMlResponseXic0ToXiPi.h" #include "PWGHF/Core/HfMlResponseXic0ToXiPiKf.h" #include "PWGHF/Core/SelectorCuts.h" #include "PWGHF/DataModel/AliasTables.h" @@ -46,8 +47,6 @@ #include #include -// Related to ML - using namespace o2; using namespace o2::aod; using namespace o2::framework; @@ -60,6 +59,11 @@ enum PidInfoStored { PiFromCharm }; +enum { + doDcaFitter = 0, + doKfParticle +}; + /// Struct for applying Omegac0/Xic0 selection cuts struct HfCandidateSelectorToXiPiQa { @@ -67,12 +71,12 @@ struct HfCandidateSelectorToXiPiQa { Produces hfSelToXiPi; // KFParticle Produces hfSelToXiPiKf; - Produces hfMlToXiPiKf; // -> Suffix "kf" of table name was deleted - - // cuts from SelectorCuts.h - Configurable> binsPt{"binsPt", std::vector{hf_cuts_to_xi_pi::vecBinsPt}, "pT bin limits"}; - Configurable> cuts{"cuts", {hf_cuts_to_xi_pi::Cuts[0], hf_cuts_to_xi_pi::NBinsPt, hf_cuts_to_xi_pi::NCutVars, hf_cuts_to_xi_pi::labelsPt, hf_cuts_to_xi_pi::labelsCutVar}, "Xic0 candidate selection per Pt Bin"}; + // ML selection - Filled with both DCAFitter and KFParticle + Produces hfMlToXiPi; + // cuts from SelectorCuts.h - pT dependent cuts + Configurable> binsPt{"binsPt", std::vector{hf_cuts_xic_to_xi_pi::vecBinsPt}, "pT bin limits"}; + Configurable> cuts{"cuts", {hf_cuts_xic_to_xi_pi::Cuts[0], hf_cuts_xic_to_xi_pi::NBinsPt, hf_cuts_xic_to_xi_pi::NCutVars, hf_cuts_xic_to_xi_pi::labelsPt, hf_cuts_xic_to_xi_pi::labelsCutVar}, "Xic0 candidate selection per Pt Bin"}; // ML inference Configurable applyMl{"applyMl", false, "Flag to apply ML selections"}; Configurable> binsPtMl{"binsPtMl", std::vector{hf_cuts_ml::vecBinsPt}, "pT bin limits for ML application"}; @@ -80,43 +84,54 @@ struct HfCandidateSelectorToXiPiQa { Configurable> cutsMl{"cutsMl", {hf_cuts_ml::Cuts[0], hf_cuts_ml::NBinsPt, hf_cuts_ml::NCutScores, hf_cuts_ml::labelsPt, hf_cuts_ml::labelsCutScore}, "ML selections per pT bin"}; Configurable nClassesMl{"nClassesMl", static_cast(hf_cuts_ml::NCutScores), "Number of classes in ML model"}; Configurable> namesInputFeatures{"namesInputFeatures", std::vector{"feature1", "feature2"}, "Names of ML model input features"}; - // CCDB configuration Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; Configurable> modelPathsCCDB{"modelPathsCCDB", std::vector{"EventFiltering/PWGHF/BDTXic0ToXipiKf"}, "Paths of models on CCDB"}; Configurable> onnxFileNames{"onnxFileNames", std::vector{"ModelHandler_onnx_Xic0ToXipiKf.onnx"}, "ONNX file names for each pT bin (if not from CCDB full path)"}; Configurable timestampCCDB{"timestampCCDB", -1, "timestamp of the ONNX file for ML model used to query in CCDB"}; Configurable loadModelsFromCCDB{"loadModelsFromCCDB", false, "Flag to enable or disable the loading of models from CCDB"}; - // LF analysis selections + Configurable etaTrackCharmBachMax{"etaTrackCharmBachMax", 0.8, "Max absolute value of eta for charm baryon bachelor"}; + Configurable etaTrackLFDauMax{"etaTrackLFDauMax", 1.0, "Max absolute value of eta for V0 and cascade daughters"}; + Configurable ptPiFromCascMin{"ptPiFromCascMin", 0.15, "Min pT pi <--Casc"}; + Configurable ptPiFromCharmBaryonMin{"ptPiFromCharmBaryonMin", 0.2, "Min pT pi <--Casc"}; + Configurable radiusCascMin{"radiusCascMin", 0.5, "Min Cascade radius"}; + Configurable radiusV0Min{"radiusV0Min", 1.1, "Min V0 radius"}; + Configurable impactParXYPiFromCharmBaryonMin{"impactParXYPiFromCharmBaryonMin", 0., "Min dcaxy pi from charm baryon track to pV"}; + Configurable impactParXYPiFromCharmBaryonMax{"impactParXYPiFromCharmBaryonMax", 10., "Max dcaxy pi from charm baryon track to pV"}; + Configurable impactParXYCascMin{"impactParXYCascMin", 0., "Min dcaxy casc track to pV"}; + Configurable impactParXYCascMax{"impactParXYCascMax", 10., "Max dcaxy casc track to pV"}; + Configurable impactParZPiFromCharmBaryonMin{"impactParZPiFromCharmBaryonMin", 0., "Min dcaz pi from charm baryon track to pV"}; + Configurable impactParZPiFromCharmBaryonMax{"impactParZPiFromCharmBaryonMax", 10., "Max dcaz pi from charm baryon track to pV"}; + Configurable impactParZCascMin{"impactParZCascMin", 0., "Min dcaz casc track to pV"}; + Configurable impactParZCascMax{"impactParZCascMax", 10., "Max dcaz casc track to pV"}; Configurable applyTrkSelLf{"applyTrkSelLf", true, "Apply track selection for LF daughters"}; - + // Mass window + Configurable v0MassWindow{"v0MassWindow", 0.01, "v0 mass window"}; + Configurable cascMassWindow{"cascMassWindow", 0.01, "cascade mass window"}; + Configurable invMassCharmBaryonMin{"invMassCharmBaryonMin", 2.0, "Lower limit of invariant mass spectrum charm baryon"}; + Configurable invMassCharmBaryonMax{"invMassCharmBaryonMax", 3.1, "Lower limit of invariant mass spectrum charm baryon"}; // PID options Configurable usePidTpcOnly{"usePidTpcOnly", false, "Perform PID using only TPC"}; Configurable usePidTpcTofCombined{"usePidTpcTofCombined", true, "Perform PID using TPC & TOF"}; - // PID - TPC selections Configurable ptPiPidTpcMin{"ptPiPidTpcMin", -1, "Lower bound of track pT for TPC PID for pion selection"}; Configurable ptPiPidTpcMax{"ptPiPidTpcMax", 9999.9, "Upper bound of track pT for TPC PID for pion selection"}; Configurable nSigmaTpcPiMax{"nSigmaTpcPiMax", 3., "Nsigma cut on TPC only for pion selection"}; Configurable nSigmaTpcCombinedPiMax{"nSigmaTpcCombinedPiMax", 0., "Nsigma cut on TPC combined with TOF for pion selection"}; - Configurable ptPrPidTpcMin{"ptPrPidTpcMin", -1, "Lower bound of track pT for TPC PID for proton selection"}; Configurable ptPrPidTpcMax{"ptPrPidTpcMax", 9999.9, "Upper bound of track pT for TPC PID for proton selection"}; Configurable nSigmaTpcPrMax{"nSigmaTpcPrMax", 3., "Nsigma cut on TPC only for proton selection"}; Configurable nSigmaTpcCombinedPrMax{"nSigmaTpcCombinedPrMax", 0., "Nsigma cut on TPC combined with TOF for proton selection"}; - // PID - TOF selections Configurable ptPiPidTofMin{"ptPiPidTofMin", -1, "Lower bound of track pT for TOF PID for pion selection"}; Configurable ptPiPidTofMax{"ptPiPidTofMax", 9999.9, "Upper bound of track pT for TOF PID for pion selection"}; Configurable nSigmaTofPiMax{"nSigmaTofPiMax", 3., "Nsigma cut on TOF only for pion selection"}; Configurable nSigmaTofCombinedPiMax{"nSigmaTofCombinedPiMax", 0., "Nsigma cut on TOF combined with TPC for pion selection"}; - Configurable ptPrPidTofMin{"ptPrPidTofMin", -1, "Lower bound of track pT for TOF PID for proton selection"}; Configurable ptPrPidTofMax{"ptPrPidTofMax", 9999.9, "Upper bound of track pT for TOF PID for proton selection"}; - Configurable nSigmaTofPrMax{"nSigmaTofPrMax", 3., "Nsigma cut on TOF only for proton selection"}; + Configurable nSigmaTofPrMax{"nSigmaTofPrMax", 5., "Nsigma cut on TOF only for proton selection"}; Configurable nSigmaTofCombinedPrMax{"nSigmaTofCombinedPrMax", 0., "Nsigma cut on TOF combined with TPC for proton selection"}; - // detector track quality selections Configurable nClustersTpcMin{"nClustersTpcMin", 70, "Minimum number of TPC clusters requirement"}; Configurable nTpcCrossedRowsMin{"nTpcCrossedRowsMin", 70, "Minimum number of TPC crossed rows requirement"}; @@ -126,14 +141,16 @@ struct HfCandidateSelectorToXiPiQa { Configurable nClustersItsInnBarrMin{"nClustersItsInnBarrMin", 1, "Minimum number of ITS clusters in inner barrel requirement for pi <- charm baryon"}; Configurable itsChi2PerClusterMax{"itsChi2PerClusterMax", 36, "Maximum value of chi2 fit over ITS clusters for pi <- charm baryon"}; - o2::analysis::HfMlResponseXic0ToXiPiKf hfMlResponse; - std::vector outputMlXic0ToXiPiKf = {}; + o2::analysis::HfMlResponseXic0ToXiPi hfMlResponseDca; + o2::analysis::HfMlResponseXic0ToXiPiKf hfMlResponseKf; + std::vector outputMlXic0ToXiPi = {}; o2::ccdb::CcdbApi ccdbApi; TrackSelectorPi selectorPion; TrackSelectorPr selectorProton; using TracksSel = soa::Join; + // using TracksSelLf = soa::Join; HistogramRegistry registry{"registry"}; // for QA of selections @@ -154,283 +171,450 @@ struct HfCandidateSelectorToXiPiQa { selectorProton.setRangeNSigmaTofCondTpc(-nSigmaTofCombinedPrMax, nSigmaTofCombinedPrMax); const AxisSpec axisSel{2, -0.5, 1.5, "status"}; + const AxisSpec axisSelOnLfDca{14, -0.5, 13.5, "status"}; + const AxisSpec axisSelOnLfKf{23, -0.5, 22.5, "status"}; + const AxisSpec axisSelOnHfDca{6, -0.5, 5.5, "status"}; + const AxisSpec axisSelOnHfKf{11, -0.5, 10.5, "status"}; - registry.add("hSelPID", "hSelPID;status;entries", {HistType::kTH1F, {{12, 0., 12.}}}); - registry.add("hStatusCheck", "Check consecutive selections status;status;entries", {HistType::kTH1F, {{12, 0., 12.}}}); - - // for QA of the selections (bin 0 -> candidates that did not pass the selection, bin 1 -> candidates that passed the selection) registry.add("hSelSignDec", "hSelSignDec;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelEtaPosV0Dau", "hSelEtaPosV0Dau;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelEtaNegV0Dau", "hSelEtaNegV0Dau;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelEtaPiFromCasc", "hSelEtaPiFromCasc;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelEtaPiFromCharm", "hSelEtaPiFromCharm;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelRadCasc", "hSelRadCasc;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelRadV0", "hSelRadV0;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelCosPACasc", "hSelCosPACasc;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelCosPAV0", "hSelCosPAV0;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelDCACascDau", "hSelDCACascDau;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelDCAV0Dau", "hSelDCAV0Dau;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelDCACharmDau", "hSelDCACharmDau;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelDCAXYPrimPi", "hSelDCAXYPrimPi;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelDCAZPrimPi", "hSelDCAZPrimPi;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelDCAXYCasc", "hSelDCAXYCasc;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelDCAZCasc", "hSelDCAZCasc;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelPtPiFromCasc", "hSelPtPiFromCasc;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelPtPiFromCharm", "hSelPtPiFromCharm;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelTPCQualityPiFromCharm", "hSelTPCQualityPiFromCharm;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelTPCQualityPiFromLam", "hSelTPCQualityPiFromLam;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelTPCQualityPrFromLam", "hSelTPCQualityPrFromLam;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelTPCQualityPiFromCasc", "hSelTPCQualityPiFromCasc;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelITSQualityPiFromCharm", "hSelITSQualityPiFromCharm;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelMassLam", "hSelMassLam;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelMassCasc", "hSelMassCasc;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelMassCharmBaryon", "hSelMassCharmBaryon;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelDcaXYToPvV0Daughters", "hSelDcaXYToPvV0Daughters;status;entries", {HistType::kTH1F, {axisSel}}); - registry.add("hSelDcaXYToPvPiFromCasc", "hSelDcaXYToPvPiFromCasc;status;entries", {HistType::kTH1F, {axisSel}}); + registry.add("hSelStatusCluster", "hSelStatusCluster:# of events Passed;;", {HistType::kTH1F, {{6, -0.5, 5.5}}}); + registry.get(HIST("hSelStatusCluster"))->GetXaxis()->SetBinLabel(1, "All"); + registry.get(HIST("hSelStatusCluster"))->GetXaxis()->SetBinLabel(2, "TpcCluster PiFromV0"); + registry.get(HIST("hSelStatusCluster"))->GetXaxis()->SetBinLabel(3, "TpcCluster PrFromV0"); + registry.get(HIST("hSelStatusCluster"))->GetXaxis()->SetBinLabel(4, "TpcCluster PiFromCasc"); + registry.get(HIST("hSelStatusCluster"))->GetXaxis()->SetBinLabel(5, "TpcCluster PiFromCharm"); + registry.get(HIST("hSelStatusCluster"))->GetXaxis()->SetBinLabel(6, "ItsCluster PiFromCharm"); + + registry.add("hSelStatusPID", "hSelStatusPID;# of events Passed;;", {HistType::kTH1F, {{4, -0.5, 3.5}}}); + registry.get(HIST("hSelStatusPID"))->GetXaxis()->SetBinLabel(1, "All"); + registry.get(HIST("hSelStatusPID"))->GetXaxis()->SetBinLabel(2, "Lambda"); + registry.get(HIST("hSelStatusPID"))->GetXaxis()->SetBinLabel(3, "Cascade"); + registry.get(HIST("hSelStatusPID"))->GetXaxis()->SetBinLabel(4, "CharmBaryon"); + + // For QA of LF & HF selection + if (doprocessSelectionDCAFitter) { + registry.add("hSelStatusLf", "hSelStatusLf;# of candidate passed;", {HistType::kTH1F, {axisSelOnLfDca}}); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(1, "All"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(2, "etaV0Dau"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(3, "radiusV0"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(4, "radiusCasc"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(5, "cosPAV0"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(6, "cosPACasc"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(7, "dcaV0Dau"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(8, "dcaCascDau"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(9, "dcaXYToPvV0Dau0"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(10, "dcaXYToPvV0Dau1"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(11, "dcaXYToPvCascDau"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(12, "ptPiFromCasc"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(13, "impactParCascXY"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(14, "impactParCascZ"); + + registry.add("hSelStatusHf", "hSelStatusHf;# of candidate passed;", {HistType::kTH1F, {axisSelOnHfDca}}); + registry.get(HIST("hSelStatusHf"))->GetXaxis()->SetBinLabel(1, "All"); + registry.get(HIST("hSelStatusHf"))->GetXaxis()->SetBinLabel(2, "etaTrackCharmBach"); + registry.get(HIST("hSelStatusHf"))->GetXaxis()->SetBinLabel(3, "dcaCharmBaryonDau"); + registry.get(HIST("hSelStatusHf"))->GetXaxis()->SetBinLabel(4, "ptPiFromCharmBaryon"); + registry.get(HIST("hSelStatusHf"))->GetXaxis()->SetBinLabel(5, "impactParBachFromCharmXY"); + registry.get(HIST("hSelStatusHf"))->GetXaxis()->SetBinLabel(6, "impactParBachFromCharmZ"); + } + + if (doprocessSelectionKFParticle) { + registry.add("hSelStatusLf", "hSelStatusLf;# of candidate passed;", {HistType::kTH1F, {axisSelOnLfKf}}); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(1, "All"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(2, "etaV0Dau"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(3, "radiusV0"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(4, "radiusCasc"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(5, "cosPAV0"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(6, "cosPACasc"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(7, "dcaV0Dau"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(8, "dcaCascDau"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(9, "dcaXYToPvV0Dau0"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(10, "dcaXYToPvV0Dau1"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(11, "dcaXYToPvCascDau"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(12, "ptPiFromCasc"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(13, "cosPAV0ToCasc"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(14, "kfDcaXYCascToPv"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(15, "chi2GeoV0"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(16, "chi2GeoCasc"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(17, "chi2TopoV0ToPv"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(18, "chi2TopoCascToPv"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(19, "chi2TopoV0ToCasc"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(20, "v0ldl"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(21, "cascldl"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(22, "decayLenXYLambda"); + registry.get(HIST("hSelStatusLf"))->GetXaxis()->SetBinLabel(23, "decayLenXYCasc"); + + registry.add("hSelStatusHf", "hSelStatusHf;# of candidate passed;", {HistType::kTH1F, {axisSelOnHfKf}}); + registry.get(HIST("hSelStatusHf"))->GetXaxis()->SetBinLabel(1, "All"); + registry.get(HIST("hSelStatusHf"))->GetXaxis()->SetBinLabel(2, "etaTrackCharmBach"); + registry.get(HIST("hSelStatusHf"))->GetXaxis()->SetBinLabel(3, "dcaCharmBaryonDau"); + registry.get(HIST("hSelStatusHf"))->GetXaxis()->SetBinLabel(4, "ptPiFromCharmBaryon"); + registry.get(HIST("hSelStatusHf"))->GetXaxis()->SetBinLabel(5, "cosPaCascToXic"); + registry.get(HIST("hSelStatusHf"))->GetXaxis()->SetBinLabel(6, "kfDcaXYPiFromXic"); + registry.get(HIST("hSelStatusHf"))->GetXaxis()->SetBinLabel(7, "chi2GeoXic"); + registry.get(HIST("hSelStatusHf"))->GetXaxis()->SetBinLabel(8, "chi2TopoPiFromXicToPv"); + registry.get(HIST("hSelStatusHf"))->GetXaxis()->SetBinLabel(9, "chi2TopoCascToXic"); + registry.get(HIST("hSelStatusHf"))->GetXaxis()->SetBinLabel(10, "decayLenXYXic"); + registry.get(HIST("hSelStatusHf"))->GetXaxis()->SetBinLabel(11, "cTauXic"); + } // invarinat mass histograms registry.add("hInvMassCharmBaryon", "Charm baryon invariant mass; int mass; entries", {HistType::kTH1F, {{1500, 1.5, 4.5}}}); registry.add("hInvMassCharmBaryonBkg", "Charm baryon invariant mass, rejected; int mass; entries", {HistType::kTH1F, {{1500, 1.5, 4.5}}}); + // HfMlResponse initialization if (applyMl) { - hfMlResponse.configure(binsPtMl, cutsMl, cutDirMl, nClassesMl); - if (loadModelsFromCCDB) { - ccdbApi.init(ccdbUrl); - hfMlResponse.setModelPathsCCDB(onnxFileNames, ccdbApi, modelPathsCCDB, timestampCCDB); + if (doprocessSelectionDCAFitter) { + hfMlResponseDca.configure(binsPtMl, cutsMl, cutDirMl, nClassesMl); + if (loadModelsFromCCDB) { + ccdbApi.init(ccdbUrl); + hfMlResponseDca.setModelPathsCCDB(onnxFileNames, ccdbApi, modelPathsCCDB, timestampCCDB); + } else { + hfMlResponseDca.setModelPathsLocal(onnxFileNames); + } + hfMlResponseDca.cacheInputFeaturesIndices(namesInputFeatures); + hfMlResponseDca.init(); } else { - hfMlResponse.setModelPathsLocal(onnxFileNames); + hfMlResponseKf.configure(binsPtMl, cutsMl, cutDirMl, nClassesMl); + if (loadModelsFromCCDB) { + ccdbApi.init(ccdbUrl); + hfMlResponseKf.setModelPathsCCDB(onnxFileNames, ccdbApi, modelPathsCCDB, timestampCCDB); + } else { + hfMlResponseKf.setModelPathsLocal(onnxFileNames); + } + hfMlResponseKf.cacheInputFeaturesIndices(namesInputFeatures); + hfMlResponseKf.init(); } - hfMlResponse.cacheInputFeaturesIndices(namesInputFeatures); - hfMlResponse.init(); } } - template - void runSelection(TCandTable const& candidates, TracksSel const&) + // LF cuts - Cuts on LF tracks reco + // Selection on LF related informations + // returns true if all cuts are passed + template + bool SelectOnLF(const T& candidate, const int& inputPtBin) { - double massLambdaFromPDG = o2::constants::physics::MassLambda0; - double massXiFromPDG = o2::constants::physics::MassXiMinus; - // looping over charm baryon candidates - for (const auto& candidate : candidates) { + registry.fill(HIST("hSelStatusLf"), 0.0); - bool resultSelections = true; // True if the candidate passes all the selections, False otherwise + // Eta selection of V0, Cascade daughters + double etaV0PosDau = candidate.etaV0PosDau(); + double etaV0NegDau = candidate.etaV0NegDau(); + double etaPiFromCasc = candidate.etaBachFromCasc(); - auto trackV0PosDau = candidate.template posTrack_as(); - auto trackV0NegDau = candidate.template negTrack_as(); - auto trackPiFromCasc = candidate.template bachelor_as(); - auto trackPiFromCharm = candidate.template bachelorFromCharmBaryon_as(); + if (std::abs(etaV0PosDau) > etaTrackLFDauMax || std::abs(etaV0NegDau) > etaTrackLFDauMax || std::abs(etaPiFromCasc) > etaTrackLFDauMax) { + return false; + } + registry.fill(HIST("hSelStatusLf"), 1.0); - auto trackPiFromLam = trackV0NegDau; - auto trackPrFromLam = trackV0PosDau; + // Minimum radius cut + double radiusV0 = RecoDecay::sqrtSumOfSquares(candidate.xDecayVtxV0(), candidate.yDecayVtxV0()); + double radiusCasc = RecoDecay::sqrtSumOfSquares(candidate.xDecayVtxCascade(), candidate.yDecayVtxCascade()); - int8_t signDecay = candidate.signDecay(); // sign of pi <- cascade + if (radiusV0 < radiusV0Min) { + return false; + } + registry.fill(HIST("hSelStatusLf"), 2.0); + if (radiusCasc < radiusCascMin) { + return false; + } + registry.fill(HIST("hSelStatusLf"), 3.0); - if (signDecay > 0) { - trackPiFromLam = trackV0PosDau; - trackPrFromLam = trackV0NegDau; - registry.fill(HIST("hSelSignDec"), 1); // anti-particle decay - } else if (signDecay < 0) { - registry.fill(HIST("hSelSignDec"), 0); // particle decay + // Cosine of pointing angle + if (candidate.cosPAV0() < cuts->get(inputPtBin, "cosPAV0")) { + return false; + } + registry.fill(HIST("hSelStatusLf"), 4.0); + if (candidate.cosPACasc() < cuts->get(inputPtBin, "cosPACasc")) { + return false; + } + registry.fill(HIST("hSelStatusLf"), 5.0); + + // Distance of Closest Approach(DCA) + if (candidate.dcaV0Dau() > cuts->get(inputPtBin, "dcaV0Dau")) { + return false; + } + registry.fill(HIST("hSelStatusLf"), 6.0); + + if (candidate.dcaCascDau() > cuts->get(inputPtBin, "dcaCascDau")) { + return false; + } + registry.fill(HIST("hSelStatusLf"), 7.0); + + if (std::abs(candidate.dcaXYToPvV0Dau0()) < cuts->get(inputPtBin, "dcaXYToPvV0Dau0")) { + return false; + } + registry.fill(HIST("hSelStatusLf"), 8.0); + + if (std::abs(candidate.dcaXYToPvV0Dau1()) < cuts->get(inputPtBin, "dcaXYToPvV0Dau1")) { + return false; + } + registry.fill(HIST("hSelStatusLf"), 9.0); + + if (std::abs(candidate.dcaXYToPvCascDau()) < cuts->get(inputPtBin, "dcaXYToPvCascDau")) { + return false; + } + registry.fill(HIST("hSelStatusLf"), 10.0); + + // pT: Bachelor + double ptPiFromCasc = RecoDecay::sqrtSumOfSquares(candidate.pxBachFromCasc(), candidate.pyBachFromCasc()); + if (ptPiFromCasc < ptPiFromCascMin) { + return false; + } + registry.fill(HIST("hSelStatusLf"), 11.0); + + // Extra cuts for KFParticle + if constexpr (svReco == doKfParticle) { + // Cosine of Pointing angle + if (candidate.cosPaV0ToCasc() < cuts->get(inputPtBin, "cosPaV0ToCasc")) { + return false; } + registry.fill(HIST("hSelStatusLf"), 12.0); - // pT selection - auto ptCandXic0 = RecoDecay::pt(candidate.pxCharmBaryon(), candidate.pyCharmBaryon()); - int pTBin = findBin(binsPt, ptCandXic0); - if (pTBin == -1) { - resultSelections = false; - continue; + // DCA + if (candidate.kfDcaXYCascToPv() > cuts->get(inputPtBin, "kfDcaXYCascToPv")) { + return false; } + registry.fill(HIST("hSelStatusLf"), 13.0); - // eta selection - double etaV0PosDau = candidate.etaV0PosDau(); - double etaV0NegDau = candidate.etaV0NegDau(); - double etaPiFromCasc = candidate.etaBachFromCasc(); - double etaPiFromCharmBaryon = candidate.etaBachFromCharmBaryon(); - if (std::abs(etaV0PosDau) > cuts->get(pTBin, "etaTrackLFDauMax")) { - resultSelections = false; - registry.fill(HIST("hSelEtaPosV0Dau"), 0); - } else { - registry.fill(HIST("hSelEtaPosV0Dau"), 1); + // Chi2 + if (candidate.chi2GeoV0() < 0 || candidate.chi2GeoV0() > cuts->get(inputPtBin, "chi2GeoV0")) { + return false; } - if (std::abs(etaV0NegDau) > cuts->get(pTBin, "etaTrackLFDauMax")) { - resultSelections = false; - registry.fill(HIST("hSelEtaNegV0Dau"), 0); - } else { - registry.fill(HIST("hSelEtaNegV0Dau"), 1); + registry.fill(HIST("hSelStatusLf"), 14.0); + if (candidate.chi2GeoCasc() < 0 || candidate.chi2GeoCasc() > cuts->get(inputPtBin, "chi2GeoCasc")) { + return false; } - if (std::abs(etaPiFromCasc) > cuts->get(pTBin, "etaTrackLFDauMax")) { - resultSelections = false; - registry.fill(HIST("hSelEtaPiFromCasc"), 0); - } else { - registry.fill(HIST("hSelEtaPiFromCasc"), 1); + registry.fill(HIST("hSelStatusLf"), 15.0); + if (candidate.chi2TopoV0ToPv() > 0 && candidate.chi2TopoV0ToPv() < cuts->get(inputPtBin, "chi2TopoV0ToPv")) { + return false; } - if (std::abs(etaPiFromCharmBaryon) > cuts->get(pTBin, "etaTrackCharmBachMax")) { - resultSelections = false; - registry.fill(HIST("hSelEtaPiFromCharm"), 0); - } else { - registry.fill(HIST("hSelEtaPiFromCharm"), 1); + registry.fill(HIST("hSelStatusLf"), 16.0); + if (candidate.chi2TopoCascToPv() < 0 || candidate.chi2TopoCascToPv() > cuts->get(inputPtBin, "chi2TopoCascToPv")) { + return false; } + registry.fill(HIST("hSelStatusLf"), 17.0); + if (candidate.chi2TopoV0ToCasc() < 0 || candidate.chi2TopoV0ToCasc() > cuts->get(inputPtBin, "chi2TopoV0ToCasc")) { + return false; + } + registry.fill(HIST("hSelStatusLf"), 18.0); - // minimum radius cut (LFcut) - if (RecoDecay::sqrtSumOfSquares(candidate.xDecayVtxCascade(), candidate.yDecayVtxCascade()) < cuts->get(pTBin, "radiusCascMin")) { - resultSelections = false; - registry.fill(HIST("hSelRadCasc"), 0); - } else { - registry.fill(HIST("hSelRadCasc"), 1); + // ldl + if (candidate.v0ldl() < cuts->get(inputPtBin, "v0ldl")) { + return false; } - if (RecoDecay::sqrtSumOfSquares(candidate.xDecayVtxV0(), candidate.yDecayVtxV0()) < cuts->get(pTBin, "radiusV0Min")) { - resultSelections = false; - registry.fill(HIST("hSelRadV0"), 0); - } else { - registry.fill(HIST("hSelRadV0"), 1); + registry.fill(HIST("hSelStatusLf"), 19.0); + if (candidate.cascldl() < cuts->get(inputPtBin, "cascldl")) { + return false; } + registry.fill(HIST("hSelStatusLf"), 20.0); - // cosPA (LFcut) - if (candidate.cosPACasc() < cuts->get(pTBin, "cosPaCascMin")) { - resultSelections = false; - registry.fill(HIST("hSelCosPACasc"), 0); - } else { - registry.fill(HIST("hSelCosPACasc"), 1); + // Decay length + if (std::abs(candidate.decayLenXYLambda()) < cuts->get(inputPtBin, "decayLenXYLambda")) { + return false; } - if (candidate.cosPAV0() < cuts->get(pTBin, "cosPaV0Min")) { - resultSelections = false; - registry.fill(HIST("hSelCosPAV0"), 0); - } else { - registry.fill(HIST("hSelCosPAV0"), 1); + registry.fill(HIST("hSelStatusLf"), 21.0); + if (std::abs(candidate.decayLenXYCasc()) < cuts->get(inputPtBin, "decayLenXYCasc")) { + return false; } + registry.fill(HIST("hSelStatusLf"), 22.0); - // cascade and v0 daughters dca cut (LF cut) - if (candidate.dcaCascDau() > cuts->get(pTBin, "dcaCascDauMax")) { - resultSelections = false; - registry.fill(HIST("hSelDCACascDau"), 0); - } else { - registry.fill(HIST("hSelDCACascDau"), 1); + } else { + // Impact parameter(DCA?) + if (std::abs(candidate.impactParCascXY()) < impactParXYCascMin || std::abs(candidate.impactParCascXY()) > impactParXYCascMax) { + return false; + } + registry.fill(HIST("hSelStatusLf"), 12.0); + if (std::abs(candidate.impactParCascZ()) < impactParZCascMin || std::abs(candidate.impactParCascZ()) > impactParZCascMax) { + return false; } + registry.fill(HIST("hSelStatusLf"), 13.0); + } - if (candidate.dcaV0Dau() > cuts->get(pTBin, "dcaV0DauMax")) { - resultSelections = false; - registry.fill(HIST("hSelDCAV0Dau"), 0); - } else { - registry.fill(HIST("hSelDCAV0Dau"), 1); + // If passes all cuts, return true + return true; + } + + // HF cuts - Cuts on Charm baryon reco + // Apply cuts with charm baryon & charm bachelor related informations + // returns true if all cuts are passed + template + bool SelectOnHF(const T& candidate, const int& inputPtBin) + { + + registry.fill(HIST("hSelStatusHf"), 0.0); + + // eta selection on charm bayron bachelor + if (candidate.etaBachFromCharmBaryon() > etaTrackCharmBachMax) { + return false; + } + registry.fill(HIST("hSelStatusHf"), 1.0); + // Distance of Closest Approach(DCA) + if (candidate.dcaCharmBaryonDau() > cuts->get(inputPtBin, "dcaCharmBaryonDau")) { + return false; + } + registry.fill(HIST("hSelStatusHf"), 2.0); + + // pT: Charm Bachelor + double ptPiFromCharmBaryon = RecoDecay::pt(candidate.pxBachFromCharmBaryon(), candidate.pyBachFromCharmBaryon()); + if (ptPiFromCharmBaryon < cuts->get("ptPiFromCharmBaryon")) { + return false; + } + registry.fill(HIST("hSelStatusHf"), 3.0); + + // specific selections with KFParticle output + if constexpr (svReco == doKfParticle) { + // Cosine of pointing angle + if (candidate.cosPaCascToXic() < cuts->get(inputPtBin, "cosPaCascToXic")) { + return false; } + registry.fill(HIST("hSelStatusHf"), 4.0); - // dca charm baryon daughters cut - if (candidate.dcaCharmBaryonDau() > cuts->get(pTBin, "dcaCharmBaryonDauMax")) { - resultSelections = false; - registry.fill(HIST("hSelDCACharmDau"), 0); - } else { - registry.fill(HIST("hSelDCACharmDau"), 1); + // DCA + if (std::abs(candidate.kfDcaXYPiFromXic()) > cuts->get(inputPtBin, "kfDcaXYPiFromXic")) { + return false; } + registry.fill(HIST("hSelStatusHf"), 5.0); - // dcaXY v0 daughters to PV cut - if (std::abs(candidate.dcaXYToPvV0Dau0()) < cuts->get(pTBin, "dcaxyV0PosDauToPvMin") || std::abs(candidate.dcaXYToPvV0Dau1()) < cuts->get(pTBin, "dcaxyV0NegDauToPvMin")) { - resultSelections = false; - registry.fill(HIST("hSelDcaXYToPvV0Daughters"), 0); - } else { - registry.fill(HIST("hSelDcaXYToPvV0Daughters"), 1); + // Chi2 + if (candidate.chi2GeoXic() < 0 || candidate.chi2GeoXic() > cuts->get(inputPtBin, "chi2GeoXic")) { + return false; + } + registry.fill(HIST("hSelStatusHf"), 6.0); + if (candidate.chi2TopoPiFromXicToPv() < 0 || candidate.chi2TopoPiFromXicToPv() > cuts->get(inputPtBin, "chi2TopoXicToPv")) { + return false; } + registry.fill(HIST("hSelStatusHf"), 7.0); + if (candidate.chi2TopoCascToXic() < 0 || candidate.chi2TopoCascToXic() > cuts->get(inputPtBin, "chi2TopoCascToXic")) { + return false; + } + registry.fill(HIST("hSelStatusHf"), 8.0); - // dcaXY pi <-- cascade to PV cut - if (std::abs(candidate.dcaXYToPvCascDau()) < cuts->get(pTBin, "dcaxyBachToPvMin")) { - resultSelections = false; - registry.fill(HIST("hSelDcaXYToPvPiFromCasc"), 0); + // Decay Length + if (std::abs(candidate.decayLenXYXic()) > cuts->get(inputPtBin, "decayLenXYXic")) { + return false; + } + registry.fill(HIST("hSelStatusHf"), 9.0); + + // ctau + if (std::abs(candidate.cTauXic()) > cuts->get(inputPtBin, "cTauXic")) { + return false; + } + registry.fill(HIST("hSelStatusHf"), 10.0); + } else { + // Impact parameter(DCA?) + if (std::abs(candidate.impactParBachFromCharmBaryonXY()) < impactParXYPiFromCharmBaryonMin || std::abs(candidate.impactParBachFromCharmBaryonXY()) > impactParXYPiFromCharmBaryonMax) { + return false; + } + registry.fill(HIST("hSelStatusHf"), 4.0); + if (std::abs(candidate.impactParBachFromCharmBaryonZ()) < impactParZPiFromCharmBaryonMin || std::abs(candidate.impactParBachFromCharmBaryonZ()) > impactParZPiFromCharmBaryonMax) { + return false; + } + registry.fill(HIST("hSelStatusHf"), 5.0); + } + + // If passes all cuts, return true + return true; + } + + template + void runSelection(TCandTable const& candidates, + TracksSel const&) + { + // looping over charm baryon candidates + for (const auto& candidate : candidates) { + + bool resultSelections = true; // True if the candidate passes all the selections, False otherwise + outputMlXic0ToXiPi.clear(); + + auto trackV0PosDau = candidate.template posTrack_as(); + auto trackV0NegDau = candidate.template negTrack_as(); + auto trackPiFromCasc = candidate.template bachelor_as(); + auto trackPiFromCharm = candidate.template bachelorFromCharmBaryon_as(); + + auto trackPiFromLam = trackV0NegDau; + auto trackPrFromLam = trackV0PosDau; + + int8_t signDecay = candidate.signDecay(); // sign of pi <- cascade + + if (signDecay > 0) { + trackPiFromLam = trackV0PosDau; + trackPrFromLam = trackV0NegDau; + registry.fill(HIST("hSelSignDec"), 1); // anti-particle decay } else { - registry.fill(HIST("hSelDcaXYToPvPiFromCasc"), 1); - } - - // // cut on charm bachelor pion dcaXY and dcaZ - // if ((std::abs(candidate.impactParBachFromCharmBaryonXY()) < cuts->get(pTBin, "impactParXYCharmBachelorMin")) || (std::abs(candidate.impactParBachFromCharmBaryonXY()) > cuts->get(pTBin, "impactParXYCharmBachelorMax"))) { - // resultSelections = false; - // registry.fill(HIST("hSelDCAXYPrimPi"), 0); - // } else { - // registry.fill(HIST("hSelDCAXYPrimPi"), 1); - // } - // if ((std::abs(candidate.impactParBachFromCharmBaryonZ()) < cuts->get(pTBin, "impactParZCharmBachelorMin")) || (std::abs(candidate.impactParBachFromCharmBaryonZ()) > cuts->get(pTBin, "impactParZCharmBachelorMax"))) { - // resultSelections = false; - // registry.fill(HIST("hSelDCAZPrimPi"), 0); - // } else { - // registry.fill(HIST("hSelDCAZPrimPi"), 1); - // } - - // // cut on cascade dcaXY and dcaZ - // if ((std::abs(candidate.impactParCascXY()) < cuts->get(pTBin, "impactParXYCascMin")) || (std::abs(candidate.impactParCascXY()) > cuts->get(pTBin, "impactParXYCascMax"))) { - // resultSelections = false; - // registry.fill(HIST("hSelDCAXYCasc"), 0); - // } else { - // registry.fill(HIST("hSelDCAXYCasc"), 1); - // } - // if ((std::abs(candidate.impactParCascZ()) < cuts->get(pTBin, "impactParZCascMin")) || (std::abs(candidate.impactParCascZ()) > cuts->get(pTBin, "impactParZCascMax"))) { - // resultSelections = false; - // registry.fill(HIST("hSelDCAZCasc"), 0); - // } else { - // registry.fill(HIST("hSelDCAZCasc"), 1); - // } - - // pT selections - double ptPiFromCasc = RecoDecay::sqrtSumOfSquares(candidate.pxBachFromCasc(), candidate.pyBachFromCasc()); - double ptPiFromCharmBaryon = RecoDecay::sqrtSumOfSquares(candidate.pxBachFromCharmBaryon(), candidate.pyBachFromCharmBaryon()); - if (std::abs(ptPiFromCasc) < cuts->get(pTBin, "ptBachelorMin")) { + registry.fill(HIST("hSelSignDec"), 0); // particle decay + } + + // pT selection + auto ptCandXic0 = RecoDecay::pt(candidate.pxCharmBaryon(), candidate.pyCharmBaryon()); + int pTBin = findBin(binsPt, ptCandXic0); + if (pTBin == -1) { resultSelections = false; - registry.fill(HIST("hSelPtPiFromCasc"), 0); - } else { - registry.fill(HIST("hSelPtPiFromCasc"), 1); } - if (std::abs(ptPiFromCharmBaryon) < cuts->get(pTBin, "ptCharmBachelorMin")) { + + // Topological selection + const bool selectionResOnLF = SelectOnLF(candidate, pTBin); + const bool selectionResOnHF = SelectOnHF(candidate, pTBin); + if (!selectionResOnLF || !selectionResOnHF) { resultSelections = false; - registry.fill(HIST("hSelPtPiFromCharm"), 0); - } else { - registry.fill(HIST("hSelPtPiFromCharm"), 1); } // TPC clusters selections + if (resultSelections) { + registry.fill(HIST("hSelStatusCluster"), 0.0); + } if (applyTrkSelLf) { if (!isSelectedTrackTpcQuality(trackPiFromLam, nClustersTpcMin, nTpcCrossedRowsMin, tpcCrossedRowsOverFindableClustersRatioMin, tpcChi2PerClusterMax)) { resultSelections = false; - registry.fill(HIST("hSelTPCQualityPiFromLam"), 0); } else { - registry.fill(HIST("hSelTPCQualityPiFromLam"), 1); + if (resultSelections) { + registry.fill(HIST("hSelStatusCluster"), 1.0); + } } + if (!isSelectedTrackTpcQuality(trackPrFromLam, nClustersTpcMin, nTpcCrossedRowsMin, tpcCrossedRowsOverFindableClustersRatioMin, tpcChi2PerClusterMax)) { resultSelections = false; - registry.fill(HIST("hSelTPCQualityPrFromLam"), 0); } else { - registry.fill(HIST("hSelTPCQualityPrFromLam"), 1); + if (resultSelections) { + registry.fill(HIST("hSelStatusCluster"), 2.0); + } } + if (!isSelectedTrackTpcQuality(trackPiFromCasc, nClustersTpcMin, nTpcCrossedRowsMin, tpcCrossedRowsOverFindableClustersRatioMin, tpcChi2PerClusterMax)) { resultSelections = false; - registry.fill(HIST("hSelTPCQualityPiFromCasc"), 0); } else { - registry.fill(HIST("hSelTPCQualityPiFromCasc"), 1); + if (resultSelections) { + registry.fill(HIST("hSelStatusCluster"), 3.0); + } } } + if (!isSelectedTrackTpcQuality(trackPiFromCharm, nClustersTpcMin, nTpcCrossedRowsMin, tpcCrossedRowsOverFindableClustersRatioMin, tpcChi2PerClusterMax)) { resultSelections = false; - registry.fill(HIST("hSelTPCQualityPiFromCharm"), 0); } else { - registry.fill(HIST("hSelTPCQualityPiFromCharm"), 1); + if (resultSelections) { + registry.fill(HIST("hSelStatusCluster"), 4.0); + } } // ITS clusters selection if (!isSelectedTrackItsQuality(trackPiFromCharm, nClustersItsMin, itsChi2PerClusterMax) || trackPiFromCharm.itsNClsInnerBarrel() < nClustersItsInnBarrMin) { resultSelections = false; - registry.fill(HIST("hSelITSQualityPiFromCharm"), 0); } else { - registry.fill(HIST("hSelITSQualityPiFromCharm"), 1); + if (resultSelections) { + registry.fill(HIST("hSelStatusCluster"), 5.0); + } } - // track-level PID selection - - // for TrackSelectorPID + // Track level PID selection + if (resultSelections) { + registry.fill(HIST("hSelStatusPID"), 0.0); + } int statusPidPrFromLam = -999; int statusPidPiFromLam = -999; int statusPidPiFromCasc = -999; int statusPidPiFromCharmBaryon = -999; - bool statusPidLambda = false; - bool statusPidCascade = false; - bool statusPidCharmBaryon = false; - int infoTpcStored = 0; int infoTofStored = 0; @@ -475,134 +659,70 @@ struct HfCandidateSelectorToXiPiQa { statusPidPiFromCharmBaryon = selectorPion.statusTpcOrTof(trackPiFromCharm); } - if (statusPidPrFromLam == TrackSelectorPID::Accepted && statusPidPiFromLam == TrackSelectorPID::Accepted) { - statusPidLambda = true; - if (resultSelections) { - registry.fill(HIST("hStatusCheck"), 0.5); - } + bool statusPidLambda = (statusPidPrFromLam == TrackSelectorPID::Accepted) && (statusPidPiFromLam == TrackSelectorPID::Accepted); + if (statusPidLambda && resultSelections) { + registry.fill(HIST("hSelStatusPID"), 1.0); } - - if (statusPidPrFromLam == TrackSelectorPID::Accepted && statusPidPiFromLam == TrackSelectorPID::Accepted && statusPidPiFromCasc == TrackSelectorPID::Accepted) { - statusPidCascade = true; - if (resultSelections) { - registry.fill(HIST("hStatusCheck"), 1.5); - } + bool statusPidCascade = (statusPidLambda && statusPidPiFromCasc == TrackSelectorPID::Accepted); + if (statusPidCascade && resultSelections) { + registry.fill(HIST("hSelStatusPID"), 2.0); } - - if (statusPidPrFromLam == TrackSelectorPID::Accepted && statusPidPiFromLam == TrackSelectorPID::Accepted && statusPidPiFromCasc == TrackSelectorPID::Accepted && statusPidPiFromCharmBaryon == TrackSelectorPID::Accepted) { - statusPidCharmBaryon = true; + bool statusPidCharmBaryon = (statusPidCascade && statusPidPiFromCharmBaryon == TrackSelectorPID::Accepted); + if (statusPidCharmBaryon) { if (resultSelections) { - registry.fill(HIST("hStatusCheck"), 2.5); + registry.fill(HIST("hSelStatusPID"), 3.0); } + } else { + resultSelections = false; } // invariant mass cuts - bool statusInvMassLambda = false; - bool statusInvMassCascade = false; - bool statusInvMassCharmBaryon = false; + bool statusInvMassLambda = true; + bool statusInvMassCascade = true; + bool statusInvMassCharmBaryon = true; double invMassLambda = candidate.invMassLambda(); double invMassCascade = candidate.invMassCascade(); double invMassCharmBaryon = candidate.invMassCharmBaryon(); - if (std::abs(invMassLambda - massLambdaFromPDG) < cuts->get(pTBin, "massWindowV0")) { - statusInvMassLambda = true; - registry.fill(HIST("hSelMassLam"), 1); - if (statusPidLambda && statusPidCascade && statusPidCharmBaryon && resultSelections) { - registry.fill(HIST("hStatusCheck"), 3.5); - } - } else { - registry.fill(HIST("hSelMassLam"), 0); + if ((invMassLambda - o2::constants::physics::MassLambda0) > v0MassWindow) { + statusInvMassLambda = false; } - - if (std::abs(invMassCascade - massXiFromPDG) < cuts->get(pTBin, "massWindowCascade")) { - statusInvMassCascade = true; - registry.fill(HIST("hSelMassCasc"), 1); - if (statusPidLambda && statusPidCascade && statusPidCharmBaryon && statusInvMassLambda && resultSelections) { - registry.fill(HIST("hStatusCheck"), 4.5); - } - } else { - registry.fill(HIST("hSelMassCasc"), 0); + if ((invMassCascade - o2::constants::physics::MassXiMinus) > cascMassWindow) { + statusInvMassCascade = false; + } + if ((invMassCharmBaryon < invMassCharmBaryonMin) || (invMassCharmBaryon > invMassCharmBaryonMax)) { + statusInvMassCharmBaryon = false; } - if ((invMassCharmBaryon >= cuts->get(pTBin, "mCharmBaryonMin")) && (invMassCharmBaryon <= cuts->get(pTBin, "mCharmBaryonMax"))) { - statusInvMassCharmBaryon = true; - registry.fill(HIST("hSelMassCharmBaryon"), 1); - if (statusPidLambda && statusPidCascade && statusPidCharmBaryon && statusInvMassLambda && statusInvMassCascade && resultSelections) { - registry.fill(HIST("hStatusCheck"), 5.5); + // ML BDT selection + if (applyMl) { + bool isSelectedMlXic0 = false; + std::vector inputFeaturesXic0 = {}; + if constexpr (svReco == doDcaFitter) { + inputFeaturesXic0 = hfMlResponseDca.getInputFeatures(candidate, trackPiFromLam, trackPiFromCasc, trackPiFromCharm); + isSelectedMlXic0 = hfMlResponseDca.isSelectedMl(inputFeaturesXic0, ptCandXic0, outputMlXic0ToXiPi); + } else { + inputFeaturesXic0 = hfMlResponseKf.getInputFeatures(candidate, trackPiFromLam, trackPiFromCasc, trackPiFromCharm); + isSelectedMlXic0 = hfMlResponseKf.isSelectedMl(inputFeaturesXic0, ptCandXic0, outputMlXic0ToXiPi); } - } else { - registry.fill(HIST("hSelMassCharmBaryon"), 0); + if (!isSelectedMlXic0) { + continue; + } + hfMlToXiPi(outputMlXic0ToXiPi); } // Fill in selection result - if constexpr (dokf == false) { + if constexpr (svReco == doDcaFitter) { hfSelToXiPi(statusPidLambda, statusPidCascade, statusPidCharmBaryon, statusInvMassLambda, statusInvMassCascade, statusInvMassCharmBaryon, resultSelections, infoTpcStored, infoTofStored, trackPiFromCharm.tpcNSigmaPi(), trackPiFromCasc.tpcNSigmaPi(), trackPiFromLam.tpcNSigmaPi(), trackPrFromLam.tpcNSigmaPr(), trackPiFromCharm.tofNSigmaPi(), trackPiFromCasc.tofNSigmaPi(), trackPiFromLam.tofNSigmaPi(), trackPrFromLam.tofNSigmaPr()); } else { - // ML selections -> Currently, no Ml for DCAFitter result is implemented - if (applyMl) { - bool isSelectedMlXic0 = false; - std::vector inputFeaturesXic0 = hfMlResponse.getInputFeatures(candidate, trackPiFromLam, trackPiFromCasc, trackPiFromCharm); - isSelectedMlXic0 = hfMlResponse.isSelectedMl(inputFeaturesXic0, ptCandXic0, outputMlXic0ToXiPiKf); - if (!isSelectedMlXic0) { - continue; - } - hfMlToXiPiKf(outputMlXic0ToXiPiKf); - } - - // Set result of selection to false if one of the statusPID or statusInvMass is false - // This is required because selection table for KF does not store any information about statusPID or statusInvMass while DCAFitter does. - if (!(statusPidLambda && statusPidCascade && statusPidCharmBaryon && statusInvMassCharmBaryon && statusInvMassCascade && statusInvMassLambda)) { - resultSelections = false; - } - hfSelToXiPiKf(resultSelections, - // statusPidCharmBaryon, statusPidCascade, statusPidLambda, statusInvMassCharmBaryon, statusInvMassCascade, statusInvMassLambda, infoTpcStored, infoTofStored, trackPiFromCharm.tpcNSigmaPi(), trackPiFromCasc.tpcNSigmaPi(), trackPiFromLam.tpcNSigmaPi(), trackPrFromLam.tpcNSigmaPr(), trackPiFromCharm.tofNSigmaPi(), trackPiFromCasc.tofNSigmaPi(), trackPiFromLam.tofNSigmaPi(), trackPrFromLam.tofNSigmaPr()); } - if (resultSelections) { - if (!statusPidLambda) { - registry.fill(HIST("hSelPID"), 0.5); - } - if (statusPidLambda) { - registry.fill(HIST("hSelPID"), 1.5); - } - if (!statusPidCascade) { - registry.fill(HIST("hSelPID"), 2.5); - } - if (statusPidCascade) { - registry.fill(HIST("hSelPID"), 3.5); - } - if (!statusPidCharmBaryon) { - registry.fill(HIST("hSelPID"), 4.5); - } - if (statusPidCharmBaryon) { - registry.fill(HIST("hSelPID"), 5.5); - } - if (!statusInvMassLambda) { - registry.fill(HIST("hSelPID"), 6.5); - } - if (statusInvMassLambda) { - registry.fill(HIST("hSelPID"), 7.5); - } - if (!statusInvMassCascade) { - registry.fill(HIST("hSelPID"), 8.5); - } - if (statusInvMassCascade) { - registry.fill(HIST("hSelPID"), 9.5); - } - if (!statusInvMassCharmBaryon) { - registry.fill(HIST("hSelPID"), 10.5); - } - if (statusInvMassCharmBaryon) { - registry.fill(HIST("hSelPID"), 11.5); - } - } - // Fill in invariant mass histogram if (statusPidLambda && statusPidCascade && statusPidCharmBaryon && statusInvMassLambda && statusInvMassCascade && statusInvMassCharmBaryon && resultSelections) { registry.fill(HIST("hInvMassCharmBaryon"), invMassCharmBaryon); @@ -618,7 +738,7 @@ struct HfCandidateSelectorToXiPiQa { /////////////////////////////////// void processSelectionDCAFitter(aod::HfCandToXiPi const& candidates, TracksSel const& tracks) { - runSelection(candidates, tracks); + runSelection(candidates, tracks); } PROCESS_SWITCH(HfCandidateSelectorToXiPiQa, processSelectionDCAFitter, "Xic0 candidate selection with DCAFitter output", true); @@ -627,7 +747,7 @@ struct HfCandidateSelectorToXiPiQa { //////////////////////////////////// void processSelectionKFParticle(aod::HfCandToXiPiKf const& candidates, TracksSel const& tracks) { - runSelection(candidates, tracks); + runSelection(candidates, tracks); } PROCESS_SWITCH(HfCandidateSelectorToXiPiQa, processSelectionKFParticle, "Xic0 candidate selection with KFParticle output", false); diff --git a/PWGHF/TableProducer/treeCreatorToXiPiQa.cxx b/PWGHF/TableProducer/treeCreatorToXiPiQa.cxx index 6df52b8d01e..72f2b9b7c71 100644 --- a/PWGHF/TableProducer/treeCreatorToXiPiQa.cxx +++ b/PWGHF/TableProducer/treeCreatorToXiPiQa.cxx @@ -39,6 +39,18 @@ using namespace o2; using namespace o2::framework; +// SV Reco method +enum { + DCAFITTER = 0, + KFPARTICLE +}; + +// Table size +enum { + FULL = 0, + LITE +}; + namespace o2::aod { namespace full @@ -327,297 +339,271 @@ struct HfTreeCreatorToXiPiQa { rowEv(collision.sel8(), std::abs(collision.posZ()) < cutZPv); } - template + template void fillCandidate(const T& candidate, int8_t flagMc, int8_t debugMc, int8_t originMc, bool collisionMatched) { - - // Save all candidate information - float centrality = -999.f; - if constexpr (useCentrality) { - auto const& collision = candidate.template collision_as(); - centrality = o2::hf_centrality::getCentralityColl(collision); - } - - rowCandidateFull( - candidate.xPv(), - candidate.yPv(), - candidate.zPv(), - centrality, - candidate.template collision_as().numContrib(), - candidate.template collision_as().chi2(), - candidate.xDecayVtxCharmBaryon(), - candidate.yDecayVtxCharmBaryon(), - candidate.zDecayVtxCharmBaryon(), - candidate.xDecayVtxCascade(), - candidate.yDecayVtxCascade(), - candidate.zDecayVtxCascade(), - candidate.xDecayVtxV0(), - candidate.yDecayVtxV0(), - candidate.zDecayVtxV0(), - candidate.signDecay(), - candidate.covVtxCharmBaryon0(), - candidate.covVtxCharmBaryon3(), - candidate.covVtxCharmBaryon5(), - candidate.pxCharmBaryon(), - candidate.pyCharmBaryon(), - candidate.pzCharmBaryon(), - candidate.pxCasc(), - candidate.pyCasc(), - candidate.pzCasc(), - candidate.pxBachFromCharmBaryon(), - candidate.pyBachFromCharmBaryon(), - candidate.pzBachFromCharmBaryon(), - candidate.pxLambda(), - candidate.pyLambda(), - candidate.pzLambda(), - candidate.pxBachFromCasc(), - candidate.pyBachFromCasc(), - candidate.pzBachFromCasc(), - candidate.pxPosV0Dau(), - candidate.pyPosV0Dau(), - candidate.pzPosV0Dau(), - candidate.pxNegV0Dau(), - candidate.pyNegV0Dau(), - candidate.pzNegV0Dau(), - candidate.impactParCascXY(), - candidate.impactParBachFromCharmBaryonXY(), - candidate.impactParCascZ(), - candidate.impactParBachFromCharmBaryonZ(), - candidate.errImpactParCascXY(), - candidate.errImpactParBachFromCharmBaryonXY(), - candidate.invMassLambda(), - candidate.invMassCascade(), - candidate.invMassCharmBaryon(), - candidate.cosPAV0(), - candidate.cosPACharmBaryon(), - candidate.cosPACasc(), - candidate.cosPAXYV0(), - candidate.cosPAXYCharmBaryon(), - candidate.cosPAXYCasc(), - candidate.cTauOmegac(), - candidate.cTauCascade(), - candidate.cTauV0(), - candidate.cTauXic(), - candidate.etaV0PosDau(), - candidate.etaV0NegDau(), - candidate.etaBachFromCasc(), - candidate.etaBachFromCharmBaryon(), - candidate.etaCharmBaryon(), - candidate.etaCascade(), - candidate.etaV0(), - candidate.dcaXYToPvV0Dau0(), - candidate.dcaXYToPvV0Dau1(), - candidate.dcaXYToPvCascDau(), - candidate.dcaZToPvV0Dau0(), - candidate.dcaZToPvV0Dau1(), - candidate.dcaZToPvCascDau(), - candidate.dcaCascDau(), - candidate.dcaV0Dau(), - candidate.dcaCharmBaryonDau(), - candidate.decLenCharmBaryon(), - candidate.decLenCascade(), - candidate.decLenV0(), - candidate.errorDecayLengthCharmBaryon(), - candidate.errorDecayLengthXYCharmBaryon(), - candidate.impactParCascXY() / candidate.errImpactParCascXY(), - candidate.impactParBachFromCharmBaryonXY() / candidate.errImpactParBachFromCharmBaryonXY(), - candidate.decLenCharmBaryon() / candidate.errorDecayLengthCharmBaryon(), - candidate.template bachelorFromCharmBaryon_as().isGlobalTrackWoDCA(), - candidate.template bachelorFromCharmBaryon_as().itsNCls(), - candidate.template bachelorFromCharmBaryon_as().tpcNClsCrossedRows(), - candidate.template bachelor_as().tpcNClsCrossedRows(), - candidate.template posTrack_as().tpcNClsCrossedRows(), - candidate.template negTrack_as().tpcNClsCrossedRows(), - candidate.statusPidLambda(), - candidate.statusPidCascade(), - candidate.statusPidCharmBaryon(), - candidate.statusInvMassLambda(), - candidate.statusInvMassCascade(), - candidate.statusInvMassCharmBaryon(), - candidate.resultSelections(), - candidate.pidTpcInfoStored(), - candidate.pidTofInfoStored(), - candidate.tpcNSigmaPiFromCharmBaryon(), - candidate.tpcNSigmaPiFromCasc(), - candidate.tpcNSigmaPiFromLambda(), - candidate.tpcNSigmaPrFromLambda(), - candidate.tofNSigmaPiFromCharmBaryon(), - candidate.tofNSigmaPiFromCasc(), - candidate.tofNSigmaPiFromLambda(), - candidate.tofNSigmaPrFromLambda(), - flagMc, - debugMc, - originMc, - collisionMatched); - } - - template - void fillCandidateLite(const T& candidate, int8_t flagMc, int8_t originMc, bool collisionMatched) - { + // save all candidate information float centrality = -999.f; if constexpr (useCentrality) { - auto const& collision = candidate.template collision_as(); + const auto& collision = candidate.template collision_as(); centrality = o2::hf_centrality::getCentralityColl(collision); } - rowCandidateLite( - candidate.xPv(), - candidate.yPv(), - candidate.zPv(), - centrality, - candidate.template collision_as().numContrib(), - candidate.template collision_as().chi2(), - candidate.xDecayVtxCharmBaryon(), - candidate.yDecayVtxCharmBaryon(), - candidate.zDecayVtxCharmBaryon(), - candidate.xDecayVtxCascade(), - candidate.yDecayVtxCascade(), - candidate.zDecayVtxCascade(), - candidate.xDecayVtxV0(), - candidate.yDecayVtxV0(), - candidate.zDecayVtxV0(), - candidate.signDecay(), - candidate.pxCharmBaryon(), - candidate.pyCharmBaryon(), - candidate.pzCharmBaryon(), - candidate.pxBachFromCharmBaryon(), - candidate.pyBachFromCharmBaryon(), - candidate.pzBachFromCharmBaryon(), - candidate.pxBachFromCasc(), - candidate.pyBachFromCasc(), - candidate.pzBachFromCasc(), - candidate.pxPosV0Dau(), - candidate.pyPosV0Dau(), - candidate.pzPosV0Dau(), - candidate.pxNegV0Dau(), - candidate.pyNegV0Dau(), - candidate.pzNegV0Dau(), - candidate.impactParCascXY(), - candidate.impactParBachFromCharmBaryonXY(), - candidate.errImpactParCascXY(), - candidate.errImpactParBachFromCharmBaryonXY(), - candidate.invMassLambda(), - candidate.invMassCascade(), - candidate.invMassCharmBaryon(), - candidate.etaV0PosDau(), - candidate.etaV0NegDau(), - candidate.etaBachFromCasc(), - candidate.etaBachFromCharmBaryon(), - candidate.dcaXYToPvV0Dau0(), - candidate.dcaXYToPvV0Dau1(), - candidate.dcaXYToPvCascDau(), - candidate.dcaCascDau(), - candidate.dcaV0Dau(), - candidate.dcaCharmBaryonDau(), - candidate.errorDecayLengthCharmBaryon(), - candidate.impactParCascXY() / candidate.errImpactParCascXY(), - candidate.impactParBachFromCharmBaryonXY() / candidate.errImpactParBachFromCharmBaryonXY(), - candidate.template bachelorFromCharmBaryon_as().isGlobalTrackWoDCA(), - candidate.template bachelorFromCharmBaryon_as().itsNCls(), - candidate.template bachelorFromCharmBaryon_as().tpcNClsCrossedRows(), - candidate.template bachelor_as().tpcNClsCrossedRows(), - candidate.template posTrack_as().tpcNClsCrossedRows(), - candidate.template negTrack_as().tpcNClsCrossedRows(), - candidate.statusPidLambda(), - candidate.statusPidCascade(), - candidate.statusPidCharmBaryon(), - candidate.statusInvMassLambda(), - candidate.statusInvMassCascade(), - candidate.statusInvMassCharmBaryon(), - candidate.resultSelections(), - candidate.pidTpcInfoStored(), - candidate.pidTofInfoStored(), - candidate.tpcNSigmaPiFromCharmBaryon(), - candidate.tpcNSigmaPiFromCasc(), - candidate.tpcNSigmaPiFromLambda(), - candidate.tpcNSigmaPrFromLambda(), - candidate.tofNSigmaPiFromCharmBaryon(), - candidate.tofNSigmaPiFromCasc(), - candidate.tofNSigmaPiFromLambda(), - candidate.tofNSigmaPrFromLambda(), - flagMc, - originMc, - collisionMatched); - } - - template - void fillKfCandidate(const T& candidate, int8_t flagMc, int8_t debugMc, int8_t originMc, bool collisionMatched) - { - float centrality = -999.f; - if constexpr (useCentrality) { - auto const& collision = candidate.template collision_as(); - centrality = o2::hf_centrality::getCentralityColl(collision); + if constexpr (svReco == DCAFITTER) { + if constexpr (tableSize == LITE) { + rowCandidateLite(candidate.xPv(), + candidate.yPv(), + candidate.zPv(), + centrality, + candidate.template collision_as().numContrib(), + candidate.template collision_as().chi2(), + candidate.xDecayVtxCharmBaryon(), + candidate.yDecayVtxCharmBaryon(), + candidate.zDecayVtxCharmBaryon(), + candidate.xDecayVtxCascade(), + candidate.yDecayVtxCascade(), + candidate.zDecayVtxCascade(), + candidate.xDecayVtxV0(), + candidate.yDecayVtxV0(), + candidate.zDecayVtxV0(), + candidate.signDecay(), + candidate.pxCharmBaryon(), + candidate.pyCharmBaryon(), + candidate.pzCharmBaryon(), + candidate.pxBachFromCharmBaryon(), + candidate.pyBachFromCharmBaryon(), + candidate.pzBachFromCharmBaryon(), + candidate.pxBachFromCasc(), + candidate.pyBachFromCasc(), + candidate.pzBachFromCasc(), + candidate.pxPosV0Dau(), + candidate.pyPosV0Dau(), + candidate.pzPosV0Dau(), + candidate.pxNegV0Dau(), + candidate.pyNegV0Dau(), + candidate.pzNegV0Dau(), + candidate.impactParCascXY(), + candidate.impactParBachFromCharmBaryonXY(), + candidate.errImpactParCascXY(), + candidate.errImpactParBachFromCharmBaryonXY(), + candidate.invMassLambda(), + candidate.invMassCascade(), + candidate.invMassCharmBaryon(), + candidate.etaV0PosDau(), + candidate.etaV0NegDau(), + candidate.etaBachFromCasc(), + candidate.etaBachFromCharmBaryon(), + candidate.dcaXYToPvV0Dau0(), + candidate.dcaXYToPvV0Dau1(), + candidate.dcaXYToPvCascDau(), + candidate.dcaCascDau(), + candidate.dcaV0Dau(), + candidate.dcaCharmBaryonDau(), + candidate.errorDecayLengthCharmBaryon(), + candidate.impactParCascXY() / candidate.errImpactParCascXY(), + candidate.impactParBachFromCharmBaryonXY() / candidate.errImpactParBachFromCharmBaryonXY(), + candidate.template bachelorFromCharmBaryon_as().isGlobalTrackWoDCA(), + candidate.template bachelorFromCharmBaryon_as().itsNCls(), + candidate.template bachelorFromCharmBaryon_as().tpcNClsCrossedRows(), + candidate.template bachelor_as().tpcNClsCrossedRows(), + candidate.template posTrack_as().tpcNClsCrossedRows(), + candidate.template negTrack_as().tpcNClsCrossedRows(), + candidate.statusPidLambda(), + candidate.statusPidCascade(), + candidate.statusPidCharmBaryon(), + candidate.statusInvMassLambda(), + candidate.statusInvMassCascade(), + candidate.statusInvMassCharmBaryon(), + candidate.resultSelections(), + candidate.pidTpcInfoStored(), + candidate.pidTofInfoStored(), + candidate.tpcNSigmaPiFromCharmBaryon(), + candidate.tpcNSigmaPiFromCasc(), + candidate.tpcNSigmaPiFromLambda(), + candidate.tpcNSigmaPrFromLambda(), + candidate.tofNSigmaPiFromCharmBaryon(), + candidate.tofNSigmaPiFromCasc(), + candidate.tofNSigmaPiFromLambda(), + candidate.tofNSigmaPrFromLambda(), + flagMc, + originMc, + collisionMatched); + } else { + rowCandidateFull(candidate.xPv(), + candidate.yPv(), + candidate.zPv(), + centrality, + candidate.template collision_as().numContrib(), + candidate.template collision_as().chi2(), + candidate.xDecayVtxCharmBaryon(), + candidate.yDecayVtxCharmBaryon(), + candidate.zDecayVtxCharmBaryon(), + candidate.xDecayVtxCascade(), + candidate.yDecayVtxCascade(), + candidate.zDecayVtxCascade(), + candidate.xDecayVtxV0(), + candidate.yDecayVtxV0(), + candidate.zDecayVtxV0(), + candidate.signDecay(), + candidate.covVtxCharmBaryon0(), + candidate.covVtxCharmBaryon3(), + candidate.covVtxCharmBaryon5(), + candidate.pxCharmBaryon(), + candidate.pyCharmBaryon(), + candidate.pzCharmBaryon(), + candidate.pxCasc(), + candidate.pyCasc(), + candidate.pzCasc(), + candidate.pxBachFromCharmBaryon(), + candidate.pyBachFromCharmBaryon(), + candidate.pzBachFromCharmBaryon(), + candidate.pxLambda(), + candidate.pyLambda(), + candidate.pzLambda(), + candidate.pxBachFromCasc(), + candidate.pyBachFromCasc(), + candidate.pzBachFromCasc(), + candidate.pxPosV0Dau(), + candidate.pyPosV0Dau(), + candidate.pzPosV0Dau(), + candidate.pxNegV0Dau(), + candidate.pyNegV0Dau(), + candidate.pzNegV0Dau(), + candidate.impactParCascXY(), + candidate.impactParBachFromCharmBaryonXY(), + candidate.impactParCascZ(), + candidate.impactParBachFromCharmBaryonZ(), + candidate.errImpactParCascXY(), + candidate.errImpactParBachFromCharmBaryonXY(), + candidate.invMassLambda(), + candidate.invMassCascade(), + candidate.invMassCharmBaryon(), + candidate.cosPAV0(), + candidate.cosPACharmBaryon(), + candidate.cosPACasc(), + candidate.cosPAXYV0(), + candidate.cosPAXYCharmBaryon(), + candidate.cosPAXYCasc(), + candidate.cTauOmegac(), + candidate.cTauCascade(), + candidate.cTauV0(), + candidate.cTauXic(), + candidate.etaV0PosDau(), + candidate.etaV0NegDau(), + candidate.etaBachFromCasc(), + candidate.etaBachFromCharmBaryon(), + candidate.etaCharmBaryon(), + candidate.etaCascade(), + candidate.etaV0(), + candidate.dcaXYToPvV0Dau0(), + candidate.dcaXYToPvV0Dau1(), + candidate.dcaXYToPvCascDau(), + candidate.dcaZToPvV0Dau0(), + candidate.dcaZToPvV0Dau1(), + candidate.dcaZToPvCascDau(), + candidate.dcaCascDau(), + candidate.dcaV0Dau(), + candidate.dcaCharmBaryonDau(), + candidate.decLenCharmBaryon(), + candidate.decLenCascade(), + candidate.decLenV0(), + candidate.errorDecayLengthCharmBaryon(), + candidate.errorDecayLengthXYCharmBaryon(), + candidate.impactParCascXY() / candidate.errImpactParCascXY(), + candidate.impactParBachFromCharmBaryonXY() / candidate.errImpactParBachFromCharmBaryonXY(), + candidate.decLenCharmBaryon() / candidate.errorDecayLengthCharmBaryon(), + candidate.template bachelorFromCharmBaryon_as().isGlobalTrackWoDCA(), + candidate.template bachelorFromCharmBaryon_as().itsNCls(), + candidate.template bachelorFromCharmBaryon_as().tpcNClsCrossedRows(), + candidate.template bachelor_as().tpcNClsCrossedRows(), + candidate.template posTrack_as().tpcNClsCrossedRows(), + candidate.template negTrack_as().tpcNClsCrossedRows(), + candidate.statusPidLambda(), + candidate.statusPidCascade(), + candidate.statusPidCharmBaryon(), + candidate.statusInvMassLambda(), + candidate.statusInvMassCascade(), + candidate.statusInvMassCharmBaryon(), + candidate.resultSelections(), + candidate.pidTpcInfoStored(), + candidate.pidTofInfoStored(), + candidate.tpcNSigmaPiFromCharmBaryon(), + candidate.tpcNSigmaPiFromCasc(), + candidate.tpcNSigmaPiFromLambda(), + candidate.tpcNSigmaPrFromLambda(), + candidate.tofNSigmaPiFromCharmBaryon(), + candidate.tofNSigmaPiFromCasc(), + candidate.tofNSigmaPiFromLambda(), + candidate.tofNSigmaPrFromLambda(), + flagMc, + debugMc, + originMc, + collisionMatched); + } + } else { + if constexpr (tableSize == LITE) { + // currently, no lite sized table for KFParticle + } else { + rowKfCandidate(centrality, + candidate.resultSelections(), + candidate.tpcNSigmaPiFromCharmBaryon(), + candidate.tofNSigmaPiFromCharmBaryon(), + candidate.tpcNSigmaPiFromCasc(), + candidate.tofNSigmaPiFromCasc(), + candidate.tpcNSigmaPiFromLambda(), + candidate.tofNSigmaPiFromLambda(), + candidate.tpcNSigmaPrFromLambda(), + candidate.tofNSigmaPrFromLambda(), + candidate.kfDcaXYPiFromXic(), + candidate.dcaCascDau(), + candidate.dcaCharmBaryonDau(), + candidate.kfDcaXYCascToPv(), + candidate.dcaXYToPvV0Dau0(), + candidate.dcaXYToPvV0Dau1(), + candidate.dcaXYToPvCascDau(), + candidate.chi2GeoV0(), + candidate.chi2GeoCasc(), + candidate.chi2GeoXic(), + candidate.chi2MassV0(), + candidate.chi2MassCasc(), + candidate.v0ldl(), + candidate.cascldl(), + candidate.chi2TopoV0ToPv(), + candidate.chi2TopoCascToPv(), + candidate.chi2TopoPiFromXicToPv(), + candidate.chi2TopoXicToPv(), + candidate.chi2TopoV0ToCasc(), + candidate.chi2TopoCascToXic(), + candidate.decayLenXYLambda(), + candidate.decayLenXYCasc(), + candidate.decayLenXYXic(), + candidate.cosPaV0ToCasc(), + candidate.cosPAV0(), + candidate.cosPaCascToXic(), + candidate.cosPACasc(), + candidate.invMassLambda(), + candidate.invMassCascade(), + candidate.invMassCharmBaryon(), + candidate.kfRapXic(), + candidate.cosThetaStarPiFromXic(), + candidate.cTauXic(), + candidate.etaCharmBaryon(), + candidate.v0Ndf(), + candidate.cascNdf(), + candidate.xicNdf(), + candidate.massV0Ndf(), + candidate.massCascNdf(), + candidate.v0Chi2OverNdf(), + candidate.cascChi2OverNdf(), + candidate.xicChi2OverNdf(), + candidate.massV0Chi2OverNdf(), + candidate.massCascChi2OverNdf(), + flagMc, + debugMc, + originMc, + collisionMatched); + } } - - rowKfCandidate( - centrality, - // candidate.statusPidLambda(), - // candidate.statusPidCascade(), - // candidate.statusPidCharmBaryon(), - // candidate.statusInvMassLambda(), - // candidate.statusInvMassCascade(), - // candidate.statusInvMassCharmBaryon(), - candidate.resultSelections(), - candidate.tpcNSigmaPiFromCharmBaryon(), - candidate.tofNSigmaPiFromCharmBaryon(), - candidate.tpcNSigmaPiFromCasc(), - candidate.tofNSigmaPiFromCasc(), - candidate.tpcNSigmaPiFromLambda(), - candidate.tofNSigmaPiFromLambda(), - candidate.tpcNSigmaPrFromLambda(), - candidate.tofNSigmaPrFromLambda(), - candidate.kfDcaXYPiFromXic(), - candidate.dcaCascDau(), - candidate.dcaCharmBaryonDau(), - candidate.kfDcaXYCascToPv(), - candidate.dcaXYToPvV0Dau0(), - candidate.dcaXYToPvV0Dau1(), - candidate.dcaXYToPvCascDau(), - candidate.chi2GeoV0(), - candidate.chi2GeoCasc(), - candidate.chi2GeoXic(), - candidate.chi2MassV0(), - candidate.chi2MassCasc(), - candidate.v0ldl(), - candidate.cascldl(), - // candidate.xicldl(), - candidate.chi2TopoV0ToPv(), - candidate.chi2TopoCascToPv(), - candidate.chi2TopoPiFromXicToPv(), - candidate.chi2TopoXicToPv(), - candidate.chi2TopoV0ToCasc(), - candidate.chi2TopoCascToXic(), - candidate.decayLenXYLambda(), - candidate.decayLenXYCasc(), - candidate.decayLenXYXic(), - candidate.cosPaV0ToCasc(), - candidate.cosPAV0(), - candidate.cosPaCascToXic(), - candidate.cosPACasc(), - // candidate.cosPACharmBaryon(), - candidate.invMassLambda(), - candidate.invMassCascade(), - candidate.invMassCharmBaryon(), - candidate.kfRapXic(), - // candidate.kfptPiFromXic(), - // candidate.kfptXic(), - candidate.cosThetaStarPiFromXic(), - candidate.cTauXic(), - candidate.etaCharmBaryon(), - candidate.v0Ndf(), - candidate.cascNdf(), - candidate.xicNdf(), - candidate.massV0Ndf(), - candidate.massCascNdf(), - candidate.v0Chi2OverNdf(), - candidate.cascChi2OverNdf(), - candidate.xicChi2OverNdf(), - candidate.massV0Chi2OverNdf(), - candidate.massCascChi2OverNdf(), - flagMc, - debugMc, - originMc, - collisionMatched); } //////////////////////////////////// @@ -642,7 +628,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowCandidateFull.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillCandidate(candidate, -7, -7, RecoDecay::OriginType::None, false); + fillCandidate(candidate, -7, -7, RecoDecay::OriginType::None, false); } } @@ -658,7 +644,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowCandidateLite.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillCandidateLite(candidate, -7, RecoDecay::OriginType::None, false); + fillCandidate(candidate, -7, -7, RecoDecay::OriginType::None, false); } } @@ -674,7 +660,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowCandidateLite.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillCandidateLite(candidate, -7, RecoDecay::OriginType::None, false); + fillCandidate(candidate, -7, -7, RecoDecay::OriginType::None, false); } } @@ -690,7 +676,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowCandidateLite.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillCandidateLite(candidate, -7, RecoDecay::OriginType::None, false); + fillCandidate(candidate, -7, -7, RecoDecay::OriginType::None, false); } } @@ -706,7 +692,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowCandidateLite.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillCandidateLite(candidate, -7, RecoDecay::OriginType::None, false); + fillCandidate(candidate, -7, -7, RecoDecay::OriginType::None, false); } } @@ -731,7 +717,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowKfCandidate.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillKfCandidate(candidate, -7, -7, RecoDecay::OriginType::None, false); + fillCandidate(candidate, -7, -7, RecoDecay::OriginType::None, false); } } @@ -747,7 +733,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowKfCandidate.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillKfCandidate(candidate, -7, -7, RecoDecay::OriginType::None, false); + fillCandidate(candidate, -7, -7, RecoDecay::OriginType::None, false); } } @@ -763,7 +749,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowKfCandidate.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillKfCandidate(candidate, -7, -7, RecoDecay::OriginType::None, false); + fillCandidate(candidate, -7, -7, RecoDecay::OriginType::None, false); } } @@ -779,7 +765,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowKfCandidate.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillKfCandidate(candidate, -7, -7, RecoDecay::OriginType::None, false); + fillCandidate(candidate, -7, -7, RecoDecay::OriginType::None, false); } } @@ -787,6 +773,7 @@ struct HfTreeCreatorToXiPiQa { PROCESS_SWITCH(HfTreeCreatorToXiPiQa, processKfDataWithFT0M, "Process KF data, with FT0M", false); PROCESS_SWITCH(HfTreeCreatorToXiPiQa, processKfDataWithFT0C, "Process KF data, with FT0C", false); PROCESS_SWITCH(HfTreeCreatorToXiPiQa, processKfDataWithNTracksPV, "Process KF data, with NTracksPV", false); + //*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*// //*~~~~~~~MC with DCAFitter~~~~~~~~*// //*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*// @@ -803,7 +790,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowCandidateFull.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillCandidate(candidate, candidate.flagMcMatchRec(), candidate.debugMcRec(), candidate.originMcRec(), candidate.collisionMatched()); + fillCandidate(candidate, candidate.flagMcMatchRec(), candidate.debugMcRec(), candidate.originMcRec(), candidate.collisionMatched()); } } @@ -819,7 +806,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowCandidateFull.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillCandidate(candidate, candidate.flagMcMatchRec(), candidate.debugMcRec(), candidate.originMcRec(), candidate.collisionMatched()); + fillCandidate(candidate, candidate.flagMcMatchRec(), candidate.debugMcRec(), candidate.originMcRec(), candidate.collisionMatched()); } } @@ -835,7 +822,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowCandidateLite.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillCandidateLite(candidate, candidate.flagMcMatchRec(), candidate.originMcRec(), candidate.collisionMatched()); + fillCandidate(candidate, candidate.flagMcMatchRec(), -7, candidate.originMcRec(), candidate.collisionMatched()); } } @@ -851,7 +838,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowCandidateLite.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillCandidateLite(candidate, candidate.flagMcMatchRec(), candidate.originMcRec(), candidate.collisionMatched()); + fillCandidate(candidate, candidate.flagMcMatchRec(), -7, candidate.originMcRec(), candidate.collisionMatched()); } } @@ -867,7 +854,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowCandidateLite.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillCandidateLite(candidate, candidate.flagMcMatchRec(), candidate.originMcRec(), candidate.collisionMatched()); + fillCandidate(candidate, candidate.flagMcMatchRec(), -7, candidate.originMcRec(), candidate.collisionMatched()); } } @@ -883,7 +870,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowCandidateLite.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillCandidateLite(candidate, candidate.flagMcMatchRec(), candidate.originMcRec(), candidate.collisionMatched()); + fillCandidate(candidate, candidate.flagMcMatchRec(), -7, candidate.originMcRec(), candidate.collisionMatched()); } } @@ -899,7 +886,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowCandidateLite.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillCandidateLite(candidate, candidate.flagMcMatchRec(), candidate.originMcRec(), candidate.collisionMatched()); + fillCandidate(candidate, candidate.flagMcMatchRec(), -7, candidate.originMcRec(), candidate.collisionMatched()); } } @@ -926,7 +913,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowKfCandidate.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillKfCandidate(candidate, candidate.flagMcMatchRec(), candidate.debugMcRec(), candidate.originMcRec(), candidate.collisionMatched()); + fillCandidate(candidate, candidate.flagMcMatchRec(), candidate.debugMcRec(), candidate.originMcRec(), candidate.collisionMatched()); } } @@ -942,7 +929,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowKfCandidate.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillKfCandidate(candidate, candidate.flagMcMatchRec(), candidate.debugMcRec(), candidate.originMcRec(), candidate.collisionMatched()); + fillCandidate(candidate, candidate.flagMcMatchRec(), candidate.debugMcRec(), candidate.originMcRec(), candidate.collisionMatched()); } } @@ -958,7 +945,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate properties rowKfCandidate.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillKfCandidate(candidate, candidate.flagMcMatchRec(), candidate.debugMcRec(), candidate.originMcRec(), candidate.collisionMatched()); + fillCandidate(candidate, candidate.flagMcMatchRec(), candidate.debugMcRec(), candidate.originMcRec(), candidate.collisionMatched()); } } @@ -974,7 +961,7 @@ struct HfTreeCreatorToXiPiQa { // Filling candidate table rowKfCandidate.reserve(candidates.size()); for (const auto& candidate : candidates) { - fillKfCandidate(candidate, candidate.flagMcMatchRec(), candidate.debugMcRec(), candidate.originMcRec(), candidate.collisionMatched()); + fillCandidate(candidate, candidate.flagMcMatchRec(), candidate.debugMcRec(), candidate.originMcRec(), candidate.collisionMatched()); } }