diff --git a/PWGCF/Femto/Core/closePairRejection.h b/PWGCF/Femto/Core/closePairRejection.h index 4430a093b06..4175758fa91 100644 --- a/PWGCF/Femto/Core/closePairRejection.h +++ b/PWGCF/Femto/Core/closePairRejection.h @@ -116,7 +116,7 @@ constexpr char PrefixV0V0PosSe[] = "CPR_V0V0_PosDau/SE/"; constexpr char PrefixV0V0NegSe[] = "CPR_V0V0_NegDau/SE/"; constexpr char PrefixV0V0PosMe[] = "CPR_V0V0_PosDau/ME/"; constexpr char PrefixV0V0NegMe[] = "CPR_V0V0_NegDau/ME/"; -constexpr char PrefixV0TwoTrackResonancePosSe[] = "CPR_V0V0_PosDau/SE/"; +constexpr char PrefixV0TwoTrackResonancePosSe[] = "CPR_V0Resonance_PosDau/SE/"; constexpr char PrefixV0TwoTrackResonanceNegSe[] = "CPR_V0Resonance_NegDau/SE/"; constexpr char PrefixV0TwoTrackResonancePosMe[] = "CPR_V0Resonance_PosDau/ME/"; constexpr char PrefixV0TwoTrackResonanceNegMe[] = "CPR_V0Resonance_NegDau/ME/"; diff --git a/PWGCF/Femto/Core/twoTrackResonanceBuilder.h b/PWGCF/Femto/Core/twoTrackResonanceBuilder.h index 21ca5ff343c..147c082fb61 100644 --- a/PWGCF/Femto/Core/twoTrackResonanceBuilder.h +++ b/PWGCF/Femto/Core/twoTrackResonanceBuilder.h @@ -210,7 +210,7 @@ class TwoTrackResonanceBuilder return ((mMass > mMassMin && mMass < mMassMax) && (mPt > mPtMin && mPt < mPtMax) && (mEta > mEtaMin && mEta < mEtaMax) && - (mPhi > mPhiMin && mPhi < mPhiMax)); + (mPhi >= mPhiMin && mPhi < mPhiMax)); } template @@ -278,7 +278,7 @@ class TwoTrackResonanceBuilder if constexpr (modes::isEqual(resoType, modes::TwoTrackResonance::kKstar0Bar)) { if (mProduceKstar0s) { resonanceProducts.producedKstars(col.globalIndex(), - mPt, + -1.f * mPt, mEta, mPhi, mMass, diff --git a/PWGCF/Femto/Core/twoTrackResonanceHistManager.h b/PWGCF/Femto/Core/twoTrackResonanceHistManager.h index a8171a1b5fd..561d3f5830c 100644 --- a/PWGCF/Femto/Core/twoTrackResonanceHistManager.h +++ b/PWGCF/Femto/Core/twoTrackResonanceHistManager.h @@ -161,11 +161,11 @@ class TwoTrackResonanceHistManager negDauPdgCodeAbs = std::abs(PDG_t::kPiMinus); } else { mPdgCode = -1 * mPdgCode; - posDauPdgCodeAbs = std::abs(PDG_t::kKMinus); - negDauPdgCodeAbs = std::abs(PDG_t::kPiPlus); + posDauPdgCodeAbs = std::abs(PDG_t::kPiPlus); + negDauPdgCodeAbs = std::abs(PDG_t::kKMinus); } } else { - LOG(fatal) << "PDG code for V0 has to be either Lambda or K0short"; + LOG(fatal) << "PDG code for Resonance has to be either Phi, Rho or K*0"; } mPosDauManager.template init(registry, PosDauSpecs, absCharge, signPlus, posDauPdgCodeAbs); diff --git a/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx b/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx index 9c70d80614a..ff71243e53c 100644 --- a/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx +++ b/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx @@ -152,12 +152,12 @@ struct FemtoPairTrackTwoTrackResonance { { if (((doprocessPhiSameEvent || doprocessPhiMixedEvent) + (doprocessKstar0SameEvent || doprocessKstar0MixedEvent)) + (doprocessRho0SameEvent || doprocessRho0MixedEvent) > 1) { - LOG(fatal) << "Can only process phi-tracks, rho-tracks or k0*-tracks"; + LOG(fatal) << "Can only process SE/ME for phi-tracks, rho-tracks or k0*-tracks"; } // setup columnpolicy for binning // default values are used during instantiation, so we need to explicity update them here - mixBinsVtxMult = {{confMixing.vtxBins, confMixing.multBins.value}, true}; + mixBinsVtxMult = {{confMixing.vtxBins.value, confMixing.multBins.value}, true}; mixBinsVtxCent = {{confMixing.vtxBins.value, confMixing.centBins.value}, true}; mixBinsVtxMultCent = {{confMixing.vtxBins.value, confMixing.multBins.value, confMixing.centBins.value}, true}; diff --git a/PWGCF/Femto/Tasks/femtoPairV0TwoTrackResonance.cxx b/PWGCF/Femto/Tasks/femtoPairV0TwoTrackResonance.cxx index 5622d735fa6..80211c7020a 100644 --- a/PWGCF/Femto/Tasks/femtoPairV0TwoTrackResonance.cxx +++ b/PWGCF/Femto/Tasks/femtoPairV0TwoTrackResonance.cxx @@ -10,7 +10,7 @@ // or submit itself to any jurisdiction. /// \file femtoPairV0TwoTrackResonance.cxx -/// \brief Tasks that computes correlation between tracks and resonances decaying into two tracks +/// \brief Tasks that computes correlation between v0s and resonances decaying into two tracks /// \author Anton Riedel, TU München, anton.riedel@cern.ch #include "PWGCF/Femto/Core/closePairRejection.h" @@ -86,8 +86,8 @@ struct FemtoPairV0TwoTrackResonance { v0histmanager::ConfK0shortBinning1 confK0shortBinning; particlecleaner::ConfK0shortCleaner1 confK0shortCleaner; - o2::framework::Partition k0shortPartition = MAKE_K0SHORT_PARTITION(k0shortSelection); - o2::framework::Preslice perColk0shorts = o2::aod::femtobase::stored::fColId; + o2::framework::Partition k0shortPartition = MAKE_K0SHORT_PARTITION(k0shortSelection); + o2::framework::Preslice perColK0shorts = o2::aod::femtobase::stored::fColId; // setup for daughters for resonances trackhistmanager::ConfResonancePosDauBinning confResoPosDauBinning; @@ -105,7 +105,7 @@ struct FemtoPairV0TwoTrackResonance { o2::framework::Partition kstar0Partition = MAKE_RESONANCE_1_PARTITON(kstar0Selection); o2::framework::Preslice perColKstar0s = o2::aod::femtobase::stored::fColId; - // rho0s + // setup rho0s twotrackresonancebuilder::ConfRho0Selection rho0Selection; twotrackresonancehistmanager::ConfRho0Binning confRho0Binning; o2::framework::Partition rho0Partition = MAKE_RESONANCE_0_PARTITON(rho0Selection); @@ -133,6 +133,96 @@ struct FemtoPairV0TwoTrackResonance { modes::TwoTrackResonance::kPhi> pairLambdaPhiBuilder; + // setup for lambda-kstar0 pairs + pairbuilder::PairV0TwoTrackResonanceBuilder< + v0histmanager::PrefixLambda1, + trackhistmanager::PrefixV01PosDaughter, + trackhistmanager::PrefixV01NegDaughter, + twotrackresonancehistmanager::PrefixKstar, + trackhistmanager::PrefixResonancePosDaughter, + trackhistmanager::PrefixResonanceNegDaughter, + pairhistmanager::PrefixV0ResonanceSe, + pairhistmanager::PrefixV0ResonanceMe, + closepairrejection::PrefixV0TwoTrackResonancePosSe, + closepairrejection::PrefixV0TwoTrackResonanceNegSe, + closepairrejection::PrefixV0TwoTrackResonancePosMe, + closepairrejection::PrefixV0TwoTrackResonanceNegMe, + modes::V0::kLambda, + modes::TwoTrackResonance::kKstar0> + pairLambdaKstar0Builder; + + // setup for lambda-rho0 pairs + pairbuilder::PairV0TwoTrackResonanceBuilder< + v0histmanager::PrefixLambda1, + trackhistmanager::PrefixV01PosDaughter, + trackhistmanager::PrefixV01NegDaughter, + twotrackresonancehistmanager::PrefixRho, + trackhistmanager::PrefixResonancePosDaughter, + trackhistmanager::PrefixResonanceNegDaughter, + pairhistmanager::PrefixV0ResonanceSe, + pairhistmanager::PrefixV0ResonanceMe, + closepairrejection::PrefixV0TwoTrackResonancePosSe, + closepairrejection::PrefixV0TwoTrackResonanceNegSe, + closepairrejection::PrefixV0TwoTrackResonancePosMe, + closepairrejection::PrefixV0TwoTrackResonanceNegMe, + modes::V0::kLambda, + modes::TwoTrackResonance::kRho0> + pairLambdaRho0Builder; + + // setup for k0short-phi pairs + pairbuilder::PairV0TwoTrackResonanceBuilder< + v0histmanager::PrefixK0short1, + trackhistmanager::PrefixV01PosDaughter, + trackhistmanager::PrefixV01NegDaughter, + twotrackresonancehistmanager::PrefixPhi, + trackhistmanager::PrefixResonancePosDaughter, + trackhistmanager::PrefixResonanceNegDaughter, + pairhistmanager::PrefixV0ResonanceSe, + pairhistmanager::PrefixV0ResonanceMe, + closepairrejection::PrefixV0TwoTrackResonancePosSe, + closepairrejection::PrefixV0TwoTrackResonanceNegSe, + closepairrejection::PrefixV0TwoTrackResonancePosMe, + closepairrejection::PrefixV0TwoTrackResonanceNegMe, + modes::V0::kK0short, + modes::TwoTrackResonance::kPhi> + pairK0shortPhiBuilder; + + // setup for k0short-kstar0 pairs + pairbuilder::PairV0TwoTrackResonanceBuilder< + v0histmanager::PrefixK0short1, + trackhistmanager::PrefixV01PosDaughter, + trackhistmanager::PrefixV01NegDaughter, + twotrackresonancehistmanager::PrefixKstar, + trackhistmanager::PrefixResonancePosDaughter, + trackhistmanager::PrefixResonanceNegDaughter, + pairhistmanager::PrefixV0ResonanceSe, + pairhistmanager::PrefixV0ResonanceMe, + closepairrejection::PrefixV0TwoTrackResonancePosSe, + closepairrejection::PrefixV0TwoTrackResonanceNegSe, + closepairrejection::PrefixV0TwoTrackResonancePosMe, + closepairrejection::PrefixV0TwoTrackResonanceNegMe, + modes::V0::kK0short, + modes::TwoTrackResonance::kKstar0> + pairK0shortKstar0Builder; + + // setup for k0short-rho0 pairs + pairbuilder::PairV0TwoTrackResonanceBuilder< + v0histmanager::PrefixK0short1, + trackhistmanager::PrefixV01PosDaughter, + trackhistmanager::PrefixV01NegDaughter, + twotrackresonancehistmanager::PrefixRho, + trackhistmanager::PrefixResonancePosDaughter, + trackhistmanager::PrefixResonanceNegDaughter, + pairhistmanager::PrefixV0ResonanceSe, + pairhistmanager::PrefixV0ResonanceMe, + closepairrejection::PrefixV0TwoTrackResonancePosSe, + closepairrejection::PrefixV0TwoTrackResonanceNegSe, + closepairrejection::PrefixV0TwoTrackResonancePosMe, + closepairrejection::PrefixV0TwoTrackResonanceNegMe, + modes::V0::kK0short, + modes::TwoTrackResonance::kRho0> + pairK0shortRho0Builder; + // setup mixing std::vector defaultVtxBins{10, -10, 10}; std::vector defaultMultBins{50, 0, 200}; @@ -152,42 +242,157 @@ struct FemtoPairV0TwoTrackResonance { void init(o2::framework::InitContext&) { + // all pair combinations share the same histogram prefixes, so only one combination can be processed per workflow instance + if ((doprocessLambdaPhiSameEvent || doprocessLambdaPhiMixedEvent) + + (doprocessLambdaKstar0SameEvent || doprocessLambdaKstar0MixedEvent) + + (doprocessLambdaRho0SameEvent || doprocessLambdaRho0MixedEvent) + + (doprocessK0shortPhiSameEvent || doprocessK0shortPhiMixedEvent) + + (doprocessK0shortKstar0SameEvent || doprocessK0shortKstar0MixedEvent) + + (doprocessK0shortRho0SameEvent || doprocessK0shortRho0MixedEvent) > + 1) { + LOG(fatal) << "Can only process one v0-resonance combination (lambda/k0short x phi/kstar0/rho0)"; + } + // setup columnpolicy for binning // default values are used during instantiation, so we need to explicity update them here - mixBinsVtxMult = {{confMixing.vtxBins, confMixing.multBins.value}, true}; + mixBinsVtxMult = {{confMixing.vtxBins.value, confMixing.multBins.value}, true}; mixBinsVtxCent = {{confMixing.vtxBins.value, confMixing.centBins.value}, true}; mixBinsVtxMultCent = {{confMixing.vtxBins.value, confMixing.multBins.value, confMixing.centBins.value}, true}; // setup histograms auto colHistSpec = colhistmanager::makeColHistSpecMap(confCollisionBinning); - auto lambdaHistSpec = v0histmanager::makeV0HistSpecMap(confLambdaBinning); auto v0PosDauSpec = trackhistmanager::makeTrackHistSpecMap(confV0PosDauBinning); auto v0NegDauSpec = trackhistmanager::makeTrackHistSpecMap(confV0NegDauBinning); - auto phiHistSpec = twotrackresonancehistmanager::makeTwoTrackResonanceHistSpecMap(confPhiBinning); auto resoPosDauSpec = trackhistmanager::makeTrackHistSpecMap(confResoPosDauBinning); - auto resov0NegDauSpec = trackhistmanager::makeTrackHistSpecMap(confResoNegDauBinning); + auto resoNegDauSpec = trackhistmanager::makeTrackHistSpecMap(confResoNegDauBinning); auto cprHistSpecPos = closepairrejection::makeCprHistSpecMap(confCprPos); auto cprHistSpecNeg = closepairrejection::makeCprHistSpecMap(confCprNeg); auto pairV0TwoTrackResonanceHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confMixing); - pairLambdaPhiBuilder.init(&hRegistry, confCollisionBinning, lambdaSelection, phiSelection, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, lambdaHistSpec, v0PosDauSpec, v0NegDauSpec, phiHistSpec, resoPosDauSpec, resov0NegDauSpec, pairV0TwoTrackResonanceHistSpec, cprHistSpecPos, cprHistSpecNeg); - }; + // setup for lambda-phi + if (doprocessLambdaPhiSameEvent || doprocessLambdaPhiMixedEvent) { + auto lambdaHistSpec = v0histmanager::makeV0HistSpecMap(confLambdaBinning); + auto phiHistSpec = twotrackresonancehistmanager::makeTwoTrackResonanceHistSpecMap(confPhiBinning); + pairLambdaPhiBuilder.init(&hRegistry, confCollisionBinning, lambdaSelection, phiSelection, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, lambdaHistSpec, v0PosDauSpec, v0NegDauSpec, phiHistSpec, resoPosDauSpec, resoNegDauSpec, pairV0TwoTrackResonanceHistSpec, cprHistSpecPos, cprHistSpecNeg); + } + + // setup for lambda-kstar0 + if (doprocessLambdaKstar0SameEvent || doprocessLambdaKstar0MixedEvent) { + auto lambdaHistSpec = v0histmanager::makeV0HistSpecMap(confLambdaBinning); + auto kstar0HistSpec = twotrackresonancehistmanager::makeTwoTrackResonanceHistSpecMap(confKstar0Binning); + pairLambdaKstar0Builder.init(&hRegistry, confCollisionBinning, lambdaSelection, kstar0Selection, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, lambdaHistSpec, v0PosDauSpec, v0NegDauSpec, kstar0HistSpec, resoPosDauSpec, resoNegDauSpec, pairV0TwoTrackResonanceHistSpec, cprHistSpecPos, cprHistSpecNeg); + } + + // setup for lambda-rho0 + if (doprocessLambdaRho0SameEvent || doprocessLambdaRho0MixedEvent) { + auto lambdaHistSpec = v0histmanager::makeV0HistSpecMap(confLambdaBinning); + auto rho0HistSpec = twotrackresonancehistmanager::makeTwoTrackResonanceHistSpecMap(confRho0Binning); + pairLambdaRho0Builder.init(&hRegistry, confCollisionBinning, lambdaSelection, rho0Selection, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, lambdaHistSpec, v0PosDauSpec, v0NegDauSpec, rho0HistSpec, resoPosDauSpec, resoNegDauSpec, pairV0TwoTrackResonanceHistSpec, cprHistSpecPos, cprHistSpecNeg); + } + + // setup for k0short-phi + if (doprocessK0shortPhiSameEvent || doprocessK0shortPhiMixedEvent) { + auto k0shortHistSpec = v0histmanager::makeV0HistSpecMap(confK0shortBinning); + auto phiHistSpec = twotrackresonancehistmanager::makeTwoTrackResonanceHistSpecMap(confPhiBinning); + pairK0shortPhiBuilder.init(&hRegistry, confCollisionBinning, k0shortSelection, phiSelection, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, k0shortHistSpec, v0PosDauSpec, v0NegDauSpec, phiHistSpec, resoPosDauSpec, resoNegDauSpec, pairV0TwoTrackResonanceHistSpec, cprHistSpecPos, cprHistSpecNeg); + } + + // setup for k0short-kstar0 + if (doprocessK0shortKstar0SameEvent || doprocessK0shortKstar0MixedEvent) { + auto k0shortHistSpec = v0histmanager::makeV0HistSpecMap(confK0shortBinning); + auto kstar0HistSpec = twotrackresonancehistmanager::makeTwoTrackResonanceHistSpecMap(confKstar0Binning); + pairK0shortKstar0Builder.init(&hRegistry, confCollisionBinning, k0shortSelection, kstar0Selection, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, k0shortHistSpec, v0PosDauSpec, v0NegDauSpec, kstar0HistSpec, resoPosDauSpec, resoNegDauSpec, pairV0TwoTrackResonanceHistSpec, cprHistSpecPos, cprHistSpecNeg); + } + + // setup for k0short-rho0 + if (doprocessK0shortRho0SameEvent || doprocessK0shortRho0MixedEvent) { + auto k0shortHistSpec = v0histmanager::makeV0HistSpecMap(confK0shortBinning); + auto rho0HistSpec = twotrackresonancehistmanager::makeTwoTrackResonanceHistSpecMap(confRho0Binning); + pairK0shortRho0Builder.init(&hRegistry, confCollisionBinning, k0shortSelection, rho0Selection, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, k0shortHistSpec, v0PosDauSpec, v0NegDauSpec, rho0HistSpec, resoPosDauSpec, resoNegDauSpec, pairV0TwoTrackResonanceHistSpec, cprHistSpecPos, cprHistSpecNeg); + } + } + // lambda-phi void processLambdaPhiSameEvent(FilteredCollision const& col, FemtoTracks const& tracks, FemtoLambdas const& /*lambdas*/, FemtoPhis const& /*phis*/) { pairLambdaPhiBuilder.processSameEvent(col, tracks, lambdaPartition, phiPartition, cache); } PROCESS_SWITCH(FemtoPairV0TwoTrackResonance, processLambdaPhiSameEvent, "Enable processing same event processing for lambdas and phis", true); - void processLambdaPhiMixedEvent(FilteredCollisions const& cols, FemtoTracks const& tracks, FemtoLambdas const& /*lambda*/, FemtoPhis const& /*phis*/) + void processLambdaPhiMixedEvent(FilteredCollisions const& cols, FemtoTracks const& tracks, FemtoLambdas const& /*lambdas*/, FemtoPhis const& /*phis*/) { pairLambdaPhiBuilder.processMixedEvent(cols, tracks, lambdaPartition, phiPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairV0TwoTrackResonance, processLambdaPhiMixedEvent, "Enable processing mixed event processing for lambdas and phis", true); + + // lambda-kstar0 + void processLambdaKstar0SameEvent(FilteredCollision const& col, FemtoTracks const& tracks, FemtoLambdas const& /*lambdas*/, FemtoKstar0s const& /*kstar0s*/) + { + pairLambdaKstar0Builder.processSameEvent(col, tracks, lambdaPartition, kstar0Partition, cache); + } + PROCESS_SWITCH(FemtoPairV0TwoTrackResonance, processLambdaKstar0SameEvent, "Enable processing same event processing for lambdas and kstar0s", false); + + void processLambdaKstar0MixedEvent(FilteredCollisions const& cols, FemtoTracks const& tracks, FemtoLambdas const& /*lambdas*/, FemtoKstar0s const& /*kstar0s*/) + { + pairLambdaKstar0Builder.processMixedEvent(cols, tracks, lambdaPartition, kstar0Partition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + } + PROCESS_SWITCH(FemtoPairV0TwoTrackResonance, processLambdaKstar0MixedEvent, "Enable processing mixed event processing for lambdas and kstar0s", false); + + // lambda-rho0 + void processLambdaRho0SameEvent(FilteredCollision const& col, FemtoTracks const& tracks, FemtoLambdas const& /*lambdas*/, FemtoRho0s const& /*rho0s*/) + { + pairLambdaRho0Builder.processSameEvent(col, tracks, lambdaPartition, rho0Partition, cache); + } + PROCESS_SWITCH(FemtoPairV0TwoTrackResonance, processLambdaRho0SameEvent, "Enable processing same event processing for lambdas and rho0s", false); + + void processLambdaRho0MixedEvent(FilteredCollisions const& cols, FemtoTracks const& tracks, FemtoLambdas const& /*lambdas*/, FemtoRho0s const& /*rho0s*/) + { + pairLambdaRho0Builder.processMixedEvent(cols, tracks, lambdaPartition, rho0Partition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + } + PROCESS_SWITCH(FemtoPairV0TwoTrackResonance, processLambdaRho0MixedEvent, "Enable processing mixed event processing for lambdas and rho0s", false); + + // k0short-phi + void processK0shortPhiSameEvent(FilteredCollision const& col, FemtoTracks const& tracks, FemtoK0shorts const& /*k0shorts*/, FemtoPhis const& /*phis*/) + { + pairK0shortPhiBuilder.processSameEvent(col, tracks, k0shortPartition, phiPartition, cache); + } + PROCESS_SWITCH(FemtoPairV0TwoTrackResonance, processK0shortPhiSameEvent, "Enable processing same event processing for k0shorts and phis", false); + + void processK0shortPhiMixedEvent(FilteredCollisions const& cols, FemtoTracks const& tracks, FemtoK0shorts const& /*k0shorts*/, FemtoPhis const& /*phis*/) + { + pairK0shortPhiBuilder.processMixedEvent(cols, tracks, k0shortPartition, phiPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + } + PROCESS_SWITCH(FemtoPairV0TwoTrackResonance, processK0shortPhiMixedEvent, "Enable processing mixed event processing for k0shorts and phis", false); + + // k0short-kstar0 + void processK0shortKstar0SameEvent(FilteredCollision const& col, FemtoTracks const& tracks, FemtoK0shorts const& /*k0shorts*/, FemtoKstar0s const& /*kstar0s*/) + { + pairK0shortKstar0Builder.processSameEvent(col, tracks, k0shortPartition, kstar0Partition, cache); + } + PROCESS_SWITCH(FemtoPairV0TwoTrackResonance, processK0shortKstar0SameEvent, "Enable processing same event processing for k0shorts and kstar0s", false); + + void processK0shortKstar0MixedEvent(FilteredCollisions const& cols, FemtoTracks const& tracks, FemtoK0shorts const& /*k0shorts*/, FemtoKstar0s const& /*kstar0s*/) + { + pairK0shortKstar0Builder.processMixedEvent(cols, tracks, k0shortPartition, kstar0Partition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + } + PROCESS_SWITCH(FemtoPairV0TwoTrackResonance, processK0shortKstar0MixedEvent, "Enable processing mixed event processing for k0shorts and kstar0s", false); + + // k0short-rho0 + void processK0shortRho0SameEvent(FilteredCollision const& col, FemtoTracks const& tracks, FemtoK0shorts const& /*k0shorts*/, FemtoRho0s const& /*rho0s*/) + { + pairK0shortRho0Builder.processSameEvent(col, tracks, k0shortPartition, rho0Partition, cache); + } + PROCESS_SWITCH(FemtoPairV0TwoTrackResonance, processK0shortRho0SameEvent, "Enable processing same event processing for k0shorts and rho0s", false); + + void processK0shortRho0MixedEvent(FilteredCollisions const& cols, FemtoTracks const& tracks, FemtoK0shorts const& /*k0shorts*/, FemtoRho0s const& /*rho0s*/) + { + pairK0shortRho0Builder.processMixedEvent(cols, tracks, k0shortPartition, rho0Partition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + } + PROCESS_SWITCH(FemtoPairV0TwoTrackResonance, processK0shortRho0MixedEvent, "Enable processing mixed event processing for k0shorts and rho0s", false); }; o2::framework::WorkflowSpec defineDataProcessing(o2::framework::ConfigContext const& cfgc)