diff --git a/PWGHF/DataModel/DerivedTables.h b/PWGHF/DataModel/DerivedTables.h index 61c85b9fd63..49632f85a95 100644 --- a/PWGHF/DataModel/DerivedTables.h +++ b/PWGHF/DataModel/DerivedTables.h @@ -325,14 +325,7 @@ DECLARE_SOA_COLUMN(PtProng1, ptProng1, float); DECLARE_SOA_COLUMN(PtProng2, ptProng2, float); //! transverse momentum of prong 2 DECLARE_SOA_COLUMN(RSecondaryVertex, rSecondaryVertex, float); //! distance of the secondary vertex from the z axis // D*± → D0(bar) π± -DECLARE_SOA_COLUMN(MassD0, massD0, float); //! invariant mass of D0 -DECLARE_SOA_COLUMN(CpaD0, cpaD0, float); //! cosine of pointing angle of D0 -DECLARE_SOA_COLUMN(CpaXYD0, cpaXYD0, float); //! cosine of pointing angle in the transverse plane of D0 -DECLARE_SOA_COLUMN(DecayLengthD0, decayLengthD0, float); //! decay length of D0 -DECLARE_SOA_COLUMN(DecayLengthXYD0, decayLengthXYD0, float); //! decay length in the transverse plane of D0 -DECLARE_SOA_COLUMN(DecayLengthNormalisedD0, decayLengthNormalisedD0, float); //! decay length of D0 divided by its uncertainty -DECLARE_SOA_COLUMN(DecayLengthXYNormalisedD0, decayLengthXYNormalisedD0, float); //! decay length in the transverse plane of D0 divided by its uncertainty -DECLARE_SOA_COLUMN(NormalisedImpParamSoftPi, normalisedImpParamSoftPi, float); //! impact parameter of soft pion divided by its uncertainty +DECLARE_SOA_COLUMN(SignProng1, signProng1, int8_t); // TOF DECLARE_SOA_COLUMN(NSigTofKa0, nSigTofKa0, float); DECLARE_SOA_COLUMN(NSigTofKa1, nSigTofKa1, float); @@ -347,7 +340,6 @@ DECLARE_SOA_COLUMN(NSigTofPiExpKa, nSigTofPiExpKa, float); DECLARE_SOA_COLUMN(NSigTofPr0, nSigTofPr0, float); DECLARE_SOA_COLUMN(NSigTofPr1, nSigTofPr1, float); DECLARE_SOA_COLUMN(NSigTofPr2, nSigTofPr2, float); -DECLARE_SOA_COLUMN(NSigTofPiSoftPi, nSigTofPiSoftPi, float); // TPC DECLARE_SOA_COLUMN(NSigTpcKa0, nSigTpcKa0, float); DECLARE_SOA_COLUMN(NSigTpcKa1, nSigTpcKa1, float); @@ -362,7 +354,6 @@ DECLARE_SOA_COLUMN(NSigTpcPiExpKa, nSigTpcPiExpKa, float); DECLARE_SOA_COLUMN(NSigTpcPr0, nSigTpcPr0, float); DECLARE_SOA_COLUMN(NSigTpcPr1, nSigTpcPr1, float); DECLARE_SOA_COLUMN(NSigTpcPr2, nSigTpcPr2, float); -DECLARE_SOA_COLUMN(NSigTpcPiSoftPi, nSigTpcPiSoftPi, float); // TPC+TOF DECLARE_SOA_COLUMN(NSigTpcTofKa0, nSigTpcTofKa0, float); DECLARE_SOA_COLUMN(NSigTpcTofKa1, nSigTpcTofKa1, float); @@ -377,7 +368,6 @@ DECLARE_SOA_COLUMN(NSigTpcTofPiExpKa, nSigTpcTofPiExpKa, float); DECLARE_SOA_COLUMN(NSigTpcTofPr0, nSigTpcTofPr0, float); DECLARE_SOA_COLUMN(NSigTpcTofPr1, nSigTpcTofPr1, float); DECLARE_SOA_COLUMN(NSigTpcTofPr2, nSigTpcTofPr2, float); -DECLARE_SOA_COLUMN(NSigTpcTofPiSoftPi, nSigTpcTofPiSoftPi, float); } // namespace hf_cand_par // Candidate properties of the charm daughter candidate used for selection of the beauty candidate @@ -403,6 +393,12 @@ DECLARE_SOA_COLUMN(ImpactParameterNormalised1Charm, impactParameterNormalised1Ch DECLARE_SOA_COLUMN(ImpactParameterNormalised2Charm, impactParameterNormalised2Charm, float); //! impact parameter of prong 2 divided by its uncertainty DECLARE_SOA_COLUMN(ImpactParameterProductCharm, impactParameterProductCharm, float); //! product of impact parameters of prong 0 and prong 1 DECLARE_SOA_COLUMN(MaxNormalisedDeltaIPCharm, maxNormalisedDeltaIPCharm, float); //! see RecoDecay::maxNormalisedDeltaIP +DECLARE_SOA_COLUMN(PxProng0Charm, pxProng0Charm, float); //! x-component of momentum of prong 0 +DECLARE_SOA_COLUMN(PyProng0Charm, pyProng0Charm, float); //! y-component of momentum of prong 0 +DECLARE_SOA_COLUMN(PzProng0Charm, pzProng0Charm, float); //! z-component of momentum of prong 0 +DECLARE_SOA_COLUMN(PxProng1Charm, pxProng1Charm, float); //! x-component of momentum of prong 1 +DECLARE_SOA_COLUMN(PyProng1Charm, pyProng1Charm, float); //! y-component of momentum of prong 1 +DECLARE_SOA_COLUMN(PzProng1Charm, pzProng1Charm, float); //! z-component of momentum of prong 1 DECLARE_SOA_COLUMN(PProng0Charm, pProng0Charm, float); //! momentum magnitude of prong 0 DECLARE_SOA_COLUMN(PProng1Charm, pProng1Charm, float); //! momentum magnitude of prong 1 DECLARE_SOA_COLUMN(PProng2Charm, pProng2Charm, float); //! momentum magnitude of prong 2 @@ -410,6 +406,7 @@ DECLARE_SOA_COLUMN(PtProng0Charm, ptProng0Charm, float); DECLARE_SOA_COLUMN(PtProng1Charm, ptProng1Charm, float); //! transverse momentum of prong 1 DECLARE_SOA_COLUMN(PtProng2Charm, ptProng2Charm, float); //! transverse momentum of prong 2 DECLARE_SOA_COLUMN(RSecondaryVertexCharm, rSecondaryVertexCharm, float); //! distance of the secondary vertex from the z axis +DECLARE_SOA_COLUMN(InvMassCharm, invMassCharm, float); //! mass of the charm daughter // TOF DECLARE_SOA_COLUMN(NSigTofKa0Charm, nSigTofKa0Charm, float); DECLARE_SOA_COLUMN(NSigTofKa1Charm, nSigTofKa1Charm, float); @@ -846,52 +843,61 @@ DECLARE_SOA_TABLE_STAGED(HfDplusMcs, "HFDPMC", //! Table with MC candidate info // D*+ // ---------------- -DECLARE_SOA_TABLE_STAGED(HfDstarPars, "HFDSTARPAR", //! Table with candidate properties used for selection - hf_cand_dstar::Chi2PCAD0, - hf_cand_par::CpaD0, - hf_cand_par::CpaXYD0, - hf_cand_par::DecayLengthD0, - hf_cand_par::DecayLengthXYD0, - hf_cand_par::DecayLengthNormalisedD0, - hf_cand_par::DecayLengthXYNormalisedD0, - hf_cand::PxProng0, +DECLARE_SOA_TABLE_STAGED(HfDstarPars, "HFDSTPAR", //! Table with candidate properties used for selection + hf_cand::PxProng0, // Prong0 is the D0 hf_cand::PyProng0, hf_cand::PzProng0, - hf_cand::PxProng1, + hf_cand::PxProng1, // Prong1 is the soft pion hf_cand::PyProng1, hf_cand::PzProng1, - hf_cand_dstar::PxD0, - hf_cand_dstar::PyD0, - hf_cand_dstar::PzD0, - hf_cand_dstar::PxSoftPi, - hf_cand_dstar::PySoftPi, - hf_cand_dstar::PzSoftPi, - hf_cand_dstar::PtSoftPi, - hf_cand_dstar::SignSoftPi, - hf_cand_dstar::PtD0, - hf_cand_par::MassD0, - hf_cand::ImpactParameter0, + hf_cand::PtProng1, + hf_cand_par::SignProng1, + hf_cand::PtProng0, hf_cand::ImpactParameter1, - hf_cand_dstar::ImpParamSoftPi, - hf_cand_par::ImpactParameterNormalised0, hf_cand_par::ImpactParameterNormalised1, - hf_cand_par::NormalisedImpParamSoftPi, - hf_cand_par::NSigTpcPi0, - hf_cand_par::NSigTofPi0, - hf_cand_par::NSigTpcTofPi0, - hf_cand_par::NSigTpcKa1, - hf_cand_par::NSigTofKa1, - hf_cand_par::NSigTpcTofKa1, - hf_cand_par::NSigTpcPiSoftPi, - hf_cand_par::NSigTofPiSoftPi, - hf_cand_par::NSigTpcTofPiSoftPi, + hf_cand_par::NSigTpcPi1, + hf_cand_par::NSigTofPi1, + hf_cand_par::NSigTpcTofPi1, + o2::soa::Marker); + +DECLARE_SOA_TABLE_STAGED(HfDstarParD0s, "HFDSTPARD0", //! Table with candidate properties used for selection + hf_cand_par_charm::Chi2PCACharm, + hf_cand_par_charm::CpaCharm, + hf_cand_par_charm::CpaXYCharm, + hf_cand_par_charm::DecayLengthCharm, + hf_cand_par_charm::DecayLengthXYCharm, + hf_cand_par_charm::DecayLengthNormalisedCharm, + hf_cand_par_charm::DecayLengthXYNormalisedCharm, + hf_cand_par_charm::PxProng0Charm, // prong0 is the first D0 daughter + hf_cand_par_charm::PyProng0Charm, + hf_cand_par_charm::PzProng0Charm, + hf_cand_par_charm::PxProng1Charm, // prong 1 is the second D0 daughter + hf_cand_par_charm::PyProng1Charm, + hf_cand_par_charm::PzProng1Charm, + hf_cand_par_charm::InvMassCharm, + hf_cand_par_charm::ImpactParameter0Charm, + hf_cand_par_charm::ImpactParameter1Charm, + hf_cand_par_charm::ImpactParameterNormalised0Charm, + hf_cand_par_charm::ImpactParameterNormalised1Charm, + hf_cand_par_charm::NSigTpcPi0Charm, + hf_cand_par_charm::NSigTofPi0Charm, + hf_cand_par_charm::NSigTpcTofPi0Charm, + hf_cand_par_charm::NSigTpcKa0Charm, + hf_cand_par_charm::NSigTofKa0Charm, + hf_cand_par_charm::NSigTpcTofKa0Charm, + hf_cand_par_charm::NSigTpcPi1Charm, + hf_cand_par_charm::NSigTofPi1Charm, + hf_cand_par_charm::NSigTpcTofPi1Charm, + hf_cand_par_charm::NSigTpcKa1Charm, + hf_cand_par_charm::NSigTofKa1Charm, + hf_cand_par_charm::NSigTpcTofKa1Charm, o2::soa::Marker); -DECLARE_SOA_TABLE_STAGED(HfDstarMls, "HFDSTARML", //! Table with candidate selection ML scores +DECLARE_SOA_TABLE_STAGED(HfDstarMls, "HFDSTML", //! Table with candidate selection ML scores hf_cand_mc::MlScores, o2::soa::Marker); -DECLARE_SOA_TABLE_STAGED(HfDstarMcs, "HFDSTARMC", //! Table with MC candidate info +DECLARE_SOA_TABLE_STAGED(HfDstarMcs, "HFDSTMC", //! Table with MC candidate info hf_cand_mc::FlagMcMatchRec, hf_cand_mc::OriginMcRec, o2::soa::Marker); diff --git a/PWGHF/TableProducer/derivedDataCreatorDstarToD0Pi.cxx b/PWGHF/TableProducer/derivedDataCreatorDstarToD0Pi.cxx index 5a0d0b92915..a11c0d94a71 100644 --- a/PWGHF/TableProducer/derivedDataCreatorDstarToD0Pi.cxx +++ b/PWGHF/TableProducer/derivedDataCreatorDstarToD0Pi.cxx @@ -65,6 +65,7 @@ struct HfDerivedDataCreatorDstarToD0Pi { rowsCommon; // Candidates Produces rowCandidatePar; + Produces rowCandidateParD0; Produces rowCandidateSel; Produces rowCandidateMl; Produces rowCandidateId; @@ -73,6 +74,7 @@ struct HfDerivedDataCreatorDstarToD0Pi { // Switches for filling tables HfConfigurableDerivedData confDerData; Configurable fillCandidatePar{"fillCandidatePar", true, "Fill candidate parameters"}; + Configurable fillCandidateParD0{"fillCandidateParD0", true, "Fill charm daughter parameters"}; Configurable fillCandidateSel{"fillCandidateSel", true, "Fill candidate selection flags"}; Configurable fillCandidateMl{"fillCandidateMl", true, "Fill candidate selection ML scores"}; Configurable fillCandidateId{"fillCandidateId", true, "Fill original indices from the candidate table"}; @@ -130,6 +132,21 @@ struct HfDerivedDataCreatorDstarToD0Pi { rowsCommon.fillTablesCandidate(candidate, invMass, y); if (fillCandidatePar) { rowCandidatePar( + candidate.pxD0(), + candidate.pyD0(), + candidate.pzD0(), + candidate.pxSoftPi(), + candidate.pySoftPi(), + candidate.pzSoftPi(), + candidate.signSoftPi(), + candidate.impParamSoftPi(), + candidate.normalisedImpParamSoftPi(), + prongSoftPi.tpcNSigmaPi(), + prongSoftPi.tofNSigmaPi(), + prongSoftPi.tpcTofNSigmaPi()); + } + if (fillCandidateParD0) { + rowCandidateParD0( candidate.chi2PCAD0(), candidate.cpaD0(), candidate.cpaXYD0(), @@ -143,29 +160,23 @@ struct HfDerivedDataCreatorDstarToD0Pi { candidate.pxProng1(), candidate.pyProng1(), candidate.pzProng1(), - candidate.pxD0(), - candidate.pyD0(), - candidate.pzD0(), - candidate.pxSoftPi(), - candidate.pySoftPi(), - candidate.pzSoftPi(), - candidate.signSoftPi(), candidate.invMassD0(), candidate.impactParameter0(), candidate.impactParameter1(), - candidate.impParamSoftPi(), candidate.impactParameterNormalised0(), candidate.impactParameterNormalised1(), - candidate.normalisedImpParamSoftPi(), prong0.tpcNSigmaPi(), prong0.tofNSigmaPi(), prong0.tpcTofNSigmaPi(), + prong0.tpcNSigmaKa(), + prong0.tofNSigmaKa(), + prong0.tpcTofNSigmaKa(), + prong1.tpcNSigmaPi(), + prong1.tofNSigmaPi(), + prong1.tpcTofNSigmaPi(), prong1.tpcNSigmaKa(), prong1.tofNSigmaKa(), - prong1.tpcTofNSigmaKa(), - prongSoftPi.tpcNSigmaPi(), - prongSoftPi.tofNSigmaPi(), - prongSoftPi.tpcTofNSigmaPi()); + prong1.tpcTofNSigmaKa()); } if (fillCandidateSel) { rowCandidateSel( @@ -224,6 +235,7 @@ struct HfDerivedDataCreatorDstarToD0Pi { // Fill candidate properties rowsCommon.reserveTablesCandidates(sizeTableCand); reserveTable(rowCandidatePar, fillCandidatePar, sizeTableCand); + reserveTable(rowCandidateParD0, fillCandidateParD0, sizeTableCand); reserveTable(rowCandidateSel, fillCandidateSel, sizeTableCand); reserveTable(rowCandidateMl, fillCandidateMl, sizeTableCand); reserveTable(rowCandidateId, fillCandidateId, sizeTableCand); diff --git a/PWGJE/Core/JetCandidateUtilities.h b/PWGJE/Core/JetCandidateUtilities.h index e1bbdd18819..921b88af9b8 100644 --- a/PWGJE/Core/JetCandidateUtilities.h +++ b/PWGJE/Core/JetCandidateUtilities.h @@ -205,11 +205,11 @@ auto matchedParticle(const T& candidate, const U& tracks, const V& particles) * @param candidate candidate that is being checked * @param table the table to be sliced */ -template -auto slicedPerCandidate(T const& table, U const& candidate, V const& perD0Candidate, M const& perDplusCandidate, N const& perLcCandidate, O const& perBplusCandidate, P const& perDielectronCandidate) +template +auto slicedPerCandidate(T const& table, U const& candidate, V const& perD0Candidate, M const& perDplusCandidate, N const& perDstarCandidate, O const& perLcCandidate, P const& perB0Candidate, Q const& perBplusCandidate, R const& perDielectronCandidate) { if constexpr (jethfutilities::isHFCandidate()) { - return jethfutilities::slicedPerHFCandidate(table, candidate, perD0Candidate, perDplusCandidate, perLcCandidate, perBplusCandidate); + return jethfutilities::slicedPerHFCandidate(table, candidate, perD0Candidate, perDplusCandidate, perDstarCandidate, perLcCandidate, perB0Candidate, perBplusCandidate); } else if constexpr (jetdqutilities::isDielectronCandidate()) { return jetdqutilities::slicedPerDielectronCandidate(table, candidate, perDielectronCandidate); } else { @@ -223,11 +223,11 @@ auto slicedPerCandidate(T const& table, U const& candidate, V const& perD0Candid * @param jet jet that the slice is based on * @param table the table to be sliced */ -template -auto slicedPerJet(T const& table, U const& jet, V const& perD0Jet, M const& perDplusJet, N const& perLcJet, O const& perBplusJet, P const& perDielectronJet) +template +auto slicedPerJet(T const& table, U const& jet, V const& perD0Jet, M const& perDplusJet, N const& perDstarJet, O const& perLcJet, P const& perB0Jet, Q const& perBplusJet, R const& perDielectronJet) { if constexpr (jethfutilities::isHFTable() || jethfutilities::isHFMcTable()) { - return jethfutilities::slicedPerHFJet(table, jet, perD0Jet, perDplusJet, perLcJet, perBplusJet); + return jethfutilities::slicedPerHFJet(table, jet, perD0Jet, perDplusJet, perDstarJet, perLcJet, perB0Jet, perBplusJet); } else if constexpr (jetdqutilities::isDielectronTable() || jetdqutilities::isDielectronMcTable()) { return jetdqutilities::slicedPerDielectronJet(table, jet, perDielectronJet); } else { diff --git a/PWGJE/Core/JetHFUtilities.h b/PWGJE/Core/JetHFUtilities.h index f8c95507757..7c70b3dff4a 100644 --- a/PWGJE/Core/JetHFUtilities.h +++ b/PWGJE/Core/JetHFUtilities.h @@ -105,6 +105,42 @@ constexpr bool isDplusMcTable() return isDplusMcCandidate() || isDplusMcCandidate(); } +/** + * returns true if the candidate is from a D* table + */ +template +constexpr bool isDstarCandidate() +{ + return std::is_same_v, o2::aod::CandidatesDstarData::iterator> || std::is_same_v, o2::aod::CandidatesDstarData::filtered_iterator> || std::is_same_v, o2::aod::CandidatesDstarMCD::iterator> || std::is_same_v, o2::aod::CandidatesDstarMCD::filtered_iterator>; +} + +/** + * returns true if the particle is from a D* MC table + */ +template +constexpr bool isDstarMcCandidate() +{ + return std::is_same_v, o2::aod::CandidatesDstarMCP::iterator> || std::is_same_v, o2::aod::CandidatesDstarMCP::filtered_iterator>; +} + +/** + * returns true if the table is a D* table + */ +template +constexpr bool isDstarTable() +{ + return isDstarCandidate() || isDstarCandidate(); +} + +/** + * returns true if the table is a D* MC table + */ +template +constexpr bool isDstarMcTable() +{ + return isDstarMcCandidate() || isDstarMcCandidate(); +} + /** * returns true if the candidate is from a Lc table */ @@ -141,6 +177,42 @@ constexpr bool isLcMcTable() return isLcMcCandidate() || isLcMcCandidate(); } +/** + * returns true if the candidate is from a B0 table + */ +template +constexpr bool isB0Candidate() +{ + return std::is_same_v, o2::aod::CandidatesB0Data::iterator> || std::is_same_v, o2::aod::CandidatesB0Data::filtered_iterator> || std::is_same_v, o2::aod::CandidatesB0MCD::iterator> || std::is_same_v, o2::aod::CandidatesB0MCD::filtered_iterator>; +} + +/** + * returns true if the particle is from a B0 MC table + */ +template +constexpr bool isB0McCandidate() +{ + return std::is_same_v, o2::aod::CandidatesB0MCP::iterator> || std::is_same_v, o2::aod::CandidatesB0MCP::filtered_iterator>; +} + +/** + * returns true if the table is a B0 table + */ +template +constexpr bool isB0Table() +{ + return isB0Candidate() || isB0Candidate(); +} + +/** + * returns true if the table is a B0 MC table + */ +template +constexpr bool isB0McTable() +{ + return isB0McCandidate() || isB0McCandidate(); +} + /** * returns true if the candidate is from a Bplus table */ @@ -188,8 +260,12 @@ constexpr bool isHFCandidate() return true; } else if constexpr (isDplusCandidate()) { return true; + } else if constexpr (isDstarCandidate()) { + return true; } else if constexpr (isLcCandidate()) { return true; + } else if constexpr (isB0Candidate()) { + return true; } else if constexpr (isBplusCandidate()) { return true; } else { @@ -208,8 +284,12 @@ constexpr bool isHFMcCandidate() return true; } else if constexpr (isDplusMcCandidate()) { return true; + } else if constexpr (isDstarMcCandidate()) { + return true; } else if constexpr (isLcMcCandidate()) { return true; + } else if constexpr (isB0McCandidate()) { + return true; } else if constexpr (isBplusMcCandidate()) { return true; } else { @@ -227,8 +307,12 @@ constexpr bool isHFTable() return true; } else if constexpr (isDplusCandidate() || isDplusCandidate()) { return true; + } else if constexpr (isDstarCandidate() || isDstarCandidate()) { + return true; } else if constexpr (isLcCandidate() || isLcCandidate()) { return true; + } else if constexpr (isB0Candidate() || isB0Candidate()) { + return true; } else if constexpr (isBplusCandidate() || isBplusCandidate()) { return true; } else { @@ -246,8 +330,12 @@ constexpr bool isHFMcTable() return true; } else if constexpr (isDplusMcCandidate() || isDplusMcCandidate()) { return true; + } else if constexpr (isDstarMcCandidate() || isDstarMcCandidate()) { + return true; } else if constexpr (isLcMcCandidate() || isLcMcCandidate()) { return true; + } else if constexpr (isB0McCandidate() || isB0McCandidate()) { + return true; } else if constexpr (isBplusMcCandidate() || isBplusMcCandidate()) { return true; } else { @@ -274,12 +362,24 @@ constexpr bool isMatchedHFCandidate(T const& candidate) } else { return false; } + } else if constexpr (isDstarCandidate()) { + if (std::abs(candidate.flagMcMatchRec()) == o2::hf_decay::hf_cand_dstar::DecayChannelMain::DstarToPiKPi) { + return true; + } else { + return false; + } } else if constexpr (isLcCandidate()) { if (std::abs(candidate.flagMcMatchRec()) == o2::hf_decay::hf_cand_3prong::DecayChannelMain::LcToPKPi) { return true; } else { return false; } + } else if constexpr (isB0Candidate()) { + if (std::abs(candidate.flagMcMatchRec()) == 1 << o2::aod::hf_cand_b0::DecayType::B0ToDPi) { + return true; + } else { + return false; + } } else if constexpr (isBplusCandidate()) { if (std::abs(candidate.flagMcMatchRec()) == 1 << o2::aod::hf_cand_bplus::DecayType::BplusToD0Pi) { return true; @@ -298,12 +398,24 @@ constexpr bool isMatchedHFCandidate(T const& candidate) } else { return false; } + } else if constexpr (isDstarMcCandidate()) { + if (std::abs(candidate.flagMcMatchGen()) == o2::hf_decay::hf_cand_dstar::DecayChannelMain::DstarToPiKPi) { + return true; + } else { + return false; + } } else if constexpr (isLcMcCandidate()) { if (std::abs(candidate.flagMcMatchGen()) == o2::hf_decay::hf_cand_3prong::DecayChannelMain::LcToPKPi) { return true; } else { return false; } + } else if constexpr (isB0McCandidate()) { + if (std::abs(candidate.flagMcMatchGen()) == 1 << o2::aod::hf_cand_b0::DecayType::B0ToDPi) { + return true; + } else { + return false; + } } else if constexpr (isBplusMcCandidate()) { if (std::abs(candidate.flagMcMatchGen()) == 1 << o2::aod::hf_cand_bplus::DecayType::BplusToD0Pi) { return true; @@ -337,12 +449,24 @@ bool isHFDaughterTrack(T& track, U& candidate, V const& /*tracks*/) } else { return false; } + } else if constexpr (isDstarCandidate()) { + if (candidate.prong0Id() == track.globalIndex() || candidate.prong1Id() == track.globalIndex() || candidate.prong2Id() == track.globalIndex()) { + return true; + } else { + return false; + } } else if constexpr (isLcCandidate()) { if (candidate.prong0Id() == track.globalIndex() || candidate.prong1Id() == track.globalIndex() || candidate.prong2Id() == track.globalIndex()) { return true; } else { return false; } + } else if constexpr (isB0Candidate()) { + if (candidate.prong0Id() == track.globalIndex() || candidate.prong1Id() == track.globalIndex() || candidate.prong2Id() == track.globalIndex() || candidate.prong3Id() == track.globalIndex()) { + return true; + } else { + return false; + } } else if constexpr (isBplusCandidate()) { if (candidate.prong0Id() == track.globalIndex() || candidate.prong1Id() == track.globalIndex() || candidate.prong2Id() == track.globalIndex()) { return true; @@ -388,15 +512,19 @@ auto matchedHFParticle(const T& candidate, const U& /*tracks*/, const V& /*parti * @param candidate HF candidate that is being checked * @param table the table to be sliced */ -template -auto slicedPerHFCandidate(T const& table, U const& candidate, V const& perD0Candidate, M const& perDplusCandidate, N const& perLcCandidate, O const& perBplusCandidate) +template +auto slicedPerHFCandidate(T const& table, U const& candidate, V const& perD0Candidate, M const& perDplusCandidate, N const& perDstarCandidate, O const& perLcCandidate, P const& perB0Candidate, Q const& perBplusCandidate) { if constexpr (isD0Candidate()) { return table.sliceBy(perD0Candidate, candidate.globalIndex()); } else if constexpr (isDplusCandidate()) { return table.sliceBy(perDplusCandidate, candidate.globalIndex()); + } else if constexpr (isDstarCandidate()) { + return table.sliceBy(perDstarCandidate, candidate.globalIndex()); } else if constexpr (isLcCandidate()) { return table.sliceBy(perLcCandidate, candidate.globalIndex()); + } else if constexpr (isB0Candidate()) { + return table.sliceBy(perB0Candidate, candidate.globalIndex()); } else if constexpr (isBplusCandidate()) { return table.sliceBy(perBplusCandidate, candidate.globalIndex()); } else { @@ -411,15 +539,19 @@ auto slicedPerHFCandidate(T const& table, U const& candidate, V const& perD0Cand * @param jet jet that is being sliced based on * @param table the table to be sliced */ -template -auto slicedPerHFJet(T const& table, U const& jet, V const& perD0Jet, M const& perDplusJet, N const& perLcJet, O const& perBplusJet) +template +auto slicedPerHFJet(T const& table, U const& jet, V const& perD0Jet, M const& perDplusJet, N const& perDstarJet, O const& perLcJet, P const& perB0Jet, Q const& perBplusJet) { if constexpr (isD0Table() || isD0McTable()) { return table.sliceBy(perD0Jet, jet.globalIndex()); } else if constexpr (isDplusTable() || isDplusMcTable()) { return table.sliceBy(perDplusJet, jet.globalIndex()); + } else if constexpr (isDstarTable() || isDstarMcTable()) { + return table.sliceBy(perDstarJet, jet.globalIndex()); } else if constexpr (isLcTable() || isLcMcTable()) { return table.sliceBy(perLcJet, jet.globalIndex()); + } else if constexpr (isB0Table() || isB0McTable()) { + return table.sliceBy(perB0Jet, jet.globalIndex()); } else if constexpr (isBplusTable() || isBplusMcTable()) { return table.sliceBy(perBplusJet, jet.globalIndex()); } else { @@ -461,8 +593,12 @@ int getHFCandidatePDG(T const& /*candidate*/) return static_cast(o2::constants::physics::Pdg::kD0); } else if constexpr (isDplusCandidate() || isDplusMcCandidate()) { return static_cast(o2::constants::physics::Pdg::kDPlus); + } else if constexpr (isDstarCandidate() || isDstarMcCandidate()) { + return static_cast(o2::constants::physics::Pdg::kDStar); } else if constexpr (isLcCandidate() || isLcMcCandidate()) { return static_cast(o2::constants::physics::Pdg::kLambdaCPlus); + } else if constexpr (isB0Candidate() || isB0McCandidate()) { + return static_cast(o2::constants::physics::Pdg::kB0); } else if constexpr (isBplusCandidate() || isBplusMcCandidate()) { return static_cast(o2::constants::physics::Pdg::kBPlus); } else { @@ -480,8 +616,12 @@ int getHFTablePDG() return static_cast(o2::constants::physics::Pdg::kD0); } else if constexpr (isDplusTable() || isDplusMcTable()) { return static_cast(o2::constants::physics::Pdg::kDPlus); + } else if constexpr (isDstarTable() || isDstarMcTable()) { + return static_cast(o2::constants::physics::Pdg::kDStar); } else if constexpr (isLcTable() || isLcMcTable()) { return static_cast(o2::constants::physics::Pdg::kLambdaCPlus); + } else if constexpr (isB0Table() || isB0McTable()) { + return static_cast(o2::constants::physics::Pdg::kB0); } else if constexpr (isBplusTable() || isBplusMcTable()) { return static_cast(o2::constants::physics::Pdg::kBPlus); } else { @@ -501,8 +641,12 @@ float getHFCandidatePDGMass(T const& /*candidate*/) return static_cast(o2::constants::physics::MassD0); } else if constexpr (isDplusCandidate() || isDplusMcCandidate()) { return static_cast(o2::constants::physics::MassDPlus); + } else if constexpr (isDstarCandidate() || isDstarMcCandidate()) { + return static_cast(o2::constants::physics::MassDStar); } else if constexpr (isLcCandidate() || isLcMcCandidate()) { return static_cast(o2::constants::physics::MassLambdaCPlus); + } else if constexpr (isB0Candidate() || isB0McCandidate()) { + return static_cast(o2::constants::physics::MassB0); } else if constexpr (isBplusCandidate() || isBplusMcCandidate()) { return static_cast(o2::constants::physics::MassBPlus); } else { @@ -521,8 +665,12 @@ float getHFTablePDGMass() return static_cast(o2::constants::physics::MassD0); } else if constexpr (isDplusTable() || isDplusMcTable()) { return static_cast(o2::constants::physics::MassDPlus); + } else if constexpr (isDstarTable() || isDstarMcTable()) { + return static_cast(o2::constants::physics::MassDStar); } else if constexpr (isLcTable() || isLcMcTable()) { return static_cast(o2::constants::physics::MassLambdaCPlus); + } else if constexpr (isB0Table() || isB0McTable()) { + return static_cast(o2::constants::physics::MassB0); } else if constexpr (isBplusTable() || isBplusMcTable()) { return static_cast(o2::constants::physics::MassBPlus); } else { @@ -682,6 +830,66 @@ void fillDplusCandidateTable(T const& candidate, U& DplusParTable, V& DplusParET } } +template +void fillDstarCandidateTable(T const& candidate, U& DstarParTable, V& DstarParDaughterTable, M& DstarMlTable, N& DstarMCDTable) +{ + + DstarParTable( + candidate.pxProng0(), + candidate.pyProng0(), + candidate.pzProng0(), + candidate.pxProng1(), + candidate.pyProng1(), + candidate.pzProng1(), + candidate.signProng1(), + candidate.impactParameter1(), + candidate.impactParameterNormalised1(), + candidate.nSigTpcPi1(), + candidate.nSigTofPi1(), + candidate.nSigTpcTofPi1()); + + DstarParDaughterTable( + candidate.chi2PCACharm(), + candidate.cpaCharm(), + candidate.cpaXYCharm(), + candidate.decayLengthCharm(), + candidate.decayLengthXYCharm(), + candidate.decayLengthNormalisedCharm(), + candidate.decayLengthXYNormalisedCharm(), + candidate.pxProng0Charm(), + candidate.pyProng0Charm(), + candidate.pzProng0Charm(), + candidate.pxProng1Charm(), + candidate.pyProng1Charm(), + candidate.pzProng1Charm(), + candidate.invMassCharm(), + candidate.impactParameter0Charm(), + candidate.impactParameter1Charm(), + candidate.impactParameterNormalised0Charm(), + candidate.impactParameterNormalised1Charm(), + candidate.nSigTpcPi0Charm(), + candidate.nSigTofPi0Charm(), + candidate.nSigTpcTofPi0Charm(), + candidate.nSigTpcKa0Charm(), + candidate.nSigTofKa0Charm(), + candidate.nSigTpcTofKa0Charm(), + candidate.nSigTpcPi1Charm(), + candidate.nSigTofPi1Charm(), + candidate.nSigTpcTofPi1Charm(), + candidate.nSigTpcKa1Charm(), + candidate.nSigTofKa1Charm(), + candidate.nSigTpcTofKa1Charm()); + + std::vector mlScoresVector; + auto mlScoresSpan = candidate.mlScores(); + std::copy(mlScoresSpan.begin(), mlScoresSpan.end(), std::back_inserter(mlScoresVector)); + DstarMlTable(mlScoresVector); + + if constexpr (isMc) { + DstarMCDTable(candidate.flagMcMatchRec(), candidate.originMcRec()); + } +} + template void fillLcCandidateTable(T const& candidate, U& LcParTable, V& LcParETable, M& LcMlTable, N& LcMCDTable) { @@ -754,6 +962,91 @@ void fillLcCandidateTable(T const& candidate, U& LcParTable, V& LcParETable, M& } } +// need to update this +template +void fillB0CandidateTable(T const& candidate, U& B0ParTable, V& B0ParETable, M& B0ParD0Table, N& B0MlTable, O& B0MlD0Table, P& B0MCDTable) +{ + + B0ParTable( + candidate.chi2PCA(), + candidate.cpa(), + candidate.cpaXY(), + candidate.decayLength(), + candidate.decayLengthXY(), + candidate.decayLengthNormalised(), + candidate.decayLengthXYNormalised(), + candidate.ptProng0(), + candidate.ptProng1(), + candidate.impactParameter0(), + candidate.impactParameter1(), + candidate.impactParameterNormalised0(), + candidate.impactParameterNormalised1(), + candidate.nSigTpcPiExpPi(), + candidate.nSigTofPiExpPi(), + candidate.nSigTpcTofPiExpPi(), + candidate.nSigTpcKaExpPi(), + candidate.nSigTofKaExpPi(), + candidate.nSigTpcTofKaExpPi(), + candidate.maxNormalisedDeltaIP(), + candidate.impactParameterProduct()); + + B0ParETable( + candidate.xSecondaryVertex(), + candidate.ySecondaryVertex(), + candidate.zSecondaryVertex(), + candidate.errorDecayLength(), + candidate.errorDecayLengthXY(), + candidate.rSecondaryVertex(), + candidate.pProng1(), + candidate.pxProng1(), + candidate.pyProng1(), + candidate.pzProng1(), + candidate.errorImpactParameter1(), + candidate.cosThetaStar(), + candidate.ct()); + + B0ParD0Table( + candidate.chi2PCACharm(), + candidate.nProngsContributorsPVCharm(), + candidate.cpaCharm(), + candidate.cpaXYCharm(), + candidate.decayLengthCharm(), + candidate.decayLengthXYCharm(), + candidate.decayLengthNormalisedCharm(), + candidate.decayLengthXYNormalisedCharm(), + candidate.ptProng0Charm(), + candidate.ptProng1Charm(), + candidate.ptProng2Charm(), + candidate.impactParameter0Charm(), + candidate.impactParameter1Charm(), + candidate.impactParameter2Charm(), + candidate.impactParameterNormalised0Charm(), + candidate.impactParameterNormalised1Charm(), + candidate.impactParameterNormalised2Charm(), + candidate.nSigTpcPi0Charm(), + candidate.nSigTofPi0Charm(), + candidate.nSigTpcTofPi0Charm(), + candidate.nSigTpcKa1Charm(), + candidate.nSigTofKa1Charm(), + candidate.nSigTpcTofKa1Charm(), + candidate.nSigTpcPi2Charm(), + candidate.nSigTofPi2Charm(), + candidate.nSigTpcTofPi2Charm()); + + // B0SelectionFlagTable(candidate.candidateSelFlag()); + + B0MlTable(candidate.mlScoreSig()); + + std::vector mlScoresCharmVector; + auto mlScoresCharmSpan = candidate.mlScoresCharm(); + std::copy(mlScoresCharmSpan.begin(), mlScoresCharmSpan.end(), std::back_inserter(mlScoresCharmVector)); + B0MlD0Table(mlScoresCharmVector); + + if constexpr (isMc) { + B0MCDTable(candidate.flagMcMatchRec(), candidate.originMcRec()); + } +} + // need to update this template void fillBplusCandidateTable(T const& candidate, U& BplusParTable, V& BplusParETable, M& BplusParD0Table, N& BplusMlTable, O& BplusMlD0Table, P& BplusMCDTable) @@ -842,9 +1135,15 @@ void fillHFCandidateTable(T const& candidate, int32_t collisionIndex, U& HFBaseT if constexpr (isDplusCandidate()) { fillDplusCandidateTable(candidate, HFParTable, HFParETable, HFMlTable, HFMCDTable); } + if constexpr (isDstarCandidate()) { + fillDstarCandidateTable(candidate, HFParTable, HFParDaughterTable, HFMlTable, HFMCDTable); + } if constexpr (isLcCandidate()) { fillLcCandidateTable(candidate, HFParTable, HFParETable, HFMlTable, HFMCDTable); } + if constexpr (isB0Candidate()) { + fillB0CandidateTable(candidate, HFParTable, HFParETable, HFParDaughterTable, HFMlTable, HFMlDaughterTable, HFMCDTable); + } if constexpr (isBplusCandidate()) { fillBplusCandidateTable(candidate, HFParTable, HFParETable, HFParDaughterTable, HFMlTable, HFMlDaughterTable, HFMCDTable); } diff --git a/PWGJE/DataModel/Jet.h b/PWGJE/DataModel/Jet.h index 0fbee0ca438..52939d0b16c 100644 --- a/PWGJE/DataModel/Jet.h +++ b/PWGJE/DataModel/Jet.h @@ -181,7 +181,9 @@ DECLARE_JET_TABLES_LEVELS(Full, JTrackSub, HfD0Bases, HfD0PBases, "F"); DECLARE_JET_TABLES_LEVELS(Neutral, JTrackSub, HfD0Bases, HfD0PBases, "N"); DECLARE_JET_TABLES_LEVELS(D0Charged, JTrackD0Sub, HfD0Bases, HfD0PBases, "D0"); DECLARE_JET_TABLES_LEVELS(DplusCharged, JTrackDplusSub, HfDplusBases, HfDplusPBases, "DP"); +DECLARE_JET_TABLES_LEVELS(DstarCharged, JTrackDstarSub, HfDstarBases, HfDstarPBases, "DST"); DECLARE_JET_TABLES_LEVELS(LcCharged, JTrackLcSub, HfLcBases, HfLcPBases, "Lc"); +DECLARE_JET_TABLES_LEVELS(B0Charged, JTrackB0Sub, HfB0Bases, HfB0PBases, "B0"); DECLARE_JET_TABLES_LEVELS(BplusCharged, JTrackBplusSub, HfBplusBases, HfBplusPBases, "BP"); DECLARE_JET_TABLES_LEVELS(V0Charged, JTrackSub, V0Cores, JV0Mcs, "V0"); DECLARE_JET_TABLES_LEVELS(DielectronCharged, JTrackSub, Dielectrons, JDielectronMcs, "DIEL"); @@ -229,6 +231,14 @@ using JetParticlesSubDplus = JMcParticleDplusSubs; using McCollisionsDplus = o2::soa::Join; using CandidatesDplusMCP = o2::soa::Join; +using CollisionsDstar = o2::soa::Join; +using CandidatesDstarData = o2::soa::Join; +using CandidatesDstarMCD = o2::soa::Join; +using JetTracksSubDstar = JTrackDstarSubs; +using JetParticlesSubDstar = JMcParticleDstarSubs; +using McCollisionsDstar = o2::soa::Join; +using CandidatesDstarMCP = o2::soa::Join; + using CollisionsLc = o2::soa::Join; using CandidatesLcData = o2::soa::Join; using CandidatesLcMCD = o2::soa::Join; @@ -237,6 +247,14 @@ using JetParticlesSubLc = JMcParticleLcSubs; using McCollisionsLc = o2::soa::Join; using CandidatesLcMCP = o2::soa::Join; +using CollisionsB0 = o2::soa::Join; +using CandidatesB0Data = o2::soa::Join; +using CandidatesB0MCD = o2::soa::Join; +using JetTracksSubB0 = JTrackB0Subs; +using JetParticlesSubB0 = JMcParticleB0Subs; +using McCollisionsB0 = o2::soa::Join; +using CandidatesB0MCP = o2::soa::Join; + using CollisionsBplus = o2::soa::Join; using CandidatesBplusData = o2::soa::Join; using CandidatesBplusMCD = o2::soa::Join; diff --git a/PWGJE/DataModel/JetReducedDataHF.h b/PWGJE/DataModel/JetReducedDataHF.h index 5e519b88f18..f295dbfa398 100644 --- a/PWGJE/DataModel/JetReducedDataHF.h +++ b/PWGJE/DataModel/JetReducedDataHF.h @@ -35,6 +35,8 @@ constexpr uint JMarkerDplus = 2; constexpr uint JMarkerLc = 3; constexpr uint JMarkerBplus = 4; constexpr uint JMarkerDielectron = 5; +constexpr uint JMarkerDstar = 6; +constexpr uint JMarkerB0 = 7; namespace jcandidateindices { @@ -120,6 +122,48 @@ DECLARE_SOA_TABLE(JDumDplusMlDaus, "AOD", "JDUMDPMLDAU", jdummydplus::DummyDplus, o2::soa::Marker<2>); +// might have to update!!!!!!!!!!!!!!!!!!!!!! + +namespace jdstarindices +{ +DECLARE_SOA_INDEX_COLUMN_FULL(Prong0, prong0, int, JTracks, "_0"); +DECLARE_SOA_INDEX_COLUMN_FULL(Prong1, prong1, int, JTracks, "_1"); +DECLARE_SOA_INDEX_COLUMN_FULL(Prong2, prong2, int, JTracks, "_2"); +} // namespace jdstarindices + +DECLARE_SOA_TABLE_STAGED(JDstarCollisionIds, "JDSTCOLLID", + jcandidateindices::JCollisionId, + o2::soa::Marker); + +DECLARE_SOA_TABLE_STAGED(JDstarMcCollisionIds, "JDSTMCCOLLID", + jcandidateindices::JMcCollisionId, + o2::soa::Marker); + +DECLARE_SOA_TABLE_STAGED(JDstarIds, "JDSTID", + jcandidateindices::JCollisionId, + jdstarindices::Prong0Id, + jdstarindices::Prong1Id, + jdstarindices::Prong2Id); + +DECLARE_SOA_TABLE_STAGED(JDstarPIds, "JDSTPID", + jcandidateindices::JMcCollisionId, + jcandidateindices::JMcParticleId, + o2::soa::Marker); + +namespace jdummydstar +{ + +DECLARE_SOA_COLUMN(DummyDstar, dummyDstar, bool); + +} // namespace jdummydstar +DECLARE_SOA_TABLE(JDumDstarParEs, "AOD", "JDUMDSTPARE", + jdummydstar::DummyDstar, + o2::soa::Marker<1>); + +DECLARE_SOA_TABLE(JDumDstarMlDaus, "AOD", "JDUMDSTMLDAU", + jdummydstar::DummyDstar, + o2::soa::Marker<2>); + namespace jlcindices { DECLARE_SOA_INDEX_COLUMN_FULL(Prong0, prong0, int, JTracks, "_0"); @@ -160,6 +204,34 @@ DECLARE_SOA_TABLE(JDumLcMlDaus, "AOD", "JDUMLCMLDAU", jdummylc::DummyLc, o2::soa::Marker<2>); +namespace jb0indices +{ +DECLARE_SOA_INDEX_COLUMN_FULL(Prong0, prong0, int, JTracks, "_0"); +DECLARE_SOA_INDEX_COLUMN_FULL(Prong1, prong1, int, JTracks, "_1"); +DECLARE_SOA_INDEX_COLUMN_FULL(Prong2, prong2, int, JTracks, "_2"); +DECLARE_SOA_INDEX_COLUMN_FULL(Prong3, prong3, int, JTracks, "_3"); +} // namespace jb0indices + +DECLARE_SOA_TABLE_STAGED(JB0CollisionIds, "JB0COLLID", + jcandidateindices::JCollisionId, + o2::soa::Marker); + +DECLARE_SOA_TABLE_STAGED(JB0McCollisionIds, "JB0MCCOLLID", + jcandidateindices::JMcCollisionId, + o2::soa::Marker); + +DECLARE_SOA_TABLE_STAGED(JB0Ids, "JB0ID", + jcandidateindices::JCollisionId, + jb0indices::Prong0Id, + jb0indices::Prong1Id, + jb0indices::Prong2Id, + jb0indices::Prong3Id); + +DECLARE_SOA_TABLE_STAGED(JB0PIds, "JB0PID", + jcandidateindices::JMcCollisionId, + jcandidateindices::JMcParticleId, + o2::soa::Marker); + namespace jbplusindices { DECLARE_SOA_INDEX_COLUMN_FULL(Prong0, prong0, int, JTracks, "_0"); diff --git a/PWGJE/DataModel/JetSubstructure.h b/PWGJE/DataModel/JetSubstructure.h index 97f51858553..88f0578d469 100644 --- a/PWGJE/DataModel/JetSubstructure.h +++ b/PWGJE/DataModel/JetSubstructure.h @@ -260,7 +260,9 @@ DECLARE_SOA_COLUMN(JetNConstituents, jetNConstituents, int); //! JETSUBSTRUCTURE_TABLES_DEF(C, "C", Charged, charged, JTracks, CJetCOs, "CJETCO", JTrackSubs, CEWSJetCOs, "CEWSJETCO", JTracks, CMCDJetCOs, "CMCDJETCO", JMcParticles, CMCPJetCOs, "CMCPJETCO"); JETSUBSTRUCTURE_TABLES_DEF(D0C, "D0C", D0Charged, d0charged, JTracks, HfD0Bases, "HFD0BASE", JTrackD0Subs, HfD0Bases, "HFD0BASE", JTracks, HfD0Bases, "HFD0BASE", JMcParticles, HfD0PBases, "HFD0PBASE"); JETSUBSTRUCTURE_TABLES_DEF(DplusC, "DPC", DplusCharged, dpluscharged, JTracks, HfDplusBases, "HFDPBASE", JTrackDplusSubs, HfDplusBases, "HFDPBASE", JTracks, HfDplusBases, "HFDPBASE", JMcParticles, HfDplusPBases, "HFDPPBASE"); +JETSUBSTRUCTURE_TABLES_DEF(DstarC, "DSTC", DstarCharged, dstarcharged, JTracks, HfDstarBases, "HFDSTBASE", JTrackDstarSubs, HfDstarBases, "HFDSTBASE", JTracks, HfDstarBases, "HFDSTBASE", JMcParticles, HfDstarPBases, "HFDSTPBASE"); JETSUBSTRUCTURE_TABLES_DEF(LcC, "LCC", LcCharged, lccharged, JTracks, HfLcBases, "HFLCBASE", JTrackLcSubs, HfLcBases, "HFLCBASE", JTracks, HfLcBases, "HFLCBASE", JMcParticles, HfLcPBases, "HFLCPBASE"); +JETSUBSTRUCTURE_TABLES_DEF(B0C, "B0C", B0Charged, b0charged, JTracks, HfB0Bases, "HFB0BASE", JTrackB0Subs, HfB0Bases, "HFB0BASE", JTracks, HfB0Bases, "HFB0BASE", JMcParticles, HfB0PBases, "HFB0PBASE"); JETSUBSTRUCTURE_TABLES_DEF(BplusC, "BPC", BplusCharged, bpluscharged, JTracks, HfBplusBases, "HFBPBASE", JTrackBplusSubs, HfBplusBases, "HFBPBASE", JTracks, HfBplusBases, "HFBPBASE", JMcParticles, HfBplusPBases, "HFBPPBASE"); JETSUBSTRUCTURE_TABLES_DEF(DielectronC, "DIELC", DielectronCharged, dielectroncharged, JTracks, Dielectrons, "RTDIELECTRON", JTrackDielectronSubs, Dielectrons, "RTDIELECTRON", JTracks, Dielectrons, "RTDIELECTRON", JMcParticles, JDielectronMcs, "JDIELMC"); diff --git a/PWGJE/DataModel/JetSubtraction.h b/PWGJE/DataModel/JetSubtraction.h index 45b22855325..d22237380c7 100644 --- a/PWGJE/DataModel/JetSubtraction.h +++ b/PWGJE/DataModel/JetSubtraction.h @@ -62,6 +62,16 @@ namespace bkgdplusmc DECLARE_SOA_INDEX_COLUMN_FULL(Candidate, candidate, int, HfDplusPBases, "_0"); } // namespace bkgdplusmc +namespace bkgdstar +{ +DECLARE_SOA_INDEX_COLUMN_FULL(Candidate, candidate, int, HfDstarBases, "_0"); +} // namespace bkgdstar + +namespace bkgdstarmc +{ +DECLARE_SOA_INDEX_COLUMN_FULL(Candidate, candidate, int, HfDstarPBases, "_0"); +} // namespace bkgdstarmc + namespace bkglc { DECLARE_SOA_INDEX_COLUMN_FULL(Candidate, candidate, int, HfLcBases, "_0"); @@ -72,6 +82,16 @@ namespace bkglcmc DECLARE_SOA_INDEX_COLUMN_FULL(Candidate, candidate, int, HfLcPBases, "_0"); } // namespace bkglcmc +namespace bkgb0 +{ +DECLARE_SOA_INDEX_COLUMN_FULL(Candidate, candidate, int, HfB0Bases, "_0"); +} // namespace bkgb0 + +namespace bkgb0mc +{ +DECLARE_SOA_INDEX_COLUMN_FULL(Candidate, candidate, int, HfB0PBases, "_0"); +} // namespace bkgb0mc + namespace bkgbplus { DECLARE_SOA_INDEX_COLUMN_FULL(Candidate, candidate, int, HfBplusBases, "_0"); @@ -127,41 +147,65 @@ DECLARE_SOA_TABLE(BkgDplusMcRhos, "AOD", "BkgDPMcRho", bkgrho::RhoM, o2::soa::Marker<5>); +DECLARE_SOA_TABLE(BkgDstarRhos, "AOD", "BkgDSTRho", + o2::soa::Index<>, + bkgrho::Rho, + bkgrho::RhoM, + o2::soa::Marker<6>); + +DECLARE_SOA_TABLE(BkgDstarMcRhos, "AOD", "BkgDSTMcRho", + o2::soa::Index<>, + bkgrho::Rho, + bkgrho::RhoM, + o2::soa::Marker<7>); + DECLARE_SOA_TABLE(BkgLcRhos, "AOD", "BkgLCRho", o2::soa::Index<>, bkgrho::Rho, bkgrho::RhoM, - o2::soa::Marker<4>); + o2::soa::Marker<8>); DECLARE_SOA_TABLE(BkgLcMcRhos, "AOD", "BkgLCMcRho", o2::soa::Index<>, bkgrho::Rho, bkgrho::RhoM, - o2::soa::Marker<5>); + o2::soa::Marker<9>); + +DECLARE_SOA_TABLE(BkgB0Rhos, "AOD", "BkgB0Rho", + o2::soa::Index<>, + bkgrho::Rho, + bkgrho::RhoM, + o2::soa::Marker<10>); + +DECLARE_SOA_TABLE(BkgB0McRhos, "AOD", "BkgB0McRho", + o2::soa::Index<>, + bkgrho::Rho, + bkgrho::RhoM, + o2::soa::Marker<11>); DECLARE_SOA_TABLE(BkgBplusRhos, "AOD", "BkgBPRho", o2::soa::Index<>, bkgrho::Rho, bkgrho::RhoM, - o2::soa::Marker<6>); + o2::soa::Marker<12>); DECLARE_SOA_TABLE(BkgBplusMcRhos, "AOD", "BkgBPMcRho", o2::soa::Index<>, bkgrho::Rho, bkgrho::RhoM, - o2::soa::Marker<7>); + o2::soa::Marker<13>); DECLARE_SOA_TABLE(BkgDielectronRhos, "AOD", "BkgDIELRho", o2::soa::Index<>, bkgrho::Rho, bkgrho::RhoM, - o2::soa::Marker<8>); + o2::soa::Marker<14>); DECLARE_SOA_TABLE(BkgDielectronMcRhos, "AOD", "BkgDIELMcRho", o2::soa::Index<>, bkgrho::Rho, bkgrho::RhoM, - o2::soa::Marker<9>); + o2::soa::Marker<15>); DECLARE_SOA_TABLE(JTrackSubs, "AOD", "JTrackSubs", o2::soa::Index<>, @@ -235,7 +279,7 @@ using JMcParticleD0Sub = JMcParticleD0Subs::iterator; DECLARE_SOA_TABLE(JTrackDplusSubs, "AOD", "JTrackDPSubs", o2::soa::Index<>, - bkglc::CandidateId, + bkgdplus::CandidateId, jtrack::Pt, jtrack::Eta, jtrack::Phi, @@ -250,7 +294,7 @@ using JTrackDplusSub = JTrackDplusSubs::iterator; DECLARE_SOA_TABLE(JMcParticleDplusSubs, "AOD", "JMcPartDPSubs", o2::soa::Index<>, - bkglcmc::CandidateId, + bkgdplusmc::CandidateId, jmcparticle::Pt, jmcparticle::Eta, jmcparticle::Phi, @@ -268,6 +312,41 @@ DECLARE_SOA_TABLE(JMcParticleDplusSubs, "AOD", "JMcPartDPSubs", using JMcParticleDplusSub = JMcParticleDplusSubs::iterator; +DECLARE_SOA_TABLE(JTrackDstarSubs, "AOD", "JTrackDSTSubs", + o2::soa::Index<>, + bkgdstar::CandidateId, + jtrack::Pt, + jtrack::Eta, + jtrack::Phi, + jtrack::TrackSel, + jtrack::Px, + jtrack::Py, + jtrack::Pz, + jtrack::P, + jtrack::Energy); + +using JTrackDstarSub = JTrackDstarSubs::iterator; + +DECLARE_SOA_TABLE(JMcParticleDstarSubs, "AOD", "JMcPartDSTSubs", + o2::soa::Index<>, + bkgdstarmc::CandidateId, + jmcparticle::Pt, + jmcparticle::Eta, + jmcparticle::Phi, + jmcparticle::Y, + jmcparticle::E, + jmcparticle::PdgCode, + jmcparticle::GenStatusCode, + jmcparticle::HepMCStatusCode, + jmcparticle::IsPhysicalPrimary, + jmcparticle::Px, + jmcparticle::Py, + jmcparticle::Pz, + jmcparticle::P, + jmcparticle::Energy); + +using JMcParticleDstarSub = JMcParticleDstarSubs::iterator; + DECLARE_SOA_TABLE(JTrackLcSubs, "AOD", "JTrackLCSubs", o2::soa::Index<>, bkglc::CandidateId, @@ -303,6 +382,41 @@ DECLARE_SOA_TABLE(JMcParticleLcSubs, "AOD", "JMcPartLCSubs", using JMcParticleLcSub = JMcParticleLcSubs::iterator; +DECLARE_SOA_TABLE(JTrackB0Subs, "AOD", "JTrackB0Subs", + o2::soa::Index<>, + bkgb0::CandidateId, + jtrack::Pt, + jtrack::Eta, + jtrack::Phi, + jtrack::TrackSel, + jtrack::Px, + jtrack::Py, + jtrack::Pz, + jtrack::P, + jtrack::Energy); + +using JTrackB0Sub = JTrackB0Subs::iterator; + +DECLARE_SOA_TABLE(JMcParticleB0Subs, "AOD", "JMcPartB0Subs", + o2::soa::Index<>, + bkgb0mc::CandidateId, + jmcparticle::Pt, + jmcparticle::Eta, + jmcparticle::Phi, + jmcparticle::Y, + jmcparticle::E, + jmcparticle::PdgCode, + jmcparticle::GenStatusCode, + jmcparticle::HepMCStatusCode, + jmcparticle::IsPhysicalPrimary, + jmcparticle::Px, + jmcparticle::Py, + jmcparticle::Pz, + jmcparticle::P, + jmcparticle::Energy); + +using JMcParticleB0Sub = JMcParticleB0Subs::iterator; + DECLARE_SOA_TABLE(JTrackBplusSubs, "AOD", "JTrackBPSubs", o2::soa::Index<>, bkgbplus::CandidateId, diff --git a/PWGJE/JetFinders/CMakeLists.txt b/PWGJE/JetFinders/CMakeLists.txt index a050f9d3fef..86052ffbe88 100644 --- a/PWGJE/JetFinders/CMakeLists.txt +++ b/PWGJE/JetFinders/CMakeLists.txt @@ -89,6 +89,21 @@ o2physics_add_dpl_workflow(jet-finder-dplus-mcp-charged PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(jet-finder-dstar-data-charged + SOURCES jetFinderDstarDataCharged.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport + COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(jet-finder-dstar-mcd-charged + SOURCES jetFinderDstarMCDCharged.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport + COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(jet-finder-dstar-mcp-charged + SOURCES jetFinderDstarMCPCharged.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-finder-lc-data-charged SOURCES jetFinderLcDataCharged.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport @@ -104,6 +119,21 @@ o2physics_add_dpl_workflow(jet-finder-lc-mcp-charged PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(jet-finder-b0-data-charged + SOURCES jetFinderB0DataCharged.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport + COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(jet-finder-b0-mcd-charged + SOURCES jetFinderB0MCDCharged.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport + COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(jet-finder-b0-mcp-charged + SOURCES jetFinderB0MCPCharged.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-finder-bplus-data-charged SOURCES jetFinderBplusDataCharged.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport diff --git a/PWGJE/JetFinders/jetFinderB0DataCharged.cxx b/PWGJE/JetFinders/jetFinderB0DataCharged.cxx new file mode 100644 index 00000000000..9288465c677 --- /dev/null +++ b/PWGJE/JetFinders/jetFinderB0DataCharged.cxx @@ -0,0 +1,38 @@ +// 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. + +// jet finder B0 data charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/JetFinders/jetFinderHF.cxx" + +#include "PWGJE/DataModel/Jet.h" + +#include +#include +#include +#include + +#include + +using JetFinderB0DataCharged = JetFinderHFTask; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + + tasks.emplace_back(adaptAnalysisTask(cfgc, + SetDefaultProcesses{{{"processChargedJetsData", true}}}, + TaskName{"jet-finder-b0-data-charged"})); + + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/JetFinders/jetFinderB0MCDCharged.cxx b/PWGJE/JetFinders/jetFinderB0MCDCharged.cxx new file mode 100644 index 00000000000..46de301e549 --- /dev/null +++ b/PWGJE/JetFinders/jetFinderB0MCDCharged.cxx @@ -0,0 +1,38 @@ +// 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. + +// jet finder B0 mcd charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/JetFinders/jetFinderHF.cxx" + +#include "PWGJE/DataModel/Jet.h" + +#include +#include +#include +#include + +#include + +using JetFinderB0MCDetectorLevelCharged = JetFinderHFTask; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + + tasks.emplace_back(adaptAnalysisTask(cfgc, + SetDefaultProcesses{{{"processChargedJetsMCD", true}}}, + TaskName{"jet-finder-b0-mcd-charged"})); + + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/JetFinders/jetFinderB0MCPCharged.cxx b/PWGJE/JetFinders/jetFinderB0MCPCharged.cxx new file mode 100644 index 00000000000..2966c817cef --- /dev/null +++ b/PWGJE/JetFinders/jetFinderB0MCPCharged.cxx @@ -0,0 +1,38 @@ +// 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. + +// jet finder B0 mcp charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/JetFinders/jetFinderHF.cxx" + +#include "PWGJE/DataModel/Jet.h" + +#include +#include +#include +#include + +#include + +using JetFinderB0MCParticleLevelCharged = JetFinderHFTask; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + + tasks.emplace_back(adaptAnalysisTask(cfgc, + SetDefaultProcesses{{{"processChargedJetsMCP", true}}}, + TaskName{"jet-finder-b0-mcp-charged"})); + + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/JetFinders/jetFinderDstarDataCharged.cxx b/PWGJE/JetFinders/jetFinderDstarDataCharged.cxx new file mode 100644 index 00000000000..0a1b6d104b3 --- /dev/null +++ b/PWGJE/JetFinders/jetFinderDstarDataCharged.cxx @@ -0,0 +1,38 @@ +// 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. + +// jet finder D* data charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/JetFinders/jetFinderHF.cxx" + +#include "PWGJE/DataModel/Jet.h" + +#include +#include +#include +#include + +#include + +using JetFinderDstarDataCharged = JetFinderHFTask; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + + tasks.emplace_back(adaptAnalysisTask(cfgc, + SetDefaultProcesses{{{"processChargedJetsData", true}}}, + TaskName{"jet-finder-dstar-data-charged"})); + + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/JetFinders/jetFinderDstarMCDCharged.cxx b/PWGJE/JetFinders/jetFinderDstarMCDCharged.cxx new file mode 100644 index 00000000000..42e9c2fb370 --- /dev/null +++ b/PWGJE/JetFinders/jetFinderDstarMCDCharged.cxx @@ -0,0 +1,38 @@ +// 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. + +// jet finder D+ mcd charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/JetFinders/jetFinderHF.cxx" + +#include "PWGJE/DataModel/Jet.h" + +#include +#include +#include +#include + +#include + +using JetFinderDstarMCDetectorLevelCharged = JetFinderHFTask; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + + tasks.emplace_back(adaptAnalysisTask(cfgc, + SetDefaultProcesses{{{"processChargedJetsMCD", true}}}, + TaskName{"jet-finder-dstar-mcd-charged"})); + + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/JetFinders/jetFinderDstarMCPCharged.cxx b/PWGJE/JetFinders/jetFinderDstarMCPCharged.cxx new file mode 100644 index 00000000000..36ce473fe3c --- /dev/null +++ b/PWGJE/JetFinders/jetFinderDstarMCPCharged.cxx @@ -0,0 +1,38 @@ +// 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. + +// jet finder D* mcp charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/JetFinders/jetFinderHF.cxx" + +#include "PWGJE/DataModel/Jet.h" + +#include +#include +#include +#include + +#include + +using JetFinderDstarMCParticleLevelCharged = JetFinderHFTask; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + + tasks.emplace_back(adaptAnalysisTask(cfgc, + SetDefaultProcesses{{{"processChargedJetsMCP", true}}}, + TaskName{"jet-finder-dstar-mcp-charged"})); + + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/JetFinders/jetFinderHF.cxx b/PWGJE/JetFinders/jetFinderHF.cxx index 66cb612075d..4314498a02a 100644 --- a/PWGJE/JetFinders/jetFinderHF.cxx +++ b/PWGJE/JetFinders/jetFinderHF.cxx @@ -179,8 +179,12 @@ struct JetFinderHFTask { PresliceOptional> perD0McCandidate = aod::bkgd0mc::candidateId; PresliceOptional> perDplusCandidate = aod::bkgdplus::candidateId; PresliceOptional> perDplusMcCandidate = aod::bkgdplusmc::candidateId; + PresliceOptional> perDstarCandidate = aod::bkgdstar::candidateId; + PresliceOptional> perDstarMcCandidate = aod::bkgdstarmc::candidateId; PresliceOptional> perLcCandidate = aod::bkglc::candidateId; PresliceOptional> perLcMcCandidate = aod::bkglcmc::candidateId; + PresliceOptional> perB0Candidate = aod::bkgb0::candidateId; + PresliceOptional> perB0McCandidate = aod::bkgb0mc::candidateId; PresliceOptional> perBplusCandidate = aod::bkgbplus::candidateId; PresliceOptional> perBplusMcCandidate = aod::bkgbplusmc::candidateId; PresliceOptional> perDielectronCandidate = aod::bkgdielectron::candidateId; @@ -250,7 +254,7 @@ struct JetFinderHFTask { void processChargedEvtWiseSubJetsData(soa::Filtered::iterator const& collision, soa::Filtered const& tracks, CandidateTableData const& candidates) { for (typename CandidateTableData::iterator const& candidate : candidates) { - analyseCharged(collision, jetcandidateutilities::slicedPerCandidate(tracks, candidate, perD0Candidate, perDplusCandidate, perLcCandidate, perBplusCandidate, perDielectronCandidate), candidate, jetsEvtWiseSubTable, constituentsEvtWiseSubTable, tracks, jetEWSPtMin, jetEWSPtMax); + analyseCharged(collision, jetcandidateutilities::slicedPerCandidate(tracks, candidate, perD0Candidate, perDplusCandidate, perDstarCandidate, perLcCandidate, perB0Candidate, perBplusCandidate, perDielectronCandidate), candidate, jetsEvtWiseSubTable, constituentsEvtWiseSubTable, tracks, jetEWSPtMin, jetEWSPtMax); } } PROCESS_SWITCH(JetFinderHFTask, processChargedEvtWiseSubJetsData, "charged hf jet finding on data with event-wise constituent subtraction", false); @@ -266,7 +270,7 @@ struct JetFinderHFTask { void processChargedEvtWiseSubJetsMCD(soa::Filtered::iterator const& collision, soa::Filtered const& tracks, CandidateTableMCD const& candidates) { for (typename CandidateTableMCD::iterator const& candidate : candidates) { - analyseCharged(collision, jetcandidateutilities::slicedPerCandidate(tracks, candidate, perD0Candidate, perDplusCandidate, perLcCandidate, perBplusCandidate, perDielectronCandidate), candidate, jetsEvtWiseSubTable, constituentsEvtWiseSubTable, tracks, jetEWSPtMin, jetEWSPtMax); + analyseCharged(collision, jetcandidateutilities::slicedPerCandidate(tracks, candidate, perD0Candidate, perDplusCandidate, perDstarCandidate, perLcCandidate, perB0Candidate, perBplusCandidate, perDielectronCandidate), candidate, jetsEvtWiseSubTable, constituentsEvtWiseSubTable, tracks, jetEWSPtMin, jetEWSPtMax); } } PROCESS_SWITCH(JetFinderHFTask, processChargedEvtWiseSubJetsMCD, "charged hf jet finding on MC detector level with event-wise constituent subtraction", false); @@ -286,7 +290,7 @@ struct JetFinderHFTask { CandidateTableMCP const& candidates) { for (typename CandidateTableMCP::iterator const& candidate : candidates) { - analyseMCP(collision, jetcandidateutilities::slicedPerCandidate(particles, candidate, perD0McCandidate, perDplusMcCandidate, perLcMcCandidate, perBplusMcCandidate, perDielectronMcCandidate), candidate, 1, jetPtMin, jetPtMax); + analyseMCP(collision, jetcandidateutilities::slicedPerCandidate(particles, candidate, perD0McCandidate, perDplusMcCandidate, perDstarMcCandidate, perLcMcCandidate, perB0McCandidate, perBplusMcCandidate, perDielectronMcCandidate), candidate, 1, jetPtMin, jetPtMax); } } PROCESS_SWITCH(JetFinderHFTask, processChargedEvtWiseSubJetsMCP, "hf jet finding on MC particle level", false); diff --git a/PWGJE/TableProducer/Matching/CMakeLists.txt b/PWGJE/TableProducer/Matching/CMakeLists.txt index beab5a4fdd6..e6526d90f1e 100644 --- a/PWGJE/TableProducer/Matching/CMakeLists.txt +++ b/PWGJE/TableProducer/Matching/CMakeLists.txt @@ -39,11 +39,21 @@ o2physics_add_dpl_workflow(jet-matching-mc-dplus-ch PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(jet-matching-mc-dstar-ch + SOURCES jetMatchingMCDstarCharged.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-matching-mc-lc-ch SOURCES jetMatchingMCLcCharged.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(jet-matching-mc-b0-ch + SOURCES jetMatchingMCB0Charged.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-matching-mc-bplus-ch SOURCES jetMatchingMCBplusCharged.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport @@ -74,11 +84,21 @@ o2physics_add_dpl_workflow(jet-matching-mc-sub-dplus-ch PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(jet-matching-mc-sub-dstar-ch + SOURCES jetMatchingMCSubDstarCharged.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-matching-mc-sub-lc-ch SOURCES jetMatchingMCSubLcCharged.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(jet-matching-mc-sub-b0-ch + SOURCES jetMatchingMCSubB0Charged.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-matching-mc-sub-bplus-ch SOURCES jetMatchingMCSubBplusCharged.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport @@ -104,6 +124,11 @@ o2physics_add_dpl_workflow(jet-matching-sub-dplus-ch PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(jet-matching-sub-dstar-ch + SOURCES jetMatchingSubDstarCharged.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-matching-sub-lc-ch SOURCES jetMatchingSubLcCharged.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport @@ -114,6 +139,11 @@ o2physics_add_dpl_workflow(jet-matching-sub-bplus-ch PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(jet-matching-sub-b0-ch + SOURCES jetMatchingSubB0Charged.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-matching-sub-dielectron-ch SOURCES jetMatchingSubDielectronCharged.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport diff --git a/PWGJE/TableProducer/Matching/Substructure/CMakeLists.txt b/PWGJE/TableProducer/Matching/Substructure/CMakeLists.txt index c507c8995ef..e004a0a52ee 100644 --- a/PWGJE/TableProducer/Matching/Substructure/CMakeLists.txt +++ b/PWGJE/TableProducer/Matching/Substructure/CMakeLists.txt @@ -27,11 +27,21 @@ o2physics_add_dpl_workflow(jet-substructure-matching-mc-dplus-ch PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(jet-substructure-matching-mc-dstar-ch + SOURCES jetSubstructureMatchingMCDstarCharged.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-substructure-matching-mc-lc-ch SOURCES jetSubstructureMatchingMCLcCharged.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(jet-substructure-matching-mc-b0-ch + SOURCES jetSubstructureMatchingMCB0Charged.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-substructure-matching-mc-bplus-ch SOURCES jetSubstructureMatchingMCBplusCharged.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport @@ -57,11 +67,21 @@ o2physics_add_dpl_workflow(jet-substructure-matching-sub-dplus-ch PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(jet-substructure-matching-sub-dstar-ch + SOURCES jetSubstructureMatchingSubDstarCharged.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-substructure-matching-sub-lc-ch SOURCES jetSubstructureMatchingSubLcCharged.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(jet-substructure-matching-sub-b0-ch + SOURCES jetSubstructureMatchingSubB0Charged.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-substructure-matching-sub-bplus-ch SOURCES jetSubstructureMatchingSubBplusCharged.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore O2::FrameworkPhysicsSupport diff --git a/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatching.cxx b/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatching.cxx index 3759901939d..02b4c1b87d1 100644 --- a/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatching.cxx +++ b/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatching.cxx @@ -61,8 +61,12 @@ struct JetSubstructureMatching { PresliceOptional TagSplittingsPerTagJetD0 = aod::d0chargedmcparticlelevelsplitting::jetId; PresliceOptional BaseSplittingsPerBaseJetDplus = aod::dpluschargedmcdetectorlevelsplitting::jetId; PresliceOptional TagSplittingsPerTagJetDplus = aod::dpluschargedmcparticlelevelsplitting::jetId; + PresliceOptional BaseSplittingsPerBaseJetDstar = aod::dstarchargedmcdetectorlevelsplitting::jetId; + PresliceOptional TagSplittingsPerTagJetDstar = aod::dstarchargedmcparticlelevelsplitting::jetId; PresliceOptional BaseSplittingsPerBaseJetLc = aod::lcchargedmcdetectorlevelsplitting::jetId; PresliceOptional TagSplittingsPerTagJetLc = aod::lcchargedmcparticlelevelsplitting::jetId; + PresliceOptional BaseSplittingsPerBaseJetB0 = aod::b0chargedmcdetectorlevelsplitting::jetId; + PresliceOptional TagSplittingsPerTagJetB0 = aod::b0chargedmcparticlelevelsplitting::jetId; PresliceOptional BaseSplittingsPerBaseJetBplus = aod::bpluschargedmcdetectorlevelsplitting::jetId; PresliceOptional TagSplittingsPerTagJetBplus = aod::bpluschargedmcparticlelevelsplitting::jetId; PresliceOptional BaseSplittingsPerBaseJetDielectron = aod::dielectronchargedmcdetectorlevelsplitting::jetId; @@ -74,19 +78,23 @@ struct JetSubstructureMatching { PresliceOptional TagPairsPerTagJetD0 = aod::d0chargedmcparticlelevelpair::jetId; PresliceOptional BasePairsPerBaseJetDplus = aod::dpluschargedmcdetectorlevelpair::jetId; PresliceOptional TagPairsPerTagJetDplus = aod::dpluschargedmcparticlelevelpair::jetId; + PresliceOptional BasePairsPerBaseJetDstar = aod::dstarchargedmcdetectorlevelpair::jetId; + PresliceOptional TagPairsPerTagJetDstar = aod::dstarchargedmcparticlelevelpair::jetId; PresliceOptional BasePairsPerBaseJetLc = aod::lcchargedmcdetectorlevelpair::jetId; PresliceOptional TagPairsPerTagJetLc = aod::lcchargedmcparticlelevelpair::jetId; + PresliceOptional BasePairsPerBaseJetB0 = aod::b0chargedmcdetectorlevelpair::jetId; + PresliceOptional TagPairsPerTagJetB0 = aod::b0chargedmcparticlelevelpair::jetId; PresliceOptional BasePairsPerBaseJetBplus = aod::bpluschargedmcdetectorlevelpair::jetId; PresliceOptional TagPairsPerTagJetBplus = aod::bpluschargedmcparticlelevelpair::jetId; PresliceOptional BasePairsPerBaseJetDielectron = aod::dielectronchargedmcdetectorlevelpair::jetId; PresliceOptional TagPairsPerTagJetDielectron = aod::dielectronchargedmcparticlelevelpair::jetId; // workaround till binding nodes can be passed as template arguments - template - auto slicedPerJetForMatching(T const& table, U const& jet, V const& perIncluisveJet, M const& perD0Jet, N const& perDplusJet, O const& perLcJet, P const& perBplusJet, Q const& perDielectronJet) + template + auto slicedPerJetForMatching(T const& table, U const& jet, V const& perIncluisveJet, M const& perD0Jet, N const& perDplusJet, O const& perDstarJet, P const& perLcJet, Q const& perB0Jet, R const& perBplusJet, S const& perDielectronJet) { if constexpr (jethfutilities::isHFTable() || jethfutilities::isHFMcTable()) { - return jethfutilities::slicedPerHFJet(table, jet, perD0Jet, perDplusJet, perLcJet, perBplusJet); + return jethfutilities::slicedPerHFJet(table, jet, perD0Jet, perDplusJet, perDstarJet, perLcJet, perB0Jet, perBplusJet); } else if constexpr (jetdqutilities::isDielectronTable() || jetdqutilities::isDielectronMcTable()) { return jetdqutilities::slicedPerDielectronJet(table, jet, perDielectronJet); } else { @@ -149,14 +157,14 @@ struct JetSubstructureMatching { } if (hasMatchedJet) { // auto const& jetTagSplittings = jetsTagSplittings.sliceBy(TagSplittingsPerTagJet, jetTag.globalIndex()); - auto const& jetTagSplittings = slicedPerJetForMatching(jetsTagSplittings, jetTag, TagSplittingsPerTagJetInclusive, TagSplittingsPerTagJetD0, TagSplittingsPerTagJetDplus, TagSplittingsPerTagJetLc, TagSplittingsPerTagJetBplus, TagSplittingsPerTagJetDielectron); + auto const& jetTagSplittings = slicedPerJetForMatching(jetsTagSplittings, jetTag, TagSplittingsPerTagJetInclusive, TagSplittingsPerTagJetD0, TagSplittingsPerTagJetDplus, TagSplittingsPerTagJetDstar, TagSplittingsPerTagJetLc, TagSplittingsPerTagJetB0, TagSplittingsPerTagJetBplus, TagSplittingsPerTagJetDielectron); int tagSplittingIndex = 0; for (auto const& jetTagSplitting : jetTagSplittings) { jetTagSplittingsMap[jetTagSplitting.globalIndex()] = tagSplittingIndex; tagSplittingIndex++; } // auto const& jetTagPairs = jetsTagPairs.sliceBy(TagPairsPerTagJet, jetTag.globalIndex()); - auto const& jetTagPairs = slicedPerJetForMatching(jetsTagPairs, jetTag, TagPairsPerTagJetInclusive, TagPairsPerTagJetD0, TagPairsPerTagJetDplus, TagPairsPerTagJetLc, TagPairsPerTagJetBplus, TagPairsPerTagJetDielectron); + auto const& jetTagPairs = slicedPerJetForMatching(jetsTagPairs, jetTag, TagPairsPerTagJetInclusive, TagPairsPerTagJetD0, TagPairsPerTagJetDplus, TagPairsPerTagJetDstar, TagPairsPerTagJetLc, TagPairsPerTagJetB0, TagPairsPerTagJetBplus, TagPairsPerTagJetDielectron); int tagPairIndex = 0; for (auto const& jetTagPair : jetTagPairs) { jetTagPairsMap[jetTagPair.globalIndex()] = tagPairIndex; @@ -197,7 +205,7 @@ struct JetSubstructureMatching { } } // auto const& jetBaseSplittings = jetsBaseSplittings.sliceBy(BaseSplittingsPerBaseJet, jetBase.globalIndex()); - auto const& jetBaseSplittings = slicedPerJetForMatching(jetsBaseSplittings, jetBase, BaseSplittingsPerBaseJetInclusive, BaseSplittingsPerBaseJetD0, BaseSplittingsPerBaseJetDplus, BaseSplittingsPerBaseJetLc, BaseSplittingsPerBaseJetBplus, BaseSplittingsPerBaseJetDielectron); + auto const& jetBaseSplittings = slicedPerJetForMatching(jetsBaseSplittings, jetBase, BaseSplittingsPerBaseJetInclusive, BaseSplittingsPerBaseJetD0, BaseSplittingsPerBaseJetDplus, BaseSplittingsPerBaseJetDstar, BaseSplittingsPerBaseJetLc, BaseSplittingsPerBaseJetB0, BaseSplittingsPerBaseJetBplus, BaseSplittingsPerBaseJetDielectron); int baseSplittingIndex = 0; for (auto const& jetBaseSplitting : jetBaseSplittings) { jetBaseSplittingsMap[jetBaseSplitting.globalIndex()] = baseSplittingIndex; @@ -205,7 +213,7 @@ struct JetSubstructureMatching { } jetmatchingutilities::doAllMatching(jetBaseSplittings, jetTagSplittings, jetsBasetoTagSplittingsMatchingGeo, jetsBasetoTagSplittingsMatchingPt, jetsBasetoTagSplittingsMatchingHF, jetsTagtoBaseSplittingsMatchingGeo, jetsTagtoBaseSplittingsMatchingPt, jetsTagtoBaseSplittingsMatchingHF, candidatesBase, tracksBase, clustersBase, candidatesTag, tracksTag, tracksTag, doMatchingGeo, doMatchingHf, doMatchingPt, maxMatchingDistance, minPtFraction); // auto const& jetBasePairs = jetsBasePairs.sliceBy(BasePairsPerBaseJet, jetBase.globalIndex()); - auto const& jetBasePairs = slicedPerJetForMatching(jetsBasePairs, jetBase, BasePairsPerBaseJetInclusive, BasePairsPerBaseJetD0, BasePairsPerBaseJetDplus, BasePairsPerBaseJetLc, BasePairsPerBaseJetBplus, BasePairsPerBaseJetDielectron); + auto const& jetBasePairs = slicedPerJetForMatching(jetsBasePairs, jetBase, BasePairsPerBaseJetInclusive, BasePairsPerBaseJetD0, BasePairsPerBaseJetDplus, BasePairsPerBaseJetDstar, BasePairsPerBaseJetLc, BasePairsPerBaseJetB0, BasePairsPerBaseJetBplus, BasePairsPerBaseJetDielectron); int basePairIndex = 0; for (auto const& jetBasePair : jetBasePairs) { jetBasePairsMap[jetBasePair.globalIndex()] = basePairIndex; diff --git a/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingMCB0Charged.cxx b/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingMCB0Charged.cxx new file mode 100644 index 00000000000..96e3e0081ec --- /dev/null +++ b/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingMCB0Charged.cxx @@ -0,0 +1,51 @@ +// 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. + +// B0 substructure matching mc charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatching.cxx" + +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetReducedData.h" +#include "PWGJE/DataModel/JetSubstructure.h" + +#include +#include +#include +#include +#include + +#include + +using B0ChargedJetSubstructureMatchingMC = JetSubstructureMatching, + soa::Join, + aod::B0ChargedMCDetectorLevelSPsMatchedToB0ChargedMCParticleLevelSPs, + aod::B0ChargedMCParticleLevelSPsMatchedToB0ChargedMCDetectorLevelSPs, + aod::B0ChargedMCDetectorLevelPRsMatchedToB0ChargedMCParticleLevelPRs, + aod::B0ChargedMCParticleLevelPRsMatchedToB0ChargedMCDetectorLevelPRs, + aod::B0ChargedMCDetectorLevelSPs, + aod::B0ChargedMCParticleLevelSPs, + aod::B0ChargedMCDetectorLevelPRs, + aod::B0ChargedMCParticleLevelPRs, + aod::CandidatesB0MCD, + aod::CandidatesB0MCP, + aod::JetTracksMCD, + aod::JetParticles, + aod::JDummys>; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + tasks.emplace_back(adaptAnalysisTask(cfgc, TaskName{"jet-substructure-matching-mc-b0-ch"})); + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingMCDstarCharged.cxx b/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingMCDstarCharged.cxx new file mode 100644 index 00000000000..9cff34b1ce7 --- /dev/null +++ b/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingMCDstarCharged.cxx @@ -0,0 +1,51 @@ +// 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. + +// D* substructure matching mc charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatching.cxx" + +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetReducedData.h" +#include "PWGJE/DataModel/JetSubstructure.h" + +#include +#include +#include +#include +#include + +#include + +using DstarChargedJetSubstructureMatchingMC = JetSubstructureMatching, + soa::Join, + aod::DstarChargedMCDetectorLevelSPsMatchedToDstarChargedMCParticleLevelSPs, + aod::DstarChargedMCParticleLevelSPsMatchedToDstarChargedMCDetectorLevelSPs, + aod::DstarChargedMCDetectorLevelPRsMatchedToDstarChargedMCParticleLevelPRs, + aod::DstarChargedMCParticleLevelPRsMatchedToDstarChargedMCDetectorLevelPRs, + aod::DstarChargedMCDetectorLevelSPs, + aod::DstarChargedMCParticleLevelSPs, + aod::DstarChargedMCDetectorLevelPRs, + aod::DstarChargedMCParticleLevelPRs, + aod::CandidatesDstarMCD, + aod::CandidatesDstarMCP, + aod::JetTracksMCD, + aod::JetParticles, + aod::JDummys>; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + tasks.emplace_back(adaptAnalysisTask(cfgc, TaskName{"jet-substructure-matching-mc-dstar-ch"})); + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingSub.cxx b/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingSub.cxx index f1eb5333081..179a4b96b05 100644 --- a/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingSub.cxx +++ b/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingSub.cxx @@ -62,8 +62,12 @@ struct JetSubstructureMatchingSub { PresliceOptional TagSplittingsPerTagJetD0 = aod::d0chargedeventwisesubtractedsplitting::jetId; PresliceOptional BaseSplittingsPerBaseJetDplus = aod::dpluschargedsplitting::jetId; PresliceOptional TagSplittingsPerTagJetDplus = aod::dpluschargedeventwisesubtractedsplitting::jetId; + PresliceOptional BaseSplittingsPerBaseJetDstar = aod::dstarchargedsplitting::jetId; + PresliceOptional TagSplittingsPerTagJetDstar = aod::dstarchargedeventwisesubtractedsplitting::jetId; PresliceOptional BaseSplittingsPerBaseJetLc = aod::lcchargedsplitting::jetId; PresliceOptional TagSplittingsPerTagJetLc = aod::lcchargedeventwisesubtractedsplitting::jetId; + PresliceOptional BaseSplittingsPerBaseJetB0 = aod::b0chargedsplitting::jetId; + PresliceOptional TagSplittingsPerTagJetB0 = aod::b0chargedeventwisesubtractedsplitting::jetId; PresliceOptional BaseSplittingsPerBaseJetBplus = aod::bpluschargedsplitting::jetId; PresliceOptional TagSplittingsPerTagJetBplus = aod::bpluschargedeventwisesubtractedsplitting::jetId; PresliceOptional BaseSplittingsPerBaseJetDielectron = aod::dielectronchargedsplitting::jetId; @@ -75,19 +79,23 @@ struct JetSubstructureMatchingSub { PresliceOptional TagPairsPerTagJetD0 = aod::d0chargedeventwisesubtractedpair::jetId; PresliceOptional BasePairsPerBaseJetDplus = aod::dpluschargedpair::jetId; PresliceOptional TagPairsPerTagJetDplus = aod::dpluschargedeventwisesubtractedpair::jetId; + PresliceOptional BasePairsPerBaseJetDstar = aod::dstarchargedpair::jetId; + PresliceOptional TagPairsPerTagJetDstar = aod::dstarchargedeventwisesubtractedpair::jetId; PresliceOptional BasePairsPerBaseJetLc = aod::lcchargedpair::jetId; PresliceOptional TagPairsPerTagJetLc = aod::lcchargedeventwisesubtractedpair::jetId; PresliceOptional BasePairsPerBaseJetBplus = aod::bpluschargedpair::jetId; PresliceOptional TagPairsPerTagJetBplus = aod::bpluschargedeventwisesubtractedpair::jetId; + PresliceOptional BasePairsPerBaseJetB0 = aod::b0chargedpair::jetId; + PresliceOptional TagPairsPerTagJetB0 = aod::b0chargedeventwisesubtractedpair::jetId; PresliceOptional BasePairsPerBaseJetDielectron = aod::dielectronchargedpair::jetId; PresliceOptional TagPairsPerTagJetDielectron = aod::dielectronchargedeventwisesubtractedpair::jetId; // workaround till binding nodes can be passed as template arguments - template - auto slicedPerJetForMatching(T const& table, U const& jet, V const& perIncluisveJet, M const& perD0Jet, N const& perDplusJet, O const& perLcJet, P const& perBplusJet, Q const& perDielectronJet) + template + auto slicedPerJetForMatching(T const& table, U const& jet, V const& perIncluisveJet, M const& perD0Jet, N const& perDplusJet, O const& perDstarJet, P const& perLcJet, Q const& perB0Jet, R const& perBplusJet, S const& perDielectronJet) { if constexpr (jethfutilities::isHFTable() || jethfutilities::isHFMcTable()) { - return jethfutilities::slicedPerHFJet(table, jet, perD0Jet, perDplusJet, perLcJet, perBplusJet); + return jethfutilities::slicedPerHFJet(table, jet, perD0Jet, perDplusJet, perDstarJet, perLcJet, perB0Jet, perBplusJet); } else if constexpr (jetdqutilities::isDielectronTable() || jetdqutilities::isDielectronMcTable()) { return jetdqutilities::slicedPerDielectronJet(table, jet, perDielectronJet); } else { @@ -150,14 +158,14 @@ struct JetSubstructureMatchingSub { } if (hasMatchedJet) { // auto const& jetTagSplittings = jetsTagSplittings.sliceBy(TagSplittingsPerTagJet, jetTag.globalIndex()); - auto const& jetTagSplittings = slicedPerJetForMatching(jetsTagSplittings, jetTag, TagSplittingsPerTagJetInclusive, TagSplittingsPerTagJetD0, TagSplittingsPerTagJetDplus, TagSplittingsPerTagJetLc, TagSplittingsPerTagJetBplus, TagSplittingsPerTagJetDielectron); + auto const& jetTagSplittings = slicedPerJetForMatching(jetsTagSplittings, jetTag, TagSplittingsPerTagJetInclusive, TagSplittingsPerTagJetD0, TagSplittingsPerTagJetDplus, TagSplittingsPerTagJetDstar, TagSplittingsPerTagJetLc, TagSplittingsPerTagJetB0, TagSplittingsPerTagJetBplus, TagSplittingsPerTagJetDielectron); int tagSplittingIndex = 0; for (auto const& jetTagSplitting : jetTagSplittings) { jetTagSplittingsMap[jetTagSplitting.globalIndex()] = tagSplittingIndex; tagSplittingIndex++; } // auto const& jetTagPairs = jetsTagPairs.sliceBy(TagPairsPerTagJet, jetTag.globalIndex()); - auto const& jetTagPairs = slicedPerJetForMatching(jetsTagPairs, jetTag, TagPairsPerTagJetInclusive, TagPairsPerTagJetD0, TagPairsPerTagJetDplus, TagPairsPerTagJetLc, TagPairsPerTagJetBplus, TagPairsPerTagJetDielectron); + auto const& jetTagPairs = slicedPerJetForMatching(jetsTagPairs, jetTag, TagPairsPerTagJetInclusive, TagPairsPerTagJetD0, TagPairsPerTagJetDplus, TagPairsPerTagJetDstar, TagPairsPerTagJetLc, TagPairsPerTagJetB0, TagPairsPerTagJetBplus, TagPairsPerTagJetDielectron); int tagPairIndex = 0; for (auto const& jetTagPair : jetTagPairs) { jetTagPairsMap[jetTagPair.globalIndex()] = tagPairIndex; @@ -198,7 +206,7 @@ struct JetSubstructureMatchingSub { } } // auto const& jetBaseSplittings = jetsBaseSplittings.sliceBy(BaseSplittingsPerBaseJet, jetBase.globalIndex()); - auto const& jetBaseSplittings = slicedPerJetForMatching(jetsBaseSplittings, jetBase, BaseSplittingsPerBaseJetInclusive, BaseSplittingsPerBaseJetD0, BaseSplittingsPerBaseJetDplus, BaseSplittingsPerBaseJetLc, BaseSplittingsPerBaseJetBplus, BaseSplittingsPerBaseJetDielectron); + auto const& jetBaseSplittings = slicedPerJetForMatching(jetsBaseSplittings, jetBase, BaseSplittingsPerBaseJetInclusive, BaseSplittingsPerBaseJetD0, BaseSplittingsPerBaseJetDplus, BaseSplittingsPerBaseJetDstar, BaseSplittingsPerBaseJetLc, BaseSplittingsPerBaseJetB0, BaseSplittingsPerBaseJetBplus, BaseSplittingsPerBaseJetDielectron); int baseSplittingIndex = 0; for (auto const& jetBaseSplitting : jetBaseSplittings) { jetBaseSplittingsMap[jetBaseSplitting.globalIndex()] = baseSplittingIndex; @@ -206,7 +214,7 @@ struct JetSubstructureMatchingSub { } jetmatchingutilities::doAllMatching(jetBaseSplittings, jetTagSplittings, jetsBasetoTagSplittingsMatchingGeo, jetsBasetoTagSplittingsMatchingPt, jetsBasetoTagSplittingsMatchingHF, jetsTagtoBaseSplittingsMatchingGeo, jetsTagtoBaseSplittingsMatchingPt, jetsTagtoBaseSplittingsMatchingHF, candidates, tracksBase, clustersBase, candidates, tracksTag, tracksTag, doMatchingGeo, doMatchingHf, doMatchingPt, maxMatchingDistance, minPtFraction); // auto const& jetBasePairs = jetsBasePairs.sliceBy(BasePairsPerBaseJet, jetBase.globalIndex()); - auto const& jetBasePairs = slicedPerJetForMatching(jetsBasePairs, jetBase, BasePairsPerBaseJetInclusive, BasePairsPerBaseJetD0, BasePairsPerBaseJetDplus, BasePairsPerBaseJetLc, BasePairsPerBaseJetBplus, BasePairsPerBaseJetDielectron); + auto const& jetBasePairs = slicedPerJetForMatching(jetsBasePairs, jetBase, BasePairsPerBaseJetInclusive, BasePairsPerBaseJetD0, BasePairsPerBaseJetDplus, BasePairsPerBaseJetDstar, BasePairsPerBaseJetLc, BasePairsPerBaseJetB0, BasePairsPerBaseJetBplus, BasePairsPerBaseJetDielectron); int basePairIndex = 0; for (auto const& jetBasePair : jetBasePairs) { jetBasePairsMap[jetBasePair.globalIndex()] = basePairIndex; diff --git a/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingSubB0Charged.cxx b/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingSubB0Charged.cxx new file mode 100644 index 00000000000..3ed89997f58 --- /dev/null +++ b/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingSubB0Charged.cxx @@ -0,0 +1,50 @@ +// 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. + +// substructure matching event-wise subtracted B0 charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingSub.cxx" + +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetReducedData.h" +#include "PWGJE/DataModel/JetSubstructure.h" + +#include +#include +#include +#include +#include + +#include + +using B0ChargedJetSubstructureMatchingSub = JetSubstructureMatchingSub, + soa::Join, + aod::B0ChargedSPsMatchedToB0ChargedEventWiseSubtractedSPs, + aod::B0ChargedEventWiseSubtractedSPsMatchedToB0ChargedSPs, + aod::B0ChargedPRsMatchedToB0ChargedEventWiseSubtractedPRs, + aod::B0ChargedEventWiseSubtractedPRsMatchedToB0ChargedPRs, + aod::B0ChargedSPs, + aod::B0ChargedEventWiseSubtractedSPs, + aod::B0ChargedPRs, + aod::B0ChargedEventWiseSubtractedPRs, + aod::CandidatesB0Data, + aod::JetTracks, + aod::JetTracksSubB0, + aod::JDummys>; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + tasks.emplace_back(adaptAnalysisTask(cfgc, TaskName{"jet-substructure-matching-sub-b0-ch"})); + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingSubDstarCharged.cxx b/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingSubDstarCharged.cxx new file mode 100644 index 00000000000..c301149c647 --- /dev/null +++ b/PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingSubDstarCharged.cxx @@ -0,0 +1,50 @@ +// 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. + +// substructure matching event-wise subtracted D* charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/TableProducer/Matching/Substructure/jetSubstructureMatchingSub.cxx" + +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetReducedData.h" +#include "PWGJE/DataModel/JetSubstructure.h" + +#include +#include +#include +#include +#include + +#include + +using DstarChargedJetSubstructureMatchingSub = JetSubstructureMatchingSub, + soa::Join, + aod::DstarChargedSPsMatchedToDstarChargedEventWiseSubtractedSPs, + aod::DstarChargedEventWiseSubtractedSPsMatchedToDstarChargedSPs, + aod::DstarChargedPRsMatchedToDstarChargedEventWiseSubtractedPRs, + aod::DstarChargedEventWiseSubtractedPRsMatchedToDstarChargedPRs, + aod::DstarChargedSPs, + aod::DstarChargedEventWiseSubtractedSPs, + aod::DstarChargedPRs, + aod::DstarChargedEventWiseSubtractedPRs, + aod::CandidatesDstarData, + aod::JetTracks, + aod::JetTracksSubDstar, + aod::JDummys>; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + tasks.emplace_back(adaptAnalysisTask(cfgc, TaskName{"jet-substructure-matching-sub-dstar-ch"})); + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/TableProducer/Matching/jetMatchingMCB0Charged.cxx b/PWGJE/TableProducer/Matching/jetMatchingMCB0Charged.cxx new file mode 100644 index 00000000000..27205e0c854 --- /dev/null +++ b/PWGJE/TableProducer/Matching/jetMatchingMCB0Charged.cxx @@ -0,0 +1,42 @@ +// 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. + +// jet matching mc B0 charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/TableProducer/Matching/jetMatchingMC.cxx" + +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetReducedData.h" + +#include +#include +#include +#include +#include + +#include + +using B0ChargedJetMatchingMC = JetMatchingMc, + soa::Join, + aod::B0ChargedMCDetectorLevelJetsMatchedToB0ChargedMCParticleLevelJets, + aod::B0ChargedMCParticleLevelJetsMatchedToB0ChargedMCDetectorLevelJets, + aod::CandidatesB0MCD, + aod::CandidatesB0MCP, + aod::JDummys>; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + tasks.emplace_back(adaptAnalysisTask(cfgc, TaskName{"jet-matching-mc-b0-ch"})); + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/TableProducer/Matching/jetMatchingMCDstarCharged.cxx b/PWGJE/TableProducer/Matching/jetMatchingMCDstarCharged.cxx new file mode 100644 index 00000000000..8eca5d1908e --- /dev/null +++ b/PWGJE/TableProducer/Matching/jetMatchingMCDstarCharged.cxx @@ -0,0 +1,42 @@ +// 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. + +// jet matching mc D* charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/TableProducer/Matching/jetMatchingMC.cxx" + +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetReducedData.h" + +#include +#include +#include +#include +#include + +#include + +using DstarChargedJetMatchingMC = JetMatchingMc, + soa::Join, + aod::DstarChargedMCDetectorLevelJetsMatchedToDstarChargedMCParticleLevelJets, + aod::DstarChargedMCParticleLevelJetsMatchedToDstarChargedMCDetectorLevelJets, + aod::CandidatesDstarMCD, + aod::CandidatesDstarMCP, + aod::JDummys>; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + tasks.emplace_back(adaptAnalysisTask(cfgc, TaskName{"jet-matching-mc-dstar-ch"})); + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/TableProducer/Matching/jetMatchingMCSubB0Charged.cxx b/PWGJE/TableProducer/Matching/jetMatchingMCSubB0Charged.cxx new file mode 100644 index 00000000000..a5de8601581 --- /dev/null +++ b/PWGJE/TableProducer/Matching/jetMatchingMCSubB0Charged.cxx @@ -0,0 +1,39 @@ +// 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. + +// jet matching mc subtracted B0 charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/TableProducer/Matching/jetMatchingMCSub.cxx" + +#include "PWGJE/DataModel/Jet.h" + +#include +#include +#include +#include +#include + +#include + +using B0ChargedJetMatchingMCSub = JetMatchingMcSub, + soa::Join, + aod::B0ChargedMCDetectorLevelJetsMatchedToB0ChargedMCDetectorLevelEventWiseSubtractedJets, + aod::B0ChargedMCDetectorLevelEventWiseSubtractedJetsMatchedToB0ChargedMCDetectorLevelJets, + aod::CandidatesB0MCD>; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + tasks.emplace_back(adaptAnalysisTask(cfgc, TaskName{"jet-matching-mc-sub-b0-ch"})); + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/TableProducer/Matching/jetMatchingMCSubDstarCharged.cxx b/PWGJE/TableProducer/Matching/jetMatchingMCSubDstarCharged.cxx new file mode 100644 index 00000000000..f2acd7aedd0 --- /dev/null +++ b/PWGJE/TableProducer/Matching/jetMatchingMCSubDstarCharged.cxx @@ -0,0 +1,39 @@ +// 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. + +// jet matching mc subtracted D* charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/TableProducer/Matching/jetMatchingMCSub.cxx" + +#include "PWGJE/DataModel/Jet.h" + +#include +#include +#include +#include +#include + +#include + +using DstarChargedJetMatchingMCSub = JetMatchingMcSub, + soa::Join, + aod::DstarChargedMCDetectorLevelJetsMatchedToDstarChargedMCDetectorLevelEventWiseSubtractedJets, + aod::DstarChargedMCDetectorLevelEventWiseSubtractedJetsMatchedToDstarChargedMCDetectorLevelJets, + aod::CandidatesDstarMCD>; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + tasks.emplace_back(adaptAnalysisTask(cfgc, TaskName{"jet-matching-mc-sub-dstar-ch"})); + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/TableProducer/Matching/jetMatchingSubB0Charged.cxx b/PWGJE/TableProducer/Matching/jetMatchingSubB0Charged.cxx new file mode 100644 index 00000000000..87598cc0cc1 --- /dev/null +++ b/PWGJE/TableProducer/Matching/jetMatchingSubB0Charged.cxx @@ -0,0 +1,41 @@ +// 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. + +// jet matching subtracted B0 charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/TableProducer/Matching/jetMatchingSub.cxx" + +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetSubtraction.h" + +#include +#include +#include +#include +#include + +#include + +using B0ChargedJetMatchingSub = JetMatchingSub, + soa::Join, + aod::B0ChargedJetsMatchedToB0ChargedEventWiseSubtractedJets, + aod::B0ChargedEventWiseSubtractedJetsMatchedToB0ChargedJets, + aod::JTrackB0Subs, + aod::CandidatesB0Data>; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + tasks.emplace_back(adaptAnalysisTask(cfgc, TaskName{"jet-matching-sub-b0-ch"})); + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/TableProducer/Matching/jetMatchingSubDstarCharged.cxx b/PWGJE/TableProducer/Matching/jetMatchingSubDstarCharged.cxx new file mode 100644 index 00000000000..e8d54a30ecb --- /dev/null +++ b/PWGJE/TableProducer/Matching/jetMatchingSubDstarCharged.cxx @@ -0,0 +1,41 @@ +// 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. + +// jet matching subtracted D* charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/TableProducer/Matching/jetMatchingSub.cxx" + +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetSubtraction.h" + +#include +#include +#include +#include +#include + +#include + +using DstarChargedJetMatchingSub = JetMatchingSub, + soa::Join, + aod::DstarChargedJetsMatchedToDstarChargedEventWiseSubtractedJets, + aod::DstarChargedEventWiseSubtractedJetsMatchedToDstarChargedJets, + aod::JTrackDstarSubs, + aod::CandidatesDstarData>; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + tasks.emplace_back(adaptAnalysisTask(cfgc, TaskName{"jet-matching-sub-dstar-ch"})); + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/TableProducer/derivedDataProducer.cxx b/PWGJE/TableProducer/derivedDataProducer.cxx index d7684932bad..e4ac527a171 100644 --- a/PWGJE/TableProducer/derivedDataProducer.cxx +++ b/PWGJE/TableProducer/derivedDataProducer.cxx @@ -99,10 +99,18 @@ struct JetDerivedDataProducerTask { Produces jDplusMcCollisionIdsTable; Produces jDplusIdsTable; Produces jDplusParticleIdsTable; + Produces jDstarCollisionIdsTable; + Produces jDstarMcCollisionIdsTable; + Produces jDstarIdsTable; + Produces jDstarParticleIdsTable; Produces jLcCollisionIdsTable; Produces jLcMcCollisionIdsTable; Produces jLcIdsTable; Produces jLcParticleIdsTable; + Produces jB0CollisionIdsTable; + Produces jB0McCollisionIdsTable; + Produces jB0IdsTable; + Produces jB0ParticleIdsTable; Produces jBplusCollisionIdsTable; Produces jBplusMcCollisionIdsTable; Produces jBplusIdsTable; @@ -469,21 +477,21 @@ struct JetDerivedDataProducerTask { } PROCESS_SWITCH(JetDerivedDataProducerTask, processD0McCollisions, "produces derived index for D0 MC collisions", false); - void processD0(aod::HfD0Ids::iterator const& D0, aod::Tracks const&) + void processD0(aod::HfD0Ids::iterator const& D0Candidate, aod::Tracks const&) { - auto JProng0ID = trackCollisionMapping.find({D0.prong0Id(), D0.prong0_as().collisionId()}); - auto JProng1ID = trackCollisionMapping.find({D0.prong1Id(), D0.prong1_as().collisionId()}); + auto JProng0ID = trackCollisionMapping.find({D0Candidate.prong0Id(), D0Candidate.prong0_as().collisionId()}); + auto JProng1ID = trackCollisionMapping.find({D0Candidate.prong1Id(), D0Candidate.prong1_as().collisionId()}); if (withCollisionAssociator) { - JProng0ID = trackCollisionMapping.find({D0.prong0Id(), D0.collisionId()}); - JProng1ID = trackCollisionMapping.find({D0.prong1Id(), D0.collisionId()}); + JProng0ID = trackCollisionMapping.find({D0Candidate.prong0Id(), D0Candidate.collisionId()}); + JProng1ID = trackCollisionMapping.find({D0Candidate.prong1Id(), D0Candidate.collisionId()}); } - products.jD0IdsTable(D0.collisionId(), JProng0ID->second, JProng1ID->second); + products.jD0IdsTable(D0Candidate.collisionId(), JProng0ID->second, JProng1ID->second); } PROCESS_SWITCH(JetDerivedDataProducerTask, processD0, "produces derived index for D0 candidates", false); - void processD0MC(aod::HfD0PIds::iterator const& D0) + void processD0MC(aod::HfD0PIds::iterator const& D0Particle) { - products.jD0ParticleIdsTable(D0.mcCollisionId(), D0.mcParticleId()); + products.jD0ParticleIdsTable(D0Particle.mcCollisionId(), D0Particle.mcParticleId()); } PROCESS_SWITCH(JetDerivedDataProducerTask, processD0MC, "produces derived index for D0 particles", false); @@ -499,26 +507,58 @@ struct JetDerivedDataProducerTask { } PROCESS_SWITCH(JetDerivedDataProducerTask, processDplusMcCollisions, "produces derived index for Dplus MC collisions", false); - void processDplus(aod::HfDplusIds::iterator const& Dplus, aod::Tracks const&) + void processDplus(aod::HfDplusIds::iterator const& DplusCandidate, aod::Tracks const&) { - auto JProng0ID = trackCollisionMapping.find({Dplus.prong0Id(), Dplus.prong0_as().collisionId()}); - auto JProng1ID = trackCollisionMapping.find({Dplus.prong1Id(), Dplus.prong1_as().collisionId()}); - auto JProng2ID = trackCollisionMapping.find({Dplus.prong2Id(), Dplus.prong2_as().collisionId()}); + auto JProng0ID = trackCollisionMapping.find({DplusCandidate.prong0Id(), DplusCandidate.prong0_as().collisionId()}); + auto JProng1ID = trackCollisionMapping.find({DplusCandidate.prong1Id(), DplusCandidate.prong1_as().collisionId()}); + auto JProng2ID = trackCollisionMapping.find({DplusCandidate.prong2Id(), DplusCandidate.prong2_as().collisionId()}); if (withCollisionAssociator) { - JProng0ID = trackCollisionMapping.find({Dplus.prong0Id(), Dplus.collisionId()}); - JProng1ID = trackCollisionMapping.find({Dplus.prong1Id(), Dplus.collisionId()}); - JProng2ID = trackCollisionMapping.find({Dplus.prong2Id(), Dplus.collisionId()}); + JProng0ID = trackCollisionMapping.find({DplusCandidate.prong0Id(), DplusCandidate.collisionId()}); + JProng1ID = trackCollisionMapping.find({DplusCandidate.prong1Id(), DplusCandidate.collisionId()}); + JProng2ID = trackCollisionMapping.find({DplusCandidate.prong2Id(), DplusCandidate.collisionId()}); } - products.jDplusIdsTable(Dplus.collisionId(), JProng0ID->second, JProng1ID->second, JProng2ID->second); + products.jDplusIdsTable(DplusCandidate.collisionId(), JProng0ID->second, JProng1ID->second, JProng2ID->second); } PROCESS_SWITCH(JetDerivedDataProducerTask, processDplus, "produces derived index for Dplus candidates", false); - void processDplusMC(aod::HfDplusPIds::iterator const& Dplus) + void processDplusMC(aod::HfDplusPIds::iterator const& DplusParticle) { - products.jDplusParticleIdsTable(Dplus.mcCollisionId(), Dplus.mcParticleId()); + products.jDplusParticleIdsTable(DplusParticle.mcCollisionId(), DplusParticle.mcParticleId()); } PROCESS_SWITCH(JetDerivedDataProducerTask, processDplusMC, "produces derived index for Dplus particles", false); + void processDstarCollisions(aod::HfDstarCollIds::iterator const& DstarCollision) + { + products.jDstarCollisionIdsTable(DstarCollision.collisionId()); + } + PROCESS_SWITCH(JetDerivedDataProducerTask, processDstarCollisions, "produces derived index for Dstar collisions", false); + + void processDstarMcCollisions(aod::HfDstarMcCollIds::iterator const& DstarMcCollision) + { + products.jDstarMcCollisionIdsTable(DstarMcCollision.mcCollisionId()); + } + PROCESS_SWITCH(JetDerivedDataProducerTask, processDstarMcCollisions, "produces derived index for Dstar MC collisions", false); + + void processDstar(aod::HfDstarIds::iterator const& DstarCandidate, aod::Tracks const&) + { + auto JProng0ID = trackCollisionMapping.find({DstarCandidate.prong0Id(), DstarCandidate.prong0_as().collisionId()}); + auto JProng1ID = trackCollisionMapping.find({DstarCandidate.prong1Id(), DstarCandidate.prong1_as().collisionId()}); + auto JProng2ID = trackCollisionMapping.find({DstarCandidate.prong2Id(), DstarCandidate.prong2_as().collisionId()}); + if (withCollisionAssociator) { + JProng0ID = trackCollisionMapping.find({DstarCandidate.prong0Id(), DstarCandidate.collisionId()}); + JProng1ID = trackCollisionMapping.find({DstarCandidate.prong1Id(), DstarCandidate.collisionId()}); + JProng2ID = trackCollisionMapping.find({DstarCandidate.prong2Id(), DstarCandidate.collisionId()}); + } + products.jDstarIdsTable(DstarCandidate.collisionId(), JProng0ID->second, JProng1ID->second, JProng2ID->second); + } + PROCESS_SWITCH(JetDerivedDataProducerTask, processDstar, "produces derived index for Dstar candidates", false); + + void processDstarMC(aod::HfDstarPIds::iterator const& DstarParticle) + { + products.jDstarParticleIdsTable(DstarParticle.mcCollisionId(), DstarParticle.mcParticleId()); + } + PROCESS_SWITCH(JetDerivedDataProducerTask, processDstarMC, "produces derived index for Dstar particles", false); + void processLcCollisions(aod::HfLcCollIds::iterator const& LcCollision) { products.jLcCollisionIdsTable(LcCollision.collisionId()); @@ -531,26 +571,60 @@ struct JetDerivedDataProducerTask { } PROCESS_SWITCH(JetDerivedDataProducerTask, processLcMcCollisions, "produces derived index for Lc MC collisions", false); - void processLc(aod::HfLcIds::iterator const& Lc, aod::Tracks const&) + void processLc(aod::HfLcIds::iterator const& LcCandidate, aod::Tracks const&) { - auto JProng0ID = trackCollisionMapping.find({Lc.prong0Id(), Lc.prong0_as().collisionId()}); - auto JProng1ID = trackCollisionMapping.find({Lc.prong1Id(), Lc.prong1_as().collisionId()}); - auto JProng2ID = trackCollisionMapping.find({Lc.prong2Id(), Lc.prong2_as().collisionId()}); + auto JProng0ID = trackCollisionMapping.find({LcCandidate.prong0Id(), LcCandidate.prong0_as().collisionId()}); + auto JProng1ID = trackCollisionMapping.find({LcCandidate.prong1Id(), LcCandidate.prong1_as().collisionId()}); + auto JProng2ID = trackCollisionMapping.find({LcCandidate.prong2Id(), LcCandidate.prong2_as().collisionId()}); if (withCollisionAssociator) { - JProng0ID = trackCollisionMapping.find({Lc.prong0Id(), Lc.collisionId()}); - JProng1ID = trackCollisionMapping.find({Lc.prong1Id(), Lc.collisionId()}); - JProng2ID = trackCollisionMapping.find({Lc.prong2Id(), Lc.collisionId()}); + JProng0ID = trackCollisionMapping.find({LcCandidate.prong0Id(), LcCandidate.collisionId()}); + JProng1ID = trackCollisionMapping.find({LcCandidate.prong1Id(), LcCandidate.collisionId()}); + JProng2ID = trackCollisionMapping.find({LcCandidate.prong2Id(), LcCandidate.collisionId()}); } - products.jLcIdsTable(Lc.collisionId(), JProng0ID->second, JProng1ID->second, JProng2ID->second); + products.jLcIdsTable(LcCandidate.collisionId(), JProng0ID->second, JProng1ID->second, JProng2ID->second); } PROCESS_SWITCH(JetDerivedDataProducerTask, processLc, "produces derived index for Lc candidates", false); - void processLcMC(aod::HfLcPIds::iterator const& Lc) + void processLcMC(aod::HfLcPIds::iterator const& LcParticle) { - products.jLcParticleIdsTable(Lc.mcCollisionId(), Lc.mcParticleId()); + products.jLcParticleIdsTable(LcParticle.mcCollisionId(), LcParticle.mcParticleId()); } PROCESS_SWITCH(JetDerivedDataProducerTask, processLcMC, "produces derived index for Lc particles", false); + void processB0Collisions(aod::HfB0CollIds::iterator const& B0Collision) + { + products.jB0CollisionIdsTable(B0Collision.collisionId()); + } + PROCESS_SWITCH(JetDerivedDataProducerTask, processB0Collisions, "produces derived index for B0 collisions", false); + + void processB0McCollisions(aod::HfB0McCollIds::iterator const& B0McCollision) + { + products.jB0McCollisionIdsTable(B0McCollision.mcCollisionId()); + } + PROCESS_SWITCH(JetDerivedDataProducerTask, processB0McCollisions, "produces derived index for B0 MC collisions", false); + + void processB0(aod::HfB0Ids::iterator const& B0Candidate, aod::Tracks const&) + { + auto JProng0ID = trackCollisionMapping.find({B0Candidate.prong0Id(), B0Candidate.prong0_as().collisionId()}); + auto JProng1ID = trackCollisionMapping.find({B0Candidate.prong1Id(), B0Candidate.prong1_as().collisionId()}); + auto JProng2ID = trackCollisionMapping.find({B0Candidate.prong2Id(), B0Candidate.prong2_as().collisionId()}); + auto JProng3ID = trackCollisionMapping.find({B0Candidate.prong3Id(), B0Candidate.prong3_as().collisionId()}); + if (withCollisionAssociator) { + JProng0ID = trackCollisionMapping.find({B0Candidate.prong0Id(), B0Candidate.collisionId()}); + JProng1ID = trackCollisionMapping.find({B0Candidate.prong1Id(), B0Candidate.collisionId()}); + JProng2ID = trackCollisionMapping.find({B0Candidate.prong2Id(), B0Candidate.collisionId()}); + JProng3ID = trackCollisionMapping.find({B0Candidate.prong3Id(), B0Candidate.collisionId()}); + } + products.jB0IdsTable(B0Candidate.collisionId(), JProng0ID->second, JProng1ID->second, JProng2ID->second, JProng3ID->second); + } + PROCESS_SWITCH(JetDerivedDataProducerTask, processB0, "produces derived index for B0 candidates", false); + + void processB0MC(aod::HfB0PIds::iterator const& B0Particle) + { + products.jB0ParticleIdsTable(B0Particle.mcCollisionId(), B0Particle.mcParticleId()); + } + PROCESS_SWITCH(JetDerivedDataProducerTask, processB0MC, "produces derived index for B0 particles", false); + void processBplusCollisions(aod::HfBplusCollIds::iterator const& BplusCollision) { products.jBplusCollisionIdsTable(BplusCollision.collisionId()); @@ -563,35 +637,35 @@ struct JetDerivedDataProducerTask { } PROCESS_SWITCH(JetDerivedDataProducerTask, processBplusMcCollisions, "produces derived index for Bplus MC collisions", false); - void processBplus(aod::HfBplusIds::iterator const& Bplus, aod::Tracks const&) + void processBplus(aod::HfBplusIds::iterator const& BplusCandidate, aod::Tracks const&) { - auto JProng0ID = trackCollisionMapping.find({Bplus.prong0Id(), Bplus.prong0_as().collisionId()}); - auto JProng1ID = trackCollisionMapping.find({Bplus.prong1Id(), Bplus.prong1_as().collisionId()}); - auto JProng2ID = trackCollisionMapping.find({Bplus.prong2Id(), Bplus.prong2_as().collisionId()}); + auto JProng0ID = trackCollisionMapping.find({BplusCandidate.prong0Id(), BplusCandidate.prong0_as().collisionId()}); + auto JProng1ID = trackCollisionMapping.find({BplusCandidate.prong1Id(), BplusCandidate.prong1_as().collisionId()}); + auto JProng2ID = trackCollisionMapping.find({BplusCandidate.prong2Id(), BplusCandidate.prong2_as().collisionId()}); if (withCollisionAssociator) { - JProng0ID = trackCollisionMapping.find({Bplus.prong0Id(), Bplus.collisionId()}); - JProng1ID = trackCollisionMapping.find({Bplus.prong1Id(), Bplus.collisionId()}); - JProng2ID = trackCollisionMapping.find({Bplus.prong2Id(), Bplus.collisionId()}); + JProng0ID = trackCollisionMapping.find({BplusCandidate.prong0Id(), BplusCandidate.collisionId()}); + JProng1ID = trackCollisionMapping.find({BplusCandidate.prong1Id(), BplusCandidate.collisionId()}); + JProng2ID = trackCollisionMapping.find({BplusCandidate.prong2Id(), BplusCandidate.collisionId()}); } - products.jBplusIdsTable(Bplus.collisionId(), JProng0ID->second, JProng1ID->second, JProng2ID->second); + products.jBplusIdsTable(BplusCandidate.collisionId(), JProng0ID->second, JProng1ID->second, JProng2ID->second); } PROCESS_SWITCH(JetDerivedDataProducerTask, processBplus, "produces derived index for Bplus candidates", false); - void processBplusMC(aod::HfBplusPIds::iterator const& Bplus) + void processBplusMC(aod::HfBplusPIds::iterator const& BplusParticle) { - products.jBplusParticleIdsTable(Bplus.mcCollisionId(), Bplus.mcParticleId()); + products.jBplusParticleIdsTable(BplusParticle.mcCollisionId(), BplusParticle.mcParticleId()); } PROCESS_SWITCH(JetDerivedDataProducerTask, processBplusMC, "produces derived index for Bplus particles", false); - void processV0(aod::V0Indices::iterator const& V0, aod::Tracks const&) + void processV0(aod::V0Indices::iterator const& V0Candidate, aod::Tracks const&) { - auto JPosTrackID = trackCollisionMapping.find({V0.posTrackId(), V0.posTrack_as().collisionId()}); - auto JNegTrackID = trackCollisionMapping.find({V0.negTrackId(), V0.negTrack_as().collisionId()}); + auto JPosTrackID = trackCollisionMapping.find({V0Candidate.posTrackId(), V0Candidate.posTrack_as().collisionId()}); + auto JNegTrackID = trackCollisionMapping.find({V0Candidate.negTrackId(), V0Candidate.negTrack_as().collisionId()}); if (withCollisionAssociator) { - JPosTrackID = trackCollisionMapping.find({V0.posTrackId(), V0.collisionId()}); - JNegTrackID = trackCollisionMapping.find({V0.negTrackId(), V0.collisionId()}); + JPosTrackID = trackCollisionMapping.find({V0Candidate.posTrackId(), V0Candidate.collisionId()}); + JNegTrackID = trackCollisionMapping.find({V0Candidate.negTrackId(), V0Candidate.collisionId()}); } - products.jV0IdsTable(V0.collisionId(), JPosTrackID->second, JNegTrackID->second); + products.jV0IdsTable(V0Candidate.collisionId(), JPosTrackID->second, JNegTrackID->second); } PROCESS_SWITCH(JetDerivedDataProducerTask, processV0, "produces derived index for V0 candidates", false); @@ -637,15 +711,15 @@ struct JetDerivedDataProducerTask { } PROCESS_SWITCH(JetDerivedDataProducerTask, processDielectronCollisions, "produces derived index for Dielectron collisions", false); - void processDielectron(aod::DielectronInfo const& Dielectron, aod::Tracks const&) + void processDielectron(aod::DielectronInfo const& DielectronCandidate, aod::Tracks const&) { - auto JProng0ID = trackCollisionMapping.find({Dielectron.prong0Id(), Dielectron.prong0_as().collisionId()}); - auto JProng1ID = trackCollisionMapping.find({Dielectron.prong1Id(), Dielectron.prong1_as().collisionId()}); + auto JProng0ID = trackCollisionMapping.find({DielectronCandidate.prong0Id(), DielectronCandidate.prong0_as().collisionId()}); + auto JProng1ID = trackCollisionMapping.find({DielectronCandidate.prong1Id(), DielectronCandidate.prong1_as().collisionId()}); if (withCollisionAssociator) { - JProng0ID = trackCollisionMapping.find({Dielectron.prong0Id(), Dielectron.collisionId()}); - JProng1ID = trackCollisionMapping.find({Dielectron.prong1Id(), Dielectron.collisionId()}); + JProng0ID = trackCollisionMapping.find({DielectronCandidate.prong0Id(), DielectronCandidate.collisionId()}); + JProng1ID = trackCollisionMapping.find({DielectronCandidate.prong1Id(), DielectronCandidate.collisionId()}); } - products.jDielectronIdsTable(Dielectron.collisionId(), JProng0ID->second, JProng1ID->second); + products.jDielectronIdsTable(DielectronCandidate.collisionId(), JProng0ID->second, JProng1ID->second); } PROCESS_SWITCH(JetDerivedDataProducerTask, processDielectron, "produces derived index for Dielectron candidates", false); diff --git a/PWGJE/TableProducer/derivedDataSelector.cxx b/PWGJE/TableProducer/derivedDataSelector.cxx index 8524fd32866..110056d73a1 100644 --- a/PWGJE/TableProducer/derivedDataSelector.cxx +++ b/PWGJE/TableProducer/derivedDataSelector.cxx @@ -60,9 +60,15 @@ struct JetDerivedDataSelector { Configurable thresholdChargedDplusJetPtMin{"thresholdChargedDplusJetPtMin", 0.0, "Minimum charged Dplus jet pt to accept event"}; Configurable thresholdChargedEventWiseSubtractedDplusJetPtMin{"thresholdChargedEventWiseSubtractedDplusJetPtMin", 0.0, "Minimum charged event-wise subtracted Dplus jet pt to accept event"}; Configurable thresholdChargedDplusMCPJetPtMin{"thresholdChargedDplusMCPJetPtMin", 0.0, "Minimum charged Dplus mcp jet pt to accept event"}; + Configurable thresholdChargedDstarJetPtMin{"thresholdChargedDstarJetPtMin", 0.0, "Minimum charged Dstar jet pt to accept event"}; + Configurable thresholdChargedEventWiseSubtractedDstarJetPtMin{"thresholdChargedEventWiseSubtractedDstarJetPtMin", 0.0, "Minimum charged event-wise subtracted Dstar jet pt to accept event"}; + Configurable thresholdChargedDstarMCPJetPtMin{"thresholdChargedDstarMCPJetPtMin", 0.0, "Minimum charged Dstar mcp jet pt to accept event"}; Configurable thresholdChargedLcJetPtMin{"thresholdChargedLcJetPtMin", 0.0, "Minimum charged Lc jet pt to accept event"}; Configurable thresholdChargedEventWiseSubtractedLcJetPtMin{"thresholdChargedEventWiseSubtractedLcJetPtMin", 0.0, "Minimum charged event-wise subtracted Lc jet pt to accept event"}; Configurable thresholdChargedLcMCPJetPtMin{"thresholdChargedLcMCPJetPtMin", 0.0, "Minimum charged Lc mcp jet pt to accept event"}; + Configurable thresholdChargedB0JetPtMin{"thresholdChargedB0JetPtMin", 0.0, "Minimum charged B0 jet pt to accept event"}; + Configurable thresholdChargedEventWiseSubtractedB0JetPtMin{"thresholdChargedEventWiseSubtractedB0JetPtMin", 0.0, "Minimum charged event-wise subtracted B0 jet pt to accept event"}; + Configurable thresholdChargedB0MCPJetPtMin{"thresholdChargedB0MCPJetPtMin", 0.0, "Minimum charged B0 mcp jet pt to accept event"}; Configurable thresholdChargedBplusJetPtMin{"thresholdChargedBplusJetPtMin", 0.0, "Minimum charged Bplus jet pt to accept event"}; Configurable thresholdChargedEventWiseSubtractedBplusJetPtMin{"thresholdChargedEventWiseSubtractedBplusJetPtMin", 0.0, "Minimum charged event-wise subtracted Bplus jet pt to accept event"}; Configurable thresholdChargedBplusMCPJetPtMin{"thresholdChargedBplusMCPJetPtMin", 0.0, "Minimum charged Bplus mcp jet pt to accept event"}; @@ -212,12 +218,24 @@ struct JetDerivedDataSelector { selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedDplusJetPtMin; } else if constexpr (std::is_same_v, aod::DplusChargedMCParticleLevelJets>) { selectionObjectPtMin = config.thresholdChargedDplusMCPJetPtMin; + } else if constexpr (std::is_same_v, aod::DstarChargedJets> || std::is_same_v, aod::DstarChargedMCDetectorLevelJets>) { + selectionObjectPtMin = config.thresholdChargedDstarJetPtMin; + } else if constexpr (std::is_same_v, aod::DstarChargedEventWiseSubtractedJets> || std::is_same_v, aod::DstarChargedMCDetectorLevelEventWiseSubtractedJets>) { + selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedDstarJetPtMin; + } else if constexpr (std::is_same_v, aod::DstarChargedMCParticleLevelJets>) { + selectionObjectPtMin = config.thresholdChargedDstarMCPJetPtMin; } else if constexpr (std::is_same_v, aod::LcChargedJets> || std::is_same_v, aod::LcChargedMCDetectorLevelJets>) { selectionObjectPtMin = config.thresholdChargedLcJetPtMin; } else if constexpr (std::is_same_v, aod::LcChargedEventWiseSubtractedJets> || std::is_same_v, aod::LcChargedMCDetectorLevelEventWiseSubtractedJets>) { selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedLcJetPtMin; } else if constexpr (std::is_same_v, aod::LcChargedMCParticleLevelJets>) { selectionObjectPtMin = config.thresholdChargedLcMCPJetPtMin; + } else if constexpr (std::is_same_v, aod::B0ChargedJets> || std::is_same_v, aod::B0ChargedMCDetectorLevelJets>) { + selectionObjectPtMin = config.thresholdChargedB0JetPtMin; + } else if constexpr (std::is_same_v, aod::B0ChargedEventWiseSubtractedJets> || std::is_same_v, aod::B0ChargedMCDetectorLevelEventWiseSubtractedJets>) { + selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedB0JetPtMin; + } else if constexpr (std::is_same_v, aod::B0ChargedMCParticleLevelJets>) { + selectionObjectPtMin = config.thresholdChargedB0MCPJetPtMin; } else if constexpr (std::is_same_v, aod::BplusChargedJets> || std::is_same_v, aod::BplusChargedMCDetectorLevelJets>) { selectionObjectPtMin = config.thresholdChargedBplusJetPtMin; } else if constexpr (std::is_same_v, aod::BplusChargedEventWiseSubtractedJets> || std::is_same_v, aod::BplusChargedMCDetectorLevelEventWiseSubtractedJets>) { @@ -257,7 +275,7 @@ struct JetDerivedDataSelector { } } if (isTriggerObject) { - if constexpr (std::is_same_v, aod::ChargedMCParticleLevelJets> || std::is_same_v, aod::NeutralMCParticleLevelJets> || std::is_same_v, aod::FullMCParticleLevelJets> || std::is_same_v, aod::D0ChargedMCParticleLevelJets> || std::is_same_v, aod::DplusChargedMCParticleLevelJets> || std::is_same_v, aod::LcChargedMCParticleLevelJets> || std::is_same_v, aod::BplusChargedMCParticleLevelJets> || std::is_same_v, aod::DielectronChargedMCParticleLevelJets>) { + if constexpr (std::is_same_v, aod::ChargedMCParticleLevelJets> || std::is_same_v, aod::NeutralMCParticleLevelJets> || std::is_same_v, aod::FullMCParticleLevelJets> || std::is_same_v, aod::D0ChargedMCParticleLevelJets> || std::is_same_v, aod::DplusChargedMCParticleLevelJets> || std::is_same_v, aod::DstarChargedMCParticleLevelJets> || std::is_same_v, aod::LcChargedMCParticleLevelJets> || std::is_same_v, aod::B0ChargedMCParticleLevelJets> || std::is_same_v, aod::BplusChargedMCParticleLevelJets> || std::is_same_v, aod::DielectronChargedMCParticleLevelJets>) { if (selectionObject.mcCollisionId() >= 0) { McCollisionFlag[selectionObject.mcCollisionId()] = true; } @@ -296,11 +314,21 @@ struct JetDerivedDataSelector { PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDplusChargedMCDJets, "process Dplus charged mcd jets", false); PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDplusChargedMCDetectorLevelEventWiseSubtractedJets, "process Dplus event-wise subtracted charged mcd jets", false); PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDplusChargedMCPJets, "process Dplus charged mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDstarChargedJets, "process Dstar charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDstarChargedEventWiseSubtractedJets, "process Dstar event-wise subtracted charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDstarChargedMCDJets, "process Dstar charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDstarChargedMCDetectorLevelEventWiseSubtractedJets, "process Dstar event-wise subtracted charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDstarChargedMCPJets, "process Dstar charged mcp jets", false); PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingLcChargedJets, "process Lc charged jets", false); PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingLcChargedEventWiseSubtractedJets, "process Lc event-wise subtracted charged jets", false); PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingLcChargedMCDJets, "process Lc charged mcd jets", false); PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingLcChargedMCDetectorLevelEventWiseSubtractedJets, "process Lc event-wise subtracted charged mcd jets", false); PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingLcChargedMCPJets, "process Lc charged mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingB0ChargedJets, "process B0 charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingB0ChargedEventWiseSubtractedJets, "process B0 event-wise subtracted charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingB0ChargedMCDJets, "process B0 charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingB0ChargedMCDetectorLevelEventWiseSubtractedJets, "process B0 event-wise subtracted charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingB0ChargedMCPJets, "process B0 charged mcp jets", false); PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingBplusChargedJets, "process Bplus charged jets", false); PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingBplusChargedEventWiseSubtractedJets, "process Bplus event-wise subtracted charged jets", false); PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingBplusChargedMCDJets, "process Bplus charged mcd jets", false); diff --git a/PWGJE/TableProducer/derivedDataWriter.cxx b/PWGJE/TableProducer/derivedDataWriter.cxx index a1d2346fd7d..4c382f9abdd 100644 --- a/PWGJE/TableProducer/derivedDataWriter.cxx +++ b/PWGJE/TableProducer/derivedDataWriter.cxx @@ -82,99 +82,153 @@ struct JetDerivedDataWriter { Produces storedJClustersMatchedTracksTable; Produces storedJMcClustersLabelTable; - Produces storedD0CollisionsTable; - Produces storedD0CollisionIdsTable; - Produces storedD0sTable; - Produces storedD0ParsTable; - Produces storedD0ParExtrasTable; - Produces storedD0ParDaughtersDummyTable; - Produces storedD0SelsTable; - Produces storedD0MlsTable; - Produces storedD0MlDughtersDummyTable; - Produces storedD0McsTable; - Produces storedD0IdsTable; - Produces storedD0McCollisionsTable; - Produces storedD0McCollisionIdsTable; - Produces storedD0McCollisionsMatchingTable; - Produces storedD0ParticlesTable; - Produces storedD0ParticleIdsTable; - - Produces storedDplusCollisionsTable; - Produces storedDplusCollisionIdsTable; - Produces storedDplussTable; - Produces storedDplusParsTable; - Produces storedDplusParExtrasTable; - Produces storedDplusParDaughtersDummyTable; - Produces storedDplusSelsTable; - Produces storedDplusMlsTable; - Produces storedDplusMlDughtersDummyTable; - Produces storedDplusMcsTable; - Produces storedDplusIdsTable; - Produces storedDplusMcCollisionsTable; - Produces storedDplusMcCollisionIdsTable; - Produces storedDplusMcCollisionsMatchingTable; - Produces storedDplusParticlesTable; - Produces storedDplusParticleIdsTable; - - Produces storedLcCollisionsTable; - Produces storedLcCollisionIdsTable; - Produces storedLcsTable; - Produces storedLcParsTable; - Produces storedLcParExtrasTable; - Produces storedLcParDaughtersDummyTable; - Produces storedLcSelsTable; - Produces storedLcMlsTable; - Produces storedLcMlDughtersDummyTable; - Produces storedLcMcsTable; - Produces storedLcIdsTable; - Produces storedLcMcCollisionsTable; - Produces storedLcMcCollisionIdsTable; - Produces storedLcMcCollisionsMatchingTable; - Produces storedLcParticlesTable; - Produces storedLcParticleIdsTable; - - Produces storedBplusCollisionsTable; - Produces storedBplusCollisionIdsTable; - Produces storedBplussTable; - Produces storedBplusParsTable; - Produces storedBplusParExtrasTable; - Produces storedBplusParD0sTable; - Produces storedBplusSelsTable; - Produces storedBplusMlsTable; - Produces storedBplusMlD0sTable; - Produces storedBplusMcsTable; - Produces storedBplusIdsTable; - Produces storedBplusMcCollisionsTable; - Produces storedBplusMcCollisionIdsTable; - Produces storedBplusMcCollisionsMatchingTable; - Produces storedBplusParticlesTable; - Produces storedBplusParticleIdsTable; - - Produces storedDielectronCollisionsTable; - Produces storedDielectronCollisionIdsTable; - Produces storedDielectronsTable; - Produces storedDielectronIdsTable; - Produces storedDielectronMcCollisionsTable; - Produces storedDielectronMcCollisionIdsTable; - Produces storedDielectronMcRCollDummysTable; - Produces storedDielectronParticlesTable; - Produces storedDielectronParticleIdsTable; + struct : ProducesGroup { + Produces storedD0CollisionsTable; + Produces storedD0CollisionIdsTable; + Produces storedD0sTable; + Produces storedD0ParsTable; + Produces storedD0ParExtrasTable; + Produces storedD0ParDaughtersDummyTable; + Produces storedD0SelsTable; + Produces storedD0MlsTable; + Produces storedD0MlDughtersDummyTable; + Produces storedD0McsTable; + Produces storedD0IdsTable; + Produces storedD0McCollisionsTable; + Produces storedD0McCollisionIdsTable; + Produces storedD0McCollisionsMatchingTable; + Produces storedD0ParticlesTable; + Produces storedD0ParticleIdsTable; + } productsD0; + + struct : ProducesGroup { + Produces storedDplusCollisionsTable; + Produces storedDplusCollisionIdsTable; + Produces storedDplussTable; + Produces storedDplusParsTable; + Produces storedDplusParExtrasTable; + Produces storedDplusParDaughtersDummyTable; + Produces storedDplusSelsTable; + Produces storedDplusMlsTable; + Produces storedDplusMlDughtersDummyTable; + Produces storedDplusMcsTable; + Produces storedDplusIdsTable; + Produces storedDplusMcCollisionsTable; + Produces storedDplusMcCollisionIdsTable; + Produces storedDplusMcCollisionsMatchingTable; + Produces storedDplusParticlesTable; + Produces storedDplusParticleIdsTable; + } productsDplus; + + struct : ProducesGroup { + Produces storedDstarCollisionsTable; + Produces storedDstarCollisionIdsTable; + Produces storedDstarsTable; + Produces storedDstarParsTable; + Produces storedDstarParExtrasDummyTable; + Produces storedDstarParD0sTable; + Produces storedDstarSelsTable; + Produces storedDstarMlsTable; + Produces storedDstarMlDaughtersDummyTable; + Produces storedDstarMcsTable; + Produces storedDstarIdsTable; + Produces storedDstarMcCollisionsTable; + Produces storedDstarMcCollisionIdsTable; + Produces storedDstarMcCollisionsMatchingTable; + Produces storedDstarParticlesTable; + Produces storedDstarParticleIdsTable; + } productsDstar; + + struct : ProducesGroup { + Produces storedLcCollisionsTable; + Produces storedLcCollisionIdsTable; + Produces storedLcsTable; + Produces storedLcParsTable; + Produces storedLcParExtrasTable; + Produces storedLcParDaughtersDummyTable; + Produces storedLcSelsTable; + Produces storedLcMlsTable; + Produces storedLcMlDughtersDummyTable; + Produces storedLcMcsTable; + Produces storedLcIdsTable; + Produces storedLcMcCollisionsTable; + Produces storedLcMcCollisionIdsTable; + Produces storedLcMcCollisionsMatchingTable; + Produces storedLcParticlesTable; + Produces storedLcParticleIdsTable; + } productsLc; + + struct : ProducesGroup { + Produces storedB0CollisionsTable; + Produces storedB0CollisionIdsTable; + Produces storedB0sTable; + Produces storedB0ParsTable; + Produces storedB0ParExtrasTable; + Produces storedB0ParDplussTable; + Produces storedB0SelsTable; + Produces storedB0MlsTable; + Produces storedB0MlDplussTable; + Produces storedB0McsTable; + Produces storedB0IdsTable; + Produces storedB0McCollisionsTable; + Produces storedB0McCollisionIdsTable; + Produces storedB0McCollisionsMatchingTable; + Produces storedB0ParticlesTable; + Produces storedB0ParticleIdsTable; + } productsB0; + + struct : ProducesGroup { + Produces storedBplusCollisionsTable; + Produces storedBplusCollisionIdsTable; + Produces storedBplussTable; + Produces storedBplusParsTable; + Produces storedBplusParExtrasTable; + Produces storedBplusParD0sTable; + Produces storedBplusSelsTable; + Produces storedBplusMlsTable; + Produces storedBplusMlD0sTable; + Produces storedBplusMcsTable; + Produces storedBplusIdsTable; + Produces storedBplusMcCollisionsTable; + Produces storedBplusMcCollisionIdsTable; + Produces storedBplusMcCollisionsMatchingTable; + Produces storedBplusParticlesTable; + Produces storedBplusParticleIdsTable; + } productsBplus; + + struct : ProducesGroup { + Produces storedDielectronCollisionsTable; + Produces storedDielectronCollisionIdsTable; + Produces storedDielectronsTable; + Produces storedDielectronIdsTable; + Produces storedDielectronMcCollisionsTable; + Produces storedDielectronMcCollisionIdsTable; + Produces storedDielectronMcRCollDummysTable; + Produces storedDielectronParticlesTable; + Produces storedDielectronParticleIdsTable; + } productsDielectron; + } products; - Preslice> TracksPerCollisionData = aod::jtrack::collisionId; - - Preslice> ParticlesPerMcCollision = aod::jmcparticle::mcCollisionId; - Preslice> TracksPerCollision = aod::jtrack::collisionId; - Preslice D0McCollisionsPerMcCollision = aod::jcandidateindices::mcCollisionId; - Preslice DplusMcCollisionsPerMcCollision = aod::jcandidateindices::mcCollisionId; - Preslice LcMcCollisionsPerMcCollision = aod::jcandidateindices::mcCollisionId; - Preslice BplusMcCollisionsPerMcCollision = aod::jcandidateindices::mcCollisionId; - Preslice DielectronMcCollisionsPerMcCollision = aod::jcandidateindices::mcCollisionId; - Preslice D0ParticlesPerMcCollision = aod::jcandidateindices::mcCollisionId; - Preslice DplusParticlesPerMcCollision = aod::jcandidateindices::mcCollisionId; - Preslice LcParticlesPerMcCollision = aod::jcandidateindices::mcCollisionId; - Preslice BplusParticlesPerMcCollision = aod::jcandidateindices::mcCollisionId; - PresliceUnsorted EMCTrackPerTrack = aod::jemctrack::trackId; + struct : PresliceGroup { + Preslice> TracksPerCollision = aod::jtrack::collisionId; + + Preslice> ParticlesPerMcCollision = aod::jmcparticle::mcCollisionId; + Preslice D0McCollisionsPerMcCollision = aod::jcandidateindices::mcCollisionId; + Preslice DplusMcCollisionsPerMcCollision = aod::jcandidateindices::mcCollisionId; + Preslice DstarMcCollisionsPerMcCollision = aod::jcandidateindices::mcCollisionId; + Preslice LcMcCollisionsPerMcCollision = aod::jcandidateindices::mcCollisionId; + Preslice B0McCollisionsPerMcCollision = aod::jcandidateindices::mcCollisionId; + Preslice BplusMcCollisionsPerMcCollision = aod::jcandidateindices::mcCollisionId; + Preslice DielectronMcCollisionsPerMcCollision = aod::jcandidateindices::mcCollisionId; + Preslice D0ParticlesPerMcCollision = aod::jcandidateindices::mcCollisionId; + Preslice DplusParticlesPerMcCollision = aod::jcandidateindices::mcCollisionId; + Preslice DstarParticlesPerMcCollision = aod::jcandidateindices::mcCollisionId; + Preslice LcParticlesPerMcCollision = aod::jcandidateindices::mcCollisionId; + Preslice B0ParticlesPerMcCollision = aod::jcandidateindices::mcCollisionId; + Preslice BplusParticlesPerMcCollision = aod::jcandidateindices::mcCollisionId; + PresliceUnsorted EMCTrackPerTrack = aod::jemctrack::trackId; + } preslices; uint32_t precisionPositionMask; uint32_t precisionMomentumMask; @@ -198,62 +252,93 @@ struct JetDerivedDataWriter { } template - void storeD0(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsD0 const& D0Collisions, T const& D0s) + void storeD0(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsD0 const& D0Collisions, T const& D0Candidates) { if (collision.isCollisionSelected()) { for (const auto& D0Collision : D0Collisions) { // should only ever be one - jethfutilities::fillHFCollisionTable(D0Collision, products.storedD0CollisionsTable); - products.storedD0CollisionIdsTable(collisionMapping[collision.globalIndex()]); + jethfutilities::fillHFCollisionTable(D0Collision, products.productsD0.storedD0CollisionsTable); + products.productsD0.storedD0CollisionIdsTable(collisionMapping[collision.globalIndex()]); } - for (const auto& D0 : D0s) { - jethfutilities::fillHFCandidateTable(D0, products.storedD0CollisionsTable.lastIndex(), products.storedD0sTable, products.storedD0ParsTable, products.storedD0ParExtrasTable, products.storedD0ParDaughtersDummyTable, products.storedD0SelsTable, products.storedD0MlsTable, products.storedD0MlDughtersDummyTable, products.storedD0McsTable); - products.storedD0IdsTable(collisionMapping[collision.globalIndex()], trackMapping[D0.prong0Id()], trackMapping[D0.prong1Id()]); + for (const auto& D0Candidate : D0Candidates) { + jethfutilities::fillHFCandidateTable(D0Candidate, products.productsD0.storedD0CollisionsTable.lastIndex(), products.productsD0.storedD0sTable, products.productsD0.storedD0ParsTable, products.productsD0.storedD0ParExtrasTable, products.productsD0.storedD0ParDaughtersDummyTable, products.productsD0.storedD0SelsTable, products.productsD0.storedD0MlsTable, products.productsD0.storedD0MlDughtersDummyTable, products.productsD0.storedD0McsTable); + products.productsD0.storedD0IdsTable(collisionMapping[collision.globalIndex()], trackMapping[D0Candidate.prong0Id()], trackMapping[D0Candidate.prong1Id()]); } } } template - void storeDplus(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsDplus const& DplusCollisions, T const& Dpluss) + void storeDplus(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsDplus const& DplusCollisions, T const& DplusCandidates) { if (collision.isCollisionSelected()) { for (const auto& DplusCollision : DplusCollisions) { // should only ever be one - jethfutilities::fillHFCollisionTable(DplusCollision, products.storedDplusCollisionsTable); - products.storedDplusCollisionIdsTable(collisionMapping[collision.globalIndex()]); + jethfutilities::fillHFCollisionTable(DplusCollision, products.productsDplus.storedDplusCollisionsTable); + products.productsDplus.storedDplusCollisionIdsTable(collisionMapping[collision.globalIndex()]); + } + for (const auto& DplusCandidate : DplusCandidates) { + jethfutilities::fillHFCandidateTable(DplusCandidate, products.productsDplus.storedDplusCollisionsTable.lastIndex(), products.productsDplus.storedDplussTable, products.productsDplus.storedDplusParsTable, products.productsDplus.storedDplusParExtrasTable, products.productsDplus.storedDplusParDaughtersDummyTable, products.productsDplus.storedDplusSelsTable, products.productsDplus.storedDplusMlsTable, products.productsDplus.storedDplusMlDughtersDummyTable, products.productsDplus.storedDplusMcsTable); + products.productsDplus.storedDplusIdsTable(collisionMapping[collision.globalIndex()], trackMapping[DplusCandidate.prong0Id()], trackMapping[DplusCandidate.prong1Id()], trackMapping[DplusCandidate.prong2Id()]); + } + } + } + + template + void storeDstar(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsDstar const& DstarCollisions, T const& DstarCandidates) + { + + if (collision.isCollisionSelected()) { + for (const auto& DstarCollision : DstarCollisions) { // should only ever be one + jethfutilities::fillHFCollisionTable(DstarCollision, products.productsDstar.storedDstarCollisionsTable); + products.productsDstar.storedDstarCollisionIdsTable(collisionMapping[collision.globalIndex()]); } - for (const auto& Dplus : Dpluss) { - jethfutilities::fillHFCandidateTable(Dplus, products.storedDplusCollisionsTable.lastIndex(), products.storedDplussTable, products.storedDplusParsTable, products.storedDplusParExtrasTable, products.storedDplusParDaughtersDummyTable, products.storedDplusSelsTable, products.storedDplusMlsTable, products.storedDplusMlDughtersDummyTable, products.storedDplusMcsTable); - products.storedDplusIdsTable(collisionMapping[collision.globalIndex()], trackMapping[Dplus.prong0Id()], trackMapping[Dplus.prong1Id()], trackMapping[Dplus.prong2Id()]); + for (const auto& DstarCandidate : DstarCandidates) { + jethfutilities::fillHFCandidateTable(DstarCandidate, products.productsDstar.storedDstarCollisionsTable.lastIndex(), products.productsDstar.storedDstarsTable, products.productsDstar.storedDstarParsTable, products.productsDstar.storedDstarParExtrasDummyTable, products.productsDstar.storedDstarParD0sTable, products.productsDstar.storedDstarSelsTable, products.productsDstar.storedDstarMlsTable, products.productsDstar.storedDstarMlDaughtersDummyTable, products.productsDstar.storedDstarMcsTable); + products.productsDstar.storedDstarIdsTable(collisionMapping[collision.globalIndex()], trackMapping[DstarCandidate.prong0Id()], trackMapping[DstarCandidate.prong1Id()], trackMapping[DstarCandidate.prong2Id()]); } } } template - void storeLc(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsLc const& LcCollisions, T const& Lcs) + void storeLc(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsLc const& LcCollisions, T const& LcCandidates) { if (collision.isCollisionSelected()) { for (const auto& LcCollision : LcCollisions) { // should only ever be one - jethfutilities::fillHFCollisionTable(LcCollision, products.storedLcCollisionsTable); - products.storedLcCollisionIdsTable(collisionMapping[collision.globalIndex()]); + jethfutilities::fillHFCollisionTable(LcCollision, products.productsLc.storedLcCollisionsTable); + products.productsLc.storedLcCollisionIdsTable(collisionMapping[collision.globalIndex()]); + } + for (const auto& LcCandidate : LcCandidates) { + jethfutilities::fillHFCandidateTable(LcCandidate, products.productsLc.storedLcCollisionsTable.lastIndex(), products.productsLc.storedLcsTable, products.productsLc.storedLcParsTable, products.productsLc.storedLcParExtrasTable, products.productsLc.storedLcParDaughtersDummyTable, products.productsLc.storedLcSelsTable, products.productsLc.storedLcMlsTable, products.productsLc.storedLcMlDughtersDummyTable, products.productsLc.storedLcMcsTable); + products.productsLc.storedLcIdsTable(collisionMapping[collision.globalIndex()], trackMapping[LcCandidate.prong0Id()], trackMapping[LcCandidate.prong1Id()], trackMapping[LcCandidate.prong2Id()]); + } + } + } + + template + void storeB0(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsB0 const& B0Collisions, T const& B0Candidates) + { + if (collision.isCollisionSelected()) { + for (const auto& B0Collision : B0Collisions) { // should only ever be one + jethfutilities::fillHFCollisionTable(B0Collision, products.productsB0.storedB0CollisionsTable); + products.productsB0.storedB0CollisionIdsTable(collisionMapping[collision.globalIndex()]); } - for (const auto& Lc : Lcs) { - jethfutilities::fillHFCandidateTable(Lc, products.storedLcCollisionsTable.lastIndex(), products.storedLcsTable, products.storedLcParsTable, products.storedLcParExtrasTable, products.storedLcParDaughtersDummyTable, products.storedLcSelsTable, products.storedLcMlsTable, products.storedLcMlDughtersDummyTable, products.storedLcMcsTable); - products.storedLcIdsTable(collisionMapping[collision.globalIndex()], trackMapping[Lc.prong0Id()], trackMapping[Lc.prong1Id()], trackMapping[Lc.prong2Id()]); + for (const auto& B0Candidate : B0Candidates) { + jethfutilities::fillHFCandidateTable(B0Candidate, products.productsB0.storedB0CollisionsTable.lastIndex(), products.productsB0.storedB0sTable, products.productsB0.storedB0ParsTable, products.productsB0.storedB0ParExtrasTable, products.productsB0.storedB0ParDplussTable, products.productsB0.storedB0SelsTable, products.productsB0.storedB0MlsTable, products.productsB0.storedB0MlDplussTable, products.productsB0.storedB0McsTable); + products.productsB0.storedB0IdsTable(collisionMapping[collision.globalIndex()], trackMapping[B0Candidate.prong0Id()], trackMapping[B0Candidate.prong1Id()], trackMapping[B0Candidate.prong2Id()], trackMapping[B0Candidate.prong3Id()]); } } } template - void storeBplus(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsBplus const& BplusCollisions, T const& Bpluss) + void storeBplus(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsBplus const& BplusCollisions, T const& BplusCandidates) { if (collision.isCollisionSelected()) { for (const auto& BplusCollision : BplusCollisions) { // should only ever be one - jethfutilities::fillHFCollisionTable(BplusCollision, products.storedBplusCollisionsTable); - products.storedBplusCollisionIdsTable(collisionMapping[collision.globalIndex()]); + jethfutilities::fillHFCollisionTable(BplusCollision, products.productsBplus.storedBplusCollisionsTable); + products.productsBplus.storedBplusCollisionIdsTable(collisionMapping[collision.globalIndex()]); } - for (const auto& Bplus : Bpluss) { - jethfutilities::fillHFCandidateTable(Bplus, products.storedBplusCollisionsTable.lastIndex(), products.storedBplussTable, products.storedBplusParsTable, products.storedBplusParExtrasTable, products.storedBplusParD0sTable, products.storedBplusSelsTable, products.storedBplusMlsTable, products.storedBplusMlD0sTable, products.storedBplusMcsTable); - products.storedBplusIdsTable(collisionMapping[collision.globalIndex()], trackMapping[Bplus.prong0Id()], trackMapping[Bplus.prong1Id()], trackMapping[Bplus.prong2Id()]); + for (const auto& BplusCandidate : BplusCandidates) { + jethfutilities::fillHFCandidateTable(BplusCandidate, products.productsBplus.storedBplusCollisionsTable.lastIndex(), products.productsBplus.storedBplussTable, products.productsBplus.storedBplusParsTable, products.productsBplus.storedBplusParExtrasTable, products.productsBplus.storedBplusParD0sTable, products.productsBplus.storedBplusSelsTable, products.productsBplus.storedBplusMlsTable, products.productsBplus.storedBplusMlD0sTable, products.productsBplus.storedBplusMcsTable); + products.productsBplus.storedBplusIdsTable(collisionMapping[collision.globalIndex()], trackMapping[BplusCandidate.prong0Id()], trackMapping[BplusCandidate.prong1Id()], trackMapping[BplusCandidate.prong2Id()]); } } } @@ -271,7 +356,9 @@ struct JetDerivedDataWriter { std::vector particleMapping; std::vector d0McCollisionMapping; std::vector dplusMcCollisionMapping; + std::vector dstarMcCollisionMapping; std::vector lcMcCollisionMapping; + std::vector b0McCollisionMapping; std::vector bplusMcCollisionMapping; std::vector dielectronMcCollisionMapping; @@ -322,7 +409,7 @@ struct JetDerivedDataWriter { for (auto const& collision : collisions) { if (collision.isCollisionSelected()) { - const auto tracksPerCollision = tracks.sliceBy(TracksPerCollisionData, collision.globalIndex()); + const auto tracksPerCollision = tracks.sliceBy(preslices.TracksPerCollision, collision.globalIndex()); for (const auto& track : tracksPerCollision) { if (!trackSelection(track)) { // skips tracks that pass no selections. This might cause a problem with tracks matched with clusters. We should generate a track selection purely for cluster matched tracks so that they are kept. This includes also the track pT selction. continue; @@ -351,7 +438,7 @@ struct JetDerivedDataWriter { std::vector clusterStoredJTrackIDs; for (const auto& clusterTrack : cluster.matchedTracks_as()) { clusterStoredJTrackIDs.push_back(trackMapping[clusterTrack.globalIndex()]); - auto emcTracksPerTrack = emcTracks.sliceBy(EMCTrackPerTrack, clusterTrack.globalIndex()); + auto emcTracksPerTrack = emcTracks.sliceBy(preslices.EMCTrackPerTrack, clusterTrack.globalIndex()); auto emcTrackPerTrack = emcTracksPerTrack.iteratorAt(0); products.storedJTracksEMCalTable(trackMapping[clusterTrack.globalIndex()], emcTrackPerTrack.etaEmcal(), emcTrackPerTrack.phiEmcal()); } @@ -363,64 +450,88 @@ struct JetDerivedDataWriter { //!!!!!!!!!! need to add the hadronic corrected energy and delete the new dummy process function - void processD0Data(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsD0 const& D0Collisions, aod::CandidatesD0Data const& D0s) + void processD0Data(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsD0 const& D0Collisions, aod::CandidatesD0Data const& D0Candidates) { - storeD0(collision, tracks, D0Collisions, D0s); + storeD0(collision, tracks, D0Collisions, D0Candidates); } PROCESS_SWITCH(JetDerivedDataWriter, processD0Data, "write out data output tables for D0", false); - void processD0MCD(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsD0 const& D0Collisions, aod::CandidatesD0MCD const& D0s) + void processD0MCD(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsD0 const& D0Collisions, aod::CandidatesD0MCD const& D0Candidates) { - storeD0(collision, tracks, D0Collisions, D0s); + storeD0(collision, tracks, D0Collisions, D0Candidates); } PROCESS_SWITCH(JetDerivedDataWriter, processD0MCD, "write out mcd output tables for D0", false); - void processDplusData(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsDplus const& DplusCollisions, aod::CandidatesDplusData const& Dpluss) + void processDplusData(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsDplus const& DplusCollisions, aod::CandidatesDplusData const& DplusCandidates) { - storeDplus(collision, tracks, DplusCollisions, Dpluss); + storeDplus(collision, tracks, DplusCollisions, DplusCandidates); } PROCESS_SWITCH(JetDerivedDataWriter, processDplusData, "write out data output tables for Dplus", false); - void processDplusMCD(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsDplus const& DplusCollisions, aod::CandidatesDplusMCD const& Dpluss) + void processDplusMCD(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsDplus const& DplusCollisions, aod::CandidatesDplusMCD const& DplusCandidates) { - storeDplus(collision, tracks, DplusCollisions, Dpluss); + storeDplus(collision, tracks, DplusCollisions, DplusCandidates); } PROCESS_SWITCH(JetDerivedDataWriter, processDplusMCD, "write out mcd output tables for Dplus", false); - void processLcData(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsLc const& LcCollisions, aod::CandidatesLcData const& Lcs) + void processDstarData(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsDstar const& DstarCollisions, aod::CandidatesDstarData const& DstarCandidates) + { + storeDstar(collision, tracks, DstarCollisions, DstarCandidates); + } + PROCESS_SWITCH(JetDerivedDataWriter, processDstarData, "write out data output tables for Dstar", false); + + void processDstarMCD(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsDstar const& DstarCollisions, aod::CandidatesDstarMCD const& DstarCandidates) + { + storeDstar(collision, tracks, DstarCollisions, DstarCandidates); + } + PROCESS_SWITCH(JetDerivedDataWriter, processDstarMCD, "write out mcd output tables for Dstar", false); + + void processLcData(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsLc const& LcCollisions, aod::CandidatesLcData const& LcCandidates) { - storeLc(collision, tracks, LcCollisions, Lcs); + storeLc(collision, tracks, LcCollisions, LcCandidates); } PROCESS_SWITCH(JetDerivedDataWriter, processLcData, "write out data output tables for Lc", false); - void processLcMCD(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsLc const& LcCollisions, aod::CandidatesLcMCD const& Lcs) + void processLcMCD(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsLc const& LcCollisions, aod::CandidatesLcMCD const& LcCandidates) { - storeLc(collision, tracks, LcCollisions, Lcs); + storeLc(collision, tracks, LcCollisions, LcCandidates); } PROCESS_SWITCH(JetDerivedDataWriter, processLcMCD, "write out mcd output tables for Lc", false); - void processBplusData(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsBplus const& BplusCollisions, aod::CandidatesBplusData const& Bpluss) + void processB0Data(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsB0 const& B0Collisions, aod::CandidatesB0Data const& B0Candidates) { - storeBplus(collision, tracks, BplusCollisions, Bpluss); + storeB0(collision, tracks, B0Collisions, B0Candidates); + } + PROCESS_SWITCH(JetDerivedDataWriter, processB0Data, "write out data output tables for B0", false); + + void processB0MCD(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsB0 const& B0Collisions, aod::CandidatesB0MCD const& B0Candidates) + { + storeB0(collision, tracks, B0Collisions, B0Candidates); + } + PROCESS_SWITCH(JetDerivedDataWriter, processB0MCD, "write out mcd output tables for B0", false); + + void processBplusData(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsBplus const& BplusCollisions, aod::CandidatesBplusData const& BplusCandidates) + { + storeBplus(collision, tracks, BplusCollisions, BplusCandidates); } PROCESS_SWITCH(JetDerivedDataWriter, processBplusData, "write out data output tables for bplus", false); - void processBplusMCD(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsBplus const& BplusCollisions, aod::CandidatesBplusMCD const& Bpluss) + void processBplusMCD(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsBplus const& BplusCollisions, aod::CandidatesBplusMCD const& BplusCandidates) { - storeBplus(collision, tracks, BplusCollisions, Bpluss); + storeBplus(collision, tracks, BplusCollisions, BplusCandidates); } PROCESS_SWITCH(JetDerivedDataWriter, processBplusMCD, "write out mcd output tables for bplus", false); - void processDielectron(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsDielectron const& DielectronCollisions, aod::CandidatesDielectronData const& Dielectrons) + void processDielectron(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsDielectron const& DielectronCollisions, aod::CandidatesDielectronData const& DielectronCandidates) { if (collision.isCollisionSelected()) { for (const auto& DielectronCollision : DielectronCollisions) { // should only ever be one - jetdqutilities::fillDielectronCollisionTable(DielectronCollision, products.storedDielectronCollisionsTable); - products.storedDielectronCollisionIdsTable(collisionMapping[collision.globalIndex()]); + jetdqutilities::fillDielectronCollisionTable(DielectronCollision, products.productsDielectron.storedDielectronCollisionsTable); + products.productsDielectron.storedDielectronCollisionIdsTable(collisionMapping[collision.globalIndex()]); } - for (const auto& Dielectron : Dielectrons) { - jetdqutilities::fillDielectronCandidateTable(Dielectron, products.storedDielectronCollisionsTable.lastIndex(), products.storedDielectronsTable); - products.storedDielectronIdsTable(collisionMapping[collision.globalIndex()], trackMapping[Dielectron.prong0Id()], trackMapping[Dielectron.prong1Id()]); + for (const auto& DielectronCandidate : DielectronCandidates) { + jetdqutilities::fillDielectronCandidateTable(DielectronCandidate, products.productsDielectron.storedDielectronCollisionsTable.lastIndex(), products.productsDielectron.storedDielectronsTable); + products.productsDielectron.storedDielectronIdsTable(collisionMapping[collision.globalIndex()], trackMapping[DielectronCandidate.prong0Id()], trackMapping[DielectronCandidate.prong1Id()]); } } } @@ -448,7 +559,7 @@ struct JetDerivedDataWriter { for (auto const& mcCollision : mcCollisions) { if (mcCollision.isMcCollisionSelected()) { - const auto particlesPerMcCollision = particles.sliceBy(ParticlesPerMcCollision, mcCollision.globalIndex()); + const auto particlesPerMcCollision = particles.sliceBy(preslices.ParticlesPerMcCollision, mcCollision.globalIndex()); for (auto particle : particlesPerMcCollision) { particleMapping[particle.globalIndex()] = particleTableIndex; @@ -488,16 +599,16 @@ struct JetDerivedDataWriter { d0McCollisionMapping.resize(D0McCollisions.size(), -1); for (auto const& mcCollision : mcCollisions) { if (mcCollision.isMcCollisionSelected()) { - const auto d0McCollisionsPerMcCollision = D0McCollisions.sliceBy(D0McCollisionsPerMcCollision, mcCollision.globalIndex()); + const auto d0McCollisionsPerMcCollision = D0McCollisions.sliceBy(preslices.D0McCollisionsPerMcCollision, mcCollision.globalIndex()); for (const auto& d0McCollisionPerMcCollision : d0McCollisionsPerMcCollision) { - jethfutilities::fillHFMcCollisionTable(d0McCollisionPerMcCollision, products.storedD0McCollisionsTable); - products.storedD0McCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); - d0McCollisionMapping[d0McCollisionPerMcCollision.globalIndex()] = products.storedD0McCollisionsTable.lastIndex(); + jethfutilities::fillHFMcCollisionTable(d0McCollisionPerMcCollision, products.productsD0.storedD0McCollisionsTable); + products.productsD0.storedD0McCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); + d0McCollisionMapping[d0McCollisionPerMcCollision.globalIndex()] = products.productsD0.storedD0McCollisionsTable.lastIndex(); } - const auto d0ParticlesPerMcCollision = D0Particles.sliceBy(D0ParticlesPerMcCollision, mcCollision.globalIndex()); + const auto d0ParticlesPerMcCollision = D0Particles.sliceBy(preslices.D0ParticlesPerMcCollision, mcCollision.globalIndex()); for (const auto& D0Particle : d0ParticlesPerMcCollision) { - jethfutilities::fillHFCandidateMcTable(D0Particle, products.storedD0McCollisionsTable.lastIndex(), products.storedD0ParticlesTable); - products.storedD0ParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[D0Particle.mcParticleId()]); + jethfutilities::fillHFCandidateMcTable(D0Particle, products.productsD0.storedD0McCollisionsTable.lastIndex(), products.productsD0.storedD0ParticlesTable); + products.productsD0.storedD0ParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[D0Particle.mcParticleId()]); } } } @@ -510,62 +621,104 @@ struct JetDerivedDataWriter { dplusMcCollisionMapping.resize(DplusMcCollisions.size(), -1); for (auto const& mcCollision : mcCollisions) { if (mcCollision.isMcCollisionSelected()) { - const auto dplusMcCollisionsPerMcCollision = DplusMcCollisions.sliceBy(DplusMcCollisionsPerMcCollision, mcCollision.globalIndex()); + const auto dplusMcCollisionsPerMcCollision = DplusMcCollisions.sliceBy(preslices.DplusMcCollisionsPerMcCollision, mcCollision.globalIndex()); for (const auto& dplusMcCollisionPerMcCollision : dplusMcCollisionsPerMcCollision) { // should only ever be one - jethfutilities::fillHFMcCollisionTable(dplusMcCollisionPerMcCollision, products.storedDplusMcCollisionsTable); - products.storedDplusMcCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); - dplusMcCollisionMapping[dplusMcCollisionPerMcCollision.globalIndex()] = products.storedDplusMcCollisionsTable.lastIndex(); + jethfutilities::fillHFMcCollisionTable(dplusMcCollisionPerMcCollision, products.productsDplus.storedDplusMcCollisionsTable); + products.productsDplus.storedDplusMcCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); + dplusMcCollisionMapping[dplusMcCollisionPerMcCollision.globalIndex()] = products.productsDplus.storedDplusMcCollisionsTable.lastIndex(); } - const auto dplusParticlesPerMcCollision = DplusParticles.sliceBy(DplusParticlesPerMcCollision, mcCollision.globalIndex()); + const auto dplusParticlesPerMcCollision = DplusParticles.sliceBy(preslices.DplusParticlesPerMcCollision, mcCollision.globalIndex()); for (const auto& DplusParticle : dplusParticlesPerMcCollision) { - jethfutilities::fillHFCandidateMcTable(DplusParticle, products.storedDplusMcCollisionsTable.lastIndex(), products.storedDplusParticlesTable); - products.storedDplusParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[DplusParticle.mcParticleId()]); + jethfutilities::fillHFCandidateMcTable(DplusParticle, products.productsDplus.storedDplusMcCollisionsTable.lastIndex(), products.productsDplus.storedDplusParticlesTable); + products.productsDplus.storedDplusParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[DplusParticle.mcParticleId()]); } } } } - PROCESS_SWITCH(JetDerivedDataWriter, processDplusMCP, "write out Dplus mcp output tables", false); + void processDstarMCP(soa::Join const& mcCollisions, aod::McCollisionsDstar const& DstarMcCollisions, aod::CandidatesDstarMCP const& DstarParticles) + { + dstarMcCollisionMapping.clear(); + dstarMcCollisionMapping.resize(DstarMcCollisions.size(), -1); + for (auto const& mcCollision : mcCollisions) { + if (mcCollision.isMcCollisionSelected()) { + const auto dstarMcCollisionsPerMcCollision = DstarMcCollisions.sliceBy(preslices.DstarMcCollisionsPerMcCollision, mcCollision.globalIndex()); + for (const auto& dstarMcCollisionPerMcCollision : dstarMcCollisionsPerMcCollision) { + jethfutilities::fillHFMcCollisionTable(dstarMcCollisionPerMcCollision, products.productsDstar.storedDstarMcCollisionsTable); + products.productsDstar.storedDstarMcCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); + dstarMcCollisionMapping[dstarMcCollisionPerMcCollision.globalIndex()] = products.productsDstar.storedDstarMcCollisionsTable.lastIndex(); + } + const auto dstarParticlesPerMcCollision = DstarParticles.sliceBy(preslices.DstarParticlesPerMcCollision, mcCollision.globalIndex()); + for (const auto& DstarParticle : dstarParticlesPerMcCollision) { + jethfutilities::fillHFCandidateMcTable(DstarParticle, products.productsDstar.storedDstarMcCollisionsTable.lastIndex(), products.productsDstar.storedDstarParticlesTable); + products.productsDstar.storedDstarParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[DstarParticle.mcParticleId()]); + } + } + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processDstarMCP, "write out D* mcp output tables", false); + void processLcMCP(soa::Join const& mcCollisions, aod::McCollisionsLc const& LcMcCollisions, aod::CandidatesLcMCP const& LcParticles) { lcMcCollisionMapping.clear(); lcMcCollisionMapping.resize(LcMcCollisions.size(), -1); for (auto const& mcCollision : mcCollisions) { if (mcCollision.isMcCollisionSelected()) { - const auto lcMcCollisionsPerMcCollision = LcMcCollisions.sliceBy(LcMcCollisionsPerMcCollision, mcCollision.globalIndex()); + const auto lcMcCollisionsPerMcCollision = LcMcCollisions.sliceBy(preslices.LcMcCollisionsPerMcCollision, mcCollision.globalIndex()); for (const auto& lcMcCollisionPerMcCollision : lcMcCollisionsPerMcCollision) { // should only ever be one - jethfutilities::fillHFMcCollisionTable(lcMcCollisionPerMcCollision, products.storedLcMcCollisionsTable); - products.storedLcMcCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); - lcMcCollisionMapping[lcMcCollisionPerMcCollision.globalIndex()] = products.storedLcMcCollisionsTable.lastIndex(); + jethfutilities::fillHFMcCollisionTable(lcMcCollisionPerMcCollision, products.productsLc.storedLcMcCollisionsTable); + products.productsLc.storedLcMcCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); + lcMcCollisionMapping[lcMcCollisionPerMcCollision.globalIndex()] = products.productsLc.storedLcMcCollisionsTable.lastIndex(); } - const auto lcParticlesPerMcCollision = LcParticles.sliceBy(LcParticlesPerMcCollision, mcCollision.globalIndex()); + const auto lcParticlesPerMcCollision = LcParticles.sliceBy(preslices.LcParticlesPerMcCollision, mcCollision.globalIndex()); for (const auto& LcParticle : lcParticlesPerMcCollision) { - jethfutilities::fillHFCandidateMcTable(LcParticle, products.storedLcMcCollisionsTable.lastIndex(), products.storedLcParticlesTable); - products.storedLcParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[LcParticle.mcParticleId()]); + jethfutilities::fillHFCandidateMcTable(LcParticle, products.productsLc.storedLcMcCollisionsTable.lastIndex(), products.productsLc.storedLcParticlesTable); + products.productsLc.storedLcParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[LcParticle.mcParticleId()]); } } } } - PROCESS_SWITCH(JetDerivedDataWriter, processLcMCP, "write out Lc mcp output tables", false); + void processB0MCP(soa::Join const& mcCollisions, aod::McCollisionsB0 const& B0McCollisions, aod::CandidatesB0MCP const& B0Particles) + { + b0McCollisionMapping.clear(); + b0McCollisionMapping.resize(B0McCollisions.size(), -1); + for (auto const& mcCollision : mcCollisions) { + if (mcCollision.isMcCollisionSelected()) { + const auto b0McCollisionsPerMcCollision = B0McCollisions.sliceBy(preslices.B0McCollisionsPerMcCollision, mcCollision.globalIndex()); + for (const auto& b0McCollisionPerMcCollision : b0McCollisionsPerMcCollision) { // should only ever be one + jethfutilities::fillHFMcCollisionTable(b0McCollisionPerMcCollision, products.productsB0.storedB0McCollisionsTable); + products.productsB0.storedB0McCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); + b0McCollisionMapping[b0McCollisionPerMcCollision.globalIndex()] = products.productsB0.storedB0McCollisionsTable.lastIndex(); + } + const auto b0ParticlesPerMcCollision = B0Particles.sliceBy(preslices.B0ParticlesPerMcCollision, mcCollision.globalIndex()); + for (const auto& B0Particle : b0ParticlesPerMcCollision) { + jethfutilities::fillHFCandidateMcTable(B0Particle, products.productsB0.storedB0McCollisionsTable.lastIndex(), products.productsB0.storedB0ParticlesTable); + products.productsB0.storedB0ParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[B0Particle.mcParticleId()]); + } + } + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processB0MCP, "write out B0 mcp output tables", false); + void processBplusMCP(soa::Join const& mcCollisions, aod::McCollisionsBplus const& BplusMcCollisions, aod::CandidatesBplusMCP const& BplusParticles) { bplusMcCollisionMapping.clear(); bplusMcCollisionMapping.resize(BplusMcCollisions.size(), -1); for (auto const& mcCollision : mcCollisions) { if (mcCollision.isMcCollisionSelected()) { - const auto bplusMcCollisionsPerMcCollision = BplusMcCollisions.sliceBy(BplusMcCollisionsPerMcCollision, mcCollision.globalIndex()); + const auto bplusMcCollisionsPerMcCollision = BplusMcCollisions.sliceBy(preslices.BplusMcCollisionsPerMcCollision, mcCollision.globalIndex()); for (const auto& bplusMcCollisionPerMcCollision : bplusMcCollisionsPerMcCollision) { // should only ever be one - jethfutilities::fillHFMcCollisionTable(bplusMcCollisionPerMcCollision, products.storedBplusMcCollisionsTable); - products.storedBplusMcCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); - bplusMcCollisionMapping[bplusMcCollisionPerMcCollision.globalIndex()] = products.storedBplusMcCollisionsTable.lastIndex(); + jethfutilities::fillHFMcCollisionTable(bplusMcCollisionPerMcCollision, products.productsBplus.storedBplusMcCollisionsTable); + products.productsBplus.storedBplusMcCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); + bplusMcCollisionMapping[bplusMcCollisionPerMcCollision.globalIndex()] = products.productsBplus.storedBplusMcCollisionsTable.lastIndex(); } - const auto bplusParticlesPerMcCollision = BplusParticles.sliceBy(BplusParticlesPerMcCollision, mcCollision.globalIndex()); + const auto bplusParticlesPerMcCollision = BplusParticles.sliceBy(preslices.BplusParticlesPerMcCollision, mcCollision.globalIndex()); for (const auto& BplusParticle : bplusParticlesPerMcCollision) { - jethfutilities::fillHFCandidateMcTable(BplusParticle, products.storedBplusMcCollisionsTable.lastIndex(), products.storedBplusParticlesTable); - products.storedBplusParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[BplusParticle.mcParticleId()]); + jethfutilities::fillHFCandidateMcTable(BplusParticle, products.productsBplus.storedBplusMcCollisionsTable.lastIndex(), products.productsBplus.storedBplusParticlesTable); + products.productsBplus.storedBplusParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[BplusParticle.mcParticleId()]); } } } @@ -576,14 +729,14 @@ struct JetDerivedDataWriter { { if (mcCollision.isMcCollisionSelected()) { - const auto dielectronMcCollisionsPerMcCollision = DielectronMcCollisions.sliceBy(DielectronMcCollisionsPerMcCollision, mcCollision.globalIndex()); + const auto dielectronMcCollisionsPerMcCollision = DielectronMcCollisions.sliceBy(preslices.DielectronMcCollisionsPerMcCollision, mcCollision.globalIndex()); for (const auto& dielectronMcCollisionPerMcCollision : dielectronMcCollisionsPerMcCollision) { // should only ever be one - jetdqutilities::fillDielectronMcCollisionTable(dielectronMcCollisionPerMcCollision, products.storedDielectronMcCollisionsTable); - products.storedDielectronMcCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); - products.storedDielectronMcRCollDummysTable(dielectronMcCollisionPerMcCollision.dummyDQ()); + jetdqutilities::fillDielectronMcCollisionTable(dielectronMcCollisionPerMcCollision, products.productsDielectron.storedDielectronMcCollisionsTable); + products.productsDielectron.storedDielectronMcCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); + products.productsDielectron.storedDielectronMcRCollDummysTable(dielectronMcCollisionPerMcCollision.dummyDQ()); } for (const auto& DielectronParticle : DielectronParticles) { - jetdqutilities::fillDielectronCandidateMcTable(DielectronParticle, products.storedDielectronMcCollisionsTable.lastIndex(), products.storedDielectronParticlesTable); + jetdqutilities::fillDielectronCandidateMcTable(DielectronParticle, products.productsDielectron.storedDielectronMcCollisionsTable.lastIndex(), products.productsDielectron.storedDielectronParticlesTable); std::vector DielectronMothersIds; int DielectronDaughtersId[2]; if (DielectronParticle.has_mothers()) { @@ -601,7 +754,7 @@ struct JetDerivedDataWriter { i++; } } - products.storedDielectronParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[DielectronParticle.mcParticleId()], DielectronMothersIds, DielectronDaughtersId); + products.productsDielectron.storedDielectronParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[DielectronParticle.mcParticleId()], DielectronMothersIds, DielectronDaughtersId); } } } @@ -657,7 +810,7 @@ struct JetDerivedDataWriter { for (auto const& d0CollisionPerMcCollision : D0McCollision.hfCollBases_as()) { d0CollisionIDs.push_back(d0McCollisionMapping[d0CollisionPerMcCollision.globalIndex()]); } - products.storedD0McCollisionsMatchingTable(d0CollisionIDs); + products.productsD0.storedD0McCollisionsMatchingTable(d0CollisionIDs); } } } @@ -671,12 +824,26 @@ struct JetDerivedDataWriter { for (auto const& dplusCollisionPerMcCollision : DplusMcCollision.hfCollBases_as()) { dplusCollisionIDs.push_back(dplusMcCollisionMapping[dplusCollisionPerMcCollision.globalIndex()]); } - products.storedDplusMcCollisionsMatchingTable(dplusCollisionIDs); + products.productsDplus.storedDplusMcCollisionsMatchingTable(dplusCollisionIDs); } } } PROCESS_SWITCH(JetDerivedDataWriter, processDplusMcCollisionMatch, "write out Dplus McCollision collision label output tables", false); + void processDstarMcCollisionMatch(soa::Join::iterator const& mcCollision, soa::Join const& DstarMcCollisions, aod::CollisionsDstar const&) + { + if (mcCollision.isMcCollisionSelected()) { + for (const auto& DstarMcCollision : DstarMcCollisions) { // should just be one + std::vector dstarCollisionIDs; + for (auto const& dstarCollisionPerMcCollision : DstarMcCollision.hfCollBases_as()) { + dstarCollisionIDs.push_back(dstarMcCollisionMapping[dstarCollisionPerMcCollision.globalIndex()]); + } + products.productsDstar.storedDstarMcCollisionsMatchingTable(dstarCollisionIDs); + } + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processDstarMcCollisionMatch, "write out D* McCollision collision label output tables", false); + void processLcMcCollisionMatch(soa::Join::iterator const& mcCollision, soa::Join const& LcMcCollisions, aod::CollisionsLc const&) { if (mcCollision.isMcCollisionSelected()) { @@ -685,12 +852,26 @@ struct JetDerivedDataWriter { for (auto const& lcCollisionPerMcCollision : LcMcCollision.hfCollBases_as()) { lcCollisionIDs.push_back(lcMcCollisionMapping[lcCollisionPerMcCollision.globalIndex()]); } - products.storedLcMcCollisionsMatchingTable(lcCollisionIDs); + products.productsLc.storedLcMcCollisionsMatchingTable(lcCollisionIDs); } } } PROCESS_SWITCH(JetDerivedDataWriter, processLcMcCollisionMatch, "write out Lc McCollision collision label output tables", false); + void processB0McCollisionMatch(soa::Join::iterator const& mcCollision, soa::Join const& B0McCollisions, aod::CollisionsB0 const&) + { + if (mcCollision.isMcCollisionSelected()) { + for (const auto& B0McCollision : B0McCollisions) { // should just be one + std::vector b0CollisionIDs; + for (auto const& b0CollisionPerMcCollision : B0McCollision.hfCollBases_as()) { + b0CollisionIDs.push_back(b0McCollisionMapping[b0CollisionPerMcCollision.globalIndex()]); + } + products.productsB0.storedB0McCollisionsMatchingTable(b0CollisionIDs); + } + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processB0McCollisionMatch, "write out B0 McCollision collision label output tables", false); + void processBplusMcCollisionMatch(soa::Join::iterator const& mcCollision, soa::Join const& BplusMcCollisions, aod::CollisionsBplus const&) { if (mcCollision.isMcCollisionSelected()) { @@ -699,7 +880,7 @@ struct JetDerivedDataWriter { for (auto const& bplusCollisionPerMcCollision : BplusMcCollision.hfCollBases_as()) { bplusCollisionIDs.push_back(bplusMcCollisionMapping[bplusCollisionPerMcCollision.globalIndex()]); } - products.storedBplusMcCollisionsMatchingTable(bplusCollisionIDs); + products.productsBplus.storedBplusMcCollisionsMatchingTable(bplusCollisionIDs); } } } diff --git a/PWGJE/TableProducer/eventwiseConstituentSubtractor.cxx b/PWGJE/TableProducer/eventwiseConstituentSubtractor.cxx index 914f10e28cb..f840a339534 100644 --- a/PWGJE/TableProducer/eventwiseConstituentSubtractor.cxx +++ b/PWGJE/TableProducer/eventwiseConstituentSubtractor.cxx @@ -44,8 +44,12 @@ struct eventWiseConstituentSubtractorTask { Produces particleSubtractedD0Table; Produces trackSubtractedDplusTable; Produces particleSubtractedDplusTable; + Produces trackSubtractedDstarTable; + Produces particleSubtractedDstarTable; Produces trackSubtractedLcTable; Produces particleSubtractedLcTable; + Produces trackSubtractedB0Table; + Produces particleSubtractedB0Table; Produces trackSubtractedBplusTable; Produces particleSubtractedBplusTable; Produces trackSubtractedDielectronTable; @@ -180,6 +184,18 @@ struct eventWiseConstituentSubtractorTask { } PROCESS_SWITCH(eventWiseConstituentSubtractorTask, processDplusMcCollisions, "Fill table of subtracted tracks for collisions with Dplus MCP candidates", false); + void processDstarCollisions(aod::JetCollision const&, soa::Filtered const& tracks, soa::Join const& candidates) + { + analyseHF(tracks, candidates, trackSubtractedDstarTable); + } + PROCESS_SWITCH(eventWiseConstituentSubtractorTask, processDstarCollisions, "Fill table of subtracted tracks for collisions with D* candidates", false); + + void processDstarMcCollisions(aod::JetMcCollision const&, soa::Filtered const& tracks, soa::Join const& candidates) + { + analyseHFMc(tracks, candidates, particleSubtractedDstarTable); + } + PROCESS_SWITCH(eventWiseConstituentSubtractorTask, processDstarMcCollisions, "Fill table of subtracted tracks for collisions with D* MCP candidates", false); + void processLcCollisions(aod::JetCollision const&, soa::Filtered const& tracks, soa::Join const& candidates) { analyseHF(tracks, candidates, trackSubtractedLcTable); @@ -192,6 +208,18 @@ struct eventWiseConstituentSubtractorTask { } PROCESS_SWITCH(eventWiseConstituentSubtractorTask, processLcMcCollisions, "Fill table of subtracted tracks for collisions with Lc MCP candidates", false); + void processB0Collisions(aod::JetCollision const&, soa::Filtered const& tracks, soa::Join const& candidates) + { + analyseHF(tracks, candidates, trackSubtractedB0Table); + } + PROCESS_SWITCH(eventWiseConstituentSubtractorTask, processB0Collisions, "Fill table of subtracted tracks for collisions with B0 candidates", false); + + void processB0McCollisions(aod::JetMcCollision const&, soa::Filtered const& tracks, soa::Join const& candidates) + { + analyseHFMc(tracks, candidates, particleSubtractedB0Table); + } + PROCESS_SWITCH(eventWiseConstituentSubtractorTask, processB0McCollisions, "Fill table of subtracted tracks for collisions with B0 MCP candidates", false); + void processBplusCollisions(aod::JetCollision const&, soa::Filtered const& tracks, soa::Join const& candidates) { analyseHF(tracks, candidates, trackSubtractedBplusTable); diff --git a/PWGJE/TableProducer/jetEventWeightMCD.cxx b/PWGJE/TableProducer/jetEventWeightMCD.cxx index 48f8ab749c9..7036f5407f6 100644 --- a/PWGJE/TableProducer/jetEventWeightMCD.cxx +++ b/PWGJE/TableProducer/jetEventWeightMCD.cxx @@ -60,7 +60,9 @@ using NeutralMCJetsEventWeight = JetEventWeightMCDTask; using D0ChargedMCJetsEventWeight = JetEventWeightMCDTask; using DplusChargedMCJetsEventWeight = JetEventWeightMCDTask; +using DstarChargedMCJetsEventWeight = JetEventWeightMCDTask; using LcChargedMCJetsEventWeight = JetEventWeightMCDTask; +using B0ChargedMCJetsEventWeight = JetEventWeightMCDTask; using BplusChargedMCJetsEventWeight = JetEventWeightMCDTask; using V0ChargedMCJetsEventWeight = JetEventWeightMCDTask; @@ -89,10 +91,18 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) adaptAnalysisTask(cfgc, SetDefaultProcesses{}, TaskName{"jet-dplus-eventweight-mcd-charged"})); + tasks.emplace_back( + adaptAnalysisTask(cfgc, + SetDefaultProcesses{}, TaskName{"jet-dstar-eventweight-mcd-charged"})); + tasks.emplace_back( adaptAnalysisTask(cfgc, SetDefaultProcesses{}, TaskName{"jet-lc-eventweight-mcd-charged"})); + tasks.emplace_back( + adaptAnalysisTask(cfgc, + SetDefaultProcesses{}, TaskName{"jet-b0-eventweight-mcd-charged"})); + tasks.emplace_back( adaptAnalysisTask(cfgc, SetDefaultProcesses{}, TaskName{"jet-bplus-eventweight-mcd-charged"})); diff --git a/PWGJE/TableProducer/jetEventWeightMCP.cxx b/PWGJE/TableProducer/jetEventWeightMCP.cxx index 3b9cf4340ba..ba2efb56ced 100644 --- a/PWGJE/TableProducer/jetEventWeightMCP.cxx +++ b/PWGJE/TableProducer/jetEventWeightMCP.cxx @@ -49,7 +49,9 @@ using NeutralMCJetsEventWeight = JetEventWeightMCPTask; using D0ChargedMCJetsEventWeight = JetEventWeightMCPTask; using DplusChargedMCJetsEventWeight = JetEventWeightMCPTask; +using DstarChargedMCJetsEventWeight = JetEventWeightMCPTask; using LcChargedMCJetsEventWeight = JetEventWeightMCPTask; +using B0ChargedMCJetsEventWeight = JetEventWeightMCPTask; using BplusChargedMCJetsEventWeight = JetEventWeightMCPTask; using V0ChargedMCJetsEventWeight = JetEventWeightMCPTask; @@ -78,10 +80,18 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) adaptAnalysisTask(cfgc, SetDefaultProcesses{}, TaskName{"jet-dplus-eventweight-mcp-charged"})); + tasks.emplace_back( + adaptAnalysisTask(cfgc, + SetDefaultProcesses{}, TaskName{"jet-dstar-eventweight-mcp-charged"})); + tasks.emplace_back( adaptAnalysisTask(cfgc, SetDefaultProcesses{}, TaskName{"jet-lc-eventweight-mcp-charged"})); + tasks.emplace_back( + adaptAnalysisTask(cfgc, + SetDefaultProcesses{}, TaskName{"jet-b0-eventweight-mcp-charged"})); + tasks.emplace_back( adaptAnalysisTask(cfgc, SetDefaultProcesses{}, TaskName{"jet-bplus-eventweight-mcp-charged"})); diff --git a/PWGJE/TableProducer/rhoEstimator.cxx b/PWGJE/TableProducer/rhoEstimator.cxx index dba3cfb50c8..6cacf12ab69 100644 --- a/PWGJE/TableProducer/rhoEstimator.cxx +++ b/PWGJE/TableProducer/rhoEstimator.cxx @@ -48,10 +48,14 @@ struct RhoEstimatorTask { Produces rhoD0McTable; Produces rhoDplusTable; Produces rhoDplusMcTable; + Produces rhoDstarTable; + Produces rhoDstarMcTable; Produces rhoLcTable; Produces rhoLcMcTable; Produces rhoBplusTable; Produces rhoBplusMcTable; + Produces rhoB0Table; + Produces rhoB0McTable; Produces rhoDielectronTable; Produces rhoDielectronMcTable; @@ -275,6 +279,34 @@ struct RhoEstimatorTask { } PROCESS_SWITCH(RhoEstimatorTask, processDplusMcCollisions, "Fill rho tables for collisions with Dplus MCP candidates", false); + void processDstarCollisions(aod::JetCollision const& collision, soa::Filtered const& tracks, aod::CandidatesDstarData const& candidates) + { + for (auto& candidate : candidates) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits) || collision.centrality() < config.centralityMin || collision.centrality() >= config.centralityMax || collision.trackOccupancyInTimeRange() > config.trackOccupancyInTimeRangeMax || std::abs(collision.posZ()) > config.vertexZCut) { + rhoDstarTable(0.0, 0.0); + continue; + } + inputParticles.clear(); + jetfindingutilities::analyseTracks(inputParticles, tracks, trackSelection, config.trackingEfficiency, &candidate); + + auto [rho, rhoM] = bkgSub.estimateRhoAreaMedian(inputParticles, config.doSparse); + rhoDstarTable(rho, rhoM); + } + } + PROCESS_SWITCH(RhoEstimatorTask, processDstarCollisions, "Fill rho tables for collisions with Dstar candidates", false); + + void processDstarMcCollisions(aod::JetMcCollision const&, soa::Filtered const& particles, aod::CandidatesDstarMCP const& candidates) + { + for (auto& candidate : candidates) { + inputParticles.clear(); + jetfindingutilities::analyseParticles(inputParticles, particleSelection, 1, particles, pdgDatabase, &candidate); + + auto [rho, rhoM] = bkgSub.estimateRhoAreaMedian(inputParticles, config.doSparse); + rhoDstarMcTable(rho, rhoM); + } + } + PROCESS_SWITCH(RhoEstimatorTask, processDstarMcCollisions, "Fill rho tables for collisions with Dstar MCP candidates", false); + void processLcCollisions(aod::JetCollision const& collision, soa::Filtered const& tracks, aod::CandidatesLcData const& candidates) { for (auto& candidate : candidates) { @@ -303,6 +335,34 @@ struct RhoEstimatorTask { } PROCESS_SWITCH(RhoEstimatorTask, processLcMcCollisions, "Fill rho tables for collisions with Lc MCP candidates", false); + void processB0Collisions(aod::JetCollision const& collision, soa::Filtered const& tracks, aod::CandidatesB0Data const& candidates) + { + for (auto& candidate : candidates) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits) || collision.centrality() < config.centralityMin || collision.centrality() >= config.centralityMax || collision.trackOccupancyInTimeRange() > config.trackOccupancyInTimeRangeMax || std::abs(collision.posZ()) > config.vertexZCut) { + rhoB0Table(0.0, 0.0); + continue; + } + inputParticles.clear(); + jetfindingutilities::analyseTracks(inputParticles, tracks, trackSelection, config.trackingEfficiency, &candidate); + + auto [rho, rhoM] = bkgSub.estimateRhoAreaMedian(inputParticles, config.doSparse); + rhoB0Table(rho, rhoM); + } + } + PROCESS_SWITCH(RhoEstimatorTask, processB0Collisions, "Fill rho tables for collisions with B0 candidates", false); + + void processB0McCollisions(aod::JetMcCollision const&, soa::Filtered const& particles, aod::CandidatesB0MCP const& candidates) + { + for (auto& candidate : candidates) { + inputParticles.clear(); + jetfindingutilities::analyseParticles(inputParticles, particleSelection, 1, particles, pdgDatabase, &candidate); + + auto [rho, rhoM] = bkgSub.estimateRhoAreaMedian(inputParticles, config.doSparse); + rhoB0McTable(rho, rhoM); + } + } + PROCESS_SWITCH(RhoEstimatorTask, processB0McCollisions, "Fill rho tables for collisions with B0 MCP candidates", false); + void processBplusCollisions(aod::JetCollision const& collision, soa::Filtered const& tracks, aod::CandidatesBplusData const& candidates) { for (auto& candidate : candidates) { diff --git a/PWGJE/Tasks/CMakeLists.txt b/PWGJE/Tasks/CMakeLists.txt index 0e39c04445a..f82c70b351b 100644 --- a/PWGJE/Tasks/CMakeLists.txt +++ b/PWGJE/Tasks/CMakeLists.txt @@ -72,10 +72,18 @@ if(FastJet_FOUND) SOURCES jetSubstructureDplus.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-substructure-dstar + SOURCES jetSubstructureDstar.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore + COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(jet-substructure-lc SOURCES jetSubstructureLc.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-substructure-b0 + SOURCES jetSubstructureB0.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore + COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(jet-substructure-bplus SOURCES jetSubstructureBplus.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore @@ -92,10 +100,18 @@ if(FastJet_FOUND) SOURCES jetSubstructureDplusOutput.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-substructure-dstar-output + SOURCES jetSubstructureDstarOutput.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore + COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(jet-substructure-lc-output SOURCES jetSubstructureLcOutput.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-substructure-b0-output + SOURCES jetSubstructureB0Output.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore + COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(jet-substructure-bplus-output SOURCES jetSubstructureBplusOutput.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore @@ -132,10 +148,18 @@ if(FastJet_FOUND) SOURCES jetFinderDplusQA.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-finder-dstar-qa + SOURCES jetFinderDstarQA.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore + COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(jet-finder-lc-qa SOURCES jetFinderLcQA.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-finder-b0-qa + SOURCES jetFinderB0QA.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore + COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(jet-finder-bplus-qa SOURCES jetFinderBplusQA.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore diff --git a/PWGJE/Tasks/jetFinderB0QA.cxx b/PWGJE/Tasks/jetFinderB0QA.cxx new file mode 100644 index 00000000000..8935968ac5b --- /dev/null +++ b/PWGJE/Tasks/jetFinderB0QA.cxx @@ -0,0 +1,37 @@ +// 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. + +// jet finder B0 charged QA task +// +/// \author Nima Zardoshti + +#include "PWGJE/Tasks/jetFinderHFQA.cxx" + +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetSubtraction.h" + +#include +#include +#include +#include + +#include + +using JetFinderB0QATask = JetFinderHFQATask; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + tasks.emplace_back(adaptAnalysisTask(cfgc, + SetDefaultProcesses{}, + TaskName{"jet-finder-charged-b0-qa"})); + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/Tasks/jetFinderDstarQA.cxx b/PWGJE/Tasks/jetFinderDstarQA.cxx new file mode 100644 index 00000000000..b8fc0808521 --- /dev/null +++ b/PWGJE/Tasks/jetFinderDstarQA.cxx @@ -0,0 +1,37 @@ +// 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. + +// jet finder D* charged QA task +// +/// \author Nima Zardoshti + +#include "PWGJE/Tasks/jetFinderHFQA.cxx" + +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetSubtraction.h" + +#include +#include +#include +#include + +#include + +using JetFinderDstarQATask = JetFinderHFQATask; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + tasks.emplace_back(adaptAnalysisTask(cfgc, + SetDefaultProcesses{}, + TaskName{"jet-finder-charged-dstar-qa"})); + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/Tasks/jetFinderHFQA.cxx b/PWGJE/Tasks/jetFinderHFQA.cxx index 0dbcb8bb609..6aa912d0828 100644 --- a/PWGJE/Tasks/jetFinderHFQA.cxx +++ b/PWGJE/Tasks/jetFinderHFQA.cxx @@ -493,7 +493,9 @@ struct JetFinderHFQATask { PresliceOptional> perD0CandidateTracks = aod::bkgd0::candidateId; PresliceOptional> perDplusCandidateTracks = aod::bkgdplus::candidateId; + PresliceOptional> perDstarCandidateTracks = aod::bkgdstar::candidateId; PresliceOptional> perLcCandidateTracks = aod::bkglc::candidateId; + PresliceOptional> perB0CandidateTracks = aod::bkgb0::candidateId; PresliceOptional> perBplusCandidateTracks = aod::bkgbplus::candidateId; PresliceOptional> perDielectronCandidateTracks = aod::bkgdielectron::candidateId; @@ -1521,7 +1523,7 @@ struct JetFinderHFQATask { } for (auto const& candidate : candidates) { - for (auto const& track : jetcandidateutilities::slicedPerCandidate(tracks, candidate, perD0CandidateTracks, perDplusCandidateTracks, perLcCandidateTracks, perBplusCandidateTracks, perDielectronCandidateTracks)) { + for (auto const& track : jetcandidateutilities::slicedPerCandidate(tracks, candidate, perD0CandidateTracks, perDplusCandidateTracks, perDstarCandidateTracks, perLcCandidateTracks, perB0CandidateTracks, perBplusCandidateTracks, perDielectronCandidateTracks)) { registry.fill(HIST("h3_centrality_track_pt_track_phi_eventwiseconstituentsubtracted"), collision.centrality(), track.pt(), track.phi()); registry.fill(HIST("h3_centrality_track_pt_track_eta_eventwiseconstituentsubtracted"), collision.centrality(), track.pt(), track.eta()); registry.fill(HIST("h3_track_pt_track_eta_track_phi_eventwiseconstituentsubtracted"), track.pt(), track.eta(), track.phi()); diff --git a/PWGJE/Tasks/jetSubstructureB0.cxx b/PWGJE/Tasks/jetSubstructureB0.cxx new file mode 100644 index 00000000000..aedac757bf8 --- /dev/null +++ b/PWGJE/Tasks/jetSubstructureB0.cxx @@ -0,0 +1,39 @@ +// 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. + +// jet substructure B0 charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/Tasks/jetSubstructureHF.cxx" + +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetSubstructure.h" +#include "PWGJE/DataModel/JetSubtraction.h" + +#include +#include +#include +#include +#include + +#include + +using JetSubstructureB0 = JetSubstructureHFTask, soa::Join, soa::Join, soa::Join, aod::CandidatesB0Data, aod::CandidatesB0MCP, aod::B0CJetSSs, aod::B0ChargedSPs, aod::B0ChargedPRs, aod::B0CMCDJetSSs, aod::B0ChargedMCDetectorLevelSPs, aod::B0ChargedMCDetectorLevelPRs, aod::B0CMCPJetSSs, aod::B0ChargedMCParticleLevelSPs, aod::B0ChargedMCParticleLevelPRs, aod::B0CEWSJetSSs, aod::B0ChargedEventWiseSubtractedSPs, aod::B0ChargedEventWiseSubtractedPRs, aod::JTrackB0Subs>; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + tasks.emplace_back(adaptAnalysisTask(cfgc, + SetDefaultProcesses{}, + TaskName{"jet-substructure-b0"})); + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/Tasks/jetSubstructureB0Output.cxx b/PWGJE/Tasks/jetSubstructureB0Output.cxx new file mode 100644 index 00000000000..4cac5ffcf2c --- /dev/null +++ b/PWGJE/Tasks/jetSubstructureB0Output.cxx @@ -0,0 +1,39 @@ +// 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. + +// jet substructure output B0 charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/Tasks/jetSubstructureHFOutput.cxx" + +#include "PWGHF/DataModel/DerivedTables.h" +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetSubstructure.h" +#include "PWGJE/DataModel/JetSubtraction.h" + +#include +#include +#include +#include +#include + +#include + +using JetSubstructureOutputB0 = JetSubstructureHFOutputTask, aod::McCollisionsB0, aod::CandidatesB0Data, aod::CandidatesB0MCD, aod::CandidatesB0MCP, aod::BkgB0Rhos, aod::BkgB0McRhos, aod::JTrackB0Subs, soa::Join, soa::Join, soa::Join, soa::Join, aod::B0CJetCOs, aod::B0CJetOs, aod::B0CJetSSOs, aod::B0CJetMOs, soa::Join, soa::Join, soa::Join, aod::B0CMCDJetCOs, aod::B0CMCDJetOs, aod::B0CMCDJetSSOs, aod::B0CMCDJetMOs, soa::Join, soa::Join, soa::Join, soa::Join, aod::B0CMCPJetCOs, aod::B0CMCPJetMCCOs, aod::B0CMCPJetOs, aod::B0CMCPJetSSOs, aod::B0CMCPJetMOs, soa::Join, soa::Join, soa::Join, aod::B0CEWSJetCOs, aod::B0CEWSJetOs, aod::B0CEWSJetSSOs, aod::B0CEWSJetMOs, aod::StoredHfB0CollBase, aod::StoredHfB0Bases, aod::StoredHfB0Pars, aod::StoredHfB0ParEs, aod::StoredHfB0ParDpluss, aod::StoredHfB0Sels, aod::StoredHfB0Mls, aod::StoredHfB0MlDpluss, aod::StoredHfB0Mcs, aod::StoredHfB0McCollBases, aod::StoredHfB0McRCollIds, aod::StoredHfB0PBases>; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + tasks.emplace_back(adaptAnalysisTask(cfgc, SetDefaultProcesses{}, TaskName{"jet-substructure-b0-output"})); + + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/Tasks/jetSubstructureDstar.cxx b/PWGJE/Tasks/jetSubstructureDstar.cxx new file mode 100644 index 00000000000..02c95adbbda --- /dev/null +++ b/PWGJE/Tasks/jetSubstructureDstar.cxx @@ -0,0 +1,39 @@ +// 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. + +// jet substructure D* charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/Tasks/jetSubstructureHF.cxx" + +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetSubstructure.h" +#include "PWGJE/DataModel/JetSubtraction.h" + +#include +#include +#include +#include +#include + +#include + +using JetSubstructureDstar = JetSubstructureHFTask, soa::Join, soa::Join, soa::Join, aod::CandidatesDstarData, aod::CandidatesDstarMCP, aod::DstarCJetSSs, aod::DstarChargedSPs, aod::DstarChargedPRs, aod::DstarCMCDJetSSs, aod::DstarChargedMCDetectorLevelSPs, aod::DstarChargedMCDetectorLevelPRs, aod::DstarCMCPJetSSs, aod::DstarChargedMCParticleLevelSPs, aod::DstarChargedMCParticleLevelPRs, aod::DstarCEWSJetSSs, aod::DstarChargedEventWiseSubtractedSPs, aod::DstarChargedEventWiseSubtractedPRs, aod::JTrackDstarSubs>; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + tasks.emplace_back(adaptAnalysisTask(cfgc, + SetDefaultProcesses{}, + TaskName{"jet-substructure-dstar"})); + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/Tasks/jetSubstructureDstarOutput.cxx b/PWGJE/Tasks/jetSubstructureDstarOutput.cxx new file mode 100644 index 00000000000..d7ced94f0ad --- /dev/null +++ b/PWGJE/Tasks/jetSubstructureDstarOutput.cxx @@ -0,0 +1,40 @@ +// 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. + +// jet substructure output D* charged task +// +/// \author Nima Zardoshti + +#include "PWGJE/Tasks/jetSubstructureHFOutput.cxx" + +#include "PWGHF/DataModel/DerivedTables.h" +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetReducedDataHF.h" +#include "PWGJE/DataModel/JetSubstructure.h" +#include "PWGJE/DataModel/JetSubtraction.h" + +#include +#include +#include +#include +#include + +#include + +using JetSubstructureOutputDstar = JetSubstructureHFOutputTask, aod::McCollisionsDstar, aod::CandidatesDstarData, aod::CandidatesDstarMCD, aod::CandidatesDstarMCP, aod::BkgDstarRhos, aod::BkgDstarMcRhos, aod::JTrackDstarSubs, soa::Join, soa::Join, soa::Join, soa::Join, aod::DstarCJetCOs, aod::DstarCJetOs, aod::DstarCJetSSOs, aod::DstarCJetMOs, soa::Join, soa::Join, soa::Join, aod::DstarCMCDJetCOs, aod::DstarCMCDJetOs, aod::DstarCMCDJetSSOs, aod::DstarCMCDJetMOs, soa::Join, soa::Join, soa::Join, soa::Join, aod::DstarCMCPJetCOs, aod::DstarCMCPJetMCCOs, aod::DstarCMCPJetOs, aod::DstarCMCPJetSSOs, aod::DstarCMCPJetMOs, soa::Join, soa::Join, soa::Join, aod::DstarCEWSJetCOs, aod::DstarCEWSJetOs, aod::DstarCEWSJetSSOs, aod::DstarCEWSJetMOs, aod::StoredHfDstarCollBase, aod::StoredHfDstarBases, aod::StoredHfDstarPars, aod::JDumDstarParEs, aod::HfDstarParD0s, aod::StoredHfDstarSels, aod::StoredHfDstarMls, aod::JDumDstarMlDaus, aod::StoredHfDstarMcs, aod::StoredHfDstarMcCollBases, aod::StoredHfDstarMcRCollIds, aod::StoredHfDstarPBases>; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + tasks.emplace_back(adaptAnalysisTask(cfgc, SetDefaultProcesses{}, TaskName{"jet-substructure-dstar-output"})); + + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/Tasks/jetSubstructureHF.cxx b/PWGJE/Tasks/jetSubstructureHF.cxx index 36394d45286..c098236dae7 100644 --- a/PWGJE/Tasks/jetSubstructureHF.cxx +++ b/PWGJE/Tasks/jetSubstructureHF.cxx @@ -130,20 +130,26 @@ struct JetSubstructureHFTask { Preslice TracksPerCollision = aod::jtrack::collisionId; PresliceOptional TracksPerD0DataSub = aod::bkgd0::candidateId; PresliceOptional TracksPerDplusDataSub = aod::bkgdplus::candidateId; + PresliceOptional TracksPerDstarDataSub = aod::bkgdstar::candidateId; PresliceOptional TracksPerLcDataSub = aod::bkglc::candidateId; + PresliceOptional TracksPerB0DataSub = aod::bkgb0::candidateId; PresliceOptional TracksPerBplusDataSub = aod::bkgbplus::candidateId; PresliceOptional TracksPerDielectronDataSub = aod::bkgdielectron::candidateId; Preslice ParticlesPerMcCollision = aod::jmcparticle::mcCollisionId; - template - auto selectSlicer(T const& D0Slicer, U const& DplusSlicer, V const& LcSlicer, M const& BplusSlicer, N const& DielectronSlicer) + template + auto selectSlicer(T const& D0Slicer, U const& DplusSlicer, V const& DstarSlicer, M const& LcSlicer, N const& B0Slicer, O const& BplusSlicer, P const& DielectronSlicer) { if constexpr (jethfutilities::isD0Table()) { return D0Slicer; } else if constexpr (jethfutilities::isDplusTable()) { return DplusSlicer; + } else if constexpr (jethfutilities::isDstarTable()) { + return DstarSlicer; } else if constexpr (jethfutilities::isLcTable()) { return LcSlicer; + } else if constexpr (jethfutilities::isB0Table()) { + return B0Slicer; } else if constexpr (jethfutilities::isBplusTable()) { return BplusSlicer; } else if constexpr (jetdqutilities::isDielectronTable()) { @@ -435,7 +441,7 @@ struct JetSubstructureHFTask { CandidateTable const& candidates, TracksSub const& tracks) { - analyseCharged(jet, tracks, candidates, selectSlicer(TracksPerD0DataSub, TracksPerDplusDataSub, TracksPerLcDataSub, TracksPerBplusDataSub, TracksPerDielectronDataSub), jetSubstructureDataSubTable, jetSplittingsDataSubTable, jetPairsDataSubTable); + analyseCharged(jet, tracks, candidates, selectSlicer(TracksPerD0DataSub, TracksPerDplusDataSub, TracksPerDstarDataSub, TracksPerLcDataSub, TracksPerB0DataSub, TracksPerBplusDataSub, TracksPerDielectronDataSub), jetSubstructureDataSubTable, jetSplittingsDataSubTable, jetPairsDataSubTable); } PROCESS_SWITCH(JetSubstructureHFTask, processChargedJetsDataSub, "HF jet substructure on data", false); diff --git a/PWGJE/Tasks/jetSubstructureHFOutput.cxx b/PWGJE/Tasks/jetSubstructureHFOutput.cxx index e071303a55d..d1460d53fc9 100644 --- a/PWGJE/Tasks/jetSubstructureHFOutput.cxx +++ b/PWGJE/Tasks/jetSubstructureHFOutput.cxx @@ -125,60 +125,83 @@ struct JetSubstructureHFOutputTask { jetRadiiValues = (std::vector)configs.jetRadii; } - PresliceUnsorted> CollisionsPerMcCollision = aod::jmccollisionlb::mcCollisionId; - PresliceOptional CandidateCollisionsPerCollision = aod::jcandidateindices::collisionId; - PresliceOptional CandidateMcCollisionsPerMcCollision = aod::jcandidateindices::mcCollisionId; - PresliceOptional CandidateMcCollisionsPerMcCollisionMCPOnly = aod::jcandidateindices::mcCollisionId; - - PresliceOptional> D0SplittingsPerJetData = aod::d0chargedsplitting::jetId; - PresliceOptional> D0SplittingsPerJetDataSub = aod::d0chargedeventwisesubtractedsplitting::jetId; - PresliceOptional> D0SplittingsPerJetMCD = aod::d0chargedmcdetectorlevelsplitting::jetId; - PresliceOptional> D0SplittingsPerJetMCP = aod::d0chargedmcparticlelevelsplitting::jetId; - - PresliceOptional> D0PairsPerJetData = aod::d0chargedpair::jetId; - PresliceOptional> D0PairsPerJetDataSub = aod::d0chargedeventwisesubtractedpair::jetId; - PresliceOptional> D0PairsPerJetMCD = aod::d0chargedmcdetectorlevelpair::jetId; - PresliceOptional> D0PairsPerJetMCP = aod::d0chargedmcparticlelevelpair::jetId; - - PresliceOptional> DplusSplittingsPerJetData = aod::dpluschargedsplitting::jetId; - PresliceOptional> DplusSplittingsPerJetDataSub = aod::dpluschargedeventwisesubtractedsplitting::jetId; - PresliceOptional> DplusSplittingsPerJetMCD = aod::dpluschargedmcdetectorlevelsplitting::jetId; - PresliceOptional> DplusSplittingsPerJetMCP = aod::dpluschargedmcparticlelevelsplitting::jetId; - - PresliceOptional> DplusPairsPerJetData = aod::dpluschargedpair::jetId; - PresliceOptional> DplusPairsPerJetDataSub = aod::dpluschargedeventwisesubtractedpair::jetId; - PresliceOptional> DplusPairsPerJetMCD = aod::dpluschargedmcdetectorlevelpair::jetId; - PresliceOptional> DplusPairsPerJetMCP = aod::dpluschargedmcparticlelevelpair::jetId; - - PresliceOptional> LcSplittingsPerJetData = aod::lcchargedsplitting::jetId; - PresliceOptional> LcSplittingsPerJetDataSub = aod::lcchargedeventwisesubtractedsplitting::jetId; - PresliceOptional> LcSplittingsPerJetMCD = aod::lcchargedmcdetectorlevelsplitting::jetId; - PresliceOptional> LcSplittingsPerJetMCP = aod::lcchargedmcparticlelevelsplitting::jetId; - - PresliceOptional> LcPairsPerJetData = aod::lcchargedpair::jetId; - PresliceOptional> LcPairsPerJetDataSub = aod::lcchargedeventwisesubtractedpair::jetId; - PresliceOptional> LcPairsPerJetMCD = aod::lcchargedmcdetectorlevelpair::jetId; - PresliceOptional> LcPairsPerJetMCP = aod::lcchargedmcparticlelevelpair::jetId; - - PresliceOptional> BplusSplittingsPerJetData = aod::bpluschargedsplitting::jetId; - PresliceOptional> BplusSplittingsPerJetDataSub = aod::bpluschargedeventwisesubtractedsplitting::jetId; - PresliceOptional> BplusSplittingsPerJetMCD = aod::bpluschargedmcdetectorlevelsplitting::jetId; - PresliceOptional> BplusSplittingsPerJetMCP = aod::bpluschargedmcparticlelevelsplitting::jetId; - - PresliceOptional> BplusPairsPerJetData = aod::bpluschargedpair::jetId; - PresliceOptional> BplusPairsPerJetDataSub = aod::bpluschargedeventwisesubtractedpair::jetId; - PresliceOptional> BplusPairsPerJetMCD = aod::bpluschargedmcdetectorlevelpair::jetId; - PresliceOptional> BplusPairsPerJetMCP = aod::bpluschargedmcparticlelevelpair::jetId; - - PresliceOptional> DielectronSplittingsPerJetData = aod::dielectronchargedsplitting::jetId; - PresliceOptional> DielectronSplittingsPerJetDataSub = aod::dielectronchargedeventwisesubtractedsplitting::jetId; - PresliceOptional> DielectronSplittingsPerJetMCD = aod::dielectronchargedmcdetectorlevelsplitting::jetId; - PresliceOptional> DielectronSplittingsPerJetMCP = aod::dielectronchargedmcparticlelevelsplitting::jetId; - - PresliceOptional> DielectronPairsPerJetData = aod::dielectronchargedpair::jetId; - PresliceOptional> DielectronPairsPerJetDataSub = aod::dielectronchargedeventwisesubtractedpair::jetId; - PresliceOptional> DielectronPairsPerJetMCD = aod::dielectronchargedmcdetectorlevelpair::jetId; - PresliceOptional> DielectronPairsPerJetMCP = aod::dielectronchargedmcparticlelevelpair::jetId; + struct : PresliceGroup { + PresliceUnsorted> CollisionsPerMcCollision = aod::jmccollisionlb::mcCollisionId; + PresliceOptional CandidateCollisionsPerCollision = aod::jcandidateindices::collisionId; + PresliceOptional CandidateMcCollisionsPerMcCollision = aod::jcandidateindices::mcCollisionId; + PresliceOptional CandidateMcCollisionsPerMcCollisionMCPOnly = aod::jcandidateindices::mcCollisionId; + + PresliceOptional> D0SplittingsPerJetData = aod::d0chargedsplitting::jetId; + PresliceOptional> D0SplittingsPerJetDataSub = aod::d0chargedeventwisesubtractedsplitting::jetId; + PresliceOptional> D0SplittingsPerJetMCD = aod::d0chargedmcdetectorlevelsplitting::jetId; + PresliceOptional> D0SplittingsPerJetMCP = aod::d0chargedmcparticlelevelsplitting::jetId; + + PresliceOptional> D0PairsPerJetData = aod::d0chargedpair::jetId; + PresliceOptional> D0PairsPerJetDataSub = aod::d0chargedeventwisesubtractedpair::jetId; + PresliceOptional> D0PairsPerJetMCD = aod::d0chargedmcdetectorlevelpair::jetId; + PresliceOptional> D0PairsPerJetMCP = aod::d0chargedmcparticlelevelpair::jetId; + + PresliceOptional> DplusSplittingsPerJetData = aod::dpluschargedsplitting::jetId; + PresliceOptional> DplusSplittingsPerJetDataSub = aod::dpluschargedeventwisesubtractedsplitting::jetId; + PresliceOptional> DplusSplittingsPerJetMCD = aod::dpluschargedmcdetectorlevelsplitting::jetId; + PresliceOptional> DplusSplittingsPerJetMCP = aod::dpluschargedmcparticlelevelsplitting::jetId; + + PresliceOptional> DplusPairsPerJetData = aod::dpluschargedpair::jetId; + PresliceOptional> DplusPairsPerJetDataSub = aod::dpluschargedeventwisesubtractedpair::jetId; + PresliceOptional> DplusPairsPerJetMCD = aod::dpluschargedmcdetectorlevelpair::jetId; + PresliceOptional> DplusPairsPerJetMCP = aod::dpluschargedmcparticlelevelpair::jetId; + + PresliceOptional> DstarSplittingsPerJetData = aod::dstarchargedsplitting::jetId; + PresliceOptional> DstarSplittingsPerJetDataSub = aod::dstarchargedeventwisesubtractedsplitting::jetId; + PresliceOptional> DstarSplittingsPerJetMCD = aod::dstarchargedmcdetectorlevelsplitting::jetId; + PresliceOptional> DstarSplittingsPerJetMCP = aod::dstarchargedmcparticlelevelsplitting::jetId; + + PresliceOptional> DstarPairsPerJetData = aod::dstarchargedpair::jetId; + PresliceOptional> DstarPairsPerJetDataSub = aod::dstarchargedeventwisesubtractedpair::jetId; + PresliceOptional> DstarPairsPerJetMCD = aod::dstarchargedmcdetectorlevelpair::jetId; + PresliceOptional> DstarPairsPerJetMCP = aod::dstarchargedmcparticlelevelpair::jetId; + + PresliceOptional> LcSplittingsPerJetData = aod::lcchargedsplitting::jetId; + PresliceOptional> LcSplittingsPerJetDataSub = aod::lcchargedeventwisesubtractedsplitting::jetId; + PresliceOptional> LcSplittingsPerJetMCD = aod::lcchargedmcdetectorlevelsplitting::jetId; + PresliceOptional> LcSplittingsPerJetMCP = aod::lcchargedmcparticlelevelsplitting::jetId; + + PresliceOptional> LcPairsPerJetData = aod::lcchargedpair::jetId; + PresliceOptional> LcPairsPerJetDataSub = aod::lcchargedeventwisesubtractedpair::jetId; + PresliceOptional> LcPairsPerJetMCD = aod::lcchargedmcdetectorlevelpair::jetId; + PresliceOptional> LcPairsPerJetMCP = aod::lcchargedmcparticlelevelpair::jetId; + + PresliceOptional> B0SplittingsPerJetData = aod::b0chargedsplitting::jetId; + PresliceOptional> B0SplittingsPerJetDataSub = aod::b0chargedeventwisesubtractedsplitting::jetId; + PresliceOptional> B0SplittingsPerJetMCD = aod::b0chargedmcdetectorlevelsplitting::jetId; + PresliceOptional> B0SplittingsPerJetMCP = aod::b0chargedmcparticlelevelsplitting::jetId; + + PresliceOptional> B0PairsPerJetData = aod::b0chargedpair::jetId; + PresliceOptional> B0PairsPerJetDataSub = aod::b0chargedeventwisesubtractedpair::jetId; + PresliceOptional> B0PairsPerJetMCD = aod::b0chargedmcdetectorlevelpair::jetId; + PresliceOptional> B0PairsPerJetMCP = aod::b0chargedmcparticlelevelpair::jetId; + + PresliceOptional> BplusSplittingsPerJetData = aod::bpluschargedsplitting::jetId; + PresliceOptional> BplusSplittingsPerJetDataSub = aod::bpluschargedeventwisesubtractedsplitting::jetId; + PresliceOptional> BplusSplittingsPerJetMCD = aod::bpluschargedmcdetectorlevelsplitting::jetId; + PresliceOptional> BplusSplittingsPerJetMCP = aod::bpluschargedmcparticlelevelsplitting::jetId; + + PresliceOptional> BplusPairsPerJetData = aod::bpluschargedpair::jetId; + PresliceOptional> BplusPairsPerJetDataSub = aod::bpluschargedeventwisesubtractedpair::jetId; + PresliceOptional> BplusPairsPerJetMCD = aod::bpluschargedmcdetectorlevelpair::jetId; + PresliceOptional> BplusPairsPerJetMCP = aod::bpluschargedmcparticlelevelpair::jetId; + + PresliceOptional> DielectronSplittingsPerJetData = aod::dielectronchargedsplitting::jetId; + PresliceOptional> DielectronSplittingsPerJetDataSub = aod::dielectronchargedeventwisesubtractedsplitting::jetId; + PresliceOptional> DielectronSplittingsPerJetMCD = aod::dielectronchargedmcdetectorlevelsplitting::jetId; + PresliceOptional> DielectronSplittingsPerJetMCP = aod::dielectronchargedmcparticlelevelsplitting::jetId; + + PresliceOptional> DielectronPairsPerJetData = aod::dielectronchargedpair::jetId; + PresliceOptional> DielectronPairsPerJetDataSub = aod::dielectronchargedeventwisesubtractedpair::jetId; + PresliceOptional> DielectronPairsPerJetMCD = aod::dielectronchargedmcdetectorlevelpair::jetId; + PresliceOptional> DielectronPairsPerJetMCP = aod::dielectronchargedmcparticlelevelpair::jetId; + + } preslices; template auto candidateMCCollisionSlicer(T const& McCollisionsPerMcCollision, U const& McCollisionsPerMcCollisionMCPOnly) @@ -360,8 +383,8 @@ struct JetSubstructureHFOutputTask { } } - template - void analyseSubstructureMatched(T const& jets, U const& allSplittings, V const& allPairs, M const& D0SplittingsPerJet, N const DplusSplittingsPerJet, O const& LcSplittingsPerJet, P const& BplusSplittingsPerJet, Q const& DielectronSplittingsPerJet, R const& D0PairsPerJet, S const DplusPairsPerJet, A const& LcPairsPerJet, B const& BplusPairsPerJet, C const& DielectronPairsPerJet, std::vector>& splittingMatchesGeoVecVec, std::vector>& splittingMatchesPtVecVec, std::vector>& splittingMatchesHFVecVec, std::vector>& pairMatchesVecVec, float jetPtMin) + template + void analyseSubstructureMatched(T const& jets, U const& allSplittings, V const& allPairs, M const& D0SplittingsPerJet, N const DplusSplittingsPerJet, O const DstarSplittingsPerJet, P const& LcSplittingsPerJet, Q const& B0SplittingsPerJet, R const& BplusSplittingsPerJet, S const& DielectronSplittingsPerJet, A const& D0PairsPerJet, B const DplusPairsPerJet, C const& DstarPairsPerJet, D const& LcPairsPerJet, E const& B0PairsPerJet, F const& BplusPairsPerJet, G const& DielectronPairsPerJet, std::vector>& splittingMatchesGeoVecVec, std::vector>& splittingMatchesPtVecVec, std::vector>& splittingMatchesHFVecVec, std::vector>& pairMatchesVecVec, float jetPtMin) { for (const auto& jet : jets) { if (jet.pt() < jetPtMin) { @@ -372,9 +395,9 @@ struct JetSubstructureHFOutputTask { } for (const auto& jetRadiiValue : jetRadiiValues) { if (jet.r() == round(jetRadiiValue * 100.0f)) { - auto splittings = jetcandidateutilities::slicedPerJet(allSplittings, jet, D0SplittingsPerJet, DplusSplittingsPerJet, LcSplittingsPerJet, BplusSplittingsPerJet, DielectronSplittingsPerJet); + auto splittings = jetcandidateutilities::slicedPerJet(allSplittings, jet, D0SplittingsPerJet, DplusSplittingsPerJet, DstarSplittingsPerJet, LcSplittingsPerJet, B0SplittingsPerJet, BplusSplittingsPerJet, DielectronSplittingsPerJet); fillSplittingMatchingVectors(splittings, jet.globalIndex(), splittingMatchesGeoVecVec, splittingMatchesPtVecVec, splittingMatchesHFVecVec); - auto pairs = jetcandidateutilities::slicedPerJet(allPairs, jet, D0PairsPerJet, DplusPairsPerJet, LcPairsPerJet, BplusPairsPerJet, DielectronPairsPerJet); + auto pairs = jetcandidateutilities::slicedPerJet(allPairs, jet, D0PairsPerJet, DplusPairsPerJet, DstarPairsPerJet, LcPairsPerJet, B0PairsPerJet, BplusPairsPerJet, DielectronPairsPerJet); fillPairMatchingVectors(pairs, jet.globalIndex(), pairMatchesVecVec); } } @@ -476,7 +499,7 @@ struct JetSubstructureHFOutputTask { mcCollisionFlag[jetMCP.mcCollisionId()] = true; if constexpr (!isMCPOnly) { - const auto collisionsPerMcCollision = collisions.sliceBy(CollisionsPerMcCollision, jetMCP.mcCollisionId()); + const auto collisionsPerMcCollision = collisions.sliceBy(preslices.CollisionsPerMcCollision, jetMCP.mcCollisionId()); for (auto collision : collisionsPerMcCollision) { collisionFlag[collision.globalIndex()] = true; } @@ -488,7 +511,7 @@ struct JetSubstructureHFOutputTask { if constexpr (!isMCPOnly) { for (const auto& collision : collisions) { if (collisionFlag[collision.globalIndex()]) { - const auto hfCollisionsPerCollision = hfCollisions.sliceBy(CandidateCollisionsPerCollision, collision.globalIndex()); + const auto hfCollisionsPerCollision = hfCollisions.sliceBy(preslices.CandidateCollisionsPerCollision, collision.globalIndex()); for (const auto& hfCollisionPerCollision : hfCollisionsPerCollision) { // should only ever be one auto hfCollisionTableIndex = candidateCollisionMapping.find(hfCollisionPerCollision.globalIndex()); if (hfCollisionTableIndex != candidateCollisionMapping.end()) { @@ -503,7 +526,7 @@ struct JetSubstructureHFOutputTask { if constexpr (isMC) { for (const auto& mcCollision : mcCollisions) { if (mcCollisionFlag[mcCollision.globalIndex()]) { - const auto hfMcCollisionsPerMcCollision = hfMcCollisions.sliceBy(candidateMCCollisionSlicer(CandidateMcCollisionsPerMcCollision, CandidateMcCollisionsPerMcCollisionMCPOnly), mcCollision.globalIndex()); + const auto hfMcCollisionsPerMcCollision = hfMcCollisions.sliceBy(candidateMCCollisionSlicer(preslices.CandidateMcCollisionsPerMcCollision, preslices.CandidateMcCollisionsPerMcCollisionMCPOnly), mcCollision.globalIndex()); for (const auto& hfMcCollisionPerMcCollision : hfMcCollisionsPerMcCollision) { // should only ever be one auto hfMcCollisionTableIndex = candidateMcCollisionMapping.find(hfMcCollisionPerMcCollision.globalIndex()); if (hfMcCollisionTableIndex != candidateMcCollisionMapping.end()) { @@ -633,12 +656,12 @@ struct JetSubstructureHFOutputTask { splittingMatchesPtVecVecData.assign(jets.size(), {}); splittingMatchesHFVecVecData.assign(jets.size(), {}); pairMatchesVecVecData.assign(jets.size(), {}); - analyseSubstructureMatched(jets, splittingsData, pairsData, D0SplittingsPerJetData, DplusSplittingsPerJetData, LcSplittingsPerJetData, BplusSplittingsPerJetData, DielectronSplittingsPerJetData, D0PairsPerJetData, DplusPairsPerJetData, LcPairsPerJetData, BplusPairsPerJetData, DielectronPairsPerJetData, splittingMatchesGeoVecVecData, splittingMatchesPtVecVecData, splittingMatchesHFVecVecData, pairMatchesVecVecData, configs.jetPtMinData); + analyseSubstructureMatched(jets, splittingsData, pairsData, preslices.D0SplittingsPerJetData, preslices.DplusSplittingsPerJetData, preslices.DstarSplittingsPerJetData, preslices.LcSplittingsPerJetData, preslices.B0SplittingsPerJetData, preslices.BplusSplittingsPerJetData, preslices.DielectronSplittingsPerJetData, preslices.D0PairsPerJetData, preslices.DplusPairsPerJetData, preslices.DstarPairsPerJetData, preslices.LcPairsPerJetData, preslices.B0PairsPerJetData, preslices.BplusPairsPerJetData, preslices.DielectronPairsPerJetData, splittingMatchesGeoVecVecData, splittingMatchesPtVecVecData, splittingMatchesHFVecVecData, pairMatchesVecVecData, configs.jetPtMinData); splittingMatchesGeoVecVecDataSub.assign(jetsSub.size(), {}); splittingMatchesPtVecVecDataSub.assign(jetsSub.size(), {}); splittingMatchesHFVecVecDataSub.assign(jetsSub.size(), {}); pairMatchesVecVecDataSub.assign(jetsSub.size(), {}); - analyseSubstructureMatched(jetsSub, splittingsDataSub, pairsDataSub, D0SplittingsPerJetDataSub, DplusSplittingsPerJetDataSub, LcSplittingsPerJetDataSub, BplusSplittingsPerJetDataSub, DielectronSplittingsPerJetDataSub, D0PairsPerJetDataSub, DplusPairsPerJetDataSub, LcPairsPerJetDataSub, BplusPairsPerJetDataSub, DielectronPairsPerJetDataSub, splittingMatchesGeoVecVecDataSub, splittingMatchesPtVecVecDataSub, splittingMatchesHFVecVecDataSub, pairMatchesVecVecDataSub, configs.jetPtMinDataSub); + analyseSubstructureMatched(jetsSub, splittingsDataSub, pairsDataSub, preslices.D0SplittingsPerJetDataSub, preslices.DplusSplittingsPerJetDataSub, preslices.DstarSplittingsPerJetDataSub, preslices.LcSplittingsPerJetDataSub, preslices.B0SplittingsPerJetDataSub, preslices.BplusSplittingsPerJetDataSub, preslices.DielectronSplittingsPerJetDataSub, preslices.D0PairsPerJetDataSub, preslices.DplusPairsPerJetDataSub, preslices.DstarPairsPerJetDataSub, preslices.LcPairsPerJetDataSub, preslices.B0PairsPerJetDataSub, preslices.BplusPairsPerJetDataSub, preslices.DielectronPairsPerJetDataSub, splittingMatchesGeoVecVecDataSub, splittingMatchesPtVecVecDataSub, splittingMatchesHFVecVecDataSub, pairMatchesVecVecDataSub, configs.jetPtMinDataSub); } PROCESS_SWITCH(JetSubstructureHFOutputTask, processOutputSubstructureMatchingData, "jet substructure matching output Data", false); @@ -679,12 +702,12 @@ struct JetSubstructureHFOutputTask { splittingMatchesPtVecVecMCD.assign(jetsMCD.size(), {}); splittingMatchesHFVecVecMCD.assign(jetsMCD.size(), {}); pairMatchesVecVecMCD.assign(jetsMCD.size(), {}); - analyseSubstructureMatched(jetsMCD, splittingsMCD, pairsMCD, D0SplittingsPerJetMCD, DplusSplittingsPerJetMCD, LcSplittingsPerJetMCD, BplusSplittingsPerJetMCD, DielectronSplittingsPerJetMCD, D0PairsPerJetMCD, DplusPairsPerJetMCD, LcPairsPerJetMCD, BplusPairsPerJetMCD, DielectronPairsPerJetMCD, splittingMatchesGeoVecVecMCD, splittingMatchesPtVecVecMCD, splittingMatchesHFVecVecMCD, pairMatchesVecVecMCD, configs.jetPtMinMCD); + analyseSubstructureMatched(jetsMCD, splittingsMCD, pairsMCD, preslices.D0SplittingsPerJetMCD, preslices.DplusSplittingsPerJetMCD, preslices.DstarSplittingsPerJetMCD, preslices.LcSplittingsPerJetMCD, preslices.B0SplittingsPerJetMCD, preslices.BplusSplittingsPerJetMCD, preslices.DielectronSplittingsPerJetMCD, preslices.D0PairsPerJetMCD, preslices.DplusPairsPerJetMCD, preslices.DstarPairsPerJetMCD, preslices.LcPairsPerJetMCD, preslices.B0PairsPerJetMCD, preslices.BplusPairsPerJetMCD, preslices.DielectronPairsPerJetMCD, splittingMatchesGeoVecVecMCD, splittingMatchesPtVecVecMCD, splittingMatchesHFVecVecMCD, pairMatchesVecVecMCD, configs.jetPtMinMCD); splittingMatchesGeoVecVecMCP.assign(jetsMCP.size(), {}); splittingMatchesPtVecVecMCP.assign(jetsMCP.size(), {}); splittingMatchesHFVecVecMCP.assign(jetsMCP.size(), {}); pairMatchesVecVecMCP.assign(jetsMCP.size(), {}); - analyseSubstructureMatched(jetsMCP, splittingsMCP, pairsMCP, D0SplittingsPerJetMCP, DplusSplittingsPerJetMCP, LcSplittingsPerJetMCP, BplusSplittingsPerJetMCP, DielectronSplittingsPerJetMCP, D0PairsPerJetMCP, DplusPairsPerJetMCP, LcPairsPerJetMCP, BplusPairsPerJetMCP, DielectronPairsPerJetMCP, splittingMatchesGeoVecVecMCP, splittingMatchesPtVecVecMCP, splittingMatchesHFVecVecMCP, pairMatchesVecVecMCP, configs.jetPtMinMCP); + analyseSubstructureMatched(jetsMCP, splittingsMCP, pairsMCP, preslices.D0SplittingsPerJetMCP, preslices.DplusSplittingsPerJetMCP, preslices.DstarSplittingsPerJetMCP, preslices.LcSplittingsPerJetMCP, preslices.B0SplittingsPerJetMCP, preslices.BplusSplittingsPerJetMCP, preslices.DielectronSplittingsPerJetMCP, preslices.D0PairsPerJetMCP, preslices.DplusPairsPerJetMCP, preslices.DstarPairsPerJetMCP, preslices.LcPairsPerJetMCP, preslices.B0PairsPerJetMCP, preslices.BplusPairsPerJetMCP, preslices.DielectronPairsPerJetMCP, splittingMatchesGeoVecVecMCP, splittingMatchesPtVecVecMCP, splittingMatchesHFVecVecMCP, pairMatchesVecVecMCP, configs.jetPtMinMCP); } PROCESS_SWITCH(JetSubstructureHFOutputTask, processOutputSubstructureMatchingMC, "jet substructure matching output MC", false);