diff --git a/PWGCF/Femto/Core/dataTypes.h b/PWGCF/Femto/Core/dataTypes.h index 0cb8c8758a5..fc1bc15f74d 100644 --- a/PWGCF/Femto/Core/dataTypes.h +++ b/PWGCF/Femto/Core/dataTypes.h @@ -50,6 +50,9 @@ using TwoTrackResonanceType = uint16_t; using CascadeMaskType = uint16_t; using CascadeType = uint16_t; +// datatype for particles +using ParticleType = uint16_t; + } // namespace femtodatatypes } // namespace o2::aod diff --git a/PWGCF/Femto/Core/femtoUtils.h b/PWGCF/Femto/Core/femtoUtils.h index e13bcfdd379..2fe02efcea6 100644 --- a/PWGCF/Femto/Core/femtoUtils.h +++ b/PWGCF/Femto/Core/femtoUtils.h @@ -27,8 +27,10 @@ #include #include +#include #include #include +#include namespace o2::analysis::femto { @@ -194,10 +196,10 @@ inline bool enableTable(const char* tableName, int userSetting, o2::framework::I } template -inline int sign(T value) -{ - return (value > 0) - (value < 0); // Returns 1 for positive, -1 for negative, 0 for zero -} +using HasMass = decltype(std::declval().mass()); + +template +using HasSign = decltype(std::declval().sign()); }; // namespace utils }; // namespace o2::analysis::femto diff --git a/PWGCF/Femto/Core/modes.h b/PWGCF/Femto/Core/modes.h index 672ada08ba3..25d27943ca1 100644 --- a/PWGCF/Femto/Core/modes.h +++ b/PWGCF/Femto/Core/modes.h @@ -71,6 +71,27 @@ enum class MomentumType : o2::aod::femtodatatypes::MomentumType { kPTpc, // momentum at inner wall of tpc }; +enum class Particle : o2::aod::femtodatatypes::ParticleType { + kTrack, + kTwoTrackResonance, + kV0, + kKink, + kCascade, +}; + +constexpr bool hasMass(Particle p) +{ + switch (p) { + case Particle::kV0: + case Particle::kTwoTrackResonance: + case Particle::kKink: + case Particle::kCascade: + return true; + default: + return false; + } +} + enum class Track : o2::aod::femtodatatypes::TrackType { kPrimaryTrack, kV0Daughter, diff --git a/PWGCF/Femto/Core/pairBuilder.h b/PWGCF/Femto/Core/pairBuilder.h index 1d788b5badd..0a98fcbd5a0 100644 --- a/PWGCF/Femto/Core/pairBuilder.h +++ b/PWGCF/Femto/Core/pairBuilder.h @@ -68,26 +68,28 @@ class PairTrackTrackBuilder typename T7, typename T8, typename T9, - typename T10> + typename T10, + typename T11> void init(o2::framework::HistogramRegistry* registry, T1 const& confTrackSelection1, T2 const& confTrackSelection2, T3 const& confCpr, T4 const& confMixing, T5 const& confPairBinning, - std::map> const& colHistSpec, - std::map> const& trackHistSpec1, - std::map> const& trackHistSpec2, - std::map> const& pairHistSpec, - std::map> const& cprHistSpec) + T6 const& confPairCuts, + std::map> const& colHistSpec, + std::map> const& trackHistSpec1, + std::map> const& trackHistSpec2, + std::map> const& pairHistSpec, + std::map> const& cprHistSpec) { // check if correlate the same tracks or not mSameSpecies = confMixing.sameSpecies.value; mColHistManager.init(registry, colHistSpec); - mPairHistManagerSe.init(registry, pairHistSpec, confPairBinning); - mPairHistManagerMe.init(registry, pairHistSpec, confPairBinning); + mPairHistManagerSe.init(registry, pairHistSpec, confPairBinning, confPairCuts); + mPairHistManagerMe.init(registry, pairHistSpec, confPairBinning, confPairCuts); if (mSameSpecies) { mTrackHistManager1.init(registry, trackHistSpec1, confTrackSelection1.chargeAbs.value); @@ -113,7 +115,7 @@ class PairTrackTrackBuilder } // setup mixing - mMixingPolicy = static_cast(confMixing.policy.value); + mMixingPolicy = static_cast(confMixing.policy.value); mMixingDepth = confMixing.depth.value; // setup rng if necessary @@ -191,13 +193,13 @@ class PairTrackTrackBuilder colhistmanager::CollisionHistManager mColHistManager; trackhistmanager::TrackHistManager mTrackHistManager1; trackhistmanager::TrackHistManager mTrackHistManager2; - pairhistmanager::PairHistManager mPairHistManagerSe; - pairhistmanager::PairHistManager mPairHistManagerMe; + pairhistmanager::PairHistManager mPairHistManagerSe; + pairhistmanager::PairHistManager mPairHistManagerMe; closepairrejection::ClosePairRejectionTrackTrack mCprSe; closepairrejection::ClosePairRejectionTrackTrack mCprMe; paircleaner::TrackTrackPairCleaner mPc; std::mt19937 mRng; - pairhistmanager::MixingPoliciy mMixingPolicy = pairhistmanager::MixingPoliciy::kVtxMult; + pairhistmanager::MixingPolicy mMixingPolicy = pairhistmanager::MixingPolicy::kVtxMult; bool mSameSpecies = false; int mMixingDepth = 5; bool mMixIdenticalParticles = false; @@ -235,29 +237,31 @@ class PairV0V0Builder typename T8, typename T9, typename T10, + typename T11, typename T12, - typename T11> + typename T13> void init(o2::framework::HistogramRegistry* registry, T1 const& confV0Selection1, T2 const& confV0Selection2, T3 const& confCpr, T4 const& confMixing, T5 const& confPairBinning, - std::map>& colHistSpec, - std::map>& V0HistSpec1, - std::map>& V0HistSpec2, - std::map>& PosDauHistSpec, - std::map>& NegDauHistSpec, - std::map>& pairHistSpec, - std::map>& cprHistSpec) + T6 const& confPairCuts, + std::map>& colHistSpec, + std::map>& V0HistSpec1, + std::map>& V0HistSpec2, + std::map>& PosDauHistSpec, + std::map>& NegDauHistSpec, + std::map>& pairHistSpec, + std::map>& cprHistSpec) { // check if correlate the same tracks or not mSameSpecies = confMixing.sameSpecies.value; mColHistManager.init(registry, colHistSpec); - mPairHistManagerSe.init(registry, pairHistSpec, confPairBinning); - mPairHistManagerMe.init(registry, pairHistSpec, confPairBinning); + mPairHistManagerSe.init(registry, pairHistSpec, confPairBinning, confPairCuts); + mPairHistManagerMe.init(registry, pairHistSpec, confPairBinning, confPairCuts); if (mSameSpecies) { mV0HistManager1.init(registry, V0HistSpec1, PosDauHistSpec, NegDauHistSpec); @@ -283,7 +287,7 @@ class PairV0V0Builder } // setup mixing - mMixingPolicy = static_cast(confMixing.policy.value); + mMixingPolicy = static_cast(confMixing.policy.value); mMixingDepth = confMixing.depth.value; // setup rng if necessary @@ -361,13 +365,13 @@ class PairV0V0Builder colhistmanager::CollisionHistManager mColHistManager; v0histmanager::V0HistManager mV0HistManager1; v0histmanager::V0HistManager mV0HistManager2; - pairhistmanager::PairHistManager mPairHistManagerSe; - pairhistmanager::PairHistManager mPairHistManagerMe; + pairhistmanager::PairHistManager mPairHistManagerSe; + pairhistmanager::PairHistManager mPairHistManagerMe; closepairrejection::ClosePairRejectionV0V0 mCprSe; closepairrejection::ClosePairRejectionV0V0 mCprMe; paircleaner::V0V0PairCleaner mPc; std::mt19937 mRng; - pairhistmanager::MixingPoliciy mMixingPolicy = pairhistmanager::MixingPoliciy::kVtxMult; + pairhistmanager::MixingPolicy mMixingPolicy = pairhistmanager::MixingPolicy::kVtxMult; bool mSameSpecies = false; int mMixingDepth = 5; bool mMixIdenticalParticles = false; @@ -403,38 +407,40 @@ class PairTrackV0Builder typename T9, typename T10, typename T11, - typename T12> + typename T12, + typename T13> void init(o2::framework::HistogramRegistry* registry, T1 const& confTrackSelection, T2 const& confV0Selection, T3 const& confCpr, T4 const& confMixing, T5 const& confPairBinning, - std::map>& colHistSpec, - std::map>& trackHistSpec, - std::map>& v0HistSpec, - std::map>& posDauHistSpec, - std::map>& negDauHistSpec, - std::map>& pairHistSpec, - std::map>& cprHistSpec) + T6 const& confPairCuts, + std::map>& colHistSpec, + std::map>& trackHistSpec, + std::map>& v0HistSpec, + std::map>& posDauHistSpec, + std::map>& negDauHistSpec, + std::map>& pairHistSpec, + std::map>& cprHistSpec) { mColHistManager.init(registry, colHistSpec); mTrackHistManager.init(registry, trackHistSpec, confTrackSelection.chargeAbs.value); mV0HistManager.init(registry, v0HistSpec, posDauHistSpec, negDauHistSpec); - mPairHistManagerSe.init(registry, pairHistSpec, confPairBinning); + mPairHistManagerSe.init(registry, pairHistSpec, confPairBinning, confPairCuts); mPairHistManagerSe.setMass(confTrackSelection.pdgCode.value, confV0Selection.pdgCode.value); mPairHistManagerSe.setCharge(confTrackSelection.chargeAbs.value, 1); mCprSe.init(registry, cprHistSpec, confCpr, confTrackSelection.chargeAbs.value); - mPairHistManagerMe.init(registry, pairHistSpec, confPairBinning); + mPairHistManagerMe.init(registry, pairHistSpec, confPairBinning, confPairCuts); mPairHistManagerMe.setMass(confTrackSelection.pdgCode.value, confV0Selection.pdgCode.value); mPairHistManagerMe.setCharge(confTrackSelection.chargeAbs.value, 1); mCprMe.init(registry, cprHistSpec, confCpr, confTrackSelection.chargeAbs.value); // setup mixing - mMixingPolicy = static_cast(confMixing.policy.value); + mMixingPolicy = static_cast(confMixing.policy.value); mMixingDepth = confMixing.depth.value; } @@ -473,12 +479,12 @@ class PairTrackV0Builder colhistmanager::CollisionHistManager mColHistManager; trackhistmanager::TrackHistManager mTrackHistManager; v0histmanager::V0HistManager mV0HistManager; - pairhistmanager::PairHistManager mPairHistManagerSe; - pairhistmanager::PairHistManager mPairHistManagerMe; + pairhistmanager::PairHistManager mPairHistManagerSe; + pairhistmanager::PairHistManager mPairHistManagerMe; closepairrejection::ClosePairRejectionTrackV0 mCprSe; closepairrejection::ClosePairRejectionTrackV0 mCprMe; paircleaner::TrackV0PairCleaner mPc; - pairhistmanager::MixingPoliciy mMixingPolicy = pairhistmanager::MixingPoliciy::kVtxMult; + pairhistmanager::MixingPolicy mMixingPolicy = pairhistmanager::MixingPolicy::kVtxMult; int mMixingDepth = 5; }; @@ -512,38 +518,40 @@ class PairTrackTwoTrackResonanceBuilder typename T9, typename T10, typename T11, - typename T12> + typename T12, + typename T13> void init(o2::framework::HistogramRegistry* registry, T1 const& confTrackSelection, T2 const& confResonanceSelection, T3 const& confCpr, T4 const& confMixing, T5 const& confPairBinning, - std::map> const& colHistSpec, - std::map> const& trackHistSpec, - std::map> const& resonanceHistSpec, - std::map> const& posDauHistSpec, - std::map> const& negDauHistSpec, - std::map> const& pairHistSpec, - std::map> const& cprHistSpec) + T6 const& confPairCuts, + std::map> const& colHistSpec, + std::map> const& trackHistSpec, + std::map> const& resonanceHistSpec, + std::map> const& posDauHistSpec, + std::map> const& negDauHistSpec, + std::map> const& pairHistSpec, + std::map> const& cprHistSpec) { mColHistManager.init(registry, colHistSpec); mTrackHistManager.init(registry, trackHistSpec, confTrackSelection.chargeAbs.value); mResonanceHistManager.init(registry, resonanceHistSpec, posDauHistSpec, negDauHistSpec); - mPairHistManagerSe.init(registry, pairHistSpec, confPairBinning); + mPairHistManagerSe.init(registry, pairHistSpec, confPairBinning, confPairCuts); mPairHistManagerSe.setMass(confTrackSelection.pdgCode.value, confResonanceSelection.pdgCode.value); mPairHistManagerSe.setCharge(confTrackSelection.chargeAbs.value, 1); mCprSe.init(registry, cprHistSpec, confCpr, confTrackSelection.chargeAbs.value); - mPairHistManagerMe.init(registry, pairHistSpec, confPairBinning); + mPairHistManagerMe.init(registry, pairHistSpec, confPairBinning, confPairCuts); mPairHistManagerMe.setMass(confTrackSelection.pdgCode.value, confResonanceSelection.pdgCode.value); mPairHistManagerMe.setCharge(confTrackSelection.chargeAbs.value, 1); mCprMe.init(registry, cprHistSpec, confCpr, confTrackSelection.chargeAbs.value); // setup mixing - mMixingPolicy = static_cast(confMixing.policy.value); + mMixingPolicy = static_cast(confMixing.policy.value); mMixingDepth = confMixing.depth.value; } @@ -582,12 +590,12 @@ class PairTrackTwoTrackResonanceBuilder colhistmanager::CollisionHistManager mColHistManager; trackhistmanager::TrackHistManager mTrackHistManager; twotrackresonancehistmanager::TwoTrackResonanceHistManager mResonanceHistManager; - pairhistmanager::PairHistManager mPairHistManagerSe; - pairhistmanager::PairHistManager mPairHistManagerMe; + pairhistmanager::PairHistManager mPairHistManagerSe; + pairhistmanager::PairHistManager mPairHistManagerMe; closepairrejection::ClosePairRejectionTrackV0 mCprSe; // cpr for twotrackresonances and v0 work the same way closepairrejection::ClosePairRejectionTrackV0 mCprMe; // cpr for twotrackresonances and v0 work the same way paircleaner::TrackV0PairCleaner mPc; // pc for twotrackresonances and v0 work the same way - pairhistmanager::MixingPoliciy mMixingPolicy = pairhistmanager::MixingPoliciy::kVtxMult; + pairhistmanager::MixingPolicy mMixingPolicy = pairhistmanager::MixingPolicy::kVtxMult; int mMixingDepth = 5; }; @@ -617,37 +625,39 @@ class PairTrackKinkBuilder typename T8, typename T9, typename T10, - typename T11> + typename T11, + typename T12> void init(o2::framework::HistogramRegistry* registry, T1 const& confTrackSelection, T2 const& confKinkSelection, T3 const& confCpr, T4 const& confMixing, T5 const& confPairBinning, - std::map> const& colHistSpec, - std::map> const& trackHistSpec, - std::map> const& kinkHistSpec, - std::map> const& chaDauHistSpec, - std::map> const& pairHistSpec, - std::map> const& cprHistSpec) + T6 const& confPairCuts, + std::map> const& colHistSpec, + std::map> const& trackHistSpec, + std::map> const& kinkHistSpec, + std::map> const& chaDauHistSpec, + std::map> const& pairHistSpec, + std::map> const& cprHistSpec) { mColHistManager.init(registry, colHistSpec); mTrackHistManager.init(registry, trackHistSpec, confTrackSelection.chargeAbs.value); mKinkHistManager.init(registry, kinkHistSpec, chaDauHistSpec); - mPairHistManagerSe.init(registry, pairHistSpec, confPairBinning); + mPairHistManagerSe.init(registry, pairHistSpec, confPairBinning, confPairCuts); mPairHistManagerSe.setMass(confTrackSelection.pdgCode.value, confKinkSelection.pdgCode.value); mPairHistManagerSe.setCharge(confTrackSelection.chargeAbs.value, 1); // abs charge of kink daughter is always 1 mCprSe.init(registry, cprHistSpec, confCpr, confTrackSelection.chargeAbs.value); - mPairHistManagerMe.init(registry, pairHistSpec, confPairBinning); + mPairHistManagerMe.init(registry, pairHistSpec, confPairBinning, confPairCuts); mPairHistManagerMe.setMass(confTrackSelection.pdgCode.value, confKinkSelection.pdgCode.value); mPairHistManagerMe.setCharge(confTrackSelection.chargeAbs.value, 1); // abs charge of kink daughter is always 1 mCprMe.init(registry, cprHistSpec, confCpr, confTrackSelection.chargeAbs.value); // setup mixing - mMixingPolicy = static_cast(confMixing.policy.value); + mMixingPolicy = static_cast(confMixing.policy.value); mMixingDepth = confMixing.depth.value; } @@ -686,12 +696,12 @@ class PairTrackKinkBuilder colhistmanager::CollisionHistManager mColHistManager; trackhistmanager::TrackHistManager mTrackHistManager; kinkhistmanager::KinkHistManager mKinkHistManager; - pairhistmanager::PairHistManager mPairHistManagerSe; - pairhistmanager::PairHistManager mPairHistManagerMe; + pairhistmanager::PairHistManager mPairHistManagerSe; + pairhistmanager::PairHistManager mPairHistManagerMe; closepairrejection::ClosePairRejectionTrackKink mCprSe; closepairrejection::ClosePairRejectionTrackKink mCprMe; paircleaner::TrackKinkPairCleaner mPc; - pairhistmanager::MixingPoliciy mMixingPolicy = pairhistmanager::MixingPoliciy::kVtxMult; + pairhistmanager::MixingPolicy mMixingPolicy = pairhistmanager::MixingPolicy::kVtxMult; int mMixingDepth = 5; }; @@ -729,39 +739,41 @@ class PairTrackCascadeBuilder typename T10, typename T11, typename T12, - typename T13> + typename T13, + typename T14> void init(o2::framework::HistogramRegistry* registry, T1 const& confTrackSelection, T2 const& confCascadeSelection, T3 const& confCpr, T4 const& confMixing, T5 const& confPairBinning, - std::map> const& colHistSpec, - std::map> const& trackHistSpec, - std::map> const& cascadeHistSpec, - std::map> const& bachelorHistSpec, - std::map> const& posDauHistSpec, - std::map> const& negDauHistSpec, - std::map> const& pairHistSpec, - std::map> const& cprHistSpec) + T6 const& confPairCuts, + std::map> const& colHistSpec, + std::map> const& trackHistSpec, + std::map> const& cascadeHistSpec, + std::map> const& bachelorHistSpec, + std::map> const& posDauHistSpec, + std::map> const& negDauHistSpec, + std::map> const& pairHistSpec, + std::map> const& cprHistSpec) { mColHistManager.init(registry, colHistSpec); mTrackHistManager.init(registry, trackHistSpec, confTrackSelection.chargeAbs.value); mCascadeHistManager.init(registry, cascadeHistSpec, bachelorHistSpec, posDauHistSpec, negDauHistSpec); - mPairHistManagerSe.init(registry, pairHistSpec, confPairBinning); + mPairHistManagerSe.init(registry, pairHistSpec, confPairBinning, confPairCuts); mPairHistManagerSe.setMass(confTrackSelection.pdgCode.value, confCascadeSelection.pdgCode.value); mPairHistManagerSe.setCharge(confTrackSelection.chargeAbs.value, 1); mCprSe.init(registry, cprHistSpec, confCpr, confTrackSelection.chargeAbs.value); - mPairHistManagerMe.init(registry, pairHistSpec, confPairBinning); + mPairHistManagerMe.init(registry, pairHistSpec, confPairBinning, confPairCuts); mPairHistManagerMe.setMass(confTrackSelection.pdgCode.value, confCascadeSelection.pdgCode.value); mPairHistManagerMe.setCharge(confTrackSelection.chargeAbs.value, 1); mCprMe.init(registry, cprHistSpec, confCpr, confTrackSelection.chargeAbs.value); // setup mixing - mMixingPolicy = static_cast(confMixing.policy.value); + mMixingPolicy = static_cast(confMixing.policy.value); mMixingDepth = confMixing.depth.value; } @@ -800,12 +812,12 @@ class PairTrackCascadeBuilder colhistmanager::CollisionHistManager mColHistManager; trackhistmanager::TrackHistManager mTrackHistManager; cascadehistmanager::CascadeHistManager mCascadeHistManager; - pairhistmanager::PairHistManager mPairHistManagerSe; - pairhistmanager::PairHistManager mPairHistManagerMe; + pairhistmanager::PairHistManager mPairHistManagerSe; + pairhistmanager::PairHistManager mPairHistManagerMe; closepairrejection::ClosePairRejectionTrackCascade mCprSe; closepairrejection::ClosePairRejectionTrackCascade mCprMe; paircleaner::TrackCascadePairCleaner mPc; - pairhistmanager::MixingPoliciy mMixingPolicy = pairhistmanager::MixingPoliciy::kVtxMult; + pairhistmanager::MixingPolicy mMixingPolicy = pairhistmanager::MixingPolicy::kVtxMult; int mMixingDepth = 5; }; diff --git a/PWGCF/Femto/Core/pairHistManager.h b/PWGCF/Femto/Core/pairHistManager.h index 16077c7a2ea..1779255816c 100644 --- a/PWGCF/Femto/Core/pairHistManager.h +++ b/PWGCF/Femto/Core/pairHistManager.h @@ -40,11 +40,11 @@ namespace pairhistmanager { // enum for pair histograms enum PairHist { - // kinemtics + // standard 1D kKstar, kKt, kMt, - // 2d + // standard 2D kPt1VsPt2, kPt1VsKstar, kPt2VsKstar, @@ -56,17 +56,25 @@ enum PairHist { kKstarVsMt, kKstarVsMult, kKstarVsCent, - - // higher dimensions + // 2D with mass + kKstarVsMass1, + kKstarVsMass2, + kMass1VsMass2, + // higher dimensions kKstarVsMtVsMult, kKstarVsMtVsMultVsCent, - kKstarVsMtVsPt1VsP2VsMult, - kKstarVsMtVsPt1VsP2VsMultVsCent, + kKstarVsMtVsPt1VsPt2VsMult, + kKstarVsMtVsPt1VsPt2VsMultVsCent, + // higher dimensions with mass + kKstarVsMass1VsMass2, + kKstarVsMass1VsMult, + kKstarVsMass2VsMult, + kKstarVsMass1VsMass2VsMult, kPairHistogramLast }; -enum MixingPoliciy { +enum MixingPolicy { kVtxMult, kVtxCent, kVtxMultCent, @@ -81,7 +89,7 @@ struct ConfMixing : o2::framework::ConfigurableGroup { o2::framework::ConfigurableAxis vtxBins{"vtxBins", {o2::framework::VARIABLE_WIDTH, -10.0f, -8.f, -6.f, -4.f, -2.f, 0.f, 2.f, 4.f, 6.f, 8.f, 10.f}, "Mixing bins - z-vertex"}; o2::framework::Configurable depth{"depth", 5, "Number of events for mixing"}; o2::framework::Configurable policy{"policy", 0, "Binning policy for mixing (alywas in combination with z-vertex) -> 0: multiplicity, -> 1: centrality, -> 2: both"}; - o2::framework::Configurable sameSpecies{"sameSpecies", false, "Enable if partilce 1 and particle 2 are the same"}; + o2::framework::Configurable sameSpecies{"sameSpecies", false, "Enable if particle 1 and particle 2 are the same"}; o2::framework::Configurable seed{"seed", -1, "Seed to randomize particle 1 and particle 2 (if they are identical). Set to negative value to deactivate. Set to 0 to generate unique seed in time."}; }; @@ -91,66 +99,103 @@ struct ConfPairBinning : o2::framework::ConfigurableGroup { o2::framework::Configurable plot2D{"plot2D", true, "Enable 2D histograms"}; o2::framework::Configurable plotKstarVsMtVsMult{"plotKstarVsMtVsMult", false, "Enable 3D histogram (Kstar Vs Mt Vs Mult)"}; o2::framework::Configurable plotKstarVsMtVsMultVsCent{"plotKstarVsMtVsMultVsCent", false, "Enable 4D histogram (Kstar Vs Mt Vs Mult Vs Cent)"}; - o2::framework::Configurable plotKstarVsMtVsPt1VsP2VsMult{"plotKstarVsMtVsPt1VsP2VsMult", false, "Enable 5D histogram (Kstar Vs Mt Vs Pt1 Vs Pt2 Vs Mult)"}; - o2::framework::Configurable plotKstarVsMtVsPt1VsP2VsMultVsCent{"plotKstarVsMtVsPt1VsP2VsMultVsCent", false, "Enable 6D histogram (Kstar Vs Mt Vs Pt1 Vs Pt2 Vs Mult Vs Cent)"}; + o2::framework::Configurable plotKstarVsMtVsPt1VsPt2VsMult{"plotKstarVsMtVsPt1VsPt2VsMult", false, "Enable 5D histogram (Kstar Vs Mt Vs Pt1 Vs Pt2 Vs Mult)"}; + o2::framework::Configurable plotKstarVsMtVsPt1VsPt2VsMultVsCent{"plotKstarVsMtVsPt1VsPt2VsMultVsCent", false, "Enable 6D histogram (Kstar Vs Mt Vs Pt1 Vs Pt2 Vs Mult Vs Cent)"}; + o2::framework::Configurable plotKstarVsMass1VsMass2{"plotKstarVsMass1VsMass2", false, "Enable 3D histogram (Kstar Vs Mass1 Vs Mass2)"}; + o2::framework::Configurable plotKstarVsMass1VsMult{"plotKstarVsMass1VsMult", false, "Enable 3D histogram (Kstar Vs Mass1 Vs Mult)"}; + o2::framework::Configurable plotKstarVsMass2VsMult{"plotKstarVsMass2VsMult", false, "Enable 3D histogram (Kstar Vs Mass2 Vs Mult)"}; + o2::framework::Configurable plotKstarVsMass1VsMass2VsMult{"plotKstarVsMass1VsMass2VsMult", false, "Enable 4D histogram (Kstar Vs Mass1 Vs Mass2 Vs Mult)"}; o2::framework::ConfigurableAxis kstar{"kstar", {{600, 0, 6}}, "kstar"}; o2::framework::ConfigurableAxis kt{"kt", {{600, 0, 6}}, "kt"}; o2::framework::ConfigurableAxis mt{"mt", {{500, 0.8, 5.8}}, "mt"}; o2::framework::ConfigurableAxis multiplicity{"multiplicity", {{50, 0, 200}}, "multiplicity"}; o2::framework::ConfigurableAxis centrality{"centrality", {{10, 0, 100}}, "centrality (mult. percentile)"}; + o2::framework::ConfigurableAxis pt1{"pt1", {{100, 0, 6}}, "Pt binning for particle 1"}; + o2::framework::ConfigurableAxis pt2{"pt2", {{100, 0, 6}}, "Pt binning for particle 2"}; + o2::framework::ConfigurableAxis mass1{"mass1", {{100, 0, 2}}, "Mass binning for particle 1 (if particle has mass getter)"}; + o2::framework::ConfigurableAxis mass2{"mass2", {{100, 0, 2}}, "Mass binning for particle 2 (if particle has mass getter)"}; +}; + +struct ConfPairCuts : o2::framework::ConfigurableGroup { + std::string prefix = std::string("PairCuts"); + o2::framework::Configurable kstarMax{"kstarMax", -1, "Maximal kstar (set to -1 to deactivate)"}; + o2::framework::Configurable kstarMin{"kstarMin", -1, "Minimal kstar (set to -1 to deactivate)"}; + o2::framework::Configurable ktMax{"ktMax", -1, "Maximal kt (set to -1 to deactivate)"}; + o2::framework::Configurable ktMin{"ktMin", -1, "Minimal kt (set to -1 to deactivate)"}; + o2::framework::Configurable mtMax{"mtMax", -1, "Maximal mt (set to -1 to deactivate)"}; + o2::framework::Configurable mtMin{"mtMin", -1, "Minimal mt (set to -1 to deactivate)"}; }; // the enum gives the correct index in the array -constexpr std::array, kPairHistogramLast> HistTable = { - { - // 1D - {kKstar, o2::framework::kTH1F, "hKstar", "k*; k* (GeV/#it{c}); Entries"}, - {kKt, o2::framework::kTH1F, "hKt", "transverse momentum; k_{T} (GeV/#it{c}); Entries"}, - {kMt, o2::framework::kTH1F, "hMt", "transverse mass; m_{T} (GeV/#it{c}^{2}); Entries"}, - // 2D - {kPt1VsPt2, o2::framework::kTH2F, "hPt1VsPt2", "track1 p_{T} vs track2 p_{T}; track1 p_T (GeV/#it{c}); track2 p_{T} (GeV/#it{c})"}, - {kPt1VsKstar, o2::framework::kTH2F, "hPt1VsKstar", "p_{T,1} vs k*; p_{T,2} (GeV/#it{c}); k* (GeV/#it{c})"}, - {kPt2VsKstar, o2::framework::kTH2F, "hPt2VsKstar", "p_{T,2} vs k*; p_{T,2} (GeV/#it{c}); k* (GeV/#it{c})"}, - {kPt1VsKt, o2::framework::kTH2F, "hPt1VsKt", "p_{T,1} vs k_{T}; p_{T,1} (GeV/#it{c}); k_{T} (GeV/#it{c})"}, - {kPt2VsKt, o2::framework::kTH2F, "hPt2VsKt", "p_{T,2} vs k_{T}; p_{T,2} (GeV/#it{c}); k_{T} (GeV/#it{c})"}, - {kPt1VsMt, o2::framework::kTH2F, "hPt1VsMt", "p_{T,1} vs m_{T}; p_{T,1} (GeV/#it{c}); m_{T} (GeV/#it{c}^{2})"}, - {kPt2VsMt, o2::framework::kTH2F, "hPt2VsMt", "p_{T,2} vs m_{T}; p_{T,2} (GeV/#it{c}); m_{T} (GeV/#it{c}^{2})"}, - {kKstarVsKt, o2::framework::kTH2F, "hKstarVsKt", "k* vs k_{T}; k* (GeV/#it{c}); k_{T} (GeV/#it{c})"}, - {kKstarVsMt, o2::framework::kTH2F, "hKstarVsMt", "k* vs m_{T}; k* (GeV/#it{c}); m_{T} (GeV/#it{c}^{2})"}, - {kKstarVsCent, o2::framework::kTH2F, "hKstarVsCent", "k* vs Centrality (Mult. Percentile); k* (GeV/#it{c}); Centrality (%)"}, - {kKstarVsMult, o2::framework::kTH2F, "hKstarVsMult", "k* vs Multiplicity; k* (GeV/#it{c}); Multiplicity"}, - - // n-D - {kKstarVsMtVsMult, o2::framework::kTHnSparseF, "hKstarVsMtVsMult", "k* vs m_{T} vs multiplicity; k* (GeV/#it{c}); m_{T} (GeV/#it{c}^{2}); Multiplicity"}, - {kKstarVsMtVsMultVsCent, o2::framework::kTHnSparseF, "hKstarVsMtVsMultVsCent", "k* vs m_{T} vs multiplicity vs centrality; k* (GeV/#it{c}); m_{T} (GeV/#it{c}^{2}); Multiplicity; Centrality (%)"}, - {kKstarVsMtVsPt1VsP2VsMult, o2::framework::kTHnSparseF, "hKstarVsMtVsPt1VsPt2VsMult", "k* vs m_{T} vs p_{T,1} vs p_{T,2} vs multiplicity; k* (GeV/#it{c}); m_{T} (GeV/#it{c}^{2}); p_{T,1} (GeV/#it{c}); p_{T,2} (GeV/#it{c}); Multiplicity"}, - {kKstarVsMtVsPt1VsP2VsMultVsCent, o2::framework::kTHnSparseF, "hKstarVsMtVsPt1VsPt2VsMultVsCent", "k* vs m_{T} vs p_{T,1} vs p_{T,2} vs multiplicity vs centrality; k* (GeV/#it{c}); m_{T} (GeV/#it{c}^{2}); p_{T,1} (GeV/#it{c}); p_{T,2} (GeV/#it{c}); Multiplicity; Centrality"}, - - }}; - -template -auto makePairHistSpecMap(const T1& confPairBinning, const T2& confObject1Binning, const T3& confObject2Binning) +constexpr std::array, kPairHistogramLast> + HistTable = { + { + // 1D + {kKstar, o2::framework::kTH1F, "hKstar", "k*; k* (GeV/#it{c}); Entries"}, + {kKt, o2::framework::kTH1F, "hKt", "transverse momentum; k_{T} (GeV/#it{c}); Entries"}, + {kMt, o2::framework::kTH1F, "hMt", "transverse mass; m_{T} (GeV/#it{c}^{2}); Entries"}, + // 2D + {kPt1VsPt2, o2::framework::kTH2F, "hPt1VsPt2", " p_{T,1} vs p_{T,2}; p_{T,1} (GeV/#it{c}); p_{T,2} (GeV/#it{c})"}, + {kPt1VsKstar, o2::framework::kTH2F, "hPt1VsKstar", "p_{T,1} vs k*; p_{T,2} (GeV/#it{c}); k* (GeV/#it{c})"}, + {kPt2VsKstar, o2::framework::kTH2F, "hPt2VsKstar", "p_{T,2} vs k*; p_{T,2} (GeV/#it{c}); k* (GeV/#it{c})"}, + {kPt1VsKt, o2::framework::kTH2F, "hPt1VsKt", "p_{T,1} vs k_{T}; p_{T,1} (GeV/#it{c}); k_{T} (GeV/#it{c})"}, + {kPt2VsKt, o2::framework::kTH2F, "hPt2VsKt", "p_{T,2} vs k_{T}; p_{T,2} (GeV/#it{c}); k_{T} (GeV/#it{c})"}, + {kPt1VsMt, o2::framework::kTH2F, "hPt1VsMt", "p_{T,1} vs m_{T}; p_{T,1} (GeV/#it{c}); m_{T} (GeV/#it{c}^{2})"}, + {kPt2VsMt, o2::framework::kTH2F, "hPt2VsMt", "p_{T,2} vs m_{T}; p_{T,2} (GeV/#it{c}); m_{T} (GeV/#it{c}^{2})"}, + {kKstarVsKt, o2::framework::kTH2F, "hKstarVsKt", "k* vs k_{T}; k* (GeV/#it{c}); k_{T} (GeV/#it{c})"}, + {kKstarVsMt, o2::framework::kTH2F, "hKstarVsMt", "k* vs m_{T}; k* (GeV/#it{c}); m_{T} (GeV/#it{c}^{2})"}, + {kKstarVsCent, o2::framework::kTH2F, "hKstarVsCent", "k* vs Centrality (Mult. Percentile); k* (GeV/#it{c}); Centrality (%)"}, + {kKstarVsMult, o2::framework::kTH2F, "hKstarVsMult", "k* vs Multiplicity; k* (GeV/#it{c}); Multiplicity"}, + // 2D with mass + {kKstarVsMass1, o2::framework::kTH2F, "hKstarVsMass1", "k* vs m_{1}; k* (GeV/#it{c}); m_{1} (GeV/#it{c}^{2})"}, + {kKstarVsMass2, o2::framework::kTH2F, "hKstarVsMass2", "k* vs m_{2}; k* (GeV/#it{c}); m_{2} (GeV/#it{c}^{2})"}, + {kMass1VsMass2, o2::framework::kTH2F, "hMass1VsMass2", "m_{1} vs m_{2}; m_{1} (GeV/#it{c}^{2}); m_{2} (GeV/#it{c}^{2})"}, + // n-D + {kKstarVsMtVsMult, o2::framework::kTHnSparseF, "hKstarVsMtVsMult", "k* vs m_{T} vs multiplicity; k* (GeV/#it{c}); m_{T} (GeV/#it{c}^{2}); Multiplicity"}, + {kKstarVsMtVsMultVsCent, o2::framework::kTHnSparseF, "hKstarVsMtVsMultVsCent", "k* vs m_{T} vs multiplicity vs centrality; k* (GeV/#it{c}); m_{T} (GeV/#it{c}^{2}); Multiplicity; Centrality (%)"}, + {kKstarVsMtVsPt1VsPt2VsMult, o2::framework::kTHnSparseF, "hKstarVsMtVsPt1VsPt2VsMult", "k* vs m_{T} vs p_{T,1} vs p_{T,2} vs multiplicity; k* (GeV/#it{c}); m_{T} (GeV/#it{c}^{2}); p_{T,1} (GeV/#it{c}); p_{T,2} (GeV/#it{c}); Multiplicity"}, + {kKstarVsMtVsPt1VsPt2VsMultVsCent, o2::framework::kTHnSparseF, "hKstarVsMtVsPt1VsPt2VsMultVsCent", "k* vs m_{T} vs p_{T,1} vs p_{T,2} vs multiplicity vs centrality; k* (GeV/#it{c}); m_{T} (GeV/#it{c}^{2}); p_{T,1} (GeV/#it{c}); p_{T,2} (GeV/#it{c}); Multiplicity; Centrality"}, + // n-D with mass + {kKstarVsMass1VsMass2, o2::framework::kTHnSparseF, "hKstarVsMass1VsMass2", "k* vs m_{1} vs m_{2}; k* (GeV/#it{c}); m_{1} (GeV/#it{c}^{2}); m_{2} (GeV/#it{c}^{2})"}, + {kKstarVsMass1VsMult, o2::framework::kTHnSparseF, "hKstarVsMass1VsMult", "k* vs m_{1} vs multiplicity; k* (GeV/#it{c}); m_{1} (GeV/#it{c}^{2}); Multiplicity"}, + {kKstarVsMass2VsMult, o2::framework::kTHnSparseF, "hKstarVsMass2VsMult", "k* vs m_{2} vs multiplicity; k* (GeV/#it{c}); m_{2} (GeV/#it{c}^{2}); Multiplicity"}, + {kKstarVsMass1VsMass2VsMult, o2::framework::kTHnSparseF, "hKstarVsMass1VsMass2VsMult", "k* vs m_{1} vs m_{2} vs multiplicity; k* (GeV/#it{c}); m_{1} (GeV/#it{c}^{2}); m_{2} (GeV/#it{c}^{2}); Multiplicity"}, + + }}; + +template +auto makePairHistSpecMap(const T& confPairBinning) { return std::map>{ {kKstar, {confPairBinning.kstar}}, {kKt, {confPairBinning.kt}}, {kMt, {confPairBinning.mt}}, - {kPt1VsPt2, {confObject1Binning.pt, confObject2Binning.pt}}, - {kPt1VsKstar, {confObject1Binning.pt, confPairBinning.kstar}}, - {kPt2VsKstar, {confObject2Binning.pt, confPairBinning.kstar}}, - {kPt1VsKt, {confObject1Binning.pt, confPairBinning.kt}}, - {kPt2VsKt, {confObject2Binning.pt, confPairBinning.kt}}, - {kPt1VsMt, {confObject1Binning.pt, confPairBinning.mt}}, - {kPt2VsMt, {confObject2Binning.pt, confPairBinning.mt}}, + {kPt1VsPt2, {confPairBinning.pt1, confPairBinning.pt2}}, + {kPt1VsKstar, {confPairBinning.pt1, confPairBinning.kstar}}, + {kPt2VsKstar, {confPairBinning.pt2, confPairBinning.kstar}}, + {kPt1VsKt, {confPairBinning.pt1, confPairBinning.kt}}, + {kPt2VsKt, {confPairBinning.pt2, confPairBinning.kt}}, + {kPt1VsMt, {confPairBinning.pt1, confPairBinning.mt}}, + {kPt2VsMt, {confPairBinning.pt2, confPairBinning.mt}}, {kKstarVsKt, {confPairBinning.kstar, confPairBinning.kt}}, {kKstarVsMt, {confPairBinning.kstar, confPairBinning.mt}}, {kKstarVsMult, {confPairBinning.kstar, confPairBinning.multiplicity}}, {kKstarVsCent, {confPairBinning.kstar, confPairBinning.centrality}}, + {kKstarVsMass1, {confPairBinning.kstar, confPairBinning.mass1}}, + {kKstarVsMass2, {confPairBinning.kstar, confPairBinning.mass2}}, + {kMass1VsMass2, {confPairBinning.mass1, confPairBinning.mass2}}, + {kKstarVsMtVsMult, {confPairBinning.kstar, confPairBinning.mt, confPairBinning.multiplicity}}, {kKstarVsMtVsMultVsCent, {confPairBinning.kstar, confPairBinning.mt, confPairBinning.multiplicity, confPairBinning.centrality}}, - {kKstarVsMtVsPt1VsP2VsMult, {confPairBinning.kstar, confPairBinning.mt, confObject1Binning.pt, confObject2Binning.pt, confPairBinning.multiplicity}}, - {kKstarVsMtVsPt1VsP2VsMultVsCent, {confPairBinning.kstar, confPairBinning.mt, confObject1Binning.pt, confObject2Binning.pt, confPairBinning.multiplicity, confPairBinning.centrality}}, + {kKstarVsMtVsPt1VsPt2VsMult, {confPairBinning.kstar, confPairBinning.mt, confPairBinning.pt1, confPairBinning.pt2, confPairBinning.multiplicity}}, + {kKstarVsMtVsPt1VsPt2VsMultVsCent, {confPairBinning.kstar, confPairBinning.mt, confPairBinning.pt1, confPairBinning.pt2, confPairBinning.multiplicity, confPairBinning.centrality}}, + + {kKstarVsMass1VsMass2, {confPairBinning.kstar, confPairBinning.mass1, confPairBinning.mass2}}, + {kKstarVsMass1VsMult, {confPairBinning.kstar, confPairBinning.mass1, confPairBinning.multiplicity}}, + {kKstarVsMass2VsMult, {confPairBinning.kstar, confPairBinning.mass2, confPairBinning.multiplicity}}, + {kKstarVsMass1VsMass2VsMult, {confPairBinning.kstar, confPairBinning.mass1, confPairBinning.mass2, confPairBinning.multiplicity}}, + }; }; @@ -178,24 +223,44 @@ constexpr std::string_view QaDir = "QA/"; /// \class FemtoDreamEventHisto /// \brief Class for histogramming event properties // template -template +template class PairHistManager { public: PairHistManager() = default; ~PairHistManager() = default; - template - void init(o2::framework::HistogramRegistry* registry, std::map> const& Specs, T const& ConfPairBinning) + template + void init(o2::framework::HistogramRegistry* registry, + std::map> const& Specs, + T1 const& ConfPairBinning, + T2 const& ConfPairCuts) { mHistogramRegistry = registry; + // flags for histograms mPlot1d = ConfPairBinning.plot1D.value; mPlot2d = ConfPairBinning.plot2D.value; mPlotKstarVsMtVsMult = ConfPairBinning.plotKstarVsMtVsMult.value; mPlotKstarVsMtVsMultVsCent = ConfPairBinning.plotKstarVsMtVsMultVsCent.value; - mPlotKstarVsMtVsPt1VsP2VsMult = ConfPairBinning.plotKstarVsMtVsPt1VsP2VsMult.value; - mPlotKstarVsMtVsPt1VsP2VsMultVsCent = ConfPairBinning.plotKstarVsMtVsPt1VsP2VsMultVsCent.value; + mPlotKstarVsMtVsPt1VsP2VsMult = ConfPairBinning.plotKstarVsMtVsPt1VsPt2VsMult.value; + mPlotKstarVsMtVsPt1VsP2VsMultVsCent = ConfPairBinning.plotKstarVsMtVsPt1VsPt2VsMultVsCent.value; + + mPlotKstarVsMass1VsMass2 = ConfPairBinning.plotKstarVsMass1VsMass2.value; + mPlotKstarVsMass1VsMult = ConfPairBinning.plotKstarVsMass1VsMult.value; + mPlotKstarVsMass2VsMult = ConfPairBinning.plotKstarVsMass2VsMult.value; + mPlotKstarVsMass1VsMass2VsMult = ConfPairBinning.plotKstarVsMass1VsMass2VsMult.value; + + // values for cuts + mKstarMin = ConfPairCuts.kstarMin.value; + mKstarMax = ConfPairCuts.kstarMax.value; + mKtMin = ConfPairCuts.ktMin.value; + mKtMax = ConfPairCuts.ktMax.value; + mMtMin = ConfPairCuts.mtMin.value; + mMtMax = ConfPairCuts.mtMax.value; if constexpr (isFlagSet(mode, modes::Mode::kAnalysis)) { std::string analysisDir = std::string(prefix) + std::string(AnalysisDir); @@ -217,6 +282,17 @@ class PairHistManager mHistogramRegistry->add(analysisDir + getHistNameV2(kKstarVsMt, HistTable), getHistDesc(kKstarVsMt, HistTable), getHistType(kKstarVsMt, HistTable), {Specs.at(kKstarVsMt)}); mHistogramRegistry->add(analysisDir + getHistNameV2(kKstarVsMult, HistTable), getHistDesc(kKstarVsMult, HistTable), getHistType(kKstarVsMult, HistTable), {Specs.at(kKstarVsMult)}); mHistogramRegistry->add(analysisDir + getHistNameV2(kKstarVsCent, HistTable), getHistDesc(kKstarVsCent, HistTable), getHistType(kKstarVsCent, HistTable), {Specs.at(kKstarVsCent)}); + + // special care for mass plots since not all particles have "mass" + if constexpr (modes::hasMass(particleType1)) { + mHistogramRegistry->add(analysisDir + getHistNameV2(kKstarVsMass1, HistTable), getHistDesc(kKstarVsMass1, HistTable), getHistType(kKstarVsMass1, HistTable), {Specs.at(kKstarVsMass1)}); + } + if constexpr (modes::hasMass(particleType2)) { + mHistogramRegistry->add(analysisDir + getHistNameV2(kKstarVsMass2, HistTable), getHistDesc(kKstarVsMass2, HistTable), getHistType(kKstarVsMass2, HistTable), {Specs.at(kKstarVsMass2)}); + } + if constexpr (modes::hasMass(particleType1) && modes::hasMass(particleType2)) { + mHistogramRegistry->add(analysisDir + getHistNameV2(kMass1VsMass2, HistTable), getHistDesc(kMass1VsMass2, HistTable), getHistType(kMass1VsMass2, HistTable), {Specs.at(kMass1VsMass2)}); + } } if (mPlotKstarVsMtVsMult) { @@ -226,10 +302,30 @@ class PairHistManager mHistogramRegistry->add(analysisDir + getHistNameV2(kKstarVsMtVsMultVsCent, HistTable), getHistDesc(kKstarVsMtVsMultVsCent, HistTable), getHistType(kKstarVsMtVsMultVsCent, HistTable), {Specs.at(kKstarVsMtVsMultVsCent)}); } if (mPlotKstarVsMtVsPt1VsP2VsMult) { - mHistogramRegistry->add(analysisDir + getHistNameV2(kKstarVsMtVsPt1VsP2VsMult, HistTable), getHistDesc(kKstarVsMtVsPt1VsP2VsMult, HistTable), getHistType(kKstarVsMtVsPt1VsP2VsMult, HistTable), {Specs.at(kKstarVsMtVsPt1VsP2VsMult)}); + mHistogramRegistry->add(analysisDir + getHistNameV2(kKstarVsMtVsPt1VsPt2VsMult, HistTable), getHistDesc(kKstarVsMtVsPt1VsPt2VsMult, HistTable), getHistType(kKstarVsMtVsPt1VsPt2VsMult, HistTable), {Specs.at(kKstarVsMtVsPt1VsPt2VsMult)}); } if (mPlotKstarVsMtVsPt1VsP2VsMultVsCent) { - mHistogramRegistry->add(analysisDir + getHistNameV2(kKstarVsMtVsPt1VsP2VsMultVsCent, HistTable), getHistDesc(kKstarVsMtVsPt1VsP2VsMultVsCent, HistTable), getHistType(kKstarVsMtVsPt1VsP2VsMultVsCent, HistTable), {Specs.at(kKstarVsMtVsPt1VsP2VsMultVsCent)}); + mHistogramRegistry->add(analysisDir + getHistNameV2(kKstarVsMtVsPt1VsPt2VsMultVsCent, HistTable), getHistDesc(kKstarVsMtVsPt1VsPt2VsMultVsCent, HistTable), getHistType(kKstarVsMtVsPt1VsPt2VsMultVsCent, HistTable), {Specs.at(kKstarVsMtVsPt1VsPt2VsMultVsCent)}); + } + + // again special care for particles with "mass" + if constexpr (modes::hasMass(particleType1)) { + if (mPlotKstarVsMass1VsMult) { + mHistogramRegistry->add(analysisDir + getHistNameV2(kKstarVsMass1VsMult, HistTable), getHistDesc(kKstarVsMass1VsMult, HistTable), getHistType(kKstarVsMass1VsMult, HistTable), {Specs.at(kKstarVsMass1VsMult)}); + } + } + if constexpr (modes::hasMass(particleType2)) { + if (mPlotKstarVsMass2VsMult) { + mHistogramRegistry->add(analysisDir + getHistNameV2(kKstarVsMass2VsMult, HistTable), getHistDesc(kKstarVsMass2VsMult, HistTable), getHistType(kKstarVsMass2VsMult, HistTable), {Specs.at(kKstarVsMass2VsMult)}); + } + } + if constexpr (modes::hasMass(particleType1) && modes::hasMass(particleType2)) { + if (mPlotKstarVsMass1VsMass2) { + mHistogramRegistry->add(analysisDir + getHistNameV2(kKstarVsMass1VsMass2, HistTable), getHistDesc(kKstarVsMass1VsMass2, HistTable), getHistType(kKstarVsMass1VsMass2, HistTable), {Specs.at(kKstarVsMass1VsMass2)}); + } + if (mPlotKstarVsMass1VsMass2VsMult) { + mHistogramRegistry->add(analysisDir + getHistNameV2(kKstarVsMass1VsMass2VsMult, HistTable), getHistDesc(kKstarVsMass1VsMass2VsMult, HistTable), getHistType(kKstarVsMass1VsMass2VsMult, HistTable), {Specs.at(kKstarVsMass1VsMass2VsMult)}); + } } } @@ -240,8 +336,9 @@ class PairHistManager void setMass(int PdgParticle1, int PdgParticle2) { - mMass1 = o2::analysis::femto::utils::getMass(PdgParticle1); - mMass2 = o2::analysis::femto::utils::getMass(PdgParticle2); + mPdgMass1 = o2::analysis::femto::utils::getMass(PdgParticle1); + mPdgMass2 = o2::analysis::femto::utils::getMass(PdgParticle2); + mPdgAverageMass = (mPdgMass1 + mPdgMass2) / 2.f; } void setCharge(int chargeAbsParticle1, int chargeAbsParticle2) { @@ -251,25 +348,20 @@ class PairHistManager mAbsCharge2 = std::abs(chargeAbsParticle2); } - template - void setPair(const T1& particle1, const T2& particle2, const T3& col) + template + void setPair(const T1& particle1, const T2& particle2) { - // set collision properties - mMult = col.mult(); - mCent = col.cent(); - // pt in track table is calculated from 1/signedPt from the original track table // in case of He with Z=2, we have to rescale the pt with the absolute charge - mParticle1 = ROOT::Math::PtEtaPhiMVector{mAbsCharge1 * particle1.pt(), particle1.eta(), particle1.phi(), mMass1}; - mParticle2 = ROOT::Math::PtEtaPhiMVector{mAbsCharge2 * particle2.pt(), particle2.eta(), particle2.phi(), mMass2}; + mParticle1 = ROOT::Math::PtEtaPhiMVector{mAbsCharge1 * particle1.pt(), particle1.eta(), particle1.phi(), mPdgMass1}; + mParticle2 = ROOT::Math::PtEtaPhiMVector{mAbsCharge2 * particle2.pt(), particle2.eta(), particle2.phi(), mPdgMass2}; auto partSum = mParticle1 + mParticle2; // set kT mKt = partSum.Pt() / 2.f; // set mT - float averageMass = (mMass1 + mMass2) / 2.f; - mMt = std::hypot(mKt, averageMass); + mMt = std::hypot(mKt, mPdgAverageMass); // Boost particle to the pair rest frame (Prf) and calculate k* (would be equivalent using particle 2) // make a copy of particle 1 @@ -278,6 +370,40 @@ class PairHistManager ROOT::Math::Boost boostPrf(partSum.BoostToCM()); // boost particle 1 into pair rest frame and calculate its momentum, which has the same value as k* mKstar = boostPrf(particle1Prf).P(); + + // if one of the particles has a mass getter, we cache the value for the filling later + if constexpr (modes::hasMass(particleType1)) { + mMass1 = particle1.mass(); + } + if constexpr (modes::hasMass(particleType2)) { + mMass2 = particle2.mass(); + } + } + + template + void setPair(const T1& particle1, const T2& particle2, const T3& col) + { + mMult = col.mult(); + mCent = col.cent(); + setPair(particle1, particle2); + } + + template + void setPair(const T1& particle1, const T2& particle2, const T3& col1, const T4& col2) + { + mMult = 0.5f * (col1.mult() + col2.mult()); // if mixing with multiplicity, should be in the same mixing bin + mCent = 0.5f * (col1.cent() + col2.cent()); // if mixing with centrality, should be in the same mixing bin + setPair(particle1, particle2); + } + + bool checkPairCuts() const + { + return (!(mKstarMin > 0.f) || mKstar > mKstarMin) && + (!(mKstarMax > 0.f) || mKstar < mKstarMax) && + (!(mKtMin > 0.f) || mKt > mKtMin) && + (!(mKtMax > 0.f) || mKt < mKtMax) && + (!(mMtMin > 0.f) || mMt > mMtMin) && + (!(mMtMax > 0.f) || mMt < mMtMax); } void fill() @@ -300,40 +426,84 @@ class PairHistManager mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMt, HistTable)), mKstar, mMt); mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMult, HistTable)), mKstar, mMult); mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsCent, HistTable)), mKstar, mCent); + + // // special care for mass plots since not all particles have "mass" + if constexpr (modes::hasMass(particleType1)) { + mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMass1, HistTable)), mKstar, mMass1); + } + if constexpr (modes::hasMass(particleType2)) { + mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMass2, HistTable)), mKstar, mMass2); + } + if constexpr (modes::hasMass(particleType1) && modes::hasMass(particleType2)) { + mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kMass1VsMass2, HistTable)), mMass1, mMass2); + } } - if (mPlotKstarVsMtVsMult) { - mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMtVsMult, HistTable)), mKstar, mMt, mMult); + } + + // n-D histograms are only filled if enabled + if (mPlotKstarVsMtVsMult) { + mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMtVsMult, HistTable)), mKstar, mMt, mMult); + } + if (mPlotKstarVsMtVsMultVsCent) { + mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMtVsMultVsCent, HistTable)), mKstar, mMt, mMult, mCent); + } + if (mPlotKstarVsMtVsPt1VsP2VsMult) { + mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMtVsPt1VsPt2VsMult, HistTable)), mKstar, mMt, mParticle1.Pt(), mParticle2.pt(), mMult); + } + if (mPlotKstarVsMtVsPt1VsP2VsMultVsCent) { + mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMtVsPt1VsPt2VsMultVsCent, HistTable)), mKstar, mMt, mParticle1.Pt(), mParticle2.pt(), mMult, mCent); + } + + // again special care for particles with "mass" + if constexpr (modes::hasMass(particleType1)) { + if (mPlotKstarVsMass1VsMult) { + mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMass1VsMult, HistTable)), mKstar, mMass1, mMult); } - if (mPlotKstarVsMtVsMultVsCent) { - mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMtVsMultVsCent, HistTable)), mKstar, mMt, mMult, mCent); + } + if constexpr (modes::hasMass(particleType2)) { + if (mPlotKstarVsMass2VsMult) { + mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMass2VsMult, HistTable)), mKstar, mMass2, mMult); } - if (mPlotKstarVsMtVsPt1VsP2VsMult) { - mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMtVsPt1VsP2VsMult, HistTable)), mKstar, mMt, mParticle1.Pt(), mParticle2.pt(), mMult); + } + if constexpr (modes::hasMass(particleType1) && modes::hasMass(particleType2)) { + if (mPlotKstarVsMass1VsMass2) { + mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMass1VsMass2, HistTable)), mKstar, mMass1, mMass2); } - if (mPlotKstarVsMtVsPt1VsP2VsMultVsCent) { - mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMtVsPt1VsP2VsMultVsCent, HistTable)), mKstar, mMt, mParticle1.Pt(), mParticle2.pt(), mMult, mCent); + if (mPlotKstarVsMass1VsMass2VsMult) { + mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMass1VsMass2VsMult, HistTable)), mKstar, mMass1, mMass2, mMult); } } - - // if constexpr (isFlagSet(mode, modes::Mode::kQA)) { - // mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(getHistName(kPtVsDcaz, HistTable)), track.pt(), track.dcaZ()); - // } } + // if constexpr (isFlagSet(mode, modes::Mode::kQA)) { + // mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(getHistName(kPtVsDcaz, HistTable)), track.pt(), track.dcaZ()); + // } + private: o2::framework::HistogramRegistry* mHistogramRegistry = nullptr; - float mMass1 = 0.f; - float mMass2 = 0.f; + float mPdgMass1 = 0.f; + float mPdgMass2 = 0.f; + float mPdgAverageMass = 0.f; int mAbsCharge1 = 1; int mAbsCharge2 = 1; ROOT::Math::PtEtaPhiMVector mParticle1{}; ROOT::Math::PtEtaPhiMVector mParticle2{}; + float mMass1 = 0.f; + float mMass2 = 0.f; float mKstar = 0.f; float mKt = 0.f; float mMt = 0.f; float mMult = 0.f; float mCent = 0.f; + // cuts + float mKstarMin = -1.f; + float mKstarMax = -1.f; + float mKtMin = -1.f; + float mKtMax = -1.f; + float mMtMin = -1.f; + float mMtMax = -1.f; + // flags bool mPlot1d = true; bool mPlot2d = true; @@ -341,6 +511,11 @@ class PairHistManager bool mPlotKstarVsMtVsMultVsCent = false; bool mPlotKstarVsMtVsPt1VsP2VsMult = false; bool mPlotKstarVsMtVsPt1VsP2VsMultVsCent = false; + + bool mPlotKstarVsMass1VsMass2 = false; + bool mPlotKstarVsMass1VsMult = false; + bool mPlotKstarVsMass2VsMult = false; + bool mPlotKstarVsMass1VsMass2VsMult = false; }; }; // namespace pairhistmanager diff --git a/PWGCF/Femto/Core/pairProcessHelpers.h b/PWGCF/Femto/Core/pairProcessHelpers.h index dbede67648d..39b800be5ce 100644 --- a/PWGCF/Femto/Core/pairProcessHelpers.h +++ b/PWGCF/Femto/Core/pairProcessHelpers.h @@ -45,20 +45,17 @@ void processSameEvent(T1 const& SliceParticle, T7& rng, bool randomize) { - // Fill single particle histograms for (auto const& part : SliceParticle) { ParticleHistManager.fill(part, TrackTable); } std::uniform_real_distribution dist(0.f, 1.f); for (auto const& [p1, p2] : o2::soa::combinations(o2::soa::CombinationsStrictlyUpperIndexPolicy(SliceParticle, SliceParticle))) { - // Close pair rejection if (CprManager.isActivated()) { CprManager.setPair(p1, p2, TrackTable); if (CprManager.isClosePair()) { continue; } } - CprManager.fill(); // Randomize pair order if enabled float threshold = 0.5f; bool swapPair = randomize ? (dist(rng) > threshold) : false; @@ -67,7 +64,10 @@ void processSameEvent(T1 const& SliceParticle, } else { PairHistManager.setPair(p1, p2, Collision); } - PairHistManager.fill(); + if (PairHistManager.checkPairCuts()) { + CprManager.fill(); + PairHistManager.fill(); + } } } @@ -110,9 +110,11 @@ void processSameEvent(T1 const& SliceParticle1, continue; } } - CprManager.fill(); PairHistManager.setPair(p1, p2, Collision); - PairHistManager.fill(); + if (PairHistManager.checkPairCuts()) { + CprManager.fill(); + PairHistManager.fill(); + } } } @@ -158,9 +160,11 @@ void processMixedEvent(T1& Collisions, continue; } } - CprManager.fill(); - PairHistManager.setPair(p1, p2, collision1); - PairHistManager.fill(); + PairHistManager.setPair(p1, p2, collision1, collision2); + if (PairHistManager.checkPairCuts()) { + CprManager.fill(); + PairHistManager.fill(); + } } } } @@ -209,9 +213,11 @@ void processMixedEvent(T1& Collisions, continue; } } - CprManager.fill(); - PairHistManager.setPair(p1, p2, collision1); - PairHistManager.fill(); + PairHistManager.setPair(p1, p2, collision1, collision2); + if (PairHistManager.checkPairCuts()) { + CprManager.fill(); + PairHistManager.fill(); + } } } } diff --git a/PWGCF/Femto/Tasks/femtoPairTrackCascade.cxx b/PWGCF/Femto/Tasks/femtoPairTrackCascade.cxx index a6b976bcb75..0c556d5ee2b 100644 --- a/PWGCF/Femto/Tasks/femtoPairTrackCascade.cxx +++ b/PWGCF/Femto/Tasks/femtoPairTrackCascade.cxx @@ -92,6 +92,7 @@ struct FemtoPairTrackCascade { // setup pairs pairhistmanager::ConfPairBinning confPairBinning; + pairhistmanager::ConfPairCuts confPairCuts; pairbuilder::PairTrackCascadeBuilder< trackhistmanager::PrefixTrack1, @@ -158,21 +159,21 @@ struct FemtoPairTrackCascade { auto bachelorHistSpec = trackhistmanager::makeTrackHistSpecMap(confBachelorBinning); auto posDauSpec = trackhistmanager::makeTrackHistSpecMap(confPosDauBinning); auto negDauSpec = trackhistmanager::makeTrackHistSpecMap(confNegDauBinning); - auto pairHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confXiBinning); + auto pairHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); auto cprHistSpec = closepairrejection::makeCprHistSpecMap(confCpr); // setup for xis if (doprocessXiSameEvent || doprocessXiMixedEvent) { auto xiHistSpec = cascadehistmanager::makeCascadeHistSpecMap(confXiBinning); - auto pairTrackXiHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confXiBinning); - pairTrackXiBuilder.init(&hRegistry, trackSelection, xiSelection, confCpr, confMixing, confPairBinning, colHistSpec, trackHistSpec, xiHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, pairTrackXiHistSpec, cprHistSpec); + auto pairTrackXiHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); + pairTrackXiBuilder.init(&hRegistry, trackSelection, xiSelection, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, xiHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, pairTrackXiHistSpec, cprHistSpec); } // setup for omegas if (doprocessOmegaSameEvent || doprocessOmegaMixedEvent) { auto omegaHistSpec = cascadehistmanager::makeCascadeHistSpecMap(confOmegaBinning); - auto pairTrackOmegaHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confOmegaBinning); - pairTrackOmegaBuilder.init(&hRegistry, trackSelection, omegaSelection, confCpr, confMixing, confPairBinning, colHistSpec, trackHistSpec, omegaHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, pairTrackOmegaHistSpec, cprHistSpec); + auto pairTrackOmegaHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); + pairTrackOmegaBuilder.init(&hRegistry, trackSelection, omegaSelection, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, omegaHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, pairTrackOmegaHistSpec, cprHistSpec); } if (((doprocessXiSameEvent || doprocessXiMixedEvent) + (doprocessOmegaSameEvent || doprocessOmegaMixedEvent)) > 1) { diff --git a/PWGCF/Femto/Tasks/femtoPairTrackKink.cxx b/PWGCF/Femto/Tasks/femtoPairTrackKink.cxx index 6c8af2f5bff..758b03f61fd 100644 --- a/PWGCF/Femto/Tasks/femtoPairTrackKink.cxx +++ b/PWGCF/Femto/Tasks/femtoPairTrackKink.cxx @@ -84,6 +84,7 @@ struct FemtoPairTrackKink { // setup pairs pairhistmanager::ConfPairBinning confPairBinning; + pairhistmanager::ConfPairCuts confPairCuts; pairbuilder::PairTrackKinkBuilder< trackhistmanager::PrefixTrack1, @@ -124,14 +125,14 @@ struct FemtoPairTrackKink { auto colHistSpec = colhistmanager::makeColHistSpecMap(confCollisionBinning); auto trackHistSpec = trackhistmanager::makeTrackHistSpecMap(confTrackBinning); auto chaDauSpec = trackhistmanager::makeTrackHistSpecMap(confChaDauBinning); - auto pairHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confSigmaBinning); + auto pairHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); auto cprHistSpec = closepairrejection::makeCprHistSpecMap(confCpr); // setup for sigma // if (doprocessSigmaSameEvent || doprocessSigmaMixedEvent) { if (doprocessSigmaSameEvent) { auto sigmaHistSpec = kinkhistmanager::makeKinkHistSpecMap(confSigmaBinning); - pairTrackSigmaBuilder.init(&hRegistry, trackSelection, sigmaSelection, confCpr, confMixing, confPairBinning, colHistSpec, trackHistSpec, sigmaHistSpec, chaDauSpec, pairHistSpec, cprHistSpec); + pairTrackSigmaBuilder.init(&hRegistry, trackSelection, sigmaSelection, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, sigmaHistSpec, chaDauSpec, pairHistSpec, cprHistSpec); } }; diff --git a/PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx b/PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx index e905757ef85..71f692eefee 100644 --- a/PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx +++ b/PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx @@ -76,6 +76,8 @@ struct FemtoPairTrackTrack { // setup pairs pairhistmanager::ConfPairBinning confPairBinning; + pairhistmanager::ConfPairCuts confPairCuts; + closepairrejection::ConfCpr confCpr; pairbuilder::PairTrackTrackBuilder< @@ -111,10 +113,10 @@ struct FemtoPairTrackTrack { auto colHistSpec = colhistmanager::makeColHistSpecMap(confCollisionBinning); auto trackHistSpec1 = trackhistmanager::makeTrackHistSpecMap(confTrackBinning1); auto trackHistSpec2 = trackhistmanager::makeTrackHistSpecMap(confTrackBinning2); - auto pairHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning1, confTrackBinning2); + auto pairHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); auto cprHistSpec = closepairrejection::makeCprHistSpecMap(confCpr); - pairTrackTrackBuilder.init(&hRegistry, trackSelections1, trackSelections2, confCpr, confMixing, confPairBinning, colHistSpec, trackHistSpec1, trackHistSpec2, pairHistSpec, cprHistSpec); + pairTrackTrackBuilder.init(&hRegistry, trackSelections1, trackSelections2, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec1, trackHistSpec2, pairHistSpec, cprHistSpec); }; void processSameEvent(FilteredCollision const& col, Tracks const& tracks) diff --git a/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx b/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx index 16e773da509..5d04cf56691 100644 --- a/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx +++ b/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx @@ -98,6 +98,7 @@ struct FemtoPairTrackTwoTrackResonance { // setup pairs pairhistmanager::ConfPairBinning confPairBinning; + pairhistmanager::ConfPairCuts confPairCuts; // setup for track-phi pairs pairbuilder::PairTrackTwoTrackResonanceBuilder< @@ -184,22 +185,22 @@ struct FemtoPairTrackTwoTrackResonance { // setup for phi if (doprocessPhiSameEvent || doprocessPhiMixedEvent) { auto phiHistSpec = twotrackresonancehistmanager::makeTwoTrackResonanceHistSpecMap(confPhiBinning); - auto pairTrackPhiHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confPhiBinning); - pairTrackPhiBuilder.init(&hRegistry, trackSelection, phiSelection, confCpr, confMixing, confPairBinning, colHistSpec, trackHistSpec, phiHistSpec, posDauSpec, negDauSpec, pairTrackPhiHistSpec, cprHistSpec); + auto pairTrackPhiHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); + pairTrackPhiBuilder.init(&hRegistry, trackSelection, phiSelection, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, phiHistSpec, posDauSpec, negDauSpec, pairTrackPhiHistSpec, cprHistSpec); } // setup for kstar0 if (doprocessKstar0SameEvent || doprocessKstar0MixedEvent) { auto kstar0HistSpec = twotrackresonancehistmanager::makeTwoTrackResonanceHistSpecMap(confKstar0Binning); - auto pairTrackKstar0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confKstar0Binning); - pairTrackKstar0Builder.init(&hRegistry, trackSelection, kstar0Selection, confCpr, confMixing, confPairBinning, colHistSpec, trackHistSpec, kstar0HistSpec, posDauSpec, negDauSpec, pairTrackKstar0HistSpec, cprHistSpec); + auto pairTrackKstar0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); + pairTrackKstar0Builder.init(&hRegistry, trackSelection, kstar0Selection, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, kstar0HistSpec, posDauSpec, negDauSpec, pairTrackKstar0HistSpec, cprHistSpec); } // setup for kstar0 if (doprocessRho0SameEvent || doprocessRho0MixedEvent) { auto rho0HistSpec = twotrackresonancehistmanager::makeTwoTrackResonanceHistSpecMap(confRho0Binning); - auto pairTrackRho0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confRho0Binning); - pairTrackRho0Builder.init(&hRegistry, trackSelection, rho0Selection, confCpr, confMixing, confPairBinning, colHistSpec, trackHistSpec, rho0HistSpec, posDauSpec, negDauSpec, pairTrackRho0HistSpec, cprHistSpec); + auto pairTrackRho0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); + pairTrackRho0Builder.init(&hRegistry, trackSelection, rho0Selection, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, rho0HistSpec, posDauSpec, negDauSpec, pairTrackRho0HistSpec, cprHistSpec); } }; diff --git a/PWGCF/Femto/Tasks/femtoPairTrackV0.cxx b/PWGCF/Femto/Tasks/femtoPairTrackV0.cxx index 9b92a7959e4..994dbbbd132 100644 --- a/PWGCF/Femto/Tasks/femtoPairTrackV0.cxx +++ b/PWGCF/Femto/Tasks/femtoPairTrackV0.cxx @@ -91,6 +91,7 @@ struct FemtoPairTrackV0 { // setup pairs pairhistmanager::ConfPairBinning confPairBinning; + pairhistmanager::ConfPairCuts confPairCuts; pairbuilder::PairTrackV0Builder< trackhistmanager::PrefixTrack1, @@ -155,15 +156,15 @@ struct FemtoPairTrackV0 { // setup for lambda if (doprocessLambdaSameEvent || doprocessLambdaMixedEvent) { auto lambdaHistSpec = v0histmanager::makeV0HistSpecMap(confLambdaBinning); - auto pairTrackLambdaHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confLambdaBinning); - pairTrackLambdaBuilder.init(&hRegistry, trackSelection, lambdaSelection, confCpr, confMixing, confPairBinning, colHistSpec, trackHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairTrackLambdaHistSpec, cprHistSpec); + auto pairTrackLambdaHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); + pairTrackLambdaBuilder.init(&hRegistry, trackSelection, lambdaSelection, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairTrackLambdaHistSpec, cprHistSpec); } // setup for k0short if (doprocessK0shortSameEvent || doprocessK0shortMixedEvent) { auto k0shortHistSpec = v0histmanager::makeV0HistSpecMap(confK0shortBinning); - auto pairTrackK0shortHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confLambdaBinning); - pairTrackK0shortBuilder.init(&hRegistry, trackSelection, lambdaSelection, confCpr, confMixing, confPairBinning, colHistSpec, trackHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairTrackK0shortHistSpec, cprHistSpec); + auto pairTrackK0shortHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); + pairTrackK0shortBuilder.init(&hRegistry, trackSelection, lambdaSelection, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairTrackK0shortHistSpec, cprHistSpec); } if (((doprocessLambdaSameEvent || doprocessLambdaMixedEvent) + (doprocessK0shortSameEvent || doprocessK0shortMixedEvent)) > 1) { diff --git a/PWGCF/Femto/Tasks/femtoPairV0V0.cxx b/PWGCF/Femto/Tasks/femtoPairV0V0.cxx index 61356c41aa7..ef5fc7e7b61 100644 --- a/PWGCF/Femto/Tasks/femtoPairV0V0.cxx +++ b/PWGCF/Femto/Tasks/femtoPairV0V0.cxx @@ -85,6 +85,7 @@ struct FemtoPairV0V0 { // setup pairs pairhistmanager::ConfPairBinning confPairBinning; + pairhistmanager::ConfPairCuts confPairCuts; pairbuilder::PairV0V0Builder< v0histmanager::PrefixLambda1, @@ -154,15 +155,15 @@ struct FemtoPairV0V0 { // setup for lambda if (doprocessLambdaLambdaSameEvent || doprocessLambdaLambdaMixedEvent) { auto lambdaHistSpec = v0histmanager::makeV0HistSpecMap(confLambdaBinning); - auto pairLambdaLambdaHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confLambdaBinning, confLambdaBinning); - pairLambdaLambdaBuilder.init(&hRegistry, lambdaSelection, lambdaSelection, confCpr, confMixing, confPairBinning, colHistSpec, lambdaHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairLambdaLambdaHistSpec, cprHistSpec); + auto pairLambdaLambdaHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); + pairLambdaLambdaBuilder.init(&hRegistry, lambdaSelection, lambdaSelection, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, lambdaHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairLambdaLambdaHistSpec, cprHistSpec); } // setup for k0short if (doprocessK0shortK0shortSameEvent || doprocessK0shortK0shortMixedEvent) { auto k0shortHistSpec = v0histmanager::makeV0HistSpecMap(confK0shortBinning); - auto pairLambdaLambdaHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confLambdaBinning, confLambdaBinning); - pairLambdaLambdaBuilder.init(&hRegistry, k0shortSelection, k0shortSelection, confCpr, confMixing, confPairBinning, colHistSpec, k0shortHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairLambdaLambdaHistSpec, cprHistSpec); + auto pairLambdaLambdaHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); + pairLambdaLambdaBuilder.init(&hRegistry, k0shortSelection, k0shortSelection, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, k0shortHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairLambdaLambdaHistSpec, cprHistSpec); } if (((doprocessLambdaLambdaSameEvent || doprocessLambdaLambdaMixedEvent) + (doprocessK0shortK0shortSameEvent || doprocessK0shortK0shortMixedEvent)) > 1) {