From 61430d94d5ccb99c3374b3aea9fddcc99df8c59e Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Fri, 8 Dec 2023 17:57:57 +0100 Subject: [PATCH 01/35] First draft of Xicplus workflow --- .../DataModel/CandidateReconstructionTables.h | 142 ++++++++++++++++++ PWGHF/TableProducer/CMakeLists.txt | 5 + 2 files changed, 147 insertions(+) diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index 6c1b4d50356..9fc0607b2c9 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1320,6 +1320,148 @@ DECLARE_SOA_TABLE(HfToOmegaKMCGen, "AOD", "HFTOOMEKMCGEN", //! hf_cand_xic0_omegac0::FlagMcMatchGen, hf_cand_xic0_omegac0::DebugGenCharmBar, hf_cand_xic0_omegac0::DebugGenCasc, hf_cand_xic0_omegac0::DebugGenLambda, hf_cand_xic0_omegac0::PtCharmBaryonGen, hf_cand_xic0_omegac0::RapidityCharmBaryonGen, hf_cand_xic0_omegac0::OriginGen, hf_cand::IdxBhadMotherPart, o2::soa::Marker<4>); +// specific Xicplus to Xi Pi Pi candidate properties +namespace hf_cand_xicplustoxipipi +{ +// Data processing results: +DECLARE_SOA_INDEX_COLUMN(Collision, collision); +DECLARE_SOA_COLUMN(XPv, xPv, float); +DECLARE_SOA_COLUMN(YPv, yPv, float); +DECLARE_SOA_COLUMN(ZPv, zPv, float); +DECLARE_SOA_COLUMN(XDecayVtxCharmBaryon, xDecayVtxCharmBaryon, float); +DECLARE_SOA_COLUMN(YDecayVtxCharmBaryon, yDecayVtxCharmBaryon, float); +DECLARE_SOA_COLUMN(ZDecayVtxCharmBaryon, zDecayVtxCharmBaryon, float); +DECLARE_SOA_COLUMN(XDecayVtxCascade, xDecayVtxCascade, float); +DECLARE_SOA_COLUMN(YDecayVtxCascade, yDecayVtxCascade, float); +DECLARE_SOA_COLUMN(ZDecayVtxCascade, zDecayVtxCascade, float); +DECLARE_SOA_COLUMN(XDecayVtxV0, xDecayVtxV0, float); +DECLARE_SOA_COLUMN(YDecayVtxV0, yDecayVtxV0, float); +DECLARE_SOA_COLUMN(ZDecayVtxV0, zDecayVtxV0, float); +DECLARE_SOA_COLUMN(SignDecay, signDecay, int8_t); // sign of pi <- xi +DECLARE_SOA_COLUMN(Chi2PCACharmBaryon, chi2PCACharmBaryon, float); +DECLARE_SOA_COLUMN(CovVtxCharmBaryon0, covVtxCharmBaryon0, float); +DECLARE_SOA_COLUMN(CovVtxCharmBaryon1, covVtxCharmBaryon1, float); +DECLARE_SOA_COLUMN(CovVtxCharmBaryon2, covVtxCharmBaryon2, float); +DECLARE_SOA_COLUMN(CovVtxCharmBaryon3, covVtxCharmBaryon3, float); +DECLARE_SOA_COLUMN(CovVtxCharmBaryon4, covVtxCharmBaryon4, float); +DECLARE_SOA_COLUMN(CovVtxCharmBaryon5, covVtxCharmBaryon5, float); +DECLARE_SOA_COLUMN(PxCharmBaryon, pxCharmBaryon, float); +DECLARE_SOA_COLUMN(PyCharmBaryon, pyCharmBaryon, float); +DECLARE_SOA_COLUMN(PzCharmBaryon, pzCharmBaryon, float); +DECLARE_SOA_COLUMN(PxCasc, pxCasc, float); +DECLARE_SOA_COLUMN(PyCasc, pyCasc, float); +DECLARE_SOA_COLUMN(PzCasc, pzCasc, float); +DECLARE_SOA_COLUMN(PxPi1FromCharmBaryon, pxPiFromCharmBaryon, float); +DECLARE_SOA_COLUMN(PyPi1FromCharmBaryon, pyPiFromCharmBaryon, float); +DECLARE_SOA_COLUMN(PzPi1FromCharmBaryon, pzPiFromCharmBaryon, float); +DECLARE_SOA_COLUMN(PxPi2FromCharmBaryon, pxPiFromCharmBaryon, float); +DECLARE_SOA_COLUMN(PyPi2FromCharmBaryon, pyPiFromCharmBaryon, float); +DECLARE_SOA_COLUMN(PzPi2FromCharmBaryon, pzPiFromCharmBaryon, float); +DECLARE_SOA_COLUMN(PxLambda, pxLambda, float); +DECLARE_SOA_COLUMN(PyLambda, pyLambda, float); +DECLARE_SOA_COLUMN(PzLambda, pzLambda, float); +DECLARE_SOA_COLUMN(PxPiFromCasc, pxPiFromCasc, float); +DECLARE_SOA_COLUMN(PyPiFromCasc, pyPiFromCasc, float); +DECLARE_SOA_COLUMN(PzPiFromCasc, pzPiFromCasc, float); +DECLARE_SOA_COLUMN(PxPosV0Dau, pxPosV0Dau, float); +DECLARE_SOA_COLUMN(PyPosV0Dau, pyPosV0Dau, float); +DECLARE_SOA_COLUMN(PzPosV0Dau, pzPosV0Dau, float); +DECLARE_SOA_COLUMN(PxNegV0Dau, pxNegV0Dau, float); +DECLARE_SOA_COLUMN(PyNegV0Dau, pyNegV0Dau, float); +DECLARE_SOA_COLUMN(PzNegV0Dau, pzNegV0Dau, float); +DECLARE_SOA_COLUMN(ImpactParCascXY, impactParCascXY, float); +DECLARE_SOA_COLUMN(ImpactParPi1FromCharmBaryonXY, impactParPiFromCharmBaryonXY, float); +DECLARE_SOA_COLUMN(ImpactParPi1FromCharmBaryonXY, impactParPiFromCharmBaryonXY, float); +DECLARE_SOA_COLUMN(ImpactParCascZ, impactParCascZ, float); +DECLARE_SOA_COLUMN(ImpactParPi2FromCharmBaryonZ, impactParPiFromCharmBaryonZ, float); +DECLARE_SOA_COLUMN(ImpactParPi2FromCharmBaryonZ, impactParPiFromCharmBaryonZ, float); +DECLARE_SOA_COLUMN(ErrImpactParCascXY, errImpactParCascXY, float); +DECLARE_SOA_COLUMN(ErrImpactParPiFromCharmBaryonXY, errImpactParPiFromCharmBaryonXY, float); +DECLARE_SOA_INDEX_COLUMN(V0, v0); +DECLARE_SOA_INDEX_COLUMN(Cascade, cascade); +DECLARE_SOA_INDEX_COLUMN_FULL(Pi1FromCharmBaryon, pi1FromCharmBaryon, int, Tracks, "_pi1fromcharmbaryon"); +DECLARE_SOA_INDEX_COLUMN_FULL(Pi2FromCharmBaryon, pi2FromCharmBaryon, int, Tracks, "_pi2fromcharmbaryon"); +DECLARE_SOA_COLUMN(InvMassLambda, invMassLambda, double); +DECLARE_SOA_COLUMN(InvMassCascade, invMassCascade, double); +DECLARE_SOA_COLUMN(InvMassCharmBaryon, invMassCharmBaryon, double); +DECLARE_SOA_COLUMN(CosPAV0, cosPAV0, double); +DECLARE_SOA_COLUMN(CosPACharmBaryon, cosPACharmBaryon, double); +DECLARE_SOA_COLUMN(CosPACasc, cosPACasc, double); +DECLARE_SOA_COLUMN(CosPAXYV0, cosPAXYV0, double); +DECLARE_SOA_COLUMN(CosPAXYCharmBaryon, cosPAXYCharmBaryon, double); +DECLARE_SOA_COLUMN(CosPAXYCasc, cosPAXYCasc, double); +DECLARE_SOA_COLUMN(CTauCascade, ctauCascade, double); +DECLARE_SOA_COLUMN(CTauV0, ctauV0, double); +DECLARE_SOA_COLUMN(CTauXicPlus, ctauXicPlus, double); +DECLARE_SOA_COLUMN(EtaV0PosDau, etaV0PosDau, double); +DECLARE_SOA_COLUMN(EtaV0NegDau, etaV0NegDau, double); +DECLARE_SOA_COLUMN(EtaPiFromCasc, etaPiFromCasc, double); +DECLARE_SOA_COLUMN(EtaPiFromCharmBaryon, etaPiFromCharmBaryon, double); +DECLARE_SOA_COLUMN(EtaCharmBaryon, etaCharmBaryon, double); +DECLARE_SOA_COLUMN(EtaCascade, etaCascade, double); +DECLARE_SOA_COLUMN(EtaV0, etaV0, double); +DECLARE_SOA_COLUMN(DcaXYToPvV0Dau0, dcaXYToPvV0Dau0, float); // pos dau +DECLARE_SOA_COLUMN(DcaXYToPvV0Dau1, dcaXYToPvV0Dau1, float); // neg dau +DECLARE_SOA_COLUMN(DcaXYToPvCascDau, dcaXYToPvCascDau, float); +DECLARE_SOA_COLUMN(DcaZToPvV0Dau0, dcaZToPvV0Dau0, float); +DECLARE_SOA_COLUMN(DcaZToPvV0Dau1, dcaZToPvV0Dau1, float); +DECLARE_SOA_COLUMN(DcaZToPvCascDau, dcaZToPvCascDau, float); +DECLARE_SOA_COLUMN(DcaCascDau, dcaCascDau, float); +DECLARE_SOA_COLUMN(DcaV0Dau, dcaV0Dau, float); +DECLARE_SOA_COLUMN(DcaCharmBaryonDau, dcaCharmBaryonDau, float); +DECLARE_SOA_COLUMN(DecLenCharmBaryon, decLenCharmBaryon, double); +DECLARE_SOA_COLUMN(DecLenCascade, decLenCascade, double); +DECLARE_SOA_COLUMN(DecLenV0, decLenV0, double); +DECLARE_SOA_COLUMN(ErrorDecayLengthCharmBaryon, errorDecayLengthCharmBaryon, float); +DECLARE_SOA_COLUMN(ErrorDecayLengthXYCharmBaryon, errorDecayLengthXYCharmBaryon, float); + +// MC matching result: +DECLARE_SOA_COLUMN(FlagMcMatchRec, flagMcMatchRec, int8_t); // reconstruction level +DECLARE_SOA_COLUMN(DebugMcRec, debugMcRec, int8_t); // debug flag for mis-association reconstruction level +DECLARE_SOA_COLUMN(FlagMcMatchGen, flagMcMatchGen, int8_t); // generator level +DECLARE_SOA_COLUMN(DebugGenCharmBar, debugGenCharmBar, int8_t); +DECLARE_SOA_COLUMN(DebugGenXi, debugGenXi, int8_t); +DECLARE_SOA_COLUMN(DebugGenLambda, debugGenLambda, int8_t); +DECLARE_SOA_COLUMN(OriginRec, originRec, int8_t); +DECLARE_SOA_COLUMN(OriginGen, originGen, int8_t); + +// mapping of decay types +enum DecayType {XicplusToXiPiPi}; + +} // end of namespace hf_cand_xicplustoxipipi + +// declare dedicated Omegac and Xic to Xi Pi candidate table +DECLARE_SOA_TABLE(HfCandXicplusToXiPiPi, "AOD", "HFCANDXICPLUSTOXIPIPI", + o2::soa::Index<>, + hf_cand_xicplustoxipipi::CollisionId, + hf_cand_xicplustoxipipi::XPv, hf_cand_xicplustoxipipi::YPv, hf_cand_xicplustoxipipi::ZPv, + hf_cand_xicplustoxipipi::XDecayVtxCharmBaryon, hf_cand_xicplustoxipipi::YDecayVtxCharmBaryon, hf_cand_xicplustoxipipi::ZDecayVtxCharmBaryon, + hf_cand_xicplustoxipipi::ErrorDecayLengthCharmBaryon, hf_cand_xicplustoxipipi::ErrorDecayLengthXYCharmBaryon, + hf_cand_xicplustoxipipi::Chi2PCACharmBaryon, + hf_cand_xicplustoxipipi::PxCharmBaryon, hf_cand_xicplustoxipipi::PyCharmBaryon, hf_cand_xicplustoxipipi::PzCharmBaryon, + hf_cand_xicplustoxipipi::PxPi1FromCharmBaryon, hf_cand_xicplustoxipipi::PyPi1FromCharmBaryon, hf_cand_xicplustoxipipi::PzPi1FromCharmBaryon, + hf_cand_xicplustoxipipi::PxPi2FromCharmBaryon, hf_cand_xicplustoxipipi::PyPi2FromCharmBaryon, hf_cand_xicplustoxipipi::PzPi2FromCharmBaryon, + hf_cand_xicplustoxipipi::ImpactParPiFromCharmBaryonXY,hf_cand_xicplustoxipipi::ImpactParPiFromCharmBaryonXY,hf_cand_xicplustoxipipi::ImpactParCascXY, + hf_cand_xicplustoxipipi::Pi1FromCharmBaryonId,hf_cand_xicplustoxipipi::Pi2FromCharmBaryonId,hf_cand_xicplustoxipipi::CascadeId, + hf_cand_xicplustoxipipi::SignDecay, + hf_cand_xicplustoxipipi::XDecayVtxCascade, hf_cand_xicplustoxipipi::YDecayVtxCascade, hf_cand_xicplustoxipipi::ZDecayVtxCascade, + hf_cand_xicplustoxipipi::XDecayVtxV0, hf_cand_xicplustoxipipi::YDecayVtxV0, hf_cand_xicplustoxipipi::ZDecayVtxV0, + hf_cand_xicplustoxipipi::PxPosV0Dau, hf_cand_xicplustoxipipi::PyPosV0Dau, hf_cand_xicplustoxipipi::PzPosV0Dau, + hf_cand_xicplustoxipipi::PxNegV0Dau, hf_cand_xicplustoxipipi::PyNegV0Dau, hf_cand_xicplustoxipipi::PzNegV0Dau, + hf_cand_xicplustoxipipi::PxPiFromCasc, hf_cand_xicplustoxipipi::PyPiFromCasc, hf_cand_xicplustoxipipi::PzPiFromCasc, + hf_cand_xicplustoxipipi::DcaXYToPvV0Dau0, hf_cand_xicplustoxipipi::DcaXYToPvV0Dau1,hf_cand_xicplustoxipipi::DcaXYToPvCascDau, + hf_track_index::HFflag); + +// table with results of reconstruction level MC matching +DECLARE_SOA_TABLE(HfXicplusToXiPiPiMCRec, "AOD", "HFXICPLUSTOXIPIPIMCREC", //! + hf_cand_xicplustoxipipi::FlagMcMatchRec, + hf_cand_xicplustoxipipi::DebugMcRec, + hf_cand_xicplustoxipipi::OriginRec); + +// table with results of generator level MC matching +DECLARE_SOA_TABLE(HfXicPlusToXiPiPiMCGen, "AOD", "HFXICPLUSTOXIPIPIMCGEN", //! + hf_cand_xicplustoxipipi::FlagMcMatchGen, hf_cand_xicplustoxipipi::DebugGenCharmBar, hf_cand_xicplustoxipipi::DebugGenXi, hf_cand_xicplustoxipipi::DebugGenLambda, hf_cand_xicplustoxipipi::OriginGen); + // specific chic candidate properties namespace hf_cand_chic { diff --git a/PWGHF/TableProducer/CMakeLists.txt b/PWGHF/TableProducer/CMakeLists.txt index cbb9580bbf4..902a9007d0a 100644 --- a/PWGHF/TableProducer/CMakeLists.txt +++ b/PWGHF/TableProducer/CMakeLists.txt @@ -80,6 +80,11 @@ o2physics_add_dpl_workflow(candidate-creator-xic0-omegac0 PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2::DCAFitter O2Physics::EventFilteringUtils COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(candidate-creator-xicplus-to-xi-pi-pi + SOURCES candidateCreatorXicplusToXiPiPi.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2::DCAFitter KFParticle::KFParticle + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(candidate-creator-xicc SOURCES candidateCreatorXicc.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2::DCAFitter From afe7d3f56ded373780cd1985a47eb3b213d48036 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Tue, 19 Dec 2023 13:47:23 +0100 Subject: [PATCH 02/35] First compiled version of XicPlusToXiPiPi candidate creator --- .../DataModel/CandidateReconstructionTables.h | 102 +-- PWGHF/TableProducer/CMakeLists.txt | 2 +- .../candidateCreatorXicPlusToXiPiPi.cxx | 657 ++++++++++++++++++ 3 files changed, 710 insertions(+), 51 deletions(-) create mode 100644 PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index 9fc0607b2c9..da96d3caa41 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1320,7 +1320,7 @@ DECLARE_SOA_TABLE(HfToOmegaKMCGen, "AOD", "HFTOOMEKMCGEN", //! hf_cand_xic0_omegac0::FlagMcMatchGen, hf_cand_xic0_omegac0::DebugGenCharmBar, hf_cand_xic0_omegac0::DebugGenCasc, hf_cand_xic0_omegac0::DebugGenLambda, hf_cand_xic0_omegac0::PtCharmBaryonGen, hf_cand_xic0_omegac0::RapidityCharmBaryonGen, hf_cand_xic0_omegac0::OriginGen, hf_cand::IdxBhadMotherPart, o2::soa::Marker<4>); -// specific Xicplus to Xi Pi Pi candidate properties +// specific XicPlus to Xi Pi Pi candidate properties namespace hf_cand_xicplustoxipipi { // Data processing results: @@ -1328,9 +1328,9 @@ DECLARE_SOA_INDEX_COLUMN(Collision, collision); DECLARE_SOA_COLUMN(XPv, xPv, float); DECLARE_SOA_COLUMN(YPv, yPv, float); DECLARE_SOA_COLUMN(ZPv, zPv, float); -DECLARE_SOA_COLUMN(XDecayVtxCharmBaryon, xDecayVtxCharmBaryon, float); -DECLARE_SOA_COLUMN(YDecayVtxCharmBaryon, yDecayVtxCharmBaryon, float); -DECLARE_SOA_COLUMN(ZDecayVtxCharmBaryon, zDecayVtxCharmBaryon, float); +DECLARE_SOA_COLUMN(XDecayVtxXicPlus, xDecayVtxXicPlus, float); +DECLARE_SOA_COLUMN(YDecayVtxXicPlus, yDecayVtxXicPlus, float); +DECLARE_SOA_COLUMN(ZDecayVtxXicPlus, zDecayVtxXicPlus, float); DECLARE_SOA_COLUMN(XDecayVtxCascade, xDecayVtxCascade, float); DECLARE_SOA_COLUMN(YDecayVtxCascade, yDecayVtxCascade, float); DECLARE_SOA_COLUMN(ZDecayVtxCascade, zDecayVtxCascade, float); @@ -1338,25 +1338,25 @@ DECLARE_SOA_COLUMN(XDecayVtxV0, xDecayVtxV0, float); DECLARE_SOA_COLUMN(YDecayVtxV0, yDecayVtxV0, float); DECLARE_SOA_COLUMN(ZDecayVtxV0, zDecayVtxV0, float); DECLARE_SOA_COLUMN(SignDecay, signDecay, int8_t); // sign of pi <- xi -DECLARE_SOA_COLUMN(Chi2PCACharmBaryon, chi2PCACharmBaryon, float); -DECLARE_SOA_COLUMN(CovVtxCharmBaryon0, covVtxCharmBaryon0, float); -DECLARE_SOA_COLUMN(CovVtxCharmBaryon1, covVtxCharmBaryon1, float); -DECLARE_SOA_COLUMN(CovVtxCharmBaryon2, covVtxCharmBaryon2, float); -DECLARE_SOA_COLUMN(CovVtxCharmBaryon3, covVtxCharmBaryon3, float); -DECLARE_SOA_COLUMN(CovVtxCharmBaryon4, covVtxCharmBaryon4, float); -DECLARE_SOA_COLUMN(CovVtxCharmBaryon5, covVtxCharmBaryon5, float); -DECLARE_SOA_COLUMN(PxCharmBaryon, pxCharmBaryon, float); -DECLARE_SOA_COLUMN(PyCharmBaryon, pyCharmBaryon, float); -DECLARE_SOA_COLUMN(PzCharmBaryon, pzCharmBaryon, float); +DECLARE_SOA_COLUMN(Chi2PCAXicPlus, chi2PCAXicPlus, float); +DECLARE_SOA_COLUMN(CovVtxXicPlus0, covVtxXicPlus0, float); +DECLARE_SOA_COLUMN(CovVtxXicPlus1, covVtxXicPlus1, float); +DECLARE_SOA_COLUMN(CovVtxXicPlus2, covVtxXicPlus2, float); +DECLARE_SOA_COLUMN(CovVtxXicPlus3, covVtxXicPlus3, float); +DECLARE_SOA_COLUMN(CovVtxXicPlus4, covVtxXicPlus4, float); +DECLARE_SOA_COLUMN(CovVtxXicPlus5, covVtxXicPlus5, float); +DECLARE_SOA_COLUMN(PxXicPlus, pxXicPlus, float); +DECLARE_SOA_COLUMN(PyXicPlus, pyXicPlus, float); +DECLARE_SOA_COLUMN(PzXicPlus, pzXicPlus, float); DECLARE_SOA_COLUMN(PxCasc, pxCasc, float); DECLARE_SOA_COLUMN(PyCasc, pyCasc, float); DECLARE_SOA_COLUMN(PzCasc, pzCasc, float); -DECLARE_SOA_COLUMN(PxPi1FromCharmBaryon, pxPiFromCharmBaryon, float); -DECLARE_SOA_COLUMN(PyPi1FromCharmBaryon, pyPiFromCharmBaryon, float); -DECLARE_SOA_COLUMN(PzPi1FromCharmBaryon, pzPiFromCharmBaryon, float); -DECLARE_SOA_COLUMN(PxPi2FromCharmBaryon, pxPiFromCharmBaryon, float); -DECLARE_SOA_COLUMN(PyPi2FromCharmBaryon, pyPiFromCharmBaryon, float); -DECLARE_SOA_COLUMN(PzPi2FromCharmBaryon, pzPiFromCharmBaryon, float); +DECLARE_SOA_COLUMN(PxPi1FromXicPlus, pxPi1FromXicPlus, float); +DECLARE_SOA_COLUMN(PyPi1FromXicPlus, pyPi1FromXicPlus, float); +DECLARE_SOA_COLUMN(PzPi1FromXicPlus, pzPi1FromXicPlus, float); +DECLARE_SOA_COLUMN(PxPi2FromXicPlus, pxPi2FromXicPlus, float); +DECLARE_SOA_COLUMN(PyPi2FromXicPlus, pyPi2FromXicPlus, float); +DECLARE_SOA_COLUMN(PzPi2FromXicPlus, pzPi2FromXicPlus, float); DECLARE_SOA_COLUMN(PxLambda, pxLambda, float); DECLARE_SOA_COLUMN(PyLambda, pyLambda, float); DECLARE_SOA_COLUMN(PzLambda, pzLambda, float); @@ -1370,25 +1370,26 @@ DECLARE_SOA_COLUMN(PxNegV0Dau, pxNegV0Dau, float); DECLARE_SOA_COLUMN(PyNegV0Dau, pyNegV0Dau, float); DECLARE_SOA_COLUMN(PzNegV0Dau, pzNegV0Dau, float); DECLARE_SOA_COLUMN(ImpactParCascXY, impactParCascXY, float); -DECLARE_SOA_COLUMN(ImpactParPi1FromCharmBaryonXY, impactParPiFromCharmBaryonXY, float); -DECLARE_SOA_COLUMN(ImpactParPi1FromCharmBaryonXY, impactParPiFromCharmBaryonXY, float); DECLARE_SOA_COLUMN(ImpactParCascZ, impactParCascZ, float); -DECLARE_SOA_COLUMN(ImpactParPi2FromCharmBaryonZ, impactParPiFromCharmBaryonZ, float); -DECLARE_SOA_COLUMN(ImpactParPi2FromCharmBaryonZ, impactParPiFromCharmBaryonZ, float); +DECLARE_SOA_COLUMN(ImpactParPi1FromXicPlusXY, impactParPi1FromXicPlusXY, float); +DECLARE_SOA_COLUMN(ImpactParPi1FromXicPlusZ, impactParPi1FromXicPlusZ, float); +DECLARE_SOA_COLUMN(ImpactParPi2FromXicPlusXY, impactParPi2FromXicPlusXY, float); +DECLARE_SOA_COLUMN(ImpactParPi2FromXicPlusZ, impactParPi2FromXicPlusZ, float); DECLARE_SOA_COLUMN(ErrImpactParCascXY, errImpactParCascXY, float); -DECLARE_SOA_COLUMN(ErrImpactParPiFromCharmBaryonXY, errImpactParPiFromCharmBaryonXY, float); +DECLARE_SOA_COLUMN(ErrImpactParPi1FromXicPlusXY, errImpactParPi1FromXicPlusXY, float); +DECLARE_SOA_COLUMN(ErrImpactParPi2FromXicPlusXY, errImpactParPi2FromXicPlusXY, float); DECLARE_SOA_INDEX_COLUMN(V0, v0); DECLARE_SOA_INDEX_COLUMN(Cascade, cascade); -DECLARE_SOA_INDEX_COLUMN_FULL(Pi1FromCharmBaryon, pi1FromCharmBaryon, int, Tracks, "_pi1fromcharmbaryon"); -DECLARE_SOA_INDEX_COLUMN_FULL(Pi2FromCharmBaryon, pi2FromCharmBaryon, int, Tracks, "_pi2fromcharmbaryon"); +DECLARE_SOA_INDEX_COLUMN_FULL(Pi1FromXicPlus, pi1FromXicPlus, int, Tracks, "_pi1fromXicPlus"); +DECLARE_SOA_INDEX_COLUMN_FULL(Pi2FromXicPlus, pi2FromXicPlus, int, Tracks, "_pi2fromXicPlus"); DECLARE_SOA_COLUMN(InvMassLambda, invMassLambda, double); DECLARE_SOA_COLUMN(InvMassCascade, invMassCascade, double); -DECLARE_SOA_COLUMN(InvMassCharmBaryon, invMassCharmBaryon, double); +DECLARE_SOA_COLUMN(InvMassXicPlus, invMassXicPlus, double); DECLARE_SOA_COLUMN(CosPAV0, cosPAV0, double); -DECLARE_SOA_COLUMN(CosPACharmBaryon, cosPACharmBaryon, double); +DECLARE_SOA_COLUMN(CosPAXicPlus, cosPAXicPlus, double); DECLARE_SOA_COLUMN(CosPACasc, cosPACasc, double); DECLARE_SOA_COLUMN(CosPAXYV0, cosPAXYV0, double); -DECLARE_SOA_COLUMN(CosPAXYCharmBaryon, cosPAXYCharmBaryon, double); +DECLARE_SOA_COLUMN(CosPAXYXicPlus, cosPAXYXicPlus, double); DECLARE_SOA_COLUMN(CosPAXYCasc, cosPAXYCasc, double); DECLARE_SOA_COLUMN(CTauCascade, ctauCascade, double); DECLARE_SOA_COLUMN(CTauV0, ctauV0, double); @@ -1396,8 +1397,8 @@ DECLARE_SOA_COLUMN(CTauXicPlus, ctauXicPlus, double); DECLARE_SOA_COLUMN(EtaV0PosDau, etaV0PosDau, double); DECLARE_SOA_COLUMN(EtaV0NegDau, etaV0NegDau, double); DECLARE_SOA_COLUMN(EtaPiFromCasc, etaPiFromCasc, double); -DECLARE_SOA_COLUMN(EtaPiFromCharmBaryon, etaPiFromCharmBaryon, double); -DECLARE_SOA_COLUMN(EtaCharmBaryon, etaCharmBaryon, double); +DECLARE_SOA_COLUMN(EtaPiFromXicPlus, etaPiFromXicPlus, double); +DECLARE_SOA_COLUMN(EtaXicPlus, etaXicPlus, double); DECLARE_SOA_COLUMN(EtaCascade, etaCascade, double); DECLARE_SOA_COLUMN(EtaV0, etaV0, double); DECLARE_SOA_COLUMN(DcaXYToPvV0Dau0, dcaXYToPvV0Dau0, float); // pos dau @@ -1408,12 +1409,12 @@ DECLARE_SOA_COLUMN(DcaZToPvV0Dau1, dcaZToPvV0Dau1, float); DECLARE_SOA_COLUMN(DcaZToPvCascDau, dcaZToPvCascDau, float); DECLARE_SOA_COLUMN(DcaCascDau, dcaCascDau, float); DECLARE_SOA_COLUMN(DcaV0Dau, dcaV0Dau, float); -DECLARE_SOA_COLUMN(DcaCharmBaryonDau, dcaCharmBaryonDau, float); -DECLARE_SOA_COLUMN(DecLenCharmBaryon, decLenCharmBaryon, double); +DECLARE_SOA_COLUMN(DcaXicPlusDau, dcaXicPlusDau, float); +DECLARE_SOA_COLUMN(DecLenXicPlus, decLenXicPlus, double); DECLARE_SOA_COLUMN(DecLenCascade, decLenCascade, double); DECLARE_SOA_COLUMN(DecLenV0, decLenV0, double); -DECLARE_SOA_COLUMN(ErrorDecayLengthCharmBaryon, errorDecayLengthCharmBaryon, float); -DECLARE_SOA_COLUMN(ErrorDecayLengthXYCharmBaryon, errorDecayLengthXYCharmBaryon, float); +DECLARE_SOA_COLUMN(ErrorDecayLengthXicPlus, errorDecayLengthXicPlus, float); +DECLARE_SOA_COLUMN(ErrorDecayLengthXYXicPlus, errorDecayLengthXYXicPlus, float); // MC matching result: DECLARE_SOA_COLUMN(FlagMcMatchRec, flagMcMatchRec, int8_t); // reconstruction level @@ -1426,24 +1427,25 @@ DECLARE_SOA_COLUMN(OriginRec, originRec, int8_t); DECLARE_SOA_COLUMN(OriginGen, originGen, int8_t); // mapping of decay types -enum DecayType {XicplusToXiPiPi}; +enum DecayType { XicPlusToXiPiPi=0 }; } // end of namespace hf_cand_xicplustoxipipi -// declare dedicated Omegac and Xic to Xi Pi candidate table -DECLARE_SOA_TABLE(HfCandXicplusToXiPiPi, "AOD", "HFCANDXICPLUSTOXIPIPI", +// declare dedicated XicPlus to Xi Pi Pi candidate table +DECLARE_SOA_TABLE(HfCandXicPlus, "AOD", "HFCANDXICPLUS", o2::soa::Index<>, hf_cand_xicplustoxipipi::CollisionId, + hf_cand_xicplustoxipipi::Pi1FromXicPlusId, hf_cand_xicplustoxipipi::Pi2FromXicPlusId, hf_cand_xicplustoxipipi::CascadeId, + cascdata::BachelorId, hf_cand_xicplustoxipipi::V0Id, v0data::PosTrackId, v0data::NegTrackId, hf_cand_xicplustoxipipi::XPv, hf_cand_xicplustoxipipi::YPv, hf_cand_xicplustoxipipi::ZPv, - hf_cand_xicplustoxipipi::XDecayVtxCharmBaryon, hf_cand_xicplustoxipipi::YDecayVtxCharmBaryon, hf_cand_xicplustoxipipi::ZDecayVtxCharmBaryon, - hf_cand_xicplustoxipipi::ErrorDecayLengthCharmBaryon, hf_cand_xicplustoxipipi::ErrorDecayLengthXYCharmBaryon, - hf_cand_xicplustoxipipi::Chi2PCACharmBaryon, - hf_cand_xicplustoxipipi::PxCharmBaryon, hf_cand_xicplustoxipipi::PyCharmBaryon, hf_cand_xicplustoxipipi::PzCharmBaryon, - hf_cand_xicplustoxipipi::PxPi1FromCharmBaryon, hf_cand_xicplustoxipipi::PyPi1FromCharmBaryon, hf_cand_xicplustoxipipi::PzPi1FromCharmBaryon, - hf_cand_xicplustoxipipi::PxPi2FromCharmBaryon, hf_cand_xicplustoxipipi::PyPi2FromCharmBaryon, hf_cand_xicplustoxipipi::PzPi2FromCharmBaryon, - hf_cand_xicplustoxipipi::ImpactParPiFromCharmBaryonXY,hf_cand_xicplustoxipipi::ImpactParPiFromCharmBaryonXY,hf_cand_xicplustoxipipi::ImpactParCascXY, - hf_cand_xicplustoxipipi::Pi1FromCharmBaryonId,hf_cand_xicplustoxipipi::Pi2FromCharmBaryonId,hf_cand_xicplustoxipipi::CascadeId, - hf_cand_xicplustoxipipi::SignDecay, + hf_cand_xicplustoxipipi::XDecayVtxXicPlus, hf_cand_xicplustoxipipi::YDecayVtxXicPlus, hf_cand_xicplustoxipipi::ZDecayVtxXicPlus, + hf_cand_xicplustoxipipi::ErrorDecayLengthXicPlus, hf_cand_xicplustoxipipi::ErrorDecayLengthXYXicPlus, + hf_cand_xicplustoxipipi::Chi2PCAXicPlus, + hf_cand_xicplustoxipipi::PxPi1FromXicPlus, hf_cand_xicplustoxipipi::PyPi1FromXicPlus, hf_cand_xicplustoxipipi::PzPi1FromXicPlus, + hf_cand_xicplustoxipipi::PxPi2FromXicPlus, hf_cand_xicplustoxipipi::PyPi2FromXicPlus, hf_cand_xicplustoxipipi::PzPi2FromXicPlus, + hf_cand_xicplustoxipipi::PxXicPlus, hf_cand_xicplustoxipipi::PyXicPlus, hf_cand_xicplustoxipipi::PzXicPlus, + hf_cand_xicplustoxipipi::ImpactParPi1FromXicPlusXY,hf_cand_xicplustoxipipi::ImpactParPi2FromXicPlusXY,hf_cand_xicplustoxipipi::ImpactParCascXY, + hf_cand_xicplustoxipipi::ErrImpactParPi1FromXicPlusXY, hf_cand_xicplustoxipipi::ErrImpactParPi2FromXicPlusXY, hf_cand_xicplustoxipipi::ErrImpactParCascXY, hf_cand_xicplustoxipipi::XDecayVtxCascade, hf_cand_xicplustoxipipi::YDecayVtxCascade, hf_cand_xicplustoxipipi::ZDecayVtxCascade, hf_cand_xicplustoxipipi::XDecayVtxV0, hf_cand_xicplustoxipipi::YDecayVtxV0, hf_cand_xicplustoxipipi::ZDecayVtxV0, hf_cand_xicplustoxipipi::PxPosV0Dau, hf_cand_xicplustoxipipi::PyPosV0Dau, hf_cand_xicplustoxipipi::PzPosV0Dau, @@ -1453,13 +1455,13 @@ DECLARE_SOA_TABLE(HfCandXicplusToXiPiPi, "AOD", "HFCANDXICPLUSTOXIPIPI", hf_track_index::HFflag); // table with results of reconstruction level MC matching -DECLARE_SOA_TABLE(HfXicplusToXiPiPiMCRec, "AOD", "HFXICPLUSTOXIPIPIMCREC", //! +DECLARE_SOA_TABLE(HfXicPlusMcRec, "AOD", "HFXICPLUSMCREC", //! hf_cand_xicplustoxipipi::FlagMcMatchRec, hf_cand_xicplustoxipipi::DebugMcRec, hf_cand_xicplustoxipipi::OriginRec); // table with results of generator level MC matching -DECLARE_SOA_TABLE(HfXicPlusToXiPiPiMCGen, "AOD", "HFXICPLUSTOXIPIPIMCGEN", //! +DECLARE_SOA_TABLE(HfXicPlusMcGen, "AOD", "HFXICPLUSMCGEN", //! hf_cand_xicplustoxipipi::FlagMcMatchGen, hf_cand_xicplustoxipipi::DebugGenCharmBar, hf_cand_xicplustoxipipi::DebugGenXi, hf_cand_xicplustoxipipi::DebugGenLambda, hf_cand_xicplustoxipipi::OriginGen); // specific chic candidate properties diff --git a/PWGHF/TableProducer/CMakeLists.txt b/PWGHF/TableProducer/CMakeLists.txt index 902a9007d0a..1c1a7988299 100644 --- a/PWGHF/TableProducer/CMakeLists.txt +++ b/PWGHF/TableProducer/CMakeLists.txt @@ -81,7 +81,7 @@ o2physics_add_dpl_workflow(candidate-creator-xic0-omegac0 COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(candidate-creator-xicplus-to-xi-pi-pi - SOURCES candidateCreatorXicplusToXiPiPi.cxx + SOURCES candidateCreatorXicPlusToXiPiPi.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2::DCAFitter KFParticle::KFParticle COMPONENT_NAME Analysis) diff --git a/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx new file mode 100644 index 00000000000..82186416832 --- /dev/null +++ b/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx @@ -0,0 +1,657 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \file candidateCreatorXicToXiPiPi.cxx +/// \brief Reconstruction of Ξc± → Ξ∓ π± π± candidates +/// +/// \author Jinjoo Seo , Heidelberg University +/// \author Phil Lennart Stahlhut , CERN + +#include +#include +#include +#include +#include + +#include + +#include "CommonConstants/PhysicsConstants.h" +#include "DCAFitter/DCAFitterN.h" +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" +#include "ReconstructionDataFormats/DCA.h" + +#include "Common/Core/trackUtilities.h" +#include "Tools/KFparticle/KFUtilities.h" + +#include "PWGLF/DataModel/LFStrangenessTables.h" + +#include "PWGHF/DataModel/CandidateReconstructionTables.h" +#include "PWGHF/Utils/utilsBfieldCCDB.h" + +using namespace o2; +using namespace o2::analysis; +using namespace o2::aod::hf_cand_xicplustoxipipi; +using namespace o2::constants::physics; +using namespace o2::framework; + +/// Reconstruction of heavy-flavour 3-prong decay candidates +struct HfCandidateCreatorXicPlus { + Produces rowCandidateBase; + + // vertexing + Configurable propagateToPCA{"propagateToPCA", true, "create tracks version propagated to PCA"}; + Configurable useAbsDCA{"useAbsDCA", false, "Minimise abs. distance rather than chi2"}; + Configurable useWeightedFinalPCA{"useWeightedFinalPCA", false, "Recalculate vertex position using track covariances, effective only if useAbsDCA is true"}; + Configurable maxR{"maxR", 200., "reject PCA's above this radius"}; + Configurable maxDZIni{"maxDZIni", 4., "reject (if>0) PCA candidate if tracks DZ exceeds threshold"}; + Configurable minParamChange{"minParamChange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; + Configurable minRelChi2Change{"minRelChi2Change", 0.9, "stop iterations is chi2/chi2old > this"}; + Configurable maxChi2{"maxChi2", 100., "discard vertices with chi2/Nprongs > this (or sum{DCAi^2}/Nprongs for abs. distance minimization)"}; + Configurable rejDiffCollTrack{"rejDiffCollTrack", true, "Reject tracks coming from different collisions"}; + Configurable fillHistograms{"fillHistograms", true, "do validation plots"}; + + // magnetic field setting from CCDB + Configurable isRun2{"isRun2", false, "enable Run 2 or Run 3 GRP objects for magnetic field"}; + Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; + Configurable ccdbPathLut{"ccdbPathLut", "GLO/Param/MatLUT", "Path for LUT parametrization"}; + Configurable ccdbPathGrp{"ccdbPathGrp", "GLO/GRP/GRP", "Path of the grp file (Run 2)"}; + Configurable ccdbPathGrpMag{"ccdbPathGrpMag", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object (Run 3)"}; + + // cascade cuts + Configurable doCascadePreselection{"doCascadePreselection", true, "Use invariant mass and dcaXY cuts to preselect cascade candidates"}; + Configurable massToleranceCascade{"massToleranceCascade", 0.01, "Invariant mass tolerance for cascade"}; + Configurable dcaXYToPVCascadeMax{"dcaXYToPVCascadeMax", 3, "Max cascade DCA to PV in xy plane"}; + + Service ccdb; + o2::base::MatLayerCylSet* lut; + o2::base::Propagator::MatCorrType matCorr = o2::base::Propagator::MatCorrType::USEMatCorrLUT; + + double massXiMinusFromPdg = MassXiMinus; + double massPionFromPdg = MassPiPlus; + + int runNumber{0}; + float toMicrometers = 10000.; // from cm to µm + double massPi{0.}; + double massXi{0.}; + double massXiPiPi{0.}; + double bz{0.}; + + OutputObj hMass3{TH1F("hMass3", "3-prong candidates;inv. mass (#Xi #pi #pi) (GeV/#it{c}^{2});entries", 500, 2.3, 2.7)}; + OutputObj hCovPVXX{TH1F("hCovPVXX", "3-prong candidates;XX element of cov. matrix of prim. vtx. position (cm^{2});entries", 100, 0., 1.e-4)}; + OutputObj hCovSVXX{TH1F("hCovSVXX", "3-prong candidates;XX element of cov. matrix of sec. vtx. position (cm^{2});entries", 100, 0., 0.2)}; + OutputObj hCovPVYY{TH1F("hCovPVYY", "3-prong candidates;YY element of cov. matrix of prim. vtx. position (cm^{2});entries", 100, 0., 1.e-4)}; + OutputObj hCovSVYY{TH1F("hCovSVYY", "3-prong candidates;YY element of cov. matrix of sec. vtx. position (cm^{2});entries", 100, 0., 0.2)}; + OutputObj hCovPVXZ{TH1F("hCovPVXZ", "3-prong candidates;XZ element of cov. matrix of prim. vtx. position (cm^{2});entries", 100, -1.e-4, 1.e-4)}; + OutputObj hCovSVXZ{TH1F("hCovSVXZ", "3-prong candidates;XZ element of cov. matrix of sec. vtx. position (cm^{2});entries", 100, -1.e-4, 0.2)}; + OutputObj hCovPVZZ{TH1F("hCovPVZZ", "3-prong candidates;ZZ element of cov. matrix of prim. vtx. position (cm^{2});entries", 100, 0., 1.e-4)}; + OutputObj hCovSVZZ{TH1F("hCovSVZZ", "3-prong candidates;ZZ element of cov. matrix of sec. vtx. position (cm^{2});entries", 100, 0., 0.2)}; + OutputObj hDcaXYProngs{TH2F("hDcaXYProngs", "DCAxy of 3-prong candidates;#it{p}_{T} (GeV/#it{c};#it{d}_{xy}) (#mum);entries", 100, 0., 20., 200, -500., 500.)}; + OutputObj hDcaZProngs{TH2F("hDcaZProngs", "DCAz of 3-prong candidates;#it{p}_{T} (GeV/#it{c};#it{d}_{z}) (#mum);entries", 100, 0., 20., 200, -500., 500.)}; + OutputObj hVertexerType{TH1F("hVertexerType", "Use KF or DCAFitterN;Vertexer type;entries", 2, -0.5, 1.5)}; // See o2::aod::hf_cand::VertexerType + + void init(InitContext const&) + { + ccdb->setURL(ccdbUrl); + ccdb->setCaching(true); + ccdb->setLocalObjectValidityChecking(); + lut = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdb->get(ccdbPathLut)); + runNumber = 0; + + std::array doprocessDF{doprocessPvRefitWithDCAFitterN, doprocessNoPvRefitWithDCAFitterN}; + std::array doprocessKF{doprocessPvRefitWithKFParticle, doprocessNoPvRefitWithKFParticle}; + if ((std::accumulate(doprocessDF.begin(), doprocessDF.end(), 0) + std::accumulate(doprocessKF.begin(), doprocessKF.end(), 0)) != 1) { + LOGP(fatal, "Only one process function can be enabled at a time."); + } + if (std::accumulate(doprocessDF.begin(), doprocessDF.end(), 0) == 1) { + hVertexerType->Fill(aod::hf_cand::VertexerType::DCAFitter); + } + if (std::accumulate(doprocessKF.begin(), doprocessKF.end(), 0) == 1) { + hVertexerType->Fill(aod::hf_cand::VertexerType::KfParticle); + } + } + + // Will be modified + using CascFull = soa::Join; + using V0Full = soa::Join; + + template + void runCreatorXicPlusWithDcaFitter(aod::Collisions const& collisions, + CandType const& rowsTrackIndexXicPlus, + aod::V0sLinked const& v0Linked, + V0Full const& v0s, + CascFull const& cascs, + TTracks const& tracks, + aod::BCsWithTimestamps const& bcWithTimeStamps) + { + // 3-prong vertex fitter + o2::vertexing::DCAFitterN<3> df; + // df.setBz(bz); + df.setPropagateToPCA(propagateToPCA); + df.setMaxR(maxR); + df.setMaxDZIni(maxDZIni); + df.setMinParamChange(minParamChange); + df.setMinRelChi2Change(minRelChi2Change); + df.setUseAbsDCA(useAbsDCA); + df.setWeightedFinalPCA(useWeightedFinalPCA); + + // loop over triplets of track indices + for (const auto& rowTrackIndexXicPlus : rowsTrackIndexXicPlus) { + auto track0 = rowTrackIndexXicPlus.template prong0_as(); + auto track1 = rowTrackIndexXicPlus.template prong1_as(); + auto casc = rowTrackIndexXicPlus.template cascade_as(); + + // preselect cascade candidates + if (doCascadePreselection) { + if (std::abs(casc.dcaXYCascToPV()) > dcaXYToPVCascadeMax) { + continue; + } + if (std::abs(casc.mXi() - massXiMinusFromPdg) > massToleranceCascade) { + continue; + } + } + + //----------------accessing particles in the decay chain------------- + // cascade daughter - charged particle + auto trackPionFromXi = casc.template bachelor_as(); // pion <- xi track from TTracks table + // cascade daughter - V0 + auto v0 = casc.template v0_as(); + auto v0Element = v0.template v0Data_as(); // V0 element from LF table containing V0 info + if (!v0.has_v0Data()) { // check that V0 data are stored + continue; + } + + // V0 positive daughter + auto trackV0PosDau = v0Element.template posTrack_as(); // p <- V0 track (positive track) from TTracks table + // V0 negative daughter + auto trackV0NegDau = v0Element.template negTrack_as(); // pion <- V0 track (negative track) from TTracks table + + // check that particles come from the same collision + if (rejDiffCollTrack) { + if (trackV0PosDau.collisionId() != trackV0NegDau.collisionId()) { + continue; + } + if (trackPionFromXi.collisionId() != trackV0PosDau.collisionId()) { + continue; + } + } + + //--------------------------reconstruct V0 track--------------------------- + // pseudorapidity + // double pseudorapV0PosDau = trackV0PosDau.eta(); + // double pseudorapV0NegDau = trackV0NegDau.eta(); + + // pion & p <- V0 tracks + auto trackParCovV0PosDau = getTrackParCov(trackV0PosDau); + auto trackParCovV0NegDau = getTrackParCov(trackV0NegDau); + + // info from LF table + // std::array pVecV0 = {casc.pxlambda(), casc.pylambda(), casc.pzlambda()}; // pVec stands for vector containing the 3-momentum components + std::array vertexV0 = {casc.xlambda(), casc.ylambda(), casc.zlambda()}; + std::array pVecV0PosDau = {casc.pxpos(), casc.pypos(), casc.pzpos()}; + std::array pVecV0NegDau = {casc.pxneg(), casc.pyneg(), casc.pzneg()}; + + //-----------------------------reconstruct cascade track----------------------------- + // pseudorapidity + // double pseudorapPionFromXi = trackPionFromXi.eta(); + + // pion <- casc track to be processed with DCAfitter + auto trackParCovPionFromXi = getTrackParCov(trackPionFromXi); + + // info from LF table + std::array vertexCasc = {casc.x(), casc.y(), casc.z()}; + std::array pVecCasc = {casc.px(), casc.py(), casc.pz()}; + std::array covCasc = {0.}; + constexpr int MomInd[6] = {9, 13, 14, 18, 19, 20}; // cov matrix elements for momentum component + for (int i = 0; i < 6; i++) { + covCasc[MomInd[i]] = casc.momentumCovMat()[i]; + covCasc[i] = casc.positionCovMat()[i]; + } + + // create cascade track + o2::track::TrackParCov trackCasc; + if (trackPionFromXi.sign() > 0) { + trackCasc = o2::track::TrackParCov(vertexCasc, pVecCasc, covCasc, 1, true); + } else if (trackPionFromXi.sign() < 0) { + trackCasc = o2::track::TrackParCov(vertexCasc, pVecCasc, covCasc, -1, true); + } else { + continue; + } + + trackCasc.setAbsCharge(1); + trackCasc.setPID(o2::track::PID::XiMinus); + + std::array pVecPionFromXi = {casc.pxbach(), casc.pybach(), casc.pzbach()}; + + auto trackParVar0 = getTrackParCov(track0); + auto trackParVar1 = getTrackParCov(track1); + auto collision = rowTrackIndexXicPlus.collision(); + + /// Set the magnetic field from ccdb. + /// The static instance of the propagator was already modified in the HFTrackIndexSkimCreator, + /// but this is not true when running on Run2 data/MC already converted into AO2Ds. + auto bc = collision.template bc_as(); + if (runNumber != bc.runNumber()) { + LOG(info) << ">>>>>>>>>>>> Current run number: " << runNumber; + initCCDB(bc, runNumber, ccdb, isRun2 ? ccdbPathGrp : ccdbPathGrpMag, lut, isRun2); + bz = o2::base::Propagator::Instance()->getNominalBz(); + LOG(info) << ">>>>>>>>>>>> Magnetic field: " << bz; + // df.setBz(bz); /// put it outside the 'if'! Otherwise we have a difference wrt bz Configurable (< 1 permille) in Run2 conv. data + // df.print(); + } + df.setBz(bz); + + // reconstruct the 3-prong secondary vertex + if (df.process(trackParVar0, trackParVar1, trackCasc) == 0) { + continue; + } + + const auto& secondaryVertex = df.getPCACandidate(); + auto chi2SV = df.getChi2AtPCACandidate(); + auto covMatrixSV = df.calcPCACovMatrixFlat(); + hCovSVXX->Fill(covMatrixSV[0]); + hCovSVYY->Fill(covMatrixSV[2]); + hCovSVXZ->Fill(covMatrixSV[3]); + hCovSVZZ->Fill(covMatrixSV[5]); + trackParVar0 = df.getTrack(0); + trackParVar1 = df.getTrack(1); + trackCasc = df.getTrack(2); + + // get track momenta + std::array pVec0; + std::array pVec1; + std::array pVec2; + trackParVar0.getPxPyPzGlo(pVec0); + trackParVar1.getPxPyPzGlo(pVec1); + trackCasc.getPxPyPzGlo(pVec2); + + // get track impact parameters + // This modifies track momenta! + auto primaryVertex = getPrimaryVertex(collision); + auto covMatrixPV = primaryVertex.getCov(); + if constexpr (doPvRefit) { + /// use PV refit + /// Using it in the rowCandidateBase all dynamic columns shall take it into account + // coordinates + //primaryVertex.setX(rowTrackIndexXicPlus.pvRefitX()); + //primaryVertex.setY(rowTrackIndexXicPlus.pvRefitY()); + //primaryVertex.setZ(rowTrackIndexXicPlus.pvRefitZ()); + // covariance matrix + //primaryVertex.setSigmaX2(rowTrackIndexXicPlus.pvRefitSigmaX2()); + //primaryVertex.setSigmaXY(rowTrackIndexXicPlus.pvRefitSigmaXY()); + //primaryVertex.setSigmaY2(rowTrackIndexXicPlus.pvRefitSigmaY2()); + //primaryVertex.setSigmaXZ(rowTrackIndexXicPlus.pvRefitSigmaXZ()); + //primaryVertex.setSigmaYZ(rowTrackIndexXicPlus.pvRefitSigmaYZ()); + //primaryVertex.setSigmaZ2(rowTrackIndexXicPlus.pvRefitSigmaZ2()); + //covMatrixPV = primaryVertex.getCov(); + } + hCovPVXX->Fill(covMatrixPV[0]); + hCovPVYY->Fill(covMatrixPV[2]); + hCovPVXZ->Fill(covMatrixPV[3]); + hCovPVZZ->Fill(covMatrixPV[5]); + + // calculate impact parameter + o2::dataformats::DCA impactParameter0; + o2::dataformats::DCA impactParameter1; + o2::dataformats::DCA impactParameterCasc; + trackParVar0.propagateToDCA(primaryVertex, bz, &impactParameter0); + trackParVar1.propagateToDCA(primaryVertex, bz, &impactParameter1); + trackCasc.propagateToDCA(primaryVertex, bz, &impactParameterCasc); + hDcaXYProngs->Fill(track0.pt(), impactParameter0.getY()); + hDcaXYProngs->Fill(track1.pt(), impactParameter1.getY()); + //hDcaXYProngs->Fill(trackCasc.pt(), impactParameterCasc.getY()); + hDcaZProngs->Fill(track0.pt(), impactParameter0.getZ()); + hDcaZProngs->Fill(track1.pt(), impactParameter1.getZ()); + //hDcaZProngs->Fill(trackCasc.pt(), impactParameterCasc.getZ()); + + // set hfFlag + int hfFlag = 1 << aod::hf_cand_xicplustoxipipi::DecayType::XicPlusToXiPiPi; + + // get uncertainty of the decay length + double 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)); + auto errorDecayLengthXY = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, 0.) + getRotatedCovMatrixXX(covMatrixSV, phi, 0.)); + + // fill candidate table rows + rowCandidateBase(collision.globalIndex(), + rowTrackIndexXicPlus.prong0Id(), rowTrackIndexXicPlus.prong1Id(), rowTrackIndexXicPlus.cascadeId(), + trackPionFromXi.globalIndex(),v0Element.globalIndex(), v0Element.posTrackId(), v0Element.negTrackId(), + primaryVertex.getX(), primaryVertex.getY(), primaryVertex.getZ(), + secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], + errorDecayLength, errorDecayLengthXY, + chi2SV, + pVec0[0], pVec0[1], pVec0[2], + pVec1[0], pVec1[1], pVec1[2], + pVec2[0], pVec2[1], pVec2[2], + impactParameter0.getY(), impactParameter1.getY(), impactParameterCasc.getY(), + std::sqrt(impactParameter0.getSigmaY2()), std::sqrt(impactParameter1.getSigmaY2()), std::sqrt(impactParameterCasc.getSigmaY2()), + vertexCasc[0], vertexCasc[1], vertexCasc[2], + vertexV0[0], vertexV0[1], vertexV0[2], + pVecV0PosDau[0], pVecV0PosDau[1], pVecV0PosDau[2], + pVecV0NegDau[0], pVecV0NegDau[1], pVecV0NegDau[2], + pVecPionFromXi[0], pVecPionFromXi[1], pVecPionFromXi[2], + trackV0PosDau.dcaXY(), trackV0NegDau.dcaXY(), trackPionFromXi.dcaXY(), + hfFlag); + + // fill histograms + if (fillHistograms) { + // calculate invariant mass + auto arrayMomenta = std::array{pVec0, pVec1, pVec2}; + massXiPiPi = RecoDecay::m(std::move(arrayMomenta), std::array{massXiMinusFromPdg, massPionFromPdg, massPionFromPdg}); + hMass3->Fill(massXiPiPi); + } + } + } + + template + void runCreatorXicPlusWithKFParticle(aod::Collisions const& collisions, + CandType const& rowsTrackIndexXicPlus, + aod::V0sLinked const&, + V0Full const&, + CascFull const&, + TTracks const& tracks, + aod::BCsWithTimestamps const& bcWithTimeStamps) + { + // loop over triplets of track indices + for (const auto& rowTrackIndexXicPlus : rowsTrackIndexXicPlus) { + auto track0 = rowTrackIndexXicPlus.template prong0_as(); + auto track1 = rowTrackIndexXicPlus.template prong1_as(); + auto casc = rowTrackIndexXicPlus.template cascade_as(); + + // preselect cascade candidates + if (doCascadePreselection) { + if (std::abs(casc.dcaXYCascToPV()) > dcaXYToPVCascadeMax) { + continue; + } + if (std::abs(casc.mXi() - massXiMinusFromPdg) > massToleranceCascade) { + continue; + } + } + + //----------------accessing particles in the decay chain------------- + // cascade daughter - charged particle + auto trackPionFromXi = casc.template bachelor_as(); // pion <- xi track from TTracks table + // cascade daughter - V0 + auto v0 = casc.template v0_as(); + auto v0Element = v0.template v0Data_as(); // V0 element from LF table containing V0 info + if (!v0.has_v0Data()) { // check that V0 data are stored + continue; + } + // V0 positive daughter + auto trackV0PosDau = v0Element.template posTrack_as(); // p <- V0 track (positive track) from TTracks table + // V0 negative daughter + auto trackV0NegDau = v0Element.template negTrack_as(); // pion <- V0 track (negative track) from TTracks table + + // check that particles come from the same collision + if (rejDiffCollTrack) { + if (trackV0PosDau.collisionId() != trackV0NegDau.collisionId()) { + continue; + } + if (trackPionFromXi.collisionId() != trackV0PosDau.collisionId()) { + continue; + } + } + + //--------------------------reconstruct V0 track--------------------------- + // pseudorapidity + // double pseudorapV0PosDau = trackV0PosDau.eta(); + // double pseudorapV0NegDau = trackV0NegDau.eta(); + + // pion & p <- V0 tracks + auto trackParCovV0PosDau = getTrackParCov(trackV0PosDau); + auto trackParCovV0NegDau = getTrackParCov(trackV0NegDau); + + // info from LF table + // std::array pVecV0 = {casc.pxlambda(), casc.pylambda(), casc.pzlambda()}; // pVec stands for vector containing the 3-momentum components + // std::array vertexV0 = {casc.xlambda(), casc.ylambda(), casc.zlambda()}; + //std::array pVecV0PosDau = {casc.pxpos(), casc.pypos(), casc.pzpos()}; + //std::array pVecV0NegDau = {casc.pxneg(), casc.pyneg(), casc.pzneg()}; + + //-----------------------------reconstruct cascade track----------------------------- + // pseudorapidity + // double pseudorapPionFromXi = trackPionFromXi.eta(); + + // pion <- casc track to be processed with DCAfitter + auto trackParCovPionFromXi = getTrackParCov(trackPionFromXi); + + // info from LF table + std::array vertexCasc = {casc.x(), casc.y(), casc.z()}; + std::array pVecCasc = {casc.px(), casc.py(), casc.pz()}; + std::array covCasc = {0.}; + constexpr int MomInd[6] = {9, 13, 14, 18, 19, 20}; // cov matrix elements for momentum component + for (int i = 0; i < 6; i++) { + covCasc[MomInd[i]] = casc.momentumCovMat()[i]; + covCasc[i] = casc.positionCovMat()[i]; + } + + // create cascade track + o2::track::TrackParCov trackCasc; + if (trackPionFromXi.sign() > 0) { + trackCasc = o2::track::TrackParCov(vertexCasc, pVecCasc, covCasc, 1, true); + } else if (trackPionFromXi.sign() < 0) { + trackCasc = o2::track::TrackParCov(vertexCasc, pVecCasc, covCasc, -1, true); + } else { + continue; + } + + trackCasc.setAbsCharge(1); + trackCasc.setPID(o2::track::PID::XiMinus); + + //std::array pVecPionFromXi = {casc.pxbach(), casc.pybach(), casc.pzbach()}; + + auto trackParVar0 = getTrackParCov(track0); + auto trackParVar1 = getTrackParCov(track1); + auto collision = rowTrackIndexXicPlus.collision(); + + /// Set the magnetic field from ccdb. + /// The static instance of the propagator was already modified in the HFTrackIndexSkimCreator, + /// but this is not true when running on Run2 data/MC already converted into AO2Ds. + auto bc = collision.template bc_as(); + if (runNumber != bc.runNumber()) { + LOG(info) << ">>>>>>>>>>>> Current run number: " << runNumber; + initCCDB(bc, runNumber, ccdb, isRun2 ? ccdbPathGrp : ccdbPathGrpMag, lut, isRun2); + bz = o2::base::Propagator::Instance()->getNominalBz(); + LOG(info) << ">>>>>>>>>>>> Magnetic field: " << bz; + // df.setBz(bz); /// put it outside the 'if'! Otherwise we have a difference wrt bz Configurable (< 1 permille) in Run2 conv. data + // df.print(); + } + float covMatrixPV[6]; + + //KFParticle::SetField(bz); + //KFPVertex kfpVertex = createKFPVertexFromCollision(collision); + + if constexpr (doPvRefit) { + // to do + } + //kfpVertex.GetCovarianceMatrix(covMatrixPV); + //KFParticle KFPV(kfpVertex); + hCovPVXX->Fill(covMatrixPV[0]); + hCovPVYY->Fill(covMatrixPV[2]); + hCovPVXZ->Fill(covMatrixPV[3]); + hCovPVZZ->Fill(covMatrixPV[5]); + + /*KFPTrack kfpTrack0 = createKFPTrackFromTrack(track0); + KFPTrack kfpTrack1 = createKFPTrackFromTrack(track1); + KFPTrack kfpCasc = createKFPTrackFromTrack(trackCasc);*/ + + // fill candidate table rows + //rowCandidateBase(); + + // fill histograms + // if (fillHistograms) {} + } + } + + void processPvRefitWithDCAFitterN(aod::Collisions const& collisions, + aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, + aod::V0sLinked const& v0Linked, + V0Full const& v0s, + CascFull const& cascs, + aod::TracksWCovDca const& tracks, + aod::BCsWithTimestamps const& bcWithTimeStamps) + { + runCreatorXicPlusWithDcaFitter(collisions, rowsTrackIndexXicPlus, v0Linked, v0s, cascs, tracks, bcWithTimeStamps); + } + PROCESS_SWITCH(HfCandidateCreatorXicPlus, processPvRefitWithDCAFitterN, "Run candidate creator with PV refit", false); + + void processNoPvRefitWithDCAFitterN(aod::Collisions const& collisions, + aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, + aod::V0sLinked const& v0Linked, + V0Full const& v0s, + CascFull const& cascs, + aod::TracksWCovDca const& tracks, + aod::BCsWithTimestamps const& bcWithTimeStamps) + { + runCreatorXicPlusWithDcaFitter(collisions, rowsTrackIndexXicPlus, v0Linked, v0s, cascs, tracks, bcWithTimeStamps); + } + PROCESS_SWITCH(HfCandidateCreatorXicPlus, processNoPvRefitWithDCAFitterN, "Run candidate creator without PV refit", true); + + void processPvRefitWithKFParticle(aod::Collisions const& collisions, + aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, + aod::V0sLinked const& v0Linked, + V0Full const& v0s, + CascFull const& cascs, + aod::TracksWCovDca const& tracks, + aod::BCsWithTimestamps const& bcWithTimeStamps) + { + // runCreatorXicPlusWithKFParticle(collisions, rowsTrackIndexXicPlus, v0Linked, v0s, cascs, tracks, bcWithTimeStamps); + } + PROCESS_SWITCH(HfCandidateCreatorXicPlus, processPvRefitWithKFParticle, "Run candidate creator with PV refit", false); + + void processNoPvRefitWithKFParticle(aod::Collisions const& collisions, + aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, + aod::V0sLinked const& v0Linked, + V0Full const& v0s, + CascFull const& cascs, + aod::TracksWCovDca const& tracks, + aod::BCsWithTimestamps const& bcWithTimeStamps) + { + // runCreatorXicPlusWithKFParticle(collisions, rowsTrackIndexXicPlus, v0Linked, v0s, cascs, tracks, bcWithTimeStamps); + } + PROCESS_SWITCH(HfCandidateCreatorXicPlus, processNoPvRefitWithKFParticle, "Run candidate creator without PV refit", false); +}; //struct + +/// Performs MC matching. +struct HfCandidateCreatorXicPlusMc { + Produces rowMcMatchRec; + Produces rowMcMatchGen; + + Configurable matchXicPlusMc{"matchXicPlusMc", true, "Do MC matching for XicPlus"}; + + void init(InitContext const&) {} + + void processMc(aod::HfCandXicPlus const& candidates, + aod::TracksWMc const& tracks, + aod::McParticles const& mcParticles) + { + int indexRec = -1; + int8_t sign = -9; + int8_t flag = -9; + int8_t origin =-9; + int8_t debug = 0; + int8_t debugGenCharmBar = 0; + int8_t debugGenXi = 0; + int8_t debugGenLambda = 0; + + int pdgCodeXicPlus = Pdg::kXiCPlus; // 4232 + int pdgCodeXiMinus = kXiMinus; // 3312 + int pdgCodeLambda = kLambda0; // 3122 + int pdgCodePiPlus = kPiPlus; // 211 + int pdgCodePiMinus = kPiMinus; // -211 + int pdgCodeProton = kProton; // 2212 + + // Match reconstructed candidates. + for (const auto& candidate : candidates) { + flag = 0; + origin = 0; + debug = 0; + auto arrayDaughters = std::array{candidate.pi1FromXicPlus_as(), // pi <- Xic + candidate.pi2FromXicPlus_as(), // pi <- Xic + candidate.bachelor_as(), // pi <- cascade + candidate.posTrack_as(), // p <- lambda + candidate.negTrack_as()}; // pi <- lambda + auto arrayDaughtersCasc = std::array{candidate.bachelor_as(), + candidate.posTrack_as(), + candidate.negTrack_as()}; + auto arrayDaughtersV0 = std::array{candidate.posTrack_as(), + candidate.negTrack_as()}; + + // Xic matching + if (matchXicPlusMc) { + // Xic → pi pi pi pi p + indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, pdgCodeXicPlus, std::array{pdgCodePiPlus, pdgCodePiPlus, pdgCodePiMinus, pdgCodeProton, pdgCodePiMinus}, true, &sign, 3); + if (indexRec == -1) { + debug = 1; + } + if (indexRec > -1) { + // Xi- → pi pi p + indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughtersCasc, pdgCodeXiMinus, std::array{pdgCodePiMinus, pdgCodeProton, pdgCodePiMinus}, true, &sign, 2); + if (indexRec == -1) { + debug = 2; + } + if (indexRec > -1) { + // Lambda → p pi + indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughtersV0, pdgCodeLambda, std::array{pdgCodeProton, pdgCodePiMinus}, true, &sign, 1); + if (indexRec == -1) { + debug = 3; + } + if (indexRec > -1) { + flag = sign * (1 << aod::hf_cand_xicplustoxipipi::DecayType::XicPlusToXiPiPi); + } + } + } + } + + if (debug == 2 || debug == 3) { + LOGF(info, "WARNING: Charm baryon decays in the expected final state but the condition on the intermediate states are not fulfilled"); + } + rowMcMatchRec(flag, debug, origin); + + } // close loop over candidates + + // Match generated particles. + for (const auto& particle : mcParticles) { + flag = -9; + sign = -9; + debugGenCharmBar = 0; + debugGenXi = 0; + debugGenLambda = 0; + origin = 0; + if (matchXicPlusMc) { + // Xic → Xi pi pi + if (RecoDecay::isMatchedMCGen(mcParticles, particle, pdgCodeXicPlus, std::array{pdgCodeXiMinus, pdgCodePiPlus, pdgCodePiPlus}, true, &sign)) { + debugGenCharmBar = 1; + // Xi- -> Lambda pi + auto cascMC = mcParticles.rawIteratorAt(particle.daughtersIds().front()); + if (RecoDecay::isMatchedMCGen(mcParticles, cascMC, pdgCodeXiMinus, std::array{pdgCodeLambda, pdgCodePiMinus}, true)) { + debugGenXi = 1; + // Lambda -> p pi + auto v0MC = mcParticles.rawIteratorAt(cascMC.daughtersIds().front()); + if (RecoDecay::isMatchedMCGen(mcParticles, v0MC, pdgCodeLambda, std::array{pdgCodeProton, pdgCodePiMinus}, true)) { + debugGenLambda = 1; + flag = sign * (1 << aod::hf_cand_xicplustoxipipi::DecayType::XicPlusToXiPiPi); + } + } + } + } + rowMcMatchGen(flag, debugGenCharmBar, debugGenXi, debugGenLambda, origin); + } + } // close process + PROCESS_SWITCH(HfCandidateCreatorXicPlusMc, processMc, "Process MC", false); +}; // close struct + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc), + adaptAnalysisTask(cfgc)}; +} From 6116277fef19366c2fa5e3434734654a2fa258d8 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Wed, 20 Dec 2023 01:05:23 +0100 Subject: [PATCH 03/35] Regroup histogram filling, add unused variables to output tables, enable PV refit --- .../DataModel/CandidateReconstructionTables.h | 61 ++++---- .../candidateCreatorXicPlusToXiPiPi.cxx | 141 ++++++++++-------- 2 files changed, 111 insertions(+), 91 deletions(-) diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index da96d3caa41..97cf080bb9d 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1357,18 +1357,18 @@ DECLARE_SOA_COLUMN(PzPi1FromXicPlus, pzPi1FromXicPlus, float); DECLARE_SOA_COLUMN(PxPi2FromXicPlus, pxPi2FromXicPlus, float); DECLARE_SOA_COLUMN(PyPi2FromXicPlus, pyPi2FromXicPlus, float); DECLARE_SOA_COLUMN(PzPi2FromXicPlus, pzPi2FromXicPlus, float); -DECLARE_SOA_COLUMN(PxLambda, pxLambda, float); -DECLARE_SOA_COLUMN(PyLambda, pyLambda, float); -DECLARE_SOA_COLUMN(PzLambda, pzLambda, float); DECLARE_SOA_COLUMN(PxPiFromCasc, pxPiFromCasc, float); DECLARE_SOA_COLUMN(PyPiFromCasc, pyPiFromCasc, float); DECLARE_SOA_COLUMN(PzPiFromCasc, pzPiFromCasc, float); -DECLARE_SOA_COLUMN(PxPosV0Dau, pxPosV0Dau, float); -DECLARE_SOA_COLUMN(PyPosV0Dau, pyPosV0Dau, float); -DECLARE_SOA_COLUMN(PzPosV0Dau, pzPosV0Dau, float); -DECLARE_SOA_COLUMN(PxNegV0Dau, pxNegV0Dau, float); -DECLARE_SOA_COLUMN(PyNegV0Dau, pyNegV0Dau, float); -DECLARE_SOA_COLUMN(PzNegV0Dau, pzNegV0Dau, float); +DECLARE_SOA_COLUMN(PxLambda, pxLambda, float); +DECLARE_SOA_COLUMN(PyLambda, pyLambda, float); +DECLARE_SOA_COLUMN(PzLambda, pzLambda, float); +DECLARE_SOA_COLUMN(PxV0PosDau, pxV0PosDau, float); +DECLARE_SOA_COLUMN(PyV0PosDau, pyV0PosDau, float); +DECLARE_SOA_COLUMN(PzV0PosDau, pzV0PosDau, float); +DECLARE_SOA_COLUMN(PxV0NegDau, pxV0NegDau, float); +DECLARE_SOA_COLUMN(PyV0NegDau, pyV0NegDau, float); +DECLARE_SOA_COLUMN(PzV0NegDau, pzV0NegDau, float); DECLARE_SOA_COLUMN(ImpactParCascXY, impactParCascXY, float); DECLARE_SOA_COLUMN(ImpactParCascZ, impactParCascZ, float); DECLARE_SOA_COLUMN(ImpactParPi1FromXicPlusXY, impactParPi1FromXicPlusXY, float); @@ -1382,34 +1382,35 @@ DECLARE_SOA_INDEX_COLUMN(V0, v0); DECLARE_SOA_INDEX_COLUMN(Cascade, cascade); DECLARE_SOA_INDEX_COLUMN_FULL(Pi1FromXicPlus, pi1FromXicPlus, int, Tracks, "_pi1fromXicPlus"); DECLARE_SOA_INDEX_COLUMN_FULL(Pi2FromXicPlus, pi2FromXicPlus, int, Tracks, "_pi2fromXicPlus"); -DECLARE_SOA_COLUMN(InvMassLambda, invMassLambda, double); -DECLARE_SOA_COLUMN(InvMassCascade, invMassCascade, double); DECLARE_SOA_COLUMN(InvMassXicPlus, invMassXicPlus, double); -DECLARE_SOA_COLUMN(CosPAV0, cosPAV0, double); +DECLARE_SOA_COLUMN(InvMassCascade, invMassCascade, double); +DECLARE_SOA_COLUMN(InvMassLambda, invMassLambda, double); DECLARE_SOA_COLUMN(CosPAXicPlus, cosPAXicPlus, double); DECLARE_SOA_COLUMN(CosPACasc, cosPACasc, double); -DECLARE_SOA_COLUMN(CosPAXYV0, cosPAXYV0, double); +DECLARE_SOA_COLUMN(CosPAV0, cosPAV0, double); DECLARE_SOA_COLUMN(CosPAXYXicPlus, cosPAXYXicPlus, double); DECLARE_SOA_COLUMN(CosPAXYCasc, cosPAXYCasc, double); +DECLARE_SOA_COLUMN(CosPAXYV0, cosPAXYV0, double); +DECLARE_SOA_COLUMN(CTauXicPlus, ctauXicPlus, double); DECLARE_SOA_COLUMN(CTauCascade, ctauCascade, double); DECLARE_SOA_COLUMN(CTauV0, ctauV0, double); -DECLARE_SOA_COLUMN(CTauXicPlus, ctauXicPlus, double); -DECLARE_SOA_COLUMN(EtaV0PosDau, etaV0PosDau, double); -DECLARE_SOA_COLUMN(EtaV0NegDau, etaV0NegDau, double); -DECLARE_SOA_COLUMN(EtaPiFromCasc, etaPiFromCasc, double); -DECLARE_SOA_COLUMN(EtaPiFromXicPlus, etaPiFromXicPlus, double); DECLARE_SOA_COLUMN(EtaXicPlus, etaXicPlus, double); DECLARE_SOA_COLUMN(EtaCascade, etaCascade, double); +DECLARE_SOA_COLUMN(EtaPi1FromXicPlus, etaPi1FromXicPlus, double); +DECLARE_SOA_COLUMN(EtaPi2FromXicPlus, etaPi2FromXicPlus, double); +DECLARE_SOA_COLUMN(EtaPiFromCasc, etaPiFromCasc, double); DECLARE_SOA_COLUMN(EtaV0, etaV0, double); -DECLARE_SOA_COLUMN(DcaXYToPvV0Dau0, dcaXYToPvV0Dau0, float); // pos dau -DECLARE_SOA_COLUMN(DcaXYToPvV0Dau1, dcaXYToPvV0Dau1, float); // neg dau +DECLARE_SOA_COLUMN(EtaV0PosDau, etaV0PosDau, double); +DECLARE_SOA_COLUMN(EtaV0NegDau, etaV0NegDau, double); DECLARE_SOA_COLUMN(DcaXYToPvCascDau, dcaXYToPvCascDau, float); -DECLARE_SOA_COLUMN(DcaZToPvV0Dau0, dcaZToPvV0Dau0, float); -DECLARE_SOA_COLUMN(DcaZToPvV0Dau1, dcaZToPvV0Dau1, float); +DECLARE_SOA_COLUMN(DcaXYToPvV0PosDau, dcaXYToPvV0PosDau, float); +DECLARE_SOA_COLUMN(DcaXYToPvV0NegDau, dcaXYToPvV0NegDau, float); DECLARE_SOA_COLUMN(DcaZToPvCascDau, dcaZToPvCascDau, float); +DECLARE_SOA_COLUMN(DcaZToPvV0PosDau, dcaZToPvV0PosDau, float); +DECLARE_SOA_COLUMN(DcaZToPvV0NegDau, dcaZToPvV0NegDau, float); +DECLARE_SOA_COLUMN(DcaXicPlusDau, dcaXicPlusDau, float); DECLARE_SOA_COLUMN(DcaCascDau, dcaCascDau, float); DECLARE_SOA_COLUMN(DcaV0Dau, dcaV0Dau, float); -DECLARE_SOA_COLUMN(DcaXicPlusDau, dcaXicPlusDau, float); DECLARE_SOA_COLUMN(DecLenXicPlus, decLenXicPlus, double); DECLARE_SOA_COLUMN(DecLenCascade, decLenCascade, double); DECLARE_SOA_COLUMN(DecLenV0, decLenV0, double); @@ -1441,17 +1442,19 @@ DECLARE_SOA_TABLE(HfCandXicPlus, "AOD", "HFCANDXICPLUS", hf_cand_xicplustoxipipi::XDecayVtxXicPlus, hf_cand_xicplustoxipipi::YDecayVtxXicPlus, hf_cand_xicplustoxipipi::ZDecayVtxXicPlus, hf_cand_xicplustoxipipi::ErrorDecayLengthXicPlus, hf_cand_xicplustoxipipi::ErrorDecayLengthXYXicPlus, hf_cand_xicplustoxipipi::Chi2PCAXicPlus, + hf_cand_xicplustoxipipi::XDecayVtxCascade, hf_cand_xicplustoxipipi::YDecayVtxCascade, hf_cand_xicplustoxipipi::ZDecayVtxCascade, + hf_cand_xicplustoxipipi::XDecayVtxV0, hf_cand_xicplustoxipipi::YDecayVtxV0, hf_cand_xicplustoxipipi::ZDecayVtxV0, hf_cand_xicplustoxipipi::PxPi1FromXicPlus, hf_cand_xicplustoxipipi::PyPi1FromXicPlus, hf_cand_xicplustoxipipi::PzPi1FromXicPlus, hf_cand_xicplustoxipipi::PxPi2FromXicPlus, hf_cand_xicplustoxipipi::PyPi2FromXicPlus, hf_cand_xicplustoxipipi::PzPi2FromXicPlus, - hf_cand_xicplustoxipipi::PxXicPlus, hf_cand_xicplustoxipipi::PyXicPlus, hf_cand_xicplustoxipipi::PzXicPlus, + hf_cand_xicplustoxipipi::PxCasc, hf_cand_xicplustoxipipi::PyCasc, hf_cand_xicplustoxipipi::PzCasc, hf_cand_xicplustoxipipi::ImpactParPi1FromXicPlusXY,hf_cand_xicplustoxipipi::ImpactParPi2FromXicPlusXY,hf_cand_xicplustoxipipi::ImpactParCascXY, hf_cand_xicplustoxipipi::ErrImpactParPi1FromXicPlusXY, hf_cand_xicplustoxipipi::ErrImpactParPi2FromXicPlusXY, hf_cand_xicplustoxipipi::ErrImpactParCascXY, - hf_cand_xicplustoxipipi::XDecayVtxCascade, hf_cand_xicplustoxipipi::YDecayVtxCascade, hf_cand_xicplustoxipipi::ZDecayVtxCascade, - hf_cand_xicplustoxipipi::XDecayVtxV0, hf_cand_xicplustoxipipi::YDecayVtxV0, hf_cand_xicplustoxipipi::ZDecayVtxV0, - hf_cand_xicplustoxipipi::PxPosV0Dau, hf_cand_xicplustoxipipi::PyPosV0Dau, hf_cand_xicplustoxipipi::PzPosV0Dau, - hf_cand_xicplustoxipipi::PxNegV0Dau, hf_cand_xicplustoxipipi::PyNegV0Dau, hf_cand_xicplustoxipipi::PzNegV0Dau, hf_cand_xicplustoxipipi::PxPiFromCasc, hf_cand_xicplustoxipipi::PyPiFromCasc, hf_cand_xicplustoxipipi::PzPiFromCasc, - hf_cand_xicplustoxipipi::DcaXYToPvV0Dau0, hf_cand_xicplustoxipipi::DcaXYToPvV0Dau1,hf_cand_xicplustoxipipi::DcaXYToPvCascDau, + hf_cand_xicplustoxipipi::PxLambda, hf_cand_xicplustoxipipi::PyLambda, hf_cand_xicplustoxipipi::PzLambda, + hf_cand_xicplustoxipipi::PxV0PosDau, hf_cand_xicplustoxipipi::PyV0PosDau, hf_cand_xicplustoxipipi::PzV0PosDau, + hf_cand_xicplustoxipipi::PxV0NegDau, hf_cand_xicplustoxipipi::PyV0NegDau, hf_cand_xicplustoxipipi::PzV0NegDau, + hf_cand_xicplustoxipipi::DcaXYToPvCascDau, hf_cand_xicplustoxipipi::DcaXYToPvV0PosDau, hf_cand_xicplustoxipipi::DcaXYToPvV0NegDau, + hf_cand_xicplustoxipipi::EtaPiFromCasc, hf_cand_xicplustoxipipi::EtaV0PosDau, hf_cand_xicplustoxipipi::EtaV0NegDau, hf_track_index::HFflag); // table with results of reconstruction level MC matching diff --git a/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx index 82186416832..5235de70e2f 100644 --- a/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx @@ -10,10 +10,10 @@ // or submit itself to any jurisdiction. /// \file candidateCreatorXicToXiPiPi.cxx -/// \brief Reconstruction of Ξc± → Ξ∓ π± π± candidates +/// \brief Reconstruction of Ξc± → (Ξ∓ → (Λ → p π∓) π∓) π± π± candidates /// /// \author Jinjoo Seo , Heidelberg University -/// \author Phil Lennart Stahlhut , CERN +/// \author Phil Lennart Stahlhut , Heidelberg University #include #include @@ -79,7 +79,6 @@ struct HfCandidateCreatorXicPlus { double massPionFromPdg = MassPiPlus; int runNumber{0}; - float toMicrometers = 10000.; // from cm to µm double massPi{0.}; double massXi{0.}; double massXiPiPi{0.}; @@ -111,10 +110,10 @@ struct HfCandidateCreatorXicPlus { if ((std::accumulate(doprocessDF.begin(), doprocessDF.end(), 0) + std::accumulate(doprocessKF.begin(), doprocessKF.end(), 0)) != 1) { LOGP(fatal, "Only one process function can be enabled at a time."); } - if (std::accumulate(doprocessDF.begin(), doprocessDF.end(), 0) == 1) { + if ((std::accumulate(doprocessDF.begin(), doprocessDF.end(), 0) == 1) && fillHistograms) { hVertexerType->Fill(aod::hf_cand::VertexerType::DCAFitter); } - if (std::accumulate(doprocessKF.begin(), doprocessKF.end(), 0) == 1) { + if ((std::accumulate(doprocessKF.begin(), doprocessKF.end(), 0) == 1) && fillHistograms) { hVertexerType->Fill(aod::hf_cand::VertexerType::KfParticle); } } @@ -134,7 +133,6 @@ struct HfCandidateCreatorXicPlus { { // 3-prong vertex fitter o2::vertexing::DCAFitterN<3> df; - // df.setBz(bz); df.setPropagateToPCA(propagateToPCA); df.setMaxR(maxR); df.setMaxDZIni(maxDZIni); @@ -186,22 +184,22 @@ struct HfCandidateCreatorXicPlus { //--------------------------reconstruct V0 track--------------------------- // pseudorapidity - // double pseudorapV0PosDau = trackV0PosDau.eta(); - // double pseudorapV0NegDau = trackV0NegDau.eta(); + double pseudorapV0PosDau = trackV0PosDau.eta(); + double pseudorapV0NegDau = trackV0NegDau.eta(); // pion & p <- V0 tracks auto trackParCovV0PosDau = getTrackParCov(trackV0PosDau); auto trackParCovV0NegDau = getTrackParCov(trackV0NegDau); // info from LF table - // std::array pVecV0 = {casc.pxlambda(), casc.pylambda(), casc.pzlambda()}; // pVec stands for vector containing the 3-momentum components + std::array pVecV0 = {casc.pxlambda(), casc.pylambda(), casc.pzlambda()}; // pVec stands for vector containing the 3-momentum components std::array vertexV0 = {casc.xlambda(), casc.ylambda(), casc.zlambda()}; std::array pVecV0PosDau = {casc.pxpos(), casc.pypos(), casc.pzpos()}; std::array pVecV0NegDau = {casc.pxneg(), casc.pyneg(), casc.pzneg()}; //-----------------------------reconstruct cascade track----------------------------- // pseudorapidity - // double pseudorapPionFromXi = trackPionFromXi.eta(); + double pseudorapPionFromXi = trackPionFromXi.eta(); // pion <- casc track to be processed with DCAfitter auto trackParCovPionFromXi = getTrackParCov(trackPionFromXi); @@ -244,8 +242,6 @@ struct HfCandidateCreatorXicPlus { initCCDB(bc, runNumber, ccdb, isRun2 ? ccdbPathGrp : ccdbPathGrpMag, lut, isRun2); bz = o2::base::Propagator::Instance()->getNominalBz(); LOG(info) << ">>>>>>>>>>>> Magnetic field: " << bz; - // df.setBz(bz); /// put it outside the 'if'! Otherwise we have a difference wrt bz Configurable (< 1 permille) in Run2 conv. data - // df.print(); } df.setBz(bz); @@ -257,10 +253,6 @@ struct HfCandidateCreatorXicPlus { const auto& secondaryVertex = df.getPCACandidate(); auto chi2SV = df.getChi2AtPCACandidate(); auto covMatrixSV = df.calcPCACovMatrixFlat(); - hCovSVXX->Fill(covMatrixSV[0]); - hCovSVYY->Fill(covMatrixSV[2]); - hCovSVXZ->Fill(covMatrixSV[3]); - hCovSVZZ->Fill(covMatrixSV[5]); trackParVar0 = df.getTrack(0); trackParVar1 = df.getTrack(1); trackCasc = df.getTrack(2); @@ -281,22 +273,18 @@ struct HfCandidateCreatorXicPlus { /// use PV refit /// Using it in the rowCandidateBase all dynamic columns shall take it into account // coordinates - //primaryVertex.setX(rowTrackIndexXicPlus.pvRefitX()); - //primaryVertex.setY(rowTrackIndexXicPlus.pvRefitY()); - //primaryVertex.setZ(rowTrackIndexXicPlus.pvRefitZ()); + primaryVertex.setX(rowTrackIndexXicPlus.pvRefitX()); + primaryVertex.setY(rowTrackIndexXicPlus.pvRefitY()); + primaryVertex.setZ(rowTrackIndexXicPlus.pvRefitZ()); // covariance matrix - //primaryVertex.setSigmaX2(rowTrackIndexXicPlus.pvRefitSigmaX2()); - //primaryVertex.setSigmaXY(rowTrackIndexXicPlus.pvRefitSigmaXY()); - //primaryVertex.setSigmaY2(rowTrackIndexXicPlus.pvRefitSigmaY2()); - //primaryVertex.setSigmaXZ(rowTrackIndexXicPlus.pvRefitSigmaXZ()); - //primaryVertex.setSigmaYZ(rowTrackIndexXicPlus.pvRefitSigmaYZ()); - //primaryVertex.setSigmaZ2(rowTrackIndexXicPlus.pvRefitSigmaZ2()); - //covMatrixPV = primaryVertex.getCov(); + primaryVertex.setSigmaX2(rowTrackIndexXicPlus.pvRefitSigmaX2()); + primaryVertex.setSigmaXY(rowTrackIndexXicPlus.pvRefitSigmaXY()); + primaryVertex.setSigmaY2(rowTrackIndexXicPlus.pvRefitSigmaY2()); + primaryVertex.setSigmaXZ(rowTrackIndexXicPlus.pvRefitSigmaXZ()); + primaryVertex.setSigmaYZ(rowTrackIndexXicPlus.pvRefitSigmaYZ()); + primaryVertex.setSigmaZ2(rowTrackIndexXicPlus.pvRefitSigmaZ2()); + covMatrixPV = primaryVertex.getCov(); } - hCovPVXX->Fill(covMatrixPV[0]); - hCovPVYY->Fill(covMatrixPV[2]); - hCovPVXZ->Fill(covMatrixPV[3]); - hCovPVZZ->Fill(covMatrixPV[5]); // calculate impact parameter o2::dataformats::DCA impactParameter0; @@ -305,22 +293,43 @@ struct HfCandidateCreatorXicPlus { trackParVar0.propagateToDCA(primaryVertex, bz, &impactParameter0); trackParVar1.propagateToDCA(primaryVertex, bz, &impactParameter1); trackCasc.propagateToDCA(primaryVertex, bz, &impactParameterCasc); - hDcaXYProngs->Fill(track0.pt(), impactParameter0.getY()); - hDcaXYProngs->Fill(track1.pt(), impactParameter1.getY()); - //hDcaXYProngs->Fill(trackCasc.pt(), impactParameterCasc.getY()); - hDcaZProngs->Fill(track0.pt(), impactParameter0.getZ()); - hDcaZProngs->Fill(track1.pt(), impactParameter1.getZ()); - //hDcaZProngs->Fill(trackCasc.pt(), impactParameterCasc.getZ()); // set hfFlag int hfFlag = 1 << aod::hf_cand_xicplustoxipipi::DecayType::XicPlusToXiPiPi; + // calculate invariant mass + auto arrayMomenta = std::array{pVec0, pVec1, pVec2}; + massXiPiPi = RecoDecay::m(std::move(arrayMomenta), std::array{massXiMinusFromPdg, massPionFromPdg, massPionFromPdg}); + // get uncertainty of the decay length double 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)); auto errorDecayLengthXY = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, 0.) + getRotatedCovMatrixXX(covMatrixSV, phi, 0.)); + // fill histograms + if (fillHistograms) { + // invariant mass + hMass3->Fill(massXiPiPi); + // covariance matrix elements of PV + hCovPVXX->Fill(covMatrixPV[0]); + hCovPVYY->Fill(covMatrixPV[2]); + hCovPVXZ->Fill(covMatrixPV[3]); + hCovPVZZ->Fill(covMatrixPV[5]); + // covariance matrix elements of SV + hCovSVXX->Fill(covMatrixSV[0]); + hCovSVYY->Fill(covMatrixSV[2]); + hCovSVXZ->Fill(covMatrixSV[3]); + hCovSVZZ->Fill(covMatrixSV[5]); + // DCAs of prongs + hDcaXYProngs->Fill(track0.pt(), impactParameter0.getY()); + hDcaXYProngs->Fill(track1.pt(), impactParameter1.getY()); + //hDcaXYProngs->Fill(trackCasc.pt(), impactParameterCasc.getY()); + hDcaZProngs->Fill(track0.pt(), impactParameter0.getZ()); + hDcaZProngs->Fill(track1.pt(), impactParameter1.getZ()); + //hDcaZProngs->Fill(trackCasc.pt(), impactParameterCasc.getZ()); + } + // fill candidate table rows rowCandidateBase(collision.globalIndex(), rowTrackIndexXicPlus.prong0Id(), rowTrackIndexXicPlus.prong1Id(), rowTrackIndexXicPlus.cascadeId(), @@ -329,28 +338,22 @@ struct HfCandidateCreatorXicPlus { secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], errorDecayLength, errorDecayLengthXY, chi2SV, + vertexCasc[0], vertexCasc[1], vertexCasc[2], + vertexV0[0], vertexV0[1], vertexV0[2], pVec0[0], pVec0[1], pVec0[2], pVec1[0], pVec1[1], pVec1[2], pVec2[0], pVec2[1], pVec2[2], impactParameter0.getY(), impactParameter1.getY(), impactParameterCasc.getY(), std::sqrt(impactParameter0.getSigmaY2()), std::sqrt(impactParameter1.getSigmaY2()), std::sqrt(impactParameterCasc.getSigmaY2()), - vertexCasc[0], vertexCasc[1], vertexCasc[2], - vertexV0[0], vertexV0[1], vertexV0[2], + pVecPionFromXi[0], pVecPionFromXi[1], pVecPionFromXi[2], + pVecV0[0], pVecV0[1], pVecV0[2], pVecV0PosDau[0], pVecV0PosDau[1], pVecV0PosDau[2], pVecV0NegDau[0], pVecV0NegDau[1], pVecV0NegDau[2], - pVecPionFromXi[0], pVecPionFromXi[1], pVecPionFromXi[2], - trackV0PosDau.dcaXY(), trackV0NegDau.dcaXY(), trackPionFromXi.dcaXY(), + trackPionFromXi.dcaXY(), trackV0PosDau.dcaXY(), trackV0NegDau.dcaXY(), + pseudorapPionFromXi, pseudorapV0PosDau, pseudorapV0NegDau, hfFlag); - - // fill histograms - if (fillHistograms) { - // calculate invariant mass - auto arrayMomenta = std::array{pVec0, pVec1, pVec2}; - massXiPiPi = RecoDecay::m(std::move(arrayMomenta), std::array{massXiMinusFromPdg, massPionFromPdg, massPionFromPdg}); - hMass3->Fill(massXiPiPi); - } - } - } + } // loop over track triplets + } // template template void runCreatorXicPlusWithKFParticle(aod::Collisions const& collisions, @@ -461,8 +464,6 @@ struct HfCandidateCreatorXicPlus { initCCDB(bc, runNumber, ccdb, isRun2 ? ccdbPathGrp : ccdbPathGrpMag, lut, isRun2); bz = o2::base::Propagator::Instance()->getNominalBz(); LOG(info) << ">>>>>>>>>>>> Magnetic field: " << bz; - // df.setBz(bz); /// put it outside the 'if'! Otherwise we have a difference wrt bz Configurable (< 1 permille) in Run2 conv. data - // df.print(); } float covMatrixPV[6]; @@ -474,25 +475,41 @@ struct HfCandidateCreatorXicPlus { } //kfpVertex.GetCovarianceMatrix(covMatrixPV); //KFParticle KFPV(kfpVertex); - hCovPVXX->Fill(covMatrixPV[0]); - hCovPVYY->Fill(covMatrixPV[2]); - hCovPVXZ->Fill(covMatrixPV[3]); - hCovPVZZ->Fill(covMatrixPV[5]); + /*KFPTrack kfpTrack0 = createKFPTrackFromTrack(track0); KFPTrack kfpTrack1 = createKFPTrackFromTrack(track1); KFPTrack kfpCasc = createKFPTrackFromTrack(trackCasc);*/ + // fill histograms + /*if (fillHistograms) { + // invariant mass + hMass3->Fill(massXiPiPi); + // covariance matrix elements of PV + hCovPVXX->Fill(covMatrixPV[0]); + hCovPVYY->Fill(covMatrixPV[2]); + hCovPVXZ->Fill(covMatrixPV[3]); + hCovPVZZ->Fill(covMatrixPV[5]); + // covariance matrix elements of SV + hCovSVXX->Fill(covMatrixSV[0]); + hCovSVYY->Fill(covMatrixSV[2]); + hCovSVXZ->Fill(covMatrixSV[3]); + hCovSVZZ->Fill(covMatrixSV[5]); + // DCAs of prongs + hDcaXYProngs->Fill(track0.pt(), impactParameter0.getY()); + hDcaXYProngs->Fill(track1.pt(), impactParameter1.getY()); + //hDcaXYProngs->Fill(trackCasc.pt(), impactParameterCasc.getY()); + hDcaZProngs->Fill(track0.pt(), impactParameter0.getZ()); + hDcaZProngs->Fill(track1.pt(), impactParameter1.getZ()); + //hDcaZProngs->Fill(trackCasc.pt(), impactParameterCasc.getZ()); + }*/ // fill candidate table rows //rowCandidateBase(); - - // fill histograms - // if (fillHistograms) {} - } - } + } // loop over track triplets + } // template void processPvRefitWithDCAFitterN(aod::Collisions const& collisions, - aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, + soa::Join const& rowsTrackIndexXicPlus, aod::V0sLinked const& v0Linked, V0Full const& v0s, CascFull const& cascs, From 4fb4b8a332f080a54b0ea872d492cd6ec283a866 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Fri, 19 Jan 2024 14:46:12 +0100 Subject: [PATCH 04/35] First version of candidate creator employing KF Particle --- .../DataModel/CandidateReconstructionTables.h | 24 +- .../candidateCreatorXicPlusToXiPiPi.cxx | 307 +++++++++--------- 2 files changed, 176 insertions(+), 155 deletions(-) diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index 97cf080bb9d..53f49c6ad01 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1437,7 +1437,7 @@ DECLARE_SOA_TABLE(HfCandXicPlus, "AOD", "HFCANDXICPLUS", o2::soa::Index<>, hf_cand_xicplustoxipipi::CollisionId, hf_cand_xicplustoxipipi::Pi1FromXicPlusId, hf_cand_xicplustoxipipi::Pi2FromXicPlusId, hf_cand_xicplustoxipipi::CascadeId, - cascdata::BachelorId, hf_cand_xicplustoxipipi::V0Id, v0data::PosTrackId, v0data::NegTrackId, + cascdata::BachelorId, v0data::PosTrackId, v0data::NegTrackId, hf_cand_xicplustoxipipi::XPv, hf_cand_xicplustoxipipi::YPv, hf_cand_xicplustoxipipi::ZPv, hf_cand_xicplustoxipipi::XDecayVtxXicPlus, hf_cand_xicplustoxipipi::YDecayVtxXicPlus, hf_cand_xicplustoxipipi::ZDecayVtxXicPlus, hf_cand_xicplustoxipipi::ErrorDecayLengthXicPlus, hf_cand_xicplustoxipipi::ErrorDecayLengthXYXicPlus, @@ -1457,6 +1457,28 @@ DECLARE_SOA_TABLE(HfCandXicPlus, "AOD", "HFCANDXICPLUS", hf_cand_xicplustoxipipi::EtaPiFromCasc, hf_cand_xicplustoxipipi::EtaV0PosDau, hf_cand_xicplustoxipipi::EtaV0NegDau, hf_track_index::HFflag); +DECLARE_SOA_TABLE(HfCandXicPlusKF, "AOD", "HFCANDXICPLUSKF", + o2::soa::Index<>, + hf_cand_xicplustoxipipi::CollisionId, + hf_cand_xicplustoxipipi::Pi1FromXicPlusId, hf_cand_xicplustoxipipi::Pi2FromXicPlusId, hf_cand_xicplustoxipipi::CascadeId, + cascdata::BachelorId, v0data::PosTrackId, v0data::NegTrackId, + hf_cand_xicplustoxipipi::XPv, hf_cand_xicplustoxipipi::YPv, hf_cand_xicplustoxipipi::ZPv, + hf_cand_xicplustoxipipi::XDecayVtxXicPlus, hf_cand_xicplustoxipipi::YDecayVtxXicPlus, hf_cand_xicplustoxipipi::ZDecayVtxXicPlus, + hf_cand_xicplustoxipipi::ErrorDecayLengthXicPlus, hf_cand_xicplustoxipipi::ErrorDecayLengthXYXicPlus, + hf_cand_xicplustoxipipi::Chi2PCAXicPlus, + hf_cand_xicplustoxipipi::XDecayVtxCascade, hf_cand_xicplustoxipipi::YDecayVtxCascade, hf_cand_xicplustoxipipi::ZDecayVtxCascade, + hf_cand_xicplustoxipipi::XDecayVtxV0, hf_cand_xicplustoxipipi::YDecayVtxV0, hf_cand_xicplustoxipipi::ZDecayVtxV0, + hf_cand_xicplustoxipipi::PxPi1FromXicPlus, hf_cand_xicplustoxipipi::PyPi1FromXicPlus, hf_cand_xicplustoxipipi::PzPi1FromXicPlus, + hf_cand_xicplustoxipipi::PxPi2FromXicPlus, hf_cand_xicplustoxipipi::PyPi2FromXicPlus, hf_cand_xicplustoxipipi::PzPi2FromXicPlus, + hf_cand_xicplustoxipipi::PxCasc, hf_cand_xicplustoxipipi::PyCasc, hf_cand_xicplustoxipipi::PzCasc, + hf_cand_xicplustoxipipi::ImpactParPi1FromXicPlusXY,hf_cand_xicplustoxipipi::ImpactParPi2FromXicPlusXY,hf_cand_xicplustoxipipi::ImpactParCascXY, + hf_cand_xicplustoxipipi::ErrImpactParPi1FromXicPlusXY, hf_cand_xicplustoxipipi::ErrImpactParPi2FromXicPlusXY, hf_cand_xicplustoxipipi::ErrImpactParCascXY, + hf_cand_xicplustoxipipi::PxPiFromCasc, hf_cand_xicplustoxipipi::PyPiFromCasc, hf_cand_xicplustoxipipi::PzPiFromCasc, + hf_cand_xicplustoxipipi::PxLambda, hf_cand_xicplustoxipipi::PyLambda, hf_cand_xicplustoxipipi::PzLambda, + hf_cand_xicplustoxipipi::PxV0PosDau, hf_cand_xicplustoxipipi::PyV0PosDau, hf_cand_xicplustoxipipi::PzV0PosDau, + hf_cand_xicplustoxipipi::PxV0NegDau, hf_cand_xicplustoxipipi::PyV0NegDau, hf_cand_xicplustoxipipi::PzV0NegDau, + hf_track_index::HFflag); + // table with results of reconstruction level MC matching DECLARE_SOA_TABLE(HfXicPlusMcRec, "AOD", "HFXICPLUSMCREC", //! hf_cand_xicplustoxipipi::FlagMcMatchRec, diff --git a/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx index 5235de70e2f..ccd731cb55b 100644 --- a/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx @@ -15,6 +15,10 @@ /// \author Jinjoo Seo , Heidelberg University /// \author Phil Lennart Stahlhut , Heidelberg University +#ifndef HomogeneousField +#define HomogeneousField +#endif + #include #include #include @@ -46,18 +50,21 @@ using namespace o2::framework; /// Reconstruction of heavy-flavour 3-prong decay candidates struct HfCandidateCreatorXicPlus { Produces rowCandidateBase; + Produces rowCandidateKF; // vertexing + Configurable rejDiffCollTrack{"rejDiffCollTrack", true, "Reject tracks coming from different collisions"}; + Configurable fillHistograms{"fillHistograms", true, "do validation plots"}; + // DCA fitter Configurable propagateToPCA{"propagateToPCA", true, "create tracks version propagated to PCA"}; - Configurable useAbsDCA{"useAbsDCA", false, "Minimise abs. distance rather than chi2"}; - Configurable useWeightedFinalPCA{"useWeightedFinalPCA", false, "Recalculate vertex position using track covariances, effective only if useAbsDCA is true"}; Configurable maxR{"maxR", 200., "reject PCA's above this radius"}; Configurable maxDZIni{"maxDZIni", 4., "reject (if>0) PCA candidate if tracks DZ exceeds threshold"}; Configurable minParamChange{"minParamChange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; Configurable minRelChi2Change{"minRelChi2Change", 0.9, "stop iterations is chi2/chi2old > this"}; - Configurable maxChi2{"maxChi2", 100., "discard vertices with chi2/Nprongs > this (or sum{DCAi^2}/Nprongs for abs. distance minimization)"}; - Configurable rejDiffCollTrack{"rejDiffCollTrack", true, "Reject tracks coming from different collisions"}; - Configurable fillHistograms{"fillHistograms", true, "do validation plots"}; + Configurable useAbsDCA{"useAbsDCA", false, "Minimise abs. distance rather than chi2"}; + Configurable useWeightedFinalPCA{"useWeightedFinalPCA", false, "Recalculate vertex position using track covariances, 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)"}; + // KFParticle // magnetic field setting from CCDB Configurable isRun2{"isRun2", false, "enable Run 2 or Run 3 GRP objects for magnetic field"}; @@ -118,18 +125,19 @@ struct HfCandidateCreatorXicPlus { } } - // Will be modified + //using V0Full = soa::Join; using CascFull = soa::Join; - using V0Full = soa::Join; + using CascFullKF = soa::Join; + template void runCreatorXicPlusWithDcaFitter(aod::Collisions const& collisions, - CandType const& rowsTrackIndexXicPlus, - aod::V0sLinked const& v0Linked, - V0Full const& v0s, - CascFull const& cascs, - TTracks const& tracks, - aod::BCsWithTimestamps const& bcWithTimeStamps) + CandType const& rowsTrackIndexXicPlus, + // aod::V0sLinked const& v0Linked, + // V0Full const& v0s, + CascFull const& cascs, + TTracks const& tracks, + aod::BCsWithTimestamps const& bcWithTimeStamps) { // 3-prong vertex fitter o2::vertexing::DCAFitterN<3> df; @@ -161,16 +169,16 @@ struct HfCandidateCreatorXicPlus { // cascade daughter - charged particle auto trackPionFromXi = casc.template bachelor_as(); // pion <- xi track from TTracks table // cascade daughter - V0 - auto v0 = casc.template v0_as(); + /*auto v0 = casc.template v0_as(); auto v0Element = v0.template v0Data_as(); // V0 element from LF table containing V0 info if (!v0.has_v0Data()) { // check that V0 data are stored continue; - } + }*/ // V0 positive daughter - auto trackV0PosDau = v0Element.template posTrack_as(); // p <- V0 track (positive track) from TTracks table + auto trackV0PosDau = casc.template posTrack_as(); // p <- V0 track (positive track) from TTracks table // V0 negative daughter - auto trackV0NegDau = v0Element.template negTrack_as(); // pion <- V0 track (negative track) from TTracks table + auto trackV0NegDau = casc.template negTrack_as(); // pion <- V0 track (negative track) from TTracks table // check that particles come from the same collision if (rejDiffCollTrack) { @@ -183,25 +191,25 @@ struct HfCandidateCreatorXicPlus { } //--------------------------reconstruct V0 track--------------------------- - // pseudorapidity + // pseudorapidity (only to store in candidate table) double pseudorapV0PosDau = trackV0PosDau.eta(); double pseudorapV0NegDau = trackV0NegDau.eta(); - // pion & p <- V0 tracks + // pion & p <- V0 tracks (unused?) auto trackParCovV0PosDau = getTrackParCov(trackV0PosDau); auto trackParCovV0NegDau = getTrackParCov(trackV0NegDau); - // info from LF table + // info from LF table (only to store in candidate table) std::array pVecV0 = {casc.pxlambda(), casc.pylambda(), casc.pzlambda()}; // pVec stands for vector containing the 3-momentum components std::array vertexV0 = {casc.xlambda(), casc.ylambda(), casc.zlambda()}; std::array pVecV0PosDau = {casc.pxpos(), casc.pypos(), casc.pzpos()}; std::array pVecV0NegDau = {casc.pxneg(), casc.pyneg(), casc.pzneg()}; //-----------------------------reconstruct cascade track----------------------------- - // pseudorapidity + // pseudorapidity (only to store in candidate table) double pseudorapPionFromXi = trackPionFromXi.eta(); - // pion <- casc track to be processed with DCAfitter + // pion <- casc track to be processed with DCAfitter (unused?) auto trackParCovPionFromXi = getTrackParCov(trackPionFromXi); // info from LF table @@ -250,14 +258,18 @@ struct HfCandidateCreatorXicPlus { continue; } + // set hfFlag + int hfFlag = BIT(aod::hf_cand_xicplustoxipipi::DecayType::XicPlusToXiPiPi); + + // get SV properties const auto& secondaryVertex = df.getPCACandidate(); auto chi2SV = df.getChi2AtPCACandidate(); auto covMatrixSV = df.calcPCACovMatrixFlat(); + + // get track momenta trackParVar0 = df.getTrack(0); trackParVar1 = df.getTrack(1); trackCasc = df.getTrack(2); - - // get track momenta std::array pVec0; std::array pVec1; std::array pVec2; @@ -285,7 +297,6 @@ struct HfCandidateCreatorXicPlus { primaryVertex.setSigmaZ2(rowTrackIndexXicPlus.pvRefitSigmaZ2()); covMatrixPV = primaryVertex.getCov(); } - // calculate impact parameter o2::dataformats::DCA impactParameter0; o2::dataformats::DCA impactParameter1; @@ -294,10 +305,7 @@ struct HfCandidateCreatorXicPlus { trackParVar1.propagateToDCA(primaryVertex, bz, &impactParameter1); trackCasc.propagateToDCA(primaryVertex, bz, &impactParameterCasc); - // set hfFlag - int hfFlag = 1 << aod::hf_cand_xicplustoxipipi::DecayType::XicPlusToXiPiPi; - - // calculate invariant mass + // get invariant mass auto arrayMomenta = std::array{pVec0, pVec1, pVec2}; massXiPiPi = RecoDecay::m(std::move(arrayMomenta), std::array{massXiMinusFromPdg, massPionFromPdg, massPionFromPdg}); @@ -333,7 +341,7 @@ struct HfCandidateCreatorXicPlus { // fill candidate table rows rowCandidateBase(collision.globalIndex(), rowTrackIndexXicPlus.prong0Id(), rowTrackIndexXicPlus.prong1Id(), rowTrackIndexXicPlus.cascadeId(), - trackPionFromXi.globalIndex(),v0Element.globalIndex(), v0Element.posTrackId(), v0Element.negTrackId(), + trackPionFromXi.globalIndex(), casc.posTrackId(), casc.negTrackId(), primaryVertex.getX(), primaryVertex.getY(), primaryVertex.getZ(), secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], errorDecayLength, errorDecayLengthXY, @@ -355,20 +363,32 @@ struct HfCandidateCreatorXicPlus { } // loop over track triplets } // template + /*// Cascade to KFParticle converter + KFParticle createKFParticleFromKFCascTables(CascFullKF const& cascKF) + { + // read {X,Y,Z,Px,Py,Pz} and corresponding covariance matrix from KF cascade Tables + std::array parPosMom = {cascKF.x(), cascKF.y(), cascKF.z(), cascKF.px(), cascKF.py(), cascKF.pz()}; + std::array covPosMom = cascKF.kfTrackCovMatrix(); + + // create KFParticle + KFParticle kfCasc; + kfCasc.Create(parPosMom, covPosMom, cascKF.sign(), cascKF.m()); + return kfCasc; + }*/ + template void runCreatorXicPlusWithKFParticle(aod::Collisions const& collisions, - CandType const& rowsTrackIndexXicPlus, - aod::V0sLinked const&, - V0Full const&, - CascFull const&, - TTracks const& tracks, - aod::BCsWithTimestamps const& bcWithTimeStamps) + CandType const& rowsTrackIndexXicPlus, + CascFullKF const&, + TTracks const& tracks, + aod::BCsWithTimestamps const& bcWithTimeStamps) { // loop over triplets of track indices for (const auto& rowTrackIndexXicPlus : rowsTrackIndexXicPlus) { auto track0 = rowTrackIndexXicPlus.template prong0_as(); auto track1 = rowTrackIndexXicPlus.template prong1_as(); - auto casc = rowTrackIndexXicPlus.template cascade_as(); + auto casc = rowTrackIndexXicPlus.template cascade_as(); + auto collision = rowTrackIndexXicPlus.collision(); // preselect cascade candidates if (doCascadePreselection) { @@ -380,81 +400,6 @@ struct HfCandidateCreatorXicPlus { } } - //----------------accessing particles in the decay chain------------- - // cascade daughter - charged particle - auto trackPionFromXi = casc.template bachelor_as(); // pion <- xi track from TTracks table - // cascade daughter - V0 - auto v0 = casc.template v0_as(); - auto v0Element = v0.template v0Data_as(); // V0 element from LF table containing V0 info - if (!v0.has_v0Data()) { // check that V0 data are stored - continue; - } - // V0 positive daughter - auto trackV0PosDau = v0Element.template posTrack_as(); // p <- V0 track (positive track) from TTracks table - // V0 negative daughter - auto trackV0NegDau = v0Element.template negTrack_as(); // pion <- V0 track (negative track) from TTracks table - - // check that particles come from the same collision - if (rejDiffCollTrack) { - if (trackV0PosDau.collisionId() != trackV0NegDau.collisionId()) { - continue; - } - if (trackPionFromXi.collisionId() != trackV0PosDau.collisionId()) { - continue; - } - } - - //--------------------------reconstruct V0 track--------------------------- - // pseudorapidity - // double pseudorapV0PosDau = trackV0PosDau.eta(); - // double pseudorapV0NegDau = trackV0NegDau.eta(); - - // pion & p <- V0 tracks - auto trackParCovV0PosDau = getTrackParCov(trackV0PosDau); - auto trackParCovV0NegDau = getTrackParCov(trackV0NegDau); - - // info from LF table - // std::array pVecV0 = {casc.pxlambda(), casc.pylambda(), casc.pzlambda()}; // pVec stands for vector containing the 3-momentum components - // std::array vertexV0 = {casc.xlambda(), casc.ylambda(), casc.zlambda()}; - //std::array pVecV0PosDau = {casc.pxpos(), casc.pypos(), casc.pzpos()}; - //std::array pVecV0NegDau = {casc.pxneg(), casc.pyneg(), casc.pzneg()}; - - //-----------------------------reconstruct cascade track----------------------------- - // pseudorapidity - // double pseudorapPionFromXi = trackPionFromXi.eta(); - - // pion <- casc track to be processed with DCAfitter - auto trackParCovPionFromXi = getTrackParCov(trackPionFromXi); - - // info from LF table - std::array vertexCasc = {casc.x(), casc.y(), casc.z()}; - std::array pVecCasc = {casc.px(), casc.py(), casc.pz()}; - std::array covCasc = {0.}; - constexpr int MomInd[6] = {9, 13, 14, 18, 19, 20}; // cov matrix elements for momentum component - for (int i = 0; i < 6; i++) { - covCasc[MomInd[i]] = casc.momentumCovMat()[i]; - covCasc[i] = casc.positionCovMat()[i]; - } - - // create cascade track - o2::track::TrackParCov trackCasc; - if (trackPionFromXi.sign() > 0) { - trackCasc = o2::track::TrackParCov(vertexCasc, pVecCasc, covCasc, 1, true); - } else if (trackPionFromXi.sign() < 0) { - trackCasc = o2::track::TrackParCov(vertexCasc, pVecCasc, covCasc, -1, true); - } else { - continue; - } - - trackCasc.setAbsCharge(1); - trackCasc.setPID(o2::track::PID::XiMinus); - - //std::array pVecPionFromXi = {casc.pxbach(), casc.pybach(), casc.pzbach()}; - - auto trackParVar0 = getTrackParCov(track0); - auto trackParVar1 = getTrackParCov(track1); - auto collision = rowTrackIndexXicPlus.collision(); - /// Set the magnetic field from ccdb. /// The static instance of the propagator was already modified in the HFTrackIndexSkimCreator, /// but this is not true when running on Run2 data/MC already converted into AO2Ds. @@ -465,26 +410,66 @@ struct HfCandidateCreatorXicPlus { bz = o2::base::Propagator::Instance()->getNominalBz(); LOG(info) << ">>>>>>>>>>>> Magnetic field: " << bz; } - float covMatrixPV[6]; + KFParticle::SetField(bz); - //KFParticle::SetField(bz); - //KFPVertex kfpVertex = createKFPVertexFromCollision(collision); + // initialize primary vertex + KFPVertex kfpVertex = createKFPVertexFromCollision(collision); + float covMatrixPV[6]; if constexpr (doPvRefit) { - // to do + kfpVertex.SetXYZ(rowTrackIndexXicPlus.pvRefitX(), rowTrackIndexXicPlus.pvRefitY(), rowTrackIndexXicPlus.pvRefitZ()); + // covariance matrix + kfpVertex.SetCovarianceMatrix(rowTrackIndexXicPlus.pvRefitSigmaX2(), rowTrackIndexXicPlus.pvRefitSigmaXY(), rowTrackIndexXicPlus.pvRefitSigmaY2(), rowTrackIndexXicPlus.pvRefitSigmaXZ(), rowTrackIndexXicPlus.pvRefitSigmaYZ(), rowTrackIndexXicPlus.pvRefitSigmaZ2()); } - //kfpVertex.GetCovarianceMatrix(covMatrixPV); - //KFParticle KFPV(kfpVertex); - + kfpVertex.GetCovarianceMatrix(covMatrixPV); + KFParticle KFPV(kfpVertex); - /*KFPTrack kfpTrack0 = createKFPTrackFromTrack(track0); + KFPTrack kfpTrack0 = createKFPTrackFromTrack(track0); KFPTrack kfpTrack1 = createKFPTrackFromTrack(track1); - KFPTrack kfpCasc = createKFPTrackFromTrack(trackCasc);*/ + KFParticle kfPion0(kfpTrack0, kPiPlus); + KFParticle kfPion1(kfpTrack1, kPiPlus); + //create Xi as KFParticle + // read {X,Y,Z,Px,Py,Pz} and corresponding covariance matrix from KF cascade Tables + std::array xyzpxpypz = {casc.x(), casc.y(), casc.z(), casc.px(), casc.py(), casc.pz()}; + float parPosMom[6]; + for (int i{0}; i < 6; ++i) { + parPosMom[i] =xyzpxpypz[i]; + } + // create KFParticle + KFParticle kfXi; + kfXi.Create(parPosMom, casc.kfTrackCovMat(), casc.sign(), casc.m(1)); + + KFParticle kfCandXicPlus; + const KFParticle* kfDaughtersXicPlus[3] = {&kfPion0, &kfPion1, &kfXi}; + kfCandXicPlus.SetConstructMethod(2); + kfCandXicPlus.Construct(kfDaughtersXicPlus, 3); + + // set hfFlag + int hfFlag = BIT(aod::hf_cand_xicplustoxipipi::DecayType::XicPlusToXiPiPi); + + auto covMatrixSV = kfCandXicPlus.CovarianceMatrix(); + auto massXicPlus = kfCandXicPlus.GetMass(); + auto chi2SV = kfCandXicPlus.GetChi2(); + + // get impact parameters of XicPlus daughters + float impactParameter0XY = 0., errImpactParameter0XY = 0.; + float impactParameter1XY = 0., errImpactParameter1XY = 0.; + float impactParameterXiXY = 0., errImpactParameterXiXY = 0.; + kfPion0.GetDistanceFromVertexXY(KFPV, impactParameter0XY, errImpactParameter0XY); + kfPion1.GetDistanceFromVertexXY(KFPV, impactParameter1XY, errImpactParameter1XY); + kfXi.GetDistanceFromVertexXY(KFPV, impactParameterXiXY, errImpactParameterXiXY); + + // get error of decay length + double phi, theta; + getPointDirection(std::array{KFPV.GetX(), KFPV.GetY(), KFPV.GetZ()}, std::array{kfCandXicPlus.GetX(), kfCandXicPlus.GetY(), kfCandXicPlus.GetZ()}, phi, theta); + auto errorDecayLength = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, theta) + getRotatedCovMatrixXX(covMatrixSV, phi, theta)); + auto errorDecayLengthXY = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, 0.) + getRotatedCovMatrixXX(covMatrixSV, phi, 0.)); + // fill histograms - /*if (fillHistograms) { + if (fillHistograms) { // invariant mass - hMass3->Fill(massXiPiPi); + hMass3->Fill(massXicPlus); // covariance matrix elements of PV hCovPVXX->Fill(covMatrixPV[0]); hCovPVYY->Fill(covMatrixPV[2]); @@ -496,63 +481,77 @@ struct HfCandidateCreatorXicPlus { hCovSVXZ->Fill(covMatrixSV[3]); hCovSVZZ->Fill(covMatrixSV[5]); // DCAs of prongs - hDcaXYProngs->Fill(track0.pt(), impactParameter0.getY()); - hDcaXYProngs->Fill(track1.pt(), impactParameter1.getY()); - //hDcaXYProngs->Fill(trackCasc.pt(), impactParameterCasc.getY()); - hDcaZProngs->Fill(track0.pt(), impactParameter0.getZ()); - hDcaZProngs->Fill(track1.pt(), impactParameter1.getZ()); - //hDcaZProngs->Fill(trackCasc.pt(), impactParameterCasc.getZ()); - }*/ + hDcaXYProngs->Fill(kfPion0.GetPt(), impactParameter0XY); + hDcaXYProngs->Fill(kfPion1.GetPt(), impactParameter1XY); + hDcaXYProngs->Fill(kfXi.GetPt(), impactParameterXiXY); + //hDcaZProngs->Fill(kfPion0.GetPt(), impactParameter0.getZ()); + //hDcaZProngs->Fill(kfPion1.GetPt(), impactParameter1.getZ()); + //hDcaZProngs->Fill(kfXi.GetPt(), impactParameterCasc.getZ()); + } // fill candidate table rows - //rowCandidateBase(); + rowCandidateKF(collision.globalIndex(), + rowTrackIndexXicPlus.prong0Id(), rowTrackIndexXicPlus.prong1Id(), rowTrackIndexXicPlus.cascadeId(), + casc.bachelorId(), casc.posTrackId(), casc.negTrackId(), + KFPV.GetX(), KFPV.GetY(), KFPV.GetZ(), + kfCandXicPlus.GetX(), kfCandXicPlus.GetX(), kfCandXicPlus.GetX(), + errorDecayLength, errorDecayLengthXY, + chi2SV, + casc.x(), casc.y(), casc.z(), + casc.xlambda(), casc.ylambda(), casc.zlambda(), + kfPion0.GetPx(), kfPion0.GetPy(), kfPion0.GetPz(), + kfPion1.GetPx(), kfPion1.GetPy(), kfPion1.GetPz(), + kfXi.GetPx(), kfXi.GetPy(), kfXi.GetPz(), + impactParameter0XY, impactParameter1XY, impactParameterXiXY, + errImpactParameter0XY, errImpactParameter1XY, errImpactParameterXiXY, + casc.pxbach(), casc.pybach(), casc.pzbach(), + casc.pxlambda(), casc.pylambda(), casc.pzlambda(), + casc.pxpos(), casc.pypos(), casc.pzpos(), + casc.pxneg(), casc.pyneg(), casc.pzneg(), + hfFlag); } // loop over track triplets } // template void processPvRefitWithDCAFitterN(aod::Collisions const& collisions, soa::Join const& rowsTrackIndexXicPlus, - aod::V0sLinked const& v0Linked, - V0Full const& v0s, + //aod::V0sLinked const& v0Linked, + //V0Full const& v0s, CascFull const& cascs, aod::TracksWCovDca const& tracks, aod::BCsWithTimestamps const& bcWithTimeStamps) { - runCreatorXicPlusWithDcaFitter(collisions, rowsTrackIndexXicPlus, v0Linked, v0s, cascs, tracks, bcWithTimeStamps); + runCreatorXicPlusWithDcaFitter(collisions, rowsTrackIndexXicPlus, cascs, tracks, bcWithTimeStamps); } PROCESS_SWITCH(HfCandidateCreatorXicPlus, processPvRefitWithDCAFitterN, "Run candidate creator with PV refit", false); void processNoPvRefitWithDCAFitterN(aod::Collisions const& collisions, - aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, - aod::V0sLinked const& v0Linked, - V0Full const& v0s, - CascFull const& cascs, - aod::TracksWCovDca const& tracks, - aod::BCsWithTimestamps const& bcWithTimeStamps) + aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, + // aod::V0sLinked const& v0Linked, + // V0Full const& v0s, + CascFull const& cascs, + aod::TracksWCovDca const& tracks, + aod::BCsWithTimestamps const& bcWithTimeStamps) { - runCreatorXicPlusWithDcaFitter(collisions, rowsTrackIndexXicPlus, v0Linked, v0s, cascs, tracks, bcWithTimeStamps); + runCreatorXicPlusWithDcaFitter(collisions, rowsTrackIndexXicPlus, cascs, tracks, bcWithTimeStamps); } PROCESS_SWITCH(HfCandidateCreatorXicPlus, processNoPvRefitWithDCAFitterN, "Run candidate creator without PV refit", true); void processPvRefitWithKFParticle(aod::Collisions const& collisions, - aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, - aod::V0sLinked const& v0Linked, - V0Full const& v0s, - CascFull const& cascs, - aod::TracksWCovDca const& tracks, + soa::Join const& rowsTrackIndexXicPlus, + CascFullKF const& cascs, + aod::TracksWCovExtra const& tracks, aod::BCsWithTimestamps const& bcWithTimeStamps) { - // runCreatorXicPlusWithKFParticle(collisions, rowsTrackIndexXicPlus, v0Linked, v0s, cascs, tracks, bcWithTimeStamps); + runCreatorXicPlusWithKFParticle(collisions, rowsTrackIndexXicPlus, cascs, tracks, bcWithTimeStamps); } PROCESS_SWITCH(HfCandidateCreatorXicPlus, processPvRefitWithKFParticle, "Run candidate creator with PV refit", false); void processNoPvRefitWithKFParticle(aod::Collisions const& collisions, - aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, - aod::V0sLinked const& v0Linked, - V0Full const& v0s, - CascFull const& cascs, - aod::TracksWCovDca const& tracks, - aod::BCsWithTimestamps const& bcWithTimeStamps) + aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, + CascFullKF const& cascs, + aod::TracksWCovExtra const& tracks, + aod::BCsWithTimestamps const& bcWithTimeStamps) { - // runCreatorXicPlusWithKFParticle(collisions, rowsTrackIndexXicPlus, v0Linked, v0s, cascs, tracks, bcWithTimeStamps); + runCreatorXicPlusWithKFParticle(collisions, rowsTrackIndexXicPlus, cascs, tracks, bcWithTimeStamps); } PROCESS_SWITCH(HfCandidateCreatorXicPlus, processNoPvRefitWithKFParticle, "Run candidate creator without PV refit", false); }; //struct From 741cc5ad1b79ad2be6237450db3fc5d6d877ef49 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Mon, 19 Feb 2024 14:54:08 +0100 Subject: [PATCH 05/35] Candidate creator with KF + revisioned output table --- .../DataModel/CandidateReconstructionTables.h | 218 +++++++--------- .../candidateCreatorXicPlusToXiPiPi.cxx | 234 +++++++++--------- 2 files changed, 207 insertions(+), 245 deletions(-) diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index 53f49c6ad01..dcc21f6bdd5 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1323,100 +1323,38 @@ DECLARE_SOA_TABLE(HfToOmegaKMCGen, "AOD", "HFTOOMEKMCGEN", //! // specific XicPlus to Xi Pi Pi candidate properties namespace hf_cand_xicplustoxipipi { -// Data processing results: -DECLARE_SOA_INDEX_COLUMN(Collision, collision); -DECLARE_SOA_COLUMN(XPv, xPv, float); -DECLARE_SOA_COLUMN(YPv, yPv, float); -DECLARE_SOA_COLUMN(ZPv, zPv, float); -DECLARE_SOA_COLUMN(XDecayVtxXicPlus, xDecayVtxXicPlus, float); -DECLARE_SOA_COLUMN(YDecayVtxXicPlus, yDecayVtxXicPlus, float); -DECLARE_SOA_COLUMN(ZDecayVtxXicPlus, zDecayVtxXicPlus, float); -DECLARE_SOA_COLUMN(XDecayVtxCascade, xDecayVtxCascade, float); -DECLARE_SOA_COLUMN(YDecayVtxCascade, yDecayVtxCascade, float); -DECLARE_SOA_COLUMN(ZDecayVtxCascade, zDecayVtxCascade, float); -DECLARE_SOA_COLUMN(XDecayVtxV0, xDecayVtxV0, float); -DECLARE_SOA_COLUMN(YDecayVtxV0, yDecayVtxV0, float); -DECLARE_SOA_COLUMN(ZDecayVtxV0, zDecayVtxV0, float); -DECLARE_SOA_COLUMN(SignDecay, signDecay, int8_t); // sign of pi <- xi -DECLARE_SOA_COLUMN(Chi2PCAXicPlus, chi2PCAXicPlus, float); -DECLARE_SOA_COLUMN(CovVtxXicPlus0, covVtxXicPlus0, float); -DECLARE_SOA_COLUMN(CovVtxXicPlus1, covVtxXicPlus1, float); -DECLARE_SOA_COLUMN(CovVtxXicPlus2, covVtxXicPlus2, float); -DECLARE_SOA_COLUMN(CovVtxXicPlus3, covVtxXicPlus3, float); -DECLARE_SOA_COLUMN(CovVtxXicPlus4, covVtxXicPlus4, float); -DECLARE_SOA_COLUMN(CovVtxXicPlus5, covVtxXicPlus5, float); -DECLARE_SOA_COLUMN(PxXicPlus, pxXicPlus, float); -DECLARE_SOA_COLUMN(PyXicPlus, pyXicPlus, float); -DECLARE_SOA_COLUMN(PzXicPlus, pzXicPlus, float); -DECLARE_SOA_COLUMN(PxCasc, pxCasc, float); -DECLARE_SOA_COLUMN(PyCasc, pyCasc, float); -DECLARE_SOA_COLUMN(PzCasc, pzCasc, float); -DECLARE_SOA_COLUMN(PxPi1FromXicPlus, pxPi1FromXicPlus, float); -DECLARE_SOA_COLUMN(PyPi1FromXicPlus, pyPi1FromXicPlus, float); -DECLARE_SOA_COLUMN(PzPi1FromXicPlus, pzPi1FromXicPlus, float); -DECLARE_SOA_COLUMN(PxPi2FromXicPlus, pxPi2FromXicPlus, float); -DECLARE_SOA_COLUMN(PyPi2FromXicPlus, pyPi2FromXicPlus, float); -DECLARE_SOA_COLUMN(PzPi2FromXicPlus, pzPi2FromXicPlus, float); -DECLARE_SOA_COLUMN(PxPiFromCasc, pxPiFromCasc, float); -DECLARE_SOA_COLUMN(PyPiFromCasc, pyPiFromCasc, float); -DECLARE_SOA_COLUMN(PzPiFromCasc, pzPiFromCasc, float); -DECLARE_SOA_COLUMN(PxLambda, pxLambda, float); -DECLARE_SOA_COLUMN(PyLambda, pyLambda, float); -DECLARE_SOA_COLUMN(PzLambda, pzLambda, float); -DECLARE_SOA_COLUMN(PxV0PosDau, pxV0PosDau, float); -DECLARE_SOA_COLUMN(PyV0PosDau, pyV0PosDau, float); -DECLARE_SOA_COLUMN(PzV0PosDau, pzV0PosDau, float); -DECLARE_SOA_COLUMN(PxV0NegDau, pxV0NegDau, float); -DECLARE_SOA_COLUMN(PyV0NegDau, pyV0NegDau, float); -DECLARE_SOA_COLUMN(PzV0NegDau, pzV0NegDau, float); -DECLARE_SOA_COLUMN(ImpactParCascXY, impactParCascXY, float); -DECLARE_SOA_COLUMN(ImpactParCascZ, impactParCascZ, float); -DECLARE_SOA_COLUMN(ImpactParPi1FromXicPlusXY, impactParPi1FromXicPlusXY, float); -DECLARE_SOA_COLUMN(ImpactParPi1FromXicPlusZ, impactParPi1FromXicPlusZ, float); -DECLARE_SOA_COLUMN(ImpactParPi2FromXicPlusXY, impactParPi2FromXicPlusXY, float); -DECLARE_SOA_COLUMN(ImpactParPi2FromXicPlusZ, impactParPi2FromXicPlusZ, float); -DECLARE_SOA_COLUMN(ErrImpactParCascXY, errImpactParCascXY, float); -DECLARE_SOA_COLUMN(ErrImpactParPi1FromXicPlusXY, errImpactParPi1FromXicPlusXY, float); -DECLARE_SOA_COLUMN(ErrImpactParPi2FromXicPlusXY, errImpactParPi2FromXicPlusXY, float); -DECLARE_SOA_INDEX_COLUMN(V0, v0); -DECLARE_SOA_INDEX_COLUMN(Cascade, cascade); -DECLARE_SOA_INDEX_COLUMN_FULL(Pi1FromXicPlus, pi1FromXicPlus, int, Tracks, "_pi1fromXicPlus"); -DECLARE_SOA_INDEX_COLUMN_FULL(Pi2FromXicPlus, pi2FromXicPlus, int, Tracks, "_pi2fromXicPlus"); +DECLARE_SOA_INDEX_COLUMN_FULL(Pi0, pi0, int, Tracks, "_pi0"); +DECLARE_SOA_INDEX_COLUMN_FULL(Pi1, pi1, int, Tracks, "_pi1"); +DECLARE_SOA_COLUMN(XPvErr, xPvErr, float); +DECLARE_SOA_COLUMN(YPvErr, yPvErr, float); +DECLARE_SOA_COLUMN(ZPvErr, zPvErr, float); +DECLARE_SOA_COLUMN(XSvErr, xSvErr, float); +DECLARE_SOA_COLUMN(YSvErr, ySvErr, float); +DECLARE_SOA_COLUMN(ZSvErr, zSvErr, float); +DECLARE_SOA_COLUMN(XDecayVtxXi, xDecayVtxXi, float); +DECLARE_SOA_COLUMN(YDecayVtxXi, yDecayVtxXi, float); +DECLARE_SOA_COLUMN(ZDecayVtxXi, zDecayVtxXi, float); +DECLARE_SOA_COLUMN(XErrDecayVtxXi, xErrDecayVtxXi, float); +DECLARE_SOA_COLUMN(YErrDecayVtxXi, yErrDecayVtxXi, float); +DECLARE_SOA_COLUMN(ZErrDecayVtxXi, zErrDecayVtxXi, float); +DECLARE_SOA_COLUMN(XDecayVtxLambda, xDecayVtxLambda, float); +DECLARE_SOA_COLUMN(YDecayVtxLambda, yDecayVtxLambda, float); +DECLARE_SOA_COLUMN(ZDecayVtxLambda, zDecayVtxLambda, float); +DECLARE_SOA_COLUMN(XErrDecayVtxLambda, xErrDecayVtxLambda, float); +DECLARE_SOA_COLUMN(YErrDecayVtxLambda, yErrDecayVtxLambda, float); +DECLARE_SOA_COLUMN(ZErrDecayVtxLambda, zErrDecayVtxLambda, float); +DECLARE_SOA_COLUMN(DcaCascDau, dcaCascDau, float); +DECLARE_SOA_COLUMN(DcaPi0Pi1, dcaPi0Pi1, float); +DECLARE_SOA_COLUMN(DcaPi0Xi, dcaPi0Xi, float); +DECLARE_SOA_COLUMN(DcaPi1Xi, dcaPi1Xi, float); +DECLARE_SOA_COLUMN(CosPAXi, cosPAXi, float); +DECLARE_SOA_COLUMN(CosPALambda, cosPALambda, float); DECLARE_SOA_COLUMN(InvMassXicPlus, invMassXicPlus, double); DECLARE_SOA_COLUMN(InvMassCascade, invMassCascade, double); DECLARE_SOA_COLUMN(InvMassLambda, invMassLambda, double); -DECLARE_SOA_COLUMN(CosPAXicPlus, cosPAXicPlus, double); -DECLARE_SOA_COLUMN(CosPACasc, cosPACasc, double); -DECLARE_SOA_COLUMN(CosPAV0, cosPAV0, double); -DECLARE_SOA_COLUMN(CosPAXYXicPlus, cosPAXYXicPlus, double); -DECLARE_SOA_COLUMN(CosPAXYCasc, cosPAXYCasc, double); -DECLARE_SOA_COLUMN(CosPAXYV0, cosPAXYV0, double); -DECLARE_SOA_COLUMN(CTauXicPlus, ctauXicPlus, double); -DECLARE_SOA_COLUMN(CTauCascade, ctauCascade, double); -DECLARE_SOA_COLUMN(CTauV0, ctauV0, double); -DECLARE_SOA_COLUMN(EtaXicPlus, etaXicPlus, double); DECLARE_SOA_COLUMN(EtaCascade, etaCascade, double); DECLARE_SOA_COLUMN(EtaPi1FromXicPlus, etaPi1FromXicPlus, double); DECLARE_SOA_COLUMN(EtaPi2FromXicPlus, etaPi2FromXicPlus, double); -DECLARE_SOA_COLUMN(EtaPiFromCasc, etaPiFromCasc, double); -DECLARE_SOA_COLUMN(EtaV0, etaV0, double); -DECLARE_SOA_COLUMN(EtaV0PosDau, etaV0PosDau, double); -DECLARE_SOA_COLUMN(EtaV0NegDau, etaV0NegDau, double); -DECLARE_SOA_COLUMN(DcaXYToPvCascDau, dcaXYToPvCascDau, float); -DECLARE_SOA_COLUMN(DcaXYToPvV0PosDau, dcaXYToPvV0PosDau, float); -DECLARE_SOA_COLUMN(DcaXYToPvV0NegDau, dcaXYToPvV0NegDau, float); -DECLARE_SOA_COLUMN(DcaZToPvCascDau, dcaZToPvCascDau, float); -DECLARE_SOA_COLUMN(DcaZToPvV0PosDau, dcaZToPvV0PosDau, float); -DECLARE_SOA_COLUMN(DcaZToPvV0NegDau, dcaZToPvV0NegDau, float); -DECLARE_SOA_COLUMN(DcaXicPlusDau, dcaXicPlusDau, float); -DECLARE_SOA_COLUMN(DcaCascDau, dcaCascDau, float); -DECLARE_SOA_COLUMN(DcaV0Dau, dcaV0Dau, float); -DECLARE_SOA_COLUMN(DecLenXicPlus, decLenXicPlus, double); -DECLARE_SOA_COLUMN(DecLenCascade, decLenCascade, double); -DECLARE_SOA_COLUMN(DecLenV0, decLenV0, double); -DECLARE_SOA_COLUMN(ErrorDecayLengthXicPlus, errorDecayLengthXicPlus, float); -DECLARE_SOA_COLUMN(ErrorDecayLengthXYXicPlus, errorDecayLengthXYXicPlus, float); - // MC matching result: DECLARE_SOA_COLUMN(FlagMcMatchRec, flagMcMatchRec, int8_t); // reconstruction level DECLARE_SOA_COLUMN(DebugMcRec, debugMcRec, int8_t); // debug flag for mis-association reconstruction level @@ -1426,58 +1364,72 @@ DECLARE_SOA_COLUMN(DebugGenXi, debugGenXi, int8_t); DECLARE_SOA_COLUMN(DebugGenLambda, debugGenLambda, int8_t); DECLARE_SOA_COLUMN(OriginRec, originRec, int8_t); DECLARE_SOA_COLUMN(OriginGen, originGen, int8_t); - // mapping of decay types enum DecayType { XicPlusToXiPiPi=0 }; - } // end of namespace hf_cand_xicplustoxipipi // declare dedicated XicPlus to Xi Pi Pi candidate table -DECLARE_SOA_TABLE(HfCandXicPlus, "AOD", "HFCANDXICPLUS", - o2::soa::Index<>, - hf_cand_xicplustoxipipi::CollisionId, - hf_cand_xicplustoxipipi::Pi1FromXicPlusId, hf_cand_xicplustoxipipi::Pi2FromXicPlusId, hf_cand_xicplustoxipipi::CascadeId, - cascdata::BachelorId, v0data::PosTrackId, v0data::NegTrackId, - hf_cand_xicplustoxipipi::XPv, hf_cand_xicplustoxipipi::YPv, hf_cand_xicplustoxipipi::ZPv, - hf_cand_xicplustoxipipi::XDecayVtxXicPlus, hf_cand_xicplustoxipipi::YDecayVtxXicPlus, hf_cand_xicplustoxipipi::ZDecayVtxXicPlus, - hf_cand_xicplustoxipipi::ErrorDecayLengthXicPlus, hf_cand_xicplustoxipipi::ErrorDecayLengthXYXicPlus, - hf_cand_xicplustoxipipi::Chi2PCAXicPlus, - hf_cand_xicplustoxipipi::XDecayVtxCascade, hf_cand_xicplustoxipipi::YDecayVtxCascade, hf_cand_xicplustoxipipi::ZDecayVtxCascade, - hf_cand_xicplustoxipipi::XDecayVtxV0, hf_cand_xicplustoxipipi::YDecayVtxV0, hf_cand_xicplustoxipipi::ZDecayVtxV0, - hf_cand_xicplustoxipipi::PxPi1FromXicPlus, hf_cand_xicplustoxipipi::PyPi1FromXicPlus, hf_cand_xicplustoxipipi::PzPi1FromXicPlus, - hf_cand_xicplustoxipipi::PxPi2FromXicPlus, hf_cand_xicplustoxipipi::PyPi2FromXicPlus, hf_cand_xicplustoxipipi::PzPi2FromXicPlus, - hf_cand_xicplustoxipipi::PxCasc, hf_cand_xicplustoxipipi::PyCasc, hf_cand_xicplustoxipipi::PzCasc, - hf_cand_xicplustoxipipi::ImpactParPi1FromXicPlusXY,hf_cand_xicplustoxipipi::ImpactParPi2FromXicPlusXY,hf_cand_xicplustoxipipi::ImpactParCascXY, - hf_cand_xicplustoxipipi::ErrImpactParPi1FromXicPlusXY, hf_cand_xicplustoxipipi::ErrImpactParPi2FromXicPlusXY, hf_cand_xicplustoxipipi::ErrImpactParCascXY, - hf_cand_xicplustoxipipi::PxPiFromCasc, hf_cand_xicplustoxipipi::PyPiFromCasc, hf_cand_xicplustoxipipi::PzPiFromCasc, - hf_cand_xicplustoxipipi::PxLambda, hf_cand_xicplustoxipipi::PyLambda, hf_cand_xicplustoxipipi::PzLambda, - hf_cand_xicplustoxipipi::PxV0PosDau, hf_cand_xicplustoxipipi::PyV0PosDau, hf_cand_xicplustoxipipi::PzV0PosDau, - hf_cand_xicplustoxipipi::PxV0NegDau, hf_cand_xicplustoxipipi::PyV0NegDau, hf_cand_xicplustoxipipi::PzV0NegDau, - hf_cand_xicplustoxipipi::DcaXYToPvCascDau, hf_cand_xicplustoxipipi::DcaXYToPvV0PosDau, hf_cand_xicplustoxipipi::DcaXYToPvV0NegDau, - hf_cand_xicplustoxipipi::EtaPiFromCasc, hf_cand_xicplustoxipipi::EtaV0PosDau, hf_cand_xicplustoxipipi::EtaV0NegDau, - hf_track_index::HFflag); +DECLARE_SOA_TABLE(HfCandXicPlBase, "AOD", "HFCANDXICPLBASE", + hf_cand::CollisionId, + collision::PosX, collision::PosY, collision::PosZ, + hf_cand_xicplustoxipipi::XPvErr, hf_cand_xicplustoxipipi::YPvErr, hf_cand_xicplustoxipipi::ZPvErr, + // 3-prong specific columns + cascdata::CascadeId, hf_cand_xicplustoxipipi::Pi0Id, hf_cand_xicplustoxipipi::Pi1Id, + cascdata::BachelorId, cascdata::PosTrackId, cascdata::NegTrackId, + hf_cand::XSecondaryVertex, hf_cand::YSecondaryVertex, hf_cand::ZSecondaryVertex, + hf_cand_xicplustoxipipi::XSvErr, hf_cand_xicplustoxipipi::YSvErr, hf_cand_xicplustoxipipi::ZSvErr, + hf_cand::ErrorDecayLength, hf_cand::ErrorDecayLengthXY, + hf_cand::Chi2PCA, + hf_cand::PxProng0, hf_cand::PyProng0, hf_cand::PzProng0, + hf_cand::PxProng1, hf_cand::PyProng1, hf_cand::PzProng1, + hf_cand::PxProng2, hf_cand::PyProng2, hf_cand::PzProng2, + hf_cand::ImpactParameter0, hf_cand::ImpactParameter1, hf_cand::ImpactParameter2, + hf_cand::ErrorImpactParameter0, hf_cand::ErrorImpactParameter1, hf_cand::ErrorImpactParameter2, + hf_cand_xicplustoxipipi::DcaPi0Pi1, hf_cand_xicplustoxipipi::DcaPi0Xi, hf_cand_xicplustoxipipi::DcaPi1Xi, + hf_track_index::HFflag, + // cascade specific columns + hf_cand_xicplustoxipipi::XDecayVtxXi, hf_cand_xicplustoxipipi::YDecayVtxXi, hf_cand_xicplustoxipipi::ZDecayVtxXi, + hf_cand_xicplustoxipipi::XDecayVtxLambda, hf_cand_xicplustoxipipi::YDecayVtxLambda, hf_cand_xicplustoxipipi::ZDecayVtxLambda, + /*hf_cand_xicplustoxipipi::XErrDecayVtxXi, hf_cand_xicplustoxipipi::YErrDecayVtxXi, hf_cand_xicplustoxipipi::ZErrDecayVtxXi, + hf_cand_xicplustoxipipi::XErrDecayVtxLambda, hf_cand_xicplustoxipipi::YErrDecayVtxLambda, hf_cand_xicplustoxipipi::ZErrDecayVtxLambda,*/ + /*cascdata::CascCosPA, cascdata::V0CosPA,*/ + /* dynamic columns */ + hf_cand::RSecondaryVertex, + hf_cand::DecayLength, + hf_cand::DecayLengthXY, + hf_cand::DecayLengthNormalised, + hf_cand::DecayLengthXYNormalised, + hf_cand_3prong::M, + hf_cand_3prong::M2, + /* dynamic columns that use daughter momentum components */ + hf_cand::PtProng0, + hf_cand::PtProng1, + hf_cand::PtProng2, + /* dynamic columns that use candidate momentum components */ + hf_cand::Pt, + hf_cand::Pt2, + hf_cand::P, + hf_cand::P2, + hf_cand::PVector, + hf_cand::CPA, + hf_cand::CPAXY, + hf_cand::Ct, + hf_cand::ImpactParameterXY, + hf_cand_3prong::MaxNormalisedDeltaIP, + hf_cand::Eta, + hf_cand::Phi, + hf_cand::Y, + hf_cand::E, + hf_cand::E2); + +// extended table with expression columns that can be used as arguments of dynamic columns +DECLARE_SOA_EXTENDED_TABLE_USER(HfCandXicPlExt, HfCandXicPlBase, "HFCANDXICPLEXT", + hf_cand_3prong::Px, hf_cand_3prong::Py, hf_cand_3prong::Pz); + +using HfCandXicPlus = HfCandXicPlExt; DECLARE_SOA_TABLE(HfCandXicPlusKF, "AOD", "HFCANDXICPLUSKF", - o2::soa::Index<>, - hf_cand_xicplustoxipipi::CollisionId, - hf_cand_xicplustoxipipi::Pi1FromXicPlusId, hf_cand_xicplustoxipipi::Pi2FromXicPlusId, hf_cand_xicplustoxipipi::CascadeId, - cascdata::BachelorId, v0data::PosTrackId, v0data::NegTrackId, - hf_cand_xicplustoxipipi::XPv, hf_cand_xicplustoxipipi::YPv, hf_cand_xicplustoxipipi::ZPv, - hf_cand_xicplustoxipipi::XDecayVtxXicPlus, hf_cand_xicplustoxipipi::YDecayVtxXicPlus, hf_cand_xicplustoxipipi::ZDecayVtxXicPlus, - hf_cand_xicplustoxipipi::ErrorDecayLengthXicPlus, hf_cand_xicplustoxipipi::ErrorDecayLengthXYXicPlus, - hf_cand_xicplustoxipipi::Chi2PCAXicPlus, - hf_cand_xicplustoxipipi::XDecayVtxCascade, hf_cand_xicplustoxipipi::YDecayVtxCascade, hf_cand_xicplustoxipipi::ZDecayVtxCascade, - hf_cand_xicplustoxipipi::XDecayVtxV0, hf_cand_xicplustoxipipi::YDecayVtxV0, hf_cand_xicplustoxipipi::ZDecayVtxV0, - hf_cand_xicplustoxipipi::PxPi1FromXicPlus, hf_cand_xicplustoxipipi::PyPi1FromXicPlus, hf_cand_xicplustoxipipi::PzPi1FromXicPlus, - hf_cand_xicplustoxipipi::PxPi2FromXicPlus, hf_cand_xicplustoxipipi::PyPi2FromXicPlus, hf_cand_xicplustoxipipi::PzPi2FromXicPlus, - hf_cand_xicplustoxipipi::PxCasc, hf_cand_xicplustoxipipi::PyCasc, hf_cand_xicplustoxipipi::PzCasc, - hf_cand_xicplustoxipipi::ImpactParPi1FromXicPlusXY,hf_cand_xicplustoxipipi::ImpactParPi2FromXicPlusXY,hf_cand_xicplustoxipipi::ImpactParCascXY, - hf_cand_xicplustoxipipi::ErrImpactParPi1FromXicPlusXY, hf_cand_xicplustoxipipi::ErrImpactParPi2FromXicPlusXY, hf_cand_xicplustoxipipi::ErrImpactParCascXY, - hf_cand_xicplustoxipipi::PxPiFromCasc, hf_cand_xicplustoxipipi::PyPiFromCasc, hf_cand_xicplustoxipipi::PzPiFromCasc, - hf_cand_xicplustoxipipi::PxLambda, hf_cand_xicplustoxipipi::PyLambda, hf_cand_xicplustoxipipi::PzLambda, - hf_cand_xicplustoxipipi::PxV0PosDau, hf_cand_xicplustoxipipi::PyV0PosDau, hf_cand_xicplustoxipipi::PzV0PosDau, - hf_cand_xicplustoxipipi::PxV0NegDau, hf_cand_xicplustoxipipi::PyV0NegDau, hf_cand_xicplustoxipipi::PzV0NegDau, - hf_track_index::HFflag); + cascdata::KFV0Chi2, cascdata::KFCascadeChi2); // table with results of reconstruction level MC matching DECLARE_SOA_TABLE(HfXicPlusMcRec, "AOD", "HFXICPLUSMCREC", //! diff --git a/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx index ccd731cb55b..955dda54561 100644 --- a/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx @@ -12,8 +12,8 @@ /// \file candidateCreatorXicToXiPiPi.cxx /// \brief Reconstruction of Ξc± → (Ξ∓ → (Λ → p π∓) π∓) π± π± candidates /// -/// \author Jinjoo Seo , Heidelberg University /// \author Phil Lennart Stahlhut , Heidelberg University +/// \author Jinjoo Seo , Heidelberg University #ifndef HomogeneousField #define HomogeneousField @@ -32,6 +32,7 @@ #include "Framework/AnalysisTask.h" #include "Framework/runDataProcessing.h" #include "ReconstructionDataFormats/DCA.h" +#include "ReconstructionDataFormats/V0.h" // for creating XicPlus track with DCA fitter #include "Common/Core/trackUtilities.h" #include "Tools/KFparticle/KFUtilities.h" @@ -49,7 +50,7 @@ using namespace o2::framework; /// Reconstruction of heavy-flavour 3-prong decay candidates struct HfCandidateCreatorXicPlus { - Produces rowCandidateBase; + Produces rowCandidateBase; Produces rowCandidateKF; // vertexing @@ -63,8 +64,8 @@ struct HfCandidateCreatorXicPlus { Configurable minRelChi2Change{"minRelChi2Change", 0.9, "stop iterations is chi2/chi2old > this"}; Configurable useAbsDCA{"useAbsDCA", false, "Minimise abs. distance rather than chi2"}; Configurable useWeightedFinalPCA{"useWeightedFinalPCA", false, "Recalculate vertex position using track covariances, 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)"}; - // KFParticle + // Configurable maxChi2{"maxChi2", 100., "discard vertices with chi2/Nprongs > this (or sum{DCAi^2}/Nprongs for abs. distance minimization)"}; + // KFParticle // magnetic field setting from CCDB Configurable isRun2{"isRun2", false, "enable Run 2 or Run 3 GRP objects for magnetic field"}; @@ -125,11 +126,10 @@ struct HfCandidateCreatorXicPlus { } } - //using V0Full = soa::Join; + // using V0Full = soa::Join; using CascFull = soa::Join; using CascFullKF = soa::Join; - template void runCreatorXicPlusWithDcaFitter(aod::Collisions const& collisions, CandType const& rowsTrackIndexXicPlus, @@ -168,16 +168,8 @@ struct HfCandidateCreatorXicPlus { //----------------accessing particles in the decay chain------------- // cascade daughter - charged particle auto trackPionFromXi = casc.template bachelor_as(); // pion <- xi track from TTracks table - // cascade daughter - V0 - /*auto v0 = casc.template v0_as(); - auto v0Element = v0.template v0Data_as(); // V0 element from LF table containing V0 info - if (!v0.has_v0Data()) { // check that V0 data are stored - continue; - }*/ - - // V0 positive daughter + // V0 daughters auto trackV0PosDau = casc.template posTrack_as(); // p <- V0 track (positive track) from TTracks table - // V0 negative daughter auto trackV0NegDau = casc.template negTrack_as(); // pion <- V0 track (negative track) from TTracks table // check that particles come from the same collision @@ -191,26 +183,24 @@ struct HfCandidateCreatorXicPlus { } //--------------------------reconstruct V0 track--------------------------- - // pseudorapidity (only to store in candidate table) + /* pseudorapidity (only to store in candidate table) double pseudorapV0PosDau = trackV0PosDau.eta(); - double pseudorapV0NegDau = trackV0NegDau.eta(); - - // pion & p <- V0 tracks (unused?) + double pseudorapV0NegDau = trackV0NegDau.eta();*/ + /*pion & p <- V0 tracks unused auto trackParCovV0PosDau = getTrackParCov(trackV0PosDau); - auto trackParCovV0NegDau = getTrackParCov(trackV0NegDau); + auto trackParCovV0NegDau = getTrackParCov(trackV0NegDau);*/ // info from LF table (only to store in candidate table) - std::array pVecV0 = {casc.pxlambda(), casc.pylambda(), casc.pzlambda()}; // pVec stands for vector containing the 3-momentum components std::array vertexV0 = {casc.xlambda(), casc.ylambda(), casc.zlambda()}; + /*std::array pVecV0 = {casc.pxlambda(), casc.pylambda(), casc.pzlambda()}; // pVec stands for vector containing the 3-momentum components std::array pVecV0PosDau = {casc.pxpos(), casc.pypos(), casc.pzpos()}; - std::array pVecV0NegDau = {casc.pxneg(), casc.pyneg(), casc.pzneg()}; + std::array pVecV0NegDau = {casc.pxneg(), casc.pyneg(), casc.pzneg()};*/ //-----------------------------reconstruct cascade track----------------------------- - // pseudorapidity (only to store in candidate table) - double pseudorapPionFromXi = trackPionFromXi.eta(); - - // pion <- casc track to be processed with DCAfitter (unused?) - auto trackParCovPionFromXi = getTrackParCov(trackPionFromXi); + /* pseudorapidity (only to store in candidate table) + double pseudorapPionFromXi = trackPionFromXi.eta();*/ + /* pion <- casc track to be processed with DCAfitter (unused) + auto trackParCovPionFromXi = getTrackParCov(trackPionFromXi);*/ // info from LF table std::array vertexCasc = {casc.x(), casc.y(), casc.z()}; @@ -235,8 +225,7 @@ struct HfCandidateCreatorXicPlus { trackCasc.setAbsCharge(1); trackCasc.setPID(o2::track::PID::XiMinus); - std::array pVecPionFromXi = {casc.pxbach(), casc.pybach(), casc.pzbach()}; - + /*std::array pVecPionFromXi = {casc.pxbach(), casc.pybach(), casc.pzbach()};*/ auto trackParVar0 = getTrackParCov(track0); auto trackParVar1 = getTrackParCov(track1); auto collision = rowTrackIndexXicPlus.collision(); @@ -270,12 +259,19 @@ struct HfCandidateCreatorXicPlus { trackParVar0 = df.getTrack(0); trackParVar1 = df.getTrack(1); trackCasc = df.getTrack(2); - std::array pVec0; - std::array pVec1; - std::array pVec2; - trackParVar0.getPxPyPzGlo(pVec0); - trackParVar1.getPxPyPzGlo(pVec1); - trackCasc.getPxPyPzGlo(pVec2); + std::array pVecXi; + std::array pVecPi0; + std::array pVecPi1; + trackCasc.getPxPyPzGlo(pVecXi); + trackParVar0.getPxPyPzGlo(pVecPi0); + trackParVar1.getPxPyPzGlo(pVecPi1); + + // get parent track + std::array pVec2Pi = RecoDecay::pVec(pVecPi0, pVecPi1); + std::array pVecXicPlus = RecoDecay::pVec(pVecXi, pVecPi0, pVecPi1); + auto trackParCov2Pi = o2::dataformats::V0(df.getPCACandidatePos(), pVec2Pi, df.calcPCACovMatrixFlat(), trackParVar0, trackParVar1); + auto trackParCovXicPlus = o2::dataformats::V0(df.getPCACandidatePos(), pVecXicPlus, df.calcPCACovMatrixFlat(), trackParCov2Pi, trackCasc); + trackParCovXicPlus.getPxPyPzGlo(pVecXicPlus); // get track impact parameters // This modifies track momenta! @@ -301,12 +297,12 @@ struct HfCandidateCreatorXicPlus { o2::dataformats::DCA impactParameter0; o2::dataformats::DCA impactParameter1; o2::dataformats::DCA impactParameterCasc; + trackCasc.propagateToDCA(primaryVertex, bz, &impactParameterCasc); trackParVar0.propagateToDCA(primaryVertex, bz, &impactParameter0); trackParVar1.propagateToDCA(primaryVertex, bz, &impactParameter1); - trackCasc.propagateToDCA(primaryVertex, bz, &impactParameterCasc); // get invariant mass - auto arrayMomenta = std::array{pVec0, pVec1, pVec2}; + auto arrayMomenta = std::array{pVecXi, pVecPi0, pVecPi1}; massXiPiPi = RecoDecay::m(std::move(arrayMomenta), std::array{massXiMinusFromPdg, massPionFromPdg, massPionFromPdg}); // get uncertainty of the decay length @@ -332,36 +328,41 @@ struct HfCandidateCreatorXicPlus { // DCAs of prongs hDcaXYProngs->Fill(track0.pt(), impactParameter0.getY()); hDcaXYProngs->Fill(track1.pt(), impactParameter1.getY()); - //hDcaXYProngs->Fill(trackCasc.pt(), impactParameterCasc.getY()); + hDcaXYProngs->Fill(trackCasc.getPt(), impactParameterCasc.getY()); hDcaZProngs->Fill(track0.pt(), impactParameter0.getZ()); hDcaZProngs->Fill(track1.pt(), impactParameter1.getZ()); - //hDcaZProngs->Fill(trackCasc.pt(), impactParameterCasc.getZ()); + hDcaZProngs->Fill(trackCasc.getPt(), impactParameterCasc.getZ()); } // fill candidate table rows rowCandidateBase(collision.globalIndex(), - rowTrackIndexXicPlus.prong0Id(), rowTrackIndexXicPlus.prong1Id(), rowTrackIndexXicPlus.cascadeId(), - trackPionFromXi.globalIndex(), casc.posTrackId(), casc.negTrackId(), primaryVertex.getX(), primaryVertex.getY(), primaryVertex.getZ(), + covMatrixPV[0], covMatrixPV[2], covMatrixPV[5], + /*3-prong specific columns*/ + rowTrackIndexXicPlus.cascadeId(), rowTrackIndexXicPlus.prong0Id(), rowTrackIndexXicPlus.prong1Id(), + casc.bachelorId(), casc.posTrackId(), casc.negTrackId(), secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], + covMatrixSV[0], covMatrixSV[2], covMatrixSV[5], errorDecayLength, errorDecayLengthXY, chi2SV, + pVecXi[0], pVecXi[1], pVecXi[2], + pVecPi0[0], pVecPi0[1], pVecPi0[2], + pVecPi1[0], pVecPi1[1], pVecPi1[2], + impactParameterCasc.getY(), impactParameter0.getY(), impactParameter1.getY(), + std::sqrt(impactParameterCasc.getSigmaY2()), std::sqrt(impactParameter0.getSigmaY2()), std::sqrt(impactParameter1.getSigmaY2()), + // DCAs + pVecCasc[0],pVecCasc[1],pVecCasc[2], + hfFlag, + /*cascade specific columns*/ vertexCasc[0], vertexCasc[1], vertexCasc[2], - vertexV0[0], vertexV0[1], vertexV0[2], - pVec0[0], pVec0[1], pVec0[2], - pVec1[0], pVec1[1], pVec1[2], - pVec2[0], pVec2[1], pVec2[2], - impactParameter0.getY(), impactParameter1.getY(), impactParameterCasc.getY(), - std::sqrt(impactParameter0.getSigmaY2()), std::sqrt(impactParameter1.getSigmaY2()), std::sqrt(impactParameterCasc.getSigmaY2()), - pVecPionFromXi[0], pVecPionFromXi[1], pVecPionFromXi[2], - pVecV0[0], pVecV0[1], pVecV0[2], - pVecV0PosDau[0], pVecV0PosDau[1], pVecV0PosDau[2], - pVecV0NegDau[0], pVecV0NegDau[1], pVecV0NegDau[2], - trackPionFromXi.dcaXY(), trackV0PosDau.dcaXY(), trackV0NegDau.dcaXY(), - pseudorapPionFromXi, pseudorapV0PosDau, pseudorapV0NegDau, - hfFlag); + vertexV0[0], vertexV0[1], vertexV0[2] + // XiVtxerror + // LambdaVtxError + /*casc.v0CosPA(), casc.cascCosPA(),*/ + /*candidate momentum (extended table) + pVecXicPlus[0], pVecXicPlus[1], pVecXicPlus[2]*/); } // loop over track triplets - } // template + } // template /*// Cascade to KFParticle converter KFParticle createKFParticleFromKFCascTables(CascFullKF const& cascKF) @@ -385,9 +386,9 @@ struct HfCandidateCreatorXicPlus { { // loop over triplets of track indices for (const auto& rowTrackIndexXicPlus : rowsTrackIndexXicPlus) { + auto casc = rowTrackIndexXicPlus.template cascade_as(); auto track0 = rowTrackIndexXicPlus.template prong0_as(); auto track1 = rowTrackIndexXicPlus.template prong1_as(); - auto casc = rowTrackIndexXicPlus.template cascade_as(); auto collision = rowTrackIndexXicPlus.collision(); // preselect cascade candidates @@ -429,28 +430,28 @@ struct HfCandidateCreatorXicPlus { KFParticle kfPion0(kfpTrack0, kPiPlus); KFParticle kfPion1(kfpTrack1, kPiPlus); - //create Xi as KFParticle + // create Xi as KFParticle // read {X,Y,Z,Px,Py,Pz} and corresponding covariance matrix from KF cascade Tables std::array xyzpxpypz = {casc.x(), casc.y(), casc.z(), casc.px(), casc.py(), casc.pz()}; float parPosMom[6]; for (int i{0}; i < 6; ++i) { - parPosMom[i] =xyzpxpypz[i]; + parPosMom[i] = xyzpxpypz[i]; } // create KFParticle KFParticle kfXi; kfXi.Create(parPosMom, casc.kfTrackCovMat(), casc.sign(), casc.m(1)); - KFParticle kfCandXicPlus; + KFParticle kfXicPlus; const KFParticle* kfDaughtersXicPlus[3] = {&kfPion0, &kfPion1, &kfXi}; - kfCandXicPlus.SetConstructMethod(2); - kfCandXicPlus.Construct(kfDaughtersXicPlus, 3); + kfXicPlus.SetConstructMethod(2); + kfXicPlus.Construct(kfDaughtersXicPlus, 3); // set hfFlag int hfFlag = BIT(aod::hf_cand_xicplustoxipipi::DecayType::XicPlusToXiPiPi); - auto covMatrixSV = kfCandXicPlus.CovarianceMatrix(); - auto massXicPlus = kfCandXicPlus.GetMass(); - auto chi2SV = kfCandXicPlus.GetChi2(); + auto covMatrixXicPlus = kfXicPlus.CovarianceMatrix(); + /*auto massXicPlus = kfXicPlus.GetMass(); + auto chi2SV = kfXicPlus.GetChi2();*/ // get impact parameters of XicPlus daughters float impactParameter0XY = 0., errImpactParameter0XY = 0.; @@ -460,61 +461,70 @@ struct HfCandidateCreatorXicPlus { kfPion1.GetDistanceFromVertexXY(KFPV, impactParameter1XY, errImpactParameter1XY); kfXi.GetDistanceFromVertexXY(KFPV, impactParameterXiXY, errImpactParameterXiXY); - // get error of decay length + // get DCAs of Pi0-Pi1, Pi0-Xi, Pi1-Xi + float dcaXYPi0Pi1 = kfPion0.GetDistanceFromParticleXY(kfPion1); + float dcaXYPi0Xi = kfPion0.GetDistanceFromParticleXY(kfXi); + float dcaXYPi1Xi = kfPion1.GetDistanceFromParticleXY(kfXi); + + /* get error of decay length double phi, theta; - getPointDirection(std::array{KFPV.GetX(), KFPV.GetY(), KFPV.GetZ()}, std::array{kfCandXicPlus.GetX(), kfCandXicPlus.GetY(), kfCandXicPlus.GetZ()}, phi, theta); + getPointDirection(std::array{KFPV.GetX(), KFPV.GetY(), KFPV.GetZ()}, std::array{kfXicPlus.GetX(), kfXicPlus.GetY(), kfXicPlus.GetZ()}, phi, theta); auto errorDecayLength = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, theta) + getRotatedCovMatrixXX(covMatrixSV, phi, theta)); - auto errorDecayLengthXY = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, 0.) + getRotatedCovMatrixXX(covMatrixSV, phi, 0.)); - + auto errorDecayLengthXY = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, 0.) + getRotatedCovMatrixXX(covMatrixSV, phi, 0.));*/ + // fill histograms if (fillHistograms) { // invariant mass - hMass3->Fill(massXicPlus); + hMass3->Fill(kfXicPlus.GetMass()); // covariance matrix elements of PV hCovPVXX->Fill(covMatrixPV[0]); hCovPVYY->Fill(covMatrixPV[2]); hCovPVXZ->Fill(covMatrixPV[3]); hCovPVZZ->Fill(covMatrixPV[5]); // covariance matrix elements of SV - hCovSVXX->Fill(covMatrixSV[0]); - hCovSVYY->Fill(covMatrixSV[2]); - hCovSVXZ->Fill(covMatrixSV[3]); - hCovSVZZ->Fill(covMatrixSV[5]); + hCovSVXX->Fill(covMatrixXicPlus[0]); + hCovSVYY->Fill(covMatrixXicPlus[2]); + hCovSVXZ->Fill(covMatrixXicPlus[3]); + hCovSVZZ->Fill(covMatrixXicPlus[5]); // DCAs of prongs hDcaXYProngs->Fill(kfPion0.GetPt(), impactParameter0XY); hDcaXYProngs->Fill(kfPion1.GetPt(), impactParameter1XY); hDcaXYProngs->Fill(kfXi.GetPt(), impactParameterXiXY); - //hDcaZProngs->Fill(kfPion0.GetPt(), impactParameter0.getZ()); - //hDcaZProngs->Fill(kfPion1.GetPt(), impactParameter1.getZ()); - //hDcaZProngs->Fill(kfXi.GetPt(), impactParameterCasc.getZ()); } // fill candidate table rows - rowCandidateKF(collision.globalIndex(), - rowTrackIndexXicPlus.prong0Id(), rowTrackIndexXicPlus.prong1Id(), rowTrackIndexXicPlus.cascadeId(), - casc.bachelorId(), casc.posTrackId(), casc.negTrackId(), - KFPV.GetX(), KFPV.GetY(), KFPV.GetZ(), - kfCandXicPlus.GetX(), kfCandXicPlus.GetX(), kfCandXicPlus.GetX(), - errorDecayLength, errorDecayLengthXY, - chi2SV, - casc.x(), casc.y(), casc.z(), - casc.xlambda(), casc.ylambda(), casc.zlambda(), - kfPion0.GetPx(), kfPion0.GetPy(), kfPion0.GetPz(), - kfPion1.GetPx(), kfPion1.GetPy(), kfPion1.GetPz(), - kfXi.GetPx(), kfXi.GetPy(), kfXi.GetPz(), - impactParameter0XY, impactParameter1XY, impactParameterXiXY, - errImpactParameter0XY, errImpactParameter1XY, errImpactParameterXiXY, - casc.pxbach(), casc.pybach(), casc.pzbach(), - casc.pxlambda(), casc.pylambda(), casc.pzlambda(), - casc.pxpos(), casc.pypos(), casc.pzpos(), - casc.pxneg(), casc.pyneg(), casc.pzneg(), - hfFlag); + rowCandidateBase(collision.globalIndex(), + KFPV.GetX(), KFPV.GetY(), KFPV.GetZ(), + covMatrixPV[0], covMatrixPV[2],covMatrixPV[5], + /*3-prong specific columns*/ + rowTrackIndexXicPlus.cascadeId(), rowTrackIndexXicPlus.prong0Id(), rowTrackIndexXicPlus.prong1Id(), + casc.bachelorId(), casc.posTrackId(), casc.negTrackId(), + kfXicPlus.GetX(), kfXicPlus.GetY(), kfXicPlus.GetZ(), + kfXicPlus.GetErrX(), kfXicPlus.GetErrY(), kfXicPlus.GetErrZ(), + kfXicPlus.GetErrDecayLength(), kfXicPlus.GetErrDecayLengthXY(), + kfXicPlus.GetChi2(), + kfXi.GetPx(), kfXi.GetPy(), kfXi.GetPz(), + kfPion0.GetPx(), kfPion0.GetPy(), kfPion0.GetPz(), + kfPion1.GetPx(), kfPion1.GetPy(), kfPion1.GetPz(), + impactParameterXiXY, impactParameter0XY, impactParameter1XY, + errImpactParameter0XY, errImpactParameter1XY, errImpactParameterXiXY, + dcaXYPi0Pi1, dcaXYPi0Xi, dcaXYPi1Xi, + hfFlag, + /*cascade specific columns*/ + casc.x(), casc.y(), casc.z(), + casc.xlambda(), casc.ylambda(), casc.zlambda() + // XiVtx error + // LambdaVtx error + /*casc.v0CosPA(), casc.cascCosPA(),*/ + /*candidate momentum (extended table) + kfXicPlus.GetPx(), kfXicPlus.GetPy(), kfXicPlus.GetPz()*/); + rowCandidateKF(casc.kfV0Chi2(), casc.kfCascadeChi2()); } // loop over track triplets - } // template + } // template void processPvRefitWithDCAFitterN(aod::Collisions const& collisions, soa::Join const& rowsTrackIndexXicPlus, - //aod::V0sLinked const& v0Linked, - //V0Full const& v0s, + // aod::V0sLinked const& v0Linked, + // V0Full const& v0s, CascFull const& cascs, aod::TracksWCovDca const& tracks, aod::BCsWithTimestamps const& bcWithTimeStamps) @@ -534,7 +544,7 @@ struct HfCandidateCreatorXicPlus { runCreatorXicPlusWithDcaFitter(collisions, rowsTrackIndexXicPlus, cascs, tracks, bcWithTimeStamps); } PROCESS_SWITCH(HfCandidateCreatorXicPlus, processNoPvRefitWithDCAFitterN, "Run candidate creator without PV refit", true); - + void processPvRefitWithKFParticle(aod::Collisions const& collisions, soa::Join const& rowsTrackIndexXicPlus, CascFullKF const& cascs, @@ -554,7 +564,7 @@ struct HfCandidateCreatorXicPlus { runCreatorXicPlusWithKFParticle(collisions, rowsTrackIndexXicPlus, cascs, tracks, bcWithTimeStamps); } PROCESS_SWITCH(HfCandidateCreatorXicPlus, processNoPvRefitWithKFParticle, "Run candidate creator without PV refit", false); -}; //struct +}; // struct /// Performs MC matching. struct HfCandidateCreatorXicPlusMc { @@ -572,29 +582,29 @@ struct HfCandidateCreatorXicPlusMc { int indexRec = -1; int8_t sign = -9; int8_t flag = -9; - int8_t origin =-9; + int8_t origin = -9; int8_t debug = 0; int8_t debugGenCharmBar = 0; int8_t debugGenXi = 0; int8_t debugGenLambda = 0; - int pdgCodeXicPlus = Pdg::kXiCPlus; // 4232 - int pdgCodeXiMinus = kXiMinus; // 3312 - int pdgCodeLambda = kLambda0; // 3122 - int pdgCodePiPlus = kPiPlus; // 211 - int pdgCodePiMinus = kPiMinus; // -211 - int pdgCodeProton = kProton; // 2212 + int pdgCodeXicPlus = Pdg::kXiCPlus; // 4232 + int pdgCodeXiMinus = kXiMinus; // 3312 + int pdgCodeLambda = kLambda0; // 3122 + int pdgCodePiPlus = kPiPlus; // 211 + int pdgCodePiMinus = kPiMinus; // -211 + int pdgCodeProton = kProton; // 2212 // Match reconstructed candidates. for (const auto& candidate : candidates) { flag = 0; origin = 0; debug = 0; - auto arrayDaughters = std::array{candidate.pi1FromXicPlus_as(), // pi <- Xic - candidate.pi2FromXicPlus_as(), // pi <- Xic - candidate.bachelor_as(), // pi <- cascade - candidate.posTrack_as(), // p <- lambda - candidate.negTrack_as()}; // pi <- lambda + auto arrayDaughters = std::array{candidate.pi0_as(), // pi <- Xic + candidate.pi1_as(), // pi <- Xic + candidate.bachelor_as(), // pi <- cascade + candidate.posTrack_as(), // p <- lambda + candidate.negTrack_as()}; // pi <- lambda auto arrayDaughtersCasc = std::array{candidate.bachelor_as(), candidate.posTrack_as(), candidate.negTrack_as()}; From c0dd0df912dc2639ea1952abc50e037f539847ae Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Tue, 20 Feb 2024 16:13:37 +0100 Subject: [PATCH 06/35] Add cascade CPAs + KF topo. constraint, improve MC matching --- .../DataModel/CandidateReconstructionTables.h | 24 +- .../candidateCreatorXicPlusToXiPiPi.cxx | 215 ++++++++---------- 2 files changed, 106 insertions(+), 133 deletions(-) diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index dcc21f6bdd5..97b315dd56e 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1347,8 +1347,10 @@ DECLARE_SOA_COLUMN(DcaCascDau, dcaCascDau, float); DECLARE_SOA_COLUMN(DcaPi0Pi1, dcaPi0Pi1, float); DECLARE_SOA_COLUMN(DcaPi0Xi, dcaPi0Xi, float); DECLARE_SOA_COLUMN(DcaPi1Xi, dcaPi1Xi, float); -DECLARE_SOA_COLUMN(CosPAXi, cosPAXi, float); -DECLARE_SOA_COLUMN(CosPALambda, cosPALambda, float); +DECLARE_SOA_COLUMN(CosPaXi, cosPaXi, float); +DECLARE_SOA_COLUMN(CosPaXYXi, cosPaXYXi, float); +DECLARE_SOA_COLUMN(CosPaLambda, cosPaLambda, float); +DECLARE_SOA_COLUMN(CosPaXYLambda, cosPaXYLambda, float); DECLARE_SOA_COLUMN(InvMassXicPlus, invMassXicPlus, double); DECLARE_SOA_COLUMN(InvMassCascade, invMassCascade, double); DECLARE_SOA_COLUMN(InvMassLambda, invMassLambda, double); @@ -1357,11 +1359,9 @@ DECLARE_SOA_COLUMN(EtaPi1FromXicPlus, etaPi1FromXicPlus, double); DECLARE_SOA_COLUMN(EtaPi2FromXicPlus, etaPi2FromXicPlus, double); // MC matching result: DECLARE_SOA_COLUMN(FlagMcMatchRec, flagMcMatchRec, int8_t); // reconstruction level -DECLARE_SOA_COLUMN(DebugMcRec, debugMcRec, int8_t); // debug flag for mis-association reconstruction level DECLARE_SOA_COLUMN(FlagMcMatchGen, flagMcMatchGen, int8_t); // generator level -DECLARE_SOA_COLUMN(DebugGenCharmBar, debugGenCharmBar, int8_t); -DECLARE_SOA_COLUMN(DebugGenXi, debugGenXi, int8_t); -DECLARE_SOA_COLUMN(DebugGenLambda, debugGenLambda, int8_t); +DECLARE_SOA_COLUMN(DebugMcRec, debugMcRec, int8_t); // debug flag for mis-association reconstruction level +DECLARE_SOA_COLUMN(DebugMcGen, debugMcGen, int8_t); DECLARE_SOA_COLUMN(OriginRec, originRec, int8_t); DECLARE_SOA_COLUMN(OriginGen, originGen, int8_t); // mapping of decay types @@ -1385,14 +1385,11 @@ DECLARE_SOA_TABLE(HfCandXicPlBase, "AOD", "HFCANDXICPLBASE", hf_cand::PxProng2, hf_cand::PyProng2, hf_cand::PzProng2, hf_cand::ImpactParameter0, hf_cand::ImpactParameter1, hf_cand::ImpactParameter2, hf_cand::ErrorImpactParameter0, hf_cand::ErrorImpactParameter1, hf_cand::ErrorImpactParameter2, - hf_cand_xicplustoxipipi::DcaPi0Pi1, hf_cand_xicplustoxipipi::DcaPi0Xi, hf_cand_xicplustoxipipi::DcaPi1Xi, hf_track_index::HFflag, // cascade specific columns hf_cand_xicplustoxipipi::XDecayVtxXi, hf_cand_xicplustoxipipi::YDecayVtxXi, hf_cand_xicplustoxipipi::ZDecayVtxXi, hf_cand_xicplustoxipipi::XDecayVtxLambda, hf_cand_xicplustoxipipi::YDecayVtxLambda, hf_cand_xicplustoxipipi::ZDecayVtxLambda, - /*hf_cand_xicplustoxipipi::XErrDecayVtxXi, hf_cand_xicplustoxipipi::YErrDecayVtxXi, hf_cand_xicplustoxipipi::ZErrDecayVtxXi, - hf_cand_xicplustoxipipi::XErrDecayVtxLambda, hf_cand_xicplustoxipipi::YErrDecayVtxLambda, hf_cand_xicplustoxipipi::ZErrDecayVtxLambda,*/ - /*cascdata::CascCosPA, cascdata::V0CosPA,*/ + hf_cand_xicplustoxipipi::CosPaXi, hf_cand_xicplustoxipipi::CosPaXYXi, hf_cand_xicplustoxipipi::CosPaLambda, hf_cand_xicplustoxipipi::CosPaXYLambda, /* dynamic columns */ hf_cand::RSecondaryVertex, hf_cand::DecayLength, @@ -1429,7 +1426,8 @@ DECLARE_SOA_EXTENDED_TABLE_USER(HfCandXicPlExt, HfCandXicPlBase, "HFCANDXICPLEXT using HfCandXicPlus = HfCandXicPlExt; DECLARE_SOA_TABLE(HfCandXicPlusKF, "AOD", "HFCANDXICPLUSKF", - cascdata::KFV0Chi2, cascdata::KFCascadeChi2); + cascdata::KFV0Chi2, cascdata::KFCascadeChi2, + hf_cand_xicplustoxipipi::DcaPi0Pi1, hf_cand_xicplustoxipipi::DcaPi0Xi, hf_cand_xicplustoxipipi::DcaPi1Xi); // table with results of reconstruction level MC matching DECLARE_SOA_TABLE(HfXicPlusMcRec, "AOD", "HFXICPLUSMCREC", //! @@ -1439,7 +1437,9 @@ DECLARE_SOA_TABLE(HfXicPlusMcRec, "AOD", "HFXICPLUSMCREC", //! // table with results of generator level MC matching DECLARE_SOA_TABLE(HfXicPlusMcGen, "AOD", "HFXICPLUSMCGEN", //! - hf_cand_xicplustoxipipi::FlagMcMatchGen, hf_cand_xicplustoxipipi::DebugGenCharmBar, hf_cand_xicplustoxipipi::DebugGenXi, hf_cand_xicplustoxipipi::DebugGenLambda, hf_cand_xicplustoxipipi::OriginGen); + hf_cand_xicplustoxipipi::FlagMcMatchGen, + hf_cand_xicplustoxipipi::DebugMcGen, + hf_cand_xicplustoxipipi::OriginGen); // specific chic candidate properties namespace hf_cand_chic diff --git a/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx index 955dda54561..d045004f84f 100644 --- a/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx @@ -64,8 +64,8 @@ struct HfCandidateCreatorXicPlus { Configurable minRelChi2Change{"minRelChi2Change", 0.9, "stop iterations is chi2/chi2old > this"}; Configurable useAbsDCA{"useAbsDCA", false, "Minimise abs. distance rather than chi2"}; Configurable useWeightedFinalPCA{"useWeightedFinalPCA", false, "Recalculate vertex position using track covariances, 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)"}; // KFParticle + Configurable constrainXicPlusToPv{"constrainXicPlusToPv", false, "Constrain XicPlus to PV"}; // magnetic field setting from CCDB Configurable isRun2{"isRun2", false, "enable Run 2 or Run 3 GRP objects for magnetic field"}; @@ -126,15 +126,12 @@ struct HfCandidateCreatorXicPlus { } } - // using V0Full = soa::Join; using CascFull = soa::Join; using CascFullKF = soa::Join; template void runCreatorXicPlusWithDcaFitter(aod::Collisions const& collisions, CandType const& rowsTrackIndexXicPlus, - // aod::V0sLinked const& v0Linked, - // V0Full const& v0s, CascFull const& cascs, TTracks const& tracks, aod::BCsWithTimestamps const& bcWithTimeStamps) @@ -182,27 +179,11 @@ struct HfCandidateCreatorXicPlus { } } - //--------------------------reconstruct V0 track--------------------------- - /* pseudorapidity (only to store in candidate table) - double pseudorapV0PosDau = trackV0PosDau.eta(); - double pseudorapV0NegDau = trackV0NegDau.eta();*/ - /*pion & p <- V0 tracks unused - auto trackParCovV0PosDau = getTrackParCov(trackV0PosDau); - auto trackParCovV0NegDau = getTrackParCov(trackV0NegDau);*/ - - // info from LF table (only to store in candidate table) + //--------------------------info of V0 track from LF-table--------------------------- std::array vertexV0 = {casc.xlambda(), casc.ylambda(), casc.zlambda()}; - /*std::array pVecV0 = {casc.pxlambda(), casc.pylambda(), casc.pzlambda()}; // pVec stands for vector containing the 3-momentum components - std::array pVecV0PosDau = {casc.pxpos(), casc.pypos(), casc.pzpos()}; - std::array pVecV0NegDau = {casc.pxneg(), casc.pyneg(), casc.pzneg()};*/ - - //-----------------------------reconstruct cascade track----------------------------- - /* pseudorapidity (only to store in candidate table) - double pseudorapPionFromXi = trackPionFromXi.eta();*/ - /* pion <- casc track to be processed with DCAfitter (unused) - auto trackParCovPionFromXi = getTrackParCov(trackPionFromXi);*/ + std::array pVecV0 = {casc.pxlambda(), casc.pylambda(), casc.pzlambda()}; - // info from LF table + //-----------------------------info of cascade track from Lf-table------------------- std::array vertexCasc = {casc.x(), casc.y(), casc.z()}; std::array pVecCasc = {casc.px(), casc.py(), casc.pz()}; std::array covCasc = {0.}; @@ -221,11 +202,9 @@ struct HfCandidateCreatorXicPlus { } else { continue; } - trackCasc.setAbsCharge(1); trackCasc.setPID(o2::track::PID::XiMinus); - /*std::array pVecPionFromXi = {casc.pxbach(), casc.pybach(), casc.pzbach()};*/ auto trackParVar0 = getTrackParCov(track0); auto trackParVar1 = getTrackParCov(track1); auto collision = rowTrackIndexXicPlus.collision(); @@ -301,7 +280,14 @@ struct HfCandidateCreatorXicPlus { trackParVar0.propagateToDCA(primaryVertex, bz, &impactParameter0); trackParVar1.propagateToDCA(primaryVertex, bz, &impactParameter1); - // get invariant mass + // calculate cosine of pointing angle + std::array pvCoord = {collision.posX(), collision.posY(), collision.posZ()}; + double cpaLambda = casc.v0cosPA(collision.posX(), collision.posY(), collision.posZ()); + double cpaXYLambda = RecoDecay::cpaXY(pvCoord, vertexV0, pVecV0); + double cpaXi = casc.casccosPA(collision.posX(), collision.posY(), collision.posZ()); + double cpaXYXi = RecoDecay::cpaXY(pvCoord, vertexCasc, pVecCasc); + + // get invariant mass (unused?) auto arrayMomenta = std::array{pVecXi, pVecPi0, pVecPi1}; massXiPiPi = RecoDecay::m(std::move(arrayMomenta), std::array{massXiMinusFromPdg, massPionFromPdg, massPionFromPdg}); @@ -350,33 +336,14 @@ struct HfCandidateCreatorXicPlus { pVecPi1[0], pVecPi1[1], pVecPi1[2], impactParameterCasc.getY(), impactParameter0.getY(), impactParameter1.getY(), std::sqrt(impactParameterCasc.getSigmaY2()), std::sqrt(impactParameter0.getSigmaY2()), std::sqrt(impactParameter1.getSigmaY2()), - // DCAs - pVecCasc[0],pVecCasc[1],pVecCasc[2], hfFlag, /*cascade specific columns*/ vertexCasc[0], vertexCasc[1], vertexCasc[2], - vertexV0[0], vertexV0[1], vertexV0[2] - // XiVtxerror - // LambdaVtxError - /*casc.v0CosPA(), casc.cascCosPA(),*/ - /*candidate momentum (extended table) - pVecXicPlus[0], pVecXicPlus[1], pVecXicPlus[2]*/); + vertexV0[0], vertexV0[1], vertexV0[2], + cpaXi, cpaXYXi, cpaLambda, cpaXYLambda); } // loop over track triplets } // template - /*// Cascade to KFParticle converter - KFParticle createKFParticleFromKFCascTables(CascFullKF const& cascKF) - { - // read {X,Y,Z,Px,Py,Pz} and corresponding covariance matrix from KF cascade Tables - std::array parPosMom = {cascKF.x(), cascKF.y(), cascKF.z(), cascKF.px(), cascKF.py(), cascKF.pz()}; - std::array covPosMom = cascKF.kfTrackCovMatrix(); - - // create KFParticle - KFParticle kfCasc; - kfCasc.Create(parPosMom, covPosMom, cascKF.sign(), cascKF.m()); - return kfCasc; - }*/ - template void runCreatorXicPlusWithKFParticle(aod::Collisions const& collisions, CandType const& rowsTrackIndexXicPlus, @@ -391,6 +358,14 @@ struct HfCandidateCreatorXicPlus { auto track1 = rowTrackIndexXicPlus.template prong1_as(); auto collision = rowTrackIndexXicPlus.collision(); + //--------------------------info of V0 track from LF-table--------------------------- + std::array vertexV0 = {casc.xlambda(), casc.ylambda(), casc.zlambda()}; + std::array pVecV0 = {casc.pxlambda(), casc.pylambda(), casc.pzlambda()}; + + //-----------------------------info of cascade track from Lf-table------------------- + std::array vertexCasc = {casc.x(), casc.y(), casc.z()}; + std::array pVecCasc = {casc.px(), casc.py(), casc.pz()}; + // preselect cascade candidates if (doCascadePreselection) { if (std::abs(casc.dcaXYCascToPV()) > dcaXYToPVCascadeMax) { @@ -416,21 +391,20 @@ struct HfCandidateCreatorXicPlus { // initialize primary vertex KFPVertex kfpVertex = createKFPVertexFromCollision(collision); float covMatrixPV[6]; - if constexpr (doPvRefit) { kfpVertex.SetXYZ(rowTrackIndexXicPlus.pvRefitX(), rowTrackIndexXicPlus.pvRefitY(), rowTrackIndexXicPlus.pvRefitZ()); - // covariance matrix kfpVertex.SetCovarianceMatrix(rowTrackIndexXicPlus.pvRefitSigmaX2(), rowTrackIndexXicPlus.pvRefitSigmaXY(), rowTrackIndexXicPlus.pvRefitSigmaY2(), rowTrackIndexXicPlus.pvRefitSigmaXZ(), rowTrackIndexXicPlus.pvRefitSigmaYZ(), rowTrackIndexXicPlus.pvRefitSigmaZ2()); } kfpVertex.GetCovarianceMatrix(covMatrixPV); - KFParticle KFPV(kfpVertex); + KFParticle KFPV(kfpVertex); // for calculation of DCAs to PV + // convert pion tracks into KFParticle object KFPTrack kfpTrack0 = createKFPTrackFromTrack(track0); KFPTrack kfpTrack1 = createKFPTrackFromTrack(track1); - KFParticle kfPion0(kfpTrack0, kPiPlus); KFParticle kfPion1(kfpTrack1, kPiPlus); - // create Xi as KFParticle + + // create Xi as KFParticle object // read {X,Y,Z,Px,Py,Pz} and corresponding covariance matrix from KF cascade Tables std::array xyzpxpypz = {casc.x(), casc.y(), casc.z(), casc.px(), casc.py(), casc.pz()}; float parPosMom[6]; @@ -441,18 +415,20 @@ struct HfCandidateCreatorXicPlus { KFParticle kfXi; kfXi.Create(parPosMom, casc.kfTrackCovMat(), casc.sign(), casc.m(1)); + // create XicPlus as KFParticle object KFParticle kfXicPlus; const KFParticle* kfDaughtersXicPlus[3] = {&kfPion0, &kfPion1, &kfXi}; - kfXicPlus.SetConstructMethod(2); + kfXicPlus.SetConstructMethod(2); // 0: no mass constraint, 2: mass constraint kfXicPlus.Construct(kfDaughtersXicPlus, 3); + // topological constraint + if (constrainXicPlusToPv) { + kfXicPlus.SetProductionVertex(KFPV); + } + auto covMatrixXicPlus = kfXicPlus.CovarianceMatrix(); // set hfFlag int hfFlag = BIT(aod::hf_cand_xicplustoxipipi::DecayType::XicPlusToXiPiPi); - auto covMatrixXicPlus = kfXicPlus.CovarianceMatrix(); - /*auto massXicPlus = kfXicPlus.GetMass(); - auto chi2SV = kfXicPlus.GetChi2();*/ - // get impact parameters of XicPlus daughters float impactParameter0XY = 0., errImpactParameter0XY = 0.; float impactParameter1XY = 0., errImpactParameter1XY = 0.; @@ -461,17 +437,18 @@ struct HfCandidateCreatorXicPlus { kfPion1.GetDistanceFromVertexXY(KFPV, impactParameter1XY, errImpactParameter1XY); kfXi.GetDistanceFromVertexXY(KFPV, impactParameterXiXY, errImpactParameterXiXY); + // calculate cosine of pointing angle + std::array pvCoord = {collision.posX(), collision.posY(), collision.posZ()}; + double cpaLambda = casc.v0cosPA(collision.posX(), collision.posY(), collision.posZ()); + double cpaXYLambda = RecoDecay::cpaXY(pvCoord, vertexV0, pVecV0); + double cpaXi = casc.casccosPA(collision.posX(), collision.posY(), collision.posZ()); + double cpaXYXi = RecoDecay::cpaXY(pvCoord, vertexCasc, pVecCasc); + // get DCAs of Pi0-Pi1, Pi0-Xi, Pi1-Xi float dcaXYPi0Pi1 = kfPion0.GetDistanceFromParticleXY(kfPion1); float dcaXYPi0Xi = kfPion0.GetDistanceFromParticleXY(kfXi); float dcaXYPi1Xi = kfPion1.GetDistanceFromParticleXY(kfXi); - /* get error of decay length - double phi, theta; - getPointDirection(std::array{KFPV.GetX(), KFPV.GetY(), KFPV.GetZ()}, std::array{kfXicPlus.GetX(), kfXicPlus.GetY(), kfXicPlus.GetZ()}, phi, theta); - auto errorDecayLength = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, theta) + getRotatedCovMatrixXX(covMatrixSV, phi, theta)); - auto errorDecayLengthXY = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, 0.) + getRotatedCovMatrixXX(covMatrixSV, phi, 0.));*/ - // fill histograms if (fillHistograms) { // invariant mass @@ -507,24 +484,18 @@ struct HfCandidateCreatorXicPlus { kfPion1.GetPx(), kfPion1.GetPy(), kfPion1.GetPz(), impactParameterXiXY, impactParameter0XY, impactParameter1XY, errImpactParameter0XY, errImpactParameter1XY, errImpactParameterXiXY, - dcaXYPi0Pi1, dcaXYPi0Xi, dcaXYPi1Xi, hfFlag, /*cascade specific columns*/ casc.x(), casc.y(), casc.z(), - casc.xlambda(), casc.ylambda(), casc.zlambda() - // XiVtx error - // LambdaVtx error - /*casc.v0CosPA(), casc.cascCosPA(),*/ - /*candidate momentum (extended table) - kfXicPlus.GetPx(), kfXicPlus.GetPy(), kfXicPlus.GetPz()*/); - rowCandidateKF(casc.kfV0Chi2(), casc.kfCascadeChi2()); + casc.xlambda(), casc.ylambda(), casc.zlambda(), + cpaXi, cpaXYXi, cpaLambda, cpaXYLambda); + rowCandidateKF(casc.kfV0Chi2(), casc.kfCascadeChi2(), + dcaXYPi0Pi1, dcaXYPi0Xi, dcaXYPi1Xi); } // loop over track triplets } // template void processPvRefitWithDCAFitterN(aod::Collisions const& collisions, soa::Join const& rowsTrackIndexXicPlus, - // aod::V0sLinked const& v0Linked, - // V0Full const& v0s, CascFull const& cascs, aod::TracksWCovDca const& tracks, aod::BCsWithTimestamps const& bcWithTimeStamps) @@ -535,8 +506,6 @@ struct HfCandidateCreatorXicPlus { void processNoPvRefitWithDCAFitterN(aod::Collisions const& collisions, aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, - // aod::V0sLinked const& v0Linked, - // V0Full const& v0s, CascFull const& cascs, aod::TracksWCovDca const& tracks, aod::BCsWithTimestamps const& bcWithTimeStamps) @@ -580,13 +549,12 @@ struct HfCandidateCreatorXicPlusMc { aod::McParticles const& mcParticles) { int indexRec = -1; + int indexRecXicPlus = -1; int8_t sign = -9; - int8_t flag = -9; - int8_t origin = -9; + int8_t flag = 0; + int8_t origin = 0; int8_t debug = 0; - int8_t debugGenCharmBar = 0; - int8_t debugGenXi = 0; - int8_t debugGenLambda = 0; + int8_t debugGen = 0; int pdgCodeXicPlus = Pdg::kXiCPlus; // 4232 int pdgCodeXiMinus = kXiMinus; // 3312 @@ -598,8 +566,10 @@ struct HfCandidateCreatorXicPlusMc { // Match reconstructed candidates. for (const auto& candidate : candidates) { flag = 0; - origin = 0; + sign = -9; + origin = RecoDecay::OriginType::None; debug = 0; + auto arrayDaughters = std::array{candidate.pi0_as(), // pi <- Xic candidate.pi1_as(), // pi <- Xic candidate.bachelor_as(), // pi <- cascade @@ -611,66 +581,69 @@ struct HfCandidateCreatorXicPlusMc { auto arrayDaughtersV0 = std::array{candidate.posTrack_as(), candidate.negTrack_as()}; - // Xic matching - if (matchXicPlusMc) { - // Xic → pi pi pi pi p - indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, pdgCodeXicPlus, std::array{pdgCodePiPlus, pdgCodePiPlus, pdgCodePiMinus, pdgCodeProton, pdgCodePiMinus}, true, &sign, 3); + // Xic → pi pi pi pi p + indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, pdgCodeXicPlus, std::array{pdgCodePiPlus, pdgCodePiPlus, pdgCodePiMinus, pdgCodeProton, pdgCodePiMinus}, true, &sign, 3); + indexRecXicPlus = indexRec; + if (indexRec == -1) { + debug = 1; + } + if (indexRec > -1) { + // Xi- → pi pi p + indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughtersCasc, pdgCodeXiMinus, std::array{pdgCodePiMinus, pdgCodeProton, pdgCodePiMinus}, true, &sign, 2); if (indexRec == -1) { - debug = 1; + debug = 2; } if (indexRec > -1) { - // Xi- → pi pi p - indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughtersCasc, pdgCodeXiMinus, std::array{pdgCodePiMinus, pdgCodeProton, pdgCodePiMinus}, true, &sign, 2); + // Lambda → p pi + indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughtersV0, pdgCodeLambda, std::array{pdgCodeProton, pdgCodePiMinus}, true, &sign, 1); if (indexRec == -1) { - debug = 2; + debug = 3; } if (indexRec > -1) { - // Lambda → p pi - indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughtersV0, pdgCodeLambda, std::array{pdgCodeProton, pdgCodePiMinus}, true, &sign, 1); - if (indexRec == -1) { - debug = 3; - } - if (indexRec > -1) { - flag = sign * (1 << aod::hf_cand_xicplustoxipipi::DecayType::XicPlusToXiPiPi); - } + flag = sign * (1 << aod::hf_cand_xicplustoxipipi::DecayType::XicPlusToXiPiPi); } } } - if (debug == 2 || debug == 3) { - LOGF(info, "WARNING: Charm baryon decays in the expected final state but the condition on the intermediate states are not fulfilled"); + // Check whether the charm baryon is non-prompt (from a b quark). + if (flag != 0) { + auto particle = mcParticles.rawIteratorAt(indexRecXicPlus); + origin = RecoDecay::getCharmHadronOrigin(mcParticles, particle, true); } - rowMcMatchRec(flag, debug, origin); + rowMcMatchRec(flag, debug, origin); } // close loop over candidates // Match generated particles. for (const auto& particle : mcParticles) { - flag = -9; + flag = 0; sign = -9; - debugGenCharmBar = 0; - debugGenXi = 0; - debugGenLambda = 0; - origin = 0; - if (matchXicPlusMc) { - // Xic → Xi pi pi - if (RecoDecay::isMatchedMCGen(mcParticles, particle, pdgCodeXicPlus, std::array{pdgCodeXiMinus, pdgCodePiPlus, pdgCodePiPlus}, true, &sign)) { - debugGenCharmBar = 1; - // Xi- -> Lambda pi - auto cascMC = mcParticles.rawIteratorAt(particle.daughtersIds().front()); - if (RecoDecay::isMatchedMCGen(mcParticles, cascMC, pdgCodeXiMinus, std::array{pdgCodeLambda, pdgCodePiMinus}, true)) { - debugGenXi = 1; - // Lambda -> p pi - auto v0MC = mcParticles.rawIteratorAt(cascMC.daughtersIds().front()); - if (RecoDecay::isMatchedMCGen(mcParticles, v0MC, pdgCodeLambda, std::array{pdgCodeProton, pdgCodePiMinus}, true)) { - debugGenLambda = 1; - flag = sign * (1 << aod::hf_cand_xicplustoxipipi::DecayType::XicPlusToXiPiPi); - } + debugGen = 0; + origin = RecoDecay::OriginType::None; + + // Xic → Xi pi pi + if (RecoDecay::isMatchedMCGen(mcParticles, particle, pdgCodeXicPlus, std::array{pdgCodeXiMinus, pdgCodePiPlus, pdgCodePiPlus}, true, &sign)) { + debugGen = 1; + // Xi- -> Lambda pi + auto cascMC = mcParticles.rawIteratorAt(particle.daughtersIds().front()); + if (RecoDecay::isMatchedMCGen(mcParticles, cascMC, pdgCodeXiMinus, std::array{pdgCodeLambda, pdgCodePiMinus}, true)) { + debugGen = 2; + // Lambda -> p pi + auto v0MC = mcParticles.rawIteratorAt(cascMC.daughtersIds().front()); + if (RecoDecay::isMatchedMCGen(mcParticles, v0MC, pdgCodeLambda, std::array{pdgCodeProton, pdgCodePiMinus}, true)) { + debugGen = 3; + flag = sign * (1 << aod::hf_cand_xicplustoxipipi::DecayType::XicPlusToXiPiPi); } } } - rowMcMatchGen(flag, debugGenCharmBar, debugGenXi, debugGenLambda, origin); - } + + // Check whether the charm baryon is non-prompt (from a b quark). + if (flag != 0) { + origin = RecoDecay::getCharmHadronOrigin(mcParticles, particle, true); + } + + rowMcMatchGen(flag, debugGen, origin); + } // close loop over generated particles } // close process PROCESS_SWITCH(HfCandidateCreatorXicPlusMc, processMc, "Process MC", false); }; // close struct From c01c5dab4bd4c20720e083f4b2ad0c1114b4d85d Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Wed, 21 Feb 2024 17:07:09 +0100 Subject: [PATCH 07/35] Rename XicPlus to Xic + first version of Xic cand selector --- PWGHF/Core/SelectorCuts.h | 49 +++ .../DataModel/CandidateReconstructionTables.h | 59 ++-- PWGHF/DataModel/CandidateSelectionTables.h | 9 + PWGHF/TableProducer/CMakeLists.txt | 9 +- ...Pi.cxx => candidateCreatorXicToXiPiPi.cxx} | 51 ++-- .../candidateSelectorXicToXiPiPi.cxx | 288 ++++++++++++++++++ 6 files changed, 407 insertions(+), 58 deletions(-) rename PWGHF/TableProducer/{candidateCreatorXicPlusToXiPiPi.cxx => candidateCreatorXicToXiPiPi.cxx} (94%) create mode 100644 PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx diff --git a/PWGHF/Core/SelectorCuts.h b/PWGHF/Core/SelectorCuts.h index b655a243890..a175d437533 100644 --- a/PWGHF/Core/SelectorCuts.h +++ b/PWGHF/Core/SelectorCuts.h @@ -700,6 +700,55 @@ 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_xic_to_xi_pi_pi +{ +static const int nBinsPt = 10; +static const int nCutVars = 12; +// 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., + 8., + 12., + 24., + 36.}; +auto vecBinsPt = std::vector{binsPt, binsPt + nBinsPt + 1}; + +// default values for the cuts m ptXi ptPi0 ptPi1 chi2PCA dL dLXY cosp cospXY impParXY Xi Pi0 Pi1 +constexpr double cuts[nBinsPt][nCutVars] = {{0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 0 < pT < 1 */ + {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 1 < pT < 2 */ + {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 2 < pT < 3 */ + {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 3 < pT < 4 */ + {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 4 < pT < 5 */ + {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 5 < pT < 6 */ + {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 6 < pT < 8 */ + {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 8 < pT < 12 */ + {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 12 < pT < 24 */ + {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}}; /* 24 < pT < 36 */ + +// 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"}; + +// column labels +static const std::vector labelsCutVar = {"m", "pT Xi", "pT Pi0", "pT Pi1", "chi2PCA", "max decay length", "max decay length XY", "cos pointing angle", "cos pointing angle XY", "max impParXY Xi", "max impParXY Pi0", "max impParXY Pi1"}; +} // namespace hf_cuts_xic_to_xi_pi_pi + namespace hf_cuts_xicc_to_p_k_pi_pi { static const int nBinsPt = 10; diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index 97b315dd56e..40cda624721 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1320,8 +1320,8 @@ DECLARE_SOA_TABLE(HfToOmegaKMCGen, "AOD", "HFTOOMEKMCGEN", //! hf_cand_xic0_omegac0::FlagMcMatchGen, hf_cand_xic0_omegac0::DebugGenCharmBar, hf_cand_xic0_omegac0::DebugGenCasc, hf_cand_xic0_omegac0::DebugGenLambda, hf_cand_xic0_omegac0::PtCharmBaryonGen, hf_cand_xic0_omegac0::RapidityCharmBaryonGen, hf_cand_xic0_omegac0::OriginGen, hf_cand::IdxBhadMotherPart, o2::soa::Marker<4>); -// specific XicPlus to Xi Pi Pi candidate properties -namespace hf_cand_xicplustoxipipi +// specific Xic to Xi Pi Pi candidate properties +namespace hf_cand_xictoxipipi { DECLARE_SOA_INDEX_COLUMN_FULL(Pi0, pi0, int, Tracks, "_pi0"); DECLARE_SOA_INDEX_COLUMN_FULL(Pi1, pi1, int, Tracks, "_pi1"); @@ -1351,12 +1351,7 @@ DECLARE_SOA_COLUMN(CosPaXi, cosPaXi, float); DECLARE_SOA_COLUMN(CosPaXYXi, cosPaXYXi, float); DECLARE_SOA_COLUMN(CosPaLambda, cosPaLambda, float); DECLARE_SOA_COLUMN(CosPaXYLambda, cosPaXYLambda, float); -DECLARE_SOA_COLUMN(InvMassXicPlus, invMassXicPlus, double); -DECLARE_SOA_COLUMN(InvMassCascade, invMassCascade, double); -DECLARE_SOA_COLUMN(InvMassLambda, invMassLambda, double); -DECLARE_SOA_COLUMN(EtaCascade, etaCascade, double); -DECLARE_SOA_COLUMN(EtaPi1FromXicPlus, etaPi1FromXicPlus, double); -DECLARE_SOA_COLUMN(EtaPi2FromXicPlus, etaPi2FromXicPlus, double); +DECLARE_SOA_COLUMN(InvMassXic, invMassXic, double); // MC matching result: DECLARE_SOA_COLUMN(FlagMcMatchRec, flagMcMatchRec, int8_t); // reconstruction level DECLARE_SOA_COLUMN(FlagMcMatchGen, flagMcMatchGen, int8_t); // generator level @@ -1365,21 +1360,21 @@ DECLARE_SOA_COLUMN(DebugMcGen, debugMcGen, int8_t); DECLARE_SOA_COLUMN(OriginRec, originRec, int8_t); DECLARE_SOA_COLUMN(OriginGen, originGen, int8_t); // mapping of decay types -enum DecayType { XicPlusToXiPiPi=0 }; -} // end of namespace hf_cand_xicplustoxipipi +enum DecayType { XicToXiPiPi=0 }; +} // end of namespace hf_cand_xictoxipipi -// declare dedicated XicPlus to Xi Pi Pi candidate table -DECLARE_SOA_TABLE(HfCandXicPlBase, "AOD", "HFCANDXICPLBASE", +// declare dedicated Xic to Xi Pi Pi candidate table +DECLARE_SOA_TABLE(HfCandXicBase, "AOD", "HFCANDXICBASE", hf_cand::CollisionId, collision::PosX, collision::PosY, collision::PosZ, - hf_cand_xicplustoxipipi::XPvErr, hf_cand_xicplustoxipipi::YPvErr, hf_cand_xicplustoxipipi::ZPvErr, + hf_cand_xictoxipipi::XPvErr, hf_cand_xictoxipipi::YPvErr, hf_cand_xictoxipipi::ZPvErr, // 3-prong specific columns - cascdata::CascadeId, hf_cand_xicplustoxipipi::Pi0Id, hf_cand_xicplustoxipipi::Pi1Id, + cascdata::CascadeId, hf_cand_xictoxipipi::Pi0Id, hf_cand_xictoxipipi::Pi1Id, cascdata::BachelorId, cascdata::PosTrackId, cascdata::NegTrackId, hf_cand::XSecondaryVertex, hf_cand::YSecondaryVertex, hf_cand::ZSecondaryVertex, - hf_cand_xicplustoxipipi::XSvErr, hf_cand_xicplustoxipipi::YSvErr, hf_cand_xicplustoxipipi::ZSvErr, + hf_cand_xictoxipipi::XSvErr, hf_cand_xictoxipipi::YSvErr, hf_cand_xictoxipipi::ZSvErr, hf_cand::ErrorDecayLength, hf_cand::ErrorDecayLengthXY, - hf_cand::Chi2PCA, + hf_cand::Chi2PCA, hf_cand_xictoxipipi::InvMassXic, hf_cand::PxProng0, hf_cand::PyProng0, hf_cand::PzProng0, hf_cand::PxProng1, hf_cand::PyProng1, hf_cand::PzProng1, hf_cand::PxProng2, hf_cand::PyProng2, hf_cand::PzProng2, @@ -1387,17 +1382,15 @@ DECLARE_SOA_TABLE(HfCandXicPlBase, "AOD", "HFCANDXICPLBASE", hf_cand::ErrorImpactParameter0, hf_cand::ErrorImpactParameter1, hf_cand::ErrorImpactParameter2, hf_track_index::HFflag, // cascade specific columns - hf_cand_xicplustoxipipi::XDecayVtxXi, hf_cand_xicplustoxipipi::YDecayVtxXi, hf_cand_xicplustoxipipi::ZDecayVtxXi, - hf_cand_xicplustoxipipi::XDecayVtxLambda, hf_cand_xicplustoxipipi::YDecayVtxLambda, hf_cand_xicplustoxipipi::ZDecayVtxLambda, - hf_cand_xicplustoxipipi::CosPaXi, hf_cand_xicplustoxipipi::CosPaXYXi, hf_cand_xicplustoxipipi::CosPaLambda, hf_cand_xicplustoxipipi::CosPaXYLambda, + hf_cand_xictoxipipi::XDecayVtxXi, hf_cand_xictoxipipi::YDecayVtxXi, hf_cand_xictoxipipi::ZDecayVtxXi, + hf_cand_xictoxipipi::XDecayVtxLambda, hf_cand_xictoxipipi::YDecayVtxLambda, hf_cand_xictoxipipi::ZDecayVtxLambda, + hf_cand_xictoxipipi::CosPaXi, hf_cand_xictoxipipi::CosPaXYXi, hf_cand_xictoxipipi::CosPaLambda, hf_cand_xictoxipipi::CosPaXYLambda, /* dynamic columns */ hf_cand::RSecondaryVertex, hf_cand::DecayLength, hf_cand::DecayLengthXY, hf_cand::DecayLengthNormalised, hf_cand::DecayLengthXYNormalised, - hf_cand_3prong::M, - hf_cand_3prong::M2, /* dynamic columns that use daughter momentum components */ hf_cand::PtProng0, hf_cand::PtProng1, @@ -1420,26 +1413,26 @@ DECLARE_SOA_TABLE(HfCandXicPlBase, "AOD", "HFCANDXICPLBASE", hf_cand::E2); // extended table with expression columns that can be used as arguments of dynamic columns -DECLARE_SOA_EXTENDED_TABLE_USER(HfCandXicPlExt, HfCandXicPlBase, "HFCANDXICPLEXT", +DECLARE_SOA_EXTENDED_TABLE_USER(HfCandXicExt, HfCandXicBase, "HFCANDXICEXT", hf_cand_3prong::Px, hf_cand_3prong::Py, hf_cand_3prong::Pz); -using HfCandXicPlus = HfCandXicPlExt; +using HfCandXic = HfCandXicExt; -DECLARE_SOA_TABLE(HfCandXicPlusKF, "AOD", "HFCANDXICPLUSKF", +DECLARE_SOA_TABLE(HfCandXicKF, "AOD", "HFCANDXICKF", cascdata::KFV0Chi2, cascdata::KFCascadeChi2, - hf_cand_xicplustoxipipi::DcaPi0Pi1, hf_cand_xicplustoxipipi::DcaPi0Xi, hf_cand_xicplustoxipipi::DcaPi1Xi); + hf_cand_xictoxipipi::DcaPi0Pi1, hf_cand_xictoxipipi::DcaPi0Xi, hf_cand_xictoxipipi::DcaPi1Xi); // table with results of reconstruction level MC matching -DECLARE_SOA_TABLE(HfXicPlusMcRec, "AOD", "HFXICPLUSMCREC", //! - hf_cand_xicplustoxipipi::FlagMcMatchRec, - hf_cand_xicplustoxipipi::DebugMcRec, - hf_cand_xicplustoxipipi::OriginRec); +DECLARE_SOA_TABLE(HfCandXicMcRec, "AOD", "HFCANDXICMCREC", //! + hf_cand_xictoxipipi::FlagMcMatchRec, + hf_cand_xictoxipipi::DebugMcRec, + hf_cand_xictoxipipi::OriginRec); // table with results of generator level MC matching -DECLARE_SOA_TABLE(HfXicPlusMcGen, "AOD", "HFXICPLUSMCGEN", //! - hf_cand_xicplustoxipipi::FlagMcMatchGen, - hf_cand_xicplustoxipipi::DebugMcGen, - hf_cand_xicplustoxipipi::OriginGen); +DECLARE_SOA_TABLE(HfCandXicMcGen, "AOD", "HFCANDXICMCGEN", //! + hf_cand_xictoxipipi::FlagMcMatchGen, + hf_cand_xictoxipipi::DebugMcGen, + hf_cand_xictoxipipi::OriginGen); // specific chic candidate properties namespace hf_cand_chic diff --git a/PWGHF/DataModel/CandidateSelectionTables.h b/PWGHF/DataModel/CandidateSelectionTables.h index fa9bc07a981..2925afa90cb 100644 --- a/PWGHF/DataModel/CandidateSelectionTables.h +++ b/PWGHF/DataModel/CandidateSelectionTables.h @@ -301,16 +301,25 @@ DECLARE_SOA_TABLE(HfSelChicToJpsiGamma, "AOD", "HFSELCHIC", //! namespace hf_sel_candidate_xic { +// XicPlus to P K Pi DECLARE_SOA_COLUMN(IsSelXicToPKPi, isSelXicToPKPi, int); //! DECLARE_SOA_COLUMN(IsSelXicToPiKP, isSelXicToPiKP, int); //! DECLARE_SOA_COLUMN(MlProbXicToPKPi, mlProbXicToPKPi, std::vector); //! DECLARE_SOA_COLUMN(MlProbXicToPiKP, mlProbXicToPiKP, std::vector); //! +// XicPlus to Xi Pi Pi +DECLARE_SOA_COLUMN(IsSelXicPlusToXiPiPi, isSelXicPlusToXiPiPi, int); //! +DECLARE_SOA_COLUMN(MlProbXicPlusToXiPiPi, mlProbXicPlusToXiPiPi, std::vector); //! } // namespace hf_sel_candidate_xic DECLARE_SOA_TABLE(HfSelXicToPKPi, "AOD", "HFSELXIC", //! hf_sel_candidate_xic::IsSelXicToPKPi, hf_sel_candidate_xic::IsSelXicToPiKP); DECLARE_SOA_TABLE(HfMlXicToPKPi, "AOD", "HFMLXIC", //! hf_sel_candidate_xic::MlProbXicToPKPi, hf_sel_candidate_xic::MlProbXicToPiKP); +// XicPlus to Xi Pi Pi +DECLARE_SOA_TABLE(HfSelXicToXiPiPi, "AOD", "HFSELXICTOXI2PI", //! + hf_sel_candidate_xic::IsSelXicPlusToXiPiPi); +DECLARE_SOA_TABLE(HfMlXicToXiPiPi, "AOD", "HFMLXICTOXIPIPI", //! + hf_sel_candidate_xic::MlProbXicPlusToXiPiPi); namespace hf_sel_candidate_xicc { diff --git a/PWGHF/TableProducer/CMakeLists.txt b/PWGHF/TableProducer/CMakeLists.txt index 1c1a7988299..506befee6bf 100644 --- a/PWGHF/TableProducer/CMakeLists.txt +++ b/PWGHF/TableProducer/CMakeLists.txt @@ -80,8 +80,8 @@ o2physics_add_dpl_workflow(candidate-creator-xic0-omegac0 PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2::DCAFitter O2Physics::EventFilteringUtils COMPONENT_NAME Analysis) -o2physics_add_dpl_workflow(candidate-creator-xicplus-to-xi-pi-pi - SOURCES candidateCreatorXicPlusToXiPiPi.cxx +o2physics_add_dpl_workflow(candidate-creator-xic-to-xi-pi-pi + SOURCES candidateCreatorXicToXiPiPi.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2::DCAFitter KFParticle::KFParticle COMPONENT_NAME Analysis) @@ -167,6 +167,11 @@ o2physics_add_dpl_workflow(candidate-selector-xic-to-p-k-pi PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::MLCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(candidate-selector-xic-to-xi-pi-pi + SOURCES candidateSelectorXicToXiPiPi.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::MLCore + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(candidate-selector-xicc-to-p-k-pi-pi SOURCES candidateSelectorXiccToPKPiPi.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore diff --git a/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx similarity index 94% rename from PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx rename to PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index d045004f84f..37776af2953 100644 --- a/PWGHF/TableProducer/candidateCreatorXicPlusToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -44,14 +44,14 @@ using namespace o2; using namespace o2::analysis; -using namespace o2::aod::hf_cand_xicplustoxipipi; +using namespace o2::aod::hf_cand_xictoxipipi; using namespace o2::constants::physics; using namespace o2::framework; /// Reconstruction of heavy-flavour 3-prong decay candidates -struct HfCandidateCreatorXicPlus { - Produces rowCandidateBase; - Produces rowCandidateKF; +struct HfCandidateCreatorXic { + Produces rowCandidateBase; + Produces rowCandidateKF; // vertexing Configurable rejDiffCollTrack{"rejDiffCollTrack", true, "Reject tracks coming from different collisions"}; @@ -227,7 +227,7 @@ struct HfCandidateCreatorXicPlus { } // set hfFlag - int hfFlag = BIT(aod::hf_cand_xicplustoxipipi::DecayType::XicPlusToXiPiPi); + int hfFlag = BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); // get SV properties const auto& secondaryVertex = df.getPCACandidate(); @@ -287,7 +287,7 @@ struct HfCandidateCreatorXicPlus { double cpaXi = casc.casccosPA(collision.posX(), collision.posY(), collision.posZ()); double cpaXYXi = RecoDecay::cpaXY(pvCoord, vertexCasc, pVecCasc); - // get invariant mass (unused?) + // get invariant mass auto arrayMomenta = std::array{pVecXi, pVecPi0, pVecPi1}; massXiPiPi = RecoDecay::m(std::move(arrayMomenta), std::array{massXiMinusFromPdg, massPionFromPdg, massPionFromPdg}); @@ -330,7 +330,7 @@ struct HfCandidateCreatorXicPlus { secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], covMatrixSV[0], covMatrixSV[2], covMatrixSV[5], errorDecayLength, errorDecayLengthXY, - chi2SV, + chi2SV, massXiPiPi, pVecXi[0], pVecXi[1], pVecXi[2], pVecPi0[0], pVecPi0[1], pVecPi0[2], pVecPi1[0], pVecPi1[1], pVecPi1[2], @@ -413,7 +413,7 @@ struct HfCandidateCreatorXicPlus { } // create KFParticle KFParticle kfXi; - kfXi.Create(parPosMom, casc.kfTrackCovMat(), casc.sign(), casc.m(1)); + kfXi.Create(parPosMom, casc.kfTrackCovMat(), casc.sign(), casc.m(1)); // casc.m(1): 1 for Lambda mass hypothesis // create XicPlus as KFParticle object KFParticle kfXicPlus; @@ -426,8 +426,13 @@ struct HfCandidateCreatorXicPlus { } auto covMatrixXicPlus = kfXicPlus.CovarianceMatrix(); + // transport daughter particles to XicPlus decay vertex + kfPion0.TransportToParticle(kfXicPlus); + kfPion1.TransportToParticle(kfXicPlus); + kfXi.TransportToParticle(kfXicPlus); + // set hfFlag - int hfFlag = BIT(aod::hf_cand_xicplustoxipipi::DecayType::XicPlusToXiPiPi); + int hfFlag = BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); // get impact parameters of XicPlus daughters float impactParameter0XY = 0., errImpactParameter0XY = 0.; @@ -478,7 +483,7 @@ struct HfCandidateCreatorXicPlus { kfXicPlus.GetX(), kfXicPlus.GetY(), kfXicPlus.GetZ(), kfXicPlus.GetErrX(), kfXicPlus.GetErrY(), kfXicPlus.GetErrZ(), kfXicPlus.GetErrDecayLength(), kfXicPlus.GetErrDecayLengthXY(), - kfXicPlus.GetChi2(), + kfXicPlus.GetChi2(), kfXicPlus.GetMass(), kfXi.GetPx(), kfXi.GetPy(), kfXi.GetPz(), kfPion0.GetPx(), kfPion0.GetPy(), kfPion0.GetPz(), kfPion1.GetPx(), kfPion1.GetPy(), kfPion1.GetPz(), @@ -502,7 +507,7 @@ struct HfCandidateCreatorXicPlus { { runCreatorXicPlusWithDcaFitter(collisions, rowsTrackIndexXicPlus, cascs, tracks, bcWithTimeStamps); } - PROCESS_SWITCH(HfCandidateCreatorXicPlus, processPvRefitWithDCAFitterN, "Run candidate creator with PV refit", false); + PROCESS_SWITCH(HfCandidateCreatorXic, processPvRefitWithDCAFitterN, "Run candidate creator with PV refit", false); void processNoPvRefitWithDCAFitterN(aod::Collisions const& collisions, aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, @@ -512,7 +517,7 @@ struct HfCandidateCreatorXicPlus { { runCreatorXicPlusWithDcaFitter(collisions, rowsTrackIndexXicPlus, cascs, tracks, bcWithTimeStamps); } - PROCESS_SWITCH(HfCandidateCreatorXicPlus, processNoPvRefitWithDCAFitterN, "Run candidate creator without PV refit", true); + PROCESS_SWITCH(HfCandidateCreatorXic, processNoPvRefitWithDCAFitterN, "Run candidate creator without PV refit", true); void processPvRefitWithKFParticle(aod::Collisions const& collisions, soa::Join const& rowsTrackIndexXicPlus, @@ -522,7 +527,7 @@ struct HfCandidateCreatorXicPlus { { runCreatorXicPlusWithKFParticle(collisions, rowsTrackIndexXicPlus, cascs, tracks, bcWithTimeStamps); } - PROCESS_SWITCH(HfCandidateCreatorXicPlus, processPvRefitWithKFParticle, "Run candidate creator with PV refit", false); + PROCESS_SWITCH(HfCandidateCreatorXic, processPvRefitWithKFParticle, "Run candidate creator with PV refit", false); void processNoPvRefitWithKFParticle(aod::Collisions const& collisions, aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, @@ -532,19 +537,19 @@ struct HfCandidateCreatorXicPlus { { runCreatorXicPlusWithKFParticle(collisions, rowsTrackIndexXicPlus, cascs, tracks, bcWithTimeStamps); } - PROCESS_SWITCH(HfCandidateCreatorXicPlus, processNoPvRefitWithKFParticle, "Run candidate creator without PV refit", false); + PROCESS_SWITCH(HfCandidateCreatorXic, processNoPvRefitWithKFParticle, "Run candidate creator without PV refit", false); }; // struct /// Performs MC matching. -struct HfCandidateCreatorXicPlusMc { - Produces rowMcMatchRec; - Produces rowMcMatchGen; +struct HfCandidateCreatorXicMc { + Produces rowMcMatchRec; + Produces rowMcMatchGen; Configurable matchXicPlusMc{"matchXicPlusMc", true, "Do MC matching for XicPlus"}; void init(InitContext const&) {} - void processMc(aod::HfCandXicPlus const& candidates, + void processMc(aod::HfCandXic const& candidates, aod::TracksWMc const& tracks, aod::McParticles const& mcParticles) { @@ -600,7 +605,7 @@ struct HfCandidateCreatorXicPlusMc { debug = 3; } if (indexRec > -1) { - flag = sign * (1 << aod::hf_cand_xicplustoxipipi::DecayType::XicPlusToXiPiPi); + flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); } } } @@ -632,7 +637,7 @@ struct HfCandidateCreatorXicPlusMc { auto v0MC = mcParticles.rawIteratorAt(cascMC.daughtersIds().front()); if (RecoDecay::isMatchedMCGen(mcParticles, v0MC, pdgCodeLambda, std::array{pdgCodeProton, pdgCodePiMinus}, true)) { debugGen = 3; - flag = sign * (1 << aod::hf_cand_xicplustoxipipi::DecayType::XicPlusToXiPiPi); + flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); } } } @@ -645,12 +650,12 @@ struct HfCandidateCreatorXicPlusMc { rowMcMatchGen(flag, debugGen, origin); } // close loop over generated particles } // close process - PROCESS_SWITCH(HfCandidateCreatorXicPlusMc, processMc, "Process MC", false); + PROCESS_SWITCH(HfCandidateCreatorXicMc, processMc, "Process MC", false); }; // close struct WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{ - adaptAnalysisTask(cfgc), - adaptAnalysisTask(cfgc)}; + adaptAnalysisTask(cfgc), + adaptAnalysisTask(cfgc)}; } diff --git a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx new file mode 100644 index 00000000000..ab5d0d82b60 --- /dev/null +++ b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx @@ -0,0 +1,288 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \file candidateSelectorXicToXiPiPi.cxx +/// \brief Ξc± → Ξ∓ π± π± candidate selector +/// +/// \author Phil Lennart Stahlhut , CERN + +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + +#include "Common/Core/TrackSelectorPID.h" + +#include "PWGHF/Utils/utilsAnalysis.h" // findBin function +#include "PWGHF/Core/HfMlResponse.h" +#include "PWGHF/Core/SelectorCuts.h" +#include "PWGHF/DataModel/CandidateReconstructionTables.h" +#include "PWGHF/DataModel/CandidateSelectionTables.h" + +using namespace o2; +using namespace o2::aod; +using namespace o2::framework; +using namespace o2::analysis; + +struct HfCandidateSelectorXicToXiPiPi { + Produces hfSelXicToXiPiPiCandidate; + Produces hfMlXicToXiPiPiCandidate; + + Configurable ptCandMin{"ptCandMin", 0., "Lower bound of candidate pT"}; + Configurable ptCandMax{"ptCandMax", 36., "Upper bound of candidate pT"}; + // Enable PID + Configurable usePid{"usePid", true, "Switch for PID selection at track level"}; + Configurable acceptPIDNotApplicable{"acceptPIDNotApplicable", true, "Switch to accept Status::NotApplicable [(NotApplicable for one detector) and (NotApplicable or Conditional for the other)] in PID selection"}; + // TPC PID + Configurable ptPidTpcMin{"ptPidTpcMin", 0.15, "Lower bound of track pT for TPC PID"}; + Configurable ptPidTpcMax{"ptPidTpcMax", 20., "Upper bound of track pT for TPC PID"}; + Configurable nSigmaTpcMax{"nSigmaTpcMax", 5., "Nsigma cut on TPC only"}; + Configurable nSigmaTpcCombinedMax{"nSigmaTpcCombinedMax", 5., "Nsigma cut on TPC combined with TOF"}; + // TOF PID + Configurable ptPidTofMin{"ptPidTofMin", 0.15, "Lower bound of track pT for TOF PID"}; + Configurable ptPidTofMax{"ptPidTofMax", 20., "Upper bound of track pT for TOF PID"}; + Configurable nSigmaTofMax{"nSigmaTofMax", 5., "Nsigma cut on TOF only"}; + Configurable nSigmaTofCombinedMax{"nSigmaTofCombinedMax", 5., "Nsigma cut on TOF combined with TPC"}; + // topological cuts + Configurable> binsPt{"binsPt", std::vector{hf_cuts_xic_to_xi_pi_pi::vecBinsPt}, "pT bin limits"}; + Configurable> cuts{"cuts", {hf_cuts_xic_to_xi_pi_pi::cuts[0], hf_cuts_xic_to_xi_pi_pi::nBinsPt, hf_cuts_xic_to_xi_pi_pi::nCutVars, hf_cuts_xic_to_xi_pi_pi::labelsPt, hf_cuts_xic_to_xi_pi_pi::labelsCutVar}, "Bs candidate selection per pT bin"}; + // QA switch + Configurable activateQA{"activateQA", false, "Flag to enable QA histogram"}; + // 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"}; + Configurable> cutDirMl{"cutDirMl", std::vector{hf_cuts_ml::vecCutDir}, "Whether to reject score values greater or smaller than the threshold"}; + 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", (int8_t)hf_cuts_ml::nCutScores, "Number of classes in ML model"}; + // CCDB configuration + Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; + Configurable> modelPathsCCDB{"modelPathsCCDB", std::vector{"EventFiltering/PWGHF/BDTXic"}, "Paths of models on CCDB"}; + Configurable> onnxFileNames{"onnxFilesCCDB", std::vector{"ModelHandler_onnx_XicTOXiPiPi.onnx"}, "ONNX file names on CCDB 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"}; + + + o2::analysis::HfMlResponse hfMlResponse; + std::vector outputMl = {}; + + o2::ccdb::CcdbApi ccdbApi; + + TrackSelectorPi selectorPion; + + using TracksPidWithSel = soa::Join; + + HistogramRegistry registry{"registry"}; + + void init(InitContext& initContext) + { + if (usePid) { + selectorPion.setRangePtTpc(ptPidTpcMin, ptPidTpcMax); + selectorPion.setRangeNSigmaTpc(-nSigmaTpcMax, nSigmaTpcMax); + selectorPion.setRangeNSigmaTpcCondTof(-nSigmaTpcCombinedMax, nSigmaTpcCombinedMax); + selectorPion.setRangePtTof(ptPidTofMin, ptPidTofMax); + selectorPion.setRangeNSigmaTof(-nSigmaTofMax, nSigmaTofMax); + selectorPion.setRangeNSigmaTofCondTpc(-nSigmaTofCombinedMax, nSigmaTofCombinedMax); + } + + if (activateQA) { + constexpr int kNBinsSelections = 1 + SelectionStep::NSelectionSteps; + std::string labels[kNBinsSelections]; + labels[0] = "No selection"; + labels[1 + SelectionStep::RecoSkims] = "Skims selection"; + labels[1 + SelectionStep::RecoTopol] = "Skims & Topological selections"; + labels[1 + SelectionStep::RecoPID] = "Skims & Topological & PID selections"; + static const AxisSpec axisSelections = {kNBinsSelections, 0.5, kNBinsSelections + 0.5, ""}; + registry.add("hSelections", "Selections;;#it{p}_{T} (GeV/#it{c})", {HistType::kTH2F, {axisSelections, {(std::vector)binsPt, "#it{p}_{T} (GeV/#it{c})"}}}); + for (int iBin = 0; iBin < kNBinsSelections; ++iBin) { + registry.get(HIST("hSelections"))->GetXaxis()->SetBinLabel(iBin + 1, labels[iBin].data()); + } + } + + if (applyMl) { + hfMlResponse.configure(binsPtMl, cutsMl, cutDirMl, nClassesMl); + if (loadModelsFromCCDB) { + ccdbApi.init(ccdbUrl); + hfMlResponse.setModelPathsCCDB(onnxFileNames, ccdbApi, modelPathsCCDB, timestampCCDB); + } else { + hfMlResponse.setModelPathsLocal(onnxFileNames); + } + hfMlResponse.init(); + outputMl.assign(((std::vector)cutDirMl).size(), -1.f); // dummy value for ML output + } + } + + /// Conjugate-independent topological cuts + /// \param candidate is candidate + /// \return true if candidate passes all cuts + template + bool selectionTopol(const T1& hfCandXic) + { + auto candpT = hfCandXic.pt(); + int pTBin = findBin(binsPt, candpT); + if (pTBin == -1) { + return false; + } + + // check that the candidate pT is within the analysis range + if (candpT < ptCandMin || candpT >= ptCandMax) { + return false; + } + + // check candidate mass is within a defined mass window + if (std::abs(hfCandXic.invMassXic() - o2::constants::physics::MassXiCPlus) > cuts->get(pTBin, "m")) { + return false; + } + + // cosine of pointing angle + if (hfCandXic.cpa() <= cuts->get(pTBin, "cos pointing angle")) { + return false; + } + + // cosine of pointing angle XY + if (hfCandXic.cpaXY() <= cuts->get(pTBin, "cos pointing angle XY")) { + return false; + } + + // candidate maximum decay length + if (hfCandXic.decayLength() > cuts->get(pTBin, "max decay length")) { + return false; + } + + // candidate maximum decay length XY + if (hfCandXic.decayLengthXY() > cuts->get(pTBin, "max decay length XY")) { + return false; + } + + // candidate chi2PC + if (hfCandXic.chi2PCA() > cuts->get(pTBin, "chi2PCA")) { + return false; + } + + // maximum DCA of daughters + if ((std::abs(hfCandXic.impactParameter0()) > cuts->get(pTBin, "max impParXY Xi")) || + (std::abs(hfCandXic.impactParameter1()) > cuts->get(pTBin, "max impParXY Pi0")) || + (std::abs(hfCandXic.impactParameter2()) > cuts->get(pTBin, "max impParXY Pi1"))) { + return false; + } + + // cut on daughter pT + if (hfCandXic.ptProng0() < cuts->get(pTBin, "pT Xi") || + hfCandXic.ptProng1() < cuts->get(pTBin, "pT Pi0") || + hfCandXic.ptProng2() < cuts->get(pTBin, "pT Pi1")) { + return false; + } + + return true; + } + + /// Apply PID selection + /// \param pidTrackPi0 PID status of trackPi0 (prong1 of Xic candidate) + /// \param pidTrackPi1 PID status of trackPi1 (prong2 of Xic candidate) + /// \param acceptPIDNotApplicable switch to accept Status::NotApplicable + /// \return true if prong1 and prong 2 of Xic candidate pass all selections + template + bool selectionPid(const T1& pidTrackPi0, const T2& pidTrackPi1, const T3& acceptPIDNotApplicable) + { + if (!acceptPIDNotApplicable && pidTrackPi0 != TrackSelectorPID::Accepted) { + return false; + } + if (acceptPIDNotApplicable && pidTrackPi0 == TrackSelectorPID::Rejected) { + return false; + } + if (!acceptPIDNotApplicable && pidTrackPi1 != TrackSelectorPID::Accepted) { + return false; + } + if (acceptPIDNotApplicable && pidTrackPi1 == TrackSelectorPID::Rejected) { + return false; + } + + return true; + } + + void process(aod::HfCandXic const& hfCandsXic, + TracksPidWithSel const&) + { + for (const auto& hfCandXic : hfCandsXic) { + int statusXicToXiPiPi = 0; + auto ptCandXic = hfCandXic.pt(); + + // check if flagged as Ξc± → Ξ∓ π± π± + if (!TESTBIT(hfCandXic.hfflag(), hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { + hfSelXicToXiPiPiCandidate(statusXicToXiPiPi); + if (applyMl) { + hfMlXicToXiPiPiCandidate(outputMl); + } + if (activateQA) { + registry.fill(HIST("hSelections"), 1, ptCandXic); + } + continue; + } + SETBIT(statusXicToXiPiPi, SelectionStep::RecoSkims); // RecoSkims = 0 --> statusXicToXiPiPi = 1 + if (activateQA) { + registry.fill(HIST("hSelections"), 2 + SelectionStep::RecoSkims, ptCandXic); + } + + // topological cuts + if (!selectionTopol(hfCandXic)) { + hfSelXicToXiPiPiCandidate(statusXicToXiPiPi); + if (applyMl) { + hfMlXicToXiPiPiCandidate(outputMl); + } + continue; + } + SETBIT(statusXicToXiPiPi, SelectionStep::RecoTopol); // RecoTopol = 1 --> statusXicToXiPiPi = 3 + if (activateQA) { + registry.fill(HIST("hSelections"), 2 + SelectionStep::RecoTopol, ptCandXic); + } + + // track-level PID selection + if (usePid) { + auto trackPi0 = hfCandXic.pi0_as(); + auto trackPi1 = hfCandXic.pi1_as(); + int pidTrackPi0 = selectorPion.statusTpcAndTof(trackPi0); + int pidTrackPi1 = selectorPion.statusTpcAndTof(trackPi1); + if (!selectionPid(pidTrackPi0, pidTrackPi1, acceptPIDNotApplicable.value)) { + hfSelXicToXiPiPiCandidate(statusXicToXiPiPi); + if (applyMl) { + hfMlXicToXiPiPiCandidate(outputMl); + } + continue; + } + SETBIT(statusXicToXiPiPi, SelectionStep::RecoPID); // RecoPID = 2 --> statusXicToXiPiPi = 7 + if (activateQA) { + registry.fill(HIST("hSelections"), 2 + SelectionStep::RecoPID, ptCandXic); + } + } + + // ML selections + if (applyMl) { + std::vector inputFeatures{}; + + bool isSelectedMl = hfMlResponse.isSelectedMl(inputFeatures, ptCandXic, outputMl); + hfMlXicToXiPiPiCandidate(outputMl); + + if (!isSelectedMl) { + hfSelXicToXiPiPiCandidate(statusXicToXiPiPi); + continue; + } + SETBIT(statusXicToXiPiPi, aod::SelectionStep::RecoMl); + if (activateQA) { + registry.fill(HIST("hSelections"), 2 + aod::SelectionStep::RecoMl, ptCandXic); + } + } + + hfSelXicToXiPiPiCandidate(statusXicToXiPiPi); + } + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; +} From 446102f7bc998e75439c63e948df71e0e673d6ae Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Thu, 22 Feb 2024 17:13:33 +0100 Subject: [PATCH 08/35] Add Xi PID to candidate selector --- .../DataModel/CandidateReconstructionTables.h | 3 +- PWGHF/DataModel/CandidateSelectionTables.h | 8 +-- .../candidateCreatorXicToXiPiPi.cxx | 6 ++- .../candidateSelectorXicToXiPiPi.cxx | 49 +++++++++++++------ 4 files changed, 44 insertions(+), 22 deletions(-) diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index 40cda624721..84a7179f271 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1352,6 +1352,7 @@ DECLARE_SOA_COLUMN(CosPaXYXi, cosPaXYXi, float); DECLARE_SOA_COLUMN(CosPaLambda, cosPaLambda, float); DECLARE_SOA_COLUMN(CosPaXYLambda, cosPaXYLambda, float); DECLARE_SOA_COLUMN(InvMassXic, invMassXic, double); +DECLARE_SOA_COLUMN(Sign, sign, double); // MC matching result: DECLARE_SOA_COLUMN(FlagMcMatchRec, flagMcMatchRec, int8_t); // reconstruction level DECLARE_SOA_COLUMN(FlagMcMatchGen, flagMcMatchGen, int8_t); // generator level @@ -1374,7 +1375,7 @@ DECLARE_SOA_TABLE(HfCandXicBase, "AOD", "HFCANDXICBASE", hf_cand::XSecondaryVertex, hf_cand::YSecondaryVertex, hf_cand::ZSecondaryVertex, hf_cand_xictoxipipi::XSvErr, hf_cand_xictoxipipi::YSvErr, hf_cand_xictoxipipi::ZSvErr, hf_cand::ErrorDecayLength, hf_cand::ErrorDecayLengthXY, - hf_cand::Chi2PCA, hf_cand_xictoxipipi::InvMassXic, + hf_cand::Chi2PCA, hf_cand_xictoxipipi::InvMassXic, hf_cand_xictoxipipi::Sign, hf_cand::PxProng0, hf_cand::PyProng0, hf_cand::PzProng0, hf_cand::PxProng1, hf_cand::PyProng1, hf_cand::PzProng1, hf_cand::PxProng2, hf_cand::PyProng2, hf_cand::PzProng2, diff --git a/PWGHF/DataModel/CandidateSelectionTables.h b/PWGHF/DataModel/CandidateSelectionTables.h index 2925afa90cb..2cea370fa07 100644 --- a/PWGHF/DataModel/CandidateSelectionTables.h +++ b/PWGHF/DataModel/CandidateSelectionTables.h @@ -307,8 +307,8 @@ DECLARE_SOA_COLUMN(IsSelXicToPiKP, isSelXicToPiKP, int); //! DECLARE_SOA_COLUMN(MlProbXicToPKPi, mlProbXicToPKPi, std::vector); //! DECLARE_SOA_COLUMN(MlProbXicToPiKP, mlProbXicToPiKP, std::vector); //! // XicPlus to Xi Pi Pi -DECLARE_SOA_COLUMN(IsSelXicPlusToXiPiPi, isSelXicPlusToXiPiPi, int); //! -DECLARE_SOA_COLUMN(MlProbXicPlusToXiPiPi, mlProbXicPlusToXiPiPi, std::vector); //! +DECLARE_SOA_COLUMN(IsSelXicToXiPiPi, isSelXicToXiPiPi, int); //! +DECLARE_SOA_COLUMN(MlProbXicToXiPiPi, mlProbXicToXiPiPi, std::vector); //! } // namespace hf_sel_candidate_xic DECLARE_SOA_TABLE(HfSelXicToPKPi, "AOD", "HFSELXIC", //! @@ -317,9 +317,9 @@ DECLARE_SOA_TABLE(HfMlXicToPKPi, "AOD", "HFMLXIC", //! hf_sel_candidate_xic::MlProbXicToPKPi, hf_sel_candidate_xic::MlProbXicToPiKP); // XicPlus to Xi Pi Pi DECLARE_SOA_TABLE(HfSelXicToXiPiPi, "AOD", "HFSELXICTOXI2PI", //! - hf_sel_candidate_xic::IsSelXicPlusToXiPiPi); + hf_sel_candidate_xic::IsSelXicToXiPiPi); DECLARE_SOA_TABLE(HfMlXicToXiPiPi, "AOD", "HFMLXICTOXIPIPI", //! - hf_sel_candidate_xic::MlProbXicPlusToXiPiPi); + hf_sel_candidate_xic::MlProbXicToXiPiPi); namespace hf_sel_candidate_xicc { diff --git a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index 37776af2953..a44fc6adc09 100644 --- a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -228,6 +228,7 @@ struct HfCandidateCreatorXic { // set hfFlag int hfFlag = BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); + int signXicPlus = casc.sign() < 0 ? +1 : -1; // get SV properties const auto& secondaryVertex = df.getPCACandidate(); @@ -330,7 +331,7 @@ struct HfCandidateCreatorXic { secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], covMatrixSV[0], covMatrixSV[2], covMatrixSV[5], errorDecayLength, errorDecayLengthXY, - chi2SV, massXiPiPi, + chi2SV, massXiPiPi, signXicPlus, pVecXi[0], pVecXi[1], pVecXi[2], pVecPi0[0], pVecPi0[1], pVecPi0[2], pVecPi1[0], pVecPi1[1], pVecPi1[2], @@ -433,6 +434,7 @@ struct HfCandidateCreatorXic { // set hfFlag int hfFlag = BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); + int signXicPlus = casc.sign() < 0 ? +1 : -1; // get impact parameters of XicPlus daughters float impactParameter0XY = 0., errImpactParameter0XY = 0.; @@ -483,7 +485,7 @@ struct HfCandidateCreatorXic { kfXicPlus.GetX(), kfXicPlus.GetY(), kfXicPlus.GetZ(), kfXicPlus.GetErrX(), kfXicPlus.GetErrY(), kfXicPlus.GetErrZ(), kfXicPlus.GetErrDecayLength(), kfXicPlus.GetErrDecayLengthXY(), - kfXicPlus.GetChi2(), kfXicPlus.GetMass(), + kfXicPlus.GetChi2(), kfXicPlus.GetMass(), signXicPlus, kfXi.GetPx(), kfXi.GetPy(), kfXi.GetPz(), kfPion0.GetPx(), kfPion0.GetPy(), kfPion0.GetPz(), kfPion1.GetPx(), kfPion1.GetPy(), kfPion1.GetPz(), diff --git a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx index ab5d0d82b60..de2e1e39992 100644 --- a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx @@ -74,20 +74,29 @@ struct HfCandidateSelectorXicToXiPiPi { o2::ccdb::CcdbApi ccdbApi; TrackSelectorPi selectorPion; + TrackSelectorPr selectorProton; - using TracksPidWithSel = soa::Join; + using TracksPidWithSel = soa::Join; HistogramRegistry registry{"registry"}; void init(InitContext& initContext) { if (usePid) { + // pion selectorPion.setRangePtTpc(ptPidTpcMin, ptPidTpcMax); selectorPion.setRangeNSigmaTpc(-nSigmaTpcMax, nSigmaTpcMax); selectorPion.setRangeNSigmaTpcCondTof(-nSigmaTpcCombinedMax, nSigmaTpcCombinedMax); selectorPion.setRangePtTof(ptPidTofMin, ptPidTofMax); selectorPion.setRangeNSigmaTof(-nSigmaTofMax, nSigmaTofMax); selectorPion.setRangeNSigmaTofCondTpc(-nSigmaTofCombinedMax, nSigmaTofCombinedMax); + // proton + selectorProton.setRangePtTpc(ptPidTpcMin, ptPidTpcMax); + selectorProton.setRangeNSigmaTpc(-nSigmaTpcMax, nSigmaTpcMax); + selectorProton.setRangeNSigmaTpcCondTof(-nSigmaTpcCombinedMax, nSigmaTpcCombinedMax); + selectorProton.setRangePtTof(ptPidTofMin, ptPidTofMax); + selectorProton.setRangeNSigmaTof(-nSigmaTofMax, nSigmaTofMax); + selectorProton.setRangeNSigmaTofCondTpc(-nSigmaTofCombinedMax, nSigmaTofCombinedMax); } if (activateQA) { @@ -182,26 +191,22 @@ struct HfCandidateSelectorXicToXiPiPi { } /// Apply PID selection - /// \param pidTrackPi0 PID status of trackPi0 (prong1 of Xic candidate) - /// \param pidTrackPi1 PID status of trackPi1 (prong2 of Xic candidate) + /// \param pidTrackPi0 PID status of trackPi0 (prong1 of Xic candidate) + /// \param pidTrackPi1 PID status of trackPi1 (prong2 of Xic candidate) + /// \param pidTrackPr PID status of trackPr (positive daughter of V0 candidate) + /// \param pidTrackPiLam PID status of trackPiLam (negative daughter of V0 candidate) + /// \param pidTrackPiXi PID status of trackPiXi (Bachelor of cascade candidate) /// \param acceptPIDNotApplicable switch to accept Status::NotApplicable /// \return true if prong1 and prong 2 of Xic candidate pass all selections - template - bool selectionPid(const T1& pidTrackPi0, const T2& pidTrackPi1, const T3& acceptPIDNotApplicable) + template + bool selectionPid(const T1& pidTrackPi0, const T2& pidTrackPi1, const T3& pidTrackPr, const T4& pidTrackPiLam, const T5& pidTrackPiXi, const T6& acceptPIDNotApplicable) { - if (!acceptPIDNotApplicable && pidTrackPi0 != TrackSelectorPID::Accepted) { + if (!acceptPIDNotApplicable && pidTrackPi0 != TrackSelectorPID::Accepted && pidTrackPi1 != TrackSelectorPID::Accepted && pidTrackPr != TrackSelectorPID::Accepted && pidTrackPiLam != TrackSelectorPID::Accepted && pidTrackPiXi == TrackSelectorPID::Rejected) { return false; } - if (acceptPIDNotApplicable && pidTrackPi0 == TrackSelectorPID::Rejected) { + if (acceptPIDNotApplicable && pidTrackPi0 == TrackSelectorPID::Rejected && pidTrackPi1 == TrackSelectorPID::Rejected && pidTrackPr == TrackSelectorPID::Rejected && pidTrackPiLam == TrackSelectorPID::Rejected && pidTrackPiXi == TrackSelectorPID::Rejected) { return false; } - if (!acceptPIDNotApplicable && pidTrackPi1 != TrackSelectorPID::Accepted) { - return false; - } - if (acceptPIDNotApplicable && pidTrackPi1 == TrackSelectorPID::Rejected) { - return false; - } - return true; } @@ -245,9 +250,23 @@ struct HfCandidateSelectorXicToXiPiPi { if (usePid) { auto trackPi0 = hfCandXic.pi0_as(); auto trackPi1 = hfCandXic.pi1_as(); + auto trackV0PosDau = hfCandXic.posTrack_as(); + auto trackV0NegDau = hfCandXic.negTrack_as(); + auto trackPiFromXi = hfCandXic.bachelor_as(); + // assign proton and pion hypothesis to V0 daughters + auto trackPr = trackV0PosDau; + auto trackPiFromLam = trackV0NegDau; + if (hfCandXic.sign() < 0) { + trackPr = trackV0NegDau; + trackPiFromLam = trackV0PosDau; + } + // PID info int pidTrackPi0 = selectorPion.statusTpcAndTof(trackPi0); int pidTrackPi1 = selectorPion.statusTpcAndTof(trackPi1); - if (!selectionPid(pidTrackPi0, pidTrackPi1, acceptPIDNotApplicable.value)) { + int pidTrackPr = selectorProton.statusTpcAndTof(trackPr); + int pidTrackPiLam = selectorPion.statusTpcAndTof(trackPiFromLam); + int pidTrackPiXi = selectorPion.statusTpcAndTof(trackPiFromXi); + if (!selectionPid(pidTrackPi0, pidTrackPi1, pidTrackPr, pidTrackPiLam, pidTrackPiXi, acceptPIDNotApplicable.value)) { hfSelXicToXiPiPiCandidate(statusXicToXiPiPi); if (applyMl) { hfMlXicToXiPiPiCandidate(outputMl); From 0d90ebb599f35278455d51e211affd9ee1af2d60 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Sun, 25 Feb 2024 16:43:12 +0100 Subject: [PATCH 09/35] First version of XicPlus tree creator --- PWGHF/DataModel/CandidateReconstructionTables.h | 8 ++++---- PWGHF/TableProducer/CMakeLists.txt | 5 +++++ 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index 84a7179f271..d46ad2ce47f 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1392,15 +1392,16 @@ DECLARE_SOA_TABLE(HfCandXicBase, "AOD", "HFCANDXICBASE", hf_cand::DecayLengthXY, hf_cand::DecayLengthNormalised, hf_cand::DecayLengthXYNormalised, + hf_cand::ImpactParameterNormalised0, + hf_cand::ImpactParameterNormalised1, + hf_cand::ImpactParameterNormalised2, /* dynamic columns that use daughter momentum components */ hf_cand::PtProng0, hf_cand::PtProng1, hf_cand::PtProng2, /* dynamic columns that use candidate momentum components */ hf_cand::Pt, - hf_cand::Pt2, hf_cand::P, - hf_cand::P2, hf_cand::PVector, hf_cand::CPA, hf_cand::CPAXY, @@ -1410,8 +1411,7 @@ DECLARE_SOA_TABLE(HfCandXicBase, "AOD", "HFCANDXICBASE", hf_cand::Eta, hf_cand::Phi, hf_cand::Y, - hf_cand::E, - hf_cand::E2); + hf_cand::E); // extended table with expression columns that can be used as arguments of dynamic columns DECLARE_SOA_EXTENDED_TABLE_USER(HfCandXicExt, HfCandXicBase, "HFCANDXICEXT", diff --git a/PWGHF/TableProducer/CMakeLists.txt b/PWGHF/TableProducer/CMakeLists.txt index 506befee6bf..205e5c8c01b 100644 --- a/PWGHF/TableProducer/CMakeLists.txt +++ b/PWGHF/TableProducer/CMakeLists.txt @@ -249,6 +249,11 @@ o2physics_add_dpl_workflow(tree-creator-xic-to-p-k-pi PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(tree-creator-xic-to-xi-pi-pi + SOURCES treeCreatorXicToXiPiPi.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(tree-creator-xicc-to-p-k-pi-pi SOURCES treeCreatorXiccToPKPiPi.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore From eff1ac201789e7eab8af2574f9126e85180b19b8 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Sun, 25 Feb 2024 16:44:15 +0100 Subject: [PATCH 10/35] First version of XicPlus tree creator II --- .../TableProducer/treeCreatorXicToXiPiPi.cxx | 467 ++++++++++++++++++ 1 file changed, 467 insertions(+) create mode 100644 PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx diff --git a/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx new file mode 100644 index 00000000000..374a3ebfdf0 --- /dev/null +++ b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx @@ -0,0 +1,467 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \file treeCreatorXicToXiPiPi.cxx +/// \brief Writer of Ξc± → Ξ∓ π± π± candidates in the form of flat tables to be stored in TTrees. +/// +/// \author Phil Lennart Stahlhut , CERN + +// include directives (C++, external, ROOT, O2, O2Physics, PWG-non-HF, PWGHF) +// using directives + +#include "CommonConstants/PhysicsConstants.h" +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + +#include "PWGHF/Core/HfHelper.h" +#include "PWGHF/DataModel/CandidateReconstructionTables.h" +#include "PWGHF/DataModel/CandidateSelectionTables.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +namespace o2::aod +{ +namespace full +{ +// track indices +DECLARE_SOA_COLUMN(CandidateSelFlag, candidateSelFlag, int); //! Selection flag of candidate (output of candidateSelector) +DECLARE_SOA_INDEX_COLUMN_FULL(Xi, xi, int, Tracks, "_pi0"); +DECLARE_SOA_INDEX_COLUMN_FULL(Pi0, pi0, int, Tracks, "_pi0"); +DECLARE_SOA_INDEX_COLUMN_FULL(Pi1, pi1, int, Tracks, "_pi1"); +//vertices +DECLARE_SOA_COLUMN(PvX, pvX, float); +DECLARE_SOA_COLUMN(PvY, pvY, float); +DECLARE_SOA_COLUMN(PvZ, pvZ, float); +DECLARE_SOA_COLUMN(PvErrX, pvErrX, float); +DECLARE_SOA_COLUMN(PvErrY, pvErrY, float); +DECLARE_SOA_COLUMN(PvErrZ, pvErrZ, float); +DECLARE_SOA_COLUMN(SvX, svX, float); +DECLARE_SOA_COLUMN(SvY, svY, float); +DECLARE_SOA_COLUMN(SvZ, svZ, float); +DECLARE_SOA_COLUMN(Chi2Sv, chi2Sv, float); +DECLARE_SOA_COLUMN(SvErrX, svErrX, float); +DECLARE_SOA_COLUMN(SvErrY, svErrY, float); +DECLARE_SOA_COLUMN(SvErrZ, svErrZ, float); +DECLARE_SOA_COLUMN(DecVtxXiX, decVtxXiX, float); +DECLARE_SOA_COLUMN(DecVtxXiY, decVtxXiY, float); +DECLARE_SOA_COLUMN(DecVtxXiZ, decVtxXiZ, float); +DECLARE_SOA_COLUMN(Chi2XiVtx, xhi2XiVtx, float); +DECLARE_SOA_COLUMN(DecVtxLamX, decVtxLamX, float); +DECLARE_SOA_COLUMN(DecVtxLamY, decVtxLamY, float); +DECLARE_SOA_COLUMN(DecVtxLamZ, decVtxLamZ, float); +DECLARE_SOA_COLUMN(Chi2LamVtx, chi2LamVtx, float); +// properties of XicPlus +DECLARE_SOA_COLUMN(Sign, sign, float); +DECLARE_SOA_COLUMN(E, e, float); //! Energy of candidate (GeV) +DECLARE_SOA_COLUMN(M, m, float); //! Invariant mass of candidate (GeV/c2) +DECLARE_SOA_COLUMN(P, p, float); //! Momentum of candidate (GeV/c) +DECLARE_SOA_COLUMN(Pt, pt, float); //! Transverse momentum of candidate (GeV/c) +DECLARE_SOA_COLUMN(Y, y, float); //! Rapidity of candidate +DECLARE_SOA_COLUMN(Eta, eta, float); //! Pseudorapidity of candidate +DECLARE_SOA_COLUMN(Phi, phi, float); //! Azimuth angle of candidate +DECLARE_SOA_COLUMN(Ct, ct, float); //! Proper lifetime time ctau of candidate (cm) +DECLARE_SOA_COLUMN(DecayLength, decayLength, float); //! Decay length of candidate (cm) +DECLARE_SOA_COLUMN(DecayLengthXY, decayLengthXY, float); //! Transverse decay length of candidate (cm) +DECLARE_SOA_COLUMN(DecayLengthNormalised, decayLengthNormalised, float); //! Normalised decay length of candidate +DECLARE_SOA_COLUMN(DecayLengthXYNormalised, decayLengthXYNormalised, float); //! Normalised transverse decay length of candidate +DECLARE_SOA_COLUMN(Cpa, cpa, float); //! Cosine pointing angle of candidate +DECLARE_SOA_COLUMN(CpaXY, cpaXY, float); //! Cosine pointing angle of candidate in transverse plane +// properties of daughter tracks +DECLARE_SOA_COLUMN(PtXi, ptXi, float); //! Transverse momentum of Xi (prong0) (GeV/c) +DECLARE_SOA_COLUMN(ImpactParameterXi, impactParameterXi, float); //! Impact parameter of Xi (prong0) +DECLARE_SOA_COLUMN(ImpactParameterNormalisedXi, impactParameterNormalisedXi, float); //! Normalised impact parameter of Xi (prong0) +DECLARE_SOA_COLUMN(PtPi0, ptPi0, float); //! Transverse momentum of Pi0 (prong1) (GeV/c) +DECLARE_SOA_COLUMN(ImpactParameterPi0, impactParameterPi0, float); //! Impact parameter of Pi0 (prong1) +DECLARE_SOA_COLUMN(ImpactParameterNormalisedPi0, impactParameterNormalisedPi0, float); //! Normalised impact parameter of Pi0 (prong1) +DECLARE_SOA_COLUMN(PtPi1, ptPi1, float); //! Transverse momentum of Pi1 (prong2) (GeV/c) +DECLARE_SOA_COLUMN(ImpactParameterPi1, impactParameterPi1, float); //! Normalised impact parameter of Pi1 (prong2) +DECLARE_SOA_COLUMN(ImpactParameterNormalisedPi1, impactParameterNormalisedPi1, float); //! Normalised impact parameter of Pi1 (prong2) +DECLARE_SOA_COLUMN(MaxNormalisedDeltaIP, maxNormalisedDeltaIP, float); //! Maximum normalized difference between measured and expected impact parameter of candidate prongs +DECLARE_SOA_COLUMN(CpaXi, cpaXi, float); +DECLARE_SOA_COLUMN(CpaXYXi, cpaXYXi, float); +DECLARE_SOA_COLUMN(CpaLam, cpaLam, float); +DECLARE_SOA_COLUMN(CpaXYLam, cpaXYLam, float); +DECLARE_SOA_COLUMN(DcaPi0Pi1, dcaPi0Pi1, float); +DECLARE_SOA_COLUMN(DcaPi0Xi, dcaPi0Xi, float); +DECLARE_SOA_COLUMN(DcaPi1Xi, dcaPi1Xi, float); +// PID daughters +DECLARE_SOA_COLUMN(NSigTpcPi1, nSigTpcPi1, float); //! TPC Nsigma separation for prong1 with pion mass hypothesis +DECLARE_SOA_COLUMN(NSigTofPi1, nSigTofPi1, float); //! TOF Nsigma separation for prong1 with pion mass hypothesis +// Events +DECLARE_SOA_COLUMN(IsEventReject, isEventReject, int); //! Event rejection flag +DECLARE_SOA_COLUMN(RunNumber, runNumber, int); //! Run number +} // namespace full + +DECLARE_SOA_TABLE(HfCandXicLites, "AOD", "HFCANDXICLITE", + full::XiId, + full::Pi0Id, + full::Pi1Id, + full::CandidateSelFlag, + full::PvX, + full::PvY, + full::PvZ, + full::SvX, + full::SvY, + full::SvZ, + full::Chi2Sv, + full::Sign, + full::E, + full::M, + full::P, + full::Pt, + full::Y, + full::Eta, + full::Phi, + full::Ct, + full::DecayLength, + full::DecayLengthXY, + full::Cpa, + full::CpaXY, + full::PtXi, + full::PtPi0, + full::PtPi1, + full::ImpactParameterXi, + full::ImpactParameterPi0, + full::ImpactParameterPi1, + full::CpaXi, + full::CpaXYXi, + full::CpaLam, + full::CpaXYLam, + //full::DcaPi0Pi1, + //full::DcaPi0Xi, + //full::DcaPi1Xi, + hf_cand_xictoxipipi::FlagMcMatchRec); + +DECLARE_SOA_TABLE(HfCandXicFulls, "AOD", "HFCANDXICFULL", + full::XiId, + full::Pi0Id, + full::Pi1Id, + full::CandidateSelFlag, + full::PvX, + full::PvY, + full::PvZ, + full::PvErrX, + full::PvErrY, + full::PvErrZ, + full::SvX, + full::SvY, + full::SvZ, + full::Chi2Sv, + full::SvErrX, + full::SvErrY, + full::SvErrZ, + full::DecVtxXiX, + full::DecVtxXiY, + full::DecVtxXiZ, + //full::Chi2XiVtx, + full::DecVtxLamX, + full::DecVtxLamY, + full::DecVtxLamZ, + //full::Chi2LamVtx, + full::Sign, + full::E, + full::M, + full::P, + full::Pt, + full::Y, + full::Eta, + full::Phi, + full::Ct, + full::DecayLength, + full::DecayLengthNormalised, + full::DecayLengthXY, + full::DecayLengthXYNormalised, + full::Cpa, + full::CpaXY, + full::PtXi, + full::PtPi0, + full::PtPi1, + full::ImpactParameterXi, + full::ImpactParameterNormalisedXi, + full::ImpactParameterPi0, + full::ImpactParameterNormalisedPi0, + full::ImpactParameterPi1, + full::ImpactParameterNormalisedPi1, + full::MaxNormalisedDeltaIP, + full::CpaXi, + full::CpaXYXi, + full::CpaLam, + full::CpaXYLam, + //full::DcaPi0Pi1, + //full::DcaPi0Xi, + //full::DcaPi1Xi, + hf_cand_xictoxipipi::FlagMcMatchRec); + +DECLARE_SOA_TABLE(HfCandXicFullEvs, "AOD", "HFCANDXICFULLEV", + collision::BCId, + collision::NumContrib, + collision::PosX, + collision::PosY, + collision::PosZ, + full::IsEventReject, + full::RunNumber); + +DECLARE_SOA_TABLE(HfCandXicFullPs, "AOD", "HFCANDXICFULLP", + collision::BCId, + full::Pt, + full::Eta, + full::Phi, + full::Y, + hf_cand_xictoxipipi::FlagMcMatchGen); +} // namespace o2::aod + +/// Writes the full information in an output TTree +struct HfTreeCreatorXicToXiPiPi { + Produces rowCandidateLite; + Produces rowCandidateFull; + Produces rowCandidateFullEvents; + Produces rowCandidateFullParticles; + + Configurable selectionFlagXic{"selectionXic", 1, "Selection Flag for Xic"}; + Configurable fillCandidateLiteTable{"fillCandidateLiteTable", false, "Switch to fill lite table with candidate properties"}; + // parameters for production of training samples + Configurable fillOnlySignal{"fillOnlySignal", false, "Flag to fill derived tables with signal for ML trainings"}; + Configurable fillOnlyBackground{"fillOnlyBackground", false, "Flag to fill derived tables with background for ML trainings"}; + Configurable downSampleBkgFactor{"downSampleBkgFactor", 1., "Fraction of background candidates to keep for ML trainings"}; + Configurable ptMaxForDownSample{"ptMaxForDownSample", 10., "Maximum pt for the application of the downsampling factor"}; + + using SelectedCandidatesMc = soa::Filtered>; + using TracksWPid = soa::Join; + + Filter filterSelectCandidates = aod::hf_sel_candidate_xic::isSelXicToXiPiPi >= selectionFlagXic; + + Partition recSig = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) == (int8_t)BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); + Partition recBg = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) != (int8_t)BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); + + void init(InitContext const&) + { + } + + template + void fillEvent(const T& collision, int isEventReject, int runNumber) + { + rowCandidateFullEvents( + collision.bcId(), + collision.numContrib(), + collision.posX(), + collision.posY(), + collision.posZ(), + isEventReject, //! filled with 0 + runNumber //! filled with 1 + ); + } + + template + void fillCandidateTable(const T& candidate) + { + int8_t flagMc = 0; + if constexpr (doMc) { + flagMc = candidate.flagMcMatchRec(); + } + if (fillCandidateLiteTable) { + rowCandidateLite( + candidate.cascadeId(), + candidate.pi0Id(), + candidate.pi1Id(), + candidate.isSelXicToXiPiPi(), + candidate.posX(), + candidate.posY(), + candidate.posZ(), + candidate.xSecondaryVertex(), + candidate.ySecondaryVertex(), + candidate.zSecondaryVertex(), + candidate.chi2PCA(), + candidate.sign(), + candidate.e(o2::constants::physics::MassXiCPlus), + candidate.invMassXic(), + candidate.p(), + candidate.pt(), + candidate.y(o2::constants::physics::MassXiCPlus), + candidate.eta(), + candidate.phi(), + candidate.ct(o2::constants::physics::MassXiCPlus), + candidate.decayLength(), + candidate.decayLengthXY(), + candidate.cpa(), + candidate.cpaXY(), + candidate.ptProng0(), + candidate.ptProng1(), + candidate.ptProng2(), + candidate.impactParameter0(), + candidate.impactParameter1(), + candidate.impactParameter2(), + candidate.cosPaXi(), + candidate.cosPaXYXi(), + candidate.cosPaLambda(), + candidate.cosPaXYLambda(), + //candidate.dcaPi0Pi1(), + //candidate.dcaPi0Xi(), + //candidate.dcaPi1Xi(), + flagMc); + } else { + rowCandidateFull( + candidate.cascadeId(), + candidate.pi0Id(), + candidate.pi1Id(), + candidate.isSelXicToXiPiPi(), + candidate.posX(), + candidate.posY(), + candidate.posZ(), + candidate.xPvErr(), + candidate.yPvErr(), + candidate.zPvErr(), + candidate.xSecondaryVertex(), + candidate.ySecondaryVertex(), + candidate.zSecondaryVertex(), + candidate.chi2PCA(), + candidate.xSvErr(), + candidate.ySvErr(), + candidate.zSvErr(), + candidate.xDecayVtxXi(), + candidate.yDecayVtxXi(), + candidate.zDecayVtxXi(), + //candidate.kfCascadeChi2(), + candidate.xDecayVtxLambda(), + candidate.yDecayVtxLambda(), + candidate.zDecayVtxLambda(), + //candidate.kfV0Chi2(), + candidate.sign(), + candidate.e(o2::constants::physics::MassXiCPlus), + candidate.invMassXic(), + candidate.p(), + candidate.pt(), + candidate.y(o2::constants::physics::MassXiCPlus), + candidate.eta(), + candidate.phi(), + candidate.ct(o2::constants::physics::MassXiCPlus), + candidate.decayLength(), + candidate.decayLengthNormalised(), + candidate.decayLengthXY(), + candidate.decayLengthXYNormalised(), + candidate.cpa(), + candidate.cpaXY(), + candidate.ptProng0(), + candidate.ptProng1(), + candidate.ptProng2(), + candidate.impactParameter0(), + candidate.impactParameterNormalised0(), + candidate.impactParameter1(), + candidate.impactParameterNormalised1(), + candidate.impactParameter2(), + candidate.impactParameterNormalised2(), + candidate.maxNormalisedDeltaIP(), + candidate.cosPaXi(), + candidate.cosPaXYXi(), + candidate.cosPaLambda(), + candidate.cosPaXYLambda(), + //candidate.dcaPi0Pi1(), + //candidate.dcaPi0Xi(), + //candidate.dcaPi1Xi(), + flagMc); + } + } + + void processData(aod::Collisions const& collisions, + soa::Filtered> const& candidates, + TracksWPid const&) + { + // Filling event properties + rowCandidateFullEvents.reserve(collisions.size()); + for (const auto& collision : collisions) { + fillEvent(collision, 0, 1); + } + + // Filling candidate properties + rowCandidateFull.reserve(candidates.size()); + if (fillCandidateLiteTable) { + rowCandidateLite.reserve(candidates.size()); + } + for (const auto& candidate : candidates) { + if (fillOnlyBackground && downSampleBkgFactor < 1.) { + float pseudoRndm = candidate.ptProng1() * 1000. - (int64_t)(candidate.ptProng1() * 1000); + if (pseudoRndm >= downSampleBkgFactor && candidate.pt() < ptMaxForDownSample) { + continue; + } + } + fillCandidateTable(candidate); + } + } + + PROCESS_SWITCH(HfTreeCreatorXicToXiPiPi, processData, "Process data", true); + + void processMc(aod::Collisions const& collisions, + aod::McCollisions const&, + SelectedCandidatesMc const& candidates, + soa::Join const& particles, + TracksWPid const&) + { + // Filling event properties + rowCandidateFullEvents.reserve(collisions.size()); + for (const auto& collision : collisions) { + fillEvent(collision, 0, 1); + } + + // Filling candidate properties + if (fillOnlySignal) { + rowCandidateFull.reserve(recSig.size()); + if (fillCandidateLiteTable) { + rowCandidateLite.reserve(recSig.size()); + } + for (const auto& candidate : recSig) { + fillCandidateTable(candidate); + } + } else if (fillOnlyBackground) { + rowCandidateFull.reserve(recBg.size()); + if (fillCandidateLiteTable) { + rowCandidateLite.reserve(recBg.size()); + } + for (const auto& candidate : recBg) { + float pseudoRndm = candidate.ptProng1() * 1000. - (int64_t)(candidate.ptProng1() * 1000); + if (candidate.pt() < ptMaxForDownSample && pseudoRndm >= downSampleBkgFactor) { + continue; + } + fillCandidateTable(candidate); + } + } else { + rowCandidateFull.reserve(candidates.size()); + if (fillCandidateLiteTable) { + rowCandidateLite.reserve(candidates.size()); + } + for (const auto& candidate : candidates) { + fillCandidateTable(candidate); + } + } + + // Filling particle properties + rowCandidateFullParticles.reserve(particles.size()); + for (const auto& particle : particles) { + if (TESTBIT(std::abs(particle.flagMcMatchGen()), aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { + rowCandidateFullParticles( + particle.mcCollision().bcId(), + particle.pt(), + particle.eta(), + particle.phi(), + RecoDecay::y(std::array{particle.px(), particle.py(), particle.pz()}, o2::constants::physics::MassXiCPlus), + particle.flagMcMatchGen()); + } + } + } + + PROCESS_SWITCH(HfTreeCreatorXicToXiPiPi, processMc, "Process MC", false); +}; + + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; +} From be85e11613f7515d64def49596dbe4e9267e7f76 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Tue, 5 Mar 2024 22:31:33 +0100 Subject: [PATCH 11/35] First version of Xic task for filling histograms --- PWGHF/D2H/Tasks/CMakeLists.txt | 5 + PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx | 348 ++++++++++++++++++ .../DataModel/CandidateReconstructionTables.h | 3 +- 3 files changed, 355 insertions(+), 1 deletion(-) create mode 100644 PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx diff --git a/PWGHF/D2H/Tasks/CMakeLists.txt b/PWGHF/D2H/Tasks/CMakeLists.txt index 4a533812364..48c93bbebca 100644 --- a/PWGHF/D2H/Tasks/CMakeLists.txt +++ b/PWGHF/D2H/Tasks/CMakeLists.txt @@ -89,6 +89,11 @@ o2physics_add_dpl_workflow(task-xic PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(task-xic-to-xi-pi-pi + SOURCES taskXicToXiPiPi.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(task-xicc SOURCES taskXicc.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore diff --git a/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx new file mode 100644 index 00000000000..ad68cf190d0 --- /dev/null +++ b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx @@ -0,0 +1,348 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \file taskXicToXiPiPi.cxx +/// \brief Ξc± → (Ξ∓ → (Λ → p π∓) π∓) π± π± analysis task +/// \note adapted from taskBs.cxx +/// +/// \author Phil Stahlhut + +#include "CommonConstants/PhysicsConstants.h" +#include "Framework/AnalysisTask.h" +#include "Framework/HistogramRegistry.h" +#include "Framework/O2DatabasePDGPlugin.h" +#include "Framework/runDataProcessing.h" + +#include "PWGHF/Core/SelectorCuts.h" +#include "PWGHF/DataModel/CandidateReconstructionTables.h" +#include "PWGHF/DataModel/CandidateSelectionTables.h" + +using namespace o2; +using namespace o2::aod; +using namespace o2::analysis; +using namespace o2::framework; +using namespace o2::framework::expressions; + +/// Bs analysis task +struct HfTaskXicToXiPiPi { + Configurable selectionFlagXic{"selectionFlagXic", 1, "Selection Flag for Xic"}; + Configurable yCandGenMax{"yCandGenMax", 0.5, "max. gen particle rapidity"}; + Configurable yCandRecoMax{"yCandRecoMax", 0.8, "max. cand. rapidity"}; + Configurable etaTrackMax{"etaTrackMax", 0.8, "max. track pseudo-rapidity"}; + Configurable ptTrackMin{"ptTrackMin", 0.1, "min. track transverse momentum"}; + Configurable> binsPt{"binsPt", std::vector{hf_cuts_xic_to_xi_pi_pi::vecBinsPt}, "pT bin limits"}; + // MC checks + Configurable checkDecayTypeMc{"checkDecayTypeMc", false, "Flag to enable DecayType histogram"}; + + Service pdg; + + Filter filterSelectCandidates = (aod::hf_sel_candidate_xic::isSelXicToXiPiPi >= selectionFlagXic); + + HistogramRegistry registry{ + "registry", + {{"hPtCand", "#Xi^{#plus}_{c} candidates;candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{1000, 0., 40.}}}}, + {"hPtProng0", "#Xi^{#plus}_{c} candidates;prong 0 (#Xi^{#minus}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{1000, 0., 40.}}}}, + {"hPtProng1", "#Xi^{#plus}_{c} candidates;prong 1 (#pi^{#plus}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{200, 0., 16.}}}}, + {"hPtProng2", "#Xi^{#plus}_{c} candidates;prong 2 (#pi^{#plus}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{200, 0., 16.}}}}}}; + + void init(InitContext const&) + { + static const AxisSpec axisMassXic = {300, 1.8, 3.0, "inv. mass (GeV/#it{c}^{2})"}; + static const AxisSpec axisPt = {(std::vector)binsPt, "#it{p}_{T} (GeV/#it{c})"}; + + registry.add("hEta", "#Xi^{#plus}_{c} candidates;#Xi^{#plus}_{c} candidate #it{#eta};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + registry.add("hRapidity", "#Xi^{#plus}_{c} candidates;#Xi^{#plus}_{c} candidate #it{y};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + registry.add("hCPA", "#Xi^{#plus}_{c} candidates;#Xi^{#plus}_{c} candidate cosine of pointing angle;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hCPAxy", "#Xi^{#plus}_{c} candidates;#Xi^{#plus}_{c} candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hMass", "#Xi^{#plus}_{c} candidates;inv. mass #Xi^{#mp} #pi^{#pm} #pi^{#pm} (GeV/#it{c}^{2});#it{p}_{T} (GeV/#it{c})", {HistType::kTH2F, {axisMassXic, axisPt}}); + registry.add("hDecLength", "#Xi^{#plus}_{c} candidates;decay length (cm);entries", {HistType::kTH2F, {{200, 0., 0.4}, axisPt}}); + registry.add("hDecLenErr", "#Xi^{#plus}_{c} candidates;#Xi^{#plus}_{c} candidate decay length error (cm);entries", {HistType::kTH2F, {{100, 0., 1.}, axisPt}}); + registry.add("hDecLengthXY", "#Xi^{#plus}_{c} candidates;decay length xy (cm);entries", {HistType::kTH2F, {{200, 0., 0.4}, axisPt}}); + registry.add("hDecLenXYErr", "#Xi^{#plus}_{c} candidates;#Xi^{#plus}_{c} candidate decay length xy error (cm);entries", {HistType::kTH2F, {{100, 0., 1.}, axisPt}}); + registry.add("hd0Prong0", "#Xi^{#plus}_{c} candidates;prong 0 (#Xi^{#mp}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{100, -0.05, 0.05}, axisPt}}); + registry.add("hd0Prong1", "#Xi^{#plus}_{c} candidates;prong 1 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{100, -0.05, 0.05}, axisPt}}); + registry.add("hd0Prong2", "#Xi^{#plus}_{c} candidates;prong 2 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{100, -0.05, 0.05}, axisPt}}); + registry.add("hImpParErr", "#Xi^{#plus}_{c} candidates;#Xi^{#plus}_{c} candidate impact parameter error (cm);entries", {HistType::kTH2F, {{100, -1., 1.}, axisPt}}); + //registry.add("hInvMassXi", "#Xi^{#plus}_{c} candidates;prong 0 (#Xi^{#mp}) inv. mass (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{500, 0, 5}, axisPt}}); + registry.add("hChi2PCA", "#Xi^{#plus}_{c} candidates (matched);sum of distances of the secondary vertex to its prongs;entries", {HistType::kTH2F, {{240, -0.01, 0.1}, axisPt}}); + registry.add("hCPAXi", "#Xi^{#plus}_{c} candidates;#Xi^{#minus} candidate cosine of pointing angle;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hCPAxyXi", "#Xi^{#plus}_{c} candidates;#Xi^{#minus} candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hCPALambda", "#Xi^{#plus}_{c} candidates;#Lambda candidate cosine of pointing angle;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hCPAxyLambda", "#Xi^{#plus}_{c} candidates;#Lambda candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + /* + MC reconstructed + */ + registry.add("hPtGenSig", "#Xi^{#plus}_{c} candidates (gen+rec);candidate #it{p}_{T}^{gen.} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); + registry.add("hPtRecSig", "#Xi^{#plus}_{c} candidates (matched);candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); + registry.add("hPtRecBg", "#Xi^{#plus}_{c} candidates (unmatched);candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); + registry.add("hPtProng0RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 0 (#Xi^{#mp}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); + registry.add("hPtProng0RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 0 (#Xi^{#mp}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); + registry.add("hPtProng1RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 1 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); + registry.add("hPtProng1RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 1 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); + registry.add("hPtProng2RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 2 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); + registry.add("hPtProng2RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 2 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); + registry.add("hEtaRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate #it{#eta};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + registry.add("hEtaRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate #it{#eta};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + registry.add("hRapidityRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate #it{y};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + registry.add("hRapidityRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate #it{y};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + registry.add("hCPARecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate cosine of pointing angle;entries", {HistType::kTH2F, {{220, 0., 1.1}, axisPt}}); + registry.add("hCPARecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate cosine of pointing angle;entries", {HistType::kTH2F, {{220, 0., 1.1}, axisPt}}); + registry.add("hCPAxyRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate CPAxy;entries", {HistType::kTH2F, {{220, 0., 1.1}, axisPt}}); + registry.add("hCPAxyRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate CPAxy;entries", {HistType::kTH2F, {{220, 0., 1.1}, axisPt}}); + registry.add("hMassRecSig", "#Xi^{#plus}_{c} candidates (matched);inv. mass #Xi^{#mp} #pi^{#pm} #pi^{#pm} (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 4.0, 7.00}, axisPt}}); + registry.add("hMassRecBg", "#Xi^{#plus}_{c} candidates (unmatched);inv. mass #Xi^{#mp} #pi^{#pm} #pi^{#pm} (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 4.0, 7.0}, axisPt}}); + registry.add("hDecLengthRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); + registry.add("hDecLengthRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); + // DecLenghtErr + registry.add("hDecLengthXYRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length xy (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); + registry.add("hDecLengthXYRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate decay length xy(cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); + // DecLengthXYErr + //registry.add("hDecLengthNormRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); + //registry.add("hDecLengthNormRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); + registry.add("hd0Prong0RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 0 (#Xi^{#mp}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); + registry.add("hd0Prong0RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 0 (#Xi^{#mp}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); + registry.add("hd0Prong1RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 1 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); + registry.add("hd0Prong1RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 1 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); + registry.add("hd0Prong2RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 2 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); + registry.add("hd0Prong2RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 2 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); + // ImpParErr + // InvMassXi + registry.add("hChi2PCARecSig", "#Xi^{#plus}_{c} candidates (matched);sum of distances of the secondary vertex to its prongs;entries", {HistType::kTH2F, {{240, -0.01, 0.1}, axisPt}}); + registry.add("hChi2PCARecBg", "#Xi^{#plus}_{c} candidates (unmatched);sum of distances of the secondary vertex to its prongs;entries", {HistType::kTH2F, {{240, -0.01, 0.1}, axisPt}}); + registry.add("hCPAXiRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#minus} cosine of pointing angle;entries", {HistType::kTH2F, {{220, 0., 1.1}, axisPt}}); + registry.add("hCPAXiRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#minus} cosine of pointing angle;entries", {HistType::kTH2F, {{220, 0., 1.1}, axisPt}}); + registry.add("hCPAxyXiRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#minus} candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hCPAxyXiRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#minus} candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hCPALambdaRecSig", "#Xi^{#plus}_{c} candidates (matched);#Lambda candidate cosine of pointing angle;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hCPALambdaRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Lambda candidate cosine of pointing angle;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hCPAxyLambdaRecSig", "#Xi^{#plus}_{c} candidates (matched);#Lambda candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hCPAxyLambdaRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Lambda candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + /* + MC generated + */ + registry.add("hPtProng0Gen", "MC particles (generated);prong 0 (#Xi^{#mp}) #it{p}_{T}^{gen} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); + registry.add("hPtProng1Gen", "MC particles (generated);prong 1 (#pi^{#pm}) #it{p}_{T}^{gen} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); + registry.add("hPtProng2Gen", "MC particles (generated);prong 2 (#pi^{#pm}) #it{p}_{T}^{gen} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); + registry.add("hEtaProng0Gen", "MC particles (generated);prong 0 (#Xi^{#mp}) #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); + registry.add("hEtaProng1Gen", "MC particles (generated);prong 1 (#pi^{#pm}) #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); + registry.add("hEtaProng2Gen", "MC particles (generated);prong 2 (#pi^{#pm}) #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); + registry.add("hYProng0Gen", "MC particles (generated);prong 0 (#Xi^{#mp}) #it{y}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); + registry.add("hYProng1Gen", "MC particles (generated);prong 1 (#pi^{#pm}) #it{y}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); + registry.add("hYProng2Gen", "MC particles (generated);prong 2 (#pi^{#pm}) #it{y}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); + registry.add("hPtGen", "MC particles (generated);candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); + registry.add("hEtaGen", "MC particles (generated);#Xi^{#plus}_{c} candidate #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + registry.add("hYGen", "MC particles (generated);#Xi^{#plus}_{c} candidate #it{y}^{gen};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + registry.add("hPtGenWithProngsInAcceptance", "MC particles (generated-daughters in acceptance);candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); + registry.add("hEtaGenWithProngsInAcceptance", "MC particles (generated-daughters in acceptance);#Xi^{#plus}_{c} candidate #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + registry.add("hYGenWithProngsInAcceptance", "MC particles (generated-daughters in acceptance);#Xi^{#plus}_{c} candidate #it{y}^{gen};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + + if (checkDecayTypeMc) { + constexpr uint8_t kNBinsDecayTypeMc = hf_cand_xictoxipipi::DecayType::NDecayType + 1; + TString labels[kNBinsDecayTypeMc]; + labels[hf_cand_xictoxipipi::DecayType::XicToXiPiPi] = "#Xi^{+}_{c} #rightarrow (#Xi^{#minus} #rightarrow #Lambda^{0} #pi^{#minus} #rightarrow p #pi^{#minus} #pi^{#minus}) #pi^{#plus}) #pi^{#plus}"; + /*labels[hf_cand_xictoxipipi::DecayTypeMc::PartlyRecoDecay] = "Partly reconstructed decay channel";*/ + labels[hf_cand_xictoxipipi::DecayType::NDecayType] = "Other decays"; + static const AxisSpec axisDecayType = {kNBinsDecayTypeMc, 0.5, kNBinsDecayTypeMc + 0.5, ""}; + registry.add("hDecayTypeMc", "DecayType", {HistType::kTH3F, {axisDecayType, axisMassXic, axisPt}}); + for (uint8_t iBin = 0; iBin < kNBinsDecayTypeMc; ++iBin) { + registry.get(HIST("hDecayTypeMc"))->GetXaxis()->SetBinLabel(iBin + 1, labels[iBin]); + } + } + } + + /// Selection of Xic daughter in geometrical acceptance + /// \param etaProng is the pseudorapidity of Xic prong + /// \param ptProng is the pT of Xic prong + /// \return true if prong is in geometrical acceptance + template + bool isProngInAcceptance(const T& etaProng, const T& ptProng) + { + return std::abs(etaProng) <= etaTrackMax && ptProng >= ptTrackMin; + } + + void process(soa::Filtered> const& candidates) + { + for (const auto& candidate : candidates) { + if (!TESTBIT(candidate.hfflag(), hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { + continue; + } + auto yCandXic = candidate.y(o2::constants::physics::MassXiCPlus); + if (yCandRecoMax >= 0. && std::abs(yCandXic) > yCandRecoMax) { + continue; + } + + auto ptCandXic = candidate.pt(); + + registry.fill(HIST("hPtCand"), ptCandXic); + registry.fill(HIST("hPtProng0"), candidate.ptProng0()); + registry.fill(HIST("hPtProng1"), candidate.ptProng1()); + registry.fill(HIST("hPtProng2"), candidate.ptProng2()); + registry.fill(HIST("hEta"), candidate.eta(), ptCandXic); + registry.fill(HIST("hRapidity"), yCandXic, ptCandXic); + registry.fill(HIST("hCPA"), candidate.cpa(), ptCandXic); + registry.fill(HIST("hCPAxy"), candidate.cpaXY(), ptCandXic); + registry.fill(HIST("hMass"), candidate.invMassXic(), ptCandXic); + registry.fill(HIST("hDecLength"), candidate.decayLength(), ptCandXic); + registry.fill(HIST("hDecLenErr"), candidate.errorDecayLength(), ptCandXic); + registry.fill(HIST("hDecLengthXY"), candidate.decayLengthXY(), ptCandXic); + registry.fill(HIST("hDecLenXYErr"), candidate.errorDecayLengthXY(), ptCandXic); + registry.fill(HIST("hd0Prong0"), candidate.impactParameter0(), ptCandXic); + registry.fill(HIST("hd0Prong1"), candidate.impactParameter1(), ptCandXic); + registry.fill(HIST("hd0Prong2"), candidate.impactParameter2(), ptCandXic); + registry.fill(HIST("hImpParErr"), candidate.errorImpactParameter0(), ptCandXic); + registry.fill(HIST("hImpParErr"), candidate.errorImpactParameter1(), ptCandXic); + registry.fill(HIST("hImpParErr"), candidate.errorImpactParameter2(), ptCandXic); + registry.fill(HIST("hChi2PCA"), candidate.chi2PCA(), ptCandXic); + registry.fill(HIST("hCPAXi"), candidate.cosPaXi(), ptCandXic); + registry.fill(HIST("hCPAxyXi"), candidate.cosPaXYXi(), ptCandXic); + registry.fill(HIST("hCPALambda"), candidate.cosPaLambda(), ptCandXic); + registry.fill(HIST("hCPAxyLambda"), candidate.cosPaLambda(), ptCandXic); + } // candidate loop + } // process + + /// Bs MC analysis and fill histograms + void processMc(soa::Filtered> const& candidates, + soa::Join const& mcParticles, + aod::TracksWMc const&) + { + // MC rec + for (const auto& candidate : candidates) { + if (!TESTBIT(candidate.hfflag(), hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { + continue; + } + auto yCandXic = candidate.y(o2::constants::physics::MassXiCPlus); + if (yCandRecoMax >= 0. && std::abs(yCandXic) > yCandRecoMax) { + continue; + } + + auto ptCandXic = candidate.pt(); + int flagMcMatchRecXic = std::abs(candidate.flagMcMatchRec()); + + if (TESTBIT(flagMcMatchRecXic, hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { + auto indexMother = RecoDecay::getMother(mcParticles, candidate.pi0_as().mcParticle_as>(), o2::constants::physics::Pdg::kXiCPlus, true); + auto particleMother = mcParticles.rawIteratorAt(indexMother); + + registry.fill(HIST("hPtGenSig"), particleMother.pt()); + registry.fill(HIST("hPtCandRecSig"), ptCandXic); + registry.fill(HIST("hPtProng0RecSig"), candidate.ptProng0()); + registry.fill(HIST("hPtProng1RecSig"), candidate.ptProng1()); + registry.fill(HIST("hPtProng2RecSig"), candidate.ptProng2()); + registry.fill(HIST("hEtaRecSig"), candidate.eta(), ptCandXic); + registry.fill(HIST("hRapidityRecSig"), yCandXic, ptCandXic); + registry.fill(HIST("hCPARecSig"), candidate.cpa(), ptCandXic); + registry.fill(HIST("hCPAxyRecSig"), candidate.cpaXY(), ptCandXic); + registry.fill(HIST("hMassRecSig"), candidate.invMassXic(), ptCandXic); + registry.fill(HIST("hDecLengthRecSig"), candidate.decayLength(), ptCandXic); + //registry.fill(HIST("hDecLenErrRecSig"), candidate.errorDecayLength(), ptCandXic); + registry.fill(HIST("hDecLengthXYRecSig"), candidate.decayLengthXY(), ptCandXic); + //registry.fill(HIST("hDecLenXYErrRecSig"), candidate.errorDecayLengthXY(), ptCandXic); + registry.fill(HIST("hd0Prong0RecSig"), candidate.impactParameter0(), ptCandXic); + registry.fill(HIST("hd0Prong1RecSig"), candidate.impactParameter1(), ptCandXic); + registry.fill(HIST("hd0Prong2RecSig"), candidate.impactParameter2(), ptCandXic); + //registry.fill(HIST("hImpParErrRecSig"), candidate.errorImpactParameter0(), ptCandXic); + //registry.fill(HIST("hImpParErrRecSig"), candidate.errorImpactParameter1(), ptCandXic); + //registry.fill(HIST("hImpParErrRecSig"), candidate.errorImpactParameter2(), ptCandXic); + registry.fill(HIST("hChi2PCARecSig"), candidate.chi2PCA(), ptCandXic); + registry.fill(HIST("hCPAXiRecSig"), candidate.cosPaXi(), ptCandXic); + registry.fill(HIST("hCPAxyXiRecSig"), candidate.cosPaXYXi(), ptCandXic); + registry.fill(HIST("hCPALambdaRecSig"), candidate.cosPaLambda(), ptCandXic); + registry.fill(HIST("hCPAxyLambdaRecSig"), candidate.cosPaLambda(), ptCandXic); + + if (checkDecayTypeMc) { + registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_xictoxipipi::DecayType::XicToXiPiPi, candidate.invMassXic(), ptCandXic); + } + } else { + registry.fill(HIST("hPtCandRecBg"), ptCandXic); + registry.fill(HIST("hPtProng0RecBg"), candidate.ptProng0()); + registry.fill(HIST("hPtProng1RecBg"), candidate.ptProng1()); + registry.fill(HIST("hPtProng2RecBg"), candidate.ptProng2()); + registry.fill(HIST("hEtaRecBg"), candidate.eta(), ptCandXic); + registry.fill(HIST("hRapidityRecBg"), yCandXic, ptCandXic); + registry.fill(HIST("hCPARecBg"), candidate.cpa(), ptCandXic); + registry.fill(HIST("hCPAxyRecBg"), candidate.cpaXY(), ptCandXic); + registry.fill(HIST("hMassRecBg"), candidate.invMassXic(), ptCandXic); + registry.fill(HIST("hDecLengthRecBg"), candidate.decayLength(), ptCandXic); + //registry.fill(HIST("hDecLenErrRecBg"), candidate.errorDecayLength(), ptCandXic); + registry.fill(HIST("hDecLengthXYRecBg"), candidate.decayLengthXY(), ptCandXic); + //registry.fill(HIST("hDecLenXYErrRecBg"), candidate.errorDecayLengthXY(), ptCandXic); + registry.fill(HIST("hd0Prong0RecBg"), candidate.impactParameter0(), ptCandXic); + registry.fill(HIST("hd0Prong1RecBg"), candidate.impactParameter1(), ptCandXic); + registry.fill(HIST("hd0Prong2RecBg"), candidate.impactParameter2(), ptCandXic); + //registry.fill(HIST("hImpParErrRecBg"), candidate.errorImpactParameter0(), ptCandXic); + //registry.fill(HIST("hImpParErrRecBg"), candidate.errorImpactParameter1(), ptCandXic); + //registry.fill(HIST("hImpParErrRecBg"), candidate.errorImpactParameter2(), ptCandXic); + registry.fill(HIST("hChi2PCARecBg"), candidate.chi2PCA(), ptCandXic); + registry.fill(HIST("hCPAXiRecBg"), candidate.cosPaXi(), ptCandXic); + registry.fill(HIST("hCPAxyXiRecBg"), candidate.cosPaXYXi(), ptCandXic); + registry.fill(HIST("hCPALambdaRecBg"), candidate.cosPaLambda(), ptCandXic); + registry.fill(HIST("hCPAxyLambdaRecBg"), candidate.cosPaLambda(), ptCandXic); + if (checkDecayTypeMc) { + registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_xictoxipipi::DecayType::NDecayType, candidate.invMassXic(), ptCandXic); + /*if (TESTBIT(flagMcMatchRecBs, hf_cand_bs::DecayTypeMc::PartlyRecoDecay)) { // Partly reconstructed decay channel + registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_bs::DecayTypeMc::PartlyRecoDecay, invMassCandBs, ptCandXic); + //} else { + registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_bs::DecayTypeMc::NDecayTypeMc, invMassCandBs, ptCandXic); + }*/ + } + } + } // rec + + // MC gen. level + for (const auto& particle : mcParticles) { + if (TESTBIT(std::abs(particle.flagMcMatchGen()), hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { + + auto ptParticle = particle.pt(); + auto yParticle = RecoDecay::y(std::array{particle.px(), particle.py(), particle.pz()}, o2::constants::physics::MassXiCPlus); + if (yCandGenMax >= 0. && std::abs(yParticle) > yCandGenMax) { + continue; + } + + std::array ptProngs; + std::array yProngs; + std::array etaProngs; + int counter = 0; + for (const auto& daught : particle.daughters_as()) { + ptProngs[counter] = daught.pt(); + etaProngs[counter] = daught.eta(); + yProngs[counter] = RecoDecay::y(std::array{daught.px(), daught.py(), daught.pz()}, pdg->Mass(daught.pdgCode())); + counter++; + } + + registry.fill(HIST("hPtProng0Gen"), ptProngs[0], ptParticle); + registry.fill(HIST("hPtProng1Gen"), ptProngs[1], ptParticle); + registry.fill(HIST("hPtProng2Gen"), ptProngs[2], ptParticle); + registry.fill(HIST("hEtaProng0Gen"), etaProngs[0], ptParticle); + registry.fill(HIST("hEtaProng1Gen"), etaProngs[1], ptParticle); + registry.fill(HIST("hEtaProng2Gen"), etaProngs[2], ptParticle); + registry.fill(HIST("hYProng0Gen"), yProngs[0], ptParticle); + registry.fill(HIST("hYProng1Gen"), yProngs[1], ptParticle); + registry.fill(HIST("hYProng2Gen"), yProngs[2], ptParticle); + registry.fill(HIST("hPtGen"), ptParticle); + registry.fill(HIST("hYGen"), yParticle, ptParticle); + registry.fill(HIST("hEtaGen"), particle.eta(), ptParticle); + + // reject Bs daughters that are not in geometrical acceptance + if (!isProngInAcceptance(etaProngs[0], ptProngs[0]) || !isProngInAcceptance(etaProngs[1], ptProngs[1]) || !isProngInAcceptance(etaProngs[2], ptProngs[2])) { + continue; + } + registry.fill(HIST("hPtGenWithProngsInAcceptance"), ptParticle); + registry.fill(HIST("hEtaGenWithProngsInAcceptance"), particle.eta(), ptParticle); + registry.fill(HIST("hYGenWithProngsInAcceptance"), yParticle, ptParticle); + } + } // gen + } // process + PROCESS_SWITCH(HfTaskXicToXiPiPi, processMc, "Process MC", false); +}; // struct + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; +} diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index d46ad2ce47f..3131a90d229 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1361,7 +1361,8 @@ DECLARE_SOA_COLUMN(DebugMcGen, debugMcGen, int8_t); DECLARE_SOA_COLUMN(OriginRec, originRec, int8_t); DECLARE_SOA_COLUMN(OriginGen, originGen, int8_t); // mapping of decay types -enum DecayType { XicToXiPiPi=0 }; +enum DecayType { XicToXiPiPi=0, + NDecayType }; } // end of namespace hf_cand_xictoxipipi // declare dedicated Xic to Xi Pi Pi candidate table From 59ae4418046cf723597c0acb7fe1805a481d77f7 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Fri, 8 Dec 2023 17:57:57 +0100 Subject: [PATCH 12/35] First draft of Xicplus workflow --- .../DataModel/CandidateReconstructionTables.h | 144 ++++++++++++++++++ 1 file changed, 144 insertions(+) diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index 3131a90d229..0d66459522d 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1320,6 +1320,7 @@ DECLARE_SOA_TABLE(HfToOmegaKMCGen, "AOD", "HFTOOMEKMCGEN", //! hf_cand_xic0_omegac0::FlagMcMatchGen, hf_cand_xic0_omegac0::DebugGenCharmBar, hf_cand_xic0_omegac0::DebugGenCasc, hf_cand_xic0_omegac0::DebugGenLambda, hf_cand_xic0_omegac0::PtCharmBaryonGen, hf_cand_xic0_omegac0::RapidityCharmBaryonGen, hf_cand_xic0_omegac0::OriginGen, hf_cand::IdxBhadMotherPart, o2::soa::Marker<4>); +<<<<<<< HEAD // specific Xic to Xi Pi Pi candidate properties namespace hf_cand_xictoxipipi { @@ -1435,6 +1436,149 @@ DECLARE_SOA_TABLE(HfCandXicMcGen, "AOD", "HFCANDXICMCGEN", //! hf_cand_xictoxipipi::FlagMcMatchGen, hf_cand_xictoxipipi::DebugMcGen, hf_cand_xictoxipipi::OriginGen); +======= +// specific Xicplus to Xi Pi Pi candidate properties +namespace hf_cand_xicplustoxipipi +{ +// Data processing results: +DECLARE_SOA_INDEX_COLUMN(Collision, collision); +DECLARE_SOA_COLUMN(XPv, xPv, float); +DECLARE_SOA_COLUMN(YPv, yPv, float); +DECLARE_SOA_COLUMN(ZPv, zPv, float); +DECLARE_SOA_COLUMN(XDecayVtxCharmBaryon, xDecayVtxCharmBaryon, float); +DECLARE_SOA_COLUMN(YDecayVtxCharmBaryon, yDecayVtxCharmBaryon, float); +DECLARE_SOA_COLUMN(ZDecayVtxCharmBaryon, zDecayVtxCharmBaryon, float); +DECLARE_SOA_COLUMN(XDecayVtxCascade, xDecayVtxCascade, float); +DECLARE_SOA_COLUMN(YDecayVtxCascade, yDecayVtxCascade, float); +DECLARE_SOA_COLUMN(ZDecayVtxCascade, zDecayVtxCascade, float); +DECLARE_SOA_COLUMN(XDecayVtxV0, xDecayVtxV0, float); +DECLARE_SOA_COLUMN(YDecayVtxV0, yDecayVtxV0, float); +DECLARE_SOA_COLUMN(ZDecayVtxV0, zDecayVtxV0, float); +DECLARE_SOA_COLUMN(SignDecay, signDecay, int8_t); // sign of pi <- xi +DECLARE_SOA_COLUMN(Chi2PCACharmBaryon, chi2PCACharmBaryon, float); +DECLARE_SOA_COLUMN(CovVtxCharmBaryon0, covVtxCharmBaryon0, float); +DECLARE_SOA_COLUMN(CovVtxCharmBaryon1, covVtxCharmBaryon1, float); +DECLARE_SOA_COLUMN(CovVtxCharmBaryon2, covVtxCharmBaryon2, float); +DECLARE_SOA_COLUMN(CovVtxCharmBaryon3, covVtxCharmBaryon3, float); +DECLARE_SOA_COLUMN(CovVtxCharmBaryon4, covVtxCharmBaryon4, float); +DECLARE_SOA_COLUMN(CovVtxCharmBaryon5, covVtxCharmBaryon5, float); +DECLARE_SOA_COLUMN(PxCharmBaryon, pxCharmBaryon, float); +DECLARE_SOA_COLUMN(PyCharmBaryon, pyCharmBaryon, float); +DECLARE_SOA_COLUMN(PzCharmBaryon, pzCharmBaryon, float); +DECLARE_SOA_COLUMN(PxCasc, pxCasc, float); +DECLARE_SOA_COLUMN(PyCasc, pyCasc, float); +DECLARE_SOA_COLUMN(PzCasc, pzCasc, float); +DECLARE_SOA_COLUMN(PxPi1FromCharmBaryon, pxPiFromCharmBaryon, float); +DECLARE_SOA_COLUMN(PyPi1FromCharmBaryon, pyPiFromCharmBaryon, float); +DECLARE_SOA_COLUMN(PzPi1FromCharmBaryon, pzPiFromCharmBaryon, float); +DECLARE_SOA_COLUMN(PxPi2FromCharmBaryon, pxPiFromCharmBaryon, float); +DECLARE_SOA_COLUMN(PyPi2FromCharmBaryon, pyPiFromCharmBaryon, float); +DECLARE_SOA_COLUMN(PzPi2FromCharmBaryon, pzPiFromCharmBaryon, float); +DECLARE_SOA_COLUMN(PxLambda, pxLambda, float); +DECLARE_SOA_COLUMN(PyLambda, pyLambda, float); +DECLARE_SOA_COLUMN(PzLambda, pzLambda, float); +DECLARE_SOA_COLUMN(PxPiFromCasc, pxPiFromCasc, float); +DECLARE_SOA_COLUMN(PyPiFromCasc, pyPiFromCasc, float); +DECLARE_SOA_COLUMN(PzPiFromCasc, pzPiFromCasc, float); +DECLARE_SOA_COLUMN(PxPosV0Dau, pxPosV0Dau, float); +DECLARE_SOA_COLUMN(PyPosV0Dau, pyPosV0Dau, float); +DECLARE_SOA_COLUMN(PzPosV0Dau, pzPosV0Dau, float); +DECLARE_SOA_COLUMN(PxNegV0Dau, pxNegV0Dau, float); +DECLARE_SOA_COLUMN(PyNegV0Dau, pyNegV0Dau, float); +DECLARE_SOA_COLUMN(PzNegV0Dau, pzNegV0Dau, float); +DECLARE_SOA_COLUMN(ImpactParCascXY, impactParCascXY, float); +DECLARE_SOA_COLUMN(ImpactParPi1FromCharmBaryonXY, impactParPiFromCharmBaryonXY, float); +DECLARE_SOA_COLUMN(ImpactParPi1FromCharmBaryonXY, impactParPiFromCharmBaryonXY, float); +DECLARE_SOA_COLUMN(ImpactParCascZ, impactParCascZ, float); +DECLARE_SOA_COLUMN(ImpactParPi2FromCharmBaryonZ, impactParPiFromCharmBaryonZ, float); +DECLARE_SOA_COLUMN(ImpactParPi2FromCharmBaryonZ, impactParPiFromCharmBaryonZ, float); +DECLARE_SOA_COLUMN(ErrImpactParCascXY, errImpactParCascXY, float); +DECLARE_SOA_COLUMN(ErrImpactParPiFromCharmBaryonXY, errImpactParPiFromCharmBaryonXY, float); +DECLARE_SOA_INDEX_COLUMN(V0, v0); +DECLARE_SOA_INDEX_COLUMN(Cascade, cascade); +DECLARE_SOA_INDEX_COLUMN_FULL(Pi1FromCharmBaryon, pi1FromCharmBaryon, int, Tracks, "_pi1fromcharmbaryon"); +DECLARE_SOA_INDEX_COLUMN_FULL(Pi2FromCharmBaryon, pi2FromCharmBaryon, int, Tracks, "_pi2fromcharmbaryon"); +DECLARE_SOA_COLUMN(InvMassLambda, invMassLambda, double); +DECLARE_SOA_COLUMN(InvMassCascade, invMassCascade, double); +DECLARE_SOA_COLUMN(InvMassCharmBaryon, invMassCharmBaryon, double); +DECLARE_SOA_COLUMN(CosPAV0, cosPAV0, double); +DECLARE_SOA_COLUMN(CosPACharmBaryon, cosPACharmBaryon, double); +DECLARE_SOA_COLUMN(CosPACasc, cosPACasc, double); +DECLARE_SOA_COLUMN(CosPAXYV0, cosPAXYV0, double); +DECLARE_SOA_COLUMN(CosPAXYCharmBaryon, cosPAXYCharmBaryon, double); +DECLARE_SOA_COLUMN(CosPAXYCasc, cosPAXYCasc, double); +DECLARE_SOA_COLUMN(CTauCascade, ctauCascade, double); +DECLARE_SOA_COLUMN(CTauV0, ctauV0, double); +DECLARE_SOA_COLUMN(CTauXicPlus, ctauXicPlus, double); +DECLARE_SOA_COLUMN(EtaV0PosDau, etaV0PosDau, double); +DECLARE_SOA_COLUMN(EtaV0NegDau, etaV0NegDau, double); +DECLARE_SOA_COLUMN(EtaPiFromCasc, etaPiFromCasc, double); +DECLARE_SOA_COLUMN(EtaPiFromCharmBaryon, etaPiFromCharmBaryon, double); +DECLARE_SOA_COLUMN(EtaCharmBaryon, etaCharmBaryon, double); +DECLARE_SOA_COLUMN(EtaCascade, etaCascade, double); +DECLARE_SOA_COLUMN(EtaV0, etaV0, double); +DECLARE_SOA_COLUMN(DcaXYToPvV0Dau0, dcaXYToPvV0Dau0, float); // pos dau +DECLARE_SOA_COLUMN(DcaXYToPvV0Dau1, dcaXYToPvV0Dau1, float); // neg dau +DECLARE_SOA_COLUMN(DcaXYToPvCascDau, dcaXYToPvCascDau, float); +DECLARE_SOA_COLUMN(DcaZToPvV0Dau0, dcaZToPvV0Dau0, float); +DECLARE_SOA_COLUMN(DcaZToPvV0Dau1, dcaZToPvV0Dau1, float); +DECLARE_SOA_COLUMN(DcaZToPvCascDau, dcaZToPvCascDau, float); +DECLARE_SOA_COLUMN(DcaCascDau, dcaCascDau, float); +DECLARE_SOA_COLUMN(DcaV0Dau, dcaV0Dau, float); +DECLARE_SOA_COLUMN(DcaCharmBaryonDau, dcaCharmBaryonDau, float); +DECLARE_SOA_COLUMN(DecLenCharmBaryon, decLenCharmBaryon, double); +DECLARE_SOA_COLUMN(DecLenCascade, decLenCascade, double); +DECLARE_SOA_COLUMN(DecLenV0, decLenV0, double); +DECLARE_SOA_COLUMN(ErrorDecayLengthCharmBaryon, errorDecayLengthCharmBaryon, float); +DECLARE_SOA_COLUMN(ErrorDecayLengthXYCharmBaryon, errorDecayLengthXYCharmBaryon, float); + +// MC matching result: +DECLARE_SOA_COLUMN(FlagMcMatchRec, flagMcMatchRec, int8_t); // reconstruction level +DECLARE_SOA_COLUMN(DebugMcRec, debugMcRec, int8_t); // debug flag for mis-association reconstruction level +DECLARE_SOA_COLUMN(FlagMcMatchGen, flagMcMatchGen, int8_t); // generator level +DECLARE_SOA_COLUMN(DebugGenCharmBar, debugGenCharmBar, int8_t); +DECLARE_SOA_COLUMN(DebugGenXi, debugGenXi, int8_t); +DECLARE_SOA_COLUMN(DebugGenLambda, debugGenLambda, int8_t); +DECLARE_SOA_COLUMN(OriginRec, originRec, int8_t); +DECLARE_SOA_COLUMN(OriginGen, originGen, int8_t); + +// mapping of decay types +enum DecayType {XicplusToXiPiPi}; + +} // end of namespace hf_cand_xicplustoxipipi + +// declare dedicated Omegac and Xic to Xi Pi candidate table +DECLARE_SOA_TABLE(HfCandXicplusToXiPiPi, "AOD", "HFCANDXICPLUSTOXIPIPI", + o2::soa::Index<>, + hf_cand_xicplustoxipipi::CollisionId, + hf_cand_xicplustoxipipi::XPv, hf_cand_xicplustoxipipi::YPv, hf_cand_xicplustoxipipi::ZPv, + hf_cand_xicplustoxipipi::XDecayVtxCharmBaryon, hf_cand_xicplustoxipipi::YDecayVtxCharmBaryon, hf_cand_xicplustoxipipi::ZDecayVtxCharmBaryon, + hf_cand_xicplustoxipipi::ErrorDecayLengthCharmBaryon, hf_cand_xicplustoxipipi::ErrorDecayLengthXYCharmBaryon, + hf_cand_xicplustoxipipi::Chi2PCACharmBaryon, + hf_cand_xicplustoxipipi::PxCharmBaryon, hf_cand_xicplustoxipipi::PyCharmBaryon, hf_cand_xicplustoxipipi::PzCharmBaryon, + hf_cand_xicplustoxipipi::PxPi1FromCharmBaryon, hf_cand_xicplustoxipipi::PyPi1FromCharmBaryon, hf_cand_xicplustoxipipi::PzPi1FromCharmBaryon, + hf_cand_xicplustoxipipi::PxPi2FromCharmBaryon, hf_cand_xicplustoxipipi::PyPi2FromCharmBaryon, hf_cand_xicplustoxipipi::PzPi2FromCharmBaryon, + hf_cand_xicplustoxipipi::ImpactParPiFromCharmBaryonXY,hf_cand_xicplustoxipipi::ImpactParPiFromCharmBaryonXY,hf_cand_xicplustoxipipi::ImpactParCascXY, + hf_cand_xicplustoxipipi::Pi1FromCharmBaryonId,hf_cand_xicplustoxipipi::Pi2FromCharmBaryonId,hf_cand_xicplustoxipipi::CascadeId, + hf_cand_xicplustoxipipi::SignDecay, + hf_cand_xicplustoxipipi::XDecayVtxCascade, hf_cand_xicplustoxipipi::YDecayVtxCascade, hf_cand_xicplustoxipipi::ZDecayVtxCascade, + hf_cand_xicplustoxipipi::XDecayVtxV0, hf_cand_xicplustoxipipi::YDecayVtxV0, hf_cand_xicplustoxipipi::ZDecayVtxV0, + hf_cand_xicplustoxipipi::PxPosV0Dau, hf_cand_xicplustoxipipi::PyPosV0Dau, hf_cand_xicplustoxipipi::PzPosV0Dau, + hf_cand_xicplustoxipipi::PxNegV0Dau, hf_cand_xicplustoxipipi::PyNegV0Dau, hf_cand_xicplustoxipipi::PzNegV0Dau, + hf_cand_xicplustoxipipi::PxPiFromCasc, hf_cand_xicplustoxipipi::PyPiFromCasc, hf_cand_xicplustoxipipi::PzPiFromCasc, + hf_cand_xicplustoxipipi::DcaXYToPvV0Dau0, hf_cand_xicplustoxipipi::DcaXYToPvV0Dau1,hf_cand_xicplustoxipipi::DcaXYToPvCascDau, + hf_track_index::HFflag); + +// table with results of reconstruction level MC matching +DECLARE_SOA_TABLE(HfXicplusToXiPiPiMCRec, "AOD", "HFXICPLUSTOXIPIPIMCREC", //! + hf_cand_xicplustoxipipi::FlagMcMatchRec, + hf_cand_xicplustoxipipi::DebugMcRec, + hf_cand_xicplustoxipipi::OriginRec); + +// table with results of generator level MC matching +DECLARE_SOA_TABLE(HfXicPlusToXiPiPiMCGen, "AOD", "HFXICPLUSTOXIPIPIMCGEN", //! + hf_cand_xicplustoxipipi::FlagMcMatchGen, hf_cand_xicplustoxipipi::DebugGenCharmBar, hf_cand_xicplustoxipipi::DebugGenXi, hf_cand_xicplustoxipipi::DebugGenLambda, hf_cand_xicplustoxipipi::OriginGen); +>>>>>>> First draft of Xicplus workflow // specific chic candidate properties namespace hf_cand_chic From ae2ce10d64ceeebe1017307a342825850be94303 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Wed, 6 Mar 2024 13:46:42 +0100 Subject: [PATCH 13/35] Resolve merge conflict --- .../DataModel/CandidateReconstructionTables.h | 144 ------------------ 1 file changed, 144 deletions(-) diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index 0d66459522d..3131a90d229 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1320,7 +1320,6 @@ DECLARE_SOA_TABLE(HfToOmegaKMCGen, "AOD", "HFTOOMEKMCGEN", //! hf_cand_xic0_omegac0::FlagMcMatchGen, hf_cand_xic0_omegac0::DebugGenCharmBar, hf_cand_xic0_omegac0::DebugGenCasc, hf_cand_xic0_omegac0::DebugGenLambda, hf_cand_xic0_omegac0::PtCharmBaryonGen, hf_cand_xic0_omegac0::RapidityCharmBaryonGen, hf_cand_xic0_omegac0::OriginGen, hf_cand::IdxBhadMotherPart, o2::soa::Marker<4>); -<<<<<<< HEAD // specific Xic to Xi Pi Pi candidate properties namespace hf_cand_xictoxipipi { @@ -1436,149 +1435,6 @@ DECLARE_SOA_TABLE(HfCandXicMcGen, "AOD", "HFCANDXICMCGEN", //! hf_cand_xictoxipipi::FlagMcMatchGen, hf_cand_xictoxipipi::DebugMcGen, hf_cand_xictoxipipi::OriginGen); -======= -// specific Xicplus to Xi Pi Pi candidate properties -namespace hf_cand_xicplustoxipipi -{ -// Data processing results: -DECLARE_SOA_INDEX_COLUMN(Collision, collision); -DECLARE_SOA_COLUMN(XPv, xPv, float); -DECLARE_SOA_COLUMN(YPv, yPv, float); -DECLARE_SOA_COLUMN(ZPv, zPv, float); -DECLARE_SOA_COLUMN(XDecayVtxCharmBaryon, xDecayVtxCharmBaryon, float); -DECLARE_SOA_COLUMN(YDecayVtxCharmBaryon, yDecayVtxCharmBaryon, float); -DECLARE_SOA_COLUMN(ZDecayVtxCharmBaryon, zDecayVtxCharmBaryon, float); -DECLARE_SOA_COLUMN(XDecayVtxCascade, xDecayVtxCascade, float); -DECLARE_SOA_COLUMN(YDecayVtxCascade, yDecayVtxCascade, float); -DECLARE_SOA_COLUMN(ZDecayVtxCascade, zDecayVtxCascade, float); -DECLARE_SOA_COLUMN(XDecayVtxV0, xDecayVtxV0, float); -DECLARE_SOA_COLUMN(YDecayVtxV0, yDecayVtxV0, float); -DECLARE_SOA_COLUMN(ZDecayVtxV0, zDecayVtxV0, float); -DECLARE_SOA_COLUMN(SignDecay, signDecay, int8_t); // sign of pi <- xi -DECLARE_SOA_COLUMN(Chi2PCACharmBaryon, chi2PCACharmBaryon, float); -DECLARE_SOA_COLUMN(CovVtxCharmBaryon0, covVtxCharmBaryon0, float); -DECLARE_SOA_COLUMN(CovVtxCharmBaryon1, covVtxCharmBaryon1, float); -DECLARE_SOA_COLUMN(CovVtxCharmBaryon2, covVtxCharmBaryon2, float); -DECLARE_SOA_COLUMN(CovVtxCharmBaryon3, covVtxCharmBaryon3, float); -DECLARE_SOA_COLUMN(CovVtxCharmBaryon4, covVtxCharmBaryon4, float); -DECLARE_SOA_COLUMN(CovVtxCharmBaryon5, covVtxCharmBaryon5, float); -DECLARE_SOA_COLUMN(PxCharmBaryon, pxCharmBaryon, float); -DECLARE_SOA_COLUMN(PyCharmBaryon, pyCharmBaryon, float); -DECLARE_SOA_COLUMN(PzCharmBaryon, pzCharmBaryon, float); -DECLARE_SOA_COLUMN(PxCasc, pxCasc, float); -DECLARE_SOA_COLUMN(PyCasc, pyCasc, float); -DECLARE_SOA_COLUMN(PzCasc, pzCasc, float); -DECLARE_SOA_COLUMN(PxPi1FromCharmBaryon, pxPiFromCharmBaryon, float); -DECLARE_SOA_COLUMN(PyPi1FromCharmBaryon, pyPiFromCharmBaryon, float); -DECLARE_SOA_COLUMN(PzPi1FromCharmBaryon, pzPiFromCharmBaryon, float); -DECLARE_SOA_COLUMN(PxPi2FromCharmBaryon, pxPiFromCharmBaryon, float); -DECLARE_SOA_COLUMN(PyPi2FromCharmBaryon, pyPiFromCharmBaryon, float); -DECLARE_SOA_COLUMN(PzPi2FromCharmBaryon, pzPiFromCharmBaryon, float); -DECLARE_SOA_COLUMN(PxLambda, pxLambda, float); -DECLARE_SOA_COLUMN(PyLambda, pyLambda, float); -DECLARE_SOA_COLUMN(PzLambda, pzLambda, float); -DECLARE_SOA_COLUMN(PxPiFromCasc, pxPiFromCasc, float); -DECLARE_SOA_COLUMN(PyPiFromCasc, pyPiFromCasc, float); -DECLARE_SOA_COLUMN(PzPiFromCasc, pzPiFromCasc, float); -DECLARE_SOA_COLUMN(PxPosV0Dau, pxPosV0Dau, float); -DECLARE_SOA_COLUMN(PyPosV0Dau, pyPosV0Dau, float); -DECLARE_SOA_COLUMN(PzPosV0Dau, pzPosV0Dau, float); -DECLARE_SOA_COLUMN(PxNegV0Dau, pxNegV0Dau, float); -DECLARE_SOA_COLUMN(PyNegV0Dau, pyNegV0Dau, float); -DECLARE_SOA_COLUMN(PzNegV0Dau, pzNegV0Dau, float); -DECLARE_SOA_COLUMN(ImpactParCascXY, impactParCascXY, float); -DECLARE_SOA_COLUMN(ImpactParPi1FromCharmBaryonXY, impactParPiFromCharmBaryonXY, float); -DECLARE_SOA_COLUMN(ImpactParPi1FromCharmBaryonXY, impactParPiFromCharmBaryonXY, float); -DECLARE_SOA_COLUMN(ImpactParCascZ, impactParCascZ, float); -DECLARE_SOA_COLUMN(ImpactParPi2FromCharmBaryonZ, impactParPiFromCharmBaryonZ, float); -DECLARE_SOA_COLUMN(ImpactParPi2FromCharmBaryonZ, impactParPiFromCharmBaryonZ, float); -DECLARE_SOA_COLUMN(ErrImpactParCascXY, errImpactParCascXY, float); -DECLARE_SOA_COLUMN(ErrImpactParPiFromCharmBaryonXY, errImpactParPiFromCharmBaryonXY, float); -DECLARE_SOA_INDEX_COLUMN(V0, v0); -DECLARE_SOA_INDEX_COLUMN(Cascade, cascade); -DECLARE_SOA_INDEX_COLUMN_FULL(Pi1FromCharmBaryon, pi1FromCharmBaryon, int, Tracks, "_pi1fromcharmbaryon"); -DECLARE_SOA_INDEX_COLUMN_FULL(Pi2FromCharmBaryon, pi2FromCharmBaryon, int, Tracks, "_pi2fromcharmbaryon"); -DECLARE_SOA_COLUMN(InvMassLambda, invMassLambda, double); -DECLARE_SOA_COLUMN(InvMassCascade, invMassCascade, double); -DECLARE_SOA_COLUMN(InvMassCharmBaryon, invMassCharmBaryon, double); -DECLARE_SOA_COLUMN(CosPAV0, cosPAV0, double); -DECLARE_SOA_COLUMN(CosPACharmBaryon, cosPACharmBaryon, double); -DECLARE_SOA_COLUMN(CosPACasc, cosPACasc, double); -DECLARE_SOA_COLUMN(CosPAXYV0, cosPAXYV0, double); -DECLARE_SOA_COLUMN(CosPAXYCharmBaryon, cosPAXYCharmBaryon, double); -DECLARE_SOA_COLUMN(CosPAXYCasc, cosPAXYCasc, double); -DECLARE_SOA_COLUMN(CTauCascade, ctauCascade, double); -DECLARE_SOA_COLUMN(CTauV0, ctauV0, double); -DECLARE_SOA_COLUMN(CTauXicPlus, ctauXicPlus, double); -DECLARE_SOA_COLUMN(EtaV0PosDau, etaV0PosDau, double); -DECLARE_SOA_COLUMN(EtaV0NegDau, etaV0NegDau, double); -DECLARE_SOA_COLUMN(EtaPiFromCasc, etaPiFromCasc, double); -DECLARE_SOA_COLUMN(EtaPiFromCharmBaryon, etaPiFromCharmBaryon, double); -DECLARE_SOA_COLUMN(EtaCharmBaryon, etaCharmBaryon, double); -DECLARE_SOA_COLUMN(EtaCascade, etaCascade, double); -DECLARE_SOA_COLUMN(EtaV0, etaV0, double); -DECLARE_SOA_COLUMN(DcaXYToPvV0Dau0, dcaXYToPvV0Dau0, float); // pos dau -DECLARE_SOA_COLUMN(DcaXYToPvV0Dau1, dcaXYToPvV0Dau1, float); // neg dau -DECLARE_SOA_COLUMN(DcaXYToPvCascDau, dcaXYToPvCascDau, float); -DECLARE_SOA_COLUMN(DcaZToPvV0Dau0, dcaZToPvV0Dau0, float); -DECLARE_SOA_COLUMN(DcaZToPvV0Dau1, dcaZToPvV0Dau1, float); -DECLARE_SOA_COLUMN(DcaZToPvCascDau, dcaZToPvCascDau, float); -DECLARE_SOA_COLUMN(DcaCascDau, dcaCascDau, float); -DECLARE_SOA_COLUMN(DcaV0Dau, dcaV0Dau, float); -DECLARE_SOA_COLUMN(DcaCharmBaryonDau, dcaCharmBaryonDau, float); -DECLARE_SOA_COLUMN(DecLenCharmBaryon, decLenCharmBaryon, double); -DECLARE_SOA_COLUMN(DecLenCascade, decLenCascade, double); -DECLARE_SOA_COLUMN(DecLenV0, decLenV0, double); -DECLARE_SOA_COLUMN(ErrorDecayLengthCharmBaryon, errorDecayLengthCharmBaryon, float); -DECLARE_SOA_COLUMN(ErrorDecayLengthXYCharmBaryon, errorDecayLengthXYCharmBaryon, float); - -// MC matching result: -DECLARE_SOA_COLUMN(FlagMcMatchRec, flagMcMatchRec, int8_t); // reconstruction level -DECLARE_SOA_COLUMN(DebugMcRec, debugMcRec, int8_t); // debug flag for mis-association reconstruction level -DECLARE_SOA_COLUMN(FlagMcMatchGen, flagMcMatchGen, int8_t); // generator level -DECLARE_SOA_COLUMN(DebugGenCharmBar, debugGenCharmBar, int8_t); -DECLARE_SOA_COLUMN(DebugGenXi, debugGenXi, int8_t); -DECLARE_SOA_COLUMN(DebugGenLambda, debugGenLambda, int8_t); -DECLARE_SOA_COLUMN(OriginRec, originRec, int8_t); -DECLARE_SOA_COLUMN(OriginGen, originGen, int8_t); - -// mapping of decay types -enum DecayType {XicplusToXiPiPi}; - -} // end of namespace hf_cand_xicplustoxipipi - -// declare dedicated Omegac and Xic to Xi Pi candidate table -DECLARE_SOA_TABLE(HfCandXicplusToXiPiPi, "AOD", "HFCANDXICPLUSTOXIPIPI", - o2::soa::Index<>, - hf_cand_xicplustoxipipi::CollisionId, - hf_cand_xicplustoxipipi::XPv, hf_cand_xicplustoxipipi::YPv, hf_cand_xicplustoxipipi::ZPv, - hf_cand_xicplustoxipipi::XDecayVtxCharmBaryon, hf_cand_xicplustoxipipi::YDecayVtxCharmBaryon, hf_cand_xicplustoxipipi::ZDecayVtxCharmBaryon, - hf_cand_xicplustoxipipi::ErrorDecayLengthCharmBaryon, hf_cand_xicplustoxipipi::ErrorDecayLengthXYCharmBaryon, - hf_cand_xicplustoxipipi::Chi2PCACharmBaryon, - hf_cand_xicplustoxipipi::PxCharmBaryon, hf_cand_xicplustoxipipi::PyCharmBaryon, hf_cand_xicplustoxipipi::PzCharmBaryon, - hf_cand_xicplustoxipipi::PxPi1FromCharmBaryon, hf_cand_xicplustoxipipi::PyPi1FromCharmBaryon, hf_cand_xicplustoxipipi::PzPi1FromCharmBaryon, - hf_cand_xicplustoxipipi::PxPi2FromCharmBaryon, hf_cand_xicplustoxipipi::PyPi2FromCharmBaryon, hf_cand_xicplustoxipipi::PzPi2FromCharmBaryon, - hf_cand_xicplustoxipipi::ImpactParPiFromCharmBaryonXY,hf_cand_xicplustoxipipi::ImpactParPiFromCharmBaryonXY,hf_cand_xicplustoxipipi::ImpactParCascXY, - hf_cand_xicplustoxipipi::Pi1FromCharmBaryonId,hf_cand_xicplustoxipipi::Pi2FromCharmBaryonId,hf_cand_xicplustoxipipi::CascadeId, - hf_cand_xicplustoxipipi::SignDecay, - hf_cand_xicplustoxipipi::XDecayVtxCascade, hf_cand_xicplustoxipipi::YDecayVtxCascade, hf_cand_xicplustoxipipi::ZDecayVtxCascade, - hf_cand_xicplustoxipipi::XDecayVtxV0, hf_cand_xicplustoxipipi::YDecayVtxV0, hf_cand_xicplustoxipipi::ZDecayVtxV0, - hf_cand_xicplustoxipipi::PxPosV0Dau, hf_cand_xicplustoxipipi::PyPosV0Dau, hf_cand_xicplustoxipipi::PzPosV0Dau, - hf_cand_xicplustoxipipi::PxNegV0Dau, hf_cand_xicplustoxipipi::PyNegV0Dau, hf_cand_xicplustoxipipi::PzNegV0Dau, - hf_cand_xicplustoxipipi::PxPiFromCasc, hf_cand_xicplustoxipipi::PyPiFromCasc, hf_cand_xicplustoxipipi::PzPiFromCasc, - hf_cand_xicplustoxipipi::DcaXYToPvV0Dau0, hf_cand_xicplustoxipipi::DcaXYToPvV0Dau1,hf_cand_xicplustoxipipi::DcaXYToPvCascDau, - hf_track_index::HFflag); - -// table with results of reconstruction level MC matching -DECLARE_SOA_TABLE(HfXicplusToXiPiPiMCRec, "AOD", "HFXICPLUSTOXIPIPIMCREC", //! - hf_cand_xicplustoxipipi::FlagMcMatchRec, - hf_cand_xicplustoxipipi::DebugMcRec, - hf_cand_xicplustoxipipi::OriginRec); - -// table with results of generator level MC matching -DECLARE_SOA_TABLE(HfXicPlusToXiPiPiMCGen, "AOD", "HFXICPLUSTOXIPIPIMCGEN", //! - hf_cand_xicplustoxipipi::FlagMcMatchGen, hf_cand_xicplustoxipipi::DebugGenCharmBar, hf_cand_xicplustoxipipi::DebugGenXi, hf_cand_xicplustoxipipi::DebugGenLambda, hf_cand_xicplustoxipipi::OriginGen); ->>>>>>> First draft of Xicplus workflow // specific chic candidate properties namespace hf_cand_chic From 766a4ad3cba9a77398053d0b29ae4284169dbfb8 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Mon, 18 Mar 2024 13:01:10 +0100 Subject: [PATCH 14/35] Add Spawning of extended table to Xic candidate creator --- PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx | 1 + 1 file changed, 1 insertion(+) diff --git a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index a44fc6adc09..421ddd40d1c 100644 --- a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -544,6 +544,7 @@ struct HfCandidateCreatorXic { /// Performs MC matching. struct HfCandidateCreatorXicMc { + Spawns rowCandXicToXiPiPi; Produces rowMcMatchRec; Produces rowMcMatchGen; From 468d59a9c45fd2372b7b2bd02236eb8cf256d075 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Mon, 18 Mar 2024 15:56:06 +0100 Subject: [PATCH 15/35] Remove unused Configurable from MC matching struct --- PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx | 2 -- 1 file changed, 2 deletions(-) diff --git a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index 421ddd40d1c..5efdddf2962 100644 --- a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -548,8 +548,6 @@ struct HfCandidateCreatorXicMc { Produces rowMcMatchRec; Produces rowMcMatchGen; - Configurable matchXicPlusMc{"matchXicPlusMc", true, "Do MC matching for XicPlus"}; - void init(InitContext const&) {} void processMc(aod::HfCandXic const& candidates, From 4ed092b62de88dea69888170c9b3f555363dd31b Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Wed, 20 Mar 2024 00:04:29 +0100 Subject: [PATCH 16/35] Correct subscription to spawned table in MC matching process --- PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index 5efdddf2962..10a1e3adcd3 100644 --- a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -544,16 +544,17 @@ struct HfCandidateCreatorXic { /// Performs MC matching. struct HfCandidateCreatorXicMc { - Spawns rowCandXicToXiPiPi; + Spawns rowCandidateXic; Produces rowMcMatchRec; Produces rowMcMatchGen; void init(InitContext const&) {} - void processMc(aod::HfCandXic const& candidates, - aod::TracksWMc const& tracks, + void processMc(aod::TracksWMc const& tracks, aod::McParticles const& mcParticles) { + rowCandidateXic->bindExternalIndices(&tracks); + int indexRec = -1; int indexRecXicPlus = -1; int8_t sign = -9; @@ -570,7 +571,7 @@ struct HfCandidateCreatorXicMc { int pdgCodeProton = kProton; // 2212 // Match reconstructed candidates. - for (const auto& candidate : candidates) { + for (const auto& candidate : *rowCandidateXic) { flag = 0; sign = -9; origin = RecoDecay::OriginType::None; From fe91d46c23547189ccba3f4e70b7ed33aec7849a Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Wed, 20 Mar 2024 16:07:56 +0100 Subject: [PATCH 17/35] Fix: Add cascades-link tables to candidate creator --- .../candidateCreatorXicToXiPiPi.cxx | 36 +++++++++++++------ 1 file changed, 26 insertions(+), 10 deletions(-) diff --git a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index 10a1e3adcd3..5a420ad5486 100644 --- a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -126,12 +126,15 @@ struct HfCandidateCreatorXic { } } + using CascadesLinked = soa::Join; + using KFCascadesLinked = soa::Join; using CascFull = soa::Join; - using CascFullKF = soa::Join; + using KFCascFull = soa::Join; template void runCreatorXicPlusWithDcaFitter(aod::Collisions const& collisions, CandType const& rowsTrackIndexXicPlus, + CascadesLinked const&, CascFull const& cascs, TTracks const& tracks, aod::BCsWithTimestamps const& bcWithTimeStamps) @@ -148,9 +151,13 @@ struct HfCandidateCreatorXic { // loop over triplets of track indices for (const auto& rowTrackIndexXicPlus : rowsTrackIndexXicPlus) { + auto cascAodElement = rowTrackIndexXicPlus.template cascade_as(); + if (!cascAodElement.has_cascData()) + continue; + auto casc = cascAodElement.template cascData_as(); auto track0 = rowTrackIndexXicPlus.template prong0_as(); auto track1 = rowTrackIndexXicPlus.template prong1_as(); - auto casc = rowTrackIndexXicPlus.template cascade_as(); + //auto casc = rowTrackIndexXicPlus.template cascade_as(); // preselect cascade candidates if (doCascadePreselection) { @@ -348,13 +355,18 @@ struct HfCandidateCreatorXic { template void runCreatorXicPlusWithKFParticle(aod::Collisions const& collisions, CandType const& rowsTrackIndexXicPlus, - CascFullKF const&, + KFCascadesLinked const&, + KFCascFull const&, TTracks const& tracks, aod::BCsWithTimestamps const& bcWithTimeStamps) { // loop over triplets of track indices for (const auto& rowTrackIndexXicPlus : rowsTrackIndexXicPlus) { - auto casc = rowTrackIndexXicPlus.template cascade_as(); + auto cascAodElement = rowTrackIndexXicPlus.template cascade_as(); + if (!cascAodElement.has_kfCascData()) + continue; + auto casc = cascAodElement.template kfCascData_as(); + //auto casc = rowTrackIndexXicPlus.template cascade_as(); auto track0 = rowTrackIndexXicPlus.template prong0_as(); auto track1 = rowTrackIndexXicPlus.template prong1_as(); auto collision = rowTrackIndexXicPlus.collision(); @@ -503,41 +515,45 @@ struct HfCandidateCreatorXic { void processPvRefitWithDCAFitterN(aod::Collisions const& collisions, soa::Join const& rowsTrackIndexXicPlus, + CascadesLinked const& cascsLinked, CascFull const& cascs, aod::TracksWCovDca const& tracks, aod::BCsWithTimestamps const& bcWithTimeStamps) { - runCreatorXicPlusWithDcaFitter(collisions, rowsTrackIndexXicPlus, cascs, tracks, bcWithTimeStamps); + runCreatorXicPlusWithDcaFitter(collisions, rowsTrackIndexXicPlus, cascsLinked, cascs, tracks, bcWithTimeStamps); } PROCESS_SWITCH(HfCandidateCreatorXic, processPvRefitWithDCAFitterN, "Run candidate creator with PV refit", false); void processNoPvRefitWithDCAFitterN(aod::Collisions const& collisions, aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, + CascadesLinked const& cascsLinked, CascFull const& cascs, aod::TracksWCovDca const& tracks, aod::BCsWithTimestamps const& bcWithTimeStamps) { - runCreatorXicPlusWithDcaFitter(collisions, rowsTrackIndexXicPlus, cascs, tracks, bcWithTimeStamps); + runCreatorXicPlusWithDcaFitter(collisions, rowsTrackIndexXicPlus, cascsLinked, cascs, tracks, bcWithTimeStamps); } PROCESS_SWITCH(HfCandidateCreatorXic, processNoPvRefitWithDCAFitterN, "Run candidate creator without PV refit", true); void processPvRefitWithKFParticle(aod::Collisions const& collisions, soa::Join const& rowsTrackIndexXicPlus, - CascFullKF const& cascs, + KFCascadesLinked const& cascsLinked, + KFCascFull const& cascs, aod::TracksWCovExtra const& tracks, aod::BCsWithTimestamps const& bcWithTimeStamps) { - runCreatorXicPlusWithKFParticle(collisions, rowsTrackIndexXicPlus, cascs, tracks, bcWithTimeStamps); + runCreatorXicPlusWithKFParticle(collisions, rowsTrackIndexXicPlus, cascsLinked, cascs, tracks, bcWithTimeStamps); } PROCESS_SWITCH(HfCandidateCreatorXic, processPvRefitWithKFParticle, "Run candidate creator with PV refit", false); void processNoPvRefitWithKFParticle(aod::Collisions const& collisions, aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, - CascFullKF const& cascs, + KFCascadesLinked const& cascsLinked, + KFCascFull const& cascs, aod::TracksWCovExtra const& tracks, aod::BCsWithTimestamps const& bcWithTimeStamps) { - runCreatorXicPlusWithKFParticle(collisions, rowsTrackIndexXicPlus, cascs, tracks, bcWithTimeStamps); + runCreatorXicPlusWithKFParticle(collisions, rowsTrackIndexXicPlus, cascsLinked, cascs, tracks, bcWithTimeStamps); } PROCESS_SWITCH(HfCandidateCreatorXic, processNoPvRefitWithKFParticle, "Run candidate creator without PV refit", false); }; // struct From 05cdd5978903e6e802677bd30fef0e9185d86c25 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Tue, 2 Apr 2024 21:59:50 +0200 Subject: [PATCH 18/35] Update ML selection to fix workflow materialisation of Xic selector --- PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx index de2e1e39992..7b481b0978a 100644 --- a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx @@ -67,7 +67,6 @@ struct HfCandidateSelectorXicToXiPiPi { 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"}; - o2::analysis::HfMlResponse hfMlResponse; std::vector outputMl = {}; @@ -106,6 +105,7 @@ struct HfCandidateSelectorXicToXiPiPi { labels[1 + SelectionStep::RecoSkims] = "Skims selection"; labels[1 + SelectionStep::RecoTopol] = "Skims & Topological selections"; labels[1 + SelectionStep::RecoPID] = "Skims & Topological & PID selections"; + labels[1 + SelectionStep::RecoMl] = "Skims & Topological & PID & ML selections"; static const AxisSpec axisSelections = {kNBinsSelections, 0.5, kNBinsSelections + 0.5, ""}; registry.add("hSelections", "Selections;;#it{p}_{T} (GeV/#it{c})", {HistType::kTH2F, {axisSelections, {(std::vector)binsPt, "#it{p}_{T} (GeV/#it{c})"}}}); for (int iBin = 0; iBin < kNBinsSelections; ++iBin) { @@ -281,7 +281,7 @@ struct HfCandidateSelectorXicToXiPiPi { // ML selections if (applyMl) { - std::vector inputFeatures{}; + std::vector inputFeatures{hfCandXic.cpa()}; bool isSelectedMl = hfMlResponse.isSelectedMl(inputFeatures, ptCandXic, outputMl); hfMlXicToXiPiPiCandidate(outputMl); From 1b7fea990e21c0699a5b7f2417a50bc78b6383a7 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Mon, 8 Apr 2024 11:18:51 +0200 Subject: [PATCH 19/35] Fix wrong histogram subscription in Xic task --- PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx | 9 ++------- PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx | 2 +- 2 files changed, 3 insertions(+), 8 deletions(-) diff --git a/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx index ad68cf190d0..899f0402558 100644 --- a/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx +++ b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx @@ -231,7 +231,7 @@ struct HfTaskXicToXiPiPi { auto particleMother = mcParticles.rawIteratorAt(indexMother); registry.fill(HIST("hPtGenSig"), particleMother.pt()); - registry.fill(HIST("hPtCandRecSig"), ptCandXic); + registry.fill(HIST("hPtRecSig"), ptCandXic); registry.fill(HIST("hPtProng0RecSig"), candidate.ptProng0()); registry.fill(HIST("hPtProng1RecSig"), candidate.ptProng1()); registry.fill(HIST("hPtProng2RecSig"), candidate.ptProng2()); @@ -260,7 +260,7 @@ struct HfTaskXicToXiPiPi { registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_xictoxipipi::DecayType::XicToXiPiPi, candidate.invMassXic(), ptCandXic); } } else { - registry.fill(HIST("hPtCandRecBg"), ptCandXic); + registry.fill(HIST("hPtRecBg"), ptCandXic); registry.fill(HIST("hPtProng0RecBg"), candidate.ptProng0()); registry.fill(HIST("hPtProng1RecBg"), candidate.ptProng1()); registry.fill(HIST("hPtProng2RecBg"), candidate.ptProng2()); @@ -286,11 +286,6 @@ struct HfTaskXicToXiPiPi { registry.fill(HIST("hCPAxyLambdaRecBg"), candidate.cosPaLambda(), ptCandXic); if (checkDecayTypeMc) { registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_xictoxipipi::DecayType::NDecayType, candidate.invMassXic(), ptCandXic); - /*if (TESTBIT(flagMcMatchRecBs, hf_cand_bs::DecayTypeMc::PartlyRecoDecay)) { // Partly reconstructed decay channel - registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_bs::DecayTypeMc::PartlyRecoDecay, invMassCandBs, ptCandXic); - //} else { - registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_bs::DecayTypeMc::NDecayTypeMc, invMassCandBs, ptCandXic); - }*/ } } } // rec diff --git a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx index 7b481b0978a..e2fab62a090 100644 --- a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx @@ -281,7 +281,7 @@ struct HfCandidateSelectorXicToXiPiPi { // ML selections if (applyMl) { - std::vector inputFeatures{hfCandXic.cpa()}; + std::vector inputFeatures{}; bool isSelectedMl = hfMlResponse.isSelectedMl(inputFeatures, ptCandXic, outputMl); hfMlXicToXiPiPiCandidate(outputMl); From cf115cdd2ca7b891dc5812634050cc5bd3d3da7d Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Sat, 4 May 2024 16:27:06 +0200 Subject: [PATCH 20/35] Preparation for PR: Fix naming conventions, include KF variables in output tables, remove unused variables --- PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx | 43 +- .../DataModel/CandidateReconstructionTables.h | 7 - .../candidateCreatorXicToXiPiPi.cxx | 16 +- .../TableProducer/treeCreatorXicToXiPiPi.cxx | 615 +++++++++++++----- 4 files changed, 481 insertions(+), 200 deletions(-) diff --git a/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx index 899f0402558..327aaef8c81 100644 --- a/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx +++ b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx @@ -64,14 +64,13 @@ struct HfTaskXicToXiPiPi { registry.add("hCPAxy", "#Xi^{#plus}_{c} candidates;#Xi^{#plus}_{c} candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); registry.add("hMass", "#Xi^{#plus}_{c} candidates;inv. mass #Xi^{#mp} #pi^{#pm} #pi^{#pm} (GeV/#it{c}^{2});#it{p}_{T} (GeV/#it{c})", {HistType::kTH2F, {axisMassXic, axisPt}}); registry.add("hDecLength", "#Xi^{#plus}_{c} candidates;decay length (cm);entries", {HistType::kTH2F, {{200, 0., 0.4}, axisPt}}); - registry.add("hDecLenErr", "#Xi^{#plus}_{c} candidates;#Xi^{#plus}_{c} candidate decay length error (cm);entries", {HistType::kTH2F, {{100, 0., 1.}, axisPt}}); + registry.add("hErrDecLength", "#Xi^{#plus}_{c} candidates;#Xi^{#plus}_{c} candidate decay length error (cm);entries", {HistType::kTH2F, {{100, 0., 1.}, axisPt}}); registry.add("hDecLengthXY", "#Xi^{#plus}_{c} candidates;decay length xy (cm);entries", {HistType::kTH2F, {{200, 0., 0.4}, axisPt}}); - registry.add("hDecLenXYErr", "#Xi^{#plus}_{c} candidates;#Xi^{#plus}_{c} candidate decay length xy error (cm);entries", {HistType::kTH2F, {{100, 0., 1.}, axisPt}}); + registry.add("hErrDecLengthXY", "#Xi^{#plus}_{c} candidates;#Xi^{#plus}_{c} candidate decay length xy error (cm);entries", {HistType::kTH2F, {{100, 0., 1.}, axisPt}}); registry.add("hd0Prong0", "#Xi^{#plus}_{c} candidates;prong 0 (#Xi^{#mp}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{100, -0.05, 0.05}, axisPt}}); registry.add("hd0Prong1", "#Xi^{#plus}_{c} candidates;prong 1 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{100, -0.05, 0.05}, axisPt}}); registry.add("hd0Prong2", "#Xi^{#plus}_{c} candidates;prong 2 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{100, -0.05, 0.05}, axisPt}}); - registry.add("hImpParErr", "#Xi^{#plus}_{c} candidates;#Xi^{#plus}_{c} candidate impact parameter error (cm);entries", {HistType::kTH2F, {{100, -1., 1.}, axisPt}}); - //registry.add("hInvMassXi", "#Xi^{#plus}_{c} candidates;prong 0 (#Xi^{#mp}) inv. mass (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{500, 0, 5}, axisPt}}); + registry.add("hImpParErr", "#Xi^{#plus}_{c} candidates;prongs impact parameter error (cm);entries", {HistType::kTH2F, {{100, -1., 1.}, axisPt}}); registry.add("hChi2PCA", "#Xi^{#plus}_{c} candidates (matched);sum of distances of the secondary vertex to its prongs;entries", {HistType::kTH2F, {{240, -0.01, 0.1}, axisPt}}); registry.add("hCPAXi", "#Xi^{#plus}_{c} candidates;#Xi^{#minus} candidate cosine of pointing angle;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); registry.add("hCPAxyXi", "#Xi^{#plus}_{c} candidates;#Xi^{#minus} candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); @@ -101,20 +100,20 @@ struct HfTaskXicToXiPiPi { registry.add("hMassRecBg", "#Xi^{#plus}_{c} candidates (unmatched);inv. mass #Xi^{#mp} #pi^{#pm} #pi^{#pm} (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 4.0, 7.0}, axisPt}}); registry.add("hDecLengthRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); registry.add("hDecLengthRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); - // DecLenghtErr + registry.add("hErrDecLengthRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); + registry.add("hErrDecLengthRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); registry.add("hDecLengthXYRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length xy (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); registry.add("hDecLengthXYRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate decay length xy(cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); - // DecLengthXYErr - //registry.add("hDecLengthNormRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); - //registry.add("hDecLengthNormRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); + registry.add("hErrDecLengthXYRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length xy (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); + registry.add("hErrDecLengthXYRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate decay length xy(cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); registry.add("hd0Prong0RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 0 (#Xi^{#mp}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); registry.add("hd0Prong0RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 0 (#Xi^{#mp}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); registry.add("hd0Prong1RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 1 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); registry.add("hd0Prong1RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 1 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); registry.add("hd0Prong2RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 2 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); registry.add("hd0Prong2RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 2 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); - // ImpParErr - // InvMassXi + registry.add("hImpParErrRecSig", "#Xi^{#plus}_{c} candidates (matched);prongs impact parameter error (cm);entries", {HistType::kTH2F, {{100, -1., 1.}, axisPt}}); + registry.add("hImpParErrRecBg", "#Xi^{#plus}_{c} candidates (unmatched);prongs impact parameter error (cm);entries", {HistType::kTH2F, {{100, -1., 1.}, axisPt}}); registry.add("hChi2PCARecSig", "#Xi^{#plus}_{c} candidates (matched);sum of distances of the secondary vertex to its prongs;entries", {HistType::kTH2F, {{240, -0.01, 0.1}, axisPt}}); registry.add("hChi2PCARecBg", "#Xi^{#plus}_{c} candidates (unmatched);sum of distances of the secondary vertex to its prongs;entries", {HistType::kTH2F, {{240, -0.01, 0.1}, axisPt}}); registry.add("hCPAXiRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#minus} cosine of pointing angle;entries", {HistType::kTH2F, {{220, 0., 1.1}, axisPt}}); @@ -191,9 +190,9 @@ struct HfTaskXicToXiPiPi { registry.fill(HIST("hCPAxy"), candidate.cpaXY(), ptCandXic); registry.fill(HIST("hMass"), candidate.invMassXic(), ptCandXic); registry.fill(HIST("hDecLength"), candidate.decayLength(), ptCandXic); - registry.fill(HIST("hDecLenErr"), candidate.errorDecayLength(), ptCandXic); + registry.fill(HIST("hErrDecLength"), candidate.errorDecayLength(), ptCandXic); registry.fill(HIST("hDecLengthXY"), candidate.decayLengthXY(), ptCandXic); - registry.fill(HIST("hDecLenXYErr"), candidate.errorDecayLengthXY(), ptCandXic); + registry.fill(HIST("hErrDecLengthXY"), candidate.errorDecayLengthXY(), ptCandXic); registry.fill(HIST("hd0Prong0"), candidate.impactParameter0(), ptCandXic); registry.fill(HIST("hd0Prong1"), candidate.impactParameter1(), ptCandXic); registry.fill(HIST("hd0Prong2"), candidate.impactParameter2(), ptCandXic); @@ -241,15 +240,15 @@ struct HfTaskXicToXiPiPi { registry.fill(HIST("hCPAxyRecSig"), candidate.cpaXY(), ptCandXic); registry.fill(HIST("hMassRecSig"), candidate.invMassXic(), ptCandXic); registry.fill(HIST("hDecLengthRecSig"), candidate.decayLength(), ptCandXic); - //registry.fill(HIST("hDecLenErrRecSig"), candidate.errorDecayLength(), ptCandXic); + registry.fill(HIST("hErrDecLengthRecSig"), candidate.errorDecayLength(), ptCandXic); registry.fill(HIST("hDecLengthXYRecSig"), candidate.decayLengthXY(), ptCandXic); - //registry.fill(HIST("hDecLenXYErrRecSig"), candidate.errorDecayLengthXY(), ptCandXic); + registry.fill(HIST("hErrDecLengthXYRecSig"), candidate.errorDecayLengthXY(), ptCandXic); registry.fill(HIST("hd0Prong0RecSig"), candidate.impactParameter0(), ptCandXic); registry.fill(HIST("hd0Prong1RecSig"), candidate.impactParameter1(), ptCandXic); registry.fill(HIST("hd0Prong2RecSig"), candidate.impactParameter2(), ptCandXic); - //registry.fill(HIST("hImpParErrRecSig"), candidate.errorImpactParameter0(), ptCandXic); - //registry.fill(HIST("hImpParErrRecSig"), candidate.errorImpactParameter1(), ptCandXic); - //registry.fill(HIST("hImpParErrRecSig"), candidate.errorImpactParameter2(), ptCandXic); + registry.fill(HIST("hImpParErrRecSig"), candidate.errorImpactParameter0(), ptCandXic); + registry.fill(HIST("hImpParErrRecSig"), candidate.errorImpactParameter1(), ptCandXic); + registry.fill(HIST("hImpParErrRecSig"), candidate.errorImpactParameter2(), ptCandXic); registry.fill(HIST("hChi2PCARecSig"), candidate.chi2PCA(), ptCandXic); registry.fill(HIST("hCPAXiRecSig"), candidate.cosPaXi(), ptCandXic); registry.fill(HIST("hCPAxyXiRecSig"), candidate.cosPaXYXi(), ptCandXic); @@ -270,15 +269,15 @@ struct HfTaskXicToXiPiPi { registry.fill(HIST("hCPAxyRecBg"), candidate.cpaXY(), ptCandXic); registry.fill(HIST("hMassRecBg"), candidate.invMassXic(), ptCandXic); registry.fill(HIST("hDecLengthRecBg"), candidate.decayLength(), ptCandXic); - //registry.fill(HIST("hDecLenErrRecBg"), candidate.errorDecayLength(), ptCandXic); + registry.fill(HIST("hErrDecLengthRecBg"), candidate.errorDecayLength(), ptCandXic); registry.fill(HIST("hDecLengthXYRecBg"), candidate.decayLengthXY(), ptCandXic); - //registry.fill(HIST("hDecLenXYErrRecBg"), candidate.errorDecayLengthXY(), ptCandXic); + registry.fill(HIST("hErrDecLengthXYRecBg"), candidate.errorDecayLengthXY(), ptCandXic); registry.fill(HIST("hd0Prong0RecBg"), candidate.impactParameter0(), ptCandXic); registry.fill(HIST("hd0Prong1RecBg"), candidate.impactParameter1(), ptCandXic); registry.fill(HIST("hd0Prong2RecBg"), candidate.impactParameter2(), ptCandXic); - //registry.fill(HIST("hImpParErrRecBg"), candidate.errorImpactParameter0(), ptCandXic); - //registry.fill(HIST("hImpParErrRecBg"), candidate.errorImpactParameter1(), ptCandXic); - //registry.fill(HIST("hImpParErrRecBg"), candidate.errorImpactParameter2(), ptCandXic); + registry.fill(HIST("hImpParErrRecBg"), candidate.errorImpactParameter0(), ptCandXic); + registry.fill(HIST("hImpParErrRecBg"), candidate.errorImpactParameter1(), ptCandXic); + registry.fill(HIST("hImpParErrRecBg"), candidate.errorImpactParameter2(), ptCandXic); registry.fill(HIST("hChi2PCARecBg"), candidate.chi2PCA(), ptCandXic); registry.fill(HIST("hCPAXiRecBg"), candidate.cosPaXi(), ptCandXic); registry.fill(HIST("hCPAxyXiRecBg"), candidate.cosPaXYXi(), ptCandXic); diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index 3131a90d229..48d899ab735 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1334,16 +1334,9 @@ DECLARE_SOA_COLUMN(ZSvErr, zSvErr, float); DECLARE_SOA_COLUMN(XDecayVtxXi, xDecayVtxXi, float); DECLARE_SOA_COLUMN(YDecayVtxXi, yDecayVtxXi, float); DECLARE_SOA_COLUMN(ZDecayVtxXi, zDecayVtxXi, float); -DECLARE_SOA_COLUMN(XErrDecayVtxXi, xErrDecayVtxXi, float); -DECLARE_SOA_COLUMN(YErrDecayVtxXi, yErrDecayVtxXi, float); -DECLARE_SOA_COLUMN(ZErrDecayVtxXi, zErrDecayVtxXi, float); DECLARE_SOA_COLUMN(XDecayVtxLambda, xDecayVtxLambda, float); DECLARE_SOA_COLUMN(YDecayVtxLambda, yDecayVtxLambda, float); DECLARE_SOA_COLUMN(ZDecayVtxLambda, zDecayVtxLambda, float); -DECLARE_SOA_COLUMN(XErrDecayVtxLambda, xErrDecayVtxLambda, float); -DECLARE_SOA_COLUMN(YErrDecayVtxLambda, yErrDecayVtxLambda, float); -DECLARE_SOA_COLUMN(ZErrDecayVtxLambda, zErrDecayVtxLambda, float); -DECLARE_SOA_COLUMN(DcaCascDau, dcaCascDau, float); DECLARE_SOA_COLUMN(DcaPi0Pi1, dcaPi0Pi1, float); DECLARE_SOA_COLUMN(DcaPi0Xi, dcaPi0Xi, float); DECLARE_SOA_COLUMN(DcaPi1Xi, dcaPi1Xi, float); diff --git a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index 5a420ad5486..7a591408763 100644 --- a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -449,11 +449,11 @@ struct HfCandidateCreatorXic { int signXicPlus = casc.sign() < 0 ? +1 : -1; // get impact parameters of XicPlus daughters - float impactParameter0XY = 0., errImpactParameter0XY = 0.; - float impactParameter1XY = 0., errImpactParameter1XY = 0.; + float impactParameterPi0XY = 0., errImpactParameterPi0XY = 0.; + float impactParameterPi1XY = 0., errImpactParameterPi1XY = 0.; float impactParameterXiXY = 0., errImpactParameterXiXY = 0.; - kfPion0.GetDistanceFromVertexXY(KFPV, impactParameter0XY, errImpactParameter0XY); - kfPion1.GetDistanceFromVertexXY(KFPV, impactParameter1XY, errImpactParameter1XY); + kfPion0.GetDistanceFromVertexXY(KFPV, impactParameterPi0XY, errImpactParameterPi0XY); + kfPion1.GetDistanceFromVertexXY(KFPV, impactParameterPi1XY, errImpactParameterPi1XY); kfXi.GetDistanceFromVertexXY(KFPV, impactParameterXiXY, errImpactParameterXiXY); // calculate cosine of pointing angle @@ -483,8 +483,8 @@ struct HfCandidateCreatorXic { hCovSVXZ->Fill(covMatrixXicPlus[3]); hCovSVZZ->Fill(covMatrixXicPlus[5]); // DCAs of prongs - hDcaXYProngs->Fill(kfPion0.GetPt(), impactParameter0XY); - hDcaXYProngs->Fill(kfPion1.GetPt(), impactParameter1XY); + hDcaXYProngs->Fill(kfPion0.GetPt(), impactParameterPi0XY); + hDcaXYProngs->Fill(kfPion1.GetPt(), impactParameterPi1XY); hDcaXYProngs->Fill(kfXi.GetPt(), impactParameterXiXY); } // fill candidate table rows @@ -501,8 +501,8 @@ struct HfCandidateCreatorXic { kfXi.GetPx(), kfXi.GetPy(), kfXi.GetPz(), kfPion0.GetPx(), kfPion0.GetPy(), kfPion0.GetPz(), kfPion1.GetPx(), kfPion1.GetPy(), kfPion1.GetPz(), - impactParameterXiXY, impactParameter0XY, impactParameter1XY, - errImpactParameter0XY, errImpactParameter1XY, errImpactParameterXiXY, + impactParameterXiXY, impactParameterPi0XY, impactParameterPi1XY, + errImpactParameterXiXY, errImpactParameterPi0XY, errImpactParameterPi1XY, hfFlag, /*cascade specific columns*/ casc.x(), casc.y(), casc.z(), diff --git a/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx index 374a3ebfdf0..0989734e87f 100644 --- a/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx @@ -21,7 +21,6 @@ #include "Framework/AnalysisTask.h" #include "Framework/runDataProcessing.h" -#include "PWGHF/Core/HfHelper.h" #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/DataModel/CandidateSelectionTables.h" @@ -39,26 +38,26 @@ DECLARE_SOA_INDEX_COLUMN_FULL(Xi, xi, int, Tracks, "_pi0"); DECLARE_SOA_INDEX_COLUMN_FULL(Pi0, pi0, int, Tracks, "_pi0"); DECLARE_SOA_INDEX_COLUMN_FULL(Pi1, pi1, int, Tracks, "_pi1"); //vertices -DECLARE_SOA_COLUMN(PvX, pvX, float); -DECLARE_SOA_COLUMN(PvY, pvY, float); -DECLARE_SOA_COLUMN(PvZ, pvZ, float); -DECLARE_SOA_COLUMN(PvErrX, pvErrX, float); -DECLARE_SOA_COLUMN(PvErrY, pvErrY, float); -DECLARE_SOA_COLUMN(PvErrZ, pvErrZ, float); -DECLARE_SOA_COLUMN(SvX, svX, float); -DECLARE_SOA_COLUMN(SvY, svY, float); -DECLARE_SOA_COLUMN(SvZ, svZ, float); +DECLARE_SOA_COLUMN(XPv, xPv, float); +DECLARE_SOA_COLUMN(YPv, yPv, float); +DECLARE_SOA_COLUMN(ZPv, zPv, float); +DECLARE_SOA_COLUMN(XPvErr, xPvErr, float); +DECLARE_SOA_COLUMN(YPvErr, yPvErr, float); +DECLARE_SOA_COLUMN(ZPvErr, zPvErr, float); +DECLARE_SOA_COLUMN(XSv, xSv, float); +DECLARE_SOA_COLUMN(YSv, ySv, float); +DECLARE_SOA_COLUMN(ZSv, zSv, float); DECLARE_SOA_COLUMN(Chi2Sv, chi2Sv, float); -DECLARE_SOA_COLUMN(SvErrX, svErrX, float); -DECLARE_SOA_COLUMN(SvErrY, svErrY, float); -DECLARE_SOA_COLUMN(SvErrZ, svErrZ, float); -DECLARE_SOA_COLUMN(DecVtxXiX, decVtxXiX, float); -DECLARE_SOA_COLUMN(DecVtxXiY, decVtxXiY, float); -DECLARE_SOA_COLUMN(DecVtxXiZ, decVtxXiZ, float); -DECLARE_SOA_COLUMN(Chi2XiVtx, xhi2XiVtx, float); -DECLARE_SOA_COLUMN(DecVtxLamX, decVtxLamX, float); -DECLARE_SOA_COLUMN(DecVtxLamY, decVtxLamY, float); -DECLARE_SOA_COLUMN(DecVtxLamZ, decVtxLamZ, float); +DECLARE_SOA_COLUMN(XSvErr, xSvErr, float); +DECLARE_SOA_COLUMN(YSvErr, ySvErr, float); +DECLARE_SOA_COLUMN(ZSvErr, zSvErr, float); +DECLARE_SOA_COLUMN(XDecVtxXi, xDecVtxXi, float); +DECLARE_SOA_COLUMN(YDecVtxXi, yDecVtxXi, float); +DECLARE_SOA_COLUMN(ZDecVtxXi, zDecVtxXi, float); +DECLARE_SOA_COLUMN(Chi2XiVtx, chi2XiVtx, float); +DECLARE_SOA_COLUMN(XDecVtxLam, xDecVtxLam, float); +DECLARE_SOA_COLUMN(YDecVtxLam, yDecVtxLam, float); +DECLARE_SOA_COLUMN(ZDecVtxLam, zDecVtxLam, float); DECLARE_SOA_COLUMN(Chi2LamVtx, chi2LamVtx, float); // properties of XicPlus DECLARE_SOA_COLUMN(Sign, sign, float); @@ -107,12 +106,12 @@ DECLARE_SOA_TABLE(HfCandXicLites, "AOD", "HFCANDXICLITE", full::Pi0Id, full::Pi1Id, full::CandidateSelFlag, - full::PvX, - full::PvY, - full::PvZ, - full::SvX, - full::SvY, - full::SvZ, + full::XPv, + full::YPv, + full::ZPv, + full::XSv, + full::YSv, + full::ZSv, full::Chi2Sv, full::Sign, full::E, @@ -137,9 +136,48 @@ DECLARE_SOA_TABLE(HfCandXicLites, "AOD", "HFCANDXICLITE", full::CpaXYXi, full::CpaLam, full::CpaXYLam, - //full::DcaPi0Pi1, - //full::DcaPi0Xi, - //full::DcaPi1Xi, + hf_cand_xictoxipipi::FlagMcMatchRec); + +DECLARE_SOA_TABLE(HfCandXicLiteKfs, "AOD", "HFCANDXICLITEKF", + full::XiId, + full::Pi0Id, + full::Pi1Id, + full::CandidateSelFlag, + full::XPv, + full::YPv, + full::ZPv, + full::XSv, + full::YSv, + full::ZSv, + full::Chi2Sv, + full::Sign, + full::E, + full::M, + full::P, + full::Pt, + full::Y, + full::Eta, + full::Phi, + full::Ct, + full::DecayLength, + full::DecayLengthXY, + full::Cpa, + full::CpaXY, + full::PtXi, + full::PtPi0, + full::PtPi1, + full::ImpactParameterXi, + full::ImpactParameterPi0, + full::ImpactParameterPi1, + full::CpaXi, + full::CpaXYXi, + full::CpaLam, + full::CpaXYLam, + full::Chi2XiVtx, + full::Chi2LamVtx, + full::DcaPi0Pi1, + full::DcaPi0Xi, + full::DcaPi1Xi, hf_cand_xictoxipipi::FlagMcMatchRec); DECLARE_SOA_TABLE(HfCandXicFulls, "AOD", "HFCANDXICFULL", @@ -147,27 +185,25 @@ DECLARE_SOA_TABLE(HfCandXicFulls, "AOD", "HFCANDXICFULL", full::Pi0Id, full::Pi1Id, full::CandidateSelFlag, - full::PvX, - full::PvY, - full::PvZ, - full::PvErrX, - full::PvErrY, - full::PvErrZ, - full::SvX, - full::SvY, - full::SvZ, + full::XPv, + full::YPv, + full::ZPv, + full::XPvErr, + full::YPvErr, + full::ZPvErr, + full::XSv, + full::YSv, + full::ZSv, full::Chi2Sv, - full::SvErrX, - full::SvErrY, - full::SvErrZ, - full::DecVtxXiX, - full::DecVtxXiY, - full::DecVtxXiZ, - //full::Chi2XiVtx, - full::DecVtxLamX, - full::DecVtxLamY, - full::DecVtxLamZ, - //full::Chi2LamVtx, + full::XSvErr, + full::YSvErr, + full::ZSvErr, + full::XDecVtxXi, + full::YDecVtxXi, + full::ZDecVtxXi, + full::XDecVtxLam, + full::YDecVtxLam, + full::ZDecVtxLam, full::Sign, full::E, full::M, @@ -197,9 +233,66 @@ DECLARE_SOA_TABLE(HfCandXicFulls, "AOD", "HFCANDXICFULL", full::CpaXYXi, full::CpaLam, full::CpaXYLam, - //full::DcaPi0Pi1, - //full::DcaPi0Xi, - //full::DcaPi1Xi, + hf_cand_xictoxipipi::FlagMcMatchRec); + +DECLARE_SOA_TABLE(HfCandXicFullKfs, "AOD", "HFCANDXICFULLKF", + full::XiId, + full::Pi0Id, + full::Pi1Id, + full::CandidateSelFlag, + full::XPv, + full::YPv, + full::ZPv, + full::XPvErr, + full::YPvErr, + full::ZPvErr, + full::XSv, + full::YSv, + full::ZSv, + full::Chi2Sv, + full::XSvErr, + full::YSvErr, + full::ZSvErr, + full::XDecVtxXi, + full::YDecVtxXi, + full::ZDecVtxXi, + full::XDecVtxLam, + full::YDecVtxLam, + full::ZDecVtxLam, + full::Sign, + full::E, + full::M, + full::P, + full::Pt, + full::Y, + full::Eta, + full::Phi, + full::Ct, + full::DecayLength, + full::DecayLengthNormalised, + full::DecayLengthXY, + full::DecayLengthXYNormalised, + full::Cpa, + full::CpaXY, + full::PtXi, + full::PtPi0, + full::PtPi1, + full::ImpactParameterXi, + full::ImpactParameterNormalisedXi, + full::ImpactParameterPi0, + full::ImpactParameterNormalisedPi0, + full::ImpactParameterPi1, + full::ImpactParameterNormalisedPi1, + full::MaxNormalisedDeltaIP, + full::CpaXi, + full::CpaXYXi, + full::CpaLam, + full::CpaXYLam, + full::Chi2XiVtx, + full::Chi2LamVtx, + full::DcaPi0Pi1, + full::DcaPi0Xi, + full::DcaPi1Xi, hf_cand_xictoxipipi::FlagMcMatchRec); DECLARE_SOA_TABLE(HfCandXicFullEvs, "AOD", "HFCANDXICFULLEV", @@ -223,7 +316,9 @@ DECLARE_SOA_TABLE(HfCandXicFullPs, "AOD", "HFCANDXICFULLP", /// Writes the full information in an output TTree struct HfTreeCreatorXicToXiPiPi { Produces rowCandidateLite; + Produces rowCandidateLiteKf; Produces rowCandidateFull; + Produces rowCandidateFullKf; Produces rowCandidateFullEvents; Produces rowCandidateFullParticles; @@ -235,13 +330,18 @@ struct HfTreeCreatorXicToXiPiPi { Configurable downSampleBkgFactor{"downSampleBkgFactor", 1., "Fraction of background candidates to keep for ML trainings"}; Configurable ptMaxForDownSample{"ptMaxForDownSample", 10., "Maximum pt for the application of the downsampling factor"}; + using SelectedCandidates = soa::Filtered>; + using SelectedCandidatesKf = soa::Filtered>; using SelectedCandidatesMc = soa::Filtered>; + using SelectedCandidatesKfMc = soa::Filtered>; using TracksWPid = soa::Join; Filter filterSelectCandidates = aod::hf_sel_candidate_xic::isSelXicToXiPiPi >= selectionFlagXic; Partition recSig = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) == (int8_t)BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); Partition recBg = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) != (int8_t)BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); + Partition recSigKf = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) == (int8_t)BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); + Partition recBgKf = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) != (int8_t)BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); void init(InitContext const&) { @@ -261,118 +361,216 @@ struct HfTreeCreatorXicToXiPiPi { ); } - template + template void fillCandidateTable(const T& candidate) { int8_t flagMc = 0; if constexpr (doMc) { flagMc = candidate.flagMcMatchRec(); } - if (fillCandidateLiteTable) { - rowCandidateLite( - candidate.cascadeId(), - candidate.pi0Id(), - candidate.pi1Id(), - candidate.isSelXicToXiPiPi(), - candidate.posX(), - candidate.posY(), - candidate.posZ(), - candidate.xSecondaryVertex(), - candidate.ySecondaryVertex(), - candidate.zSecondaryVertex(), - candidate.chi2PCA(), - candidate.sign(), - candidate.e(o2::constants::physics::MassXiCPlus), - candidate.invMassXic(), - candidate.p(), - candidate.pt(), - candidate.y(o2::constants::physics::MassXiCPlus), - candidate.eta(), - candidate.phi(), - candidate.ct(o2::constants::physics::MassXiCPlus), - candidate.decayLength(), - candidate.decayLengthXY(), - candidate.cpa(), - candidate.cpaXY(), - candidate.ptProng0(), - candidate.ptProng1(), - candidate.ptProng2(), - candidate.impactParameter0(), - candidate.impactParameter1(), - candidate.impactParameter2(), - candidate.cosPaXi(), - candidate.cosPaXYXi(), - candidate.cosPaLambda(), - candidate.cosPaXYLambda(), - //candidate.dcaPi0Pi1(), - //candidate.dcaPi0Xi(), - //candidate.dcaPi1Xi(), - flagMc); + if constexpr (noKf){ + if (fillCandidateLiteTable) { + rowCandidateLite( + candidate.cascadeId(), + candidate.pi0Id(), + candidate.pi1Id(), + candidate.isSelXicToXiPiPi(), + candidate.posX(), + candidate.posY(), + candidate.posZ(), + candidate.xSecondaryVertex(), + candidate.ySecondaryVertex(), + candidate.zSecondaryVertex(), + candidate.chi2PCA(), + candidate.sign(), + candidate.e(o2::constants::physics::MassXiCPlus), + candidate.invMassXic(), + candidate.p(), + candidate.pt(), + candidate.y(o2::constants::physics::MassXiCPlus), + candidate.eta(), + candidate.phi(), + candidate.ct(o2::constants::physics::MassXiCPlus), + candidate.decayLength(), + candidate.decayLengthXY(), + candidate.cpa(), + candidate.cpaXY(), + candidate.ptProng0(), + candidate.ptProng1(), + candidate.ptProng2(), + candidate.impactParameter0(), + candidate.impactParameter1(), + candidate.impactParameter2(), + candidate.cosPaXi(), + candidate.cosPaXYXi(), + candidate.cosPaLambda(), + candidate.cosPaXYLambda(), + flagMc); + } else { + rowCandidateFull( + candidate.cascadeId(), + candidate.pi0Id(), + candidate.pi1Id(), + candidate.isSelXicToXiPiPi(), + candidate.posX(), + candidate.posY(), + candidate.posZ(), + candidate.xPvErr(), + candidate.yPvErr(), + candidate.zPvErr(), + candidate.xSecondaryVertex(), + candidate.ySecondaryVertex(), + candidate.zSecondaryVertex(), + candidate.chi2PCA(), + candidate.xSvErr(), + candidate.ySvErr(), + candidate.zSvErr(), + candidate.xDecayVtxXi(), + candidate.yDecayVtxXi(), + candidate.zDecayVtxXi(), + candidate.xDecayVtxLambda(), + candidate.yDecayVtxLambda(), + candidate.zDecayVtxLambda(), + candidate.sign(), + candidate.e(o2::constants::physics::MassXiCPlus), + candidate.invMassXic(), + candidate.p(), + candidate.pt(), + candidate.y(o2::constants::physics::MassXiCPlus), + candidate.eta(), + candidate.phi(), + candidate.ct(o2::constants::physics::MassXiCPlus), + candidate.decayLength(), + candidate.decayLengthNormalised(), + candidate.decayLengthXY(), + candidate.decayLengthXYNormalised(), + candidate.cpa(), + candidate.cpaXY(), + candidate.ptProng0(), + candidate.ptProng1(), + candidate.ptProng2(), + candidate.impactParameter0(), + candidate.impactParameterNormalised0(), + candidate.impactParameter1(), + candidate.impactParameterNormalised1(), + candidate.impactParameter2(), + candidate.impactParameterNormalised2(), + candidate.maxNormalisedDeltaIP(), + candidate.cosPaXi(), + candidate.cosPaXYXi(), + candidate.cosPaLambda(), + candidate.cosPaXYLambda(), + flagMc); + } } else { - rowCandidateFull( - candidate.cascadeId(), - candidate.pi0Id(), - candidate.pi1Id(), - candidate.isSelXicToXiPiPi(), - candidate.posX(), - candidate.posY(), - candidate.posZ(), - candidate.xPvErr(), - candidate.yPvErr(), - candidate.zPvErr(), - candidate.xSecondaryVertex(), - candidate.ySecondaryVertex(), - candidate.zSecondaryVertex(), - candidate.chi2PCA(), - candidate.xSvErr(), - candidate.ySvErr(), - candidate.zSvErr(), - candidate.xDecayVtxXi(), - candidate.yDecayVtxXi(), - candidate.zDecayVtxXi(), - //candidate.kfCascadeChi2(), - candidate.xDecayVtxLambda(), - candidate.yDecayVtxLambda(), - candidate.zDecayVtxLambda(), - //candidate.kfV0Chi2(), - candidate.sign(), - candidate.e(o2::constants::physics::MassXiCPlus), - candidate.invMassXic(), - candidate.p(), - candidate.pt(), - candidate.y(o2::constants::physics::MassXiCPlus), - candidate.eta(), - candidate.phi(), - candidate.ct(o2::constants::physics::MassXiCPlus), - candidate.decayLength(), - candidate.decayLengthNormalised(), - candidate.decayLengthXY(), - candidate.decayLengthXYNormalised(), - candidate.cpa(), - candidate.cpaXY(), - candidate.ptProng0(), - candidate.ptProng1(), - candidate.ptProng2(), - candidate.impactParameter0(), - candidate.impactParameterNormalised0(), - candidate.impactParameter1(), - candidate.impactParameterNormalised1(), - candidate.impactParameter2(), - candidate.impactParameterNormalised2(), - candidate.maxNormalisedDeltaIP(), - candidate.cosPaXi(), - candidate.cosPaXYXi(), - candidate.cosPaLambda(), - candidate.cosPaXYLambda(), - //candidate.dcaPi0Pi1(), - //candidate.dcaPi0Xi(), - //candidate.dcaPi1Xi(), - flagMc); + if (fillCandidateLiteTable) { + rowCandidateLiteKf( + candidate.cascadeId(), + candidate.pi0Id(), + candidate.pi1Id(), + candidate.isSelXicToXiPiPi(), + candidate.posX(), + candidate.posY(), + candidate.posZ(), + candidate.xSecondaryVertex(), + candidate.ySecondaryVertex(), + candidate.zSecondaryVertex(), + candidate.chi2PCA(), + candidate.sign(), + candidate.e(o2::constants::physics::MassXiCPlus), + candidate.invMassXic(), + candidate.p(), + candidate.pt(), + candidate.y(o2::constants::physics::MassXiCPlus), + candidate.eta(), + candidate.phi(), + candidate.ct(o2::constants::physics::MassXiCPlus), + candidate.decayLength(), + candidate.decayLengthXY(), + candidate.cpa(), + candidate.cpaXY(), + candidate.ptProng0(), + candidate.ptProng1(), + candidate.ptProng2(), + candidate.impactParameter0(), + candidate.impactParameter1(), + candidate.impactParameter2(), + candidate.cosPaXi(), + candidate.cosPaXYXi(), + candidate.cosPaLambda(), + candidate.cosPaXYLambda(), + candidate.kfCascadeChi2(), + candidate.kfV0Chi2(), + candidate.dcaPi0Pi1(), + candidate.dcaPi0Xi(), + candidate.dcaPi1Xi(), + flagMc); + } else { + rowCandidateFullKf( + candidate.cascadeId(), + candidate.pi0Id(), + candidate.pi1Id(), + candidate.isSelXicToXiPiPi(), + candidate.posX(), + candidate.posY(), + candidate.posZ(), + candidate.xPvErr(), + candidate.yPvErr(), + candidate.zPvErr(), + candidate.xSecondaryVertex(), + candidate.ySecondaryVertex(), + candidate.zSecondaryVertex(), + candidate.chi2PCA(), + candidate.xSvErr(), + candidate.ySvErr(), + candidate.zSvErr(), + candidate.xDecayVtxXi(), + candidate.yDecayVtxXi(), + candidate.zDecayVtxXi(), + candidate.xDecayVtxLambda(), + candidate.yDecayVtxLambda(), + candidate.zDecayVtxLambda(), + candidate.sign(), + candidate.e(o2::constants::physics::MassXiCPlus), + candidate.invMassXic(), + candidate.p(), + candidate.pt(), + candidate.y(o2::constants::physics::MassXiCPlus), + candidate.eta(), + candidate.phi(), + candidate.ct(o2::constants::physics::MassXiCPlus), + candidate.decayLength(), + candidate.decayLengthNormalised(), + candidate.decayLengthXY(), + candidate.decayLengthXYNormalised(), + candidate.cpa(), + candidate.cpaXY(), + candidate.ptProng0(), + candidate.ptProng1(), + candidate.ptProng2(), + candidate.impactParameter0(), + candidate.impactParameterNormalised0(), + candidate.impactParameter1(), + candidate.impactParameterNormalised1(), + candidate.impactParameter2(), + candidate.impactParameterNormalised2(), + candidate.maxNormalisedDeltaIP(), + candidate.cosPaXi(), + candidate.cosPaXYXi(), + candidate.cosPaLambda(), + candidate.cosPaXYLambda(), + candidate.kfCascadeChi2(), + candidate.kfV0Chi2(), + candidate.dcaPi0Pi1(), + candidate.dcaPi0Xi(), + candidate.dcaPi1Xi(), + flagMc); + } } } void processData(aod::Collisions const& collisions, - soa::Filtered> const& candidates, + SelectedCandidates const& candidates, TracksWPid const&) { // Filling event properties @@ -382,9 +580,10 @@ struct HfTreeCreatorXicToXiPiPi { } // Filling candidate properties - rowCandidateFull.reserve(candidates.size()); if (fillCandidateLiteTable) { rowCandidateLite.reserve(candidates.size()); + } else { + rowCandidateFull.reserve(candidates.size()); } for (const auto& candidate : candidates) { if (fillOnlyBackground && downSampleBkgFactor < 1.) { @@ -396,9 +595,36 @@ struct HfTreeCreatorXicToXiPiPi { fillCandidateTable(candidate); } } - PROCESS_SWITCH(HfTreeCreatorXicToXiPiPi, processData, "Process data", true); + void processDataKf(aod::Collisions const& collisions, + SelectedCandidatesKf const& candidates, + TracksWPid const&) + { + // Filling event properties + rowCandidateFullEvents.reserve(collisions.size()); + for (const auto& collision : collisions) { + fillEvent(collision, 0, 1); + } + + // Filling candidate properties + if (fillCandidateLiteTable) { + rowCandidateLite.reserve(candidates.size()); + } else { + rowCandidateFull.reserve(candidates.size()); + } + for (const auto& candidate : candidates) { + if (fillOnlyBackground && downSampleBkgFactor < 1.) { + float pseudoRndm = candidate.ptProng1() * 1000. - (int64_t)(candidate.ptProng1() * 1000); + if (pseudoRndm >= downSampleBkgFactor && candidate.pt() < ptMaxForDownSample) { + continue; + } + } + fillCandidateTable(candidate); + } + } + PROCESS_SWITCH(HfTreeCreatorXicToXiPiPi, processDataKf, "Process data with KF Particle reconstruction", false); + void processMc(aod::Collisions const& collisions, aod::McCollisions const&, SelectedCandidatesMc const& candidates, @@ -413,32 +639,35 @@ struct HfTreeCreatorXicToXiPiPi { // Filling candidate properties if (fillOnlySignal) { - rowCandidateFull.reserve(recSig.size()); if (fillCandidateLiteTable) { rowCandidateLite.reserve(recSig.size()); + } else { + rowCandidateFull.reserve(recSig.size()); } for (const auto& candidate : recSig) { - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } else if (fillOnlyBackground) { - rowCandidateFull.reserve(recBg.size()); if (fillCandidateLiteTable) { rowCandidateLite.reserve(recBg.size()); + } else { + rowCandidateFull.reserve(recBg.size()); } for (const auto& candidate : recBg) { float pseudoRndm = candidate.ptProng1() * 1000. - (int64_t)(candidate.ptProng1() * 1000); if (candidate.pt() < ptMaxForDownSample && pseudoRndm >= downSampleBkgFactor) { continue; } - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } else { - rowCandidateFull.reserve(candidates.size()); if (fillCandidateLiteTable) { rowCandidateLite.reserve(candidates.size()); + } else { + rowCandidateFull.reserve(candidates.size()); } for (const auto& candidate : candidates) { - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } @@ -456,10 +685,70 @@ struct HfTreeCreatorXicToXiPiPi { } } } - PROCESS_SWITCH(HfTreeCreatorXicToXiPiPi, processMc, "Process MC", false); -}; + void processMcKf(aod::Collisions const& collisions, + aod::McCollisions const&, + SelectedCandidatesKfMc const& candidates, + soa::Join const& particles, + TracksWPid const&) + { + // Filling event properties + rowCandidateFullEvents.reserve(collisions.size()); + for (const auto& collision : collisions) { + fillEvent(collision, 0, 1); + } + + // Filling candidate properties + if (fillOnlySignal) { + if (fillCandidateLiteTable) { + rowCandidateLite.reserve(recSigKf.size()); + } else { + rowCandidateFull.reserve(recSigKf.size()); + } + for (const auto& candidate : recSigKf) { + fillCandidateTable(candidate); + } + } else if (fillOnlyBackground) { + if (fillCandidateLiteTable) { + rowCandidateLite.reserve(recBgKf.size()); + } else { + rowCandidateFull.reserve(recBgKf.size()); + } + for (const auto& candidate : recBgKf) { + float pseudoRndm = candidate.ptProng1() * 1000. - (int64_t)(candidate.ptProng1() * 1000); + if (candidate.pt() < ptMaxForDownSample && pseudoRndm >= downSampleBkgFactor) { + continue; + } + fillCandidateTable(candidate); + } + } else { + if (fillCandidateLiteTable) { + rowCandidateLite.reserve(candidates.size()); + } else { + rowCandidateFull.reserve(candidates.size()); + } + for (const auto& candidate : candidates) { + fillCandidateTable(candidate); + } + } + + // Filling particle properties + rowCandidateFullParticles.reserve(particles.size()); + for (const auto& particle : particles) { + if (TESTBIT(std::abs(particle.flagMcMatchGen()), aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { + rowCandidateFullParticles( + particle.mcCollision().bcId(), + particle.pt(), + particle.eta(), + particle.phi(), + RecoDecay::y(std::array{particle.px(), particle.py(), particle.pz()}, o2::constants::physics::MassXiCPlus), + particle.flagMcMatchGen()); + } + } + } + PROCESS_SWITCH(HfTreeCreatorXicToXiPiPi, processMcKf, "Process MC with KF Particle reconstruction", false); +}; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { From 3ab639d596ecf9e5782dd95ca8f95f146448e2e6 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Sat, 1 Jun 2024 12:36:51 +0200 Subject: [PATCH 21/35] Fix kfXicPlus creation --- PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index 7a591408763..e760858c837 100644 --- a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -426,12 +426,12 @@ struct HfCandidateCreatorXic { } // create KFParticle KFParticle kfXi; - kfXi.Create(parPosMom, casc.kfTrackCovMat(), casc.sign(), casc.m(1)); // casc.m(1): 1 for Lambda mass hypothesis + kfXi.Create(parPosMom, casc.kfTrackCovMat(), casc.sign(), casc.mXi()); // create XicPlus as KFParticle object KFParticle kfXicPlus; const KFParticle* kfDaughtersXicPlus[3] = {&kfPion0, &kfPion1, &kfXi}; - kfXicPlus.SetConstructMethod(2); // 0: no mass constraint, 2: mass constraint + kfXicPlus.SetConstructMethod(0); // 0: no mass constraint, 2: mass constraint kfXicPlus.Construct(kfDaughtersXicPlus, 3); // topological constraint if (constrainXicPlusToPv) { From 0afa3ef668a79a8c9ee5e697f3bac7d3433f4774 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Fri, 7 Jun 2024 11:03:27 +0200 Subject: [PATCH 22/35] Add Xi resonance to MC matching --- .../DataModel/CandidateReconstructionTables.h | 1 + .../candidateCreatorXicToXiPiPi.cxx | 42 ++++++++++++++----- 2 files changed, 32 insertions(+), 11 deletions(-) diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index 48d899ab735..6a8f8a50800 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1355,6 +1355,7 @@ DECLARE_SOA_COLUMN(OriginRec, originRec, int8_t); DECLARE_SOA_COLUMN(OriginGen, originGen, int8_t); // mapping of decay types enum DecayType { XicToXiPiPi=0, + XicToXiResPiToXiPiPi, NDecayType }; } // end of namespace hf_cand_xictoxipipi diff --git a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index e760858c837..7adfc1c5e06 100644 --- a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -573,14 +573,15 @@ struct HfCandidateCreatorXicMc { int indexRec = -1; int indexRecXicPlus = -1; + int indexRes = -1; int8_t sign = -9; int8_t flag = 0; int8_t origin = 0; int8_t debug = 0; - int8_t debugGen = 0; int pdgCodeXicPlus = Pdg::kXiCPlus; // 4232 int pdgCodeXiMinus = kXiMinus; // 3312 + int pdgCodeXiRes = 3324 // 3324 int pdgCodeLambda = kLambda0; // 3122 int pdgCodePiPlus = kPiPlus; // 211 int pdgCodePiMinus = kPiMinus; // -211 @@ -598,14 +599,18 @@ struct HfCandidateCreatorXicMc { candidate.bachelor_as(), // pi <- cascade candidate.posTrack_as(), // p <- lambda candidate.negTrack_as()}; // pi <- lambda + auto arrayDaughtersResPi0 = std::array{candidate.cascade_as(), + candidate.pi0_as()}; + auto arrayDaughtersResPi1 = std::array{candidate.cascade_as(), + candidate.pi1_as()}; auto arrayDaughtersCasc = std::array{candidate.bachelor_as(), candidate.posTrack_as(), - candidate.negTrack_as()}; + candidate.negTrack_as()}; auto arrayDaughtersV0 = std::array{candidate.posTrack_as(), candidate.negTrack_as()}; // Xic → pi pi pi pi p - indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, pdgCodeXicPlus, std::array{pdgCodePiPlus, pdgCodePiPlus, pdgCodePiMinus, pdgCodeProton, pdgCodePiMinus}, true, &sign, 3); + indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, pdgCodeXicPlus, std::array{pdgCodePiPlus, pdgCodePiPlus, pdgCodePiMinus, pdgCodeProton, pdgCodePiMinus}, true, &sign, 4); indexRecXicPlus = indexRec; if (indexRec == -1) { debug = 1; @@ -623,7 +628,18 @@ struct HfCandidateCreatorXicMc { debug = 3; } if (indexRec > -1) { - flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); + //Xic → Xi(1530) pi + indexRes = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughtersResPi0, pdgCodeXicPlus, std::array{pdgCodeXiRes, pdgCodePiMinus}, true, &sign, 1); + if (indexRes > -1) { + flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi); + } else if (indexRes == -1) { + indexRes = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughtersResPi1, pdgCodeXicPlus, std::array{pdgCodeXiRes, pdgCodePiMinus}, true, &sign, 1); + if (indexRes > -1) { + flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi); + } else if (indexRes ==-1) { + flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); + } + } } } } @@ -641,21 +657,25 @@ struct HfCandidateCreatorXicMc { for (const auto& particle : mcParticles) { flag = 0; sign = -9; - debugGen = 0; + debug = 0; origin = RecoDecay::OriginType::None; // Xic → Xi pi pi - if (RecoDecay::isMatchedMCGen(mcParticles, particle, pdgCodeXicPlus, std::array{pdgCodeXiMinus, pdgCodePiPlus, pdgCodePiPlus}, true, &sign)) { - debugGen = 1; + if (RecoDecay::isMatchedMCGen(mcParticles, particle, pdgCodeXicPlus, std::array{pdgCodeXiMinus, pdgCodePiPlus, pdgCodePiPlus}, true, &sign, 2)) { + debug = 1; // Xi- -> Lambda pi auto cascMC = mcParticles.rawIteratorAt(particle.daughtersIds().front()); if (RecoDecay::isMatchedMCGen(mcParticles, cascMC, pdgCodeXiMinus, std::array{pdgCodeLambda, pdgCodePiMinus}, true)) { - debugGen = 2; + debug = 2; // Lambda -> p pi auto v0MC = mcParticles.rawIteratorAt(cascMC.daughtersIds().front()); if (RecoDecay::isMatchedMCGen(mcParticles, v0MC, pdgCodeLambda, std::array{pdgCodeProton, pdgCodePiMinus}, true)) { - debugGen = 3; - flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); + debug = 3; + if (RecoDecay::isMatchedMCGen(mcParticles, particle, pdgCodeXicPlus, std::array{pdgCodeXiRes, pdgCodePiMinus}, true)) { + flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi); + } else { + flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); + } } } } @@ -665,7 +685,7 @@ struct HfCandidateCreatorXicMc { origin = RecoDecay::getCharmHadronOrigin(mcParticles, particle, true); } - rowMcMatchGen(flag, debugGen, origin); + rowMcMatchGen(flag, debug, origin); } // close loop over generated particles } // close process PROCESS_SWITCH(HfCandidateCreatorXicMc, processMc, "Process MC", false); From de5ce678e3bdf5a5c72127517ca5e27500f8dc91 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Sat, 8 Jun 2024 20:40:19 +0200 Subject: [PATCH 23/35] Restructure candidate creator: Remove PV refit, add KF process with track index skimming --- PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx | 6 +- .../candidateCreatorXicToXiPiPi.cxx | 582 +++++++++++------- .../candidateSelectorXicToXiPiPi.cxx | 22 +- .../TableProducer/treeCreatorXicToXiPiPi.cxx | 3 - 4 files changed, 388 insertions(+), 225 deletions(-) diff --git a/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx index 327aaef8c81..895cc353792 100644 --- a/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx +++ b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx @@ -31,7 +31,7 @@ using namespace o2::analysis; using namespace o2::framework; using namespace o2::framework::expressions; -/// Bs analysis task +/// Xic analysis task struct HfTaskXicToXiPiPi { Configurable selectionFlagXic{"selectionFlagXic", 1, "Selection Flag for Xic"}; Configurable yCandGenMax{"yCandGenMax", 0.5, "max. gen particle rapidity"}; @@ -207,7 +207,7 @@ struct HfTaskXicToXiPiPi { } // candidate loop } // process - /// Bs MC analysis and fill histograms + /// MC analysis and fill histograms void processMc(soa::Filtered> const& candidates, soa::Join const& mcParticles, aod::TracksWMc const&) @@ -323,7 +323,7 @@ struct HfTaskXicToXiPiPi { registry.fill(HIST("hYGen"), yParticle, ptParticle); registry.fill(HIST("hEtaGen"), particle.eta(), ptParticle); - // reject Bs daughters that are not in geometrical acceptance + // reject Xic daughters that are not in geometrical acceptance if (!isProngInAcceptance(etaProngs[0], ptProngs[0]) || !isProngInAcceptance(etaProngs[1], ptProngs[1]) || !isProngInAcceptance(etaProngs[2], ptProngs[2])) { continue; } diff --git a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index 7adfc1c5e06..08083d22f5c 100644 --- a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -19,14 +19,17 @@ #define HomogeneousField #endif +//external headers #include #include #include #include #include +//ROOT #include +//O2 #include "CommonConstants/PhysicsConstants.h" #include "DCAFitter/DCAFitterN.h" #include "Framework/AnalysisTask.h" @@ -34,11 +37,15 @@ #include "ReconstructionDataFormats/DCA.h" #include "ReconstructionDataFormats/V0.h" // for creating XicPlus track with DCA fitter +//O2Physics +#include "Common/DataModel/CollisionAssociationTables.h" #include "Common/Core/trackUtilities.h" #include "Tools/KFparticle/KFUtilities.h" +//PWG non-HF #include "PWGLF/DataModel/LFStrangenessTables.h" +//PWGHF #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/Utils/utilsBfieldCCDB.h" @@ -47,15 +54,24 @@ using namespace o2::analysis; using namespace o2::aod::hf_cand_xictoxipipi; using namespace o2::constants::physics; using namespace o2::framework; +using namespace o2::framework::expressions; /// Reconstruction of heavy-flavour 3-prong decay candidates struct HfCandidateCreatorXic { Produces rowCandidateBase; Produces rowCandidateKF; - // vertexing - Configurable rejDiffCollTrack{"rejDiffCollTrack", true, "Reject tracks coming from different collisions"}; Configurable fillHistograms{"fillHistograms", true, "do validation plots"}; + // magnetic field setting from CCDB + Configurable isRun2{"isRun2", false, "enable Run 2 or Run 3 GRP objects for magnetic field"}; + Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; + Configurable ccdbPathLut{"ccdbPathLut", "GLO/Param/MatLUT", "Path for LUT parametrization"}; + Configurable ccdbPathGrp{"ccdbPathGrp", "GLO/GRP/GRP", "Path of the grp file (Run 2)"}; + Configurable ccdbPathGrpMag{"ccdbPathGrpMag", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object (Run 3)"}; + // cascade preselections + Configurable doCascadePreselection{"doCascadePreselection", true, "Use invariant mass and dcaXY cuts to preselect cascade candidates"}; + Configurable massToleranceCascade{"massToleranceCascade", 0.01, "Invariant mass tolerance for cascade"}; + Configurable dcaXYToPVCascadeMax{"dcaXYToPVCascadeMax", 3, "Max cascade DCA to PV in xy plane"}; // DCA fitter Configurable propagateToPCA{"propagateToPCA", true, "create tracks version propagated to PCA"}; Configurable maxR{"maxR", 200., "reject PCA's above this radius"}; @@ -66,18 +82,8 @@ struct HfCandidateCreatorXic { Configurable useWeightedFinalPCA{"useWeightedFinalPCA", false, "Recalculate vertex position using track covariances, effective only if useAbsDCA is true"}; // KFParticle Configurable constrainXicPlusToPv{"constrainXicPlusToPv", false, "Constrain XicPlus to PV"}; - - // magnetic field setting from CCDB - Configurable isRun2{"isRun2", false, "enable Run 2 or Run 3 GRP objects for magnetic field"}; - Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; - Configurable ccdbPathLut{"ccdbPathLut", "GLO/Param/MatLUT", "Path for LUT parametrization"}; - Configurable ccdbPathGrp{"ccdbPathGrp", "GLO/GRP/GRP", "Path of the grp file (Run 2)"}; - Configurable ccdbPathGrpMag{"ccdbPathGrpMag", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object (Run 3)"}; - - // cascade cuts - Configurable doCascadePreselection{"doCascadePreselection", true, "Use invariant mass and dcaXY cuts to preselect cascade candidates"}; - Configurable massToleranceCascade{"massToleranceCascade", 0.01, "Invariant mass tolerance for cascade"}; - Configurable dcaXYToPVCascadeMax{"dcaXYToPVCascadeMax", 3, "Max cascade DCA to PV in xy plane"}; + Configurable kfConstructMethod{"kfConstructMethod", 0, "Construct method of XicPlus: 0 no mass constraint, 2 mass constraint"}; + Configurable rejDiffCollTrack{"rejDiffCollTrack", true, "Reject tracks coming from different collisions (effective only for KFParticle w/o derived data)"}; Service ccdb; o2::base::MatLayerCylSet* lut; @@ -92,6 +98,19 @@ struct HfCandidateCreatorXic { double massXiPiPi{0.}; double bz{0.}; + using CascadesLinked = soa::Join; + using CascFull = soa::Join; + using KFCascadesLinked = soa::Join; + using KFCascFull = soa::Join; + using SelectedCollisions = soa::Filtered>; + using SelectedHfTrackAssoc = soa::Filtered>; + + Filter filterSelectCollisions = (aod::hf_sel_collision::whyRejectColl == static_cast(0)); + Filter filterSelectTrackIds = ((aod::hf_sel_track::isSelProng & static_cast(BIT(4))) != 0u); // corresponds to CandidateType::CandCascadeBachelor in trackIndexSkimCreator.cxx + + Preslice trackIndicesPerCollision = aod::track_association::collisionId; + Preslice linkedCascadesPerCollision = aod::cascdata::collisionId; + OutputObj hMass3{TH1F("hMass3", "3-prong candidates;inv. mass (#Xi #pi #pi) (GeV/#it{c}^{2});entries", 500, 2.3, 2.7)}; OutputObj hCovPVXX{TH1F("hCovPVXX", "3-prong candidates;XX element of cov. matrix of prim. vtx. position (cm^{2});entries", 100, 0., 1.e-4)}; OutputObj hCovSVXX{TH1F("hCovSVXX", "3-prong candidates;XX element of cov. matrix of sec. vtx. position (cm^{2});entries", 100, 0., 0.2)}; @@ -113,12 +132,11 @@ struct HfCandidateCreatorXic { lut = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdb->get(ccdbPathLut)); runNumber = 0; - std::array doprocessDF{doprocessPvRefitWithDCAFitterN, doprocessNoPvRefitWithDCAFitterN}; - std::array doprocessKF{doprocessPvRefitWithKFParticle, doprocessNoPvRefitWithKFParticle}; - if ((std::accumulate(doprocessDF.begin(), doprocessDF.end(), 0) + std::accumulate(doprocessKF.begin(), doprocessKF.end(), 0)) != 1) { + std::array doprocessKF{doprocessXicplusWithKFParticleFromDerivedData, doprocessXicplusWithKFParticle}; + if ((doprocessXicplusWithDcaFitter + std::accumulate(doprocessKF.begin(), doprocessKF.end(), 0)) != 1) { LOGP(fatal, "Only one process function can be enabled at a time."); } - if ((std::accumulate(doprocessDF.begin(), doprocessDF.end(), 0) == 1) && fillHistograms) { + if ((doprocessXicplusWithDcaFitter == 1) && fillHistograms) { hVertexerType->Fill(aod::hf_cand::VertexerType::DCAFitter); } if ((std::accumulate(doprocessKF.begin(), doprocessKF.end(), 0) == 1) && fillHistograms) { @@ -126,20 +144,14 @@ struct HfCandidateCreatorXic { } } - using CascadesLinked = soa::Join; - using KFCascadesLinked = soa::Join; - using CascFull = soa::Join; - using KFCascFull = soa::Join; - - template - void runCreatorXicPlusWithDcaFitter(aod::Collisions const& collisions, - CandType const& rowsTrackIndexXicPlus, - CascadesLinked const&, - CascFull const& cascs, - TTracks const& tracks, - aod::BCsWithTimestamps const& bcWithTimeStamps) + void processXicplusWithDcaFitter(aod::Collisions const&, + aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, + CascadesLinked const&, + CascFull const&, + aod::TracksWCovDca const&, + aod::BCsWithTimestamps const&) { - // 3-prong vertex fitter + // initialize 3-prong vertex fitter o2::vertexing::DCAFitterN<3> df; df.setPropagateToPCA(propagateToPCA); df.setMaxR(maxR); @@ -151,13 +163,13 @@ struct HfCandidateCreatorXic { // loop over triplets of track indices for (const auto& rowTrackIndexXicPlus : rowsTrackIndexXicPlus) { - auto cascAodElement = rowTrackIndexXicPlus.template cascade_as(); + auto cascAodElement = rowTrackIndexXicPlus.cascade_as(); if (!cascAodElement.has_cascData()) - continue; - auto casc = cascAodElement.template cascData_as(); - auto track0 = rowTrackIndexXicPlus.template prong0_as(); - auto track1 = rowTrackIndexXicPlus.template prong1_as(); - //auto casc = rowTrackIndexXicPlus.template cascade_as(); + continue; + auto casc = cascAodElement.cascData_as(); + auto trackCharmBachelor0 = rowTrackIndexXicPlus.prong0_as(); + auto trackCharmBachelor1 = rowTrackIndexXicPlus.prong1_as(); + auto collision = rowTrackIndexXicPlus.collision(); // preselect cascade candidates if (doCascadePreselection) { @@ -169,37 +181,36 @@ struct HfCandidateCreatorXic { } } - //----------------accessing particles in the decay chain------------- - // cascade daughter - charged particle - auto trackPionFromXi = casc.template bachelor_as(); // pion <- xi track from TTracks table - // V0 daughters - auto trackV0PosDau = casc.template posTrack_as(); // p <- V0 track (positive track) from TTracks table - auto trackV0NegDau = casc.template negTrack_as(); // pion <- V0 track (negative track) from TTracks table - - // check that particles come from the same collision - if (rejDiffCollTrack) { - if (trackV0PosDau.collisionId() != trackV0NegDau.collisionId()) { - continue; - } - if (trackPionFromXi.collisionId() != trackV0PosDau.collisionId()) { - continue; - } + //----------------------Set the magnetic field from ccdb--------------------------------------- + /// The static instance of the propagator was already modified in the HFTrackIndexSkimCreator, + /// but this is not true when running on Run2 data/MC already converted into AO2Ds. + auto bc = collision.bc_as(); + if (runNumber != bc.runNumber()) { + LOG(info) << ">>>>>>>>>>>> Current run number: " << runNumber; + initCCDB(bc, runNumber, ccdb, isRun2 ? ccdbPathGrp : ccdbPathGrpMag, lut, isRun2); + bz = o2::base::Propagator::Instance()->getNominalBz(); + LOG(info) << ">>>>>>>>>>>> Magnetic field: " << bz; } + df.setBz(bz); - //--------------------------info of V0 track from LF-table--------------------------- + //----------------accessing particles in the decay chain------------- + auto trackPionFromXi = casc.bachelor_as(); // pion <- xi track from TracksWCovDca table + //auto trackV0PosDau = casc.posTrack_as(); // p <- V0 track (positive track) from TracksWCovDca table + //auto trackV0NegDau = casc.negTrack_as(); // pion <- V0 track (negative track) from TracksWCovDca table + + //--------------------------info of V0 and cascades track from LF-tables--------------------------- std::array vertexV0 = {casc.xlambda(), casc.ylambda(), casc.zlambda()}; std::array pVecV0 = {casc.pxlambda(), casc.pylambda(), casc.pzlambda()}; - - //-----------------------------info of cascade track from Lf-table------------------- std::array vertexCasc = {casc.x(), casc.y(), casc.z()}; std::array pVecCasc = {casc.px(), casc.py(), casc.pz()}; std::array covCasc = {0.}; + + //----------------create cascade track------------------------------------------------------------ constexpr int MomInd[6] = {9, 13, 14, 18, 19, 20}; // cov matrix elements for momentum component for (int i = 0; i < 6; i++) { covCasc[MomInd[i]] = casc.momentumCovMat()[i]; covCasc[i] = casc.positionCovMat()[i]; } - // create cascade track o2::track::TrackParCov trackCasc; if (trackPionFromXi.sign() > 0) { @@ -212,27 +223,16 @@ struct HfCandidateCreatorXic { trackCasc.setAbsCharge(1); trackCasc.setPID(o2::track::PID::XiMinus); - auto trackParVar0 = getTrackParCov(track0); - auto trackParVar1 = getTrackParCov(track1); - auto collision = rowTrackIndexXicPlus.collision(); - - /// Set the magnetic field from ccdb. - /// The static instance of the propagator was already modified in the HFTrackIndexSkimCreator, - /// but this is not true when running on Run2 data/MC already converted into AO2Ds. - auto bc = collision.template bc_as(); - if (runNumber != bc.runNumber()) { - LOG(info) << ">>>>>>>>>>>> Current run number: " << runNumber; - initCCDB(bc, runNumber, ccdb, isRun2 ? ccdbPathGrp : ccdbPathGrpMag, lut, isRun2); - bz = o2::base::Propagator::Instance()->getNominalBz(); - LOG(info) << ">>>>>>>>>>>> Magnetic field: " << bz; - } - df.setBz(bz); + //----------------------------fit SV and create XicPlus track------------------ + auto trackParCovCharmBachelor0 = getTrackParCov(trackCharmBachelor0); + auto trackParCovCharmBachelor1 = getTrackParCov(trackCharmBachelor1); // reconstruct the 3-prong secondary vertex - if (df.process(trackParVar0, trackParVar1, trackCasc) == 0) { + if (df.process(trackParCovCharmBachelor0, trackParCovCharmBachelor1, trackCasc) == 0) { continue; } + //----------------------------calculate physical properties----------------------- // set hfFlag int hfFlag = BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); int signXicPlus = casc.sign() < 0 ? +1 : -1; @@ -243,20 +243,20 @@ struct HfCandidateCreatorXic { auto covMatrixSV = df.calcPCACovMatrixFlat(); // get track momenta - trackParVar0 = df.getTrack(0); - trackParVar1 = df.getTrack(1); + trackParCovCharmBachelor0 = df.getTrack(0); + trackParCovCharmBachelor1 = df.getTrack(1); trackCasc = df.getTrack(2); std::array pVecXi; std::array pVecPi0; std::array pVecPi1; trackCasc.getPxPyPzGlo(pVecXi); - trackParVar0.getPxPyPzGlo(pVecPi0); - trackParVar1.getPxPyPzGlo(pVecPi1); + trackParCovCharmBachelor0.getPxPyPzGlo(pVecPi0); + trackParCovCharmBachelor1.getPxPyPzGlo(pVecPi1); // get parent track std::array pVec2Pi = RecoDecay::pVec(pVecPi0, pVecPi1); std::array pVecXicPlus = RecoDecay::pVec(pVecXi, pVecPi0, pVecPi1); - auto trackParCov2Pi = o2::dataformats::V0(df.getPCACandidatePos(), pVec2Pi, df.calcPCACovMatrixFlat(), trackParVar0, trackParVar1); + auto trackParCov2Pi = o2::dataformats::V0(df.getPCACandidatePos(), pVec2Pi, df.calcPCACovMatrixFlat(), trackParCovCharmBachelor0, trackParCovCharmBachelor1); auto trackParCovXicPlus = o2::dataformats::V0(df.getPCACandidatePos(), pVecXicPlus, df.calcPCACovMatrixFlat(), trackParCov2Pi, trackCasc); trackParCovXicPlus.getPxPyPzGlo(pVecXicPlus); @@ -264,29 +264,13 @@ struct HfCandidateCreatorXic { // This modifies track momenta! auto primaryVertex = getPrimaryVertex(collision); auto covMatrixPV = primaryVertex.getCov(); - if constexpr (doPvRefit) { - /// use PV refit - /// Using it in the rowCandidateBase all dynamic columns shall take it into account - // coordinates - primaryVertex.setX(rowTrackIndexXicPlus.pvRefitX()); - primaryVertex.setY(rowTrackIndexXicPlus.pvRefitY()); - primaryVertex.setZ(rowTrackIndexXicPlus.pvRefitZ()); - // covariance matrix - primaryVertex.setSigmaX2(rowTrackIndexXicPlus.pvRefitSigmaX2()); - primaryVertex.setSigmaXY(rowTrackIndexXicPlus.pvRefitSigmaXY()); - primaryVertex.setSigmaY2(rowTrackIndexXicPlus.pvRefitSigmaY2()); - primaryVertex.setSigmaXZ(rowTrackIndexXicPlus.pvRefitSigmaXZ()); - primaryVertex.setSigmaYZ(rowTrackIndexXicPlus.pvRefitSigmaYZ()); - primaryVertex.setSigmaZ2(rowTrackIndexXicPlus.pvRefitSigmaZ2()); - covMatrixPV = primaryVertex.getCov(); - } // calculate impact parameter o2::dataformats::DCA impactParameter0; o2::dataformats::DCA impactParameter1; o2::dataformats::DCA impactParameterCasc; trackCasc.propagateToDCA(primaryVertex, bz, &impactParameterCasc); - trackParVar0.propagateToDCA(primaryVertex, bz, &impactParameter0); - trackParVar1.propagateToDCA(primaryVertex, bz, &impactParameter1); + trackParCovCharmBachelor0.propagateToDCA(primaryVertex, bz, &impactParameter0); + trackParCovCharmBachelor1.propagateToDCA(primaryVertex, bz, &impactParameter1); // calculate cosine of pointing angle std::array pvCoord = {collision.posX(), collision.posY(), collision.posZ()}; @@ -305,7 +289,7 @@ struct HfCandidateCreatorXic { auto errorDecayLength = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, theta) + getRotatedCovMatrixXX(covMatrixSV, phi, theta)); auto errorDecayLengthXY = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, 0.) + getRotatedCovMatrixXX(covMatrixSV, phi, 0.)); - // fill histograms + //--------------------------------------------fill histograms---------------------------------------------------------------- if (fillHistograms) { // invariant mass hMass3->Fill(massXiPiPi); @@ -320,15 +304,15 @@ struct HfCandidateCreatorXic { hCovSVXZ->Fill(covMatrixSV[3]); hCovSVZZ->Fill(covMatrixSV[5]); // DCAs of prongs - hDcaXYProngs->Fill(track0.pt(), impactParameter0.getY()); - hDcaXYProngs->Fill(track1.pt(), impactParameter1.getY()); + hDcaXYProngs->Fill(trackCharmBachelor0.pt(), impactParameter0.getY()); + hDcaXYProngs->Fill(trackCharmBachelor1.pt(), impactParameter1.getY()); hDcaXYProngs->Fill(trackCasc.getPt(), impactParameterCasc.getY()); - hDcaZProngs->Fill(track0.pt(), impactParameter0.getZ()); - hDcaZProngs->Fill(track1.pt(), impactParameter1.getZ()); + hDcaZProngs->Fill(trackCharmBachelor0.pt(), impactParameter0.getZ()); + hDcaZProngs->Fill(trackCharmBachelor1.pt(), impactParameter1.getZ()); hDcaZProngs->Fill(trackCasc.getPt(), impactParameterCasc.getZ()); } - // fill candidate table rows + //---------------------------------fill candidate table rows------------------------------------------------------------------------------------------- rowCandidateBase(collision.globalIndex(), primaryVertex.getX(), primaryVertex.getY(), primaryVertex.getZ(), covMatrixPV[0], covMatrixPV[2], covMatrixPV[5], @@ -342,7 +326,7 @@ struct HfCandidateCreatorXic { pVecXi[0], pVecXi[1], pVecXi[2], pVecPi0[0], pVecPi0[1], pVecPi0[2], pVecPi1[0], pVecPi1[1], pVecPi1[2], - impactParameterCasc.getY(), impactParameter0.getY(), impactParameter1.getY(), + impactParameterCasc.getY(), impactParameter0.getY(), impactParameter1.getY(), std::sqrt(impactParameterCasc.getSigmaY2()), std::sqrt(impactParameter0.getSigmaY2()), std::sqrt(impactParameter1.getSigmaY2()), hfFlag, /*cascade specific columns*/ @@ -350,36 +334,27 @@ struct HfCandidateCreatorXic { vertexV0[0], vertexV0[1], vertexV0[2], cpaXi, cpaXYXi, cpaLambda, cpaXYLambda); } // loop over track triplets - } // template - - template - void runCreatorXicPlusWithKFParticle(aod::Collisions const& collisions, - CandType const& rowsTrackIndexXicPlus, - KFCascadesLinked const&, - KFCascFull const&, - TTracks const& tracks, - aod::BCsWithTimestamps const& bcWithTimeStamps) + } + PROCESS_SWITCH(HfCandidateCreatorXic, processXicplusWithDcaFitter, "Run candidate creator with DCAFitter.", false); + + void processXicplusWithKFParticleFromDerivedData(aod::Collisions const&, + aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, + KFCascadesLinked const&, + KFCascFull const&, + aod::TracksWCovExtra const&, + aod::BCsWithTimestamps const&) { // loop over triplets of track indices for (const auto& rowTrackIndexXicPlus : rowsTrackIndexXicPlus) { - auto cascAodElement = rowTrackIndexXicPlus.template cascade_as(); + auto cascAodElement = rowTrackIndexXicPlus.cascade_as(); if (!cascAodElement.has_kfCascData()) - continue; - auto casc = cascAodElement.template kfCascData_as(); - //auto casc = rowTrackIndexXicPlus.template cascade_as(); - auto track0 = rowTrackIndexXicPlus.template prong0_as(); - auto track1 = rowTrackIndexXicPlus.template prong1_as(); + continue; + auto casc = cascAodElement.kfCascData_as(); + auto trackCharmBachelor0 = rowTrackIndexXicPlus.prong0_as(); + auto trackCharmBachelor1 = rowTrackIndexXicPlus.prong1_as(); auto collision = rowTrackIndexXicPlus.collision(); - //--------------------------info of V0 track from LF-table--------------------------- - std::array vertexV0 = {casc.xlambda(), casc.ylambda(), casc.zlambda()}; - std::array pVecV0 = {casc.pxlambda(), casc.pylambda(), casc.pzlambda()}; - - //-----------------------------info of cascade track from Lf-table------------------- - std::array vertexCasc = {casc.x(), casc.y(), casc.z()}; - std::array pVecCasc = {casc.px(), casc.py(), casc.pz()}; - - // preselect cascade candidates + //-------------------preselect cascade candidates-------------------------------------- if (doCascadePreselection) { if (std::abs(casc.dcaXYCascToPV()) > dcaXYToPVCascadeMax) { continue; @@ -389,10 +364,10 @@ struct HfCandidateCreatorXic { } } - /// Set the magnetic field from ccdb. + //----------------------Set the magnetic field from ccdb----------------------------- /// The static instance of the propagator was already modified in the HFTrackIndexSkimCreator, /// but this is not true when running on Run2 data/MC already converted into AO2Ds. - auto bc = collision.template bc_as(); + auto bc = collision.bc_as(); if (runNumber != bc.runNumber()) { LOG(info) << ">>>>>>>>>>>> Current run number: " << runNumber; initCCDB(bc, runNumber, ccdb, isRun2 ? ccdbPathGrp : ccdbPathGrpMag, lut, isRun2); @@ -401,21 +376,24 @@ struct HfCandidateCreatorXic { } KFParticle::SetField(bz); + //----------------------info of V0 and cascade tracks from LF-table------------------ + 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 XicPlus as KFParticle object------------------------------------------- // initialize primary vertex KFPVertex kfpVertex = createKFPVertexFromCollision(collision); float covMatrixPV[6]; - if constexpr (doPvRefit) { - kfpVertex.SetXYZ(rowTrackIndexXicPlus.pvRefitX(), rowTrackIndexXicPlus.pvRefitY(), rowTrackIndexXicPlus.pvRefitZ()); - kfpVertex.SetCovarianceMatrix(rowTrackIndexXicPlus.pvRefitSigmaX2(), rowTrackIndexXicPlus.pvRefitSigmaXY(), rowTrackIndexXicPlus.pvRefitSigmaY2(), rowTrackIndexXicPlus.pvRefitSigmaXZ(), rowTrackIndexXicPlus.pvRefitSigmaYZ(), rowTrackIndexXicPlus.pvRefitSigmaZ2()); - } kfpVertex.GetCovarianceMatrix(covMatrixPV); KFParticle KFPV(kfpVertex); // for calculation of DCAs to PV // convert pion tracks into KFParticle object - KFPTrack kfpTrack0 = createKFPTrackFromTrack(track0); - KFPTrack kfpTrack1 = createKFPTrackFromTrack(track1); - KFParticle kfPion0(kfpTrack0, kPiPlus); - KFParticle kfPion1(kfpTrack1, kPiPlus); + KFPTrack kfpTrackCharmBachelor0 = createKFPTrackFromTrack(trackCharmBachelor0); + KFPTrack kfpTrackCharmBachelor1 = createKFPTrackFromTrack(trackCharmBachelor1); + KFParticle kfCharmBachelor0(kfpTrackCharmBachelor0, kPiPlus); + KFParticle kfCharmBachelor1(kfpTrackCharmBachelor1, kPiPlus); // create Xi as KFParticle object // read {X,Y,Z,Px,Py,Pz} and corresponding covariance matrix from KF cascade Tables @@ -430,9 +408,15 @@ struct HfCandidateCreatorXic { // create XicPlus as KFParticle object KFParticle kfXicPlus; - const KFParticle* kfDaughtersXicPlus[3] = {&kfPion0, &kfPion1, &kfXi}; - kfXicPlus.SetConstructMethod(0); // 0: no mass constraint, 2: mass constraint - kfXicPlus.Construct(kfDaughtersXicPlus, 3); + const KFParticle* kfDaughtersXicPlus[3] = {&kfCharmBachelor0, &kfCharmBachelor1, &kfXi}; + kfXicPlus.SetConstructMethod(kfConstructMethod); + try { + kfXicPlus.Construct(kfDaughtersXicPlus, 3); + } catch (std::runtime_error& e) { + LOG(debug) << "Failed to construct XicPlus : " << e.what(); + continue; + } + // topological constraint if (constrainXicPlusToPv) { kfXicPlus.SetProductionVertex(KFPV); @@ -440,10 +424,11 @@ struct HfCandidateCreatorXic { auto covMatrixXicPlus = kfXicPlus.CovarianceMatrix(); // transport daughter particles to XicPlus decay vertex - kfPion0.TransportToParticle(kfXicPlus); - kfPion1.TransportToParticle(kfXicPlus); + kfCharmBachelor0.TransportToParticle(kfXicPlus); + kfCharmBachelor1.TransportToParticle(kfXicPlus); kfXi.TransportToParticle(kfXicPlus); + //---------------------calculate physical parameters of XicPlus candidate---------------------- // set hfFlag int hfFlag = BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); int signXicPlus = casc.sign() < 0 ? +1 : -1; @@ -452,8 +437,8 @@ struct HfCandidateCreatorXic { float impactParameterPi0XY = 0., errImpactParameterPi0XY = 0.; float impactParameterPi1XY = 0., errImpactParameterPi1XY = 0.; float impactParameterXiXY = 0., errImpactParameterXiXY = 0.; - kfPion0.GetDistanceFromVertexXY(KFPV, impactParameterPi0XY, errImpactParameterPi0XY); - kfPion1.GetDistanceFromVertexXY(KFPV, impactParameterPi1XY, errImpactParameterPi1XY); + kfCharmBachelor0.GetDistanceFromVertexXY(KFPV, impactParameterPi0XY, errImpactParameterPi0XY); + kfCharmBachelor1.GetDistanceFromVertexXY(KFPV, impactParameterPi1XY, errImpactParameterPi1XY); kfXi.GetDistanceFromVertexXY(KFPV, impactParameterXiXY, errImpactParameterXiXY); // calculate cosine of pointing angle @@ -464,11 +449,11 @@ struct HfCandidateCreatorXic { double cpaXYXi = RecoDecay::cpaXY(pvCoord, vertexCasc, pVecCasc); // get DCAs of Pi0-Pi1, Pi0-Xi, Pi1-Xi - float dcaXYPi0Pi1 = kfPion0.GetDistanceFromParticleXY(kfPion1); - float dcaXYPi0Xi = kfPion0.GetDistanceFromParticleXY(kfXi); - float dcaXYPi1Xi = kfPion1.GetDistanceFromParticleXY(kfXi); + float dcaXYPi0Pi1 = kfCharmBachelor0.GetDistanceFromParticleXY(kfCharmBachelor1); + float dcaXYPi0Xi = kfCharmBachelor0.GetDistanceFromParticleXY(kfXi); + float dcaXYPi1Xi = kfCharmBachelor1.GetDistanceFromParticleXY(kfXi); - // fill histograms + //-------------------------------fill histograms-------------------------------------------- if (fillHistograms) { // invariant mass hMass3->Fill(kfXicPlus.GetMass()); @@ -483,14 +468,15 @@ struct HfCandidateCreatorXic { hCovSVXZ->Fill(covMatrixXicPlus[3]); hCovSVZZ->Fill(covMatrixXicPlus[5]); // DCAs of prongs - hDcaXYProngs->Fill(kfPion0.GetPt(), impactParameterPi0XY); - hDcaXYProngs->Fill(kfPion1.GetPt(), impactParameterPi1XY); + hDcaXYProngs->Fill(kfCharmBachelor0.GetPt(), impactParameterPi0XY); + hDcaXYProngs->Fill(kfCharmBachelor1.GetPt(), impactParameterPi1XY); hDcaXYProngs->Fill(kfXi.GetPt(), impactParameterXiXY); } - // fill candidate table rows + + //------------------------------fill candidate table rows-------------------------------------- rowCandidateBase(collision.globalIndex(), KFPV.GetX(), KFPV.GetY(), KFPV.GetZ(), - covMatrixPV[0], covMatrixPV[2],covMatrixPV[5], + covMatrixPV[0], covMatrixPV[2], covMatrixPV[5], /*3-prong specific columns*/ rowTrackIndexXicPlus.cascadeId(), rowTrackIndexXicPlus.prong0Id(), rowTrackIndexXicPlus.prong1Id(), casc.bachelorId(), casc.posTrackId(), casc.negTrackId(), @@ -499,8 +485,8 @@ struct HfCandidateCreatorXic { kfXicPlus.GetErrDecayLength(), kfXicPlus.GetErrDecayLengthXY(), kfXicPlus.GetChi2(), kfXicPlus.GetMass(), signXicPlus, kfXi.GetPx(), kfXi.GetPy(), kfXi.GetPz(), - kfPion0.GetPx(), kfPion0.GetPy(), kfPion0.GetPz(), - kfPion1.GetPx(), kfPion1.GetPy(), kfPion1.GetPz(), + kfCharmBachelor0.GetPx(), kfCharmBachelor0.GetPy(), kfCharmBachelor0.GetPz(), + kfCharmBachelor1.GetPx(), kfCharmBachelor1.GetPy(), kfCharmBachelor1.GetPz(), impactParameterXiXY, impactParameterPi0XY, impactParameterPi1XY, errImpactParameterXiXY, errImpactParameterPi0XY, errImpactParameterPi1XY, hfFlag, @@ -511,55 +497,235 @@ struct HfCandidateCreatorXic { rowCandidateKF(casc.kfV0Chi2(), casc.kfCascadeChi2(), dcaXYPi0Pi1, dcaXYPi0Xi, dcaXYPi1Xi); } // loop over track triplets - } // template - - void processPvRefitWithDCAFitterN(aod::Collisions const& collisions, - soa::Join const& rowsTrackIndexXicPlus, - CascadesLinked const& cascsLinked, - CascFull const& cascs, - aod::TracksWCovDca const& tracks, - aod::BCsWithTimestamps const& bcWithTimeStamps) - { - runCreatorXicPlusWithDcaFitter(collisions, rowsTrackIndexXicPlus, cascsLinked, cascs, tracks, bcWithTimeStamps); - } - PROCESS_SWITCH(HfCandidateCreatorXic, processPvRefitWithDCAFitterN, "Run candidate creator with PV refit", false); - - void processNoPvRefitWithDCAFitterN(aod::Collisions const& collisions, - aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, - CascadesLinked const& cascsLinked, - CascFull const& cascs, - aod::TracksWCovDca const& tracks, - aod::BCsWithTimestamps const& bcWithTimeStamps) - { - runCreatorXicPlusWithDcaFitter(collisions, rowsTrackIndexXicPlus, cascsLinked, cascs, tracks, bcWithTimeStamps); } - PROCESS_SWITCH(HfCandidateCreatorXic, processNoPvRefitWithDCAFitterN, "Run candidate creator without PV refit", true); - - void processPvRefitWithKFParticle(aod::Collisions const& collisions, - soa::Join const& rowsTrackIndexXicPlus, - KFCascadesLinked const& cascsLinked, - KFCascFull const& cascs, - aod::TracksWCovExtra const& tracks, - aod::BCsWithTimestamps const& bcWithTimeStamps) + PROCESS_SWITCH(HfCandidateCreatorXic, processXicplusWithKFParticleFromDerivedData, "Run candidate creator with KFParticle using derived data from HfTrackIndexSkimCreatorLfCascades.", true); + + void processXicplusWithKFParticle(SelectedCollisions const& collisions, + SelectedHfTrackAssoc const& trackIndices, + KFCascadesLinked const& linkedCascades, + KFCascFull const&, + aod::TracksWCovExtra const&, + aod::BCsWithTimestamps const&) { - runCreatorXicPlusWithKFParticle(collisions, rowsTrackIndexXicPlus, cascsLinked, cascs, tracks, bcWithTimeStamps); - } - PROCESS_SWITCH(HfCandidateCreatorXic, processPvRefitWithKFParticle, "Run candidate creator with PV refit", false); - - void processNoPvRefitWithKFParticle(aod::Collisions const& collisions, - aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, - KFCascadesLinked const& cascsLinked, - KFCascFull const& cascs, - aod::TracksWCovExtra const& tracks, - aod::BCsWithTimestamps const& bcWithTimeStamps) - { - runCreatorXicPlusWithKFParticle(collisions, rowsTrackIndexXicPlus, cascsLinked, cascs, tracks, bcWithTimeStamps); + for (const auto& collision : collisions) { + //------------------------- Set the magnetic field from ccdb--------------------------------- + /// The static instance of the propagator was already modified in the HFTrackIndexSkimCreator, + /// but this is not true when running on Run2 data/MC already converted into AO2Ds. + auto bc = collision.bc_as(); + if (runNumber != bc.runNumber()) { + LOG(info) << ">>>>>>>>>>>> Current run number: " << runNumber; + initCCDB(bc, runNumber, ccdb, isRun2 ? ccdbPathGrp : ccdbPathGrpMag, lut, isRun2); + bz = o2::base::Propagator::Instance()->getNominalBz(); + LOG(info) << ">>>>>>>>>>>> Magnetic field: " << bz; + } + KFParticle::SetField(bz); + + // ------------------------------------cascade loop------------------------------------------- + auto thisCollId = collision.globalIndex(); + // auto groupedCascades = cascades.sliceBy(cascadesPerCollision, thisCollId); + auto groupedLinkedCascades = linkedCascades.sliceBy(linkedCascadesPerCollision, thisCollId); + for (const auto& linkedCasc : groupedLinkedCascades) { + if (!linkedCasc.has_kfCascData()) { + continue; + } + auto casc = linkedCasc.kfCascData_as(); + + //----------------accessing particles in the decay chain------------- + // cascade daughter - charged particle + auto trackCascDauCharged = casc.bachelor_as(); // meson <- xi track + // cascade daughter - V0 + auto trackV0PosDau = casc.posTrack_as(); // p <- V0 track (positive track) 0 + // V0 negative daughter + auto trackV0NegDau = casc.negTrack_as(); // pion <- V0 track (negative track) 1 + + // check that particles come from the same collision + if (rejDiffCollTrack) { + if (trackV0PosDau.collisionId() != trackV0NegDau.collisionId()) { + continue; + } + if (trackCascDauCharged.collisionId() != trackV0PosDau.collisionId()) { + continue; + } + } + // check not to take cascade daughters twice + if (trackV0PosDau.globalIndex() == trackV0NegDau.globalIndex() || trackV0PosDau.globalIndex() == trackCascDauCharged.globalIndex() || trackV0NegDau.globalIndex() == trackCascDauCharged.globalIndex()) { + continue; + } + + // preselect cascade candidates + if (doCascadePreselection) { + if (std::abs(casc.dcaXYCascToPV()) > dcaXYToPVCascadeMax) { + continue; + } + if (std::abs(casc.mXi() - massXiMinusFromPdg) > massToleranceCascade) { + continue; + } + } + + //--------------------------------------loop over first bachelor----------------------------------------------------- + auto groupedBachTrackIndices = trackIndices.sliceBy(trackIndicesPerCollision, thisCollId); + for (auto trackIdCharmBachelor0 = groupedBachTrackIndices.begin(); trackIdCharmBachelor0 != groupedBachTrackIndices.end(); ++trackIdCharmBachelor0) { + auto trackCharmBachelor0 = trackIdCharmBachelor0.track_as(); + + // check that particles come from the same collision + if ((rejDiffCollTrack) && (trackCascDauCharged.collisionId() != trackCharmBachelor0.collisionId())) { + continue; + } + // ask for opposite sign daughters + if (trackCharmBachelor0.sign() * trackCascDauCharged.sign() >= 0) { + continue; + } + // check not to take the same particle twice in the decay chain + if (trackCharmBachelor0.globalIndex() == trackCascDauCharged.globalIndex() || trackCharmBachelor0.globalIndex() == trackV0PosDau.globalIndex() || trackCharmBachelor0.globalIndex() == trackV0NegDau.globalIndex()) { + continue; + } + + //-----------------------------------------------loop over second bachelor--------------------------------------------------------------------------- + for (auto trackIdCharmBachelor1 = trackIdCharmBachelor0 + 1; trackIdCharmBachelor1 != groupedBachTrackIndices.end(); ++trackIdCharmBachelor1) { + auto trackCharmBachelor1 = trackIdCharmBachelor1.track_as(); + // check that particles come from the same collision + if ((rejDiffCollTrack) && (trackCascDauCharged.collisionId() != trackCharmBachelor1.collisionId())) { + continue; + } + // ask for same sign daughters + if (trackCharmBachelor1.sign() * trackCharmBachelor0.sign() <= 0) { + continue; + } + // check not to take the same particle twice in the decay chain + if (trackCharmBachelor1.globalIndex() == trackCharmBachelor0.globalIndex() || trackCharmBachelor1.globalIndex() == trackCascDauCharged.globalIndex() || trackCharmBachelor1.globalIndex() == trackV0PosDau.globalIndex() || trackCharmBachelor1.globalIndex() == trackV0NegDau.globalIndex()) { + continue; + } + + //----------------------info of V0 and cascade tracks from LF-table------------------ + 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 XicPlus as KFParticle object------------------------------------------- + // initialize primary vertex + KFPVertex kfpVertex = createKFPVertexFromCollision(collision); + float covMatrixPV[6]; + kfpVertex.GetCovarianceMatrix(covMatrixPV); + KFParticle KFPV(kfpVertex); // for calculation of DCAs to PV + + // convert pion tracks into KFParticle object + KFPTrack kfpTrackCharmBachelor0 = createKFPTrackFromTrack(trackCharmBachelor0); + KFPTrack kfpTrackCharmBachelor1 = createKFPTrackFromTrack(trackCharmBachelor1); + KFParticle kfCharmBachelor0(kfpTrackCharmBachelor0, kPiPlus); + KFParticle kfCharmBachelor1(kfpTrackCharmBachelor1, kPiPlus); + + // create Xi as KFParticle object + // read {X,Y,Z,Px,Py,Pz} and corresponding covariance matrix from KF cascade Tables + std::array xyzpxpypz = {casc.x(), casc.y(), casc.z(), casc.px(), casc.py(), casc.pz()}; + float parPosMom[6]; + for (int i{0}; i < 6; ++i) { + parPosMom[i] = xyzpxpypz[i]; + } + // create KFParticle + KFParticle kfXi; + kfXi.Create(parPosMom, casc.kfTrackCovMat(), casc.sign(), casc.mXi()); + + // create XicPlus as KFParticle object + KFParticle kfXicPlus; + const KFParticle* kfDaughtersXicPlus[3] = {&kfCharmBachelor0, &kfCharmBachelor1, &kfXi}; + kfXicPlus.SetConstructMethod(kfConstructMethod); + try { + kfXicPlus.Construct(kfDaughtersXicPlus, 3); + } catch (std::runtime_error& e) { + LOG(debug) << "Failed to construct XicPlus : " << e.what(); + continue; + } + + // topological constraint + if (constrainXicPlusToPv) { + kfXicPlus.SetProductionVertex(KFPV); + } + auto covMatrixXicPlus = kfXicPlus.CovarianceMatrix(); + + // transport daughter particles to XicPlus decay vertex + kfCharmBachelor0.TransportToParticle(kfXicPlus); + kfCharmBachelor1.TransportToParticle(kfXicPlus); + kfXi.TransportToParticle(kfXicPlus); + + //---------------------calculate physical parameters of XicPlus candidate---------------------- + // set hfFlag + int hfFlag = BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); + int signXicPlus = casc.sign() < 0 ? +1 : -1; + + // get impact parameters of XicPlus daughters + float impactParameterPi0XY = 0., errImpactParameterPi0XY = 0.; + float impactParameterPi1XY = 0., errImpactParameterPi1XY = 0.; + float impactParameterXiXY = 0., errImpactParameterXiXY = 0.; + kfCharmBachelor0.GetDistanceFromVertexXY(KFPV, impactParameterPi0XY, errImpactParameterPi0XY); + kfCharmBachelor1.GetDistanceFromVertexXY(KFPV, impactParameterPi1XY, errImpactParameterPi1XY); + kfXi.GetDistanceFromVertexXY(KFPV, impactParameterXiXY, errImpactParameterXiXY); + + // calculate cosine of pointing angle + std::array pvCoord = {collision.posX(), collision.posY(), collision.posZ()}; + double cpaLambda = casc.v0cosPA(collision.posX(), collision.posY(), collision.posZ()); + double cpaXYLambda = RecoDecay::cpaXY(pvCoord, vertexV0, pVecV0); + double cpaXi = casc.casccosPA(collision.posX(), collision.posY(), collision.posZ()); + double cpaXYXi = RecoDecay::cpaXY(pvCoord, vertexCasc, pVecCasc); + + // get DCAs of Pi0-Pi1, Pi0-Xi, Pi1-Xi + float dcaXYPi0Pi1 = kfCharmBachelor0.GetDistanceFromParticleXY(kfCharmBachelor1); + float dcaXYPi0Xi = kfCharmBachelor0.GetDistanceFromParticleXY(kfXi); + float dcaXYPi1Xi = kfCharmBachelor1.GetDistanceFromParticleXY(kfXi); + + //-------------------------------fill histograms-------------------------------------------- + if (fillHistograms) { + // invariant mass + hMass3->Fill(kfXicPlus.GetMass()); + // covariance matrix elements of PV + hCovPVXX->Fill(covMatrixPV[0]); + hCovPVYY->Fill(covMatrixPV[2]); + hCovPVXZ->Fill(covMatrixPV[3]); + hCovPVZZ->Fill(covMatrixPV[5]); + // covariance matrix elements of SV + hCovSVXX->Fill(covMatrixXicPlus[0]); + hCovSVYY->Fill(covMatrixXicPlus[2]); + hCovSVXZ->Fill(covMatrixXicPlus[3]); + hCovSVZZ->Fill(covMatrixXicPlus[5]); + // DCAs of prongs + hDcaXYProngs->Fill(kfCharmBachelor0.GetPt(), impactParameterPi0XY); + hDcaXYProngs->Fill(kfCharmBachelor1.GetPt(), impactParameterPi1XY); + hDcaXYProngs->Fill(kfXi.GetPt(), impactParameterXiXY); + } + + //------------------------------fill candidate table rows-------------------------------------- + rowCandidateBase(collision.globalIndex(), + KFPV.GetX(), KFPV.GetY(), KFPV.GetZ(), + covMatrixPV[0], covMatrixPV[2], covMatrixPV[5], + /*3-prong specific columns*/ + casc.cascadeId(), trackCharmBachelor0.globalIndex(), trackCharmBachelor1.globalIndex(), + casc.bachelorId(), casc.posTrackId(), casc.negTrackId(), + kfXicPlus.GetX(), kfXicPlus.GetY(), kfXicPlus.GetZ(), + kfXicPlus.GetErrX(), kfXicPlus.GetErrY(), kfXicPlus.GetErrZ(), + kfXicPlus.GetErrDecayLength(), kfXicPlus.GetErrDecayLengthXY(), + kfXicPlus.GetChi2(), kfXicPlus.GetMass(), signXicPlus, + kfXi.GetPx(), kfXi.GetPy(), kfXi.GetPz(), + kfCharmBachelor0.GetPx(), kfCharmBachelor0.GetPy(), kfCharmBachelor0.GetPz(), + kfCharmBachelor1.GetPx(), kfCharmBachelor1.GetPy(), kfCharmBachelor1.GetPz(), + impactParameterXiXY, impactParameterPi0XY, impactParameterPi1XY, + errImpactParameterXiXY, errImpactParameterPi0XY, errImpactParameterPi1XY, + hfFlag, + /*cascade specific columns*/ + casc.x(), casc.y(), casc.z(), + casc.xlambda(), casc.ylambda(), casc.zlambda(), + cpaXi, cpaXYXi, cpaLambda, cpaXYLambda); + rowCandidateKF(casc.kfV0Chi2(), casc.kfCascadeChi2(), + dcaXYPi0Pi1, dcaXYPi0Xi, dcaXYPi1Xi); + } // bachelor 1 + } // bachelor 0 + } // cascades + } // collisions } - PROCESS_SWITCH(HfCandidateCreatorXic, processNoPvRefitWithKFParticle, "Run candidate creator without PV refit", false); + PROCESS_SWITCH(HfCandidateCreatorXic, processXicplusWithKFParticle, "Run candidate creator with KFParticle", false); }; // struct /// Performs MC matching. -struct HfCandidateCreatorXicMc { +struct HfCandidateCreatorXicExpressions { Spawns rowCandidateXic; Produces rowMcMatchRec; Produces rowMcMatchGen; @@ -581,7 +747,7 @@ struct HfCandidateCreatorXicMc { int pdgCodeXicPlus = Pdg::kXiCPlus; // 4232 int pdgCodeXiMinus = kXiMinus; // 3312 - int pdgCodeXiRes = 3324 // 3324 + int pdgCodeXiRes = 3324; // 3324 int pdgCodeLambda = kLambda0; // 3122 int pdgCodePiPlus = kPiPlus; // 211 int pdgCodePiMinus = kPiMinus; // -211 @@ -594,18 +760,18 @@ struct HfCandidateCreatorXicMc { origin = RecoDecay::OriginType::None; debug = 0; - auto arrayDaughters = std::array{candidate.pi0_as(), // pi <- Xic - candidate.pi1_as(), // pi <- Xic - candidate.bachelor_as(), // pi <- cascade - candidate.posTrack_as(), // p <- lambda - candidate.negTrack_as()}; // pi <- lambda + auto arrayDaughters = std::array{candidate.pi0_as(), // pi <- Xic + candidate.pi1_as(), // pi <- Xic + candidate.bachelor_as(), // pi <- cascade + candidate.posTrack_as(), // p <- lambda + candidate.negTrack_as()}; // pi <- lambda auto arrayDaughtersResPi0 = std::array{candidate.cascade_as(), candidate.pi0_as()}; auto arrayDaughtersResPi1 = std::array{candidate.cascade_as(), - candidate.pi1_as()}; + candidate.pi1_as()}; auto arrayDaughtersCasc = std::array{candidate.bachelor_as(), candidate.posTrack_as(), - candidate.negTrack_as()}; + candidate.negTrack_as()}; auto arrayDaughtersV0 = std::array{candidate.posTrack_as(), candidate.negTrack_as()}; @@ -628,7 +794,7 @@ struct HfCandidateCreatorXicMc { debug = 3; } if (indexRec > -1) { - //Xic → Xi(1530) pi + // Xic → Xi(1530) pi indexRes = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughtersResPi0, pdgCodeXicPlus, std::array{pdgCodeXiRes, pdgCodePiMinus}, true, &sign, 1); if (indexRes > -1) { flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi); @@ -636,7 +802,7 @@ struct HfCandidateCreatorXicMc { indexRes = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughtersResPi1, pdgCodeXicPlus, std::array{pdgCodeXiRes, pdgCodePiMinus}, true, &sign, 1); if (indexRes > -1) { flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi); - } else if (indexRes ==-1) { + } else if (indexRes == -1) { flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); } } @@ -688,12 +854,12 @@ struct HfCandidateCreatorXicMc { rowMcMatchGen(flag, debug, origin); } // close loop over generated particles } // close process - PROCESS_SWITCH(HfCandidateCreatorXicMc, processMc, "Process MC", false); + PROCESS_SWITCH(HfCandidateCreatorXicExpressions, processMc, "Process MC", false); }; // close struct WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{ adaptAnalysisTask(cfgc), - adaptAnalysisTask(cfgc)}; + adaptAnalysisTask(cfgc)}; } diff --git a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx index e2fab62a090..17e036a4af5 100644 --- a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx @@ -36,6 +36,17 @@ struct HfCandidateSelectorXicToXiPiPi { Configurable ptCandMin{"ptCandMin", 0., "Lower bound of candidate pT"}; Configurable ptCandMax{"ptCandMax", 36., "Upper bound of candidate pT"}; + // topological cuts + Configurable> binsPt{"binsPt", std::vector{hf_cuts_xic_to_xi_pi_pi::vecBinsPt}, "pT bin limits"}; + Configurable> cuts{"cuts", {hf_cuts_xic_to_xi_pi_pi::cuts[0], hf_cuts_xic_to_xi_pi_pi::nBinsPt, hf_cuts_xic_to_xi_pi_pi::nCutVars, hf_cuts_xic_to_xi_pi_pi::labelsPt, hf_cuts_xic_to_xi_pi_pi::labelsCutVar}, "Xicplus candidate selection per pT bin"}; + // QA switch + Configurable activateQA{"activateQA", false, "Flag to enable QA histogram"}; + // CCDB configuration + Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; + Configurable> modelPathsCCDB{"modelPathsCCDB", std::vector{"EventFiltering/PWGHF/BDTXic"}, "Paths of models on CCDB"}; + Configurable> onnxFileNames{"onnxFilesCCDB", std::vector{"ModelHandler_onnx_XicTOXiPiPi.onnx"}, "ONNX file names on CCDB 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"}; // Enable PID Configurable usePid{"usePid", true, "Switch for PID selection at track level"}; Configurable acceptPIDNotApplicable{"acceptPIDNotApplicable", true, "Switch to accept Status::NotApplicable [(NotApplicable for one detector) and (NotApplicable or Conditional for the other)] in PID selection"}; @@ -49,23 +60,12 @@ struct HfCandidateSelectorXicToXiPiPi { Configurable ptPidTofMax{"ptPidTofMax", 20., "Upper bound of track pT for TOF PID"}; Configurable nSigmaTofMax{"nSigmaTofMax", 5., "Nsigma cut on TOF only"}; Configurable nSigmaTofCombinedMax{"nSigmaTofCombinedMax", 5., "Nsigma cut on TOF combined with TPC"}; - // topological cuts - Configurable> binsPt{"binsPt", std::vector{hf_cuts_xic_to_xi_pi_pi::vecBinsPt}, "pT bin limits"}; - Configurable> cuts{"cuts", {hf_cuts_xic_to_xi_pi_pi::cuts[0], hf_cuts_xic_to_xi_pi_pi::nBinsPt, hf_cuts_xic_to_xi_pi_pi::nCutVars, hf_cuts_xic_to_xi_pi_pi::labelsPt, hf_cuts_xic_to_xi_pi_pi::labelsCutVar}, "Bs candidate selection per pT bin"}; - // QA switch - Configurable activateQA{"activateQA", false, "Flag to enable QA histogram"}; // 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"}; Configurable> cutDirMl{"cutDirMl", std::vector{hf_cuts_ml::vecCutDir}, "Whether to reject score values greater or smaller than the threshold"}; 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", (int8_t)hf_cuts_ml::nCutScores, "Number of classes in ML model"}; - // CCDB configuration - Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; - Configurable> modelPathsCCDB{"modelPathsCCDB", std::vector{"EventFiltering/PWGHF/BDTXic"}, "Paths of models on CCDB"}; - Configurable> onnxFileNames{"onnxFilesCCDB", std::vector{"ModelHandler_onnx_XicTOXiPiPi.onnx"}, "ONNX file names on CCDB 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"}; o2::analysis::HfMlResponse hfMlResponse; std::vector outputMl = {}; diff --git a/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx index 0989734e87f..6c95abfdf00 100644 --- a/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx @@ -14,9 +14,6 @@ /// /// \author Phil Lennart Stahlhut , CERN -// include directives (C++, external, ROOT, O2, O2Physics, PWG-non-HF, PWGHF) -// using directives - #include "CommonConstants/PhysicsConstants.h" #include "Framework/AnalysisTask.h" #include "Framework/runDataProcessing.h" From b92138be3e00f3e82ad969d9c205898b9e85ddda Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Sun, 9 Jun 2024 19:07:06 +0200 Subject: [PATCH 24/35] Add mass of Xi-pi pairs, correct DecayType flag conditions in tree creator and task --- PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx | 78 +++++++----- .../DataModel/CandidateReconstructionTables.h | 16 ++- .../candidateCreatorXicToXiPiPi.cxx | 119 +++++++++++++----- .../TableProducer/treeCreatorXicToXiPiPi.cxx | 18 ++- 4 files changed, 155 insertions(+), 76 deletions(-) diff --git a/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx index 895cc353792..1cec34af017 100644 --- a/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx +++ b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx @@ -48,14 +48,15 @@ struct HfTaskXicToXiPiPi { HistogramRegistry registry{ "registry", - {{"hPtCand", "#Xi^{#plus}_{c} candidates;candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{1000, 0., 40.}}}}, - {"hPtProng0", "#Xi^{#plus}_{c} candidates;prong 0 (#Xi^{#minus}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{1000, 0., 40.}}}}, - {"hPtProng1", "#Xi^{#plus}_{c} candidates;prong 1 (#pi^{#plus}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{200, 0., 16.}}}}, - {"hPtProng2", "#Xi^{#plus}_{c} candidates;prong 2 (#pi^{#plus}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{200, 0., 16.}}}}}}; + {{"hPtCand", "#Xi^{#plus}_{c} candidates;candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{400, 0., 40.}}}}, + {"hPtProng0", "#Xi^{#plus}_{c} candidates;prong 0 (#Xi^{#minus}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}}, + {"hPtProng1", "#Xi^{#plus}_{c} candidates;prong 1 (#pi^{#plus}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{200, 0., 20.}}}}, + {"hPtProng2", "#Xi^{#plus}_{c} candidates;prong 2 (#pi^{#plus}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{200, 0., 20.}}}}}}; void init(InitContext const&) { static const AxisSpec axisMassXic = {300, 1.8, 3.0, "inv. mass (GeV/#it{c}^{2})"}; + static const AxisSpec axisMassXiRes= {300, 1.0,2.0, "inv. mass (GeV/#it{c}^{2})"}; static const AxisSpec axisPt = {(std::vector)binsPt, "#it{p}_{T} (GeV/#it{c})"}; registry.add("hEta", "#Xi^{#plus}_{c} candidates;#Xi^{#plus}_{c} candidate #it{#eta};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); @@ -70,34 +71,36 @@ struct HfTaskXicToXiPiPi { registry.add("hd0Prong0", "#Xi^{#plus}_{c} candidates;prong 0 (#Xi^{#mp}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{100, -0.05, 0.05}, axisPt}}); registry.add("hd0Prong1", "#Xi^{#plus}_{c} candidates;prong 1 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{100, -0.05, 0.05}, axisPt}}); registry.add("hd0Prong2", "#Xi^{#plus}_{c} candidates;prong 2 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{100, -0.05, 0.05}, axisPt}}); - registry.add("hImpParErr", "#Xi^{#plus}_{c} candidates;prongs impact parameter error (cm);entries", {HistType::kTH2F, {{100, -1., 1.}, axisPt}}); - registry.add("hChi2PCA", "#Xi^{#plus}_{c} candidates (matched);sum of distances of the secondary vertex to its prongs;entries", {HistType::kTH2F, {{240, -0.01, 0.1}, axisPt}}); + registry.add("hImpParErr", "#Xi^{#plus}_{c} candidates;prongs impact parameter error (cm);entries", {HistType::kTH2F, {{200, -0.1, 0.1}, axisPt}}); + registry.add("hChi2PCA", "#Xi^{#plus}_{c} candidates (matched);sum of distances of the secondary vertex to its prongs;entries", {HistType::kTH2F, {{240, -0.01, 0.5}, axisPt}}); registry.add("hCPAXi", "#Xi^{#plus}_{c} candidates;#Xi^{#minus} candidate cosine of pointing angle;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); registry.add("hCPAxyXi", "#Xi^{#plus}_{c} candidates;#Xi^{#minus} candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); registry.add("hCPALambda", "#Xi^{#plus}_{c} candidates;#Lambda candidate cosine of pointing angle;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); registry.add("hCPAxyLambda", "#Xi^{#plus}_{c} candidates;#Lambda candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hMassXiPi1", "#Xi^{#plus}_{c} candidates;inv. mass #Xi^{#mp} #pi^{#pm} (prong 1) (GeV/#it{c}^{2});#it{p}_{T} (GeV/#it{c})", {HistType::kTH2F, {axisMassXiRes, axisPt}}); + registry.add("hMassXiPi2", "#Xi^{#plus}_{c} candidates;inv. mass #Xi^{#mp} #pi^{#pm} (prong 2) (GeV/#it{c}^{2});#it{p}_{T} (GeV/#it{c})", {HistType::kTH2F, {axisMassXiRes, axisPt}}); /* MC reconstructed */ registry.add("hPtGenSig", "#Xi^{#plus}_{c} candidates (gen+rec);candidate #it{p}_{T}^{gen.} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); registry.add("hPtRecSig", "#Xi^{#plus}_{c} candidates (matched);candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); registry.add("hPtRecBg", "#Xi^{#plus}_{c} candidates (unmatched);candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); - registry.add("hPtProng0RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 0 (#Xi^{#mp}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); - registry.add("hPtProng0RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 0 (#Xi^{#mp}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); - registry.add("hPtProng1RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 1 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); - registry.add("hPtProng1RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 1 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); - registry.add("hPtProng2RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 2 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); - registry.add("hPtProng2RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 2 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); + registry.add("hPtProng0RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 0 (#Xi^{#mp}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 30.}, axisPt}}); + registry.add("hPtProng0RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 0 (#Xi^{#mp}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 30.}, axisPt}}); + registry.add("hPtProng1RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 1 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 20.}, axisPt}}); + registry.add("hPtProng1RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 1 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 20.}, axisPt}}); + registry.add("hPtProng2RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 2 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 20.}, axisPt}}); + registry.add("hPtProng2RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 2 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 20.}, axisPt}}); registry.add("hEtaRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate #it{#eta};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); registry.add("hEtaRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate #it{#eta};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); registry.add("hRapidityRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate #it{y};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); registry.add("hRapidityRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate #it{y};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); - registry.add("hCPARecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate cosine of pointing angle;entries", {HistType::kTH2F, {{220, 0., 1.1}, axisPt}}); - registry.add("hCPARecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate cosine of pointing angle;entries", {HistType::kTH2F, {{220, 0., 1.1}, axisPt}}); - registry.add("hCPAxyRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate CPAxy;entries", {HistType::kTH2F, {{220, 0., 1.1}, axisPt}}); - registry.add("hCPAxyRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate CPAxy;entries", {HistType::kTH2F, {{220, 0., 1.1}, axisPt}}); - registry.add("hMassRecSig", "#Xi^{#plus}_{c} candidates (matched);inv. mass #Xi^{#mp} #pi^{#pm} #pi^{#pm} (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 4.0, 7.00}, axisPt}}); - registry.add("hMassRecBg", "#Xi^{#plus}_{c} candidates (unmatched);inv. mass #Xi^{#mp} #pi^{#pm} #pi^{#pm} (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 4.0, 7.0}, axisPt}}); + registry.add("hCPARecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate cosine of pointing angle;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); + registry.add("hCPARecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate cosine of pointing angle;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); + registry.add("hCPAxyRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate CPAxy;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); + registry.add("hCPAxyRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate CPAxy;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); + registry.add("hMassRecSig", "#Xi^{#plus}_{c} candidates (matched);inv. mass #Xi^{#mp} #pi^{#pm} #pi^{#pm} (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.8, 3.0}, axisPt}}); + registry.add("hMassRecBg", "#Xi^{#plus}_{c} candidates (unmatched);inv. mass #Xi^{#mp} #pi^{#pm} #pi^{#pm} (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.8, 3.0}, axisPt}}); registry.add("hDecLengthRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); registry.add("hDecLengthRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); registry.add("hErrDecLengthRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); @@ -112,24 +115,28 @@ struct HfTaskXicToXiPiPi { registry.add("hd0Prong1RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 1 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); registry.add("hd0Prong2RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 2 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); registry.add("hd0Prong2RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 2 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); - registry.add("hImpParErrRecSig", "#Xi^{#plus}_{c} candidates (matched);prongs impact parameter error (cm);entries", {HistType::kTH2F, {{100, -1., 1.}, axisPt}}); - registry.add("hImpParErrRecBg", "#Xi^{#plus}_{c} candidates (unmatched);prongs impact parameter error (cm);entries", {HistType::kTH2F, {{100, -1., 1.}, axisPt}}); + registry.add("hImpParErrRecSig", "#Xi^{#plus}_{c} candidates (matched);prongs impact parameter error (cm);entries", {HistType::kTH2F, {{100, -0.1, 0.1}, axisPt}}); + registry.add("hImpParErrRecBg", "#Xi^{#plus}_{c} candidates (unmatched);prongs impact parameter error (cm);entries", {HistType::kTH2F, {{100, -0.1, 0.1}, axisPt}}); registry.add("hChi2PCARecSig", "#Xi^{#plus}_{c} candidates (matched);sum of distances of the secondary vertex to its prongs;entries", {HistType::kTH2F, {{240, -0.01, 0.1}, axisPt}}); registry.add("hChi2PCARecBg", "#Xi^{#plus}_{c} candidates (unmatched);sum of distances of the secondary vertex to its prongs;entries", {HistType::kTH2F, {{240, -0.01, 0.1}, axisPt}}); - registry.add("hCPAXiRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#minus} cosine of pointing angle;entries", {HistType::kTH2F, {{220, 0., 1.1}, axisPt}}); - registry.add("hCPAXiRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#minus} cosine of pointing angle;entries", {HistType::kTH2F, {{220, 0., 1.1}, axisPt}}); + registry.add("hCPAXiRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#minus} cosine of pointing angle;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); + registry.add("hCPAXiRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#minus} cosine of pointing angle;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); registry.add("hCPAxyXiRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#minus} candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); registry.add("hCPAxyXiRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#minus} candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); registry.add("hCPALambdaRecSig", "#Xi^{#plus}_{c} candidates (matched);#Lambda candidate cosine of pointing angle;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); registry.add("hCPALambdaRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Lambda candidate cosine of pointing angle;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); registry.add("hCPAxyLambdaRecSig", "#Xi^{#plus}_{c} candidates (matched);#Lambda candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); registry.add("hCPAxyLambdaRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Lambda candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hMassXiPi1RecSig", "#Xi^{#plus}_{c} candidates (matched);inv. mass #Xi^{#mp} #pi^{#pm} (prong 1) (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.0, 2.0}, axisPt}}); + registry.add("hMassXiPi1RecBg", "#Xi^{#plus}_{c} candidates (unmatched);inv. mass #Xi^{#mp} #pi^{#pm} (prong 1) (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.0, 2.0}, axisPt}}); + registry.add("hMassXiPi2RecSig", "#Xi^{#plus}_{c} candidates (matched);inv. mass #Xi^{#mp} #pi^{#pm} (prong 2) (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.0, 2.0}, axisPt}}); + registry.add("hMassXiPi2RecBg", "#Xi^{#plus}_{c} candidates (unmatched);inv. mass #Xi^{#mp} #pi^{#pm} (prong 2) (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.0, 2.0}, axisPt}}); /* MC generated */ - registry.add("hPtProng0Gen", "MC particles (generated);prong 0 (#Xi^{#mp}) #it{p}_{T}^{gen} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); - registry.add("hPtProng1Gen", "MC particles (generated);prong 1 (#pi^{#pm}) #it{p}_{T}^{gen} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); - registry.add("hPtProng2Gen", "MC particles (generated);prong 2 (#pi^{#pm}) #it{p}_{T}^{gen} (GeV/#it{c});entries", {HistType::kTH2F, {{100, 0., 10.}, axisPt}}); + registry.add("hPtProng0Gen", "MC particles (generated);prong 0 (#Xi^{#mp}) #it{p}_{T}^{gen} (GeV/#it{c});entries", {HistType::kTH2F, {{300, 0., 30.}, axisPt}}); + registry.add("hPtProng1Gen", "MC particles (generated);prong 1 (#pi^{#pm}) #it{p}_{T}^{gen} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 20.}, axisPt}}); + registry.add("hPtProng2Gen", "MC particles (generated);prong 2 (#pi^{#pm}) #it{p}_{T}^{gen} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 20.}, axisPt}}); registry.add("hEtaProng0Gen", "MC particles (generated);prong 0 (#Xi^{#mp}) #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); registry.add("hEtaProng1Gen", "MC particles (generated);prong 1 (#pi^{#pm}) #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); registry.add("hEtaProng2Gen", "MC particles (generated);prong 2 (#pi^{#pm}) #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); @@ -146,8 +153,8 @@ struct HfTaskXicToXiPiPi { if (checkDecayTypeMc) { constexpr uint8_t kNBinsDecayTypeMc = hf_cand_xictoxipipi::DecayType::NDecayType + 1; TString labels[kNBinsDecayTypeMc]; - labels[hf_cand_xictoxipipi::DecayType::XicToXiPiPi] = "#Xi^{+}_{c} #rightarrow (#Xi^{#minus} #rightarrow #Lambda^{0} #pi^{#minus} #rightarrow p #pi^{#minus} #pi^{#minus}) #pi^{#plus}) #pi^{#plus}"; - /*labels[hf_cand_xictoxipipi::DecayTypeMc::PartlyRecoDecay] = "Partly reconstructed decay channel";*/ + labels[hf_cand_xictoxipipi::DecayType::XicToXiPiPi] = "#Xi^{+}_{c} #rightarrow #Xi^{#minus} #pi^{#plus}) #pi^{#plus}"; + labels[hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi] = "#Xi^{+}_{c} #rightarrow #Xi(1530)^{0} #pi^{#plus} #rightarrow #Xi^{#minus} #pi^{#plus}) #pi^{#plus}"; labels[hf_cand_xictoxipipi::DecayType::NDecayType] = "Other decays"; static const AxisSpec axisDecayType = {kNBinsDecayTypeMc, 0.5, kNBinsDecayTypeMc + 0.5, ""}; registry.add("hDecayTypeMc", "DecayType", {HistType::kTH3F, {axisDecayType, axisMassXic, axisPt}}); @@ -204,6 +211,8 @@ struct HfTaskXicToXiPiPi { registry.fill(HIST("hCPAxyXi"), candidate.cosPaXYXi(), ptCandXic); registry.fill(HIST("hCPALambda"), candidate.cosPaLambda(), ptCandXic); registry.fill(HIST("hCPAxyLambda"), candidate.cosPaLambda(), ptCandXic); + registry.fill(HIST("hMassXiPi1"), candidate.invMassXiPi0(), ptCandXic); + registry.fill(HIST("hMassXiPi2"), candidate.invMassXiPi1(), ptCandXic); } // candidate loop } // process @@ -225,7 +234,7 @@ struct HfTaskXicToXiPiPi { auto ptCandXic = candidate.pt(); int flagMcMatchRecXic = std::abs(candidate.flagMcMatchRec()); - if (TESTBIT(flagMcMatchRecXic, hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { + if (TESTBIT(flagMcMatchRecXic, hf_cand_xictoxipipi::DecayType::XicToXiPiPi) || TESTBIT(flagMcMatchRecXic, hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi)) { auto indexMother = RecoDecay::getMother(mcParticles, candidate.pi0_as().mcParticle_as>(), o2::constants::physics::Pdg::kXiCPlus, true); auto particleMother = mcParticles.rawIteratorAt(indexMother); @@ -254,10 +263,6 @@ struct HfTaskXicToXiPiPi { registry.fill(HIST("hCPAxyXiRecSig"), candidate.cosPaXYXi(), ptCandXic); registry.fill(HIST("hCPALambdaRecSig"), candidate.cosPaLambda(), ptCandXic); registry.fill(HIST("hCPAxyLambdaRecSig"), candidate.cosPaLambda(), ptCandXic); - - if (checkDecayTypeMc) { - registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_xictoxipipi::DecayType::XicToXiPiPi, candidate.invMassXic(), ptCandXic); - } } else { registry.fill(HIST("hPtRecBg"), ptCandXic); registry.fill(HIST("hPtProng0RecBg"), candidate.ptProng0()); @@ -283,7 +288,14 @@ struct HfTaskXicToXiPiPi { registry.fill(HIST("hCPAxyXiRecBg"), candidate.cosPaXYXi(), ptCandXic); registry.fill(HIST("hCPALambdaRecBg"), candidate.cosPaLambda(), ptCandXic); registry.fill(HIST("hCPAxyLambdaRecBg"), candidate.cosPaLambda(), ptCandXic); - if (checkDecayTypeMc) { + } + + if (checkDecayTypeMc) { + if (TESTBIT(flagMcMatchRecXic, hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { + registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_xictoxipipi::DecayType::XicToXiPiPi, candidate.invMassXic(), ptCandXic); + } else if (TESTBIT(flagMcMatchRecXic, hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi)) { + registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi, candidate.invMassXic(), ptCandXic); + } else { registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_xictoxipipi::DecayType::NDecayType, candidate.invMassXic(), ptCandXic); } } diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index 6a8f8a50800..99eaaac958e 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1337,15 +1337,18 @@ DECLARE_SOA_COLUMN(ZDecayVtxXi, zDecayVtxXi, float); DECLARE_SOA_COLUMN(XDecayVtxLambda, xDecayVtxLambda, float); DECLARE_SOA_COLUMN(YDecayVtxLambda, yDecayVtxLambda, float); DECLARE_SOA_COLUMN(ZDecayVtxLambda, zDecayVtxLambda, float); -DECLARE_SOA_COLUMN(DcaPi0Pi1, dcaPi0Pi1, float); -DECLARE_SOA_COLUMN(DcaPi0Xi, dcaPi0Xi, float); -DECLARE_SOA_COLUMN(DcaPi1Xi, dcaPi1Xi, float); DECLARE_SOA_COLUMN(CosPaXi, cosPaXi, float); DECLARE_SOA_COLUMN(CosPaXYXi, cosPaXYXi, float); DECLARE_SOA_COLUMN(CosPaLambda, cosPaLambda, float); DECLARE_SOA_COLUMN(CosPaXYLambda, cosPaXYLambda, float); -DECLARE_SOA_COLUMN(InvMassXic, invMassXic, double); -DECLARE_SOA_COLUMN(Sign, sign, double); +DECLARE_SOA_COLUMN(InvMassXic, invMassXic, float); +DECLARE_SOA_COLUMN(Sign, sign, float); +DECLARE_SOA_COLUMN(InvMassXiPi0, invMassXiPi0, float); +DECLARE_SOA_COLUMN(InvMassXiPi1, invMassXiPi1, float); +// KF specific columns +DECLARE_SOA_COLUMN(DcaPi0Pi1, dcaPi0Pi1, float); +DECLARE_SOA_COLUMN(DcaPi0Xi, dcaPi0Xi, float); +DECLARE_SOA_COLUMN(DcaPi1Xi, dcaPi1Xi, float); // MC matching result: DECLARE_SOA_COLUMN(FlagMcMatchRec, flagMcMatchRec, int8_t); // reconstruction level DECLARE_SOA_COLUMN(FlagMcMatchGen, flagMcMatchGen, int8_t); // generator level @@ -1381,6 +1384,7 @@ DECLARE_SOA_TABLE(HfCandXicBase, "AOD", "HFCANDXICBASE", hf_cand_xictoxipipi::XDecayVtxXi, hf_cand_xictoxipipi::YDecayVtxXi, hf_cand_xictoxipipi::ZDecayVtxXi, hf_cand_xictoxipipi::XDecayVtxLambda, hf_cand_xictoxipipi::YDecayVtxLambda, hf_cand_xictoxipipi::ZDecayVtxLambda, hf_cand_xictoxipipi::CosPaXi, hf_cand_xictoxipipi::CosPaXYXi, hf_cand_xictoxipipi::CosPaLambda, hf_cand_xictoxipipi::CosPaXYLambda, + hf_cand_xictoxipipi::InvMassXiPi0, hf_cand_xictoxipipi::InvMassXiPi1, /* dynamic columns */ hf_cand::RSecondaryVertex, hf_cand::DecayLength, @@ -1415,7 +1419,7 @@ DECLARE_SOA_EXTENDED_TABLE_USER(HfCandXicExt, HfCandXicBase, "HFCANDXICEXT", using HfCandXic = HfCandXicExt; DECLARE_SOA_TABLE(HfCandXicKF, "AOD", "HFCANDXICKF", - cascdata::KFV0Chi2, cascdata::KFCascadeChi2, + cascdata::KFCascadeChi2, cascdata::KFV0Chi2, hf_cand_xictoxipipi::DcaPi0Pi1, hf_cand_xictoxipipi::DcaPi0Xi, hf_cand_xictoxipipi::DcaPi1Xi); // table with results of reconstruction level MC matching diff --git a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index 08083d22f5c..6d0015e1efd 100644 --- a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -19,17 +19,14 @@ #define HomogeneousField #endif -//external headers #include #include #include #include #include -//ROOT #include -//O2 #include "CommonConstants/PhysicsConstants.h" #include "DCAFitter/DCAFitterN.h" #include "Framework/AnalysisTask.h" @@ -37,15 +34,12 @@ #include "ReconstructionDataFormats/DCA.h" #include "ReconstructionDataFormats/V0.h" // for creating XicPlus track with DCA fitter -//O2Physics #include "Common/DataModel/CollisionAssociationTables.h" #include "Common/Core/trackUtilities.h" #include "Tools/KFparticle/KFUtilities.h" -//PWG non-HF #include "PWGLF/DataModel/LFStrangenessTables.h" -//PWGHF #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/Utils/utilsBfieldCCDB.h" @@ -93,9 +87,9 @@ struct HfCandidateCreatorXic { double massPionFromPdg = MassPiPlus; int runNumber{0}; - double massPi{0.}; - double massXi{0.}; - double massXiPiPi{0.}; + float massXiPiPi{0.}; + float massXiPi0{0.}; + float massXiPi1{0.}; double bz{0.}; using CascadesLinked = soa::Join; @@ -164,8 +158,9 @@ struct HfCandidateCreatorXic { // loop over triplets of track indices for (const auto& rowTrackIndexXicPlus : rowsTrackIndexXicPlus) { auto cascAodElement = rowTrackIndexXicPlus.cascade_as(); - if (!cascAodElement.has_cascData()) + if (!cascAodElement.has_cascData()) { continue; + } auto casc = cascAodElement.cascData_as(); auto trackCharmBachelor0 = rowTrackIndexXicPlus.prong0_as(); auto trackCharmBachelor1 = rowTrackIndexXicPlus.prong1_as(); @@ -195,8 +190,6 @@ struct HfCandidateCreatorXic { //----------------accessing particles in the decay chain------------- auto trackPionFromXi = casc.bachelor_as(); // pion <- xi track from TracksWCovDca table - //auto trackV0PosDau = casc.posTrack_as(); // p <- V0 track (positive track) from TracksWCovDca table - //auto trackV0NegDau = casc.negTrack_as(); // pion <- V0 track (negative track) from TracksWCovDca table //--------------------------info of V0 and cascades track from LF-tables--------------------------- std::array vertexV0 = {casc.xlambda(), casc.ylambda(), casc.zlambda()}; @@ -228,14 +221,16 @@ struct HfCandidateCreatorXic { auto trackParCovCharmBachelor1 = getTrackParCov(trackCharmBachelor1); // reconstruct the 3-prong secondary vertex - if (df.process(trackParCovCharmBachelor0, trackParCovCharmBachelor1, trackCasc) == 0) { + if (df.process(trackCasc, trackParCovCharmBachelor0, trackParCovCharmBachelor1) == 0) { continue; } //----------------------------calculate physical properties----------------------- // set hfFlag int hfFlag = BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); - int signXicPlus = casc.sign() < 0 ? +1 : -1; + + // Charge of charm baryon + int signXic = casc.sign() < 0 ? +1 : -1; // get SV properties const auto& secondaryVertex = df.getPCACandidate(); @@ -243,8 +238,8 @@ struct HfCandidateCreatorXic { auto covMatrixSV = df.calcPCACovMatrixFlat(); // get track momenta - trackParCovCharmBachelor0 = df.getTrack(0); - trackParCovCharmBachelor1 = df.getTrack(1); + trackParCovCharmBachelor0 = df.getTrack(1); + trackParCovCharmBachelor1 = df.getTrack(2); trackCasc = df.getTrack(2); std::array pVecXi; std::array pVecPi0; @@ -253,21 +248,25 @@ struct HfCandidateCreatorXic { trackParCovCharmBachelor0.getPxPyPzGlo(pVecPi0); trackParCovCharmBachelor1.getPxPyPzGlo(pVecPi1); - // get parent track + // get invariant mass of Xic candidate + auto arrayMomenta = std::array{pVecXi, pVecPi0, pVecPi1}; + massXiPiPi = RecoDecay::m(std::move(arrayMomenta), std::array{massXiMinusFromPdg, massPionFromPdg, massPionFromPdg}); + + /* get parent track necessary? std::array pVec2Pi = RecoDecay::pVec(pVecPi0, pVecPi1); std::array pVecXicPlus = RecoDecay::pVec(pVecXi, pVecPi0, pVecPi1); auto trackParCov2Pi = o2::dataformats::V0(df.getPCACandidatePos(), pVec2Pi, df.calcPCACovMatrixFlat(), trackParCovCharmBachelor0, trackParCovCharmBachelor1); auto trackParCovXicPlus = o2::dataformats::V0(df.getPCACandidatePos(), pVecXicPlus, df.calcPCACovMatrixFlat(), trackParCov2Pi, trackCasc); - trackParCovXicPlus.getPxPyPzGlo(pVecXicPlus); + trackParCovXicPlus.getPxPyPzGlo(pVecXicPlus);*/ // get track impact parameters // This modifies track momenta! auto primaryVertex = getPrimaryVertex(collision); auto covMatrixPV = primaryVertex.getCov(); // calculate impact parameter + o2::dataformats::DCA impactParameterCasc; o2::dataformats::DCA impactParameter0; o2::dataformats::DCA impactParameter1; - o2::dataformats::DCA impactParameterCasc; trackCasc.propagateToDCA(primaryVertex, bz, &impactParameterCasc); trackParCovCharmBachelor0.propagateToDCA(primaryVertex, bz, &impactParameter0); trackParCovCharmBachelor1.propagateToDCA(primaryVertex, bz, &impactParameter1); @@ -279,9 +278,11 @@ struct HfCandidateCreatorXic { double cpaXi = casc.casccosPA(collision.posX(), collision.posY(), collision.posZ()); double cpaXYXi = RecoDecay::cpaXY(pvCoord, vertexCasc, pVecCasc); - // get invariant mass - auto arrayMomenta = std::array{pVecXi, pVecPi0, pVecPi1}; - massXiPiPi = RecoDecay::m(std::move(arrayMomenta), std::array{massXiMinusFromPdg, massPionFromPdg, massPionFromPdg}); + // get invariant mass of Xi-pi pairs + auto arrayMomentaXiPi0 = std::array{pVecXi, pVecPi0}; + massXiPi0 = RecoDecay::m(std::move(arrayMomentaXiPi0), std::array{massXiMinusFromPdg, massPionFromPdg}); + auto arrayMomentaXiPi1 = std::array{pVecXi, pVecPi1}; + massXiPi1 = RecoDecay::m(std::move(arrayMomentaXiPi1), std::array{massXiMinusFromPdg, massPionFromPdg}); // get uncertainty of the decay length double phi, theta; @@ -322,7 +323,7 @@ struct HfCandidateCreatorXic { secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], covMatrixSV[0], covMatrixSV[2], covMatrixSV[5], errorDecayLength, errorDecayLengthXY, - chi2SV, massXiPiPi, signXicPlus, + chi2SV, massXiPiPi, signXic, pVecXi[0], pVecXi[1], pVecXi[2], pVecPi0[0], pVecPi0[1], pVecPi0[2], pVecPi1[0], pVecPi1[1], pVecPi1[2], @@ -332,7 +333,8 @@ struct HfCandidateCreatorXic { /*cascade specific columns*/ vertexCasc[0], vertexCasc[1], vertexCasc[2], vertexV0[0], vertexV0[1], vertexV0[2], - cpaXi, cpaXYXi, cpaLambda, cpaXYLambda); + cpaXi, cpaXYXi, cpaLambda, cpaXYLambda, + massXiPi0, massXiPi1); } // loop over track triplets } PROCESS_SWITCH(HfCandidateCreatorXic, processXicplusWithDcaFitter, "Run candidate creator with DCAFitter.", false); @@ -347,8 +349,9 @@ struct HfCandidateCreatorXic { // loop over triplets of track indices for (const auto& rowTrackIndexXicPlus : rowsTrackIndexXicPlus) { auto cascAodElement = rowTrackIndexXicPlus.cascade_as(); - if (!cascAodElement.has_kfCascData()) + if (!cascAodElement.has_kfCascData()) { continue; + } auto casc = cascAodElement.kfCascData_as(); auto trackCharmBachelor0 = rowTrackIndexXicPlus.prong0_as(); auto trackCharmBachelor1 = rowTrackIndexXicPlus.prong1_as(); @@ -429,9 +432,11 @@ struct HfCandidateCreatorXic { kfXi.TransportToParticle(kfXicPlus); //---------------------calculate physical parameters of XicPlus candidate---------------------- + // sign of charm baryon + int signXic = casc.sign() < 0 ? +1 : -1; + // set hfFlag int hfFlag = BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); - int signXicPlus = casc.sign() < 0 ? +1 : -1; // get impact parameters of XicPlus daughters float impactParameterPi0XY = 0., errImpactParameterPi0XY = 0.; @@ -453,6 +458,28 @@ struct HfCandidateCreatorXic { float dcaXYPi0Xi = kfCharmBachelor0.GetDistanceFromParticleXY(kfXi); float dcaXYPi1Xi = kfCharmBachelor1.GetDistanceFromParticleXY(kfXi); + // mass of Xi-Pi0 pair + KFParticle kfXiPi0; + const KFParticle* kfXiResonanceDaughtersPi0[2] = {&kfXi, &kfCharmBachelor0}; + kfXiPi0.SetConstructMethod(kfConstructMethod); + try { + kfXiPi0.Construct(kfXiResonanceDaughtersPi0, 2); + massXiPi0 = kfXiPi0.GetMass(); + } catch(...) { + LOG(info) << "Failed to construct Xi(1530) with Pi 0"; + } + + // mass of Xi-Pi1 pair + KFParticle kfXiPi1; + const KFParticle* kfXiResonanceDaughtersPi1[2] = {&kfXi, &kfCharmBachelor1}; + kfXiPi1.SetConstructMethod(kfConstructMethod); + try { + kfXiPi1.Construct(kfXiResonanceDaughtersPi1, 2); + massXiPi1 = kfXiPi1.GetMass(); + } catch(...){ + LOG(info) << "Failed to construct Xi(1530) with Pi 1"; + } + //-------------------------------fill histograms-------------------------------------------- if (fillHistograms) { // invariant mass @@ -483,7 +510,7 @@ struct HfCandidateCreatorXic { kfXicPlus.GetX(), kfXicPlus.GetY(), kfXicPlus.GetZ(), kfXicPlus.GetErrX(), kfXicPlus.GetErrY(), kfXicPlus.GetErrZ(), kfXicPlus.GetErrDecayLength(), kfXicPlus.GetErrDecayLengthXY(), - kfXicPlus.GetChi2(), kfXicPlus.GetMass(), signXicPlus, + kfXicPlus.GetChi2(), kfXicPlus.GetMass(), signXic, kfXi.GetPx(), kfXi.GetPy(), kfXi.GetPz(), kfCharmBachelor0.GetPx(), kfCharmBachelor0.GetPy(), kfCharmBachelor0.GetPz(), kfCharmBachelor1.GetPx(), kfCharmBachelor1.GetPy(), kfCharmBachelor1.GetPz(), @@ -493,8 +520,9 @@ struct HfCandidateCreatorXic { /*cascade specific columns*/ casc.x(), casc.y(), casc.z(), casc.xlambda(), casc.ylambda(), casc.zlambda(), - cpaXi, cpaXYXi, cpaLambda, cpaXYLambda); - rowCandidateKF(casc.kfV0Chi2(), casc.kfCascadeChi2(), + cpaXi, cpaXYXi, cpaLambda, cpaXYLambda, + massXiPi0, massXiPi1); + rowCandidateKF(casc.kfCascadeChi2(), casc.kfV0Chi2(), dcaXYPi0Pi1, dcaXYPi0Xi, dcaXYPi1Xi); } // loop over track triplets } @@ -651,7 +679,9 @@ struct HfCandidateCreatorXic { //---------------------calculate physical parameters of XicPlus candidate---------------------- // set hfFlag int hfFlag = BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); - int signXicPlus = casc.sign() < 0 ? +1 : -1; + + // sign of charm baryon + int signXic = casc.sign() < 0 ? +1 : -1; // get impact parameters of XicPlus daughters float impactParameterPi0XY = 0., errImpactParameterPi0XY = 0.; @@ -673,6 +703,28 @@ struct HfCandidateCreatorXic { float dcaXYPi0Xi = kfCharmBachelor0.GetDistanceFromParticleXY(kfXi); float dcaXYPi1Xi = kfCharmBachelor1.GetDistanceFromParticleXY(kfXi); + // mass of Xi-Pi0 pair + KFParticle kfXiPi0; + const KFParticle* kfXiResonanceDaughtersPi0[2] = {&kfXi, &kfCharmBachelor0}; + kfXiPi0.SetConstructMethod(kfConstructMethod); + try { + kfXiPi0.Construct(kfXiResonanceDaughtersPi0, 2); + massXiPi0 = kfXiPi0.GetMass(); + } catch(...) { + LOG(info) << "Failed to construct Xi(1530) with Pi 0"; + } + + // mass of Xi-Pi1 pair + KFParticle kfXiPi1; + const KFParticle* kfXiResonanceDaughtersPi1[2] = {&kfXi, &kfCharmBachelor1}; + kfXiPi1.SetConstructMethod(kfConstructMethod); + try { + kfXiPi1.Construct(kfXiResonanceDaughtersPi1, 2); + massXiPi1 = kfXiPi1.GetMass(); + } catch(...){ + LOG(info) << "Failed to construct Xi(1530) with Pi 1"; + } + //-------------------------------fill histograms-------------------------------------------- if (fillHistograms) { // invariant mass @@ -703,7 +755,7 @@ struct HfCandidateCreatorXic { kfXicPlus.GetX(), kfXicPlus.GetY(), kfXicPlus.GetZ(), kfXicPlus.GetErrX(), kfXicPlus.GetErrY(), kfXicPlus.GetErrZ(), kfXicPlus.GetErrDecayLength(), kfXicPlus.GetErrDecayLengthXY(), - kfXicPlus.GetChi2(), kfXicPlus.GetMass(), signXicPlus, + kfXicPlus.GetChi2(), kfXicPlus.GetMass(), signXic, kfXi.GetPx(), kfXi.GetPy(), kfXi.GetPz(), kfCharmBachelor0.GetPx(), kfCharmBachelor0.GetPy(), kfCharmBachelor0.GetPz(), kfCharmBachelor1.GetPx(), kfCharmBachelor1.GetPy(), kfCharmBachelor1.GetPz(), @@ -713,8 +765,9 @@ struct HfCandidateCreatorXic { /*cascade specific columns*/ casc.x(), casc.y(), casc.z(), casc.xlambda(), casc.ylambda(), casc.zlambda(), - cpaXi, cpaXYXi, cpaLambda, cpaXYLambda); - rowCandidateKF(casc.kfV0Chi2(), casc.kfCascadeChi2(), + cpaXi, cpaXYXi, cpaLambda, cpaXYLambda, + massXiPi0, massXiPi1); + rowCandidateKF(casc.kfCascadeChi2(), casc.kfV0Chi2(), dcaXYPi0Pi1, dcaXYPi0Xi, dcaXYPi1Xi); } // bachelor 1 } // bachelor 0 diff --git a/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx index 6c95abfdf00..61d382fa4c8 100644 --- a/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx @@ -90,6 +90,8 @@ DECLARE_SOA_COLUMN(CpaXYLam, cpaXYLam, float); DECLARE_SOA_COLUMN(DcaPi0Pi1, dcaPi0Pi1, float); DECLARE_SOA_COLUMN(DcaPi0Xi, dcaPi0Xi, float); DECLARE_SOA_COLUMN(DcaPi1Xi, dcaPi1Xi, float); +DECLARE_SOA_COLUMN(InvMassXiPi0, invMassXiPi0, float); +DECLARE_SOA_COLUMN(InvMassXiPi1, invMassXiPi1, float); // PID daughters DECLARE_SOA_COLUMN(NSigTpcPi1, nSigTpcPi1, float); //! TPC Nsigma separation for prong1 with pion mass hypothesis DECLARE_SOA_COLUMN(NSigTofPi1, nSigTofPi1, float); //! TOF Nsigma separation for prong1 with pion mass hypothesis @@ -230,6 +232,8 @@ DECLARE_SOA_TABLE(HfCandXicFulls, "AOD", "HFCANDXICFULL", full::CpaXYXi, full::CpaLam, full::CpaXYLam, + full::InvMassXiPi0, + full::InvMassXiPi1, hf_cand_xictoxipipi::FlagMcMatchRec); DECLARE_SOA_TABLE(HfCandXicFullKfs, "AOD", "HFCANDXICFULLKF", @@ -285,6 +289,8 @@ DECLARE_SOA_TABLE(HfCandXicFullKfs, "AOD", "HFCANDXICFULLKF", full::CpaXYXi, full::CpaLam, full::CpaXYLam, + full::InvMassXiPi0, + full::InvMassXiPi1, full::Chi2XiVtx, full::Chi2LamVtx, full::DcaPi0Pi1, @@ -335,10 +341,10 @@ struct HfTreeCreatorXicToXiPiPi { Filter filterSelectCandidates = aod::hf_sel_candidate_xic::isSelXicToXiPiPi >= selectionFlagXic; - Partition recSig = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) == (int8_t)BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); - Partition recBg = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) != (int8_t)BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); - Partition recSigKf = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) == (int8_t)BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); - Partition recBgKf = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) != (int8_t)BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); + Partition recSig = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) != int8_t(0); + Partition recBg = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) == int8_t(0); + Partition recSigKf = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) != int8_t(0); + Partition recBgKf = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) == int8_t(0); void init(InitContext const&) { @@ -457,6 +463,8 @@ struct HfTreeCreatorXicToXiPiPi { candidate.cosPaXYXi(), candidate.cosPaLambda(), candidate.cosPaXYLambda(), + candidate.invMassXiPi0(), + candidate.invMassXiPi1(), flagMc); } } else { @@ -556,6 +564,8 @@ struct HfTreeCreatorXicToXiPiPi { candidate.cosPaXYXi(), candidate.cosPaLambda(), candidate.cosPaXYLambda(), + candidate.invMassXiPi0(), + candidate.invMassXiPi1(), candidate.kfCascadeChi2(), candidate.kfV0Chi2(), candidate.dcaPi0Pi1(), From 4525402f69c085240d66bce165c3254894555c67 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Sun, 9 Jun 2024 21:04:43 +0200 Subject: [PATCH 25/35] Remove ML selection + correct PID selection --- .../candidateCreatorXicToXiPiPi.cxx | 4 +- .../candidateSelectorXicToXiPiPi.cxx | 54 +------------------ 2 files changed, 4 insertions(+), 54 deletions(-) diff --git a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index 6d0015e1efd..bf56bcad839 100644 --- a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -337,7 +337,7 @@ struct HfCandidateCreatorXic { massXiPi0, massXiPi1); } // loop over track triplets } - PROCESS_SWITCH(HfCandidateCreatorXic, processXicplusWithDcaFitter, "Run candidate creator with DCAFitter.", false); + PROCESS_SWITCH(HfCandidateCreatorXic, processXicplusWithDcaFitter, "Run candidate creator with DCAFitter.", true); void processXicplusWithKFParticleFromDerivedData(aod::Collisions const&, aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, @@ -526,7 +526,7 @@ struct HfCandidateCreatorXic { dcaXYPi0Pi1, dcaXYPi0Xi, dcaXYPi1Xi); } // loop over track triplets } - PROCESS_SWITCH(HfCandidateCreatorXic, processXicplusWithKFParticleFromDerivedData, "Run candidate creator with KFParticle using derived data from HfTrackIndexSkimCreatorLfCascades.", true); + PROCESS_SWITCH(HfCandidateCreatorXic, processXicplusWithKFParticleFromDerivedData, "Run candidate creator with KFParticle using derived data from HfTrackIndexSkimCreatorLfCascades.", false); void processXicplusWithKFParticle(SelectedCollisions const& collisions, SelectedHfTrackAssoc const& trackIndices, diff --git a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx index 17e036a4af5..9cd6942a6a2 100644 --- a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx @@ -20,7 +20,6 @@ #include "Common/Core/TrackSelectorPID.h" #include "PWGHF/Utils/utilsAnalysis.h" // findBin function -#include "PWGHF/Core/HfMlResponse.h" #include "PWGHF/Core/SelectorCuts.h" #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/DataModel/CandidateSelectionTables.h" @@ -32,7 +31,6 @@ using namespace o2::analysis; struct HfCandidateSelectorXicToXiPiPi { Produces hfSelXicToXiPiPiCandidate; - Produces hfMlXicToXiPiPiCandidate; Configurable ptCandMin{"ptCandMin", 0., "Lower bound of candidate pT"}; Configurable ptCandMax{"ptCandMax", 36., "Upper bound of candidate pT"}; @@ -60,17 +58,6 @@ struct HfCandidateSelectorXicToXiPiPi { Configurable ptPidTofMax{"ptPidTofMax", 20., "Upper bound of track pT for TOF PID"}; Configurable nSigmaTofMax{"nSigmaTofMax", 5., "Nsigma cut on TOF only"}; Configurable nSigmaTofCombinedMax{"nSigmaTofCombinedMax", 5., "Nsigma cut on TOF combined with TPC"}; - // 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"}; - Configurable> cutDirMl{"cutDirMl", std::vector{hf_cuts_ml::vecCutDir}, "Whether to reject score values greater or smaller than the threshold"}; - 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", (int8_t)hf_cuts_ml::nCutScores, "Number of classes in ML model"}; - - o2::analysis::HfMlResponse hfMlResponse; - std::vector outputMl = {}; - - o2::ccdb::CcdbApi ccdbApi; TrackSelectorPi selectorPion; TrackSelectorPr selectorProton; @@ -113,17 +100,6 @@ struct HfCandidateSelectorXicToXiPiPi { } } - if (applyMl) { - hfMlResponse.configure(binsPtMl, cutsMl, cutDirMl, nClassesMl); - if (loadModelsFromCCDB) { - ccdbApi.init(ccdbUrl); - hfMlResponse.setModelPathsCCDB(onnxFileNames, ccdbApi, modelPathsCCDB, timestampCCDB); - } else { - hfMlResponse.setModelPathsLocal(onnxFileNames); - } - hfMlResponse.init(); - outputMl.assign(((std::vector)cutDirMl).size(), -1.f); // dummy value for ML output - } } /// Conjugate-independent topological cuts @@ -201,10 +177,10 @@ struct HfCandidateSelectorXicToXiPiPi { template bool selectionPid(const T1& pidTrackPi0, const T2& pidTrackPi1, const T3& pidTrackPr, const T4& pidTrackPiLam, const T5& pidTrackPiXi, const T6& acceptPIDNotApplicable) { - if (!acceptPIDNotApplicable && pidTrackPi0 != TrackSelectorPID::Accepted && pidTrackPi1 != TrackSelectorPID::Accepted && pidTrackPr != TrackSelectorPID::Accepted && pidTrackPiLam != TrackSelectorPID::Accepted && pidTrackPiXi == TrackSelectorPID::Rejected) { + if (!acceptPIDNotApplicable && (pidTrackPi0 != TrackSelectorPID::Accepted || pidTrackPi1 != TrackSelectorPID::Accepted || pidTrackPr != TrackSelectorPID::Accepted || pidTrackPiLam != TrackSelectorPID::Accepted || pidTrackPiXi != TrackSelectorPID::Accepted)) { return false; } - if (acceptPIDNotApplicable && pidTrackPi0 == TrackSelectorPID::Rejected && pidTrackPi1 == TrackSelectorPID::Rejected && pidTrackPr == TrackSelectorPID::Rejected && pidTrackPiLam == TrackSelectorPID::Rejected && pidTrackPiXi == TrackSelectorPID::Rejected) { + if (acceptPIDNotApplicable && (pidTrackPi0 == TrackSelectorPID::Rejected || pidTrackPi1 == TrackSelectorPID::Rejected || pidTrackPr == TrackSelectorPID::Rejected || pidTrackPiLam == TrackSelectorPID::Rejected || pidTrackPiXi == TrackSelectorPID::Rejected)) { return false; } return true; @@ -220,9 +196,6 @@ struct HfCandidateSelectorXicToXiPiPi { // check if flagged as Ξc± → Ξ∓ π± π± if (!TESTBIT(hfCandXic.hfflag(), hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { hfSelXicToXiPiPiCandidate(statusXicToXiPiPi); - if (applyMl) { - hfMlXicToXiPiPiCandidate(outputMl); - } if (activateQA) { registry.fill(HIST("hSelections"), 1, ptCandXic); } @@ -236,9 +209,6 @@ struct HfCandidateSelectorXicToXiPiPi { // topological cuts if (!selectionTopol(hfCandXic)) { hfSelXicToXiPiPiCandidate(statusXicToXiPiPi); - if (applyMl) { - hfMlXicToXiPiPiCandidate(outputMl); - } continue; } SETBIT(statusXicToXiPiPi, SelectionStep::RecoTopol); // RecoTopol = 1 --> statusXicToXiPiPi = 3 @@ -268,9 +238,6 @@ struct HfCandidateSelectorXicToXiPiPi { int pidTrackPiXi = selectorPion.statusTpcAndTof(trackPiFromXi); if (!selectionPid(pidTrackPi0, pidTrackPi1, pidTrackPr, pidTrackPiLam, pidTrackPiXi, acceptPIDNotApplicable.value)) { hfSelXicToXiPiPiCandidate(statusXicToXiPiPi); - if (applyMl) { - hfMlXicToXiPiPiCandidate(outputMl); - } continue; } SETBIT(statusXicToXiPiPi, SelectionStep::RecoPID); // RecoPID = 2 --> statusXicToXiPiPi = 7 @@ -279,23 +246,6 @@ struct HfCandidateSelectorXicToXiPiPi { } } - // ML selections - if (applyMl) { - std::vector inputFeatures{}; - - bool isSelectedMl = hfMlResponse.isSelectedMl(inputFeatures, ptCandXic, outputMl); - hfMlXicToXiPiPiCandidate(outputMl); - - if (!isSelectedMl) { - hfSelXicToXiPiPiCandidate(statusXicToXiPiPi); - continue; - } - SETBIT(statusXicToXiPiPi, aod::SelectionStep::RecoMl); - if (activateQA) { - registry.fill(HIST("hSelections"), 2 + aod::SelectionStep::RecoMl, ptCandXic); - } - } - hfSelXicToXiPiPiCandidate(statusXicToXiPiPi); } } From 8ec55bb4c9c50a31063602e6ee97d958d798c36f Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Sun, 9 Jun 2024 23:11:05 +0200 Subject: [PATCH 26/35] Remove unused ML configurables from candidate selector --- PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx | 6 ------ 1 file changed, 6 deletions(-) diff --git a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx index 9cd6942a6a2..3da11bd4d15 100644 --- a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx @@ -39,12 +39,6 @@ struct HfCandidateSelectorXicToXiPiPi { Configurable> cuts{"cuts", {hf_cuts_xic_to_xi_pi_pi::cuts[0], hf_cuts_xic_to_xi_pi_pi::nBinsPt, hf_cuts_xic_to_xi_pi_pi::nCutVars, hf_cuts_xic_to_xi_pi_pi::labelsPt, hf_cuts_xic_to_xi_pi_pi::labelsCutVar}, "Xicplus candidate selection per pT bin"}; // QA switch Configurable activateQA{"activateQA", false, "Flag to enable QA histogram"}; - // CCDB configuration - Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; - Configurable> modelPathsCCDB{"modelPathsCCDB", std::vector{"EventFiltering/PWGHF/BDTXic"}, "Paths of models on CCDB"}; - Configurable> onnxFileNames{"onnxFilesCCDB", std::vector{"ModelHandler_onnx_XicTOXiPiPi.onnx"}, "ONNX file names on CCDB 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"}; // Enable PID Configurable usePid{"usePid", true, "Switch for PID selection at track level"}; Configurable acceptPIDNotApplicable{"acceptPIDNotApplicable", true, "Switch to accept Status::NotApplicable [(NotApplicable for one detector) and (NotApplicable or Conditional for the other)] in PID selection"}; From 21a9e8ada910bc6bcf911ed730c5599ea11deb31 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Fri, 14 Jun 2024 18:29:55 +0200 Subject: [PATCH 27/35] Remove hfFlag, fix resonance matching + fix filling of histograms for generated particles --- PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx | 38 +++++----- .../DataModel/CandidateReconstructionTables.h | 1 - .../candidateCreatorXicToXiPiPi.cxx | 75 ++++++++----------- .../candidateSelectorXicToXiPiPi.cxx | 11 +-- 4 files changed, 57 insertions(+), 68 deletions(-) diff --git a/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx index 1cec34af017..b68ff5211ed 100644 --- a/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx +++ b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx @@ -85,12 +85,12 @@ struct HfTaskXicToXiPiPi { registry.add("hPtGenSig", "#Xi^{#plus}_{c} candidates (gen+rec);candidate #it{p}_{T}^{gen.} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); registry.add("hPtRecSig", "#Xi^{#plus}_{c} candidates (matched);candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); registry.add("hPtRecBg", "#Xi^{#plus}_{c} candidates (unmatched);candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); - registry.add("hPtProng0RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 0 (#Xi^{#mp}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 30.}, axisPt}}); - registry.add("hPtProng0RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 0 (#Xi^{#mp}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 30.}, axisPt}}); - registry.add("hPtProng1RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 1 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 20.}, axisPt}}); - registry.add("hPtProng1RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 1 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 20.}, axisPt}}); - registry.add("hPtProng2RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 2 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 20.}, axisPt}}); - registry.add("hPtProng2RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 2 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 20.}, axisPt}}); + registry.add("hPtProng0RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 0 (#Xi^{#mp}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); + registry.add("hPtProng0RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 0 (#Xi^{#mp}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); + registry.add("hPtProng1RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 1 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 20.}}}); + registry.add("hPtProng1RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 1 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 20.}}}); + registry.add("hPtProng2RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 2 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 20.}}}); + registry.add("hPtProng2RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 2 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 20.}}}); registry.add("hEtaRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate #it{#eta};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); registry.add("hEtaRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate #it{#eta};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); registry.add("hRapidityRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate #it{y};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); @@ -177,9 +177,6 @@ struct HfTaskXicToXiPiPi { void process(soa::Filtered> const& candidates) { for (const auto& candidate : candidates) { - if (!TESTBIT(candidate.hfflag(), hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { - continue; - } auto yCandXic = candidate.y(o2::constants::physics::MassXiCPlus); if (yCandRecoMax >= 0. && std::abs(yCandXic) > yCandRecoMax) { continue; @@ -221,11 +218,12 @@ struct HfTaskXicToXiPiPi { soa::Join const& mcParticles, aod::TracksWMc const&) { + std::vector arrDaughIndex; + int pdgCodeXiMinus = kXiMinus; // 3312 + int pdgCodePiPlus = kPiPlus; // 211 + // MC rec for (const auto& candidate : candidates) { - if (!TESTBIT(candidate.hfflag(), hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { - continue; - } auto yCandXic = candidate.y(o2::constants::physics::MassXiCPlus); if (yCandRecoMax >= 0. && std::abs(yCandXic) > yCandRecoMax) { continue; @@ -303,22 +301,26 @@ struct HfTaskXicToXiPiPi { // MC gen. level for (const auto& particle : mcParticles) { - if (TESTBIT(std::abs(particle.flagMcMatchGen()), hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { + if (TESTBIT(std::abs(particle.flagMcMatchGen()), hf_cand_xictoxipipi::DecayType::XicToXiPiPi) || TESTBIT(std::abs(particle.flagMcMatchGen()), hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi)) { + arrDaughIndex.clear(); auto ptParticle = particle.pt(); - auto yParticle = RecoDecay::y(std::array{particle.px(), particle.py(), particle.pz()}, o2::constants::physics::MassXiCPlus); + auto yParticle = RecoDecay::y(particle.pVector(), o2::constants::physics::MassXiCPlus); if (yCandGenMax >= 0. && std::abs(yParticle) > yCandGenMax) { continue; } + // get kinematic variables of Ξ π π std::array ptProngs; std::array yProngs; std::array etaProngs; int counter = 0; - for (const auto& daught : particle.daughters_as()) { - ptProngs[counter] = daught.pt(); - etaProngs[counter] = daught.eta(); - yProngs[counter] = RecoDecay::y(std::array{daught.px(), daught.py(), daught.pz()}, pdg->Mass(daught.pdgCode())); + RecoDecay::getDaughters(particle, &arrDaughIndex, std::array{pdgCodeXiMinus, pdgCodePiPlus, pdgCodePiPlus}, 2); + for (auto iProng = 0u; iProng < arrDaughIndex.size(); ++iProng) { + auto daughI = mcParticles.rawIteratorAt(arrDaughIndex[iProng]); + ptProngs[counter] = daughI.pt(); + etaProngs[counter] = daughI.eta(); + yProngs[counter] = RecoDecay::y(daughI.pVector(), pdg->Mass(daughI.pdgCode())); counter++; } diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index 99eaaac958e..ab567658326 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1379,7 +1379,6 @@ DECLARE_SOA_TABLE(HfCandXicBase, "AOD", "HFCANDXICBASE", hf_cand::PxProng2, hf_cand::PyProng2, hf_cand::PzProng2, hf_cand::ImpactParameter0, hf_cand::ImpactParameter1, hf_cand::ImpactParameter2, hf_cand::ErrorImpactParameter0, hf_cand::ErrorImpactParameter1, hf_cand::ErrorImpactParameter2, - hf_track_index::HFflag, // cascade specific columns hf_cand_xictoxipipi::XDecayVtxXi, hf_cand_xictoxipipi::YDecayVtxXi, hf_cand_xictoxipipi::ZDecayVtxXi, hf_cand_xictoxipipi::XDecayVtxLambda, hf_cand_xictoxipipi::YDecayVtxLambda, hf_cand_xictoxipipi::ZDecayVtxLambda, diff --git a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index bf56bcad839..684105ad760 100644 --- a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -32,7 +32,6 @@ #include "Framework/AnalysisTask.h" #include "Framework/runDataProcessing.h" #include "ReconstructionDataFormats/DCA.h" -#include "ReconstructionDataFormats/V0.h" // for creating XicPlus track with DCA fitter #include "Common/DataModel/CollisionAssociationTables.h" #include "Common/Core/trackUtilities.h" @@ -226,9 +225,6 @@ struct HfCandidateCreatorXic { } //----------------------------calculate physical properties----------------------- - // set hfFlag - int hfFlag = BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); - // Charge of charm baryon int signXic = casc.sign() < 0 ? +1 : -1; @@ -252,13 +248,6 @@ struct HfCandidateCreatorXic { auto arrayMomenta = std::array{pVecXi, pVecPi0, pVecPi1}; massXiPiPi = RecoDecay::m(std::move(arrayMomenta), std::array{massXiMinusFromPdg, massPionFromPdg, massPionFromPdg}); - /* get parent track necessary? - std::array pVec2Pi = RecoDecay::pVec(pVecPi0, pVecPi1); - std::array pVecXicPlus = RecoDecay::pVec(pVecXi, pVecPi0, pVecPi1); - auto trackParCov2Pi = o2::dataformats::V0(df.getPCACandidatePos(), pVec2Pi, df.calcPCACovMatrixFlat(), trackParCovCharmBachelor0, trackParCovCharmBachelor1); - auto trackParCovXicPlus = o2::dataformats::V0(df.getPCACandidatePos(), pVecXicPlus, df.calcPCACovMatrixFlat(), trackParCov2Pi, trackCasc); - trackParCovXicPlus.getPxPyPzGlo(pVecXicPlus);*/ - // get track impact parameters // This modifies track momenta! auto primaryVertex = getPrimaryVertex(collision); @@ -329,7 +318,6 @@ struct HfCandidateCreatorXic { pVecPi1[0], pVecPi1[1], pVecPi1[2], impactParameterCasc.getY(), impactParameter0.getY(), impactParameter1.getY(), std::sqrt(impactParameterCasc.getSigmaY2()), std::sqrt(impactParameter0.getSigmaY2()), std::sqrt(impactParameter1.getSigmaY2()), - hfFlag, /*cascade specific columns*/ vertexCasc[0], vertexCasc[1], vertexCasc[2], vertexV0[0], vertexV0[1], vertexV0[2], @@ -435,9 +423,6 @@ struct HfCandidateCreatorXic { // sign of charm baryon int signXic = casc.sign() < 0 ? +1 : -1; - // set hfFlag - int hfFlag = BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); - // get impact parameters of XicPlus daughters float impactParameterPi0XY = 0., errImpactParameterPi0XY = 0.; float impactParameterPi1XY = 0., errImpactParameterPi1XY = 0.; @@ -516,7 +501,6 @@ struct HfCandidateCreatorXic { kfCharmBachelor1.GetPx(), kfCharmBachelor1.GetPy(), kfCharmBachelor1.GetPz(), impactParameterXiXY, impactParameterPi0XY, impactParameterPi1XY, errImpactParameterXiXY, errImpactParameterPi0XY, errImpactParameterPi1XY, - hfFlag, /*cascade specific columns*/ casc.x(), casc.y(), casc.z(), casc.xlambda(), casc.ylambda(), casc.zlambda(), @@ -676,10 +660,7 @@ struct HfCandidateCreatorXic { kfCharmBachelor1.TransportToParticle(kfXicPlus); kfXi.TransportToParticle(kfXicPlus); - //---------------------calculate physical parameters of XicPlus candidate---------------------- - // set hfFlag - int hfFlag = BIT(aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); - + //---------------------calculate physical parameters of XicPlus candidate---------------------- // sign of charm baryon int signXic = casc.sign() < 0 ? +1 : -1; @@ -761,7 +742,6 @@ struct HfCandidateCreatorXic { kfCharmBachelor1.GetPx(), kfCharmBachelor1.GetPy(), kfCharmBachelor1.GetPz(), impactParameterXiXY, impactParameterPi0XY, impactParameterPi1XY, errImpactParameterXiXY, errImpactParameterPi0XY, errImpactParameterPi1XY, - hfFlag, /*cascade specific columns*/ casc.x(), casc.y(), casc.z(), casc.xlambda(), casc.ylambda(), casc.zlambda(), @@ -792,15 +772,16 @@ struct HfCandidateCreatorXicExpressions { int indexRec = -1; int indexRecXicPlus = -1; - int indexRes = -1; - int8_t sign = -9; + int8_t sign = 0; int8_t flag = 0; int8_t origin = 0; int8_t debug = 0; + std::vector arrDaughIndex; + std::array arrPDGDaugh; + std::array arrXiResonance = {3324, kPiPlus}; // 3324: Ξ(1530) int pdgCodeXicPlus = Pdg::kXiCPlus; // 4232 int pdgCodeXiMinus = kXiMinus; // 3312 - int pdgCodeXiRes = 3324; // 3324 int pdgCodeLambda = kLambda0; // 3122 int pdgCodePiPlus = kPiPlus; // 211 int pdgCodePiMinus = kPiMinus; // -211 @@ -809,19 +790,16 @@ struct HfCandidateCreatorXicExpressions { // Match reconstructed candidates. for (const auto& candidate : *rowCandidateXic) { flag = 0; - sign = -9; + sign = 0; origin = RecoDecay::OriginType::None; debug = 0; + arrDaughIndex.clear(); auto arrayDaughters = std::array{candidate.pi0_as(), // pi <- Xic candidate.pi1_as(), // pi <- Xic candidate.bachelor_as(), // pi <- cascade candidate.posTrack_as(), // p <- lambda candidate.negTrack_as()}; // pi <- lambda - auto arrayDaughtersResPi0 = std::array{candidate.cascade_as(), - candidate.pi0_as()}; - auto arrayDaughtersResPi1 = std::array{candidate.cascade_as(), - candidate.pi1_as()}; auto arrayDaughtersCasc = std::array{candidate.bachelor_as(), candidate.posTrack_as(), candidate.negTrack_as()}; @@ -847,17 +825,19 @@ struct HfCandidateCreatorXicExpressions { debug = 3; } if (indexRec > -1) { - // Xic → Xi(1530) pi - indexRes = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughtersResPi0, pdgCodeXicPlus, std::array{pdgCodeXiRes, pdgCodePiMinus}, true, &sign, 1); - if (indexRes > -1) { - flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi); - } else if (indexRes == -1) { - indexRes = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughtersResPi1, pdgCodeXicPlus, std::array{pdgCodeXiRes, pdgCodePiMinus}, true, &sign, 1); - if (indexRes > -1) { + RecoDecay::getDaughters(mcParticles.rawIteratorAt(indexRecXicPlus), &arrDaughIndex, std::array{0}, 1); + if (arrDaughIndex.size() == 2) { + for (auto iProng = 0u; iProng < arrDaughIndex.size(); ++iProng) { + auto daughI = mcParticles.rawIteratorAt(arrDaughIndex[iProng]); + arrPDGDaugh[iProng] = std::abs(daughI.pdgCode()); + } + if ((arrPDGDaugh[0] == arrXiResonance[0] && arrPDGDaugh[1] == arrXiResonance[1]) || (arrPDGDaugh[0] == arrXiResonance[1] && arrPDGDaugh[1] == arrXiResonance[0])) { flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi); - } else if (indexRes == -1) { - flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); + } else { + debug = 4; } + } else { + flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); } } } @@ -875,9 +855,10 @@ struct HfCandidateCreatorXicExpressions { // Match generated particles. for (const auto& particle : mcParticles) { flag = 0; - sign = -9; + sign = 0; debug = 0; origin = RecoDecay::OriginType::None; + arrDaughIndex.clear(); // Xic → Xi pi pi if (RecoDecay::isMatchedMCGen(mcParticles, particle, pdgCodeXicPlus, std::array{pdgCodeXiMinus, pdgCodePiPlus, pdgCodePiPlus}, true, &sign, 2)) { @@ -890,10 +871,20 @@ struct HfCandidateCreatorXicExpressions { auto v0MC = mcParticles.rawIteratorAt(cascMC.daughtersIds().front()); if (RecoDecay::isMatchedMCGen(mcParticles, v0MC, pdgCodeLambda, std::array{pdgCodeProton, pdgCodePiMinus}, true)) { debug = 3; - if (RecoDecay::isMatchedMCGen(mcParticles, particle, pdgCodeXicPlus, std::array{pdgCodeXiRes, pdgCodePiMinus}, true)) { - flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi); + + RecoDecay::getDaughters(particle, &arrDaughIndex, std::array{0}, 1); + if (arrDaughIndex.size() == 2) { + for (auto iProng = 0u; iProng < arrDaughIndex.size(); ++iProng) { + auto daughI = mcParticles.rawIteratorAt(arrDaughIndex[iProng]); + arrPDGDaugh[iProng] = std::abs(daughI.pdgCode()); + } + if ((arrPDGDaugh[0] == arrXiResonance[0] && arrPDGDaugh[1] == arrXiResonance[1]) || (arrPDGDaugh[0] == arrXiResonance[1] && arrPDGDaugh[1] == arrXiResonance[0])) { + flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi); + } else { + debug = 4; + } } else { - flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); + flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); } } } diff --git a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx index 3da11bd4d15..70dc1eeaf01 100644 --- a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx @@ -187,14 +187,11 @@ struct HfCandidateSelectorXicToXiPiPi { int statusXicToXiPiPi = 0; auto ptCandXic = hfCandXic.pt(); - // check if flagged as Ξc± → Ξ∓ π± π± - if (!TESTBIT(hfCandXic.hfflag(), hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { - hfSelXicToXiPiPiCandidate(statusXicToXiPiPi); - if (activateQA) { - registry.fill(HIST("hSelections"), 1, ptCandXic); - } - continue; + if (activateQA) { + registry.fill(HIST("hSelections"), 1, ptCandXic); } + + // No hfFlag -> by default skim selected SETBIT(statusXicToXiPiPi, SelectionStep::RecoSkims); // RecoSkims = 0 --> statusXicToXiPiPi = 1 if (activateQA) { registry.fill(HIST("hSelections"), 2 + SelectionStep::RecoSkims, ptCandXic); From 883acd5cd6695f961f753833f57face007ca3290 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Thu, 20 Jun 2024 18:41:07 +0200 Subject: [PATCH 28/35] Remove process function independent of HfTrackIndexSkimCreatorLfCascades for PR --- .../candidateCreatorXicToXiPiPi.cxx | 258 +----------------- 1 file changed, 2 insertions(+), 256 deletions(-) diff --git a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index 684105ad760..5b820f3655b 100644 --- a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -47,7 +47,6 @@ using namespace o2::analysis; using namespace o2::aod::hf_cand_xictoxipipi; using namespace o2::constants::physics; using namespace o2::framework; -using namespace o2::framework::expressions; /// Reconstruction of heavy-flavour 3-prong decay candidates struct HfCandidateCreatorXic { @@ -95,14 +94,6 @@ struct HfCandidateCreatorXic { using CascFull = soa::Join; using KFCascadesLinked = soa::Join; using KFCascFull = soa::Join; - using SelectedCollisions = soa::Filtered>; - using SelectedHfTrackAssoc = soa::Filtered>; - - Filter filterSelectCollisions = (aod::hf_sel_collision::whyRejectColl == static_cast(0)); - Filter filterSelectTrackIds = ((aod::hf_sel_track::isSelProng & static_cast(BIT(4))) != 0u); // corresponds to CandidateType::CandCascadeBachelor in trackIndexSkimCreator.cxx - - Preslice trackIndicesPerCollision = aod::track_association::collisionId; - Preslice linkedCascadesPerCollision = aod::cascdata::collisionId; OutputObj hMass3{TH1F("hMass3", "3-prong candidates;inv. mass (#Xi #pi #pi) (GeV/#it{c}^{2});entries", 500, 2.3, 2.7)}; OutputObj hCovPVXX{TH1F("hCovPVXX", "3-prong candidates;XX element of cov. matrix of prim. vtx. position (cm^{2});entries", 100, 0., 1.e-4)}; @@ -125,14 +116,13 @@ struct HfCandidateCreatorXic { lut = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdb->get(ccdbPathLut)); runNumber = 0; - std::array doprocessKF{doprocessXicplusWithKFParticleFromDerivedData, doprocessXicplusWithKFParticle}; - if ((doprocessXicplusWithDcaFitter + std::accumulate(doprocessKF.begin(), doprocessKF.end(), 0)) != 1) { + if ((doprocessXicplusWithDcaFitter + doprocessXicplusWithKFParticleFromDerivedData) != 1) { LOGP(fatal, "Only one process function can be enabled at a time."); } if ((doprocessXicplusWithDcaFitter == 1) && fillHistograms) { hVertexerType->Fill(aod::hf_cand::VertexerType::DCAFitter); } - if ((std::accumulate(doprocessKF.begin(), doprocessKF.end(), 0) == 1) && fillHistograms) { + if ((doprocessXicplusWithKFParticleFromDerivedData == 1) && fillHistograms) { hVertexerType->Fill(aod::hf_cand::VertexerType::KfParticle); } } @@ -511,250 +501,6 @@ struct HfCandidateCreatorXic { } // loop over track triplets } PROCESS_SWITCH(HfCandidateCreatorXic, processXicplusWithKFParticleFromDerivedData, "Run candidate creator with KFParticle using derived data from HfTrackIndexSkimCreatorLfCascades.", false); - - void processXicplusWithKFParticle(SelectedCollisions const& collisions, - SelectedHfTrackAssoc const& trackIndices, - KFCascadesLinked const& linkedCascades, - KFCascFull const&, - aod::TracksWCovExtra const&, - aod::BCsWithTimestamps const&) - { - for (const auto& collision : collisions) { - //------------------------- Set the magnetic field from ccdb--------------------------------- - /// The static instance of the propagator was already modified in the HFTrackIndexSkimCreator, - /// but this is not true when running on Run2 data/MC already converted into AO2Ds. - auto bc = collision.bc_as(); - if (runNumber != bc.runNumber()) { - LOG(info) << ">>>>>>>>>>>> Current run number: " << runNumber; - initCCDB(bc, runNumber, ccdb, isRun2 ? ccdbPathGrp : ccdbPathGrpMag, lut, isRun2); - bz = o2::base::Propagator::Instance()->getNominalBz(); - LOG(info) << ">>>>>>>>>>>> Magnetic field: " << bz; - } - KFParticle::SetField(bz); - - // ------------------------------------cascade loop------------------------------------------- - auto thisCollId = collision.globalIndex(); - // auto groupedCascades = cascades.sliceBy(cascadesPerCollision, thisCollId); - auto groupedLinkedCascades = linkedCascades.sliceBy(linkedCascadesPerCollision, thisCollId); - for (const auto& linkedCasc : groupedLinkedCascades) { - if (!linkedCasc.has_kfCascData()) { - continue; - } - auto casc = linkedCasc.kfCascData_as(); - - //----------------accessing particles in the decay chain------------- - // cascade daughter - charged particle - auto trackCascDauCharged = casc.bachelor_as(); // meson <- xi track - // cascade daughter - V0 - auto trackV0PosDau = casc.posTrack_as(); // p <- V0 track (positive track) 0 - // V0 negative daughter - auto trackV0NegDau = casc.negTrack_as(); // pion <- V0 track (negative track) 1 - - // check that particles come from the same collision - if (rejDiffCollTrack) { - if (trackV0PosDau.collisionId() != trackV0NegDau.collisionId()) { - continue; - } - if (trackCascDauCharged.collisionId() != trackV0PosDau.collisionId()) { - continue; - } - } - // check not to take cascade daughters twice - if (trackV0PosDau.globalIndex() == trackV0NegDau.globalIndex() || trackV0PosDau.globalIndex() == trackCascDauCharged.globalIndex() || trackV0NegDau.globalIndex() == trackCascDauCharged.globalIndex()) { - continue; - } - - // preselect cascade candidates - if (doCascadePreselection) { - if (std::abs(casc.dcaXYCascToPV()) > dcaXYToPVCascadeMax) { - continue; - } - if (std::abs(casc.mXi() - massXiMinusFromPdg) > massToleranceCascade) { - continue; - } - } - - //--------------------------------------loop over first bachelor----------------------------------------------------- - auto groupedBachTrackIndices = trackIndices.sliceBy(trackIndicesPerCollision, thisCollId); - for (auto trackIdCharmBachelor0 = groupedBachTrackIndices.begin(); trackIdCharmBachelor0 != groupedBachTrackIndices.end(); ++trackIdCharmBachelor0) { - auto trackCharmBachelor0 = trackIdCharmBachelor0.track_as(); - - // check that particles come from the same collision - if ((rejDiffCollTrack) && (trackCascDauCharged.collisionId() != trackCharmBachelor0.collisionId())) { - continue; - } - // ask for opposite sign daughters - if (trackCharmBachelor0.sign() * trackCascDauCharged.sign() >= 0) { - continue; - } - // check not to take the same particle twice in the decay chain - if (trackCharmBachelor0.globalIndex() == trackCascDauCharged.globalIndex() || trackCharmBachelor0.globalIndex() == trackV0PosDau.globalIndex() || trackCharmBachelor0.globalIndex() == trackV0NegDau.globalIndex()) { - continue; - } - - //-----------------------------------------------loop over second bachelor--------------------------------------------------------------------------- - for (auto trackIdCharmBachelor1 = trackIdCharmBachelor0 + 1; trackIdCharmBachelor1 != groupedBachTrackIndices.end(); ++trackIdCharmBachelor1) { - auto trackCharmBachelor1 = trackIdCharmBachelor1.track_as(); - // check that particles come from the same collision - if ((rejDiffCollTrack) && (trackCascDauCharged.collisionId() != trackCharmBachelor1.collisionId())) { - continue; - } - // ask for same sign daughters - if (trackCharmBachelor1.sign() * trackCharmBachelor0.sign() <= 0) { - continue; - } - // check not to take the same particle twice in the decay chain - if (trackCharmBachelor1.globalIndex() == trackCharmBachelor0.globalIndex() || trackCharmBachelor1.globalIndex() == trackCascDauCharged.globalIndex() || trackCharmBachelor1.globalIndex() == trackV0PosDau.globalIndex() || trackCharmBachelor1.globalIndex() == trackV0NegDau.globalIndex()) { - continue; - } - - //----------------------info of V0 and cascade tracks from LF-table------------------ - 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 XicPlus as KFParticle object------------------------------------------- - // initialize primary vertex - KFPVertex kfpVertex = createKFPVertexFromCollision(collision); - float covMatrixPV[6]; - kfpVertex.GetCovarianceMatrix(covMatrixPV); - KFParticle KFPV(kfpVertex); // for calculation of DCAs to PV - - // convert pion tracks into KFParticle object - KFPTrack kfpTrackCharmBachelor0 = createKFPTrackFromTrack(trackCharmBachelor0); - KFPTrack kfpTrackCharmBachelor1 = createKFPTrackFromTrack(trackCharmBachelor1); - KFParticle kfCharmBachelor0(kfpTrackCharmBachelor0, kPiPlus); - KFParticle kfCharmBachelor1(kfpTrackCharmBachelor1, kPiPlus); - - // create Xi as KFParticle object - // read {X,Y,Z,Px,Py,Pz} and corresponding covariance matrix from KF cascade Tables - std::array xyzpxpypz = {casc.x(), casc.y(), casc.z(), casc.px(), casc.py(), casc.pz()}; - float parPosMom[6]; - for (int i{0}; i < 6; ++i) { - parPosMom[i] = xyzpxpypz[i]; - } - // create KFParticle - KFParticle kfXi; - kfXi.Create(parPosMom, casc.kfTrackCovMat(), casc.sign(), casc.mXi()); - - // create XicPlus as KFParticle object - KFParticle kfXicPlus; - const KFParticle* kfDaughtersXicPlus[3] = {&kfCharmBachelor0, &kfCharmBachelor1, &kfXi}; - kfXicPlus.SetConstructMethod(kfConstructMethod); - try { - kfXicPlus.Construct(kfDaughtersXicPlus, 3); - } catch (std::runtime_error& e) { - LOG(debug) << "Failed to construct XicPlus : " << e.what(); - continue; - } - - // topological constraint - if (constrainXicPlusToPv) { - kfXicPlus.SetProductionVertex(KFPV); - } - auto covMatrixXicPlus = kfXicPlus.CovarianceMatrix(); - - // transport daughter particles to XicPlus decay vertex - kfCharmBachelor0.TransportToParticle(kfXicPlus); - kfCharmBachelor1.TransportToParticle(kfXicPlus); - kfXi.TransportToParticle(kfXicPlus); - - //---------------------calculate physical parameters of XicPlus candidate---------------------- - // sign of charm baryon - int signXic = casc.sign() < 0 ? +1 : -1; - - // get impact parameters of XicPlus daughters - float impactParameterPi0XY = 0., errImpactParameterPi0XY = 0.; - float impactParameterPi1XY = 0., errImpactParameterPi1XY = 0.; - float impactParameterXiXY = 0., errImpactParameterXiXY = 0.; - kfCharmBachelor0.GetDistanceFromVertexXY(KFPV, impactParameterPi0XY, errImpactParameterPi0XY); - kfCharmBachelor1.GetDistanceFromVertexXY(KFPV, impactParameterPi1XY, errImpactParameterPi1XY); - kfXi.GetDistanceFromVertexXY(KFPV, impactParameterXiXY, errImpactParameterXiXY); - - // calculate cosine of pointing angle - std::array pvCoord = {collision.posX(), collision.posY(), collision.posZ()}; - double cpaLambda = casc.v0cosPA(collision.posX(), collision.posY(), collision.posZ()); - double cpaXYLambda = RecoDecay::cpaXY(pvCoord, vertexV0, pVecV0); - double cpaXi = casc.casccosPA(collision.posX(), collision.posY(), collision.posZ()); - double cpaXYXi = RecoDecay::cpaXY(pvCoord, vertexCasc, pVecCasc); - - // get DCAs of Pi0-Pi1, Pi0-Xi, Pi1-Xi - float dcaXYPi0Pi1 = kfCharmBachelor0.GetDistanceFromParticleXY(kfCharmBachelor1); - float dcaXYPi0Xi = kfCharmBachelor0.GetDistanceFromParticleXY(kfXi); - float dcaXYPi1Xi = kfCharmBachelor1.GetDistanceFromParticleXY(kfXi); - - // mass of Xi-Pi0 pair - KFParticle kfXiPi0; - const KFParticle* kfXiResonanceDaughtersPi0[2] = {&kfXi, &kfCharmBachelor0}; - kfXiPi0.SetConstructMethod(kfConstructMethod); - try { - kfXiPi0.Construct(kfXiResonanceDaughtersPi0, 2); - massXiPi0 = kfXiPi0.GetMass(); - } catch(...) { - LOG(info) << "Failed to construct Xi(1530) with Pi 0"; - } - - // mass of Xi-Pi1 pair - KFParticle kfXiPi1; - const KFParticle* kfXiResonanceDaughtersPi1[2] = {&kfXi, &kfCharmBachelor1}; - kfXiPi1.SetConstructMethod(kfConstructMethod); - try { - kfXiPi1.Construct(kfXiResonanceDaughtersPi1, 2); - massXiPi1 = kfXiPi1.GetMass(); - } catch(...){ - LOG(info) << "Failed to construct Xi(1530) with Pi 1"; - } - - //-------------------------------fill histograms-------------------------------------------- - if (fillHistograms) { - // invariant mass - hMass3->Fill(kfXicPlus.GetMass()); - // covariance matrix elements of PV - hCovPVXX->Fill(covMatrixPV[0]); - hCovPVYY->Fill(covMatrixPV[2]); - hCovPVXZ->Fill(covMatrixPV[3]); - hCovPVZZ->Fill(covMatrixPV[5]); - // covariance matrix elements of SV - hCovSVXX->Fill(covMatrixXicPlus[0]); - hCovSVYY->Fill(covMatrixXicPlus[2]); - hCovSVXZ->Fill(covMatrixXicPlus[3]); - hCovSVZZ->Fill(covMatrixXicPlus[5]); - // DCAs of prongs - hDcaXYProngs->Fill(kfCharmBachelor0.GetPt(), impactParameterPi0XY); - hDcaXYProngs->Fill(kfCharmBachelor1.GetPt(), impactParameterPi1XY); - hDcaXYProngs->Fill(kfXi.GetPt(), impactParameterXiXY); - } - - //------------------------------fill candidate table rows-------------------------------------- - rowCandidateBase(collision.globalIndex(), - KFPV.GetX(), KFPV.GetY(), KFPV.GetZ(), - covMatrixPV[0], covMatrixPV[2], covMatrixPV[5], - /*3-prong specific columns*/ - casc.cascadeId(), trackCharmBachelor0.globalIndex(), trackCharmBachelor1.globalIndex(), - casc.bachelorId(), casc.posTrackId(), casc.negTrackId(), - kfXicPlus.GetX(), kfXicPlus.GetY(), kfXicPlus.GetZ(), - kfXicPlus.GetErrX(), kfXicPlus.GetErrY(), kfXicPlus.GetErrZ(), - kfXicPlus.GetErrDecayLength(), kfXicPlus.GetErrDecayLengthXY(), - kfXicPlus.GetChi2(), kfXicPlus.GetMass(), signXic, - kfXi.GetPx(), kfXi.GetPy(), kfXi.GetPz(), - kfCharmBachelor0.GetPx(), kfCharmBachelor0.GetPy(), kfCharmBachelor0.GetPz(), - kfCharmBachelor1.GetPx(), kfCharmBachelor1.GetPy(), kfCharmBachelor1.GetPz(), - impactParameterXiXY, impactParameterPi0XY, impactParameterPi1XY, - errImpactParameterXiXY, errImpactParameterPi0XY, errImpactParameterPi1XY, - /*cascade specific columns*/ - casc.x(), casc.y(), casc.z(), - casc.xlambda(), casc.ylambda(), casc.zlambda(), - cpaXi, cpaXYXi, cpaLambda, cpaXYLambda, - massXiPi0, massXiPi1); - rowCandidateKF(casc.kfCascadeChi2(), casc.kfV0Chi2(), - dcaXYPi0Pi1, dcaXYPi0Xi, dcaXYPi1Xi); - } // bachelor 1 - } // bachelor 0 - } // cascades - } // collisions - } - PROCESS_SWITCH(HfCandidateCreatorXic, processXicplusWithKFParticle, "Run candidate creator with KFParticle", false); }; // struct /// Performs MC matching. From 7f4adb7b43590a8c94f834594b4159c122ce7785 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 20 Jun 2024 16:49:57 +0000 Subject: [PATCH 29/35] Please consider the following formatting changes --- PWGHF/Core/SelectorCuts.h | 152 ++++++++++++++++-- PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx | 8 +- .../DataModel/CandidateReconstructionTables.h | 4 +- PWGHF/DataModel/CandidateSelectionTables.h | 4 +- .../candidateCreatorXicToXiPiPi.cxx | 36 ++--- .../candidateSelectorXicToXiPiPi.cxx | 5 +- .../TableProducer/treeCreatorXicToXiPiPi.cxx | 114 ++++++------- 7 files changed, 226 insertions(+), 97 deletions(-) diff --git a/PWGHF/Core/SelectorCuts.h b/PWGHF/Core/SelectorCuts.h index a175d437533..8876ce00674 100644 --- a/PWGHF/Core/SelectorCuts.h +++ b/PWGHF/Core/SelectorCuts.h @@ -721,16 +721,146 @@ constexpr double binsPt[nBinsPt + 1] = { auto vecBinsPt = std::vector{binsPt, binsPt + nBinsPt + 1}; // default values for the cuts m ptXi ptPi0 ptPi1 chi2PCA dL dLXY cosp cospXY impParXY Xi Pi0 Pi1 -constexpr double cuts[nBinsPt][nCutVars] = {{0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 0 < pT < 1 */ - {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 1 < pT < 2 */ - {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 2 < pT < 3 */ - {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 3 < pT < 4 */ - {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 4 < pT < 5 */ - {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 5 < pT < 6 */ - {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 6 < pT < 8 */ - {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 8 < pT < 12 */ - {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}, /* 12 < pT < 24 */ - {0.400, 0.4, 0.4, 0.4, 1e-5, 0.005, 0.005, 0.8, 0.8, 0.1, 0.1, 0.1,}}; /* 24 < pT < 36 */ +constexpr double cuts[nBinsPt][nCutVars] = {{ + 0.400, + 0.4, + 0.4, + 0.4, + 1e-5, + 0.005, + 0.005, + 0.8, + 0.8, + 0.1, + 0.1, + 0.1, + }, /* 0 < pT < 1 */ + { + 0.400, + 0.4, + 0.4, + 0.4, + 1e-5, + 0.005, + 0.005, + 0.8, + 0.8, + 0.1, + 0.1, + 0.1, + }, /* 1 < pT < 2 */ + { + 0.400, + 0.4, + 0.4, + 0.4, + 1e-5, + 0.005, + 0.005, + 0.8, + 0.8, + 0.1, + 0.1, + 0.1, + }, /* 2 < pT < 3 */ + { + 0.400, + 0.4, + 0.4, + 0.4, + 1e-5, + 0.005, + 0.005, + 0.8, + 0.8, + 0.1, + 0.1, + 0.1, + }, /* 3 < pT < 4 */ + { + 0.400, + 0.4, + 0.4, + 0.4, + 1e-5, + 0.005, + 0.005, + 0.8, + 0.8, + 0.1, + 0.1, + 0.1, + }, /* 4 < pT < 5 */ + { + 0.400, + 0.4, + 0.4, + 0.4, + 1e-5, + 0.005, + 0.005, + 0.8, + 0.8, + 0.1, + 0.1, + 0.1, + }, /* 5 < pT < 6 */ + { + 0.400, + 0.4, + 0.4, + 0.4, + 1e-5, + 0.005, + 0.005, + 0.8, + 0.8, + 0.1, + 0.1, + 0.1, + }, /* 6 < pT < 8 */ + { + 0.400, + 0.4, + 0.4, + 0.4, + 1e-5, + 0.005, + 0.005, + 0.8, + 0.8, + 0.1, + 0.1, + 0.1, + }, /* 8 < pT < 12 */ + { + 0.400, + 0.4, + 0.4, + 0.4, + 1e-5, + 0.005, + 0.005, + 0.8, + 0.8, + 0.1, + 0.1, + 0.1, + }, /* 12 < pT < 24 */ + { + 0.400, + 0.4, + 0.4, + 0.4, + 1e-5, + 0.005, + 0.005, + 0.8, + 0.8, + 0.1, + 0.1, + 0.1, + }}; /* 24 < pT < 36 */ // row labels static const std::vector labelsPt = { @@ -746,7 +876,7 @@ static const std::vector labelsPt = { "pT bin 9"}; // column labels -static const std::vector labelsCutVar = {"m", "pT Xi", "pT Pi0", "pT Pi1", "chi2PCA", "max decay length", "max decay length XY", "cos pointing angle", "cos pointing angle XY", "max impParXY Xi", "max impParXY Pi0", "max impParXY Pi1"}; +static const std::vector labelsCutVar = {"m", "pT Xi", "pT Pi0", "pT Pi1", "chi2PCA", "max decay length", "max decay length XY", "cos pointing angle", "cos pointing angle XY", "max impParXY Xi", "max impParXY Pi0", "max impParXY Pi1"}; } // namespace hf_cuts_xic_to_xi_pi_pi namespace hf_cuts_xicc_to_p_k_pi_pi diff --git a/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx index b68ff5211ed..16111287ebd 100644 --- a/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx +++ b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx @@ -56,7 +56,7 @@ struct HfTaskXicToXiPiPi { void init(InitContext const&) { static const AxisSpec axisMassXic = {300, 1.8, 3.0, "inv. mass (GeV/#it{c}^{2})"}; - static const AxisSpec axisMassXiRes= {300, 1.0,2.0, "inv. mass (GeV/#it{c}^{2})"}; + static const AxisSpec axisMassXiRes = {300, 1.0, 2.0, "inv. mass (GeV/#it{c}^{2})"}; static const AxisSpec axisPt = {(std::vector)binsPt, "#it{p}_{T} (GeV/#it{c})"}; registry.add("hEta", "#Xi^{#plus}_{c} candidates;#Xi^{#plus}_{c} candidate #it{#eta};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); @@ -219,8 +219,8 @@ struct HfTaskXicToXiPiPi { aod::TracksWMc const&) { std::vector arrDaughIndex; - int pdgCodeXiMinus = kXiMinus; // 3312 - int pdgCodePiPlus = kPiPlus; // 211 + int pdgCodeXiMinus = kXiMinus; // 3312 + int pdgCodePiPlus = kPiPlus; // 211 // MC rec for (const auto& candidate : candidates) { @@ -287,7 +287,7 @@ struct HfTaskXicToXiPiPi { registry.fill(HIST("hCPALambdaRecBg"), candidate.cosPaLambda(), ptCandXic); registry.fill(HIST("hCPAxyLambdaRecBg"), candidate.cosPaLambda(), ptCandXic); } - + if (checkDecayTypeMc) { if (TESTBIT(flagMcMatchRecXic, hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_xictoxipipi::DecayType::XicToXiPiPi, candidate.invMassXic(), ptCandXic); diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index ab567658326..146b6fa858f 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1357,7 +1357,7 @@ DECLARE_SOA_COLUMN(DebugMcGen, debugMcGen, int8_t); DECLARE_SOA_COLUMN(OriginRec, originRec, int8_t); DECLARE_SOA_COLUMN(OriginGen, originGen, int8_t); // mapping of decay types -enum DecayType { XicToXiPiPi=0, +enum DecayType { XicToXiPiPi = 0, XicToXiResPiToXiPiPi, NDecayType }; } // end of namespace hf_cand_xictoxipipi @@ -1418,7 +1418,7 @@ DECLARE_SOA_EXTENDED_TABLE_USER(HfCandXicExt, HfCandXicBase, "HFCANDXICEXT", using HfCandXic = HfCandXicExt; DECLARE_SOA_TABLE(HfCandXicKF, "AOD", "HFCANDXICKF", - cascdata::KFCascadeChi2, cascdata::KFV0Chi2, + cascdata::KFCascadeChi2, cascdata::KFV0Chi2, hf_cand_xictoxipipi::DcaPi0Pi1, hf_cand_xictoxipipi::DcaPi0Xi, hf_cand_xictoxipipi::DcaPi1Xi); // table with results of reconstruction level MC matching diff --git a/PWGHF/DataModel/CandidateSelectionTables.h b/PWGHF/DataModel/CandidateSelectionTables.h index 2cea370fa07..18abbb95692 100644 --- a/PWGHF/DataModel/CandidateSelectionTables.h +++ b/PWGHF/DataModel/CandidateSelectionTables.h @@ -307,7 +307,7 @@ DECLARE_SOA_COLUMN(IsSelXicToPiKP, isSelXicToPiKP, int); //! DECLARE_SOA_COLUMN(MlProbXicToPKPi, mlProbXicToPKPi, std::vector); //! DECLARE_SOA_COLUMN(MlProbXicToPiKP, mlProbXicToPiKP, std::vector); //! // XicPlus to Xi Pi Pi -DECLARE_SOA_COLUMN(IsSelXicToXiPiPi, isSelXicToXiPiPi, int); //! +DECLARE_SOA_COLUMN(IsSelXicToXiPiPi, isSelXicToXiPiPi, int); //! DECLARE_SOA_COLUMN(MlProbXicToXiPiPi, mlProbXicToXiPiPi, std::vector); //! } // namespace hf_sel_candidate_xic @@ -315,7 +315,7 @@ DECLARE_SOA_TABLE(HfSelXicToPKPi, "AOD", "HFSELXIC", //! hf_sel_candidate_xic::IsSelXicToPKPi, hf_sel_candidate_xic::IsSelXicToPiKP); DECLARE_SOA_TABLE(HfMlXicToPKPi, "AOD", "HFMLXIC", //! hf_sel_candidate_xic::MlProbXicToPKPi, hf_sel_candidate_xic::MlProbXicToPiKP); -// XicPlus to Xi Pi Pi +// XicPlus to Xi Pi Pi DECLARE_SOA_TABLE(HfSelXicToXiPiPi, "AOD", "HFSELXICTOXI2PI", //! hf_sel_candidate_xic::IsSelXicToXiPiPi); DECLARE_SOA_TABLE(HfMlXicToXiPiPi, "AOD", "HFMLXICTOXIPIPI", //! diff --git a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index 5b820f3655b..9d2dd78501f 100644 --- a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -440,7 +440,7 @@ struct HfCandidateCreatorXic { try { kfXiPi0.Construct(kfXiResonanceDaughtersPi0, 2); massXiPi0 = kfXiPi0.GetMass(); - } catch(...) { + } catch (...) { LOG(info) << "Failed to construct Xi(1530) with Pi 0"; } @@ -451,7 +451,7 @@ struct HfCandidateCreatorXic { try { kfXiPi1.Construct(kfXiResonanceDaughtersPi1, 2); massXiPi1 = kfXiPi1.GetMass(); - } catch(...){ + } catch (...) { LOG(info) << "Failed to construct Xi(1530) with Pi 1"; } @@ -526,12 +526,12 @@ struct HfCandidateCreatorXicExpressions { std::array arrPDGDaugh; std::array arrXiResonance = {3324, kPiPlus}; // 3324: Ξ(1530) - int pdgCodeXicPlus = Pdg::kXiCPlus; // 4232 - int pdgCodeXiMinus = kXiMinus; // 3312 - int pdgCodeLambda = kLambda0; // 3122 - int pdgCodePiPlus = kPiPlus; // 211 - int pdgCodePiMinus = kPiMinus; // -211 - int pdgCodeProton = kProton; // 2212 + int pdgCodeXicPlus = Pdg::kXiCPlus; // 4232 + int pdgCodeXiMinus = kXiMinus; // 3312 + int pdgCodeLambda = kLambda0; // 3122 + int pdgCodePiPlus = kPiPlus; // 211 + int pdgCodePiMinus = kPiMinus; // -211 + int pdgCodeProton = kProton; // 2212 // Match reconstructed candidates. for (const auto& candidate : *rowCandidateXic) { @@ -621,16 +621,16 @@ struct HfCandidateCreatorXicExpressions { RecoDecay::getDaughters(particle, &arrDaughIndex, std::array{0}, 1); if (arrDaughIndex.size() == 2) { for (auto iProng = 0u; iProng < arrDaughIndex.size(); ++iProng) { - auto daughI = mcParticles.rawIteratorAt(arrDaughIndex[iProng]); - arrPDGDaugh[iProng] = std::abs(daughI.pdgCode()); - } - if ((arrPDGDaugh[0] == arrXiResonance[0] && arrPDGDaugh[1] == arrXiResonance[1]) || (arrPDGDaugh[0] == arrXiResonance[1] && arrPDGDaugh[1] == arrXiResonance[0])) { - flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi); - } else { - debug = 4; - } + auto daughI = mcParticles.rawIteratorAt(arrDaughIndex[iProng]); + arrPDGDaugh[iProng] = std::abs(daughI.pdgCode()); + } + if ((arrPDGDaugh[0] == arrXiResonance[0] && arrPDGDaugh[1] == arrXiResonance[1]) || (arrPDGDaugh[0] == arrXiResonance[1] && arrPDGDaugh[1] == arrXiResonance[0])) { + flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi); + } else { + debug = 4; + } } else { - flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); + flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); } } } @@ -643,7 +643,7 @@ struct HfCandidateCreatorXicExpressions { rowMcMatchGen(flag, debug, origin); } // close loop over generated particles - } // close process + } // close process PROCESS_SWITCH(HfCandidateCreatorXicExpressions, processMc, "Process MC", false); }; // close struct diff --git a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx index 70dc1eeaf01..1c68d35bf80 100644 --- a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx @@ -93,7 +93,6 @@ struct HfCandidateSelectorXicToXiPiPi { registry.get(HIST("hSelections"))->GetXaxis()->SetBinLabel(iBin + 1, labels[iBin].data()); } } - } /// Conjugate-independent topological cuts @@ -151,8 +150,8 @@ struct HfCandidateSelectorXicToXiPiPi { } // cut on daughter pT - if (hfCandXic.ptProng0() < cuts->get(pTBin, "pT Xi") || - hfCandXic.ptProng1() < cuts->get(pTBin, "pT Pi0") || + if (hfCandXic.ptProng0() < cuts->get(pTBin, "pT Xi") || + hfCandXic.ptProng1() < cuts->get(pTBin, "pT Pi0") || hfCandXic.ptProng2() < cuts->get(pTBin, "pT Pi1")) { return false; } diff --git a/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx index 61d382fa4c8..6723b31c62e 100644 --- a/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx @@ -30,59 +30,59 @@ namespace o2::aod namespace full { // track indices -DECLARE_SOA_COLUMN(CandidateSelFlag, candidateSelFlag, int); //! Selection flag of candidate (output of candidateSelector) +DECLARE_SOA_COLUMN(CandidateSelFlag, candidateSelFlag, int); //! Selection flag of candidate (output of candidateSelector) DECLARE_SOA_INDEX_COLUMN_FULL(Xi, xi, int, Tracks, "_pi0"); DECLARE_SOA_INDEX_COLUMN_FULL(Pi0, pi0, int, Tracks, "_pi0"); DECLARE_SOA_INDEX_COLUMN_FULL(Pi1, pi1, int, Tracks, "_pi1"); -//vertices +// vertices DECLARE_SOA_COLUMN(XPv, xPv, float); -DECLARE_SOA_COLUMN(YPv, yPv, float); +DECLARE_SOA_COLUMN(YPv, yPv, float); DECLARE_SOA_COLUMN(ZPv, zPv, float); DECLARE_SOA_COLUMN(XPvErr, xPvErr, float); -DECLARE_SOA_COLUMN(YPvErr, yPvErr, float); -DECLARE_SOA_COLUMN(ZPvErr, zPvErr, float); -DECLARE_SOA_COLUMN(XSv, xSv, float); -DECLARE_SOA_COLUMN(YSv, ySv, float); +DECLARE_SOA_COLUMN(YPvErr, yPvErr, float); +DECLARE_SOA_COLUMN(ZPvErr, zPvErr, float); +DECLARE_SOA_COLUMN(XSv, xSv, float); +DECLARE_SOA_COLUMN(YSv, ySv, float); DECLARE_SOA_COLUMN(ZSv, zSv, float); DECLARE_SOA_COLUMN(Chi2Sv, chi2Sv, float); -DECLARE_SOA_COLUMN(XSvErr, xSvErr, float); -DECLARE_SOA_COLUMN(YSvErr, ySvErr, float); +DECLARE_SOA_COLUMN(XSvErr, xSvErr, float); +DECLARE_SOA_COLUMN(YSvErr, ySvErr, float); DECLARE_SOA_COLUMN(ZSvErr, zSvErr, float); -DECLARE_SOA_COLUMN(XDecVtxXi, xDecVtxXi, float); -DECLARE_SOA_COLUMN(YDecVtxXi, yDecVtxXi, float); +DECLARE_SOA_COLUMN(XDecVtxXi, xDecVtxXi, float); +DECLARE_SOA_COLUMN(YDecVtxXi, yDecVtxXi, float); DECLARE_SOA_COLUMN(ZDecVtxXi, zDecVtxXi, float); DECLARE_SOA_COLUMN(Chi2XiVtx, chi2XiVtx, float); -DECLARE_SOA_COLUMN(XDecVtxLam, xDecVtxLam, float); -DECLARE_SOA_COLUMN(YDecVtxLam, yDecVtxLam, float); +DECLARE_SOA_COLUMN(XDecVtxLam, xDecVtxLam, float); +DECLARE_SOA_COLUMN(YDecVtxLam, yDecVtxLam, float); DECLARE_SOA_COLUMN(ZDecVtxLam, zDecVtxLam, float); DECLARE_SOA_COLUMN(Chi2LamVtx, chi2LamVtx, float); // properties of XicPlus DECLARE_SOA_COLUMN(Sign, sign, float); -DECLARE_SOA_COLUMN(E, e, float); //! Energy of candidate (GeV) -DECLARE_SOA_COLUMN(M, m, float); //! Invariant mass of candidate (GeV/c2) -DECLARE_SOA_COLUMN(P, p, float); //! Momentum of candidate (GeV/c) -DECLARE_SOA_COLUMN(Pt, pt, float); //! Transverse momentum of candidate (GeV/c) -DECLARE_SOA_COLUMN(Y, y, float); //! Rapidity of candidate -DECLARE_SOA_COLUMN(Eta, eta, float); //! Pseudorapidity of candidate -DECLARE_SOA_COLUMN(Phi, phi, float); //! Azimuth angle of candidate -DECLARE_SOA_COLUMN(Ct, ct, float); //! Proper lifetime time ctau of candidate (cm) -DECLARE_SOA_COLUMN(DecayLength, decayLength, float); //! Decay length of candidate (cm) -DECLARE_SOA_COLUMN(DecayLengthXY, decayLengthXY, float); //! Transverse decay length of candidate (cm) -DECLARE_SOA_COLUMN(DecayLengthNormalised, decayLengthNormalised, float); //! Normalised decay length of candidate -DECLARE_SOA_COLUMN(DecayLengthXYNormalised, decayLengthXYNormalised, float); //! Normalised transverse decay length of candidate -DECLARE_SOA_COLUMN(Cpa, cpa, float); //! Cosine pointing angle of candidate -DECLARE_SOA_COLUMN(CpaXY, cpaXY, float); //! Cosine pointing angle of candidate in transverse plane -// properties of daughter tracks -DECLARE_SOA_COLUMN(PtXi, ptXi, float); //! Transverse momentum of Xi (prong0) (GeV/c) -DECLARE_SOA_COLUMN(ImpactParameterXi, impactParameterXi, float); //! Impact parameter of Xi (prong0) -DECLARE_SOA_COLUMN(ImpactParameterNormalisedXi, impactParameterNormalisedXi, float); //! Normalised impact parameter of Xi (prong0) -DECLARE_SOA_COLUMN(PtPi0, ptPi0, float); //! Transverse momentum of Pi0 (prong1) (GeV/c) -DECLARE_SOA_COLUMN(ImpactParameterPi0, impactParameterPi0, float); //! Impact parameter of Pi0 (prong1) -DECLARE_SOA_COLUMN(ImpactParameterNormalisedPi0, impactParameterNormalisedPi0, float); //! Normalised impact parameter of Pi0 (prong1) -DECLARE_SOA_COLUMN(PtPi1, ptPi1, float); //! Transverse momentum of Pi1 (prong2) (GeV/c) -DECLARE_SOA_COLUMN(ImpactParameterPi1, impactParameterPi1, float); //! Normalised impact parameter of Pi1 (prong2) -DECLARE_SOA_COLUMN(ImpactParameterNormalisedPi1, impactParameterNormalisedPi1, float); //! Normalised impact parameter of Pi1 (prong2) -DECLARE_SOA_COLUMN(MaxNormalisedDeltaIP, maxNormalisedDeltaIP, float); //! Maximum normalized difference between measured and expected impact parameter of candidate prongs +DECLARE_SOA_COLUMN(E, e, float); //! Energy of candidate (GeV) +DECLARE_SOA_COLUMN(M, m, float); //! Invariant mass of candidate (GeV/c2) +DECLARE_SOA_COLUMN(P, p, float); //! Momentum of candidate (GeV/c) +DECLARE_SOA_COLUMN(Pt, pt, float); //! Transverse momentum of candidate (GeV/c) +DECLARE_SOA_COLUMN(Y, y, float); //! Rapidity of candidate +DECLARE_SOA_COLUMN(Eta, eta, float); //! Pseudorapidity of candidate +DECLARE_SOA_COLUMN(Phi, phi, float); //! Azimuth angle of candidate +DECLARE_SOA_COLUMN(Ct, ct, float); //! Proper lifetime time ctau of candidate (cm) +DECLARE_SOA_COLUMN(DecayLength, decayLength, float); //! Decay length of candidate (cm) +DECLARE_SOA_COLUMN(DecayLengthXY, decayLengthXY, float); //! Transverse decay length of candidate (cm) +DECLARE_SOA_COLUMN(DecayLengthNormalised, decayLengthNormalised, float); //! Normalised decay length of candidate +DECLARE_SOA_COLUMN(DecayLengthXYNormalised, decayLengthXYNormalised, float); //! Normalised transverse decay length of candidate +DECLARE_SOA_COLUMN(Cpa, cpa, float); //! Cosine pointing angle of candidate +DECLARE_SOA_COLUMN(CpaXY, cpaXY, float); //! Cosine pointing angle of candidate in transverse plane +// properties of daughter tracks +DECLARE_SOA_COLUMN(PtXi, ptXi, float); //! Transverse momentum of Xi (prong0) (GeV/c) +DECLARE_SOA_COLUMN(ImpactParameterXi, impactParameterXi, float); //! Impact parameter of Xi (prong0) +DECLARE_SOA_COLUMN(ImpactParameterNormalisedXi, impactParameterNormalisedXi, float); //! Normalised impact parameter of Xi (prong0) +DECLARE_SOA_COLUMN(PtPi0, ptPi0, float); //! Transverse momentum of Pi0 (prong1) (GeV/c) +DECLARE_SOA_COLUMN(ImpactParameterPi0, impactParameterPi0, float); //! Impact parameter of Pi0 (prong1) +DECLARE_SOA_COLUMN(ImpactParameterNormalisedPi0, impactParameterNormalisedPi0, float); //! Normalised impact parameter of Pi0 (prong1) +DECLARE_SOA_COLUMN(PtPi1, ptPi1, float); //! Transverse momentum of Pi1 (prong2) (GeV/c) +DECLARE_SOA_COLUMN(ImpactParameterPi1, impactParameterPi1, float); //! Normalised impact parameter of Pi1 (prong2) +DECLARE_SOA_COLUMN(ImpactParameterNormalisedPi1, impactParameterNormalisedPi1, float); //! Normalised impact parameter of Pi1 (prong2) +DECLARE_SOA_COLUMN(MaxNormalisedDeltaIP, maxNormalisedDeltaIP, float); //! Maximum normalized difference between measured and expected impact parameter of candidate prongs DECLARE_SOA_COLUMN(CpaXi, cpaXi, float); DECLARE_SOA_COLUMN(CpaXYXi, cpaXYXi, float); DECLARE_SOA_COLUMN(CpaLam, cpaLam, float); @@ -93,8 +93,8 @@ DECLARE_SOA_COLUMN(DcaPi1Xi, dcaPi1Xi, float); DECLARE_SOA_COLUMN(InvMassXiPi0, invMassXiPi0, float); DECLARE_SOA_COLUMN(InvMassXiPi1, invMassXiPi1, float); // PID daughters -DECLARE_SOA_COLUMN(NSigTpcPi1, nSigTpcPi1, float); //! TPC Nsigma separation for prong1 with pion mass hypothesis -DECLARE_SOA_COLUMN(NSigTofPi1, nSigTofPi1, float); //! TOF Nsigma separation for prong1 with pion mass hypothesis +DECLARE_SOA_COLUMN(NSigTpcPi1, nSigTpcPi1, float); //! TPC Nsigma separation for prong1 with pion mass hypothesis +DECLARE_SOA_COLUMN(NSigTofPi1, nSigTofPi1, float); //! TOF Nsigma separation for prong1 with pion mass hypothesis // Events DECLARE_SOA_COLUMN(IsEventReject, isEventReject, int); //! Event rejection flag DECLARE_SOA_COLUMN(RunNumber, runNumber, int); //! Run number @@ -332,7 +332,7 @@ struct HfTreeCreatorXicToXiPiPi { Configurable fillOnlyBackground{"fillOnlyBackground", false, "Flag to fill derived tables with background for ML trainings"}; Configurable downSampleBkgFactor{"downSampleBkgFactor", 1., "Fraction of background candidates to keep for ML trainings"}; Configurable ptMaxForDownSample{"ptMaxForDownSample", 10., "Maximum pt for the application of the downsampling factor"}; - + using SelectedCandidates = soa::Filtered>; using SelectedCandidatesKf = soa::Filtered>; using SelectedCandidatesMc = soa::Filtered>; @@ -344,7 +344,7 @@ struct HfTreeCreatorXicToXiPiPi { Partition recSig = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) != int8_t(0); Partition recBg = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) == int8_t(0); Partition recSigKf = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) != int8_t(0); - Partition recBgKf = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) == int8_t(0); + Partition recBgKf = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) == int8_t(0); void init(InitContext const&) { @@ -359,9 +359,9 @@ struct HfTreeCreatorXicToXiPiPi { collision.posX(), collision.posY(), collision.posZ(), - isEventReject, //! filled with 0 - runNumber //! filled with 1 - ); + isEventReject, //! filled with 0 + runNumber //! filled with 1 + ); } template @@ -371,7 +371,7 @@ struct HfTreeCreatorXicToXiPiPi { if constexpr (doMc) { flagMc = candidate.flagMcMatchRec(); } - if constexpr (noKf){ + if constexpr (noKf) { if (fillCandidateLiteTable) { rowCandidateLite( candidate.cascadeId(), @@ -627,7 +627,7 @@ struct HfTreeCreatorXicToXiPiPi { continue; } } - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } PROCESS_SWITCH(HfTreeCreatorXicToXiPiPi, processDataKf, "Process data with KF Particle reconstruction", false); @@ -652,7 +652,7 @@ struct HfTreeCreatorXicToXiPiPi { rowCandidateFull.reserve(recSig.size()); } for (const auto& candidate : recSig) { - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } else if (fillOnlyBackground) { if (fillCandidateLiteTable) { @@ -665,7 +665,7 @@ struct HfTreeCreatorXicToXiPiPi { if (candidate.pt() < ptMaxForDownSample && pseudoRndm >= downSampleBkgFactor) { continue; } - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } else { if (fillCandidateLiteTable) { @@ -674,7 +674,7 @@ struct HfTreeCreatorXicToXiPiPi { rowCandidateFull.reserve(candidates.size()); } for (const auto& candidate : candidates) { - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } @@ -695,10 +695,10 @@ struct HfTreeCreatorXicToXiPiPi { PROCESS_SWITCH(HfTreeCreatorXicToXiPiPi, processMc, "Process MC", false); void processMcKf(aod::Collisions const& collisions, - aod::McCollisions const&, - SelectedCandidatesKfMc const& candidates, - soa::Join const& particles, - TracksWPid const&) + aod::McCollisions const&, + SelectedCandidatesKfMc const& candidates, + soa::Join const& particles, + TracksWPid const&) { // Filling event properties rowCandidateFullEvents.reserve(collisions.size()); @@ -714,7 +714,7 @@ struct HfTreeCreatorXicToXiPiPi { rowCandidateFull.reserve(recSigKf.size()); } for (const auto& candidate : recSigKf) { - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } else if (fillOnlyBackground) { if (fillCandidateLiteTable) { @@ -727,7 +727,7 @@ struct HfTreeCreatorXicToXiPiPi { if (candidate.pt() < ptMaxForDownSample && pseudoRndm >= downSampleBkgFactor) { continue; } - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } else { if (fillCandidateLiteTable) { @@ -736,7 +736,7 @@ struct HfTreeCreatorXicToXiPiPi { rowCandidateFull.reserve(candidates.size()); } for (const auto& candidate : candidates) { - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } From 0b55f5f773eed271542e684f1ecce6df46158156 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Thu, 20 Jun 2024 19:26:33 +0200 Subject: [PATCH 30/35] Fix MegaLinter error --- PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx index 6723b31c62e..60963810b40 100644 --- a/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx @@ -360,8 +360,7 @@ struct HfTreeCreatorXicToXiPiPi { collision.posY(), collision.posZ(), isEventReject, //! filled with 0 - runNumber //! filled with 1 - ); + runNumber); //! filled with 1 } template From d48a2d645c3bf761d8a30e192313e4e5f8489c3e Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Sun, 23 Jun 2024 18:52:06 +0200 Subject: [PATCH 31/35] Add requested changes to PR --- PWGHF/Core/SelectorCuts.h | 152 ++------------- PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx | 169 +++++++++-------- .../DataModel/CandidateReconstructionTables.h | 35 ++-- PWGHF/DataModel/CandidateSelectionTables.h | 3 - .../candidateCreatorXicToXiPiPi.cxx | 176 +++++++++--------- .../candidateSelectorXicToXiPiPi.cxx | 27 +-- .../TableProducer/treeCreatorXicToXiPiPi.cxx | 40 ++-- 7 files changed, 234 insertions(+), 368 deletions(-) diff --git a/PWGHF/Core/SelectorCuts.h b/PWGHF/Core/SelectorCuts.h index 8876ce00674..92f62d72cca 100644 --- a/PWGHF/Core/SelectorCuts.h +++ b/PWGHF/Core/SelectorCuts.h @@ -720,147 +720,17 @@ constexpr double binsPt[nBinsPt + 1] = { 36.}; auto vecBinsPt = std::vector{binsPt, binsPt + nBinsPt + 1}; -// default values for the cuts m ptXi ptPi0 ptPi1 chi2PCA dL dLXY cosp cospXY impParXY Xi Pi0 Pi1 -constexpr double cuts[nBinsPt][nCutVars] = {{ - 0.400, - 0.4, - 0.4, - 0.4, - 1e-5, - 0.005, - 0.005, - 0.8, - 0.8, - 0.1, - 0.1, - 0.1, - }, /* 0 < pT < 1 */ - { - 0.400, - 0.4, - 0.4, - 0.4, - 1e-5, - 0.005, - 0.005, - 0.8, - 0.8, - 0.1, - 0.1, - 0.1, - }, /* 1 < pT < 2 */ - { - 0.400, - 0.4, - 0.4, - 0.4, - 1e-5, - 0.005, - 0.005, - 0.8, - 0.8, - 0.1, - 0.1, - 0.1, - }, /* 2 < pT < 3 */ - { - 0.400, - 0.4, - 0.4, - 0.4, - 1e-5, - 0.005, - 0.005, - 0.8, - 0.8, - 0.1, - 0.1, - 0.1, - }, /* 3 < pT < 4 */ - { - 0.400, - 0.4, - 0.4, - 0.4, - 1e-5, - 0.005, - 0.005, - 0.8, - 0.8, - 0.1, - 0.1, - 0.1, - }, /* 4 < pT < 5 */ - { - 0.400, - 0.4, - 0.4, - 0.4, - 1e-5, - 0.005, - 0.005, - 0.8, - 0.8, - 0.1, - 0.1, - 0.1, - }, /* 5 < pT < 6 */ - { - 0.400, - 0.4, - 0.4, - 0.4, - 1e-5, - 0.005, - 0.005, - 0.8, - 0.8, - 0.1, - 0.1, - 0.1, - }, /* 6 < pT < 8 */ - { - 0.400, - 0.4, - 0.4, - 0.4, - 1e-5, - 0.005, - 0.005, - 0.8, - 0.8, - 0.1, - 0.1, - 0.1, - }, /* 8 < pT < 12 */ - { - 0.400, - 0.4, - 0.4, - 0.4, - 1e-5, - 0.005, - 0.005, - 0.8, - 0.8, - 0.1, - 0.1, - 0.1, - }, /* 12 < pT < 24 */ - { - 0.400, - 0.4, - 0.4, - 0.4, - 1e-5, - 0.005, - 0.005, - 0.8, - 0.8, - 0.1, - 0.1, - 0.1, - }}; /* 24 < pT < 36 */ +// default values for the cuts m ptXi ptPi0 ptPi1 chi2PCA dL dLXY cosp cospXY impParXY Xi Pi0 Pi1 +constexpr double cuts[nBinsPt][nCutVars] = {{0.4, 0.4, 0.4, 0.4, 1e-5, 0.5, 0.5, 0.9, 0.9, 0.1, 0.1, 0.1}, /* 0 < pT < 1 */ + {0.4, 0.4, 0.4, 0.4, 1e-5, 0.5, 0.5, 0.9, 0.9, 0.1, 0.1, 0.1}, /* 1 < pT < 2 */ + {0.4, 0.4, 0.4, 0.4, 1e-5, 0.5, 0.5, 0.9, 0.9, 0.1, 0.1, 0.1}, /* 2 < pT < 3 */ + {0.4, 0.4, 0.4, 0.4, 1e-5, 0.5, 0.5, 0.9, 0.9, 0.1, 0.1, 0.1}, /* 3 < pT < 4 */ + {0.4, 0.4, 0.4, 0.4, 1e-5, 0.5, 0.5, 0.9, 0.9, 0.1, 0.1, 0.1}, /* 4 < pT < 5 */ + {0.4, 0.4, 0.4, 0.4, 1e-5, 0.5, 0.5, 0.9, 0.9, 0.1, 0.1, 0.1}, /* 5 < pT < 6 */ + {0.4, 0.4, 0.4, 0.4, 1e-5, 0.5, 0.5, 0.9, 0.9, 0.1, 0.1, 0.1}, /* 6 < pT < 8 */ + {0.4, 0.4, 0.4, 0.4, 1e-5, 0.5, 0.5, 0.9, 0.9, 0.1, 0.1, 0.1}, /* 8 < pT < 10 */ + {0.4, 0.4, 0.4, 0.4, 1e-5, 0.5, 0.5, 0.9, 0.9, 0.1, 0.1, 0.1}, /* 12 < pT < 24 */ + {0.4, 0.4, 0.4, 0.4, 1e-5, 0.5, 0.5, 0.9, 0.9, 0.1, 0.1, 0.1}}; /* 24 < pT < 36 */ // row labels static const std::vector labelsPt = { diff --git a/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx index 16111287ebd..9d8a5a52160 100644 --- a/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx +++ b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx @@ -34,8 +34,8 @@ using namespace o2::framework::expressions; /// Xic analysis task struct HfTaskXicToXiPiPi { Configurable selectionFlagXic{"selectionFlagXic", 1, "Selection Flag for Xic"}; - Configurable yCandGenMax{"yCandGenMax", 0.5, "max. gen particle rapidity"}; - Configurable yCandRecoMax{"yCandRecoMax", 0.8, "max. cand. rapidity"}; + Configurable yCandGenMax{"yCandGenMax", 0.5, "max. gen particle rapidity"}; + Configurable yCandRecoMax{"yCandRecoMax", 0.8, "max. cand. rapidity"}; Configurable etaTrackMax{"etaTrackMax", 0.8, "max. track pseudo-rapidity"}; Configurable ptTrackMin{"ptTrackMin", 0.1, "min. track transverse momentum"}; Configurable> binsPt{"binsPt", std::vector{hf_cuts_xic_to_xi_pi_pi::vecBinsPt}, "pT bin limits"}; @@ -79,83 +79,82 @@ struct HfTaskXicToXiPiPi { registry.add("hCPAxyLambda", "#Xi^{#plus}_{c} candidates;#Lambda candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); registry.add("hMassXiPi1", "#Xi^{#plus}_{c} candidates;inv. mass #Xi^{#mp} #pi^{#pm} (prong 1) (GeV/#it{c}^{2});#it{p}_{T} (GeV/#it{c})", {HistType::kTH2F, {axisMassXiRes, axisPt}}); registry.add("hMassXiPi2", "#Xi^{#plus}_{c} candidates;inv. mass #Xi^{#mp} #pi^{#pm} (prong 2) (GeV/#it{c}^{2});#it{p}_{T} (GeV/#it{c})", {HistType::kTH2F, {axisMassXiRes, axisPt}}); - /* - MC reconstructed - */ - registry.add("hPtGenSig", "#Xi^{#plus}_{c} candidates (gen+rec);candidate #it{p}_{T}^{gen.} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); - registry.add("hPtRecSig", "#Xi^{#plus}_{c} candidates (matched);candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); - registry.add("hPtRecBg", "#Xi^{#plus}_{c} candidates (unmatched);candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); - registry.add("hPtProng0RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 0 (#Xi^{#mp}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); - registry.add("hPtProng0RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 0 (#Xi^{#mp}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); - registry.add("hPtProng1RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 1 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 20.}}}); - registry.add("hPtProng1RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 1 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 20.}}}); - registry.add("hPtProng2RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 2 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 20.}}}); - registry.add("hPtProng2RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 2 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 20.}}}); - registry.add("hEtaRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate #it{#eta};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); - registry.add("hEtaRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate #it{#eta};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); - registry.add("hRapidityRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate #it{y};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); - registry.add("hRapidityRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate #it{y};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); - registry.add("hCPARecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate cosine of pointing angle;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); - registry.add("hCPARecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate cosine of pointing angle;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); - registry.add("hCPAxyRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate CPAxy;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); - registry.add("hCPAxyRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate CPAxy;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); - registry.add("hMassRecSig", "#Xi^{#plus}_{c} candidates (matched);inv. mass #Xi^{#mp} #pi^{#pm} #pi^{#pm} (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.8, 3.0}, axisPt}}); - registry.add("hMassRecBg", "#Xi^{#plus}_{c} candidates (unmatched);inv. mass #Xi^{#mp} #pi^{#pm} #pi^{#pm} (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.8, 3.0}, axisPt}}); - registry.add("hDecLengthRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); - registry.add("hDecLengthRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); - registry.add("hErrDecLengthRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); - registry.add("hErrDecLengthRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); - registry.add("hDecLengthXYRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length xy (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); - registry.add("hDecLengthXYRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate decay length xy(cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); - registry.add("hErrDecLengthXYRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length xy (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); - registry.add("hErrDecLengthXYRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate decay length xy(cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); - registry.add("hd0Prong0RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 0 (#Xi^{#mp}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); - registry.add("hd0Prong0RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 0 (#Xi^{#mp}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); - registry.add("hd0Prong1RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 1 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); - registry.add("hd0Prong1RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 1 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); - registry.add("hd0Prong2RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 2 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); - registry.add("hd0Prong2RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 2 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); - registry.add("hImpParErrRecSig", "#Xi^{#plus}_{c} candidates (matched);prongs impact parameter error (cm);entries", {HistType::kTH2F, {{100, -0.1, 0.1}, axisPt}}); - registry.add("hImpParErrRecBg", "#Xi^{#plus}_{c} candidates (unmatched);prongs impact parameter error (cm);entries", {HistType::kTH2F, {{100, -0.1, 0.1}, axisPt}}); - registry.add("hChi2PCARecSig", "#Xi^{#plus}_{c} candidates (matched);sum of distances of the secondary vertex to its prongs;entries", {HistType::kTH2F, {{240, -0.01, 0.1}, axisPt}}); - registry.add("hChi2PCARecBg", "#Xi^{#plus}_{c} candidates (unmatched);sum of distances of the secondary vertex to its prongs;entries", {HistType::kTH2F, {{240, -0.01, 0.1}, axisPt}}); - registry.add("hCPAXiRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#minus} cosine of pointing angle;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); - registry.add("hCPAXiRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#minus} cosine of pointing angle;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); - registry.add("hCPAxyXiRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#minus} candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); - registry.add("hCPAxyXiRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#minus} candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); - registry.add("hCPALambdaRecSig", "#Xi^{#plus}_{c} candidates (matched);#Lambda candidate cosine of pointing angle;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); - registry.add("hCPALambdaRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Lambda candidate cosine of pointing angle;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); - registry.add("hCPAxyLambdaRecSig", "#Xi^{#plus}_{c} candidates (matched);#Lambda candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); - registry.add("hCPAxyLambdaRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Lambda candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); - registry.add("hMassXiPi1RecSig", "#Xi^{#plus}_{c} candidates (matched);inv. mass #Xi^{#mp} #pi^{#pm} (prong 1) (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.0, 2.0}, axisPt}}); - registry.add("hMassXiPi1RecBg", "#Xi^{#plus}_{c} candidates (unmatched);inv. mass #Xi^{#mp} #pi^{#pm} (prong 1) (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.0, 2.0}, axisPt}}); - registry.add("hMassXiPi2RecSig", "#Xi^{#plus}_{c} candidates (matched);inv. mass #Xi^{#mp} #pi^{#pm} (prong 2) (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.0, 2.0}, axisPt}}); - registry.add("hMassXiPi2RecBg", "#Xi^{#plus}_{c} candidates (unmatched);inv. mass #Xi^{#mp} #pi^{#pm} (prong 2) (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.0, 2.0}, axisPt}}); - /* - MC generated - */ - registry.add("hPtProng0Gen", "MC particles (generated);prong 0 (#Xi^{#mp}) #it{p}_{T}^{gen} (GeV/#it{c});entries", {HistType::kTH2F, {{300, 0., 30.}, axisPt}}); - registry.add("hPtProng1Gen", "MC particles (generated);prong 1 (#pi^{#pm}) #it{p}_{T}^{gen} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 20.}, axisPt}}); - registry.add("hPtProng2Gen", "MC particles (generated);prong 2 (#pi^{#pm}) #it{p}_{T}^{gen} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 20.}, axisPt}}); - registry.add("hEtaProng0Gen", "MC particles (generated);prong 0 (#Xi^{#mp}) #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); - registry.add("hEtaProng1Gen", "MC particles (generated);prong 1 (#pi^{#pm}) #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); - registry.add("hEtaProng2Gen", "MC particles (generated);prong 2 (#pi^{#pm}) #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); - registry.add("hYProng0Gen", "MC particles (generated);prong 0 (#Xi^{#mp}) #it{y}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); - registry.add("hYProng1Gen", "MC particles (generated);prong 1 (#pi^{#pm}) #it{y}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); - registry.add("hYProng2Gen", "MC particles (generated);prong 2 (#pi^{#pm}) #it{y}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); - registry.add("hPtGen", "MC particles (generated);candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); - registry.add("hEtaGen", "MC particles (generated);#Xi^{#plus}_{c} candidate #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); - registry.add("hYGen", "MC particles (generated);#Xi^{#plus}_{c} candidate #it{y}^{gen};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); - registry.add("hPtGenWithProngsInAcceptance", "MC particles (generated-daughters in acceptance);candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); - registry.add("hEtaGenWithProngsInAcceptance", "MC particles (generated-daughters in acceptance);#Xi^{#plus}_{c} candidate #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); - registry.add("hYGenWithProngsInAcceptance", "MC particles (generated-daughters in acceptance);#Xi^{#plus}_{c} candidate #it{y}^{gen};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + + if (doprocessMc) { + // MC reconstructed + registry.add("hPtGenSig", "#Xi^{#plus}_{c} candidates (gen+rec);candidate #it{p}_{T}^{gen.} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); + registry.add("hPtRecSig", "#Xi^{#plus}_{c} candidates (matched);candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); + registry.add("hPtRecBg", "#Xi^{#plus}_{c} candidates (unmatched);candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); + registry.add("hPtProng0RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 0 (#Xi^{#mp}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); + registry.add("hPtProng0RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 0 (#Xi^{#mp}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); + registry.add("hPtProng1RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 1 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 20.}}}); + registry.add("hPtProng1RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 1 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 20.}}}); + registry.add("hPtProng2RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 2 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 20.}}}); + registry.add("hPtProng2RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 2 (#pi^{#pm}) #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 20.}}}); + registry.add("hEtaRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate #it{#eta};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + registry.add("hEtaRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate #it{#eta};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + registry.add("hRapidityRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate #it{y};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + registry.add("hRapidityRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate #it{y};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + registry.add("hCPARecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate cosine of pointing angle;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); + registry.add("hCPARecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate cosine of pointing angle;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); + registry.add("hCPAxyRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate CPAxy;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); + registry.add("hCPAxyRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate CPAxy;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); + registry.add("hMassRecSig", "#Xi^{#plus}_{c} candidates (matched);inv. mass #Xi^{#mp} #pi^{#pm} #pi^{#pm} (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.8, 3.0}, axisPt}}); + registry.add("hMassRecBg", "#Xi^{#plus}_{c} candidates (unmatched);inv. mass #Xi^{#mp} #pi^{#pm} #pi^{#pm} (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.8, 3.0}, axisPt}}); + registry.add("hDecLengthRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); + registry.add("hDecLengthRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); + registry.add("hErrDecLengthRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); + registry.add("hErrDecLengthRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate decay length (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); + registry.add("hDecLengthXYRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length xy (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); + registry.add("hDecLengthXYRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate decay length xy(cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); + registry.add("hErrDecLengthXYRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#plus}_{c} candidate decay length xy (cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); + registry.add("hErrDecLengthXYRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#plus}_{c} candidate decay length xy(cm);entries", {HistType::kTH2F, {{100, 0., 0.5}, axisPt}}); + registry.add("hd0Prong0RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 0 (#Xi^{#mp}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); + registry.add("hd0Prong0RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 0 (#Xi^{#mp}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); + registry.add("hd0Prong1RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 1 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); + registry.add("hd0Prong1RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 1 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); + registry.add("hd0Prong2RecSig", "#Xi^{#plus}_{c} candidates (matched);prong 2 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); + registry.add("hd0Prong2RecBg", "#Xi^{#plus}_{c} candidates (unmatched);prong 2 (#pi^{#pm}) DCAxy to prim. vertex (cm);entries", {HistType::kTH2F, {{200, -0.05, 0.05}, axisPt}}); + registry.add("hImpParErrRecSig", "#Xi^{#plus}_{c} candidates (matched);prongs impact parameter error (cm);entries", {HistType::kTH2F, {{100, -0.1, 0.1}, axisPt}}); + registry.add("hImpParErrRecBg", "#Xi^{#plus}_{c} candidates (unmatched);prongs impact parameter error (cm);entries", {HistType::kTH2F, {{100, -0.1, 0.1}, axisPt}}); + registry.add("hChi2PCARecSig", "#Xi^{#plus}_{c} candidates (matched);sum of distances of the secondary vertex to its prongs;entries", {HistType::kTH2F, {{240, -0.01, 0.1}, axisPt}}); + registry.add("hChi2PCARecBg", "#Xi^{#plus}_{c} candidates (unmatched);sum of distances of the secondary vertex to its prongs;entries", {HistType::kTH2F, {{240, -0.01, 0.1}, axisPt}}); + registry.add("hCPAXiRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#minus} cosine of pointing angle;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); + registry.add("hCPAXiRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#minus} cosine of pointing angle;entries", {HistType::kTH2F, {{220, -1.1, 1.1}, axisPt}}); + registry.add("hCPAxyXiRecSig", "#Xi^{#plus}_{c} candidates (matched);#Xi^{#minus} candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hCPAxyXiRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Xi^{#minus} candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hCPALambdaRecSig", "#Xi^{#plus}_{c} candidates (matched);#Lambda candidate cosine of pointing angle;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hCPALambdaRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Lambda candidate cosine of pointing angle;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hCPAxyLambdaRecSig", "#Xi^{#plus}_{c} candidates (matched);#Lambda candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hCPAxyLambdaRecBg", "#Xi^{#plus}_{c} candidates (unmatched);#Lambda candidate cosine of pointing angle xy;entries", {HistType::kTH2F, {{110, -1.1, 1.1}, axisPt}}); + registry.add("hMassXiPi1RecSig", "#Xi^{#plus}_{c} candidates (matched);inv. mass #Xi^{#mp} #pi^{#pm} (prong 1) (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.0, 2.0}, axisPt}}); + registry.add("hMassXiPi1RecBg", "#Xi^{#plus}_{c} candidates (unmatched);inv. mass #Xi^{#mp} #pi^{#pm} (prong 1) (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.0, 2.0}, axisPt}}); + registry.add("hMassXiPi2RecSig", "#Xi^{#plus}_{c} candidates (matched);inv. mass #Xi^{#mp} #pi^{#pm} (prong 2) (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.0, 2.0}, axisPt}}); + registry.add("hMassXiPi2RecBg", "#Xi^{#plus}_{c} candidates (unmatched);inv. mass #Xi^{#mp} #pi^{#pm} (prong 2) (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{300, 1.0, 2.0}, axisPt}}); + // MC generated + registry.add("hPtProng0Gen", "MC particles (generated);prong 0 (#Xi^{#mp}) #it{p}_{T}^{gen} (GeV/#it{c});entries", {HistType::kTH2F, {{300, 0., 30.}, axisPt}}); + registry.add("hPtProng1Gen", "MC particles (generated);prong 1 (#pi^{#pm}) #it{p}_{T}^{gen} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 20.}, axisPt}}); + registry.add("hPtProng2Gen", "MC particles (generated);prong 2 (#pi^{#pm}) #it{p}_{T}^{gen} (GeV/#it{c});entries", {HistType::kTH2F, {{200, 0., 20.}, axisPt}}); + registry.add("hEtaProng0Gen", "MC particles (generated);prong 0 (#Xi^{#mp}) #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); + registry.add("hEtaProng1Gen", "MC particles (generated);prong 1 (#pi^{#pm}) #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); + registry.add("hEtaProng2Gen", "MC particles (generated);prong 2 (#pi^{#pm}) #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); + registry.add("hYProng0Gen", "MC particles (generated);prong 0 (#Xi^{#mp}) #it{y}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); + registry.add("hYProng1Gen", "MC particles (generated);prong 1 (#pi^{#pm}) #it{y}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); + registry.add("hYProng2Gen", "MC particles (generated);prong 2 (#pi^{#pm}) #it{y}^{gen};entries", {HistType::kTH2F, {{100, -2, 2}, axisPt}}); + registry.add("hPtGen", "MC particles (generated);candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); + registry.add("hEtaGen", "MC particles (generated);#Xi^{#plus}_{c} candidate #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + registry.add("hYGen", "MC particles (generated);#Xi^{#plus}_{c} candidate #it{y}^{gen};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + registry.add("hPtGenWithProngsInAcceptance", "MC particles (generated-daughters in acceptance);candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); + registry.add("hEtaGenWithProngsInAcceptance", "MC particles (generated-daughters in acceptance);#Xi^{#plus}_{c} candidate #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + registry.add("hYGenWithProngsInAcceptance", "MC particles (generated-daughters in acceptance);#Xi^{#plus}_{c} candidate #it{y}^{gen};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); + } if (checkDecayTypeMc) { - constexpr uint8_t kNBinsDecayTypeMc = hf_cand_xictoxipipi::DecayType::NDecayType + 1; + constexpr uint8_t kNBinsDecayTypeMc = hf_cand_xic_to_xi_pi_pi::DecayType::NDecayType + 1; TString labels[kNBinsDecayTypeMc]; - labels[hf_cand_xictoxipipi::DecayType::XicToXiPiPi] = "#Xi^{+}_{c} #rightarrow #Xi^{#minus} #pi^{#plus}) #pi^{#plus}"; - labels[hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi] = "#Xi^{+}_{c} #rightarrow #Xi(1530)^{0} #pi^{#plus} #rightarrow #Xi^{#minus} #pi^{#plus}) #pi^{#plus}"; - labels[hf_cand_xictoxipipi::DecayType::NDecayType] = "Other decays"; + labels[hf_cand_xic_to_xi_pi_pi::DecayType::XicToXiPiPi] = "#Xi^{+}_{c} #rightarrow #Xi^{#minus} #pi^{#plus}) #pi^{#plus}"; + labels[hf_cand_xic_to_xi_pi_pi::DecayType::XicToXiResPiToXiPiPi] = "#Xi^{+}_{c} #rightarrow #Xi(1530)^{0} #pi^{#plus} #rightarrow #Xi^{#minus} #pi^{#plus}) #pi^{#plus}"; + labels[hf_cand_xic_to_xi_pi_pi::DecayType::NDecayType] = "Other decays"; static const AxisSpec axisDecayType = {kNBinsDecayTypeMc, 0.5, kNBinsDecayTypeMc + 0.5, ""}; registry.add("hDecayTypeMc", "DecayType", {HistType::kTH3F, {axisDecayType, axisMassXic, axisPt}}); for (uint8_t iBin = 0; iBin < kNBinsDecayTypeMc; ++iBin) { @@ -219,8 +218,6 @@ struct HfTaskXicToXiPiPi { aod::TracksWMc const&) { std::vector arrDaughIndex; - int pdgCodeXiMinus = kXiMinus; // 3312 - int pdgCodePiPlus = kPiPlus; // 211 // MC rec for (const auto& candidate : candidates) { @@ -232,7 +229,7 @@ struct HfTaskXicToXiPiPi { auto ptCandXic = candidate.pt(); int flagMcMatchRecXic = std::abs(candidate.flagMcMatchRec()); - if (TESTBIT(flagMcMatchRecXic, hf_cand_xictoxipipi::DecayType::XicToXiPiPi) || TESTBIT(flagMcMatchRecXic, hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi)) { + if (TESTBIT(flagMcMatchRecXic, hf_cand_xic_to_xi_pi_pi::DecayType::XicToXiPiPi) || TESTBIT(flagMcMatchRecXic, hf_cand_xic_to_xi_pi_pi::DecayType::XicToXiResPiToXiPiPi)) { auto indexMother = RecoDecay::getMother(mcParticles, candidate.pi0_as().mcParticle_as>(), o2::constants::physics::Pdg::kXiCPlus, true); auto particleMother = mcParticles.rawIteratorAt(indexMother); @@ -289,19 +286,19 @@ struct HfTaskXicToXiPiPi { } if (checkDecayTypeMc) { - if (TESTBIT(flagMcMatchRecXic, hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { - registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_xictoxipipi::DecayType::XicToXiPiPi, candidate.invMassXic(), ptCandXic); - } else if (TESTBIT(flagMcMatchRecXic, hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi)) { - registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi, candidate.invMassXic(), ptCandXic); + if (TESTBIT(flagMcMatchRecXic, hf_cand_xic_to_xi_pi_pi::DecayType::XicToXiPiPi)) { + registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_xic_to_xi_pi_pi::DecayType::XicToXiPiPi, candidate.invMassXic(), ptCandXic); + } else if (TESTBIT(flagMcMatchRecXic, hf_cand_xic_to_xi_pi_pi::DecayType::XicToXiResPiToXiPiPi)) { + registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_xic_to_xi_pi_pi::DecayType::XicToXiResPiToXiPiPi, candidate.invMassXic(), ptCandXic); } else { - registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_xictoxipipi::DecayType::NDecayType, candidate.invMassXic(), ptCandXic); + registry.fill(HIST("hDecayTypeMc"), 1 + hf_cand_xic_to_xi_pi_pi::DecayType::NDecayType, candidate.invMassXic(), ptCandXic); } } } // rec // MC gen. level for (const auto& particle : mcParticles) { - if (TESTBIT(std::abs(particle.flagMcMatchGen()), hf_cand_xictoxipipi::DecayType::XicToXiPiPi) || TESTBIT(std::abs(particle.flagMcMatchGen()), hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi)) { + if (TESTBIT(std::abs(particle.flagMcMatchGen()), hf_cand_xic_to_xi_pi_pi::DecayType::XicToXiPiPi) || TESTBIT(std::abs(particle.flagMcMatchGen()), hf_cand_xic_to_xi_pi_pi::DecayType::XicToXiResPiToXiPiPi)) { arrDaughIndex.clear(); auto ptParticle = particle.pt(); @@ -315,7 +312,7 @@ struct HfTaskXicToXiPiPi { std::array yProngs; std::array etaProngs; int counter = 0; - RecoDecay::getDaughters(particle, &arrDaughIndex, std::array{pdgCodeXiMinus, pdgCodePiPlus, pdgCodePiPlus}, 2); + RecoDecay::getDaughters(particle, &arrDaughIndex, std::array{+kXiMinus, +kPiPlus, +kPiPlus}, 2); for (auto iProng = 0u; iProng < arrDaughIndex.size(); ++iProng) { auto daughI = mcParticles.rawIteratorAt(arrDaughIndex[iProng]); ptProngs[counter] = daughI.pt(); diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index 146b6fa858f..c22ae64ccec 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1321,7 +1321,7 @@ DECLARE_SOA_TABLE(HfToOmegaKMCGen, "AOD", "HFTOOMEKMCGEN", //! hf_cand_xic0_omegac0::PtCharmBaryonGen, hf_cand_xic0_omegac0::RapidityCharmBaryonGen, hf_cand_xic0_omegac0::OriginGen, hf_cand::IdxBhadMotherPart, o2::soa::Marker<4>); // specific Xic to Xi Pi Pi candidate properties -namespace hf_cand_xictoxipipi +namespace hf_cand_xic_to_xi_pi_pi { DECLARE_SOA_INDEX_COLUMN_FULL(Pi0, pi0, int, Tracks, "_pi0"); DECLARE_SOA_INDEX_COLUMN_FULL(Pi1, pi1, int, Tracks, "_pi1"); @@ -1356,34 +1356,35 @@ DECLARE_SOA_COLUMN(DebugMcRec, debugMcRec, int8_t); // debug flag for mi DECLARE_SOA_COLUMN(DebugMcGen, debugMcGen, int8_t); DECLARE_SOA_COLUMN(OriginRec, originRec, int8_t); DECLARE_SOA_COLUMN(OriginGen, originGen, int8_t); + // mapping of decay types enum DecayType { XicToXiPiPi = 0, XicToXiResPiToXiPiPi, NDecayType }; -} // end of namespace hf_cand_xictoxipipi +} // end of namespace hf_cand_xic_to_xi_pi_pi // declare dedicated Xic to Xi Pi Pi candidate table DECLARE_SOA_TABLE(HfCandXicBase, "AOD", "HFCANDXICBASE", hf_cand::CollisionId, collision::PosX, collision::PosY, collision::PosZ, - hf_cand_xictoxipipi::XPvErr, hf_cand_xictoxipipi::YPvErr, hf_cand_xictoxipipi::ZPvErr, + hf_cand_xic_to_xi_pi_pi::XPvErr, hf_cand_xic_to_xi_pi_pi::YPvErr, hf_cand_xic_to_xi_pi_pi::ZPvErr, // 3-prong specific columns - cascdata::CascadeId, hf_cand_xictoxipipi::Pi0Id, hf_cand_xictoxipipi::Pi1Id, + cascdata::CascadeId, hf_cand_xic_to_xi_pi_pi::Pi0Id, hf_cand_xic_to_xi_pi_pi::Pi1Id, cascdata::BachelorId, cascdata::PosTrackId, cascdata::NegTrackId, hf_cand::XSecondaryVertex, hf_cand::YSecondaryVertex, hf_cand::ZSecondaryVertex, - hf_cand_xictoxipipi::XSvErr, hf_cand_xictoxipipi::YSvErr, hf_cand_xictoxipipi::ZSvErr, + hf_cand_xic_to_xi_pi_pi::XSvErr, hf_cand_xic_to_xi_pi_pi::YSvErr, hf_cand_xic_to_xi_pi_pi::ZSvErr, hf_cand::ErrorDecayLength, hf_cand::ErrorDecayLengthXY, - hf_cand::Chi2PCA, hf_cand_xictoxipipi::InvMassXic, hf_cand_xictoxipipi::Sign, + hf_cand::Chi2PCA, hf_cand_xic_to_xi_pi_pi::InvMassXic, hf_cand_xic_to_xi_pi_pi::Sign, hf_cand::PxProng0, hf_cand::PyProng0, hf_cand::PzProng0, hf_cand::PxProng1, hf_cand::PyProng1, hf_cand::PzProng1, hf_cand::PxProng2, hf_cand::PyProng2, hf_cand::PzProng2, hf_cand::ImpactParameter0, hf_cand::ImpactParameter1, hf_cand::ImpactParameter2, hf_cand::ErrorImpactParameter0, hf_cand::ErrorImpactParameter1, hf_cand::ErrorImpactParameter2, // cascade specific columns - hf_cand_xictoxipipi::XDecayVtxXi, hf_cand_xictoxipipi::YDecayVtxXi, hf_cand_xictoxipipi::ZDecayVtxXi, - hf_cand_xictoxipipi::XDecayVtxLambda, hf_cand_xictoxipipi::YDecayVtxLambda, hf_cand_xictoxipipi::ZDecayVtxLambda, - hf_cand_xictoxipipi::CosPaXi, hf_cand_xictoxipipi::CosPaXYXi, hf_cand_xictoxipipi::CosPaLambda, hf_cand_xictoxipipi::CosPaXYLambda, - hf_cand_xictoxipipi::InvMassXiPi0, hf_cand_xictoxipipi::InvMassXiPi1, + hf_cand_xic_to_xi_pi_pi::XDecayVtxXi, hf_cand_xic_to_xi_pi_pi::YDecayVtxXi, hf_cand_xic_to_xi_pi_pi::ZDecayVtxXi, + hf_cand_xic_to_xi_pi_pi::XDecayVtxLambda, hf_cand_xic_to_xi_pi_pi::YDecayVtxLambda, hf_cand_xic_to_xi_pi_pi::ZDecayVtxLambda, + hf_cand_xic_to_xi_pi_pi::CosPaXi, hf_cand_xic_to_xi_pi_pi::CosPaXYXi, hf_cand_xic_to_xi_pi_pi::CosPaLambda, hf_cand_xic_to_xi_pi_pi::CosPaXYLambda, + hf_cand_xic_to_xi_pi_pi::InvMassXiPi0, hf_cand_xic_to_xi_pi_pi::InvMassXiPi1, /* dynamic columns */ hf_cand::RSecondaryVertex, hf_cand::DecayLength, @@ -1419,19 +1420,19 @@ using HfCandXic = HfCandXicExt; DECLARE_SOA_TABLE(HfCandXicKF, "AOD", "HFCANDXICKF", cascdata::KFCascadeChi2, cascdata::KFV0Chi2, - hf_cand_xictoxipipi::DcaPi0Pi1, hf_cand_xictoxipipi::DcaPi0Xi, hf_cand_xictoxipipi::DcaPi1Xi); + hf_cand_xic_to_xi_pi_pi::DcaPi0Pi1, hf_cand_xic_to_xi_pi_pi::DcaPi0Xi, hf_cand_xic_to_xi_pi_pi::DcaPi1Xi); // table with results of reconstruction level MC matching DECLARE_SOA_TABLE(HfCandXicMcRec, "AOD", "HFCANDXICMCREC", //! - hf_cand_xictoxipipi::FlagMcMatchRec, - hf_cand_xictoxipipi::DebugMcRec, - hf_cand_xictoxipipi::OriginRec); + hf_cand_xic_to_xi_pi_pi::FlagMcMatchRec, + hf_cand_xic_to_xi_pi_pi::DebugMcRec, + hf_cand_xic_to_xi_pi_pi::OriginRec); // table with results of generator level MC matching DECLARE_SOA_TABLE(HfCandXicMcGen, "AOD", "HFCANDXICMCGEN", //! - hf_cand_xictoxipipi::FlagMcMatchGen, - hf_cand_xictoxipipi::DebugMcGen, - hf_cand_xictoxipipi::OriginGen); + hf_cand_xic_to_xi_pi_pi::FlagMcMatchGen, + hf_cand_xic_to_xi_pi_pi::DebugMcGen, + hf_cand_xic_to_xi_pi_pi::OriginGen); // specific chic candidate properties namespace hf_cand_chic diff --git a/PWGHF/DataModel/CandidateSelectionTables.h b/PWGHF/DataModel/CandidateSelectionTables.h index 18abbb95692..39fb8681c65 100644 --- a/PWGHF/DataModel/CandidateSelectionTables.h +++ b/PWGHF/DataModel/CandidateSelectionTables.h @@ -308,7 +308,6 @@ DECLARE_SOA_COLUMN(MlProbXicToPKPi, mlProbXicToPKPi, std::vector); //! DECLARE_SOA_COLUMN(MlProbXicToPiKP, mlProbXicToPiKP, std::vector); //! // XicPlus to Xi Pi Pi DECLARE_SOA_COLUMN(IsSelXicToXiPiPi, isSelXicToXiPiPi, int); //! -DECLARE_SOA_COLUMN(MlProbXicToXiPiPi, mlProbXicToXiPiPi, std::vector); //! } // namespace hf_sel_candidate_xic DECLARE_SOA_TABLE(HfSelXicToPKPi, "AOD", "HFSELXIC", //! @@ -318,8 +317,6 @@ DECLARE_SOA_TABLE(HfMlXicToPKPi, "AOD", "HFMLXIC", //! // XicPlus to Xi Pi Pi DECLARE_SOA_TABLE(HfSelXicToXiPiPi, "AOD", "HFSELXICTOXI2PI", //! hf_sel_candidate_xic::IsSelXicToXiPiPi); -DECLARE_SOA_TABLE(HfMlXicToXiPiPi, "AOD", "HFMLXICTOXIPIPI", //! - hf_sel_candidate_xic::MlProbXicToXiPiPi); namespace hf_sel_candidate_xicc { diff --git a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index 9d2dd78501f..d300301922e 100644 --- a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -30,11 +30,12 @@ #include "CommonConstants/PhysicsConstants.h" #include "DCAFitter/DCAFitterN.h" #include "Framework/AnalysisTask.h" +#include "Framework/HistogramRegistry.h" #include "Framework/runDataProcessing.h" #include "ReconstructionDataFormats/DCA.h" -#include "Common/DataModel/CollisionAssociationTables.h" #include "Common/Core/trackUtilities.h" +#include "Common/DataModel/CollisionAssociationTables.h" #include "Tools/KFparticle/KFUtilities.h" #include "PWGLF/DataModel/LFStrangenessTables.h" @@ -44,12 +45,12 @@ using namespace o2; using namespace o2::analysis; -using namespace o2::aod::hf_cand_xictoxipipi; +using namespace o2::aod::hf_cand_xic_to_xi_pi_pi; using namespace o2::constants::physics; using namespace o2::framework; /// Reconstruction of heavy-flavour 3-prong decay candidates -struct HfCandidateCreatorXic { +struct HfCandidateCreatorXicToXiPiPi { Produces rowCandidateBase; Produces rowCandidateKF; @@ -81,8 +82,7 @@ struct HfCandidateCreatorXic { o2::base::MatLayerCylSet* lut; o2::base::Propagator::MatCorrType matCorr = o2::base::Propagator::MatCorrType::USEMatCorrLUT; - double massXiMinusFromPdg = MassXiMinus; - double massPionFromPdg = MassPiPlus; + o2::vertexing::DCAFitterN<3> df; int runNumber{0}; float massXiPiPi{0.}; @@ -95,47 +95,45 @@ struct HfCandidateCreatorXic { using KFCascadesLinked = soa::Join; using KFCascFull = soa::Join; - OutputObj hMass3{TH1F("hMass3", "3-prong candidates;inv. mass (#Xi #pi #pi) (GeV/#it{c}^{2});entries", 500, 2.3, 2.7)}; - OutputObj hCovPVXX{TH1F("hCovPVXX", "3-prong candidates;XX element of cov. matrix of prim. vtx. position (cm^{2});entries", 100, 0., 1.e-4)}; - OutputObj hCovSVXX{TH1F("hCovSVXX", "3-prong candidates;XX element of cov. matrix of sec. vtx. position (cm^{2});entries", 100, 0., 0.2)}; - OutputObj hCovPVYY{TH1F("hCovPVYY", "3-prong candidates;YY element of cov. matrix of prim. vtx. position (cm^{2});entries", 100, 0., 1.e-4)}; - OutputObj hCovSVYY{TH1F("hCovSVYY", "3-prong candidates;YY element of cov. matrix of sec. vtx. position (cm^{2});entries", 100, 0., 0.2)}; - OutputObj hCovPVXZ{TH1F("hCovPVXZ", "3-prong candidates;XZ element of cov. matrix of prim. vtx. position (cm^{2});entries", 100, -1.e-4, 1.e-4)}; - OutputObj hCovSVXZ{TH1F("hCovSVXZ", "3-prong candidates;XZ element of cov. matrix of sec. vtx. position (cm^{2});entries", 100, -1.e-4, 0.2)}; - OutputObj hCovPVZZ{TH1F("hCovPVZZ", "3-prong candidates;ZZ element of cov. matrix of prim. vtx. position (cm^{2});entries", 100, 0., 1.e-4)}; - OutputObj hCovSVZZ{TH1F("hCovSVZZ", "3-prong candidates;ZZ element of cov. matrix of sec. vtx. position (cm^{2});entries", 100, 0., 0.2)}; - OutputObj hDcaXYProngs{TH2F("hDcaXYProngs", "DCAxy of 3-prong candidates;#it{p}_{T} (GeV/#it{c};#it{d}_{xy}) (#mum);entries", 100, 0., 20., 200, -500., 500.)}; - OutputObj hDcaZProngs{TH2F("hDcaZProngs", "DCAz of 3-prong candidates;#it{p}_{T} (GeV/#it{c};#it{d}_{z}) (#mum);entries", 100, 0., 20., 200, -500., 500.)}; - OutputObj hVertexerType{TH1F("hVertexerType", "Use KF or DCAFitterN;Vertexer type;entries", 2, -0.5, 1.5)}; // See o2::aod::hf_cand::VertexerType + HistogramRegistry registry{"registry"}; void init(InitContext const&) { + // add histograms to registry + if (fillHistograms) { + registry.add("hMass3", "3-prong candidates;inv. mass (#Xi #pi #pi) (GeV/#it{c}^{2});entries", {HistType::kTH1D, {{500, 2.3, 2.7}}}); + registry.add("hCovPVXX", "3-prong candidates;XX element of cov. matrix of prim. vtx. position (cm^{2});entries", {HistType::kTH1D, {{100, 0., 1.e-4}}}); + registry.add("hCovSVXX", "3-prong candidates;XX element of cov. matrix of sec. vtx. position (cm^{2});entries", {HistType::kTH1D, {{100, 0., 0.2}}}); + registry.add("hCovPVYY", "3-prong candidates;YY element of cov. matrix of prim. vtx. position (cm^{2});entries", {HistType::kTH1D, {{100, 0., 1.e-4}}}); + registry.add("hCovSVYY", "3-prong candidates;YY element of cov. matrix of sec. vtx. position (cm^{2});entries", {HistType::kTH1D, {{100, 0., 0.2}}}); + registry.add("hCovPVXZ", "3-prong candidates;XZ element of cov. matrix of prim. vtx. position (cm^{2});entries", {HistType::kTH1D, {{100, -1.e-4, 1.e-4}}}); + registry.add("hCovSVXZ", "3-prong candidates;XZ element of cov. matrix of sec. vtx. position (cm^{2});entries", {HistType::kTH1D, {{100, -1.e-4, 0.2}}}); + registry.add("hCovPVZZ", "3-prong candidates;ZZ element of cov. matrix of prim. vtx. position (cm^{2});entries", {HistType::kTH1D, {{100, 0., 1.e-4}}}); + registry.add("hCovSVZZ", "3-prong candidates;ZZ element of cov. matrix of sec. vtx. position (cm^{2});entries", {HistType::kTH1D, {{100, 0., 0.2}}}); + registry.add("hVertexerType", "Use KF or DCAFitterN;Vertexer type;entries", {HistType::kTH1F, {{2, -0.5, 1.5}}}); // See o2::aod::hf_cand::VertexerType + registry.add("hDcaXYProngs", "DCAxy of 3-prong candidates;#it{p}_{T} (GeV/#it{c};#it{d}_{xy}) (#mum);entries", {HistType::kTH2D, {{100, 0., 20.}, {200, -500., 500.}}}); + registry.add("hDcaZProngs", "DCAz of 3-prong candidates;#it{p}_{T} (GeV/#it{c};#it{d}_{z}) (#mum);entries", {HistType::kTH2D, {{100, 0., 20.}, {200, -500., 500.}}}); + } + + // initialize CCDB ccdb->setURL(ccdbUrl); ccdb->setCaching(true); ccdb->setLocalObjectValidityChecking(); lut = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdb->get(ccdbPathLut)); runNumber = 0; - if ((doprocessXicplusWithDcaFitter + doprocessXicplusWithKFParticleFromDerivedData) != 1) { + // fill hVertexerType histogram + if ((doprocessXicPlusWithDcaFitter + doprocessXicPlusWithKFParticleFromDerivedData) != 1) { LOGP(fatal, "Only one process function can be enabled at a time."); } - if ((doprocessXicplusWithDcaFitter == 1) && fillHistograms) { - hVertexerType->Fill(aod::hf_cand::VertexerType::DCAFitter); + if ((doprocessXicPlusWithDcaFitter == 1) && fillHistograms) { + registry.fill(HIST("hVertexerType"), aod::hf_cand::VertexerType::DCAFitter); } - if ((doprocessXicplusWithKFParticleFromDerivedData == 1) && fillHistograms) { - hVertexerType->Fill(aod::hf_cand::VertexerType::KfParticle); + if ((doprocessXicPlusWithKFParticleFromDerivedData == 1) && fillHistograms) { + registry.fill(HIST("hVertexerType"), aod::hf_cand::VertexerType::KfParticle); } - } - void processXicplusWithDcaFitter(aod::Collisions const&, - aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, - CascadesLinked const&, - CascFull const&, - aod::TracksWCovDca const&, - aod::BCsWithTimestamps const&) - { // initialize 3-prong vertex fitter - o2::vertexing::DCAFitterN<3> df; df.setPropagateToPCA(propagateToPCA); df.setMaxR(maxR); df.setMaxDZIni(maxDZIni); @@ -143,7 +141,15 @@ struct HfCandidateCreatorXic { df.setMinRelChi2Change(minRelChi2Change); df.setUseAbsDCA(useAbsDCA); df.setWeightedFinalPCA(useWeightedFinalPCA); + } + void processXicPlusWithDcaFitter(aod::Collisions const&, + aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, + CascadesLinked const&, + CascFull const&, + aod::TracksWCovDca const&, + aod::BCsWithTimestamps const&) + { // loop over triplets of track indices for (const auto& rowTrackIndexXicPlus : rowsTrackIndexXicPlus) { auto cascAodElement = rowTrackIndexXicPlus.cascade_as(); @@ -160,7 +166,7 @@ struct HfCandidateCreatorXic { if (std::abs(casc.dcaXYCascToPV()) > dcaXYToPVCascadeMax) { continue; } - if (std::abs(casc.mXi() - massXiMinusFromPdg) > massToleranceCascade) { + if (std::abs(casc.mXi() - MassXiMinus) > massToleranceCascade) { continue; } } @@ -224,9 +230,9 @@ struct HfCandidateCreatorXic { auto covMatrixSV = df.calcPCACovMatrixFlat(); // get track momenta + trackCasc = df.getTrack(0); trackParCovCharmBachelor0 = df.getTrack(1); trackParCovCharmBachelor1 = df.getTrack(2); - trackCasc = df.getTrack(2); std::array pVecXi; std::array pVecPi0; std::array pVecPi1; @@ -236,7 +242,7 @@ struct HfCandidateCreatorXic { // get invariant mass of Xic candidate auto arrayMomenta = std::array{pVecXi, pVecPi0, pVecPi1}; - massXiPiPi = RecoDecay::m(std::move(arrayMomenta), std::array{massXiMinusFromPdg, massPionFromPdg, massPionFromPdg}); + massXiPiPi = RecoDecay::m(std::move(arrayMomenta), std::array{MassXiMinus, MassPiPlus, MassPiPlus}); // get track impact parameters // This modifies track momenta! @@ -259,9 +265,9 @@ struct HfCandidateCreatorXic { // get invariant mass of Xi-pi pairs auto arrayMomentaXiPi0 = std::array{pVecXi, pVecPi0}; - massXiPi0 = RecoDecay::m(std::move(arrayMomentaXiPi0), std::array{massXiMinusFromPdg, massPionFromPdg}); + massXiPi0 = RecoDecay::m(std::move(arrayMomentaXiPi0), std::array{MassXiMinus, MassPiPlus}); auto arrayMomentaXiPi1 = std::array{pVecXi, pVecPi1}; - massXiPi1 = RecoDecay::m(std::move(arrayMomentaXiPi1), std::array{massXiMinusFromPdg, massPionFromPdg}); + massXiPi1 = RecoDecay::m(std::move(arrayMomentaXiPi1), std::array{MassXiMinus, MassPiPlus}); // get uncertainty of the decay length double phi, theta; @@ -272,24 +278,24 @@ struct HfCandidateCreatorXic { //--------------------------------------------fill histograms---------------------------------------------------------------- if (fillHistograms) { // invariant mass - hMass3->Fill(massXiPiPi); + registry.fill(HIST("hMass3"), massXiPiPi); // covariance matrix elements of PV - hCovPVXX->Fill(covMatrixPV[0]); - hCovPVYY->Fill(covMatrixPV[2]); - hCovPVXZ->Fill(covMatrixPV[3]); - hCovPVZZ->Fill(covMatrixPV[5]); + registry.fill(HIST("hCovPVXX"), covMatrixPV[0]); + registry.fill(HIST("hCovPVYY"), covMatrixPV[2]); + registry.fill(HIST("hCovPVXZ"), covMatrixPV[3]); + registry.fill(HIST("hCovPVZZ"), covMatrixPV[5]); // covariance matrix elements of SV - hCovSVXX->Fill(covMatrixSV[0]); - hCovSVYY->Fill(covMatrixSV[2]); - hCovSVXZ->Fill(covMatrixSV[3]); - hCovSVZZ->Fill(covMatrixSV[5]); + registry.fill(HIST("hCovSVXX"), covMatrixSV[0]); + registry.fill(HIST("hCovSVYY"), covMatrixSV[2]); + registry.fill(HIST("hCovSVXZ"), covMatrixSV[3]); + registry.fill(HIST("hCovSVZZ"), covMatrixSV[5]); // DCAs of prongs - hDcaXYProngs->Fill(trackCharmBachelor0.pt(), impactParameter0.getY()); - hDcaXYProngs->Fill(trackCharmBachelor1.pt(), impactParameter1.getY()); - hDcaXYProngs->Fill(trackCasc.getPt(), impactParameterCasc.getY()); - hDcaZProngs->Fill(trackCharmBachelor0.pt(), impactParameter0.getZ()); - hDcaZProngs->Fill(trackCharmBachelor1.pt(), impactParameter1.getZ()); - hDcaZProngs->Fill(trackCasc.getPt(), impactParameterCasc.getZ()); + registry.fill(HIST("hDcaXYProngs"), trackCasc.getPt(), impactParameterCasc.getY()); + registry.fill(HIST("hDcaXYProngs"), trackCharmBachelor0.pt(), impactParameter0.getY()); + registry.fill(HIST("hDcaXYProngs"), trackCharmBachelor1.pt(), impactParameter1.getY()); + registry.fill(HIST("hDcaZProngs"), trackCasc.getPt(), impactParameterCasc.getZ()); + registry.fill(HIST("hDcaZProngs"), trackCharmBachelor0.pt(), impactParameter0.getZ()); + registry.fill(HIST("hDcaZProngs"), trackCharmBachelor1.pt(), impactParameter1.getZ()); } //---------------------------------fill candidate table rows------------------------------------------------------------------------------------------- @@ -315,9 +321,9 @@ struct HfCandidateCreatorXic { massXiPi0, massXiPi1); } // loop over track triplets } - PROCESS_SWITCH(HfCandidateCreatorXic, processXicplusWithDcaFitter, "Run candidate creator with DCAFitter.", true); + PROCESS_SWITCH(HfCandidateCreatorXicToXiPiPi, processXicPlusWithDcaFitter, "Run candidate creator with DCAFitter.", true); - void processXicplusWithKFParticleFromDerivedData(aod::Collisions const&, + void processXicPlusWithKFParticleFromDerivedData(aod::Collisions const&, aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, KFCascadesLinked const&, KFCascFull const&, @@ -340,7 +346,7 @@ struct HfCandidateCreatorXic { if (std::abs(casc.dcaXYCascToPV()) > dcaXYToPVCascadeMax) { continue; } - if (std::abs(casc.mXi() - massXiMinusFromPdg) > massToleranceCascade) { + if (std::abs(casc.mXi() - MassXiMinus) > massToleranceCascade) { continue; } } @@ -458,21 +464,21 @@ struct HfCandidateCreatorXic { //-------------------------------fill histograms-------------------------------------------- if (fillHistograms) { // invariant mass - hMass3->Fill(kfXicPlus.GetMass()); + registry.fill(HIST("hMass3"), kfXicPlus.GetMass()); // covariance matrix elements of PV - hCovPVXX->Fill(covMatrixPV[0]); - hCovPVYY->Fill(covMatrixPV[2]); - hCovPVXZ->Fill(covMatrixPV[3]); - hCovPVZZ->Fill(covMatrixPV[5]); + registry.fill(HIST("hCovPVXX"), covMatrixPV[0]); + registry.fill(HIST("hCovPVYY"), covMatrixPV[2]); + registry.fill(HIST("hCovPVXZ"), covMatrixPV[3]); + registry.fill(HIST("hCovPVZZ"), covMatrixPV[5]); // covariance matrix elements of SV - hCovSVXX->Fill(covMatrixXicPlus[0]); - hCovSVYY->Fill(covMatrixXicPlus[2]); - hCovSVXZ->Fill(covMatrixXicPlus[3]); - hCovSVZZ->Fill(covMatrixXicPlus[5]); + registry.fill(HIST("hCovSVXX"), covMatrixXicPlus[0]); + registry.fill(HIST("hCovSVYY"), covMatrixXicPlus[2]); + registry.fill(HIST("hCovSVXZ"), covMatrixXicPlus[3]); + registry.fill(HIST("hCovSVZZ"), covMatrixXicPlus[5]); // DCAs of prongs - hDcaXYProngs->Fill(kfCharmBachelor0.GetPt(), impactParameterPi0XY); - hDcaXYProngs->Fill(kfCharmBachelor1.GetPt(), impactParameterPi1XY); - hDcaXYProngs->Fill(kfXi.GetPt(), impactParameterXiXY); + registry.fill(HIST("hDcaXYProngs"), kfXi.GetPt(), impactParameterXiXY); + registry.fill(HIST("hDcaXYProngs"), kfCharmBachelor0.GetPt(), impactParameterPi0XY); + registry.fill(HIST("hDcaXYProngs"), kfCharmBachelor1.GetPt(), impactParameterPi1XY); } //------------------------------fill candidate table rows-------------------------------------- @@ -500,11 +506,11 @@ struct HfCandidateCreatorXic { dcaXYPi0Pi1, dcaXYPi0Xi, dcaXYPi1Xi); } // loop over track triplets } - PROCESS_SWITCH(HfCandidateCreatorXic, processXicplusWithKFParticleFromDerivedData, "Run candidate creator with KFParticle using derived data from HfTrackIndexSkimCreatorLfCascades.", false); + PROCESS_SWITCH(HfCandidateCreatorXicToXiPiPi, processXicPlusWithKFParticleFromDerivedData, "Run candidate creator with KFParticle using derived data from HfTrackIndexSkimCreatorLfCascades.", false); }; // struct /// Performs MC matching. -struct HfCandidateCreatorXicExpressions { +struct HfCandidateCreatorXicToXiPiPiExpressions { Spawns rowCandidateXic; Produces rowMcMatchRec; Produces rowMcMatchGen; @@ -522,16 +528,10 @@ struct HfCandidateCreatorXicExpressions { int8_t flag = 0; int8_t origin = 0; int8_t debug = 0; + // for resonance matching: std::vector arrDaughIndex; std::array arrPDGDaugh; - std::array arrXiResonance = {3324, kPiPlus}; // 3324: Ξ(1530) - int pdgCodeXicPlus = Pdg::kXiCPlus; // 4232 - int pdgCodeXiMinus = kXiMinus; // 3312 - int pdgCodeLambda = kLambda0; // 3122 - int pdgCodePiPlus = kPiPlus; // 211 - int pdgCodePiMinus = kPiMinus; // -211 - int pdgCodeProton = kProton; // 2212 // Match reconstructed candidates. for (const auto& candidate : *rowCandidateXic) { @@ -553,20 +553,20 @@ struct HfCandidateCreatorXicExpressions { candidate.negTrack_as()}; // Xic → pi pi pi pi p - indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, pdgCodeXicPlus, std::array{pdgCodePiPlus, pdgCodePiPlus, pdgCodePiMinus, pdgCodeProton, pdgCodePiMinus}, true, &sign, 4); + indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, Pdg::kXiCPlus, std::array{+kPiPlus, +kPiPlus, +kPiMinus, +kProton, +kPiMinus}, true, &sign, 4); indexRecXicPlus = indexRec; if (indexRec == -1) { debug = 1; } if (indexRec > -1) { // Xi- → pi pi p - indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughtersCasc, pdgCodeXiMinus, std::array{pdgCodePiMinus, pdgCodeProton, pdgCodePiMinus}, true, &sign, 2); + indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughtersCasc, +kXiMinus, std::array{+kPiMinus, +kProton, +kPiMinus}, true, &sign, 2); if (indexRec == -1) { debug = 2; } if (indexRec > -1) { // Lambda → p pi - indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughtersV0, pdgCodeLambda, std::array{pdgCodeProton, pdgCodePiMinus}, true, &sign, 1); + indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughtersV0, +kLambda0, std::array{+kProton, +kPiMinus}, true, &sign, 1); if (indexRec == -1) { debug = 3; } @@ -578,12 +578,12 @@ struct HfCandidateCreatorXicExpressions { arrPDGDaugh[iProng] = std::abs(daughI.pdgCode()); } if ((arrPDGDaugh[0] == arrXiResonance[0] && arrPDGDaugh[1] == arrXiResonance[1]) || (arrPDGDaugh[0] == arrXiResonance[1] && arrPDGDaugh[1] == arrXiResonance[0])) { - flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi); + flag = sign * (1 << aod::hf_cand_xic_to_xi_pi_pi::DecayType::XicToXiResPiToXiPiPi); } else { debug = 4; } } else { - flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); + flag = sign * (1 << aod::hf_cand_xic_to_xi_pi_pi::DecayType::XicToXiPiPi); } } } @@ -607,15 +607,15 @@ struct HfCandidateCreatorXicExpressions { arrDaughIndex.clear(); // Xic → Xi pi pi - if (RecoDecay::isMatchedMCGen(mcParticles, particle, pdgCodeXicPlus, std::array{pdgCodeXiMinus, pdgCodePiPlus, pdgCodePiPlus}, true, &sign, 2)) { + if (RecoDecay::isMatchedMCGen(mcParticles, particle, Pdg::kXiCPlus, std::array{+kXiMinus, +kPiPlus, +kPiPlus}, true, &sign, 2)) { debug = 1; // Xi- -> Lambda pi auto cascMC = mcParticles.rawIteratorAt(particle.daughtersIds().front()); - if (RecoDecay::isMatchedMCGen(mcParticles, cascMC, pdgCodeXiMinus, std::array{pdgCodeLambda, pdgCodePiMinus}, true)) { + if (RecoDecay::isMatchedMCGen(mcParticles, cascMC, +kXiMinus, std::array{+kLambda0, +kPiMinus}, true)) { debug = 2; // Lambda -> p pi auto v0MC = mcParticles.rawIteratorAt(cascMC.daughtersIds().front()); - if (RecoDecay::isMatchedMCGen(mcParticles, v0MC, pdgCodeLambda, std::array{pdgCodeProton, pdgCodePiMinus}, true)) { + if (RecoDecay::isMatchedMCGen(mcParticles, v0MC, +kLambda0, std::array{+kProton, +kPiMinus}, true)) { debug = 3; RecoDecay::getDaughters(particle, &arrDaughIndex, std::array{0}, 1); @@ -625,12 +625,12 @@ struct HfCandidateCreatorXicExpressions { arrPDGDaugh[iProng] = std::abs(daughI.pdgCode()); } if ((arrPDGDaugh[0] == arrXiResonance[0] && arrPDGDaugh[1] == arrXiResonance[1]) || (arrPDGDaugh[0] == arrXiResonance[1] && arrPDGDaugh[1] == arrXiResonance[0])) { - flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiResPiToXiPiPi); + flag = sign * (1 << aod::hf_cand_xic_to_xi_pi_pi::DecayType::XicToXiResPiToXiPiPi); } else { debug = 4; } } else { - flag = sign * (1 << aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi); + flag = sign * (1 << aod::hf_cand_xic_to_xi_pi_pi::DecayType::XicToXiPiPi); } } } @@ -644,12 +644,12 @@ struct HfCandidateCreatorXicExpressions { rowMcMatchGen(flag, debug, origin); } // close loop over generated particles } // close process - PROCESS_SWITCH(HfCandidateCreatorXicExpressions, processMc, "Process MC", false); + PROCESS_SWITCH(HfCandidateCreatorXicToXiPiPiExpressions, processMc, "Process MC", false); }; // close struct WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{ - adaptAnalysisTask(cfgc), - adaptAnalysisTask(cfgc)}; + adaptAnalysisTask(cfgc), + adaptAnalysisTask(cfgc)}; } diff --git a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx index 1c68d35bf80..709bb4c1510 100644 --- a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx @@ -19,10 +19,10 @@ #include "Common/Core/TrackSelectorPID.h" -#include "PWGHF/Utils/utilsAnalysis.h" // findBin function #include "PWGHF/Core/SelectorCuts.h" #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/DataModel/CandidateSelectionTables.h" +#include "PWGHF/Utils/utilsAnalysis.h" // findBin function using namespace o2; using namespace o2::aod; @@ -32,8 +32,8 @@ using namespace o2::analysis; struct HfCandidateSelectorXicToXiPiPi { Produces hfSelXicToXiPiPiCandidate; - Configurable ptCandMin{"ptCandMin", 0., "Lower bound of candidate pT"}; - Configurable ptCandMax{"ptCandMax", 36., "Upper bound of candidate pT"}; + Configurable ptCandMin{"ptCandMin", 0., "Lower bound of candidate pT"}; + Configurable ptCandMax{"ptCandMax", 36., "Upper bound of candidate pT"}; // topological cuts Configurable> binsPt{"binsPt", std::vector{hf_cuts_xic_to_xi_pi_pi::vecBinsPt}, "pT bin limits"}; Configurable> cuts{"cuts", {hf_cuts_xic_to_xi_pi_pi::cuts[0], hf_cuts_xic_to_xi_pi_pi::nBinsPt, hf_cuts_xic_to_xi_pi_pi::nCutVars, hf_cuts_xic_to_xi_pi_pi::labelsPt, hf_cuts_xic_to_xi_pi_pi::labelsCutVar}, "Xicplus candidate selection per pT bin"}; @@ -166,9 +166,13 @@ struct HfCandidateSelectorXicToXiPiPi { /// \param pidTrackPiLam PID status of trackPiLam (negative daughter of V0 candidate) /// \param pidTrackPiXi PID status of trackPiXi (Bachelor of cascade candidate) /// \param acceptPIDNotApplicable switch to accept Status::NotApplicable - /// \return true if prong1 and prong 2 of Xic candidate pass all selections - template - bool selectionPid(const T1& pidTrackPi0, const T2& pidTrackPi1, const T3& pidTrackPr, const T4& pidTrackPiLam, const T5& pidTrackPiXi, const T6& acceptPIDNotApplicable) + /// \return true if prongs of Xic candidate pass all selections + bool selectionPid(TrackSelectorPID::Status const pidTrackPi0, + TrackSelectorPID::Status const pidTrackPi1, + TrackSelectorPID::Status const pidTrackPr, + TrackSelectorPID::Status const pidTrackPiLam, + TrackSelectorPID::Status const pidTrackPiXi, + bool const acceptPIDNotApplicable) { if (!acceptPIDNotApplicable && (pidTrackPi0 != TrackSelectorPID::Accepted || pidTrackPi1 != TrackSelectorPID::Accepted || pidTrackPr != TrackSelectorPID::Accepted || pidTrackPiLam != TrackSelectorPID::Accepted || pidTrackPiXi != TrackSelectorPID::Accepted)) { return false; @@ -221,11 +225,12 @@ struct HfCandidateSelectorXicToXiPiPi { trackPiFromLam = trackV0PosDau; } // PID info - int pidTrackPi0 = selectorPion.statusTpcAndTof(trackPi0); - int pidTrackPi1 = selectorPion.statusTpcAndTof(trackPi1); - int pidTrackPr = selectorProton.statusTpcAndTof(trackPr); - int pidTrackPiLam = selectorPion.statusTpcAndTof(trackPiFromLam); - int pidTrackPiXi = selectorPion.statusTpcAndTof(trackPiFromXi); + TrackSelectorPID::Status pidTrackPi0 = selectorPion.statusTpcAndTof(trackPi0); + TrackSelectorPID::Status pidTrackPi1 = selectorPion.statusTpcAndTof(trackPi1); + TrackSelectorPID::Status pidTrackPr = selectorProton.statusTpcAndTof(trackPr); + TrackSelectorPID::Status pidTrackPiLam = selectorPion.statusTpcAndTof(trackPiFromLam); + TrackSelectorPID::Status pidTrackPiXi = selectorPion.statusTpcAndTof(trackPiFromXi); + if (!selectionPid(pidTrackPi0, pidTrackPi1, pidTrackPr, pidTrackPiLam, pidTrackPiXi, acceptPIDNotApplicable.value)) { hfSelXicToXiPiPiCandidate(statusXicToXiPiPi); continue; diff --git a/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx index 60963810b40..e7c3fa553f5 100644 --- a/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx @@ -135,7 +135,7 @@ DECLARE_SOA_TABLE(HfCandXicLites, "AOD", "HFCANDXICLITE", full::CpaXYXi, full::CpaLam, full::CpaXYLam, - hf_cand_xictoxipipi::FlagMcMatchRec); + hf_cand_xic_to_xi_pi_pi::FlagMcMatchRec); DECLARE_SOA_TABLE(HfCandXicLiteKfs, "AOD", "HFCANDXICLITEKF", full::XiId, @@ -177,7 +177,7 @@ DECLARE_SOA_TABLE(HfCandXicLiteKfs, "AOD", "HFCANDXICLITEKF", full::DcaPi0Pi1, full::DcaPi0Xi, full::DcaPi1Xi, - hf_cand_xictoxipipi::FlagMcMatchRec); + hf_cand_xic_to_xi_pi_pi::FlagMcMatchRec); DECLARE_SOA_TABLE(HfCandXicFulls, "AOD", "HFCANDXICFULL", full::XiId, @@ -234,7 +234,7 @@ DECLARE_SOA_TABLE(HfCandXicFulls, "AOD", "HFCANDXICFULL", full::CpaXYLam, full::InvMassXiPi0, full::InvMassXiPi1, - hf_cand_xictoxipipi::FlagMcMatchRec); + hf_cand_xic_to_xi_pi_pi::FlagMcMatchRec); DECLARE_SOA_TABLE(HfCandXicFullKfs, "AOD", "HFCANDXICFULLKF", full::XiId, @@ -296,16 +296,14 @@ DECLARE_SOA_TABLE(HfCandXicFullKfs, "AOD", "HFCANDXICFULLKF", full::DcaPi0Pi1, full::DcaPi0Xi, full::DcaPi1Xi, - hf_cand_xictoxipipi::FlagMcMatchRec); + hf_cand_xic_to_xi_pi_pi::FlagMcMatchRec); DECLARE_SOA_TABLE(HfCandXicFullEvs, "AOD", "HFCANDXICFULLEV", collision::BCId, collision::NumContrib, collision::PosX, collision::PosY, - collision::PosZ, - full::IsEventReject, - full::RunNumber); + collision::PosZ); DECLARE_SOA_TABLE(HfCandXicFullPs, "AOD", "HFCANDXICFULLP", collision::BCId, @@ -313,7 +311,7 @@ DECLARE_SOA_TABLE(HfCandXicFullPs, "AOD", "HFCANDXICFULLP", full::Eta, full::Phi, full::Y, - hf_cand_xictoxipipi::FlagMcMatchGen); + hf_cand_xic_to_xi_pi_pi::FlagMcMatchGen); } // namespace o2::aod /// Writes the full information in an output TTree @@ -341,26 +339,24 @@ struct HfTreeCreatorXicToXiPiPi { Filter filterSelectCandidates = aod::hf_sel_candidate_xic::isSelXicToXiPiPi >= selectionFlagXic; - Partition recSig = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) != int8_t(0); - Partition recBg = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) == int8_t(0); - Partition recSigKf = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) != int8_t(0); - Partition recBgKf = nabs(aod::hf_cand_xictoxipipi::flagMcMatchRec) == int8_t(0); + Partition recSig = nabs(aod::hf_cand_xic_to_xi_pi_pi::flagMcMatchRec) != int8_t(0); + Partition recBg = nabs(aod::hf_cand_xic_to_xi_pi_pi::flagMcMatchRec) == int8_t(0); + Partition recSigKf = nabs(aod::hf_cand_xic_to_xi_pi_pi::flagMcMatchRec) != int8_t(0); + Partition recBgKf = nabs(aod::hf_cand_xic_to_xi_pi_pi::flagMcMatchRec) == int8_t(0); void init(InitContext const&) { } template - void fillEvent(const T& collision, int isEventReject, int runNumber) + void fillEvent(const T& collision) { rowCandidateFullEvents( collision.bcId(), collision.numContrib(), collision.posX(), collision.posY(), - collision.posZ(), - isEventReject, //! filled with 0 - runNumber); //! filled with 1 + collision.posZ()); } template @@ -582,7 +578,7 @@ struct HfTreeCreatorXicToXiPiPi { // Filling event properties rowCandidateFullEvents.reserve(collisions.size()); for (const auto& collision : collisions) { - fillEvent(collision, 0, 1); + fillEvent(collision); } // Filling candidate properties @@ -610,7 +606,7 @@ struct HfTreeCreatorXicToXiPiPi { // Filling event properties rowCandidateFullEvents.reserve(collisions.size()); for (const auto& collision : collisions) { - fillEvent(collision, 0, 1); + fillEvent(collision); } // Filling candidate properties @@ -640,7 +636,7 @@ struct HfTreeCreatorXicToXiPiPi { // Filling event properties rowCandidateFullEvents.reserve(collisions.size()); for (const auto& collision : collisions) { - fillEvent(collision, 0, 1); + fillEvent(collision); } // Filling candidate properties @@ -680,7 +676,7 @@ struct HfTreeCreatorXicToXiPiPi { // Filling particle properties rowCandidateFullParticles.reserve(particles.size()); for (const auto& particle : particles) { - if (TESTBIT(std::abs(particle.flagMcMatchGen()), aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { + if (TESTBIT(std::abs(particle.flagMcMatchGen()), aod::hf_cand_xic_to_xi_pi_pi::DecayType::XicToXiPiPi)) { rowCandidateFullParticles( particle.mcCollision().bcId(), particle.pt(), @@ -702,7 +698,7 @@ struct HfTreeCreatorXicToXiPiPi { // Filling event properties rowCandidateFullEvents.reserve(collisions.size()); for (const auto& collision : collisions) { - fillEvent(collision, 0, 1); + fillEvent(collision); } // Filling candidate properties @@ -742,7 +738,7 @@ struct HfTreeCreatorXicToXiPiPi { // Filling particle properties rowCandidateFullParticles.reserve(particles.size()); for (const auto& particle : particles) { - if (TESTBIT(std::abs(particle.flagMcMatchGen()), aod::hf_cand_xictoxipipi::DecayType::XicToXiPiPi)) { + if (TESTBIT(std::abs(particle.flagMcMatchGen()), aod::hf_cand_xic_to_xi_pi_pi::DecayType::XicToXiPiPi)) { rowCandidateFullParticles( particle.mcCollision().bcId(), particle.pt(), From faad520c5741a4f0a0bfe115075584740468c0d8 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Sun, 23 Jun 2024 19:00:37 +0200 Subject: [PATCH 32/35] Fix formatting --- PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx | 2 +- PWGHF/DataModel/CandidateSelectionTables.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx index 9d8a5a52160..3a5acb6dd6e 100644 --- a/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx +++ b/PWGHF/D2H/Tasks/taskXicToXiPiPi.cxx @@ -147,7 +147,7 @@ struct HfTaskXicToXiPiPi { registry.add("hPtGenWithProngsInAcceptance", "MC particles (generated-daughters in acceptance);candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{300, 0., 30.}}}); registry.add("hEtaGenWithProngsInAcceptance", "MC particles (generated-daughters in acceptance);#Xi^{#plus}_{c} candidate #it{#eta}^{gen};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); registry.add("hYGenWithProngsInAcceptance", "MC particles (generated-daughters in acceptance);#Xi^{#plus}_{c} candidate #it{y}^{gen};entries", {HistType::kTH2F, {{100, -2., 2.}, axisPt}}); - } + } if (checkDecayTypeMc) { constexpr uint8_t kNBinsDecayTypeMc = hf_cand_xic_to_xi_pi_pi::DecayType::NDecayType + 1; diff --git a/PWGHF/DataModel/CandidateSelectionTables.h b/PWGHF/DataModel/CandidateSelectionTables.h index 39fb8681c65..e5b38f39493 100644 --- a/PWGHF/DataModel/CandidateSelectionTables.h +++ b/PWGHF/DataModel/CandidateSelectionTables.h @@ -307,7 +307,7 @@ DECLARE_SOA_COLUMN(IsSelXicToPiKP, isSelXicToPiKP, int); //! DECLARE_SOA_COLUMN(MlProbXicToPKPi, mlProbXicToPKPi, std::vector); //! DECLARE_SOA_COLUMN(MlProbXicToPiKP, mlProbXicToPiKP, std::vector); //! // XicPlus to Xi Pi Pi -DECLARE_SOA_COLUMN(IsSelXicToXiPiPi, isSelXicToXiPiPi, int); //! +DECLARE_SOA_COLUMN(IsSelXicToXiPiPi, isSelXicToXiPiPi, int); //! } // namespace hf_sel_candidate_xic DECLARE_SOA_TABLE(HfSelXicToPKPi, "AOD", "HFSELXIC", //! From 62b34bee57537f7450647d779365be204377091f Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Wed, 26 Jun 2024 12:45:57 +0200 Subject: [PATCH 33/35] Implement requested changes in candidate and tree creator --- .../candidateCreatorXicToXiPiPi.cxx | 43 ++++++++-------- .../TableProducer/treeCreatorXicToXiPiPi.cxx | 50 ++++++++----------- 2 files changed, 44 insertions(+), 49 deletions(-) diff --git a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index d300301922e..eddcdf29ff5 100644 --- a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -99,6 +99,10 @@ struct HfCandidateCreatorXicToXiPiPi { void init(InitContext const&) { + if ((doprocessXicplusWithDcaFitter + doprocessXicplusWithKFParticle) != 1) { + LOGP(fatal, "Only one process function can be enabled at a time."); + } + // add histograms to registry if (fillHistograms) { registry.add("hMass3", "3-prong candidates;inv. mass (#Xi #pi #pi) (GeV/#it{c}^{2});entries", {HistType::kTH1D, {{500, 2.3, 2.7}}}); @@ -115,6 +119,14 @@ struct HfCandidateCreatorXicToXiPiPi { registry.add("hDcaZProngs", "DCAz of 3-prong candidates;#it{p}_{T} (GeV/#it{c};#it{d}_{z}) (#mum);entries", {HistType::kTH2D, {{100, 0., 20.}, {200, -500., 500.}}}); } + // fill hVertexerType histogram + if ((doprocessXicplusWithDcaFitter == 1) && fillHistograms) { + registry.fill(HIST("hVertexerType"), aod::hf_cand::VertexerType::DCAFitter); + } + if ((doprocessXicplusWithKFParticle == 1) && fillHistograms) { + registry.fill(HIST("hVertexerType"), aod::hf_cand::VertexerType::KfParticle); + } + // initialize CCDB ccdb->setURL(ccdbUrl); ccdb->setCaching(true); @@ -122,17 +134,6 @@ struct HfCandidateCreatorXicToXiPiPi { lut = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdb->get(ccdbPathLut)); runNumber = 0; - // fill hVertexerType histogram - if ((doprocessXicPlusWithDcaFitter + doprocessXicPlusWithKFParticleFromDerivedData) != 1) { - LOGP(fatal, "Only one process function can be enabled at a time."); - } - if ((doprocessXicPlusWithDcaFitter == 1) && fillHistograms) { - registry.fill(HIST("hVertexerType"), aod::hf_cand::VertexerType::DCAFitter); - } - if ((doprocessXicPlusWithKFParticleFromDerivedData == 1) && fillHistograms) { - registry.fill(HIST("hVertexerType"), aod::hf_cand::VertexerType::KfParticle); - } - // initialize 3-prong vertex fitter df.setPropagateToPCA(propagateToPCA); df.setMaxR(maxR); @@ -143,7 +144,7 @@ struct HfCandidateCreatorXicToXiPiPi { df.setWeightedFinalPCA(useWeightedFinalPCA); } - void processXicPlusWithDcaFitter(aod::Collisions const&, + void processXicplusWithDcaFitter(aod::Collisions const&, aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, CascadesLinked const&, CascFull const&, @@ -321,14 +322,14 @@ struct HfCandidateCreatorXicToXiPiPi { massXiPi0, massXiPi1); } // loop over track triplets } - PROCESS_SWITCH(HfCandidateCreatorXicToXiPiPi, processXicPlusWithDcaFitter, "Run candidate creator with DCAFitter.", true); - - void processXicPlusWithKFParticleFromDerivedData(aod::Collisions const&, - aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, - KFCascadesLinked const&, - KFCascFull const&, - aod::TracksWCovExtra const&, - aod::BCsWithTimestamps const&) + PROCESS_SWITCH(HfCandidateCreatorXicToXiPiPi, processXicplusWithDcaFitter, "Run candidate creator with DCAFitter.", true); + + void processXicplusWithKFParticle(aod::Collisions const&, + aod::HfCascLf3Prongs const& rowsTrackIndexXicPlus, + KFCascadesLinked const&, + KFCascFull const&, + aod::TracksWCovExtra const&, + aod::BCsWithTimestamps const&) { // loop over triplets of track indices for (const auto& rowTrackIndexXicPlus : rowsTrackIndexXicPlus) { @@ -506,7 +507,7 @@ struct HfCandidateCreatorXicToXiPiPi { dcaXYPi0Pi1, dcaXYPi0Xi, dcaXYPi1Xi); } // loop over track triplets } - PROCESS_SWITCH(HfCandidateCreatorXicToXiPiPi, processXicPlusWithKFParticleFromDerivedData, "Run candidate creator with KFParticle using derived data from HfTrackIndexSkimCreatorLfCascades.", false); + PROCESS_SWITCH(HfCandidateCreatorXicToXiPiPi, processXicplusWithKFParticle, "Run candidate creator with KFParticle using derived data from HfTrackIndexSkimCreatorLfCascades.", false); }; // struct /// Performs MC matching. diff --git a/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx index e7c3fa553f5..3cb58040a44 100644 --- a/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx @@ -92,15 +92,9 @@ DECLARE_SOA_COLUMN(DcaPi0Xi, dcaPi0Xi, float); DECLARE_SOA_COLUMN(DcaPi1Xi, dcaPi1Xi, float); DECLARE_SOA_COLUMN(InvMassXiPi0, invMassXiPi0, float); DECLARE_SOA_COLUMN(InvMassXiPi1, invMassXiPi1, float); -// PID daughters -DECLARE_SOA_COLUMN(NSigTpcPi1, nSigTpcPi1, float); //! TPC Nsigma separation for prong1 with pion mass hypothesis -DECLARE_SOA_COLUMN(NSigTofPi1, nSigTofPi1, float); //! TOF Nsigma separation for prong1 with pion mass hypothesis -// Events -DECLARE_SOA_COLUMN(IsEventReject, isEventReject, int); //! Event rejection flag -DECLARE_SOA_COLUMN(RunNumber, runNumber, int); //! Run number } // namespace full -DECLARE_SOA_TABLE(HfCandXicLites, "AOD", "HFCANDXICLITE", +DECLARE_SOA_TABLE(HfCandXicToXiPiPiLites, "AOD", "HFXICXI2PILITE", full::XiId, full::Pi0Id, full::Pi1Id, @@ -137,7 +131,7 @@ DECLARE_SOA_TABLE(HfCandXicLites, "AOD", "HFCANDXICLITE", full::CpaXYLam, hf_cand_xic_to_xi_pi_pi::FlagMcMatchRec); -DECLARE_SOA_TABLE(HfCandXicLiteKfs, "AOD", "HFCANDXICLITEKF", +DECLARE_SOA_TABLE(HfCandXicToXiPiPiLiteKfs, "AOD", "HFXICXI2PILITKF", full::XiId, full::Pi0Id, full::Pi1Id, @@ -179,7 +173,7 @@ DECLARE_SOA_TABLE(HfCandXicLiteKfs, "AOD", "HFCANDXICLITEKF", full::DcaPi1Xi, hf_cand_xic_to_xi_pi_pi::FlagMcMatchRec); -DECLARE_SOA_TABLE(HfCandXicFulls, "AOD", "HFCANDXICFULL", +DECLARE_SOA_TABLE(HfCandXicToXiPiPiFulls, "AOD", "HFXICXI2PIFULL", full::XiId, full::Pi0Id, full::Pi1Id, @@ -236,7 +230,7 @@ DECLARE_SOA_TABLE(HfCandXicFulls, "AOD", "HFCANDXICFULL", full::InvMassXiPi1, hf_cand_xic_to_xi_pi_pi::FlagMcMatchRec); -DECLARE_SOA_TABLE(HfCandXicFullKfs, "AOD", "HFCANDXICFULLKF", +DECLARE_SOA_TABLE(HfCandXicToXiPiPiFullKfs, "AOD", "HFXICXI2PIFULKF", full::XiId, full::Pi0Id, full::Pi1Id, @@ -298,14 +292,14 @@ DECLARE_SOA_TABLE(HfCandXicFullKfs, "AOD", "HFCANDXICFULLKF", full::DcaPi1Xi, hf_cand_xic_to_xi_pi_pi::FlagMcMatchRec); -DECLARE_SOA_TABLE(HfCandXicFullEvs, "AOD", "HFCANDXICFULLEV", +DECLARE_SOA_TABLE(HfCandXicToXiPiPiFullEvs, "AOD", "HFXICXI2PIFULEV", collision::BCId, collision::NumContrib, collision::PosX, collision::PosY, collision::PosZ); -DECLARE_SOA_TABLE(HfCandXicFullPs, "AOD", "HFCANDXICFULLP", +DECLARE_SOA_TABLE(HfCandXicToXiPiPiFullPs, "AOD", "HFXICXI2PIFULLP", collision::BCId, full::Pt, full::Eta, @@ -316,12 +310,12 @@ DECLARE_SOA_TABLE(HfCandXicFullPs, "AOD", "HFCANDXICFULLP", /// Writes the full information in an output TTree struct HfTreeCreatorXicToXiPiPi { - Produces rowCandidateLite; - Produces rowCandidateLiteKf; - Produces rowCandidateFull; - Produces rowCandidateFullKf; - Produces rowCandidateFullEvents; - Produces rowCandidateFullParticles; + Produces rowCandidateLite; + Produces rowCandidateLiteKf; + Produces rowCandidateFull; + Produces rowCandidateFullKf; + Produces rowCandidateFullEvents; + Produces rowCandidateFullParticles; Configurable selectionFlagXic{"selectionXic", 1, "Selection Flag for Xic"}; Configurable fillCandidateLiteTable{"fillCandidateLiteTable", false, "Switch to fill lite table with candidate properties"}; @@ -359,14 +353,14 @@ struct HfTreeCreatorXicToXiPiPi { collision.posZ()); } - template + template void fillCandidateTable(const T& candidate) { int8_t flagMc = 0; if constexpr (doMc) { flagMc = candidate.flagMcMatchRec(); } - if constexpr (noKf) { + if constexpr (!doKf) { if (fillCandidateLiteTable) { rowCandidateLite( candidate.cascadeId(), @@ -594,7 +588,7 @@ struct HfTreeCreatorXicToXiPiPi { continue; } } - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } PROCESS_SWITCH(HfTreeCreatorXicToXiPiPi, processData, "Process data", true); @@ -622,7 +616,7 @@ struct HfTreeCreatorXicToXiPiPi { continue; } } - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } PROCESS_SWITCH(HfTreeCreatorXicToXiPiPi, processDataKf, "Process data with KF Particle reconstruction", false); @@ -647,7 +641,7 @@ struct HfTreeCreatorXicToXiPiPi { rowCandidateFull.reserve(recSig.size()); } for (const auto& candidate : recSig) { - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } else if (fillOnlyBackground) { if (fillCandidateLiteTable) { @@ -660,7 +654,7 @@ struct HfTreeCreatorXicToXiPiPi { if (candidate.pt() < ptMaxForDownSample && pseudoRndm >= downSampleBkgFactor) { continue; } - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } else { if (fillCandidateLiteTable) { @@ -669,7 +663,7 @@ struct HfTreeCreatorXicToXiPiPi { rowCandidateFull.reserve(candidates.size()); } for (const auto& candidate : candidates) { - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } @@ -709,7 +703,7 @@ struct HfTreeCreatorXicToXiPiPi { rowCandidateFull.reserve(recSigKf.size()); } for (const auto& candidate : recSigKf) { - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } else if (fillOnlyBackground) { if (fillCandidateLiteTable) { @@ -722,7 +716,7 @@ struct HfTreeCreatorXicToXiPiPi { if (candidate.pt() < ptMaxForDownSample && pseudoRndm >= downSampleBkgFactor) { continue; } - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } else { if (fillCandidateLiteTable) { @@ -731,7 +725,7 @@ struct HfTreeCreatorXicToXiPiPi { rowCandidateFull.reserve(candidates.size()); } for (const auto& candidate : candidates) { - fillCandidateTable(candidate); + fillCandidateTable(candidate); } } From 2675309c7a99c857329865bd74c55365ce7a2bab Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Fri, 5 Jul 2024 11:32:10 +0200 Subject: [PATCH 34/35] Tree creator: Move index columns to separate table --- .../TableProducer/treeCreatorXicToXiPiPi.cxx | 88 ++++++++++++++----- 1 file changed, 64 insertions(+), 24 deletions(-) diff --git a/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx index 3cb58040a44..c28709ffc75 100644 --- a/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/treeCreatorXicToXiPiPi.cxx @@ -95,9 +95,6 @@ DECLARE_SOA_COLUMN(InvMassXiPi1, invMassXiPi1, float); } // namespace full DECLARE_SOA_TABLE(HfCandXicToXiPiPiLites, "AOD", "HFXICXI2PILITE", - full::XiId, - full::Pi0Id, - full::Pi1Id, full::CandidateSelFlag, full::XPv, full::YPv, @@ -132,9 +129,6 @@ DECLARE_SOA_TABLE(HfCandXicToXiPiPiLites, "AOD", "HFXICXI2PILITE", hf_cand_xic_to_xi_pi_pi::FlagMcMatchRec); DECLARE_SOA_TABLE(HfCandXicToXiPiPiLiteKfs, "AOD", "HFXICXI2PILITKF", - full::XiId, - full::Pi0Id, - full::Pi1Id, full::CandidateSelFlag, full::XPv, full::YPv, @@ -174,9 +168,6 @@ DECLARE_SOA_TABLE(HfCandXicToXiPiPiLiteKfs, "AOD", "HFXICXI2PILITKF", hf_cand_xic_to_xi_pi_pi::FlagMcMatchRec); DECLARE_SOA_TABLE(HfCandXicToXiPiPiFulls, "AOD", "HFXICXI2PIFULL", - full::XiId, - full::Pi0Id, - full::Pi1Id, full::CandidateSelFlag, full::XPv, full::YPv, @@ -231,9 +222,6 @@ DECLARE_SOA_TABLE(HfCandXicToXiPiPiFulls, "AOD", "HFXICXI2PIFULL", hf_cand_xic_to_xi_pi_pi::FlagMcMatchRec); DECLARE_SOA_TABLE(HfCandXicToXiPiPiFullKfs, "AOD", "HFXICXI2PIFULKF", - full::XiId, - full::Pi0Id, - full::Pi1Id, full::CandidateSelFlag, full::XPv, full::YPv, @@ -292,6 +280,11 @@ DECLARE_SOA_TABLE(HfCandXicToXiPiPiFullKfs, "AOD", "HFXICXI2PIFULKF", full::DcaPi1Xi, hf_cand_xic_to_xi_pi_pi::FlagMcMatchRec); +DECLARE_SOA_TABLE(HfCandXicToXiPiPiDauInds, "AOD", "HFXICXI2PIDAUIN", + full::XiId, + full::Pi0Id, + full::Pi1Id); + DECLARE_SOA_TABLE(HfCandXicToXiPiPiFullEvs, "AOD", "HFXICXI2PIFULEV", collision::BCId, collision::NumContrib, @@ -314,11 +307,13 @@ struct HfTreeCreatorXicToXiPiPi { Produces rowCandidateLiteKf; Produces rowCandidateFull; Produces rowCandidateFullKf; + Produces rowCandidateDauIndices; Produces rowCandidateFullEvents; Produces rowCandidateFullParticles; Configurable selectionFlagXic{"selectionXic", 1, "Selection Flag for Xic"}; Configurable fillCandidateLiteTable{"fillCandidateLiteTable", false, "Switch to fill lite table with candidate properties"}; + Configurable fillCandidateDauIndexTable{"fillCandidateDauIndexTable", false, "Switch to fill table with Xic daughters track indices"}; // parameters for production of training samples Configurable fillOnlySignal{"fillOnlySignal", false, "Flag to fill derived tables with signal for ML trainings"}; Configurable fillOnlyBackground{"fillOnlyBackground", false, "Flag to fill derived tables with background for ML trainings"}; @@ -353,6 +348,15 @@ struct HfTreeCreatorXicToXiPiPi { collision.posZ()); } + template + void fillIndexTable(const T& candidate) + { + rowCandidateDauIndices( + candidate.cascadeId(), + candidate.pi0Id(), + candidate.pi1Id()); + } + template void fillCandidateTable(const T& candidate) { @@ -363,9 +367,6 @@ struct HfTreeCreatorXicToXiPiPi { if constexpr (!doKf) { if (fillCandidateLiteTable) { rowCandidateLite( - candidate.cascadeId(), - candidate.pi0Id(), - candidate.pi1Id(), candidate.isSelXicToXiPiPi(), candidate.posX(), candidate.posY(), @@ -400,9 +401,6 @@ struct HfTreeCreatorXicToXiPiPi { flagMc); } else { rowCandidateFull( - candidate.cascadeId(), - candidate.pi0Id(), - candidate.pi1Id(), candidate.isSelXicToXiPiPi(), candidate.posX(), candidate.posY(), @@ -459,9 +457,6 @@ struct HfTreeCreatorXicToXiPiPi { } else { if (fillCandidateLiteTable) { rowCandidateLiteKf( - candidate.cascadeId(), - candidate.pi0Id(), - candidate.pi1Id(), candidate.isSelXicToXiPiPi(), candidate.posX(), candidate.posY(), @@ -501,9 +496,6 @@ struct HfTreeCreatorXicToXiPiPi { flagMc); } else { rowCandidateFullKf( - candidate.cascadeId(), - candidate.pi0Id(), - candidate.pi1Id(), candidate.isSelXicToXiPiPi(), candidate.posX(), candidate.posY(), @@ -576,6 +568,9 @@ struct HfTreeCreatorXicToXiPiPi { } // Filling candidate properties + if (fillCandidateDauIndexTable) { + rowCandidateDauIndices.reserve(candidates.size()); + } if (fillCandidateLiteTable) { rowCandidateLite.reserve(candidates.size()); } else { @@ -589,6 +584,9 @@ struct HfTreeCreatorXicToXiPiPi { } } fillCandidateTable(candidate); + if (fillCandidateDauIndexTable) { + fillIndexTable(candidate); + } } } PROCESS_SWITCH(HfTreeCreatorXicToXiPiPi, processData, "Process data", true); @@ -604,6 +602,9 @@ struct HfTreeCreatorXicToXiPiPi { } // Filling candidate properties + if (fillCandidateDauIndexTable) { + rowCandidateDauIndices.reserve(candidates.size()); + } if (fillCandidateLiteTable) { rowCandidateLite.reserve(candidates.size()); } else { @@ -617,6 +618,9 @@ struct HfTreeCreatorXicToXiPiPi { } } fillCandidateTable(candidate); + if (fillCandidateDauIndexTable) { + fillIndexTable(candidate); + } } } PROCESS_SWITCH(HfTreeCreatorXicToXiPiPi, processDataKf, "Process data with KF Particle reconstruction", false); @@ -635,6 +639,9 @@ struct HfTreeCreatorXicToXiPiPi { // Filling candidate properties if (fillOnlySignal) { + if (fillCandidateDauIndexTable) { + rowCandidateDauIndices.reserve(candidates.size()); + } if (fillCandidateLiteTable) { rowCandidateLite.reserve(recSig.size()); } else { @@ -642,8 +649,14 @@ struct HfTreeCreatorXicToXiPiPi { } for (const auto& candidate : recSig) { fillCandidateTable(candidate); + if (fillCandidateDauIndexTable) { + fillIndexTable(candidate); + } } } else if (fillOnlyBackground) { + if (fillCandidateDauIndexTable) { + rowCandidateDauIndices.reserve(candidates.size()); + } if (fillCandidateLiteTable) { rowCandidateLite.reserve(recBg.size()); } else { @@ -655,8 +668,14 @@ struct HfTreeCreatorXicToXiPiPi { continue; } fillCandidateTable(candidate); + if (fillCandidateDauIndexTable) { + fillIndexTable(candidate); + } } } else { + if (fillCandidateDauIndexTable) { + rowCandidateDauIndices.reserve(candidates.size()); + } if (fillCandidateLiteTable) { rowCandidateLite.reserve(candidates.size()); } else { @@ -664,6 +683,9 @@ struct HfTreeCreatorXicToXiPiPi { } for (const auto& candidate : candidates) { fillCandidateTable(candidate); + if (fillCandidateDauIndexTable) { + fillIndexTable(candidate); + } } } @@ -697,6 +719,9 @@ struct HfTreeCreatorXicToXiPiPi { // Filling candidate properties if (fillOnlySignal) { + if (fillCandidateDauIndexTable) { + rowCandidateDauIndices.reserve(candidates.size()); + } if (fillCandidateLiteTable) { rowCandidateLite.reserve(recSigKf.size()); } else { @@ -704,8 +729,14 @@ struct HfTreeCreatorXicToXiPiPi { } for (const auto& candidate : recSigKf) { fillCandidateTable(candidate); + if (fillCandidateDauIndexTable) { + fillIndexTable(candidate); + } } } else if (fillOnlyBackground) { + if (fillCandidateDauIndexTable) { + rowCandidateDauIndices.reserve(candidates.size()); + } if (fillCandidateLiteTable) { rowCandidateLite.reserve(recBgKf.size()); } else { @@ -717,8 +748,14 @@ struct HfTreeCreatorXicToXiPiPi { continue; } fillCandidateTable(candidate); + if (fillCandidateDauIndexTable) { + fillIndexTable(candidate); + } } } else { + if (fillCandidateDauIndexTable) { + rowCandidateDauIndices.reserve(candidates.size()); + } if (fillCandidateLiteTable) { rowCandidateLite.reserve(candidates.size()); } else { @@ -726,6 +763,9 @@ struct HfTreeCreatorXicToXiPiPi { } for (const auto& candidate : candidates) { fillCandidateTable(candidate); + if (fillCandidateDauIndexTable) { + fillIndexTable(candidate); + } } } From 949171d6a29b3669c26d21bcb385b5d00a571a96 Mon Sep 17 00:00:00 2001 From: Phil Lennart Stahlhut Date: Fri, 5 Jul 2024 14:42:37 +0200 Subject: [PATCH 35/35] Implement requested changes from review --- PWGHF/DataModel/CandidateReconstructionTables.h | 4 ++-- .../candidateCreatorXicToXiPiPi.cxx | 4 ++-- .../candidateSelectorXicToXiPiPi.cxx | 16 ++++++++-------- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index c22ae64ccec..e1b28dfaab4 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -1358,8 +1358,8 @@ DECLARE_SOA_COLUMN(OriginRec, originRec, int8_t); DECLARE_SOA_COLUMN(OriginGen, originGen, int8_t); // mapping of decay types -enum DecayType { XicToXiPiPi = 0, - XicToXiResPiToXiPiPi, +enum DecayType { XicToXiPiPi = 0, // Ξc± → Ξ∓ π± π± + XicToXiResPiToXiPiPi, // Ξc± → Ξ(1530) π± → Ξ∓ π± π± NDecayType }; } // end of namespace hf_cand_xic_to_xi_pi_pi diff --git a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx index eddcdf29ff5..36f9c083625 100644 --- a/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateCreatorXicToXiPiPi.cxx @@ -120,10 +120,10 @@ struct HfCandidateCreatorXicToXiPiPi { } // fill hVertexerType histogram - if ((doprocessXicplusWithDcaFitter == 1) && fillHistograms) { + if (doprocessXicplusWithDcaFitter && fillHistograms) { registry.fill(HIST("hVertexerType"), aod::hf_cand::VertexerType::DCAFitter); } - if ((doprocessXicplusWithKFParticle == 1) && fillHistograms) { + if (doprocessXicplusWithKFParticle && fillHistograms) { registry.fill(HIST("hVertexerType"), aod::hf_cand::VertexerType::KfParticle); } diff --git a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx index 709bb4c1510..4928ab194fc 100644 --- a/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx +++ b/PWGHF/TableProducer/candidateSelectorXicToXiPiPi.cxx @@ -43,15 +43,15 @@ struct HfCandidateSelectorXicToXiPiPi { Configurable usePid{"usePid", true, "Switch for PID selection at track level"}; Configurable acceptPIDNotApplicable{"acceptPIDNotApplicable", true, "Switch to accept Status::NotApplicable [(NotApplicable for one detector) and (NotApplicable or Conditional for the other)] in PID selection"}; // TPC PID - Configurable ptPidTpcMin{"ptPidTpcMin", 0.15, "Lower bound of track pT for TPC PID"}; - Configurable ptPidTpcMax{"ptPidTpcMax", 20., "Upper bound of track pT for TPC PID"}; - Configurable nSigmaTpcMax{"nSigmaTpcMax", 5., "Nsigma cut on TPC only"}; - Configurable nSigmaTpcCombinedMax{"nSigmaTpcCombinedMax", 5., "Nsigma cut on TPC combined with TOF"}; + Configurable ptPidTpcMin{"ptPidTpcMin", 0.15, "Lower bound of track pT for TPC PID"}; + Configurable ptPidTpcMax{"ptPidTpcMax", 20., "Upper bound of track pT for TPC PID"}; + Configurable nSigmaTpcMax{"nSigmaTpcMax", 5., "Nsigma cut on TPC only"}; + Configurable nSigmaTpcCombinedMax{"nSigmaTpcCombinedMax", 5., "Nsigma cut on TPC combined with TOF"}; // TOF PID - Configurable ptPidTofMin{"ptPidTofMin", 0.15, "Lower bound of track pT for TOF PID"}; - Configurable ptPidTofMax{"ptPidTofMax", 20., "Upper bound of track pT for TOF PID"}; - Configurable nSigmaTofMax{"nSigmaTofMax", 5., "Nsigma cut on TOF only"}; - Configurable nSigmaTofCombinedMax{"nSigmaTofCombinedMax", 5., "Nsigma cut on TOF combined with TPC"}; + Configurable ptPidTofMin{"ptPidTofMin", 0.15, "Lower bound of track pT for TOF PID"}; + Configurable ptPidTofMax{"ptPidTofMax", 20., "Upper bound of track pT for TOF PID"}; + Configurable nSigmaTofMax{"nSigmaTofMax", 5., "Nsigma cut on TOF only"}; + Configurable nSigmaTofCombinedMax{"nSigmaTofCombinedMax", 5., "Nsigma cut on TOF combined with TPC"}; TrackSelectorPi selectorPion; TrackSelectorPr selectorProton;