From 6e25a6ffb745c3fd6a8d3039d65ea7f858d31208 Mon Sep 17 00:00:00 2001 From: Mattia Faggin Date: Mon, 15 Jul 2024 18:16:41 +0200 Subject: [PATCH] Fix filling of Lc->pKpi background table filling in polarization analysis. --- PWGHF/D2H/Tasks/taskCharmPolarisation.cxx | 155 +++++++++++++++------- 1 file changed, 104 insertions(+), 51 deletions(-) diff --git a/PWGHF/D2H/Tasks/taskCharmPolarisation.cxx b/PWGHF/D2H/Tasks/taskCharmPolarisation.cxx index 105a3cdafa5..8cc40d7e52b 100644 --- a/PWGHF/D2H/Tasks/taskCharmPolarisation.cxx +++ b/PWGHF/D2H/Tasks/taskCharmPolarisation.cxx @@ -72,8 +72,9 @@ DECLARE_SOA_COLUMN(MassKPi, massKPi, float); DECLARE_SOA_COLUMN(MassKProton, massKProton, float); DECLARE_SOA_COLUMN(MassPiProton, massPiProton, float); DECLARE_SOA_COLUMN(BdtBkgScore, bdtBkgScore, float); -DECLARE_SOA_COLUMN(IsRealPKPi, isRealPKPi, bool); -DECLARE_SOA_COLUMN(IsReflected, isReflected, bool); +DECLARE_SOA_COLUMN(IsRealPKPi, isRealPKPi, int8_t); +DECLARE_SOA_COLUMN(IsRealLcPKPi, isRealLcPKPi, int8_t); +DECLARE_SOA_COLUMN(IsReflected, isReflected, int8_t); } // namespace charm_polarisation @@ -91,6 +92,7 @@ DECLARE_SOA_TABLE(HfLcPolBkg, "AOD", "HFLCPOLBKG", charm_polarisation::MassPiProton, charm_polarisation::BdtBkgScore, charm_polarisation::IsRealPKPi, + charm_polarisation::IsRealLcPKPi, charm_polarisation::IsReflected); } // namespace o2::aod @@ -140,7 +142,6 @@ struct TaskPolarisationCharmHadrons { float maxInvMass{1000.f}; /// table for Lc->pKpi background studies in MC - Configurable activateTableLcPKPiBkgMc{"activateTableLcPKPiBkgMc", false, "Activate the filling of the table to study Lc->PKPi background from MC"}; Configurable cosThStarAxisLcPKPiBkgMc{"cosThStarAxisLcPKPiBkgMc", 1, "cos(Theta*) axis for background studies (1 = helicity; 2 = production; 3 = beam; 4 = random)"}; Filter filterSelectDstarCandidates = aod::hf_sel_candidate_dstar::isSelDstarToD0Pi == selectionFlagDstarToD0Pi; @@ -182,7 +183,7 @@ struct TaskPolarisationCharmHadrons { void init(InitContext&) { /// check process functions - std::array processes = {doprocessDstar, doprocessDstarWithMl, doprocessLcToPKPi, doprocessLcToPKPiWithMl, doprocessDstarMc, doprocessDstarMcWithMl, doprocessLcToPKPiMc, doprocessLcToPKPiMcWithMl}; + std::array processes = {doprocessDstar, doprocessDstarWithMl, doprocessLcToPKPi, doprocessLcToPKPiWithMl, doprocessDstarMc, doprocessDstarMcWithMl, doprocessLcToPKPiMc, doprocessLcToPKPiMcWithMl, doprocessLcToPKPiBackgroundMcWithMl}; const int nProcesses = std::accumulate(processes.begin(), processes.end(), 0); if (nProcesses > 1) { LOGP(fatal, "Only one process function should be enabled at a time, please check your configuration"); @@ -210,15 +211,10 @@ struct TaskPolarisationCharmHadrons { } // check bkg rotation for MC (not supported currently) - if (nBkgRotations > 0 && (doprocessDstarMc || doprocessDstarMcWithMl || doprocessLcToPKPiMc || doprocessLcToPKPiMcWithMl)) { + if (nBkgRotations > 0 && (doprocessDstarMc || doprocessDstarMcWithMl || doprocessLcToPKPiMc || doprocessLcToPKPiMcWithMl || doprocessLcToPKPiBackgroundMcWithMl)) { LOGP(fatal, "No background rotation supported for MC."); } - /// check configurations of the table for Lc->pKpi background studies - if (activateTableLcPKPiBkgMc && (cosThStarAxisLcPKPiBkgMc < 1 || cosThStarAxisLcPKPiBkgMc > 4)) { - LOGP(fatal, "cosThStarAxisLcPKPiBkgMc axis chosen is wrong. Fix it! (1 = helicity; 2 = production; 3 = beam; 4 = random)"); - } - massPi = o2::constants::physics::MassPiPlus; massProton = o2::constants::physics::MassProton; massKaon = o2::constants::physics::MassKaonCharged; @@ -284,7 +280,7 @@ struct TaskPolarisationCharmHadrons { registry.add("hRecoNonPromptRandom", "THn for polarisation studies with cosThStar w.r.t. random axis and BDT scores -- reco non-prompt signal", HistType::kTHnSparseF, {thnAxisInvMass, thnAxisPt, thnAxisNumPvContributors, thnAxisY, thnAxisInvMassD0, thnAxisCosThetaStarRandom, thnAxisMlBkg, thnAxisMlNonPrompt, thnAxisPtB}); } } - } else if (doprocessLcToPKPiWithMl || doprocessLcToPKPiMcWithMl) { + } else if (doprocessLcToPKPiWithMl || doprocessLcToPKPiMcWithMl || doprocessLcToPKPiBackgroundMcWithMl) { /// analysis for Lc+ baryon with ML, w/ rot. background axis (for data only) if (doprocessLcToPKPiWithMl) { if (activateTHnSparseCosThStarHelicity) { @@ -386,7 +382,7 @@ struct TaskPolarisationCharmHadrons { } // MC Gen histos - if (doprocessDstarMc || doprocessDstarMcWithMl || doprocessLcToPKPiMc || doprocessLcToPKPiMcWithMl) { + if (doprocessDstarMc || doprocessDstarMcWithMl || doprocessLcToPKPiMc || doprocessLcToPKPiMcWithMl || doprocessLcToPKPiBackgroundMcWithMl) { if (activateTHnSparseCosThStarHelicity) { registry.add("hGenPromptHelicity", "THn for polarisation studies with cosThStar w.r.t. helicity axis -- gen prompt signal", HistType::kTHnSparseF, {thnAxisPt, thnAxisNumPvContributors, thnAxisY, thnAxisCosThetaStarHelicity, thnAxisDausAcc, thnAxisResoChannelLc}); registry.add("hGenNonPromptHelicity", "THn for polarisation studies with cosThStar w.r.t. helicity axis -- gen non-prompt signal", HistType::kTHnSparseF, {thnAxisPt, thnAxisNumPvContributors, thnAxisY, thnAxisCosThetaStarHelicity, thnAxisPtB, thnAxisDausAcc, thnAxisResoChannelLc}); @@ -705,14 +701,17 @@ struct TaskPolarisationCharmHadrons { return true; } + /// \param prongTrack is the track we want to find the mother of + /// \param idMothers is the vector containing the mother IDs + /// \param particles are the MC particles template - void searchFirstLevelMother(Trk const& prongTrack, std::vector& idMothers, Part const&) + void searchFirstLevelMother(Trk const& prongTrack, std::vector& idMothers, Part const& /*particles*/) { /// particle associated to the prong track if (!prongTrack.has_mcParticle()) { return; } - auto prongParticle = prongTrack.mcParticle(); + auto prongParticle = prongTrack.template mcParticle_as(); /// leave the vector of mother indices empty if the currect paticle has no mothers if (!prongParticle.has_mothers()) { return; @@ -727,9 +726,11 @@ struct TaskPolarisationCharmHadrons { /// \param candidates are the selected candidates /// \param bkgRotationId is the id for the background rotation /// \param numPvContributors is the number of PV contributors + /// \param particles are the generated particles + /// \param tracks are the reconstructed tracks /// \return true if candidate in signal region - template - bool runPolarisationAnalysis(Cand const& candidate, Part const& particles, int bkgRotationId, int numPvContributors, Trk const&) + template + bool runPolarisationAnalysis(Cand const& candidate, int bkgRotationId, int numPvContributors, Part const& particles, Trk const& /*tracks*/) { bool isCandidateInSignalRegion{false}; int8_t origin{RecoDecay::OriginType::None}; @@ -749,16 +750,18 @@ struct TaskPolarisationCharmHadrons { return isCandidateInSignalRegion; } } else if constexpr (channel == charm_polarisation::DecayChannel::LcToPKPi) { - if (!TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_3prong::DecayType::LcToPKPi)) { // this candidate is not signal, skip - return isCandidateInSignalRegion; - } - origin = candidate.originMcRec(); - if (candidate.isCandidateSwapped()) { - massHypoMcTruth = charm_polarisation::MassHyposLcToPKPi::PiKP; - } else { - massHypoMcTruth = charm_polarisation::MassHyposLcToPKPi::PKPi; + if constexpr (!studyLcPKPiBkgMc) { // skip this if studyLcPKPiBkgMc is true, since we are interested in background + if (!TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_3prong::DecayType::LcToPKPi)) { // this candidate is not signal, skip + return isCandidateInSignalRegion; + } + origin = candidate.originMcRec(); + if (candidate.isCandidateSwapped()) { + massHypoMcTruth = charm_polarisation::MassHyposLcToPKPi::PiKP; + } else { + massHypoMcTruth = charm_polarisation::MassHyposLcToPKPi::PKPi; + } + resoChannelLc = candidate.flagMcDecayChanRec(); /// 0: direct; 1: Λc± → p± K*; 2: Λc± → Δ(1232)±± K∓; 3: Λc± → Λ(1520) π± } - resoChannelLc = candidate.flagMcDecayChanRec(); /// 0: direct; 1: Λc± → p± K*; 2: Λc± → Δ(1232)±± K∓; 3: Λc± → Λ(1520) π± } } @@ -965,10 +968,23 @@ struct TaskPolarisationCharmHadrons { /// Table for Lc->pKpi background studies /// Defined only in MC simulations, to study resonances and reflected signal if constexpr (doMc && channel == charm_polarisation::DecayChannel::LcToPKPi) { - if (activateTableLcPKPiBkgMc) { + if constexpr (studyLcPKPiBkgMc) { + /****************************************************************************************** + The code below can work only without grouping on "mcCollision". + In fact, grouping by "mcCollision" introduces the following inconsistencies: + + 1) the particle getters "track.template mcParticle_as()" retrieve the daughter particles quering the full particle table in the dataframe. + In other words, even if the 3-prong candidate is reconstructed in a completely wrong reco. collision due to the track-to-collision associator, + therefore this collision points to a "mcCollision" different from the current one and the daughter particles are associated to this different "mcCollision", + the getter "mcParticle_as" works anyway, because it works with unbound tables ignoring the fact that "particles" is grouped; + + 2) when we look for the mother index from the daughter particles of the previous point, but the daughter particles belong to a "mcCollision" different from the current one, + then also the mother particle belongs to this different "mcCollision". This means that the mother index ( - "particles.offset()") is outside the "particles.size()", + because the table "particles" is grouped w.r.t. the current "mcCollision". + *******************************************************************************************/ /// check if the tracks are associated to a pion + a kaon + a proton - bool isRealPKPi = false; /// true only if the triplet is formed by a MC pion + a MC kaon + a MC proton + int8_t isRealPKPi = 0; /// true only if the triplet is formed by a MC pion + a MC kaon + a MC proton bool isGenPKPi = false; bool isGenPiKP = false; auto trackProng0 = candidate.template prong0_as(); @@ -978,25 +994,40 @@ struct TaskPolarisationCharmHadrons { int pdgProng1 = 0; int pdgProng2 = 0; if (trackProng0.has_mcParticle()) { - pdgProng0 = trackProng0.mcParticle().pdgCode(); + /// BEWARE: even when grouping by mcCollision, mcParticle_as<> gets the mcParticle even if it belongs to a different mcCollision + /// because _as<> works with unbound tables. (*) + auto particleProng0 = trackProng0.template mcParticle_as(); + pdgProng0 = particleProng0.pdgCode(); } if (trackProng1.has_mcParticle()) { - pdgProng1 = trackProng1.mcParticle().pdgCode(); + /// BEWARE: even when grouping by mcCollision, mcParticle_as<> gets the mcParticle even if it belongs to a different mcCollision + /// because _as<> works with unbound tables. (*) + auto particleProng1 = trackProng1.template mcParticle_as(); + pdgProng1 = particleProng1.pdgCode(); } if (trackProng2.has_mcParticle()) { - pdgProng2 = trackProng2.mcParticle().pdgCode(); + /// BEWARE: even when grouping by mcCollision, mcParticle_as<> gets the mcParticle even if it belongs to a different mcCollision + /// because _as<> works with unbound tables. (*) + auto particleProng2 = trackProng2.template mcParticle_as(); + pdgProng2 = particleProng2.pdgCode(); } isGenPKPi = std::abs(pdgProng0) == kProton && std::abs(pdgProng1) == kKPlus && std::abs(pdgProng2) == kPiPlus; isGenPiKP = std::abs(pdgProng0) == kPiPlus && std::abs(pdgProng1) == kKPlus && std::abs(pdgProng2) == kProton; if (isGenPKPi || isGenPiKP) { - isRealPKPi = true; + isRealPKPi = 1; } /// check if the triplet is reflected or not /// i.e. generated as pKpi but reconstructed as piKp, or viceversa - bool isReflected = false; + int8_t isReflected = 0; if (isRealPKPi && ((iMass == charm_polarisation::MassHyposLcToPKPi::PKPi && candidate.isSelLcToPKPi() >= selectionFlagLcToPKPi && isGenPiKP) || (iMass == charm_polarisation::MassHyposLcToPKPi::PiKP && candidate.isSelLcToPiKP() >= selectionFlagLcToPKPi && isGenPKPi))) { - isReflected = true; + isReflected = 1; + } + + /// check if the pKpi triplet is a Lc->pKpi + int8_t isRealLcPKPi = 0; + if (isRealPKPi && TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_3prong::DecayType::LcToPKPi)) { + isRealLcPKPi = 1; } /// look for daughters' mothers (1st level only) @@ -1013,16 +1044,22 @@ struct TaskPolarisationCharmHadrons { int pdgMotherProng1 = -1; int pdgMotherProng2 = -1; if (idMothersProng0.size() > 0 && idMothersProng1.size() > 0 && idMothersProng0.at(0) == idMothersProng1.at(0)) { + /// BEWARE: in case of mcCollision grouping, the idMother can anyway point to a particle in another collision (*) + /// therefore the rawIteratorAt call might crash the code because one goes above the (grouped) particles table size auto mother = particles.rawIteratorAt(idMothersProng0.at(0) - particles.offset()); pdgMotherProng0 = std::abs(mother.pdgCode()); // PDG code of the mother pdgMotherProng1 = pdgMotherProng0; } if (idMothersProng1.size() > 0 && idMothersProng2.size() > 0 && idMothersProng1.at(0) == idMothersProng2.at(0)) { + /// BEWARE: in case of mcCollision grouping, the idMother can anyway point to a particle in another collision (*) + /// therefore the rawIteratorAt call might crash the code because one goes above the (grouped) particles table size auto mother = particles.rawIteratorAt(idMothersProng1.at(0) - particles.offset()); pdgMotherProng1 = std::abs(mother.pdgCode()); // PDG code of the mother pdgMotherProng2 = pdgMotherProng1; } if (idMothersProng0.size() > 0 && idMothersProng2.size() > 0 && idMothersProng0.at(0) == idMothersProng2.at(0)) { + /// BEWARE: in case of mcCollision grouping, the idMother can anyway point to a particle in another collision (*) + /// therefore the rawIteratorAt call might crash the code because one goes above the (grouped) particles table size auto mother = particles.rawIteratorAt(idMothersProng0.at(0) - particles.offset()); pdgMotherProng0 = std::abs(mother.pdgCode()); // PDG code of the mother pdgMotherProng2 = pdgMotherProng0; @@ -1059,14 +1096,17 @@ struct TaskPolarisationCharmHadrons { case 4: cosThetaStarForTable = cosThetaStarRandom; break; + default: + LOG(fatal) << "cosThStarAxisLcPKPiBkgMc must be between 1 and 4 (1: helicity; 2: production; 3: beam; 4: random), but cosThStarAxisLcPKPiBkgMc = " << cosThStarAxisLcPKPiBkgMc << ". Fix it!"; + break; } rowCandLcBkg(invMassCharmHadForSparse, ptCharmHad, rapidity, cosThetaStarForTable, pdgMotherProng0, pdgMotherProng1, pdgMotherProng2, massKPi, massKProton, massPiProton, outputMl.at(0), - isRealPKPi, isReflected); - } // end activateTableLcPKPiBkgMc + isRealPKPi, isRealLcPKPi, isReflected); + } // end studyLcPKPiBkgMc } // end table for Lc->pKpi background studies } /// end loop over mass hypotheses @@ -1207,12 +1247,12 @@ struct TaskPolarisationCharmHadrons { for (const auto& dstarCandidate : groupedDstarCandidates) { nCands++; - if (runPolarisationAnalysis(dstarCandidate, -1 /*MC particles*/, 0, numPvContributors, -1 /*tracks*/)) { + if (runPolarisationAnalysis(dstarCandidate, 0, numPvContributors, -1 /*MC particles*/, -1 /*tracks*/)) { nCandsInSignalRegion++; } for (int iRotation{1}; iRotation <= nBkgRotations; ++iRotation) { - runPolarisationAnalysis(dstarCandidate, -1 /*MC particles*/, iRotation, numPvContributors, -1 /*tracks*/); + runPolarisationAnalysis(dstarCandidate, iRotation, numPvContributors, -1 /*MC particles*/, -1 /*tracks*/); } } fillMultHistos(numPvContributors, nCands, nCandsInSignalRegion); @@ -1232,12 +1272,12 @@ struct TaskPolarisationCharmHadrons { for (const auto& dstarCandidate : groupedDstarCandidates) { nCands++; - if (runPolarisationAnalysis(dstarCandidate, -1 /*MC particles*/, 0, numPvContributors, -1 /*tracks*/)) { + if (runPolarisationAnalysis(dstarCandidate, 0, numPvContributors, -1 /*MC particles*/, -1 /*tracks*/)) { nCandsInSignalRegion++; } for (int iRotation{1}; iRotation <= nBkgRotations; ++iRotation) { - runPolarisationAnalysis(dstarCandidate, -1 /*MC particles*/, iRotation, numPvContributors, -1 /*tracks*/); + runPolarisationAnalysis(dstarCandidate, iRotation, numPvContributors, -1 /*MC particles*/, -1 /*tracks*/); } } fillMultHistos(numPvContributors, nCands, nCandsInSignalRegion); @@ -1264,7 +1304,7 @@ struct TaskPolarisationCharmHadrons { for (const auto& dstarCandidate : groupedDstarCandidates) { nCands++; - if (runPolarisationAnalysis(dstarCandidate, -1 /*MC particles*/, 0, numPvContributors, -1 /*tracks*/)) { + if (runPolarisationAnalysis(dstarCandidate, 0, numPvContributors, -1 /*MC particles*/, -1 /*tracks*/)) { nCandsInSignalRegion++; } } @@ -1296,7 +1336,7 @@ struct TaskPolarisationCharmHadrons { for (const auto& dstarCandidate : groupedDstarCandidates) { nCands++; - if (runPolarisationAnalysis(dstarCandidate, -1 /*MC particles*/, 0, numPvContributors, -1 /*tracks*/)) { + if (runPolarisationAnalysis(dstarCandidate, 0, numPvContributors, -1 /*MC particles*/, -1 /*tracks*/)) { nCandsInSignalRegion++; } } @@ -1325,13 +1365,13 @@ struct TaskPolarisationCharmHadrons { for (const auto& lcCandidate : groupedLcCandidates) { nCands++; - if (runPolarisationAnalysis(lcCandidate, -1 /*MC particles*/, 0, numPvContributors, -1 /*tracks*/)) { + if (runPolarisationAnalysis(lcCandidate, 0, numPvContributors, -1 /*MC particles*/, -1 /*tracks*/)) { nCandsInSignalRegion++; } /// rotational background for (int iRotation{1}; iRotation <= nBkgRotations; ++iRotation) { - runPolarisationAnalysis(lcCandidate, -1 /*MC particles*/, iRotation, numPvContributors, -1 /*tracks*/); + runPolarisationAnalysis(lcCandidate, iRotation, numPvContributors, -1 /*MC particles*/, -1 /*tracks*/); } } fillMultHistos(numPvContributors, nCands, nCandsInSignalRegion); @@ -1351,13 +1391,13 @@ struct TaskPolarisationCharmHadrons { for (const auto& lcCandidate : groupedLcCandidates) { nCands++; - if (runPolarisationAnalysis(lcCandidate, -1 /*MC particles*/, 0, numPvContributors, -1 /*tracks*/)) { + if (runPolarisationAnalysis(lcCandidate, 0, numPvContributors, -1 /*MC particles*/, -1 /*tracks*/)) { nCandsInSignalRegion++; } /// rotational background for (int iRotation{1}; iRotation <= nBkgRotations; ++iRotation) { - runPolarisationAnalysis(lcCandidate, -1 /*MC particles*/, iRotation, numPvContributors, -1 /*tracks*/); + runPolarisationAnalysis(lcCandidate, iRotation, numPvContributors, -1 /*MC particles*/, -1 /*tracks*/); } } fillMultHistos(numPvContributors, nCands, nCandsInSignalRegion); @@ -1369,8 +1409,7 @@ struct TaskPolarisationCharmHadrons { void processLcToPKPiMc(aod::McCollisions::iterator const&, McParticles3ProngMatched const& mcParticles, CollisionsWithMcLabels const& collisions, // this is grouped with SmallGroupsCollisionsWithMcLabels const& collisions, - FilteredCandLcToPKPiWSelFlagAndMc const& lcCandidates, - TracksWithMcLabels const& tracks) + FilteredCandLcToPKPiWSelFlagAndMc const& lcCandidates) { int numPvContributorsGen{0}; for (const auto& collision : collisions) { // loop over reco collisions associated to this gen collision @@ -1385,7 +1424,7 @@ struct TaskPolarisationCharmHadrons { for (const auto& lcCandidate : groupedLcCandidates) { nCands++; - if (runPolarisationAnalysis(lcCandidate, mcParticles, 0, numPvContributors, tracks)) { + if (runPolarisationAnalysis(lcCandidate, 0, numPvContributors, -1 /*MC particles*/, -1 /*tracks*/)) { nCandsInSignalRegion++; } } @@ -1402,8 +1441,7 @@ struct TaskPolarisationCharmHadrons { void processLcToPKPiMcWithMl(aod::McCollisions::iterator const&, McParticles3ProngMatched const& mcParticles, CollisionsWithMcLabels const& collisions, // this is grouped with SmallGroups - FilteredCandLcToPKPiWSelFlagAndMcAndMl const& lcCandidates, - TracksWithMcLabels const& tracks) + FilteredCandLcToPKPiWSelFlagAndMcAndMl const& lcCandidates) { int numPvContributorsGen{0}; for (const auto& collision : collisions) { // loop over reco collisions associated to this gen collision @@ -1418,7 +1456,7 @@ struct TaskPolarisationCharmHadrons { for (const auto& lcCandidate : groupedLcCandidates) { nCands++; - if (runPolarisationAnalysis(lcCandidate, mcParticles, 0, numPvContributors, tracks)) { + if (runPolarisationAnalysis(lcCandidate, 0, numPvContributors, -1 /*MC particles*/, -1 /*tracks*/)) { nCandsInSignalRegion++; } } @@ -1430,6 +1468,21 @@ struct TaskPolarisationCharmHadrons { } } PROCESS_SWITCH(TaskPolarisationCharmHadrons, processLcToPKPiMcWithMl, "Process Lc candidates in MC with ML", false); + + // Lc->pKpi in MC with ML cuts w/o mcCollision grouping (to study Lc background) + void processLcToPKPiBackgroundMcWithMl(McParticles3ProngMatched const& mcParticles, + FilteredCandLcToPKPiWSelFlagAndMcAndMl const& lcCandidates, + TracksWithMcLabels const& tracks) + { + for (const auto& lcCandidate : lcCandidates) { + runPolarisationAnalysis(lcCandidate, 0, /*numPvContributors*/ -1, mcParticles, tracks); + } + + for (const auto& mcParticle : mcParticles) { + runMcGenPolarisationAnalysis(mcParticle, mcParticles, /*numPvContributorsGen*/ -1); + } + } + PROCESS_SWITCH(TaskPolarisationCharmHadrons, processLcToPKPiBackgroundMcWithMl, "Process Lc candidates in MC with ML w/o mcCollision grouping", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)