From 9c5f4d42df3e480b7b071dac39373a0fc2c6a967 Mon Sep 17 00:00:00 2001 From: Anton Riedel Date: Wed, 15 Apr 2026 13:02:32 +0200 Subject: [PATCH 1/2] Feat: update pair builder --- PWGCF/Femto/Core/closePairRejection.h | 2 +- PWGCF/Femto/Core/collisionHistManager.h | 49 +--- PWGCF/Femto/Core/modes.h | 6 + PWGCF/Femto/Core/pairBuilder.h | 119 +++++----- PWGCF/Femto/Core/pairHistManager.h | 212 ++++++++++++++---- PWGCF/Femto/Core/tripletBuilder.h | 20 +- PWGCF/Femto/Core/tripletHistManager.h | 2 +- PWGCF/Femto/Tasks/femtoCascadeQa.cxx | 8 +- PWGCF/Femto/Tasks/femtoKinkQa.cxx | 8 +- PWGCF/Femto/Tasks/femtoPairTrackCascade.cxx | 33 ++- PWGCF/Femto/Tasks/femtoPairTrackKink.cxx | 28 +-- PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx | 20 +- .../Tasks/femtoPairTrackTwoTrackResonance.cxx | 24 +- PWGCF/Femto/Tasks/femtoPairTrackV0.cxx | 28 +-- PWGCF/Femto/Tasks/femtoPairV0V0.cxx | 30 +-- PWGCF/Femto/Tasks/femtoTrackQa.cxx | 4 +- .../Femto/Tasks/femtoTwotrackresonanceQa.cxx | 6 +- PWGCF/Femto/Tasks/femtoV0Qa.cxx | 8 +- .../Tasks/femtoPairLambdaAntilambda.cxx | 32 +-- 19 files changed, 373 insertions(+), 266 deletions(-) diff --git a/PWGCF/Femto/Core/closePairRejection.h b/PWGCF/Femto/Core/closePairRejection.h index 3edc198aba9..792f521a3c4 100644 --- a/PWGCF/Femto/Core/closePairRejection.h +++ b/PWGCF/Femto/Core/closePairRejection.h @@ -558,7 +558,7 @@ class ClosePairRejectionTrackCascade bool isClosePair() const { - return mCtrBachelor.isClosePair() || mCtrBachelor.isClosePair(); + return mCtrBachelor.isClosePair(); } void fill(float kstar) diff --git a/PWGCF/Femto/Core/collisionHistManager.h b/PWGCF/Femto/Core/collisionHistManager.h index a4bbda81b6f..0d345236a5d 100644 --- a/PWGCF/Femto/Core/collisionHistManager.h +++ b/PWGCF/Femto/Core/collisionHistManager.h @@ -53,9 +53,6 @@ enum ColHist { kCentVsMult, kCentVsSphericity, kMultVsSphericity, - // particle number correlation - kNpart1VsNpart2, - kNpart1VsNpart2VsNpart3, // mc kTrueCentVsCent, kTrueMultVsMult, @@ -84,21 +81,16 @@ constexpr std::array, kColHistLast> HistTable = { {kCentVsMult, o2::framework::kTH2F, "hCentVsMult", "Centrality vs Multiplicity; Centrality (%); Multiplicity"}, {kMultVsSphericity, o2::framework::kTH2F, "hMultVsSphericity", "Multiplicity vs Sphericity; Multiplicity; Sphericity"}, {kCentVsSphericity, o2::framework::kTH2F, "hCentVsSphericity", "Centrality vs Sphericity; Centrality (%); Sphericity"}, - // particle number correlation - {kNpart1VsNpart2, o2::framework::kTH2F, "hNpart1VsNpart2", "# particle 1 vs # particle 2; # particle 1; # particle 2"}, - {kNpart1VsNpart2VsNpart3, o2::framework::kTHnSparseF, "hNpart1VsNpart2VsNpart3", "# particle 1 vs # particle 2 vs particle 3; # particle 1; # particle 2; # particle 3"}, // mc {kTrueCentVsCent, o2::framework::kTH2F, "hTrueCentVsCent", "True centrality vs centrality; Centrality_{True} (%); Centrality (%)"}, {kTrueMultVsMult, o2::framework::kTH2F, "hTrueMultVsMult", "True multiplicity vs multiplicity; Multiplicity_{True}; Multiplicity"}, }}; -#define COL_HIST_ANALYSIS_MAP(conf) \ - {kPosZ, {conf.vtxZ}}, \ - {kMult, {conf.mult}}, \ - {kCent, {conf.cent}}, \ - {kMagField, {conf.magField}}, \ - {kNpart1VsNpart2, {conf.particleCorrelation, conf.particleCorrelation}}, \ - {kNpart1VsNpart2VsNpart3, {conf.particleCorrelation, conf.particleCorrelation, conf.particleCorrelation}}, +#define COL_HIST_ANALYSIS_MAP(conf) \ + {kPosZ, {conf.vtxZ}}, \ + {kMult, {conf.mult}}, \ + {kCent, {conf.cent}}, \ + {kMagField, {conf.magField}}, #define COL_HIST_QA_MAP(confAnalysis, confQa) \ {kPosX, {confQa.vtxXY}}, \ @@ -158,9 +150,6 @@ struct ConfCollisionBinning : o2::framework::ConfigurableGroup { o2::framework::ConfigurableAxis mult{"mult", {200, 0, 200}, "Multiplicity binning"}; o2::framework::ConfigurableAxis cent{"cent", {100, 0.0f, 100.0f}, "Centrality (multiplicity percentile) binning"}; o2::framework::ConfigurableAxis magField{"magField", {11, -5.5, 5.5}, "Magnetic field binning"}; - o2::framework::Configurable plotParticlePairCorrelation{"plotParticlePairCorrelation", false, "Plot particle number correlation for pairs"}; - o2::framework::Configurable plotParticleTripletCorrelation{"plotParticleTripletCorrelation", false, "Plot particle number correlation for triplets"}; - o2::framework::ConfigurableAxis particleCorrelation{"particleCorrelation", {6, -0.5f, 5.5f}, "Binning for particle number correlation of pairs/triplets"}; }; struct ConfCollisionQaBinning : o2::framework::ConfigurableGroup { @@ -181,11 +170,9 @@ class CollisionHistManager template void init(o2::framework::HistogramRegistry* registry, std::map> const& Specs, - T const& ConfCollisionBinning) + T const& /*ConfCollisionBinning*/) { mHistogramRegistry = registry; - mPlotPairCorrelation = ConfCollisionBinning.plotParticlePairCorrelation.value; - mPlotTripletCorrelation = ConfCollisionBinning.plotParticleTripletCorrelation.value; if constexpr (isFlagSet(mode, modes::Mode::kAnalysis)) { initAnalysis(Specs); } @@ -214,10 +201,10 @@ class CollisionHistManager } template - void fill(T const& col, int64_t nSlice1, int64_t nSlice2, int64_t nSlice3) + void fill(T const& col) { if constexpr (isFlagSet(mode, modes::Mode::kAnalysis)) { - fillAnalysis(col, nSlice1, nSlice2, nSlice3); + fillAnalysis(col); } if constexpr (isFlagSet(mode, modes::Mode::kQa)) { fillQa(col); @@ -225,10 +212,10 @@ class CollisionHistManager } template - void fill(T1 const& col, T2 const& mcCols, int64_t nSlice1, int64_t nSlice2, int64_t nSlice3) + void fill(T1 const& col, T2 const& mcCols) { if constexpr (isFlagSet(mode, modes::Mode::kAnalysis)) { - fillAnalysis(col, nSlice1, nSlice2, nSlice3); + fillAnalysis(col); } if constexpr (isFlagSet(mode, modes::Mode::kQa)) { fillQa(col); @@ -246,12 +233,6 @@ class CollisionHistManager mHistogramRegistry->add(analysisDir + getHistNameV2(kMult, HistTable), getHistDesc(kMult, HistTable), getHistType(kMult, HistTable), {Specs.at(kMult)}); mHistogramRegistry->add(analysisDir + getHistNameV2(kCent, HistTable), getHistDesc(kCent, HistTable), getHistType(kCent, HistTable), {Specs.at(kCent)}); mHistogramRegistry->add(analysisDir + getHistNameV2(kMagField, HistTable), getHistDesc(kMagField, HistTable), getHistType(kMagField, HistTable), {Specs.at(kMagField)}); - if (mPlotPairCorrelation) { - mHistogramRegistry->add(analysisDir + getHistNameV2(kNpart1VsNpart2, HistTable), getHistDesc(kNpart1VsNpart2, HistTable), getHistType(kNpart1VsNpart2, HistTable), {Specs.at(kNpart1VsNpart2)}); - } - if (mPlotTripletCorrelation) { - mHistogramRegistry->add(analysisDir + getHistNameV2(kNpart1VsNpart2VsNpart3, HistTable), getHistDesc(kNpart1VsNpart2VsNpart3, HistTable), getHistType(kNpart1VsNpart2VsNpart3, HistTable), {Specs.at(kNpart1VsNpart2VsNpart3)}); - } } void initQa(std::map> const& Specs) @@ -279,18 +260,12 @@ class CollisionHistManager } template - void fillAnalysis(T const& col, size_t nSlice1, size_t nSlice2, size_t nSlice3) + void fillAnalysis(T const& col) { mHistogramRegistry->fill(HIST(AnalysisDir) + HIST(getHistName(kPosZ, HistTable)), col.posZ()); mHistogramRegistry->fill(HIST(AnalysisDir) + HIST(getHistName(kMult, HistTable)), col.mult()); mHistogramRegistry->fill(HIST(AnalysisDir) + HIST(getHistName(kCent, HistTable)), col.cent()); mHistogramRegistry->fill(HIST(AnalysisDir) + HIST(getHistName(kMagField, HistTable)), col.magField()); - if (mPlotPairCorrelation) { - mHistogramRegistry->fill(HIST(AnalysisDir) + HIST(getHistName(kNpart1VsNpart2, HistTable)), nSlice1, nSlice2); - } - if (mPlotTripletCorrelation) { - mHistogramRegistry->fill(HIST(AnalysisDir) + HIST(getHistName(kNpart1VsNpart2VsNpart3, HistTable)), nSlice1, nSlice2, nSlice3); - } } template @@ -323,8 +298,6 @@ class CollisionHistManager o2::framework::HistogramRegistry* mHistogramRegistry = nullptr; bool mPlot2d = false; - bool mPlotPairCorrelation = false; - bool mPlotTripletCorrelation = false; }; // namespace femtounitedcolhistmanager }; // namespace colhistmanager }; // namespace o2::analysis::femto diff --git a/PWGCF/Femto/Core/modes.h b/PWGCF/Femto/Core/modes.h index 45c0db54f63..c694e1916a6 100644 --- a/PWGCF/Femto/Core/modes.h +++ b/PWGCF/Femto/Core/modes.h @@ -48,9 +48,15 @@ enum class Mode : uint32_t { kAnalysis = BIT(0), kQa = BIT(1), kMc = BIT(2), + kSe = BIT(3), + kMe = BIT(4), kAnalysis_Qa = kAnalysis | kQa, kAnalysis_Mc = kAnalysis | kMc, kAnalysis_Qa_Mc = kAnalysis | kQa | kMc, + kSe_Analysis = kAnalysis | kSe, + kMe_Analysis = kAnalysis | kMe, + kSe_Analysis_Mc = kAnalysis | kSe | kMc, + kMe_Analysis_Mc = kAnalysis | kMe | kMc, }; enum class System : uint32_t { diff --git a/PWGCF/Femto/Core/pairBuilder.h b/PWGCF/Femto/Core/pairBuilder.h index af6e9aa51bb..fb4e2c022f0 100644 --- a/PWGCF/Femto/Core/pairBuilder.h +++ b/PWGCF/Femto/Core/pairBuilder.h @@ -57,7 +57,8 @@ class PairTrackTrackBuilder PairTrackTrackBuilder() = default; ~PairTrackTrackBuilder() = default; - template (registry, colHistSpec, confCollisionBinning); - mPairHistManagerSe.template init(registry, pairHistSpec, confPairBinning, confPairCuts); - mPairHistManagerMe.template init(registry, pairHistSpec, confPairBinning, confPairCuts); - mPc.template init(confPairCuts); + mColHistManager.template init(registry, colHistSpec, confCollisionBinning); + mPairHistManagerSe.template init(registry, pairHistSpec, confPairBinning, confPairCuts, confMixing); + mPairHistManagerMe.template init(registry, pairHistSpec, confPairBinning, confPairCuts, confMixing); + mPc.template init(confPairCuts); if (mSameSpecies) { mTrackCleaner1.init(confTrackCleaner1); - mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); + mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); mPairHistManagerSe.setMass(confTrackSelection1.pdgCodeAbs.value, confTrackSelection1.pdgCodeAbs.value); mPairHistManagerSe.setCharge(confTrackSelection1.chargeAbs.value, confTrackSelection1.chargeAbs.value); @@ -112,8 +113,8 @@ class PairTrackTrackBuilder } else { mTrackCleaner1.init(confTrackCleaner1); mTrackCleaner2.init(confTrackCleaner2); - mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); - mTrackHistManager2.template init(registry, trackHistSpec2, confTrackSelection2); + mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); + mTrackHistManager2.template init(registry, trackHistSpec2, confTrackSelection2); mPairHistManagerSe.setMass(confTrackSelection1.pdgCodeAbs.value, confTrackSelection2.pdgCodeAbs.value); mPairHistManagerSe.setCharge(confTrackSelection1.chargeAbs.value, confTrackSelection2.chargeAbs.value); @@ -151,7 +152,7 @@ class PairTrackTrackBuilder if (trackSlice1.size() < nLimitPartitionIdenticalParticles) { return; } - mColHistManager.template fill(col, trackSlice1.size(), trackSlice1.size(), 0); + mColHistManager.template fill(col); mCprSe.setMagField(col.magField()); pairprocesshelpers::PairOrder pairOrder = pairprocesshelpers::kOrder12; if (mMixIdenticalParticles) { @@ -164,7 +165,7 @@ class PairTrackTrackBuilder if (trackSlice1.size() < nLimitPartitionParticles || trackSlice2.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, trackSlice1.size(), trackSlice2.size(), 0); + mColHistManager.template fill(col); mCprSe.setMagField(col.magField()); pairprocesshelpers::processSameEvent(trackSlice1, trackSlice2, trackTable, col, mTrackHistManager1, mTrackHistManager2, mPairHistManagerSe, mCprSe, mPc); } @@ -179,7 +180,7 @@ class PairTrackTrackBuilder if (trackSlice1.size() < nLimitPartitionIdenticalParticles) { return; } - mColHistManager.template fill(col, mcCols, trackSlice1.size(), trackSlice1.size(), 0); + mColHistManager.template fill(col, mcCols); mCprSe.setMagField(col.magField()); pairprocesshelpers::PairOrder pairOrder = pairprocesshelpers::kOrder12; if (mMixIdenticalParticles) { @@ -192,7 +193,7 @@ class PairTrackTrackBuilder if (trackSlice1.size() < nLimitPartitionParticles || trackSlice2.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, mcCols, trackSlice1.size(), trackSlice2.size(), 0); + mColHistManager.template fill(col, mcCols); mCprSe.setMagField(col.magField()); pairprocesshelpers::processSameEvent(trackSlice1, trackSlice2, trackTable, mcParticles, mcMothers, mcPartonicMothers, col, mcCols, mTrackHistManager1, mTrackHistManager2, mPairHistManagerSe, mTrackCleaner1, mTrackCleaner2, mCprSe, mPc); } @@ -306,7 +307,8 @@ class PairV0V0Builder PairV0V0Builder() = default; ~PairV0V0Builder() = default; - template (registry, colHistSpec, confCollisionBinning); - mPairHistManagerSe.template init(registry, pairHistSpec, confPairBinning, confPairCuts); - mPairHistManagerMe.template init(registry, pairHistSpec, confPairBinning, confPairCuts); + mColHistManager.template init(registry, colHistSpec, confCollisionBinning); + mPairHistManagerSe.template init(registry, pairHistSpec, confPairBinning, confPairCuts, confMixing); + mPairHistManagerMe.template init(registry, pairHistSpec, confPairBinning, confPairCuts, confMixing); + mPc.template init(confPairCuts); if (mSameSpecies) { mV0Cleaner1.init(confV0Cleaner1); - mV0HistManager1.template init(registry, V0HistSpec1, confV0Selection1, PosDauHistSpec, NegDauHistSpec); + mV0HistManager1.template init(registry, V0HistSpec1, confV0Selection1, PosDauHistSpec, NegDauHistSpec); mPairHistManagerSe.setMass(confV0Selection1.pdgCodeAbs.value, confV0Selection1.pdgCodeAbs.value); mPairHistManagerSe.setCharge(1, 1); @@ -367,8 +370,8 @@ class PairV0V0Builder } else { mV0Cleaner1.init(confV0Cleaner1); mV0Cleaner2.init(confV0Cleaner2); - mV0HistManager1.template init(registry, V0HistSpec1, confV0Selection1, PosDauHistSpec, NegDauHistSpec); - mV0HistManager2.template init(registry, V0HistSpec2, confV0Selection2, PosDauHistSpec, NegDauHistSpec); + mV0HistManager1.template init(registry, V0HistSpec1, confV0Selection1, PosDauHistSpec, NegDauHistSpec); + mV0HistManager2.template init(registry, V0HistSpec2, confV0Selection2, PosDauHistSpec, NegDauHistSpec); mPairHistManagerSe.setMass(confV0Selection1.pdgCodeAbs.value, confV0Selection2.pdgCodeAbs.value); mPairHistManagerSe.setCharge(1, 1); @@ -404,7 +407,7 @@ class PairV0V0Builder if (v0Slice1.size() < nLimitPartitionIdenticalParticles) { return; } - mColHistManager.template fill(col, v0Slice1.size(), v0Slice1.size(), 0); + mColHistManager.template fill(col); mCprSe.setMagField(col.magField()); pairprocesshelpers::PairOrder pairOrder = pairprocesshelpers::kOrder12; if (mMixIdenticalParticles) { @@ -417,7 +420,7 @@ class PairV0V0Builder if (v0Slice1.size() < nLimitPartitionParticles || v0Slice2.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, v0Slice1.size(), v0Slice2.size(), 0); + mColHistManager.template fill(col); mCprSe.setMagField(col.magField()); pairprocesshelpers::processSameEvent(v0Slice1, v0Slice2, trackTable, col, mV0HistManager1, mV0HistManager2, mPairHistManagerSe, mCprSe, mPc); } @@ -432,7 +435,7 @@ class PairV0V0Builder if (v0Slice1.size() < nLimitPartitionIdenticalParticles) { return; } - mColHistManager.template fill(col, mcCols, v0Slice1.size(), v0Slice1.size(), 0); + mColHistManager.template fill(col, mcCols); mCprSe.setMagField(col.magField()); pairprocesshelpers::PairOrder pairOrder = pairprocesshelpers::kOrder12; if (mMixIdenticalParticles) { @@ -445,7 +448,7 @@ class PairV0V0Builder if (v0Slice1.size() < nLimitPartitionParticles || v0Slice2.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, mcCols, v0Slice1.size(), v0Slice2.size(), 0); + mColHistManager.template fill(col, mcCols); mCprSe.setMagField(col.magField()); pairprocesshelpers::processSameEvent(v0Slice1, v0Slice2, trackTable, mcParticles, mcMothers, mcPartonicMothers, col, mcCols, mV0HistManager1, mV0HistManager2, mPairHistManagerSe, mV0Cleaner1, mV0Cleaner2, mCprSe, mPc); } @@ -554,7 +557,8 @@ class PairTrackV0Builder PairTrackV0Builder() = default; ~PairTrackV0Builder() = default; - template >& pairHistSpec, std::map>& cprHistSpec) { - mColHistManager.template init(registry, colHistSpec, confCollisionBinning); + mColHistManager.template init(registry, colHistSpec, confCollisionBinning); - mTrackHistManager.template init(registry, trackHistSpec, confTrackSelection); - mV0HistManager.template init(registry, v0HistSpec, confV0Selection, posDauHistSpec, negDauHistSpec); + mTrackHistManager.template init(registry, trackHistSpec, confTrackSelection); + mV0HistManager.template init(registry, v0HistSpec, confV0Selection, posDauHistSpec, negDauHistSpec); mTrackCleaner.init(confTrackCleaner); mV0Cleaner.init(confV0Cleaner); @@ -612,16 +616,16 @@ class PairTrackV0Builder } } - mPairHistManagerSe.template init(registry, pairHistSpec, confPairBinning, confPairCuts); + mPairHistManagerSe.template init(registry, pairHistSpec, confPairBinning, confPairCuts, confMixing); mPairHistManagerSe.setMass(confTrackSelection.pdgCodeAbs.value, 0, 0, confV0Selection.pdgCodeAbs.value, pdgCodePosDau, pdgCodeNegDau); mPairHistManagerSe.setCharge(confTrackSelection.chargeAbs.value, 1); mCprSe.init(registry, cprHistSpec, confCpr, confTrackSelection.chargeAbs.value); - mPairHistManagerMe.template init(registry, pairHistSpec, confPairBinning, confPairCuts); + mPairHistManagerMe.template init(registry, pairHistSpec, confPairBinning, confPairCuts, confMixing); mPairHistManagerMe.setMass(confTrackSelection.pdgCodeAbs.value, 0, 0, confV0Selection.pdgCodeAbs.value, pdgCodePosDau, pdgCodeNegDau); mPairHistManagerMe.setCharge(confTrackSelection.chargeAbs.value, 1); mCprMe.init(registry, cprHistSpec, confCpr, confTrackSelection.chargeAbs.value); - mPc.template init(confPairCuts); + mPc.template init(confPairCuts); // setup mixing mMixingPolicy = static_cast(confMixing.policy.value); @@ -636,7 +640,7 @@ class PairTrackV0Builder if (trackSlice.size() < nLimitPartitionParticles || v0Slice.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, trackSlice.size(), v0Slice.size(), 0); + mColHistManager.template fill(col); mCprSe.setMagField(col.magField()); pairprocesshelpers::processSameEvent(trackSlice, v0Slice, trackTable, col, mTrackHistManager, mV0HistManager, mPairHistManagerSe, mCprSe, mPc); } @@ -649,7 +653,7 @@ class PairTrackV0Builder if (trackSlice.size() < nLimitPartitionParticles || v0Slice.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, mcCols, trackSlice.size(), v0Slice.size(), 0); + mColHistManager.template fill(col, mcCols); mCprSe.setMagField(col.magField()); pairprocesshelpers::processSameEvent(trackSlice, v0Slice, trackTable, mcParticles, mcMothers, mcPartonicMothers, col, mcCols, mTrackHistManager, mV0HistManager, mPairHistManagerSe, mTrackCleaner, mV0Cleaner, mCprSe, mPc); } @@ -720,7 +724,8 @@ class PairTrackTwoTrackResonanceBuilder PairTrackTwoTrackResonanceBuilder() = default; ~PairTrackTwoTrackResonanceBuilder() = default; - template > const& pairHistSpec, std::map> const& cprHistSpec) { - mColHistManager.template init(registry, colHistSpec, confCollisionBinning); + mColHistManager.template init(registry, colHistSpec, confCollisionBinning); - mTrackHistManager.template init(registry, trackHistSpec, confTrackSelection); - mResonanceHistManager.template init(registry, resonanceHistSpec, confResonanceSelection, posDauHistSpec, negDauHistSpec); + mTrackHistManager.template init(registry, trackHistSpec, confTrackSelection); + mResonanceHistManager.template init(registry, resonanceHistSpec, confResonanceSelection, posDauHistSpec, negDauHistSpec); - mPairHistManagerSe.template init(registry, pairHistSpec, confPairBinning, confPairCuts); + mPairHistManagerSe.template init(registry, pairHistSpec, confPairBinning, confPairCuts, confMixing); mPairHistManagerSe.setMass(confTrackSelection.pdgCodeAbs.value, confResonanceSelection.pdgCodeAbs.value); mPairHistManagerSe.setCharge(confTrackSelection.chargeAbs.value, 1); mCprSe.init(registry, cprHistSpec, confCpr, confTrackSelection.chargeAbs.value); - mPairHistManagerMe.template init(registry, pairHistSpec, confPairBinning, confPairCuts); + mPairHistManagerMe.template init(registry, pairHistSpec, confPairBinning, confPairCuts, confMixing); mPairHistManagerMe.setMass(confTrackSelection.pdgCodeAbs.value, confResonanceSelection.pdgCodeAbs.value); mPairHistManagerMe.setCharge(confTrackSelection.chargeAbs.value, 1); mCprMe.init(registry, cprHistSpec, confCpr, confTrackSelection.chargeAbs.value); @@ -779,7 +784,7 @@ class PairTrackTwoTrackResonanceBuilder if (trackSlice.size() < nLimitPartitionParticles || resonanaceSlice.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, trackSlice.size(), resonanaceSlice.size(), 0); + mColHistManager.template fill(col); mCprSe.setMagField(col.magField()); pairprocesshelpers::processSameEvent(trackSlice, resonanaceSlice, trackTable, col, mTrackHistManager, mResonanceHistManager, mPairHistManagerSe, mCprSe, mPc); } @@ -829,7 +834,8 @@ class PairTrackKinkBuilder PairTrackKinkBuilder() = default; ~PairTrackKinkBuilder() = default; - template > const& pairHistSpec, std::map> const& cprHistSpec) { - mColHistManager.template init(registry, colHistSpec, confCollisionBinning); + mColHistManager.template init(registry, colHistSpec, confCollisionBinning); - mTrackHistManager.template init(registry, trackHistSpec, confTrackSelection); - mKinkHistManager.template init(registry, kinkHistSpec, confKinkSelection, chaDauHistSpec); + mTrackHistManager.template init(registry, trackHistSpec, confTrackSelection); + mKinkHistManager.template init(registry, kinkHistSpec, confKinkSelection, chaDauHistSpec); mTrackCleaner.init(confTrackCleaner); mKinkCleaner.init(confKinkCleaner); - mPairHistManagerSe.template init(registry, pairHistSpec, confPairBinning, confPairCuts); + mPairHistManagerSe.template init(registry, pairHistSpec, confPairBinning, confPairCuts, confMixing); mPairHistManagerSe.setMass(confTrackSelection.pdgCodeAbs.value, confKinkSelection.pdgCodeAbs.value); mPairHistManagerSe.setCharge(confTrackSelection.chargeAbs.value, 1); // abs charge of kink daughter is always 1 mCprSe.init(registry, cprHistSpec, confCpr, confTrackSelection.chargeAbs.value); - mPairHistManagerMe.template init(registry, pairHistSpec, confPairBinning, confPairCuts); + mPairHistManagerMe.template init(registry, pairHistSpec, confPairBinning, confPairCuts, confMixing); mPairHistManagerMe.setMass(confTrackSelection.pdgCodeAbs.value, confKinkSelection.pdgCodeAbs.value); mPairHistManagerMe.setCharge(confTrackSelection.chargeAbs.value, 1); // abs charge of kink daughter is always 1 mCprMe.init(registry, cprHistSpec, confCpr, confTrackSelection.chargeAbs.value); - mPc.template init(confPairCuts); + mPc.template init(confPairCuts); // setup mixing mMixingPolicy = static_cast(confMixing.policy.value); @@ -894,7 +900,7 @@ class PairTrackKinkBuilder if (trackSlice.size() < nLimitPartitionParticles || kinkSlice.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, 0, 0, 0); + mColHistManager.template fill(col); mCprSe.setMagField(col.magField()); pairprocesshelpers::processSameEvent(trackSlice, kinkSlice, trackTable, col, mTrackHistManager, mKinkHistManager, mPairHistManagerSe, mCprSe, mPc); } @@ -907,7 +913,7 @@ class PairTrackKinkBuilder if (trackSlice.size() < nLimitPartitionParticles || kinkSlice.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, mcCols, 0, 0, 0); + mColHistManager.template fill(col, mcCols); mCprSe.setMagField(col.magField()); pairprocesshelpers::processSameEvent(trackSlice, kinkSlice, trackTable, mcParticles, mcMothers, mcPartonicMothers, col, mcCols, mTrackHistManager, mKinkHistManager, mPairHistManagerSe, mTrackCleaner, mKinkCleaner, mCprSe, mPc); } @@ -981,7 +987,8 @@ class PairTrackCascadeBuilder PairTrackCascadeBuilder() = default; ~PairTrackCascadeBuilder() = default; - template > const& cprHistSpecBachelor, std::map> const& cprHistSpecV0Daughter) { - mColHistManager.template init(registry, colHistSpec, confCollisionBinning); + mColHistManager.template init(registry, colHistSpec, confCollisionBinning); - mTrackHistManager.template init(registry, trackHistSpec, confTrackSelection); - mCascadeHistManager.template init(registry, cascadeHistSpec, confCascadeSelection, bachelorHistSpec, posDauHistSpec, negDauHistSpec); + mTrackHistManager.template init(registry, trackHistSpec, confTrackSelection); + mCascadeHistManager.template init(registry, cascadeHistSpec, confCascadeSelection, bachelorHistSpec, posDauHistSpec, negDauHistSpec); mTrackCleaner.init(confTrackCleaner); mCascadeCleaner.init(confCascadeCleaner); - mPairHistManagerSe.template init(registry, pairHistSpec, confPairBinning, confPairCuts); + mPairHistManagerSe.template init(registry, pairHistSpec, confPairBinning, confPairCuts, confMixing); mPairHistManagerSe.setMass(confTrackSelection.pdgCodeAbs.value, confCascadeSelection.pdgCodeAbs.value); mPairHistManagerSe.setCharge(confTrackSelection.chargeAbs.value, 1); mCprSe.init(registry, cprHistSpecBachelor, cprHistSpecV0Daughter, confCprBachelor, confCprV0Daughter, confTrackSelection.chargeAbs.value); - mPairHistManagerMe.template init(registry, pairHistSpec, confPairBinning, confPairCuts); + mPairHistManagerMe.template init(registry, pairHistSpec, confPairBinning, confPairCuts, confMixing); mPairHistManagerMe.setMass(confTrackSelection.pdgCodeAbs.value, confCascadeSelection.pdgCodeAbs.value); mPairHistManagerMe.setCharge(confTrackSelection.chargeAbs.value, 1); mCprMe.init(registry, cprHistSpecBachelor, cprHistSpecV0Daughter, confCprBachelor, confCprV0Daughter, confTrackSelection.chargeAbs.value); @@ -1053,7 +1060,7 @@ class PairTrackCascadeBuilder if (trackSlice.size() < nLimitPartitionParticles || cascadeSlice.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, trackSlice.size(), cascadeSlice.size(), 0); + mColHistManager.template fill(col); mCprSe.setMagField(col.magField()); pairprocesshelpers::processSameEvent(trackSlice, cascadeSlice, trackTable, col, mTrackHistManager, mCascadeHistManager, mPairHistManagerSe, mCprSe, mPc); } @@ -1066,7 +1073,7 @@ class PairTrackCascadeBuilder if (trackSlice.size() < nLimitPartitionParticles || cascadeSlice.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, mcCols, trackSlice.size(), cascadeSlice.size(), 0); + mColHistManager.template fill(col, mcCols); mCprSe.setMagField(col.magField()); pairprocesshelpers::processSameEvent(trackSlice, cascadeSlice, trackTable, mcParticles, mcMothers, mcPartonicMothers, col, mcCols, mTrackHistManager, mCascadeHistManager, mPairHistManagerSe, mTrackCleaner, mCascadeCleaner, mCprSe, mPc); } diff --git a/PWGCF/Femto/Core/pairHistManager.h b/PWGCF/Femto/Core/pairHistManager.h index 31efc4779a4..6ac87c8ce35 100644 --- a/PWGCF/Femto/Core/pairHistManager.h +++ b/PWGCF/Femto/Core/pairHistManager.h @@ -46,6 +46,7 @@ enum PairHist { kKstar, kKt, kMt, + kMinv, // standard 2D kPt1VsPt2, kPt1VsKstar, @@ -62,6 +63,10 @@ enum PairHist { kKstarVsMass1, kKstarVsMass2, kMass1VsMass2, + // 2D with invariant mass + kKstarVsMinv, + kPt1VsMinv, + kPt2VsMinv, // higher dimensions kKstarVsMtVsMult, kKstarVsMtVsMultVsCent, @@ -77,15 +82,27 @@ enum PairHist { kKstarVsMtVsMass1VsMass2VsPt1VsPt2, kKstarVsMtVsMass1VsMass2VsPt1VsPt2VsMult, kKstarVsMtVsMass1VsMass2VsPt1VsPt2VsMultVsCent, + // higher dimensions with pt and invariant mass + kKstarVsMtVsMinvVsPt1VsPt2, + kKstarVsMtVsMinvVsPt1VsPt2VsMult, + kKstarVsMtVsMinvVsPt1VsPt2VsMultVsCent, // dalitz plots kDalitz, // between a track and pos/neg daughter of another particle // mc kTrueKstarVsKstar, kTrueKtVsKt, kTrueMtVsMt, + kTrueMinvVsMinv, kTrueMultVsMult, kTrueCentVsCent, + // mixing qa + kSeNpart1VsNpart2, // number of particles 1 vs number of particles 2 in each same event + kMeNpart1, // number of unique particles 1 in each mixing bin + kMeNpart2, // number of unique particles 2 in each mixing bin + kMeAverageNpart1VsAverageNpart2, // average number of particles 1 vs average number of particles 2 in each mixing bin + kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2, // correlation of event properties in each mixing bin + kPairHistogramLast }; @@ -106,6 +123,9 @@ struct ConfMixing : o2::framework::ConfigurableGroup { 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 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."}; + o2::framework::Configurable enableSameEventQa{"enableSameEventQa", false, "Enable qa plots for same event"}; + o2::framework::Configurable enableMixedEventQa{"enableMixedEventQa", false, "Enable qa plots for mixed event"}; + o2::framework::ConfigurableAxis particleBinning{"particleBinning", {50, -0.5f, 49.5f}, "Binning for particle number correlation in pairs"}; }; struct ConfPairBinning : o2::framework::ConfigurableGroup { @@ -134,6 +154,7 @@ struct ConfPairBinning : o2::framework::ConfigurableGroup { 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, otherwise PDG mass)"}; o2::framework::ConfigurableAxis mass2{"mass2", {{100, 0, 2}}, "Mass binning for particle 2 (if particle has mass getter, otherwise PDG mass)"}; + o2::framework::ConfigurableAxis massInv{"massInv", {{100, 0, 2}}, "Invariant Mass binning"}; o2::framework::ConfigurableAxis dalitzMtot{"dalitzMtot", {{100, 0, 10}}, "Total invariant mass squared binning in darlitz plot"}; o2::framework::ConfigurableAxis dalitzM12{"dalitzM12", {{100, 0, 10}}, "Mass12 binning of darlitz plot"}; o2::framework::ConfigurableAxis dalitzM13{"dalitzM13", {{100, 0, 10}}, "Mass13 binning of darlitz plot"}; @@ -148,6 +169,8 @@ struct ConfPairCuts : o2::framework::ConfigurableGroup { 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)"}; + o2::framework::Configurable massInvMin{"massInvMin", -1, "Minimal invariant mass (set to -1 to deactivate)"}; + o2::framework::Configurable massInvMax{"massInvMax", -1, "Maximal invariant mass (set to -1 to deactivate)"}; o2::framework::Configurable mixOnlyCommonAncestor{"mixOnlyCommonAncestor", false, "Require pair to have common anchestor (in the same event)"}; o2::framework::Configurable mixOnlyNonCommonAncestor{"mixOnlyNonCommonAncestor", false, "Require pair to have non-common anchestor (in the same event)"}; }; @@ -160,6 +183,7 @@ constexpr std::array, kPairHistogramLast> {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"}, + {kMinv, o2::framework::kTH1F, "hMinv", "invariant mass; m_{Inv} (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})"}, @@ -176,6 +200,9 @@ constexpr std::array, kPairHistogramLast> {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})"}, + {kKstarVsMinv, o2::framework::kTH2F, "hKstarVsMinv", "k* vs m_{Inv}; k* (GeV/#it{c}); m_{Inv} (GeV/#it{c}^{2})"}, + {kPt1VsMinv, o2::framework::kTH2F, "hPt1VsMinv", "p_{T,1} vs m_{Inv}; p_{T,1} (GeV/#it{c}); m_{Inv} (GeV/#it{c}^{2})"}, + {kPt2VsMinv, o2::framework::kTH2F, "hPt2VsMinv", "p_{T,2} vs m_{Inv}; p_{T,2} (GeV/#it{c}); m_{Inv} (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 (%);"}, @@ -195,60 +222,76 @@ constexpr std::array, kPairHistogramLast> {kTrueKstarVsKstar, o2::framework::kTH2F, "hTrueKstarVsKstar", "k*_{True} vs k*; k*_{True} (GeV/#it{c}); k* (GeV/#it{c})"}, {kTrueKtVsKt, o2::framework::kTH2F, "hTrueKtVsKt", "k_{T,True} vs k_{T}; k_{T,True} (GeV/#it{c}); k_{T} (GeV/#it{c})"}, {kTrueMtVsMt, o2::framework::kTH2F, "hTrueMtVsMt", "m_{T,True} vs m_{T}; m_{T,True} (GeV/#it{c}^{2}); m_{T} (GeV/#it{c}^{2})"}, + {kTrueMinvVsMinv, o2::framework::kTH2F, "hTrueMinvVsMinv", "m_{Inv,True} vs m_{Inv}; m_{Inv,True} (GeV/#it{c}^{2}); m_{Inv} (GeV/#it{c}^{2})"}, {kTrueMultVsMult, o2::framework::kTH2F, "hTrueMultVsMult", "Multiplicity_{True} vs Multiplicity; Multiplicity_{True} ; Multiplicity"}, {kTrueCentVsCent, o2::framework::kTH2F, "hTrueCentVsCent", "Centrality_{True} vs Centrality; Centrality_{True} (%); Centrality (%)"}, + {kSeNpart1VsNpart2, o2::framework::kTH2F, "hSeNpart1VsNpart2", "# particle 1 vs # particle in SE; # partilce 1; #particle 2"}, + {kMeNpart1, o2::framework::kTH1F, "hMeNpart1", "# particle 1 in each mixing bin; # partilce 1; Entries"}, + {kMeNpart2, o2::framework::kTH1F, "hMeNpart2", "# particle 2 in each mixing bin; # particle 2; Entries"}, + {kMeAverageNpart1VsAverageNpart2, o2::framework::kTH2F, "hMeAverageNpart1VsAverageNpart2", "average # particle 1 vs average # particle in ME; Average # partilce 1; Average #particle 2"}, + {kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2, o2::framework::kTHnSparseF, "hVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2", "Mixing bins; V_{z,1} (cm); multiplicity_{1}; centrality_{1} (%); V_{z,2} (cm); multiplicity_{2}; centrality_{2} (%)"}, }}; -#define PAIR_HIST_ANALYSIS_MAP(conf) \ - {kKstar, {conf.kstar}}, \ - {kKt, {conf.kt}}, \ - {kMt, {conf.mt}}, \ - {kPt1VsPt2, {conf.pt1, conf.pt2}}, \ - {kPt1VsKstar, {conf.pt1, conf.kstar}}, \ - {kPt2VsKstar, {conf.pt2, conf.kstar}}, \ - {kPt1VsKt, {conf.pt1, conf.kt}}, \ - {kPt2VsKt, {conf.pt2, conf.kt}}, \ - {kPt1VsMt, {conf.pt1, conf.mt}}, \ - {kPt2VsMt, {conf.pt2, conf.mt}}, \ - {kKstarVsKt, {conf.kstar, conf.kt}}, \ - {kKstarVsMt, {conf.kstar, conf.mt}}, \ - {kKstarVsMult, {conf.kstar, conf.multiplicity}}, \ - {kKstarVsCent, {conf.kstar, conf.centrality}}, \ - {kKstarVsMass1, {conf.kstar, conf.mass1}}, \ - {kKstarVsMass2, {conf.kstar, conf.mass2}}, \ - {kMass1VsMass2, {conf.mass1, conf.mass2}}, \ - {kKstarVsMtVsMult, {conf.kstar, conf.mt, conf.multiplicity}}, \ - {kKstarVsMtVsMultVsCent, {conf.kstar, conf.mt, conf.multiplicity, conf.centrality}}, \ - {kKstarVsMtVsPt1VsPt2, {conf.kstar, conf.mt, conf.pt1, conf.pt2}}, \ - {kKstarVsMtVsPt1VsPt2VsMult, {conf.kstar, conf.mt, conf.pt1, conf.pt2, conf.multiplicity}}, \ - {kKstarVsMtVsPt1VsPt2VsMultVsCent, {conf.kstar, conf.mt, conf.pt1, conf.pt2, conf.multiplicity, conf.centrality}}, \ - {kKstarVsMtVsMass1VsMass2, {conf.kstar, conf.mt, conf.mass1, conf.mass2}}, \ - {kKstarVsMtVsMass1VsMass2VsMult, {conf.kstar, conf.mt, conf.mass1, conf.mass2, conf.multiplicity}}, \ - {kKstarVsMtVsMass1VsMass2VsMultVsCent, {conf.kstar, conf.mt, conf.mass1, conf.mass2, conf.multiplicity, conf.centrality}}, \ - {kKstarVsMtVsMass1VsMass2VsPt1VsPt2, {conf.kstar, conf.mt, conf.mass1, conf.mass2, conf.pt1, conf.pt2}}, \ - {kKstarVsMtVsMass1VsMass2VsPt1VsPt2VsMult, {conf.kstar, conf.mt, conf.mass1, conf.mass2, conf.pt1, conf.pt2, conf.multiplicity}}, \ - {kKstarVsMtVsMass1VsMass2VsPt1VsPt2VsMultVsCent, {conf.kstar, conf.mt, conf.mass1, conf.mass2, conf.pt1, conf.pt2, conf.multiplicity, conf.centrality}}, \ - {kDalitz, {conf.kstar, conf.dalitzMtot, conf.dalitzM12, conf.dalitzM13}}, +#define PAIR_HIST_ANALYSIS_MAP(confAnalysis, confMixing) \ + {kKstar, {confAnalysis.kstar}}, \ + {kKt, {confAnalysis.kt}}, \ + {kMt, {confAnalysis.mt}}, \ + {kMinv, {confAnalysis.massInv}}, \ + {kPt1VsPt2, {confAnalysis.pt1, confAnalysis.pt2}}, \ + {kPt1VsKstar, {confAnalysis.pt1, confAnalysis.kstar}}, \ + {kPt2VsKstar, {confAnalysis.pt2, confAnalysis.kstar}}, \ + {kPt1VsKt, {confAnalysis.pt1, confAnalysis.kt}}, \ + {kPt2VsKt, {confAnalysis.pt2, confAnalysis.kt}}, \ + {kPt1VsMt, {confAnalysis.pt1, confAnalysis.mt}}, \ + {kPt2VsMt, {confAnalysis.pt2, confAnalysis.mt}}, \ + {kKstarVsKt, {confAnalysis.kstar, confAnalysis.kt}}, \ + {kKstarVsMt, {confAnalysis.kstar, confAnalysis.mt}}, \ + {kKstarVsMult, {confAnalysis.kstar, confAnalysis.multiplicity}}, \ + {kKstarVsCent, {confAnalysis.kstar, confAnalysis.centrality}}, \ + {kKstarVsMass1, {confAnalysis.kstar, confAnalysis.mass1}}, \ + {kKstarVsMass2, {confAnalysis.kstar, confAnalysis.mass2}}, \ + {kMass1VsMass2, {confAnalysis.mass1, confAnalysis.mass2}}, \ + {kKstarVsMinv, {confAnalysis.kstar, confAnalysis.massInv}}, \ + {kPt1VsMinv, {confAnalysis.pt1, confAnalysis.massInv}}, \ + {kPt2VsMinv, {confAnalysis.pt2, confAnalysis.massInv}}, \ + {kKstarVsMtVsMult, {confAnalysis.kstar, confAnalysis.mt, confAnalysis.multiplicity}}, \ + {kKstarVsMtVsMultVsCent, {confAnalysis.kstar, confAnalysis.mt, confAnalysis.multiplicity, confAnalysis.centrality}}, \ + {kKstarVsMtVsPt1VsPt2, {confAnalysis.kstar, confAnalysis.mt, confAnalysis.pt1, confAnalysis.pt2}}, \ + {kKstarVsMtVsPt1VsPt2VsMult, {confAnalysis.kstar, confAnalysis.mt, confAnalysis.pt1, confAnalysis.pt2, confAnalysis.multiplicity}}, \ + {kKstarVsMtVsPt1VsPt2VsMultVsCent, {confAnalysis.kstar, confAnalysis.mt, confAnalysis.pt1, confAnalysis.pt2, confAnalysis.multiplicity, confAnalysis.centrality}}, \ + {kKstarVsMtVsMass1VsMass2, {confAnalysis.kstar, confAnalysis.mt, confAnalysis.mass1, confAnalysis.mass2}}, \ + {kKstarVsMtVsMass1VsMass2VsMult, {confAnalysis.kstar, confAnalysis.mt, confAnalysis.mass1, confAnalysis.mass2, confAnalysis.multiplicity}}, \ + {kKstarVsMtVsMass1VsMass2VsMultVsCent, {confAnalysis.kstar, confAnalysis.mt, confAnalysis.mass1, confAnalysis.mass2, confAnalysis.multiplicity, confAnalysis.centrality}}, \ + {kKstarVsMtVsMass1VsMass2VsPt1VsPt2, {confAnalysis.kstar, confAnalysis.mt, confAnalysis.mass1, confAnalysis.mass2, confAnalysis.pt1, confAnalysis.pt2}}, \ + {kKstarVsMtVsMass1VsMass2VsPt1VsPt2VsMult, {confAnalysis.kstar, confAnalysis.mt, confAnalysis.mass1, confAnalysis.mass2, confAnalysis.pt1, confAnalysis.pt2, confAnalysis.multiplicity}}, \ + {kKstarVsMtVsMass1VsMass2VsPt1VsPt2VsMultVsCent, {confAnalysis.kstar, confAnalysis.mt, confAnalysis.mass1, confAnalysis.mass2, confAnalysis.pt1, confAnalysis.pt2, confAnalysis.multiplicity, confAnalysis.centrality}}, \ + {kDalitz, {confAnalysis.kstar, confAnalysis.dalitzMtot, confAnalysis.dalitzM12, confAnalysis.dalitzM13}}, \ + {kSeNpart1VsNpart2, {confMixing.particleBinning, confMixing.particleBinning}}, \ + {kMeNpart1, {confMixing.particleBinning}}, \ + {kMeNpart2, {confMixing.particleBinning}}, \ + {kMeAverageNpart1VsAverageNpart2, {confMixing.particleBinning, confMixing.particleBinning}}, \ + {kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2, {confMixing.vtxBins, confMixing.multBins, confMixing.centBins, confMixing.vtxBins, confMixing.multBins, confMixing.centBins}}, #define PAIR_HIST_MC_MAP(conf) \ {kTrueKstarVsKstar, {conf.kstar, conf.kstar}}, \ {kTrueKtVsKt, {conf.kt, conf.kt}}, \ {kTrueMtVsMt, {conf.mt, conf.mt}}, \ + {kTrueMinvVsMinv, {conf.massInv, conf.massInv}}, \ {kTrueMultVsMult, {conf.multiplicity, conf.multiplicity}}, \ {kTrueCentVsCent, {conf.centrality, conf.centrality}}, -template -auto makePairHistSpecMap(const T& confPairBinning) +template +auto makePairHistSpecMap(T1 const& confPairBinning, T2 const& confMixing) { return std::map>{ - PAIR_HIST_ANALYSIS_MAP(confPairBinning)}; + PAIR_HIST_ANALYSIS_MAP(confPairBinning, confMixing)}; }; -template -auto makePairMcHistSpecMap(const T& confPairBinning) +template +auto makePairMcHistSpecMap(T1 const& confPairBinning, T2 const& confMixing) { return std::map>{ - PAIR_HIST_ANALYSIS_MAP(confPairBinning) + PAIR_HIST_ANALYSIS_MAP(confPairBinning, confMixing) PAIR_HIST_MC_MAP(confPairBinning)}; }; @@ -274,7 +317,7 @@ constexpr char PrefixTrackKinkSe[] = "TrackKink/SE/"; constexpr char PrefixTrackKinkMe[] = "TrackKink/ME/"; constexpr std::string_view AnalysisDir = "Analysis/"; -constexpr std::string_view QaDir = "QA/"; +constexpr std::string_view MixingQaDir = "MixingQA/"; constexpr std::string_view McDir = "MC/"; template + template void init(o2::framework::HistogramRegistry* registry, std::map> const& Specs, T1 const& ConfPairBinning, - T2 const& ConfPairCuts) + T2 const& ConfPairCuts, + T3 const& ConfMixing) { mHistogramRegistry = registry; @@ -326,6 +370,18 @@ class PairHistManager mKtMax = ConfPairCuts.ktMax.value; mMtMin = ConfPairCuts.mtMin.value; mMtMax = ConfPairCuts.mtMax.value; + mMassInvMin = ConfPairCuts.massInvMin.value; + mMassInvMax = ConfPairCuts.massInvMax.value; + + if constexpr (isFlagSet(mode, modes::Mode::kSe)) { + mSeMixingQa = ConfMixing.enableSameEventQa.value; + initSeMixingQa(Specs); + } + + if constexpr (isFlagSet(mode, modes::Mode::kMe)) { + mMeMixingQa = ConfMixing.enableMixedEventQa.value; + initMeMixingQa(Specs); + } if constexpr (isFlagSet(mode, modes::Mode::kAnalysis)) { initAnalysis(Specs); @@ -396,6 +452,9 @@ class PairHistManager // set mT mMt = getMt(mParticle1, mParticle2); + // set Minv + mMassInv = getMinv(mParticle1, mParticle2); + // set kstar mKstar = getKstar(mParticle1, mParticle2); @@ -443,12 +502,10 @@ class PairHistManager mTrueParticle1 = ROOT::Math::PtEtaPhiMVector(mAbsCharge1 * mcParticle1.pt(), mcParticle1.eta(), mcParticle1.phi(), mPdgMass1); mTrueParticle2 = ROOT::Math::PtEtaPhiMVector(mAbsCharge2 * mcParticle2.pt(), mcParticle2.eta(), mcParticle2.phi(), mPdgMass2); - // set kT + // compute true kinematics mTrueKt = getKt(mTrueParticle1, mTrueParticle2); - - // set mT mTrueMt = getMt(mTrueParticle1, mTrueParticle2); - + mTrueMt = getMinv(mTrueParticle1, mTrueParticle2); mTrueKstar = getKstar(mTrueParticle1, mTrueParticle2); } @@ -490,7 +547,11 @@ class PairHistManager (!(mKtMin > 0.f) || mKt > mKtMin) && (!(mKtMax > 0.f) || mKt < mKtMax) && (!(mMtMin > 0.f) || mMt > mMtMin) && - (!(mMtMax > 0.f) || mMt < mMtMax); + (!(mMtMax > 0.f) || mMt < mMtMax) && + (!(mMassInvMin > 0.f) || mMassInv > mMassInvMin) && + (!(mMassInvMax > 0.f) || mMassInv < mMassInvMax) + + ; } template @@ -504,6 +565,17 @@ class PairHistManager } } + template + void fillMixingQa(T1 const& particles1, T2 const& particles2) + { + if constexpr (isFlagSet(mode, modes::Mode::kSe)) { + fillMixingQaSe(particles1, particles2); + } + if constexpr (isFlagSet(mode, modes::Mode::kMe)) { + // fillMc(); + } + } + float getKstar() const { return mKstar; } private: @@ -514,6 +586,7 @@ class PairHistManager mHistogramRegistry->add(analysisDir + getHistNameV2(kKstar, HistTable), getHistDesc(kKstar, HistTable), getHistType(kKstar, HistTable), {Specs.at(kKstar)}); mHistogramRegistry->add(analysisDir + getHistNameV2(kKt, HistTable), getHistDesc(kKt, HistTable), getHistType(kKt, HistTable), {Specs.at(kKt)}); mHistogramRegistry->add(analysisDir + getHistNameV2(kMt, HistTable), getHistDesc(kMt, HistTable), getHistType(kMt, HistTable), {Specs.at(kMt)}); + mHistogramRegistry->add(analysisDir + getHistNameV2(kMinv, HistTable), getHistDesc(kMinv, HistTable), getHistType(kMinv, HistTable), {Specs.at(kMinv)}); } if (mPlot2d) { mHistogramRegistry->add(analysisDir + getHistNameV2(kPt1VsPt2, HistTable), getHistDesc(kPt1VsPt2, HistTable), getHistType(kPt1VsPt2, HistTable), {Specs.at(kPt1VsPt2)}); @@ -531,6 +604,10 @@ class PairHistManager mHistogramRegistry->add(analysisDir + getHistNameV2(kKstarVsMass1, HistTable), getHistDesc(kKstarVsMass1, HistTable), getHistType(kKstarVsMass1, HistTable), {Specs.at(kKstarVsMass1)}); mHistogramRegistry->add(analysisDir + getHistNameV2(kKstarVsMass2, HistTable), getHistDesc(kKstarVsMass2, HistTable), getHistType(kKstarVsMass2, HistTable), {Specs.at(kKstarVsMass2)}); mHistogramRegistry->add(analysisDir + getHistNameV2(kMass1VsMass2, HistTable), getHistDesc(kMass1VsMass2, HistTable), getHistType(kMass1VsMass2, HistTable), {Specs.at(kMass1VsMass2)}); + + mHistogramRegistry->add(analysisDir + getHistNameV2(kKstarVsMinv, HistTable), getHistDesc(kKstarVsMinv, HistTable), getHistType(kKstarVsMinv, HistTable), {Specs.at(kKstarVsMinv)}); + mHistogramRegistry->add(analysisDir + getHistNameV2(kPt1VsMinv, HistTable), getHistDesc(kPt1VsMinv, HistTable), getHistType(kPt1VsMinv, HistTable), {Specs.at(kPt1VsMinv)}); + mHistogramRegistry->add(analysisDir + getHistNameV2(kPt2VsMinv, HistTable), getHistDesc(kPt2VsMinv, HistTable), getHistType(kPt2VsMinv, HistTable), {Specs.at(kPt2VsMinv)}); } // higher dimensional histograms @@ -580,16 +657,37 @@ class PairHistManager mHistogramRegistry->add(mcDir + getHistNameV2(kTrueKstarVsKstar, HistTable), getHistDesc(kTrueKstarVsKstar, HistTable), getHistType(kTrueKstarVsKstar, HistTable), {Specs.at(kTrueKstarVsKstar)}); mHistogramRegistry->add(mcDir + getHistNameV2(kTrueKtVsKt, HistTable), getHistDesc(kTrueKtVsKt, HistTable), getHistType(kTrueKtVsKt, HistTable), {Specs.at(kTrueKtVsKt)}); mHistogramRegistry->add(mcDir + getHistNameV2(kTrueMtVsMt, HistTable), getHistDesc(kTrueMtVsMt, HistTable), getHistType(kTrueMtVsMt, HistTable), {Specs.at(kTrueMtVsMt)}); + mHistogramRegistry->add(mcDir + getHistNameV2(kTrueMinvVsMinv, HistTable), getHistDesc(kTrueMinvVsMinv, HistTable), getHistType(kTrueMinvVsMinv, HistTable), {Specs.at(kTrueMinvVsMinv)}); mHistogramRegistry->add(mcDir + getHistNameV2(kTrueMultVsMult, HistTable), getHistDesc(kTrueMultVsMult, HistTable), getHistType(kTrueMultVsMult, HistTable), {Specs.at(kTrueMultVsMult)}); mHistogramRegistry->add(mcDir + getHistNameV2(kTrueCentVsCent, HistTable), getHistDesc(kTrueCentVsCent, HistTable), getHistType(kTrueCentVsCent, HistTable), {Specs.at(kTrueCentVsCent)}); } + void initSeMixingQa(std::map> const& Specs) + { + std::string mcDir = std::string(prefix) + std::string(MixingQaDir); + if (mSeMixingQa) { + mHistogramRegistry->add(mcDir + getHistNameV2(kSeNpart1VsNpart2, HistTable), getHistDesc(kSeNpart1VsNpart2, HistTable), getHistType(kSeNpart1VsNpart2, HistTable), {Specs.at(kSeNpart1VsNpart2)}); + } + } + + void initMeMixingQa(std::map> const& Specs) + { + std::string mcDir = std::string(prefix) + std::string(MixingQaDir); + if (mMeMixingQa) { + mHistogramRegistry->add(mcDir + getHistNameV2(kMeNpart1, HistTable), getHistDesc(kMeNpart1, HistTable), getHistType(kMeNpart1, HistTable), {Specs.at(kMeNpart1)}); + mHistogramRegistry->add(mcDir + getHistNameV2(kMeNpart2, HistTable), getHistDesc(kMeNpart2, HistTable), getHistType(kMeNpart2, HistTable), {Specs.at(kMeNpart2)}); + mHistogramRegistry->add(mcDir + getHistNameV2(kMeAverageNpart1VsAverageNpart2, HistTable), getHistDesc(kMeAverageNpart1VsAverageNpart2, HistTable), getHistType(kMeAverageNpart1VsAverageNpart2, HistTable), {Specs.at(kMeAverageNpart1VsAverageNpart2)}); + mHistogramRegistry->add(mcDir + getHistNameV2(kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2, HistTable), getHistDesc(kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2, HistTable), getHistType(kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2, HistTable), {Specs.at(kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2)}); + } + } + void fillAnalysis() { if (mPlot1d) { mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstar, HistTable)), mKstar); mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kMt, HistTable)), mMt); mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKt, HistTable)), mKt); + mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kMinv, HistTable)), mMassInv); } if (mPlot2d) { mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kPt1VsPt2, HistTable)), mParticle1.Pt(), mParticle2.Pt()); @@ -607,6 +705,10 @@ class PairHistManager mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMass1, HistTable)), mKstar, mRecoMass1); mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMass2, HistTable)), mKstar, mRecoMass2); mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kMass1VsMass2, HistTable)), mRecoMass1, mRecoMass2); + + mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kKstarVsMinv, HistTable)), mKstar, mMassInv); + mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kPt1VsMinv, HistTable)), mParticle1.Pt(), mMassInv); + mHistogramRegistry->fill(HIST(prefix) + HIST(AnalysisDir) + HIST(getHistName(kPt2VsMinv, HistTable)), mParticle2.Pt(), mMassInv); } // n-D histograms are only filled if enabled @@ -656,6 +758,7 @@ class PairHistManager mHistogramRegistry->fill(HIST(prefix) + HIST(McDir) + HIST(getHistName(kTrueKstarVsKstar, HistTable)), mTrueKstar, mKstar); mHistogramRegistry->fill(HIST(prefix) + HIST(McDir) + HIST(getHistName(kTrueKtVsKt, HistTable)), mTrueKt, mKt); mHistogramRegistry->fill(HIST(prefix) + HIST(McDir) + HIST(getHistName(kTrueMtVsMt, HistTable)), mTrueMt, mMt); + mHistogramRegistry->fill(HIST(prefix) + HIST(McDir) + HIST(getHistName(kTrueMinvVsMinv, HistTable)), mTrueMinv, mMassInv); } if (mHasMcCol) { mHistogramRegistry->fill(HIST(prefix) + HIST(McDir) + HIST(getHistName(kTrueMultVsMult, HistTable)), mTrueMult, mMult); @@ -663,6 +766,14 @@ class PairHistManager } } + template + void fillMixingQaSe(T1 const& particles1, T2 const& particles2) + { + if (mSeMixingQa) { + mHistogramRegistry->fill(HIST(prefix) + HIST(MixingQaDir) + HIST(getHistName(kSeNpart1VsNpart2, HistTable)), particles1.size(), particles2.size()); + } + } + float getKt(ROOT::Math::PtEtaPhiMVector const& part1, ROOT::Math::PtEtaPhiMVector const& part2) { auto sum = (part1 + part2); @@ -694,6 +805,11 @@ class PairHistManager return static_cast(mt); } + float getMinv(ROOT::Math::PtEtaPhiMVector const& part1, ROOT::Math::PtEtaPhiMVector const& part2) + { + return static_cast((part1 + part2).M()); + } + float getKstar(ROOT::Math::PtEtaPhiMVector const& part1, ROOT::Math::PtEtaPhiMVector const& part2) { // compute pair momentum @@ -727,6 +843,7 @@ class PairHistManager float mKstar = 0.f; float mKt = 0.f; float mMt = 0.f; + float mMassInv = 0.f; float mMult = 0.f; float mCent = 0.f; double mMass12 = 0.; @@ -739,6 +856,7 @@ class PairHistManager float mTrueKstar = 0.f; float mTrueKt = 0.f; float mTrueMt = 0.f; + float mTrueMinv = 0.f; float mTrueMult = 0.f; float mTrueCent = 0.f; @@ -751,6 +869,8 @@ class PairHistManager float mKtMax = -1.f; float mMtMin = -1.f; float mMtMax = -1.f; + float mMassInvMin = -1; + float mMassInvMax = -1; // flags bool mPlot1d = true; @@ -772,6 +892,10 @@ class PairHistManager bool mPlotKstarVsMtVsMass1VsMass2VsPt1VsPt2VsMultVsCent = false; bool mPlotDalitz = false; + + // qa + bool mSeMixingQa = false; + bool mMeMixingQa = false; }; }; // namespace pairhistmanager diff --git a/PWGCF/Femto/Core/tripletBuilder.h b/PWGCF/Femto/Core/tripletBuilder.h index 1857f6a3996..909934a1b69 100644 --- a/PWGCF/Femto/Core/tripletBuilder.h +++ b/PWGCF/Femto/Core/tripletBuilder.h @@ -179,7 +179,7 @@ class TripletTrackTrackTrackBuilder if (trackSlice1.size() < nLimitPartitionIdenticalParticles123) { return; } - mColHistManager.template fill(col, trackSlice1.size(), trackSlice1.size(), trackSlice1.size()); + mColHistManager.template fill(col); mCtrSe.setMagField(col.magField()); if (mMixIdenticalParticles) { tripletOrder = static_cast(mDist(mRng)); @@ -191,7 +191,7 @@ class TripletTrackTrackTrackBuilder if (trackSlice1.size() < nLimitPartitionIdenticalParticles12 || trackSlice3.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, trackSlice1.size(), trackSlice1.size(), trackSlice3.size()); + mColHistManager.template fill(col); mCtrSe.setMagField(col.magField()); if (mMixIdenticalParticles) { tripletOrder = static_cast(mDist(mRng)); @@ -204,7 +204,7 @@ class TripletTrackTrackTrackBuilder if (trackSlice1.size() < nLimitPartitionParticles || trackSlice2.size() < nLimitPartitionParticles || trackSlice3.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, trackSlice1.size(), trackSlice2.size(), trackSlice3.size()); + mColHistManager.template fill(col); mCtrSe.setMagField(col.magField()); tripletprocesshelpers::processSameEvent(trackSlice1, trackSlice2, trackSlice3, trackTable, col, mTrackHistManager1, mTrackHistManager2, mTrackHistManager3, mTripletHistManagerSe, mCtrSe, mTc); } @@ -220,7 +220,7 @@ class TripletTrackTrackTrackBuilder if (trackSlice1.size() < nLimitPartitionIdenticalParticles123) { return; } - mColHistManager.template fill(col, mcCols, trackSlice1.size(), trackSlice1.size(), trackSlice1.size()); + mColHistManager.template fill(col, mcCols); mCtrSe.setMagField(col.magField()); if (mMixIdenticalParticles) { tripletOrder = static_cast(mDist(mRng)); @@ -232,7 +232,7 @@ class TripletTrackTrackTrackBuilder if (trackSlice1.size() < nLimitPartitionIdenticalParticles12 || trackSlice3.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, mcCols, trackSlice1.size(), trackSlice1.size(), trackSlice3.size()); + mColHistManager.template fill(col, mcCols); mCtrSe.setMagField(col.magField()); if (mMixIdenticalParticles) { tripletOrder = static_cast(mDist(mRng)); @@ -245,7 +245,7 @@ class TripletTrackTrackTrackBuilder if (trackSlice1.size() < nLimitPartitionParticles || trackSlice2.size() < nLimitPartitionParticles || trackSlice3.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, mcCols, trackSlice1.size(), trackSlice2.size(), trackSlice3.size()); + mColHistManager.template fill(col, mcCols); mCtrSe.setMagField(col.magField()); tripletprocesshelpers::processSameEvent(trackSlice1, trackSlice2, trackSlice3, trackTable, mcParticles, mcMothers, mcPartonicMothers, col, mcCols, mTrackHistManager1, mTrackHistManager2, mTrackHistManager3, mTripletHistManagerSe, mCtrSe, mTc); } @@ -487,7 +487,7 @@ class TripletTrackTrackV0Builder if (trackSlice1.size() < nLimitPartitionIdenticalParticles12 || v0Slice.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, trackSlice1.size(), trackSlice1.size(), v0Slice.size()); + mColHistManager.template fill(col); mCtrSe.setMagField(col.magField()); if (mMixIdenticalParticles) { tripletOrder = static_cast(mDist(mRng)); @@ -500,7 +500,7 @@ class TripletTrackTrackV0Builder if (trackSlice1.size() < nLimitPartitionParticles || trackSlice2.size() < nLimitPartitionParticles || v0Slice.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, trackSlice1.size(), trackSlice2.size(), v0Slice.size()); + mColHistManager.template fill(col); mCtrSe.setMagField(col.magField()); tripletprocesshelpers::processSameEvent(trackSlice1, trackSlice2, v0Slice, trackTable, col, mTrackHistManager1, mTrackHistManager2, mV0HistManager, mTripletHistManagerSe, mCtrSe, mTc); } @@ -517,7 +517,7 @@ class TripletTrackTrackV0Builder if (trackSlice1.size() < nLimitPartitionIdenticalParticles12 || v0Slice.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, mcCols, trackSlice1.size(), trackSlice1.size(), v0Slice.size()); + mColHistManager.template fill(col, mcCols); mCtrSe.setMagField(col.magField()); if (mMixIdenticalParticles) { tripletOrder = static_cast(mDist(mRng)); @@ -530,7 +530,7 @@ class TripletTrackTrackV0Builder if (trackSlice1.size() < nLimitPartitionParticles || trackSlice2.size() < nLimitPartitionParticles || v0Slice.size() < nLimitPartitionParticles) { return; } - mColHistManager.template fill(col, mcCols, trackSlice1.size(), trackSlice2.size(), v0Slice.size()); + mColHistManager.template fill(col, mcCols); mCtrSe.setMagField(col.magField()); tripletprocesshelpers::processSameEvent(trackSlice1, trackSlice2, v0Slice, trackTable, mcParticles, mcMothers, mcPartonicMothers, col, mcCols, mTrackHistManager1, mTrackHistManager2, mV0HistManager, mTripletHistManagerSe, mCtrSe, mTc); } diff --git a/PWGCF/Femto/Core/tripletHistManager.h b/PWGCF/Femto/Core/tripletHistManager.h index 672e9f68055..181fc66ae44 100644 --- a/PWGCF/Femto/Core/tripletHistManager.h +++ b/PWGCF/Femto/Core/tripletHistManager.h @@ -349,7 +349,7 @@ class TripletHistManager { setTriplet(particle1, particle2, particle3, col1, col2, col3); setTripletMc(particle1, particle2, particle3, mcParticles); - if (!col1.has_fMcCol() || !col2.has_fMcCol() || !col2.has_fMcCol()) { + if (!col1.has_fMcCol() || !col2.has_fMcCol() || !col3.has_fMcCol()) { mHasMcCol = false; return; } diff --git a/PWGCF/Femto/Tasks/femtoCascadeQa.cxx b/PWGCF/Femto/Tasks/femtoCascadeQa.cxx index ea60ae07ab2..11bed7ee106 100644 --- a/PWGCF/Femto/Tasks/femtoCascadeQa.cxx +++ b/PWGCF/Femto/Tasks/femtoCascadeQa.cxx @@ -171,7 +171,7 @@ struct FemtoCascadeQa { void processXi(FilteredFemtoCollision const& col, FemtoXis const& /*xis*/, FemtoTracks const& tracks) { - colHistManager.fill(col, 0, 0, 0); + colHistManager.fill(col); auto xiSlice = xiPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache); for (auto const& xi : xiSlice) { xiHistManager.fill(xi, tracks); @@ -181,7 +181,7 @@ struct FemtoCascadeQa { void processXiMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoXisWithLabel const& /*xis*/, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - colHistManager.fill(col, mcCols, 0, 0, 0); + colHistManager.fill(col, mcCols); auto xiSlice = xiWithLabelPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache); for (auto const& xi : xiSlice) { if (!xiCleaner.isClean(xi, mcParticles, mcMothers, mcPartonicMothers)) { @@ -194,7 +194,7 @@ struct FemtoCascadeQa { void processOmega(FilteredFemtoCollision const& col, FemtoOmegas const& /*omegas*/, FemtoTracks const& tracks) { - colHistManager.fill(col, 0, 0, 0); + colHistManager.fill(col); auto omegaSlice = omegaPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache); for (auto const& omega : omegaSlice) { omegaHistManager.fill(omega, tracks); @@ -204,7 +204,7 @@ struct FemtoCascadeQa { void processOmegaMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoOmegasWithLabel const& /*omegas*/, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - colHistManager.fill(col, mcCols, 0, 0, 0); + colHistManager.fill(col, mcCols); auto omegaSlice = omegaWithLabelPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache); for (auto const& omega : omegaSlice) { if (!omegaCleaner.isClean(omega, mcParticles, mcMothers, mcPartonicMothers)) { diff --git a/PWGCF/Femto/Tasks/femtoKinkQa.cxx b/PWGCF/Femto/Tasks/femtoKinkQa.cxx index 82ba5c380c8..89a53dbf72e 100644 --- a/PWGCF/Femto/Tasks/femtoKinkQa.cxx +++ b/PWGCF/Femto/Tasks/femtoKinkQa.cxx @@ -163,7 +163,7 @@ struct FemtoKinkQa { void processSigma(FilteredFemtoCollision const& col, FemtoSigmas const& /*sigmas*/, FemtoTracks const& tracks) { - colHistManager.fill(col, 0, 0, 0); + colHistManager.fill(col); auto sigmaSlice = sigmaPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache); for (auto const& sigma : sigmaSlice) { sigmaHistManager.fill(sigma, tracks); @@ -173,7 +173,7 @@ struct FemtoKinkQa { void processSigmaMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoSigmasWithLabel const& /*sigmas*/, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - colHistManager.fill(col, mcCols, 0, 0, 0); + colHistManager.fill(col, mcCols); auto sigmaSlice = sigmaWithLabelPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache); for (auto const& sigma : sigmaSlice) { if (!sigmaCleaner.isClean(sigma, mcParticles, mcMothers, mcPartonicMothers)) { @@ -186,7 +186,7 @@ struct FemtoKinkQa { void processSigmaPlus(FilteredFemtoCollision const& col, FemtoSigmaPlus const& /*sigmaplus*/, FemtoTracks const& tracks) { - colHistManager.fill(col, 0, 0, 0); + colHistManager.fill(col); auto sigmaplusSlice = sigmaPlusPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache); @@ -198,7 +198,7 @@ struct FemtoKinkQa { void processSigmaPlusMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoSigmaPlusWithLabel const& /*sigmaPlus*/, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - colHistManager.fill(col, mcCols, 0, 0, 0); + colHistManager.fill(col, mcCols); auto sigmaPlusSlice = sigmaPlusWithLabelPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache); for (auto const& sigmaPlus : sigmaPlusSlice) { if (!sigmaPlusCleaner.isClean(sigmaPlus, mcParticles, mcMothers, mcPartonicMothers)) { diff --git a/PWGCF/Femto/Tasks/femtoPairTrackCascade.cxx b/PWGCF/Femto/Tasks/femtoPairTrackCascade.cxx index 9430fa71eef..59cbf706fb1 100644 --- a/PWGCF/Femto/Tasks/femtoPairTrackCascade.cxx +++ b/PWGCF/Femto/Tasks/femtoPairTrackCascade.cxx @@ -197,15 +197,14 @@ struct FemtoPairTrackCascade { bachelorHistSpec = trackhistmanager::makeTrackHistSpecMap(confBachelorBinning); posDauSpec = trackhistmanager::makeTrackHistSpecMap(confPosDauBinning); negDauSpec = trackhistmanager::makeTrackHistSpecMap(confNegDauBinning); - pairTrackCascadeHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); + pairTrackCascadeHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confMixing); if (processXi) { xiHistSpec = cascadehistmanager::makeCascadeHistSpecMap(confXiBinning); - pairTrackCascadeHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); - pairTrackXiBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, confXiSelection, confXiCleaner, confCprBachelor, confCprV0Daughter, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, xiHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, pairTrackCascadeHistSpec, cprHistSpecBachelor, cprHistSpecV0Daughter); + pairTrackXiBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, confXiSelection, confXiCleaner, confCprBachelor, confCprV0Daughter, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, xiHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, pairTrackCascadeHistSpec, cprHistSpecBachelor, cprHistSpecV0Daughter); } else { omegaHistSpec = cascadehistmanager::makeCascadeHistSpecMap(confOmegaBinning); - pairTrackCascadeHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); - pairTrackOmegaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, confOmegaSelection, confOmegaCleaner, confCprBachelor, confCprV0Daughter, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, omegaHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, pairTrackCascadeHistSpec, cprHistSpecBachelor, cprHistSpecV0Daughter); + pairTrackCascadeHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confMixing); + pairTrackOmegaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, confOmegaSelection, confOmegaCleaner, confCprBachelor, confCprV0Daughter, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, omegaHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, pairTrackCascadeHistSpec, cprHistSpecBachelor, cprHistSpecV0Daughter); } } else { colHistSpec = colhistmanager::makeColMcHistSpecMap(confCollisionBinning); @@ -213,64 +212,62 @@ struct FemtoPairTrackCascade { bachelorHistSpec = trackhistmanager::makeTrackMcHistSpecMap(confBachelorBinning); posDauSpec = trackhistmanager::makeTrackMcHistSpecMap(confPosDauBinning); negDauSpec = trackhistmanager::makeTrackMcHistSpecMap(confNegDauBinning); - pairTrackCascadeHistSpec = pairhistmanager::makePairMcHistSpecMap(confPairBinning); + pairTrackCascadeHistSpec = pairhistmanager::makePairMcHistSpecMap(confPairBinning, confMixing); if (processXi) { xiHistSpec = cascadehistmanager::makeCascadeMcHistSpecMap(confXiBinning); - pairTrackCascadeHistSpec = pairhistmanager::makePairMcHistSpecMap(confPairBinning); - pairTrackXiBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, confXiSelection, confXiCleaner, confCprBachelor, confCprV0Daughter, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, xiHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, pairTrackCascadeHistSpec, cprHistSpecBachelor, cprHistSpecV0Daughter); + pairTrackXiBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, confXiSelection, confXiCleaner, confCprBachelor, confCprV0Daughter, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, xiHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, pairTrackCascadeHistSpec, cprHistSpecBachelor, cprHistSpecV0Daughter); } else { omegaHistSpec = cascadehistmanager::makeCascadeMcHistSpecMap(confOmegaBinning); - pairTrackCascadeHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); - pairTrackOmegaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, confOmegaSelection, confOmegaCleaner, confCprBachelor, confCprV0Daughter, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, omegaHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, pairTrackCascadeHistSpec, cprHistSpecBachelor, cprHistSpecV0Daughter); + pairTrackOmegaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, confOmegaSelection, confOmegaCleaner, confCprBachelor, confCprV0Daughter, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, omegaHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, pairTrackCascadeHistSpec, cprHistSpecBachelor, cprHistSpecV0Daughter); } } }; void processXiSameEvent(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoXis const& xis) { - pairTrackXiBuilder.processSameEvent(col, tracks, trackPartition, xis, xiPartition, cache); + pairTrackXiBuilder.processSameEvent(col, tracks, trackPartition, xis, xiPartition, cache); } PROCESS_SWITCH(FemtoPairTrackCascade, processXiSameEvent, "Enable processing same event processing for tracks and xis", true); void processXiSameEventMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoXisWithLabel const& xis, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairTrackXiBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition, xis, xiWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); + pairTrackXiBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition, xis, xiWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); } PROCESS_SWITCH(FemtoPairTrackCascade, processXiSameEventMc, "Enable processing same event processing for tracks and xis with mc information", false); void processXiMixedEvent(FilteredFemtoCollisions const& cols, FemtoTracks const& tracks, FemtoXis const& /*xis*/) { - pairTrackXiBuilder.processMixedEvent(cols, tracks, trackPartition, xiPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackXiBuilder.processMixedEvent(cols, tracks, trackPartition, xiPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackCascade, processXiMixedEvent, "Enable processing mixed event processing for tracks and xis", true); void processXiMixedEventMc(FilteredFemtoCollisionsWithLabel const& cols, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoXisWithLabel const& /*xis*/, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairTrackXiBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition, xiWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackXiBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition, xiWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackCascade, processXiMixedEventMc, "Enable processing mixed event processing for tracks and xis with mc information", false); void processOmegaSameEvent(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoOmegas const& omegas) { - pairTrackOmegaBuilder.processSameEvent(col, tracks, trackPartition, omegas, omegaPartition, cache); + pairTrackOmegaBuilder.processSameEvent(col, tracks, trackPartition, omegas, omegaPartition, cache); } PROCESS_SWITCH(FemtoPairTrackCascade, processOmegaSameEvent, "Enable processing same event processing for tracks and omegas", false); void processOmegaSameEventMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoOmegasWithLabel const& omegas, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairTrackOmegaBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition, omegas, omegaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); + pairTrackOmegaBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition, omegas, omegaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); } PROCESS_SWITCH(FemtoPairTrackCascade, processOmegaSameEventMc, "Enable processing same event processing for tracks and omegas with mc information", false); void processOmegaMixedEvent(FilteredFemtoCollisions const& cols, FemtoTracks const& tracks, FemtoOmegas const& /*omegas*/) { - pairTrackOmegaBuilder.processMixedEvent(cols, tracks, trackPartition, omegaPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackOmegaBuilder.processMixedEvent(cols, tracks, trackPartition, omegaPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackCascade, processOmegaMixedEvent, "Enable processing mixed event processing for tracks and omegas", false); void processOmegaMixedEventMc(FilteredFemtoCollisionsWithLabel const& cols, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoXisWithLabel const& /*xis*/, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairTrackOmegaBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition, omegaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackOmegaBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition, omegaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackCascade, processOmegaMixedEventMc, "Enable processing mixed event processing for tracks and omegas with mc information", false); }; diff --git a/PWGCF/Femto/Tasks/femtoPairTrackKink.cxx b/PWGCF/Femto/Tasks/femtoPairTrackKink.cxx index 2132de4073e..2b0730109f3 100644 --- a/PWGCF/Femto/Tasks/femtoPairTrackKink.cxx +++ b/PWGCF/Femto/Tasks/femtoPairTrackKink.cxx @@ -181,25 +181,25 @@ struct FemtoPairTrackKink { colHistSpec = colhistmanager::makeColHistSpecMap(confCollisionBinning); trackHistSpec = trackhistmanager::makeTrackHistSpecMap(confTrackBinning); chaDauSpec = trackhistmanager::makeTrackHistSpecMap(confChaDauBinning); - pairTrackKinkHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); + pairTrackKinkHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confMixing); if (processSigma) { sigmaHistSpec = kinkhistmanager::makeKinkHistSpecMap(confSigmaBinning); - pairTrackSigmaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, confSigmaSelection, confSigmaCleaner, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, sigmaHistSpec, chaDauSpec, pairTrackKinkHistSpec, cprHistSpec); + pairTrackSigmaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, confSigmaSelection, confSigmaCleaner, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, sigmaHistSpec, chaDauSpec, pairTrackKinkHistSpec, cprHistSpec); } else { sigmaPlusHistSpec = kinkhistmanager::makeKinkHistSpecMap(confSigmaPlusBinning); - pairTrackSigmaPlusBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, confSigmaPlusSelection, confSigmaPlusCleaner, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, sigmaPlusHistSpec, chaDauSpec, pairTrackKinkHistSpec, cprHistSpec); + pairTrackSigmaPlusBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, confSigmaPlusSelection, confSigmaPlusCleaner, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, sigmaPlusHistSpec, chaDauSpec, pairTrackKinkHistSpec, cprHistSpec); } } else { colHistSpec = colhistmanager::makeColMcHistSpecMap(confCollisionBinning); trackHistSpec = trackhistmanager::makeTrackMcHistSpecMap(confTrackBinning); chaDauSpec = trackhistmanager::makeTrackMcHistSpecMap(confChaDauBinning); - pairTrackKinkHistSpec = pairhistmanager::makePairMcHistSpecMap(confPairBinning); + pairTrackKinkHistSpec = pairhistmanager::makePairMcHistSpecMap(confPairBinning, confMixing); if (processSigma) { sigmaHistSpec = kinkhistmanager::makeKinkMcHistSpecMap(confSigmaBinning); - pairTrackSigmaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, confSigmaSelection, confSigmaCleaner, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, sigmaHistSpec, chaDauSpec, pairTrackKinkHistSpec, cprHistSpec); + pairTrackSigmaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, confSigmaSelection, confSigmaCleaner, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, sigmaHistSpec, chaDauSpec, pairTrackKinkHistSpec, cprHistSpec); } else { sigmaPlusHistSpec = kinkhistmanager::makeKinkMcHistSpecMap(confSigmaPlusBinning); - pairTrackSigmaPlusBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, confSigmaPlusSelection, confSigmaPlusCleaner, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, sigmaPlusHistSpec, chaDauSpec, pairTrackKinkHistSpec, cprHistSpec); + pairTrackSigmaPlusBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, confSigmaPlusSelection, confSigmaPlusCleaner, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, sigmaPlusHistSpec, chaDauSpec, pairTrackKinkHistSpec, cprHistSpec); } } hRegistry.print(); @@ -207,49 +207,49 @@ struct FemtoPairTrackKink { void processSigmaSameEvent(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoSigmas const& sigmas) { - pairTrackSigmaBuilder.processSameEvent(col, tracks, trackPartition, sigmas, sigmaPartition, cache); + pairTrackSigmaBuilder.processSameEvent(col, tracks, trackPartition, sigmas, sigmaPartition, cache); } PROCESS_SWITCH(FemtoPairTrackKink, processSigmaSameEvent, "Enable processing same event processing for tracks and sigmas", true); void processSigmaSameEventMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoSigmasWithLabel const& sigmas, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairTrackSigmaBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition, sigmas, sigmaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); + pairTrackSigmaBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition, sigmas, sigmaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); } PROCESS_SWITCH(FemtoPairTrackKink, processSigmaSameEventMc, "Enable processing same event processing for tracks and sigmas with MC information", false); void processSigmaMixedEvent(FilteredFemtoCollisions const& cols, FemtoTracks const& tracks, FemtoSigmas const& /*sigmas*/) { - pairTrackSigmaBuilder.processMixedEvent(cols, tracks, trackPartition, sigmaPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackSigmaBuilder.processMixedEvent(cols, tracks, trackPartition, sigmaPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackKink, processSigmaMixedEvent, "Enable processing mixed event processing for tracks and sigmas", true); void processSigmaMixedEventMc(FilteredFemtoCollisionsWithLabel const& cols, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoSigmasWithLabel const& /*sigmas*/, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairTrackSigmaBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition, sigmaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackSigmaBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition, sigmaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackKink, processSigmaMixedEventMc, "Enable processing mixed event processing for tracks and sigmas with MC information", false); void processSigmaPlusSameEvent(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoSigmaPlus const& sigmaplus) { - pairTrackSigmaPlusBuilder.processSameEvent(col, tracks, trackPartition, sigmaplus, sigmaPlusPartition, cache); + pairTrackSigmaPlusBuilder.processSameEvent(col, tracks, trackPartition, sigmaplus, sigmaPlusPartition, cache); } PROCESS_SWITCH(FemtoPairTrackKink, processSigmaPlusSameEvent, "Enable processing same event processing for tracks and sigma plus", false); void processSigmaPlusSameEventMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoSigmaPlusWithLabel const& sigmaplus, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairTrackSigmaPlusBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition, sigmaplus, sigmaPlusWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); + pairTrackSigmaPlusBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition, sigmaplus, sigmaPlusWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); } PROCESS_SWITCH(FemtoPairTrackKink, processSigmaPlusSameEventMc, "Enable processing same event processing for tracks and sigma plus with MC information", false); void processSigmaPlusMixedEvent(FilteredFemtoCollisions const& cols, FemtoTracks const& tracks, FemtoSigmaPlus const& /*sigmaplus*/) { - pairTrackSigmaPlusBuilder.processMixedEvent(cols, tracks, trackPartition, sigmaPlusPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackSigmaPlusBuilder.processMixedEvent(cols, tracks, trackPartition, sigmaPlusPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackKink, processSigmaPlusMixedEvent, "Enable processing mixed event processing for tracks and sigma plus", false); void processSigmaPlusMixedEventMc(FilteredFemtoCollisionsWithLabel const& cols, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoSigmaPlusWithLabel const& /*sigmaplus*/, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairTrackSigmaPlusBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition, sigmaPlusWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackSigmaPlusBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition, sigmaPlusWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackKink, processSigmaPlusMixedEventMc, "Enable processing mixed event processing for tracks and sigma plus with MC information", false); }; diff --git a/PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx b/PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx index deb7c1164d8..e399f6e8399 100644 --- a/PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx +++ b/PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx @@ -142,51 +142,51 @@ struct FemtoPairTrackTrack { colHistSpec = colhistmanager::makeColHistSpecMap(confCollisionBinning); trackHistSpec1 = trackhistmanager::makeTrackHistSpecMap(confTrackBinning1); trackHistSpec2 = trackhistmanager::makeTrackHistSpecMap(confTrackBinning2); - pairHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); - pairTrackTrackBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confTrackCleaner1, confTrackCleaner2, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec1, trackHistSpec2, pairHistSpec, cprHistSpec); + pairHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confMixing); + pairTrackTrackBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confTrackCleaner1, confTrackCleaner2, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec1, trackHistSpec2, pairHistSpec, cprHistSpec); } else { colHistSpec = colhistmanager::makeColMcHistSpecMap(confCollisionBinning); trackHistSpec1 = trackhistmanager::makeTrackMcHistSpecMap(confTrackBinning1); trackHistSpec2 = trackhistmanager::makeTrackMcHistSpecMap(confTrackBinning2); - pairHistSpec = pairhistmanager::makePairMcHistSpecMap(confPairBinning); - pairTrackTrackBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confTrackCleaner1, confTrackCleaner2, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec1, trackHistSpec2, pairHistSpec, cprHistSpec); + pairHistSpec = pairhistmanager::makePairMcHistSpecMap(confPairBinning, confMixing); + pairTrackTrackBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confTrackCleaner1, confTrackCleaner2, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec1, trackHistSpec2, pairHistSpec, cprHistSpec); } hRegistry.print(); }; void processSameEvent(FilteredFemtoCollision const& col, FemtoTracks const& tracks) { - pairTrackTrackBuilder.processSameEvent(col, tracks, trackPartition1, trackPartition2, cache); + pairTrackTrackBuilder.processSameEvent(col, tracks, trackPartition1, trackPartition2, cache); } PROCESS_SWITCH(FemtoPairTrackTrack, processSameEvent, "Enable processing same event processing", true); void processSameEventWithMass(FilteredFemtoCollision const& col, FemtoTracksWithMass const& tracks) { - pairTrackTrackBuilder.processSameEvent(col, tracks, trackWithMassPartition1, trackWithMassPartition2, cache); + pairTrackTrackBuilder.processSameEvent(col, tracks, trackWithMassPartition1, trackWithMassPartition2, cache); } PROCESS_SWITCH(FemtoPairTrackTrack, processSameEventWithMass, "Enable processing same event processing (with track masses)", false); void processSameEventMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairTrackTrackBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, mcParticles, mcMothers, mcPartonicMothers, cache); + pairTrackTrackBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, mcParticles, mcMothers, mcPartonicMothers, cache); } PROCESS_SWITCH(FemtoPairTrackTrack, processSameEventMc, "Enable processing same event processing", false); void processMixedEvent(FilteredFemtoCollisions const& cols, FemtoTracks const& tracks) { - pairTrackTrackBuilder.processMixedEvent(cols, tracks, trackPartition1, trackPartition2, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackTrackBuilder.processMixedEvent(cols, tracks, trackPartition1, trackPartition2, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackTrack, processMixedEvent, "Enable processing mixed event processing", true); void processMixedEventWithMass(FilteredFemtoCollisions const& cols, FemtoTracksWithMass const& tracks) { - pairTrackTrackBuilder.processMixedEvent(cols, tracks, trackWithMassPartition1, trackWithMassPartition2, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackTrackBuilder.processMixedEvent(cols, tracks, trackWithMassPartition1, trackWithMassPartition2, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackTrack, processMixedEventWithMass, "Enable processing mixed event processing (with track masses)", false); void processMixedEventMc(FilteredFemtoCollisionsWithLabel const& cols, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairTrackTrackBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackTrackBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackTrack, processMixedEventMc, "Enable processing mixed event processing", false); }; diff --git a/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx b/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx index db7e18ba53b..371e2fa0aaf 100644 --- a/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx +++ b/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx @@ -176,58 +176,58 @@ struct FemtoPairTrackTwoTrackResonance { // setup for phi if (doprocessPhiSameEvent || doprocessPhiMixedEvent) { auto phiHistSpec = twotrackresonancehistmanager::makeTwoTrackResonanceHistSpecMap(confPhiBinning); - auto pairTrackPhiHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); - pairTrackPhiBuilder.init(&hRegistry, confCollisionBinning, trackSelection, phiSelection, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, phiHistSpec, posDauSpec, negDauSpec, pairTrackPhiHistSpec, cprHistSpec); + auto pairTrackPhiHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confMixing); + pairTrackPhiBuilder.init(&hRegistry, confCollisionBinning, 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); - pairTrackKstar0Builder.init(&hRegistry, confCollisionBinning, trackSelection, kstar0Selection, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, kstar0HistSpec, posDauSpec, negDauSpec, pairTrackKstar0HistSpec, cprHistSpec); + auto pairTrackKstar0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confMixing); + pairTrackKstar0Builder.init(&hRegistry, confCollisionBinning, 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); - pairTrackRho0Builder.init(&hRegistry, confCollisionBinning, trackSelection, rho0Selection, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, rho0HistSpec, posDauSpec, negDauSpec, pairTrackRho0HistSpec, cprHistSpec); + auto pairTrackRho0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confMixing); + pairTrackRho0Builder.init(&hRegistry, confCollisionBinning, trackSelection, rho0Selection, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, rho0HistSpec, posDauSpec, negDauSpec, pairTrackRho0HistSpec, cprHistSpec); } }; void processPhiSameEvent(FilteredCollision const& col, Tracks const& tracks, Phis const& phis) { - pairTrackPhiBuilder.processSameEvent(col, tracks, trackPartition, phis, phiPartition, cache); + pairTrackPhiBuilder.processSameEvent(col, tracks, trackPartition, phis, phiPartition, cache); } PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processPhiSameEvent, "Enable processing same event processing for tracks and phis", true); void processPhiMixedEvent(FilteredCollisions const& cols, Tracks const& tracks, Phis const& /*phis*/) { - pairTrackPhiBuilder.processMixedEvent(cols, tracks, trackPartition, phiPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackPhiBuilder.processMixedEvent(cols, tracks, trackPartition, phiPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processPhiMixedEvent, "Enable processing mixed event processing for tracks and phis", true); void processKstar0SameEvent(FilteredCollision const& col, Tracks const& tracks, Kstar0s const& kstar0s) { - pairTrackKstar0Builder.processSameEvent(col, tracks, trackPartition, kstar0s, kstar0Partition, cache); + pairTrackKstar0Builder.processSameEvent(col, tracks, trackPartition, kstar0s, kstar0Partition, cache); } PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processKstar0SameEvent, "Enable processing same event processing for tracks and kstar0s", false); void processKstar0MixedEvent(FilteredCollisions const& cols, Tracks const& tracks, Kstar0s const& /*kstar0s*/) { - pairTrackKstar0Builder.processMixedEvent(cols, tracks, trackPartition, kstar0Partition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackKstar0Builder.processMixedEvent(cols, tracks, trackPartition, kstar0Partition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processKstar0MixedEvent, "Enable processing mixed event processing for tracks and kstar0s", false); void processRho0SameEvent(FilteredCollision const& col, Tracks const& tracks, Rho0s const& rho0s) { - pairTrackRho0Builder.processSameEvent(col, tracks, trackPartition, rho0s, rho0Partition, cache); + pairTrackRho0Builder.processSameEvent(col, tracks, trackPartition, rho0s, rho0Partition, cache); } PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processRho0SameEvent, "Enable processing same event processing for tracks and rho0s", false); void processRho0MixedEvent(FilteredCollisions const& cols, Tracks const& tracks, Rho0s const& /*rho0s*/) { - pairTrackRho0Builder.processMixedEvent(cols, tracks, trackPartition, rho0Partition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackRho0Builder.processMixedEvent(cols, tracks, trackPartition, rho0Partition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processRho0MixedEvent, "Enable processing mixed event processing for tracks and rho0s", false); }; diff --git a/PWGCF/Femto/Tasks/femtoPairTrackV0.cxx b/PWGCF/Femto/Tasks/femtoPairTrackV0.cxx index f112f60b973..6747aabb561 100644 --- a/PWGCF/Femto/Tasks/femtoPairTrackV0.cxx +++ b/PWGCF/Femto/Tasks/femtoPairTrackV0.cxx @@ -185,26 +185,26 @@ struct FemtoPairTrackV0 { trackHistSpec = trackhistmanager::makeTrackHistSpecMap(confTrackBinning); posDauSpec = trackhistmanager::makeTrackHistSpecMap(confPosDauBinning); negDauSpec = trackhistmanager::makeTrackHistSpecMap(confNegDauBinning); - pairTrackV0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); + pairTrackV0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confMixing); if (processLambda) { lambdaHistSpec = v0histmanager::makeV0HistSpecMap(confLambdaBinning); - pairTrackLambdaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, lambdaSelection, confLambdaCleaner, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairTrackV0HistSpec, cprHistSpec); + pairTrackLambdaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, lambdaSelection, confLambdaCleaner, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairTrackV0HistSpec, cprHistSpec); } else { k0shortHistSpec = v0histmanager::makeV0HistSpecMap(confK0shortBinning); - pairTrackK0shortBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, lambdaSelection, confTrackCleaner, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairTrackV0HistSpec, cprHistSpec); + pairTrackK0shortBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, lambdaSelection, confTrackCleaner, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairTrackV0HistSpec, cprHistSpec); } } else { colHistSpec = colhistmanager::makeColMcHistSpecMap(confCollisionBinning); trackHistSpec = trackhistmanager::makeTrackMcHistSpecMap(confTrackBinning); posDauSpec = trackhistmanager::makeTrackMcHistSpecMap(confPosDauBinning); negDauSpec = trackhistmanager::makeTrackMcHistSpecMap(confNegDauBinning); - pairTrackV0HistSpec = pairhistmanager::makePairMcHistSpecMap(confPairBinning); + pairTrackV0HistSpec = pairhistmanager::makePairMcHistSpecMap(confPairBinning, confMixing); if (processLambda) { lambdaHistSpec = v0histmanager::makeV0McHistSpecMap(confLambdaBinning); - pairTrackLambdaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, lambdaSelection, confLambdaCleaner, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairTrackV0HistSpec, cprHistSpec); + pairTrackLambdaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, lambdaSelection, confLambdaCleaner, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairTrackV0HistSpec, cprHistSpec); } else { k0shortHistSpec = v0histmanager::makeV0McHistSpecMap(confK0shortBinning); - pairTrackK0shortBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, lambdaSelection, confLambdaCleaner, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairTrackV0HistSpec, cprHistSpec); + pairTrackK0shortBuilder.init(&hRegistry, confCollisionBinning, confTrackSelection, confTrackCleaner, lambdaSelection, confLambdaCleaner, confCpr, confMixing, confPairBinning, confPairCuts, colHistSpec, trackHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairTrackV0HistSpec, cprHistSpec); } } hRegistry.print(); @@ -212,49 +212,49 @@ struct FemtoPairTrackV0 { void processLambdaSameEvent(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoLambdas const& lambdas) { - pairTrackLambdaBuilder.processSameEvent(col, tracks, trackPartition, lambdas, lambdaPartition, cache); + pairTrackLambdaBuilder.processSameEvent(col, tracks, trackPartition, lambdas, lambdaPartition, cache); } PROCESS_SWITCH(FemtoPairTrackV0, processLambdaSameEvent, "Enable processing same event processing for tracks and lambdas", true); void processLambdaSameEventMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoLambdasWithLabel const& lambdas, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairTrackLambdaBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition, lambdas, lambdaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); + pairTrackLambdaBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition, lambdas, lambdaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); } PROCESS_SWITCH(FemtoPairTrackV0, processLambdaSameEventMc, "Enable processing same event processing for tracks and lambdas with MC information", false); void processLambdaMixedEvent(FilteredFemtoCollisions const& cols, FemtoTracks const& tracks, FemtoLambdas const& /*lambas*/) { - pairTrackLambdaBuilder.processMixedEvent(cols, tracks, trackPartition, lambdaPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackLambdaBuilder.processMixedEvent(cols, tracks, trackPartition, lambdaPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackV0, processLambdaMixedEvent, "Enable processing mixed event processing for tracks and lambdas", true); void processLambdaMixedEventMc(FilteredFemtoCollisionsWithLabel const& cols, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoLambdasWithLabel const& /*lambas*/, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairTrackLambdaBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition, lambdaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackLambdaBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition, lambdaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackV0, processLambdaMixedEventMc, "Enable processing mixed event processing for tracks and lambdas with MC information", false); void processK0shortSameEvent(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoK0shorts const& k0shorts) { - pairTrackK0shortBuilder.processSameEvent(col, tracks, trackPartition, k0shorts, k0shortPartition, cache); + pairTrackK0shortBuilder.processSameEvent(col, tracks, trackPartition, k0shorts, k0shortPartition, cache); } PROCESS_SWITCH(FemtoPairTrackV0, processK0shortSameEvent, "Enable processing same event processing for tracks and k0shorts", false); void processK0shortSameEventMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoK0shortsWithLabel const& k0shorts, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairTrackK0shortBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition, k0shorts, k0shortWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); + pairTrackK0shortBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition, k0shorts, k0shortWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); } PROCESS_SWITCH(FemtoPairTrackV0, processK0shortSameEventMc, "Enable processing same event processing for tracks and k0shorts with MC information", false); void processK0shortMixedEvent(FilteredFemtoCollisions const& cols, FemtoTracks const& tracks, FemtoK0shorts const& /*k0shorts*/) { - pairTrackK0shortBuilder.processMixedEvent(cols, tracks, trackPartition, k0shortPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackK0shortBuilder.processMixedEvent(cols, tracks, trackPartition, k0shortPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackV0, processK0shortMixedEvent, "Enable processing mixed event processing for tracks and k0shorts", false); void processK0shortMixedEventMc(FilteredFemtoCollisionsWithLabel const& cols, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoK0shortsWithLabel const& /*k0shorts*/, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairTrackK0shortBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition, k0shortWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairTrackK0shortBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition, k0shortWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackV0, processK0shortMixedEventMc, "Enable processing mixed event processing for tracks and k0shorts with mc information", false); }; diff --git a/PWGCF/Femto/Tasks/femtoPairV0V0.cxx b/PWGCF/Femto/Tasks/femtoPairV0V0.cxx index 1cf6ffaf677..44bf36b9635 100644 --- a/PWGCF/Femto/Tasks/femtoPairV0V0.cxx +++ b/PWGCF/Femto/Tasks/femtoPairV0V0.cxx @@ -188,15 +188,15 @@ struct FemtoPairV0V0 { negDauSpec = trackhistmanager::makeTrackHistSpecMap(confNegDauBinning); if (processLambdaLambda) { lambdaHistSpec = v0histmanager::makeV0HistSpecMap(confLambdaBinning); - pairV0V0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); - pairLambdaLambdaBuilder.init(&hRegistry, confCollisionBinning, confLambdaSelection, confLambdaSelection, confLambdaCleaner, confLambdaCleaner, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, lambdaHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairV0V0HistSpec, cprHistSpecPos, cprHistSpecNeg); + pairV0V0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confMixing); + pairLambdaLambdaBuilder.init(&hRegistry, confCollisionBinning, confLambdaSelection, confLambdaSelection, confLambdaCleaner, confLambdaCleaner, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, lambdaHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairV0V0HistSpec, cprHistSpecPos, cprHistSpecNeg); } // setup for k0short if (doprocessK0shortK0shortSameEvent || doprocessK0shortK0shortMixedEvent) { k0shortHistSpec = v0histmanager::makeV0HistSpecMap(confK0shortBinning); - pairV0V0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); - pairK0shortK0shortBuilder.init(&hRegistry, confCollisionBinning, confK0shortSelection, confK0shortSelection, confK0shortCleaner, confK0shortCleaner, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, k0shortHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairV0V0HistSpec, cprHistSpecPos, cprHistSpecNeg); + pairV0V0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confMixing); + pairK0shortK0shortBuilder.init(&hRegistry, confCollisionBinning, confK0shortSelection, confK0shortSelection, confK0shortCleaner, confK0shortCleaner, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, k0shortHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairV0V0HistSpec, cprHistSpecPos, cprHistSpecNeg); } } else { colHistSpec = colhistmanager::makeColMcHistSpecMap(confCollisionBinning); @@ -204,52 +204,52 @@ struct FemtoPairV0V0 { negDauSpec = trackhistmanager::makeTrackMcHistSpecMap(confNegDauBinning); if (processLambdaLambda) { lambdaHistSpec = v0histmanager::makeV0McHistSpecMap(confLambdaBinning); - pairV0V0HistSpec = pairhistmanager::makePairMcHistSpecMap(confPairBinning); - pairLambdaLambdaBuilder.init(&hRegistry, confCollisionBinning, confLambdaSelection, confLambdaSelection, confLambdaCleaner, confLambdaCleaner, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, lambdaHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairV0V0HistSpec, cprHistSpecPos, cprHistSpecNeg); + pairV0V0HistSpec = pairhistmanager::makePairMcHistSpecMap(confPairBinning, confMixing); + pairLambdaLambdaBuilder.init(&hRegistry, confCollisionBinning, confLambdaSelection, confLambdaSelection, confLambdaCleaner, confLambdaCleaner, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, lambdaHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairV0V0HistSpec, cprHistSpecPos, cprHistSpecNeg); } // setup for k0short if (doprocessK0shortK0shortSameEvent || doprocessK0shortK0shortMixedEvent) { k0shortHistSpec = v0histmanager::makeV0McHistSpecMap(confK0shortBinning); - pairV0V0HistSpec = pairhistmanager::makePairMcHistSpecMap(confPairBinning); - pairK0shortK0shortBuilder.init(&hRegistry, confCollisionBinning, confK0shortSelection, confK0shortSelection, confK0shortCleaner, confK0shortCleaner, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, k0shortHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairV0V0HistSpec, cprHistSpecPos, cprHistSpecNeg); + pairV0V0HistSpec = pairhistmanager::makePairMcHistSpecMap(confPairBinning, confMixing); + pairK0shortK0shortBuilder.init(&hRegistry, confCollisionBinning, confK0shortSelection, confK0shortSelection, confK0shortCleaner, confK0shortCleaner, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, k0shortHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairV0V0HistSpec, cprHistSpecPos, cprHistSpecNeg); } } }; void processLambdaLambdaSameEvent(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoLambdas const& lambdas) { - pairLambdaLambdaBuilder.processSameEvent(col, tracks, lambdas, lambdaPartition, lambdaPartition, cache); + pairLambdaLambdaBuilder.processSameEvent(col, tracks, lambdas, lambdaPartition, lambdaPartition, cache); } PROCESS_SWITCH(FemtoPairV0V0, processLambdaLambdaSameEvent, "Enable processing same event processing for lambda-lambda", true); void processLambdaLambdaSameEventMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoLambdasWithLabel const& lambdas, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairLambdaLambdaBuilder.processSameEvent(col, mcCols, tracks, lambdas, lambdaWithLabelPartition, lambdaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); + pairLambdaLambdaBuilder.processSameEvent(col, mcCols, tracks, lambdas, lambdaWithLabelPartition, lambdaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); } PROCESS_SWITCH(FemtoPairV0V0, processLambdaLambdaSameEventMc, "Enable processing same event processing for lambda-lambda with mc information", false); void processLambdaLambdaMixedEvent(FilteredFemtoCollisions const& cols, FemtoTracks const& tracks, FemtoLambdas const& lambdas) { - pairLambdaLambdaBuilder.processMixedEvent(cols, tracks, lambdas, lambdaPartition, lambdaPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairLambdaLambdaBuilder.processMixedEvent(cols, tracks, lambdas, lambdaPartition, lambdaPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairV0V0, processLambdaLambdaMixedEvent, "Enable processing mixed event processing for lambda-lambda", true); void processLambdaLambdaMixedEventMc(FilteredFemtoCollisionsWithLabel const& cols, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoLambdasWithLabel const& /*lambdas*/, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairLambdaLambdaBuilder.processMixedEvent(cols, mcCols, tracks, lambdaWithLabelPartition, lambdaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairLambdaLambdaBuilder.processMixedEvent(cols, mcCols, tracks, lambdaWithLabelPartition, lambdaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairV0V0, processLambdaLambdaMixedEventMc, "Enable processing mixed event processing for lambda-lambda with mc information", false); void processK0shortK0shortSameEvent(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoK0shorts const& k0shorts) { - pairK0shortK0shortBuilder.processSameEvent(col, tracks, k0shorts, k0shortPartition, k0shortPartition, cache); + pairK0shortK0shortBuilder.processSameEvent(col, tracks, k0shorts, k0shortPartition, k0shortPartition, cache); } PROCESS_SWITCH(FemtoPairV0V0, processK0shortK0shortSameEvent, "Enable processing same event processing for k0short-k0short", false); void processK0shortK0shortSameEventMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoK0shortsWithLabel const& k0shorts, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairK0shortK0shortBuilder.processSameEvent(col, mcCols, tracks, k0shorts, k0shortWithLabelPartition, k0shortWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); + pairK0shortK0shortBuilder.processSameEvent(col, mcCols, tracks, k0shorts, k0shortWithLabelPartition, k0shortWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); } PROCESS_SWITCH(FemtoPairV0V0, processK0shortK0shortSameEventMc, "Enable processing same event processing for k0short-k0short with mc information", false); @@ -261,7 +261,7 @@ struct FemtoPairV0V0 { void processK0shortK0shortMixedEventMc(FilteredFemtoCollisionsWithLabel const& cols, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoK0shortsWithLabel const& /*k0shorts*/, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairK0shortK0shortBuilder.processMixedEvent(cols, mcCols, tracks, k0shortWithLabelPartition, k0shortWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairK0shortK0shortBuilder.processMixedEvent(cols, mcCols, tracks, k0shortWithLabelPartition, k0shortWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairV0V0, processK0shortK0shortMixedEventMc, "Enable processing mixed event processing for k0short-k0short with mc information", false); }; diff --git a/PWGCF/Femto/Tasks/femtoTrackQa.cxx b/PWGCF/Femto/Tasks/femtoTrackQa.cxx index 25916affb95..c01da3e08ec 100644 --- a/PWGCF/Femto/Tasks/femtoTrackQa.cxx +++ b/PWGCF/Femto/Tasks/femtoTrackQa.cxx @@ -106,7 +106,7 @@ struct FemtoTrackQa { void processData(FilteredFemtoCollision const& col, FemtoTracks const& tracks) { - colHistManager.fill(col, 0, 0, 0); + colHistManager.fill(col); auto trackSlice = trackPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache); for (auto const& track : trackSlice) { trackHistManager.fill(track, tracks); @@ -116,7 +116,7 @@ struct FemtoTrackQa { void processMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - colHistManager.fill(col, mcCols, 0, 0, 0); + colHistManager.fill(col, mcCols); auto trackSlice = trackWithLabelPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache); for (auto const& track : trackSlice) { if (!trackCleaner.isClean(track, mcParticles, mcMothers, mcPartonicMothers)) { diff --git a/PWGCF/Femto/Tasks/femtoTwotrackresonanceQa.cxx b/PWGCF/Femto/Tasks/femtoTwotrackresonanceQa.cxx index 5d2e3348c16..73fb88c1092 100644 --- a/PWGCF/Femto/Tasks/femtoTwotrackresonanceQa.cxx +++ b/PWGCF/Femto/Tasks/femtoTwotrackresonanceQa.cxx @@ -140,7 +140,7 @@ struct FemtoTwotrackresonanceQa { void processPhis(FilteredFemtoCollision const& col, FemtoPhis const& /*phis*/, FemtoTracks const& tracks) { - colHistManager.fill(col, 0, 0, 0); + colHistManager.fill(col); auto phiSlice = phiPartition->sliceByCached(femtobase::stored::fColId, col.globalIndex(), cache); for (auto const& phi : phiSlice) { phiHistManager.fill(phi, tracks); @@ -150,7 +150,7 @@ struct FemtoTwotrackresonanceQa { void processRho0s(FilteredFemtoCollision const& col, FemtoRho0s const& /*rho0s*/, FemtoTracks const& tracks) { - colHistManager.fill(col, 0, 0, 0); + colHistManager.fill(col); auto rho0Slice = rho0Partition->sliceByCached(femtobase::stored::fColId, col.globalIndex(), cache); for (auto const& rho0 : rho0Slice) { rho0HistManager.fill(rho0, tracks); @@ -160,7 +160,7 @@ struct FemtoTwotrackresonanceQa { void processKstar0s(FilteredFemtoCollision const& col, FemtoKstar0s const& /*kstar0s*/, FemtoTracks const& tracks) { - colHistManager.fill(col, 0, 0, 0); + colHistManager.fill(col); auto kstar0Slice = kstar0Partition->sliceByCached(femtobase::stored::fColId, col.globalIndex(), cache); for (auto const& kstar0 : kstar0Slice) { kstar0HistManager.fill(kstar0, tracks); diff --git a/PWGCF/Femto/Tasks/femtoV0Qa.cxx b/PWGCF/Femto/Tasks/femtoV0Qa.cxx index 5ed29d305ba..8c50193f3ec 100644 --- a/PWGCF/Femto/Tasks/femtoV0Qa.cxx +++ b/PWGCF/Femto/Tasks/femtoV0Qa.cxx @@ -166,7 +166,7 @@ struct FemtoV0Qa { void processK0short(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoK0shorts const& /*k0shorts*/) { - colHistManager.fill(col, 0, 0, 0); + colHistManager.fill(col); auto k0shortSlice = k0shortPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache); for (auto const& k0short : k0shortSlice) { k0shortHistManager.fill(k0short, tracks); @@ -176,7 +176,7 @@ struct FemtoV0Qa { void processK0shortMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoK0shortsWithLabel const& /*k0shorts*/, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - colHistManager.fill(col, mcCols, 0, 0, 0); + colHistManager.fill(col, mcCols); auto k0shortSlice = k0shortWithLabelPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache); for (auto const& k0short : k0shortSlice) { if (!k0shortCleaner.isClean(k0short, mcParticles, mcMothers, mcPartonicMothers)) { @@ -189,7 +189,7 @@ struct FemtoV0Qa { void processLambda(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoLambdas const& /*lambdas*/) { - colHistManager.fill(col, 0, 0, 0); + colHistManager.fill(col); auto lambdaSlice = lambdaPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache); for (auto const& lambda : lambdaSlice) { lambdaHistManager.fill(lambda, tracks); @@ -199,7 +199,7 @@ struct FemtoV0Qa { void processLambdaMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoLambdasWithLabel const& /*lambdas*/, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - colHistManager.fill(col, mcCols, 0, 0, 0); + colHistManager.fill(col, mcCols); auto lambdaSlice = lambdaWithLabelPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache); for (auto const& lambda : lambdaSlice) { if (!lambdaCleaner.isClean(lambda, mcParticles, mcMothers, mcPartonicMothers)) { diff --git a/PWGCF/FemtoWorld/Tasks/femtoPairLambdaAntilambda.cxx b/PWGCF/FemtoWorld/Tasks/femtoPairLambdaAntilambda.cxx index 11c590b7002..9a9127cc1ac 100644 --- a/PWGCF/FemtoWorld/Tasks/femtoPairLambdaAntilambda.cxx +++ b/PWGCF/FemtoWorld/Tasks/femtoPairLambdaAntilambda.cxx @@ -192,15 +192,15 @@ struct FemtoPairLambdaAntilambda { negDauSpec = trackhistmanager::makeTrackHistSpecMap(confNegDauBinning); if (processLambdaLambda) { lambdaHistSpec = v0histmanager::makeV0HistSpecMap(confLambdaBinning); - pairV0V0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); - pairLambdaLambdaBuilder.init(&hRegistry, confCollisionBinning, confLambdaSelection, confLambdaSelection2, confLambdaCleaner, confLambdaCleaner, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, lambdaHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairV0V0HistSpec, cprHistSpecPos, cprHistSpecNeg); + pairV0V0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confMixing); + pairLambdaLambdaBuilder.init(&hRegistry, confCollisionBinning, confLambdaSelection, confLambdaSelection2, confLambdaCleaner, confLambdaCleaner, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, lambdaHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairV0V0HistSpec, cprHistSpecPos, cprHistSpecNeg); } // setup for k0short if (doprocessK0shortK0shortSameEvent || doprocessK0shortK0shortMixedEvent) { k0shortHistSpec = v0histmanager::makeV0HistSpecMap(confK0shortBinning); - pairV0V0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning); - pairK0shortK0shortBuilder.init(&hRegistry, confCollisionBinning, confK0shortSelection, confK0shortSelection, confK0shortCleaner, confK0shortCleaner, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, k0shortHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairV0V0HistSpec, cprHistSpecPos, cprHistSpecNeg); + pairV0V0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confMixing); + pairK0shortK0shortBuilder.init(&hRegistry, confCollisionBinning, confK0shortSelection, confK0shortSelection, confK0shortCleaner, confK0shortCleaner, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, k0shortHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairV0V0HistSpec, cprHistSpecPos, cprHistSpecNeg); } } else { colHistSpec = colhistmanager::makeColMcHistSpecMap(confCollisionBinning); @@ -208,64 +208,64 @@ struct FemtoPairLambdaAntilambda { negDauSpec = trackhistmanager::makeTrackMcHistSpecMap(confNegDauBinning); if (processLambdaLambda) { lambdaHistSpec = v0histmanager::makeV0McHistSpecMap(confLambdaBinning); - pairV0V0HistSpec = pairhistmanager::makePairMcHistSpecMap(confPairBinning); - pairLambdaLambdaBuilder.init(&hRegistry, confCollisionBinning, confLambdaSelection, confLambdaSelection2, confLambdaCleaner, confLambdaCleaner, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, lambdaHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairV0V0HistSpec, cprHistSpecPos, cprHistSpecNeg); + pairV0V0HistSpec = pairhistmanager::makePairMcHistSpecMap(confPairBinning, confMixing); + pairLambdaLambdaBuilder.init(&hRegistry, confCollisionBinning, confLambdaSelection, confLambdaSelection2, confLambdaCleaner, confLambdaCleaner, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, lambdaHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairV0V0HistSpec, cprHistSpecPos, cprHistSpecNeg); } // setup for k0short if (doprocessK0shortK0shortSameEvent || doprocessK0shortK0shortMixedEvent) { k0shortHistSpec = v0histmanager::makeV0McHistSpecMap(confK0shortBinning); - pairV0V0HistSpec = pairhistmanager::makePairMcHistSpecMap(confPairBinning); - pairK0shortK0shortBuilder.init(&hRegistry, confCollisionBinning, confK0shortSelection, confK0shortSelection, confK0shortCleaner, confK0shortCleaner, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, k0shortHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairV0V0HistSpec, cprHistSpecPos, cprHistSpecNeg); + pairV0V0HistSpec = pairhistmanager::makePairMcHistSpecMap(confPairBinning, confMixing); + pairK0shortK0shortBuilder.init(&hRegistry, confCollisionBinning, confK0shortSelection, confK0shortSelection, confK0shortCleaner, confK0shortCleaner, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, k0shortHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairV0V0HistSpec, cprHistSpecPos, cprHistSpecNeg); } } }; void processLambdaLambdaSameEvent(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoLambdas const& lambdas) { - pairLambdaLambdaBuilder.processSameEvent(col, tracks, lambdas, lambdaPartition, lambdaPartition2, cache); + pairLambdaLambdaBuilder.processSameEvent(col, tracks, lambdas, lambdaPartition, lambdaPartition2, cache); } PROCESS_SWITCH(FemtoPairLambdaAntilambda, processLambdaLambdaSameEvent, "Enable processing same event processing for lambda-lambda", true); void processLambdaLambdaSameEventMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoLambdasWithLabel const& lambdas, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairLambdaLambdaBuilder.processSameEvent(col, mcCols, tracks, lambdas, lambdaWithLabelPartition, lambdaWithLabelPartition2, mcParticles, mcMothers, mcPartonicMothers, cache); + pairLambdaLambdaBuilder.processSameEvent(col, mcCols, tracks, lambdas, lambdaWithLabelPartition, lambdaWithLabelPartition2, mcParticles, mcMothers, mcPartonicMothers, cache); } PROCESS_SWITCH(FemtoPairLambdaAntilambda, processLambdaLambdaSameEventMc, "Enable processing same event processing for lambda-lambda with mc information", false); void processLambdaLambdaMixedEvent(FilteredFemtoCollisions const& cols, FemtoTracks const& tracks, FemtoLambdas const& lambdas) { - pairLambdaLambdaBuilder.processMixedEvent(cols, tracks, lambdas, lambdaPartition, lambdaPartition2, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairLambdaLambdaBuilder.processMixedEvent(cols, tracks, lambdas, lambdaPartition, lambdaPartition2, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairLambdaAntilambda, processLambdaLambdaMixedEvent, "Enable processing mixed event processing for lambda-lambda", true); void processLambdaLambdaMixedEventMc(FilteredFemtoCollisionsWithLabel const& cols, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoLambdasWithLabel const& /*lambdas*/, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairLambdaLambdaBuilder.processMixedEvent(cols, mcCols, tracks, lambdaWithLabelPartition, lambdaWithLabelPartition2, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairLambdaLambdaBuilder.processMixedEvent(cols, mcCols, tracks, lambdaWithLabelPartition, lambdaWithLabelPartition2, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairLambdaAntilambda, processLambdaLambdaMixedEventMc, "Enable processing mixed event processing for lambda-lambda with mc information", false); void processK0shortK0shortSameEvent(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoK0shorts const& k0shorts) { - pairK0shortK0shortBuilder.processSameEvent(col, tracks, k0shorts, k0shortPartition, k0shortPartition, cache); + pairK0shortK0shortBuilder.processSameEvent(col, tracks, k0shorts, k0shortPartition, k0shortPartition, cache); } PROCESS_SWITCH(FemtoPairLambdaAntilambda, processK0shortK0shortSameEvent, "Enable processing same event processing for k0short-k0short", false); void processK0shortK0shortSameEventMc(FilteredFemtoCollisionWithLabel const& col, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoK0shortsWithLabel const& k0shorts, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairK0shortK0shortBuilder.processSameEvent(col, mcCols, tracks, k0shorts, k0shortWithLabelPartition, k0shortWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); + pairK0shortK0shortBuilder.processSameEvent(col, mcCols, tracks, k0shorts, k0shortWithLabelPartition, k0shortWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); } PROCESS_SWITCH(FemtoPairLambdaAntilambda, processK0shortK0shortSameEventMc, "Enable processing same event processing for k0short-k0short with mc information", false); void processK0shortK0shortMixedEvent(FilteredFemtoCollisions const& cols, FemtoTracks const& tracks, FemtoK0shorts const& k0shorts) { - pairK0shortK0shortBuilder.processMixedEvent(cols, tracks, k0shorts, k0shortPartition, k0shortPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairK0shortK0shortBuilder.processMixedEvent(cols, tracks, k0shorts, k0shortPartition, k0shortPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairLambdaAntilambda, processK0shortK0shortMixedEvent, "Enable processing mixed event processing for k0short-k0short", false); void processK0shortK0shortMixedEventMc(FilteredFemtoCollisionsWithLabel const& cols, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, FemtoK0shortsWithLabel const& /*k0shorts*/, o2::aod::FMcParticles const& mcParticles, o2::aod::FMcMothers const& mcMothers, o2::aod::FMcPartMoths const& mcPartonicMothers) { - pairK0shortK0shortBuilder.processMixedEvent(cols, mcCols, tracks, k0shortWithLabelPartition, k0shortWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + pairK0shortK0shortBuilder.processMixedEvent(cols, mcCols, tracks, k0shortWithLabelPartition, k0shortWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairLambdaAntilambda, processK0shortK0shortMixedEventMc, "Enable processing mixed event processing for k0short-k0short with mc information", false); }; From e908043b3f9fa443d9b6084951e4ecac25427676 Mon Sep 17 00:00:00 2001 From: Anton Riedel Date: Wed, 15 Apr 2026 18:13:42 +0200 Subject: [PATCH 2/2] Feat: add Mixing Qa --- PWGCF/Femto/Core/closePairRejection.h | 4 +- PWGCF/Femto/Core/mcBuilder.h | 3 +- PWGCF/Femto/Core/pairBuilder.h | 6 +- PWGCF/Femto/Core/pairHistManager.h | 132 ++++++++++++++++------ PWGCF/Femto/Core/pairProcessHelpers.h | 82 ++++++++++++-- PWGCF/Femto/Core/partitions.h | 2 +- PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx | 6 +- PWGCF/Femto/Tasks/femtoPairV0V0.cxx | 5 +- 8 files changed, 184 insertions(+), 56 deletions(-) diff --git a/PWGCF/Femto/Core/closePairRejection.h b/PWGCF/Femto/Core/closePairRejection.h index 792f521a3c4..5b3cbf74330 100644 --- a/PWGCF/Femto/Core/closePairRejection.h +++ b/PWGCF/Femto/Core/closePairRejection.h @@ -367,8 +367,8 @@ class CloseTrackRejection { double arg = 0.3 * (0.1 * magfield) * (0.01 * radius) / (2. * signedPt); if (std::fabs(arg) <= 1.) { - double phistar = phi - std::asin(arg); - return static_cast(RecoDecay::constrainAngle(phistar)); + double angle = phi - std::asin(arg); + return static_cast(RecoDecay::constrainAngle(angle)); } return std::nullopt; } diff --git a/PWGCF/Femto/Core/mcBuilder.h b/PWGCF/Femto/Core/mcBuilder.h index 30f6210c027..d799265dd88 100644 --- a/PWGCF/Femto/Core/mcBuilder.h +++ b/PWGCF/Femto/Core/mcBuilder.h @@ -134,10 +134,9 @@ class McBuilder // Not yet created → create it auto mcCol = col.template mcCollision_as(); this->fillMcCollision(mcCol, mcProducts); - it = mCollisionMap.find(originalIndex); } // Add label - mcProducts.producedCollisionLabels(it->second); + mcProducts.producedCollisionLabels(mCollisionMap.at(originalIndex)); // mc collsions has been added so we can now safely retrieve the index } else { // If no MC collision associated, fill empty label mcProducts.producedCollisionLabels(-1); diff --git a/PWGCF/Femto/Core/pairBuilder.h b/PWGCF/Femto/Core/pairBuilder.h index fb4e2c022f0..31fb57c6ff7 100644 --- a/PWGCF/Femto/Core/pairBuilder.h +++ b/PWGCF/Femto/Core/pairBuilder.h @@ -604,15 +604,15 @@ class PairTrackV0Builder int pdgCodePosDau = 0; int pdgCodeNegDau = 0; if (modes::isEqual(v0Type, modes::V0::kK0short)) { - pdgCodeNegDau = kPiPlus; + pdgCodePosDau = kPiPlus; pdgCodeNegDau = kPiMinus; } else if (modes::isEqual(v0Type, modes::V0::kLambda) || modes::isEqual(v0Type, modes::V0::kAntiLambda)) { if (confV0Selection.sign.value > 0) { - pdgCodeNegDau = kProton; + pdgCodePosDau = kProton; pdgCodeNegDau = kPiMinus; } else { + pdgCodePosDau = kPiPlus; pdgCodeNegDau = kProtonBar; - pdgCodeNegDau = kPiPlus; } } diff --git a/PWGCF/Femto/Core/pairHistManager.h b/PWGCF/Femto/Core/pairHistManager.h index 6ac87c8ce35..9e9cb73cb47 100644 --- a/PWGCF/Femto/Core/pairHistManager.h +++ b/PWGCF/Femto/Core/pairHistManager.h @@ -32,8 +32,10 @@ #include #include #include +#include #include #include +#include #include namespace o2::analysis::femto @@ -98,9 +100,10 @@ enum PairHist { // mixing qa kSeNpart1VsNpart2, // number of particles 1 vs number of particles 2 in each same event + kMeMixingDepth, // mixing depth + kMeNpart1VsNpart2, // number of particles 1 vs number of particles 2 in each mixed event kMeNpart1, // number of unique particles 1 in each mixing bin kMeNpart2, // number of unique particles 2 in each mixing bin - kMeAverageNpart1VsAverageNpart2, // average number of particles 1 vs average number of particles 2 in each mixing bin kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2, // correlation of event properties in each mixing bin kPairHistogramLast @@ -123,8 +126,8 @@ struct ConfMixing : o2::framework::ConfigurableGroup { 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 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."}; - o2::framework::Configurable enableSameEventQa{"enableSameEventQa", false, "Enable qa plots for same event"}; - o2::framework::Configurable enableMixedEventQa{"enableMixedEventQa", false, "Enable qa plots for mixed event"}; + o2::framework::Configurable enablePairCorrelationQa{"enablePairCorrelationQa", true, "Enable pair-level correlation QA (same-event + mixed-event)"}; + o2::framework::Configurable enableEventMixingQa{"enableEventMixingQa", false, "Enable QA of event properties used in event mixing (vtx, multiplicity, centrality)"}; o2::framework::ConfigurableAxis particleBinning{"particleBinning", {50, -0.5f, 49.5f}, "Binning for particle number correlation in pairs"}; }; @@ -225,10 +228,11 @@ constexpr std::array, kPairHistogramLast> {kTrueMinvVsMinv, o2::framework::kTH2F, "hTrueMinvVsMinv", "m_{Inv,True} vs m_{Inv}; m_{Inv,True} (GeV/#it{c}^{2}); m_{Inv} (GeV/#it{c}^{2})"}, {kTrueMultVsMult, o2::framework::kTH2F, "hTrueMultVsMult", "Multiplicity_{True} vs Multiplicity; Multiplicity_{True} ; Multiplicity"}, {kTrueCentVsCent, o2::framework::kTH2F, "hTrueCentVsCent", "Centrality_{True} vs Centrality; Centrality_{True} (%); Centrality (%)"}, - {kSeNpart1VsNpart2, o2::framework::kTH2F, "hSeNpart1VsNpart2", "# particle 1 vs # particle in SE; # partilce 1; #particle 2"}, + {kSeNpart1VsNpart2, o2::framework::kTH2F, "hSeNpart1VsNpart2", "# particle 1 vs # particle 2 in each same event; # partilce 1; # particle 2"}, + {kMeMixingDepth, o2::framework::kTH1F, "hMeMixingDepth", "Mixing Depth; Mixing Depth ; Entries"}, + {kMeNpart1VsNpart2, o2::framework::kTH2F, "hMeNpart1VsNpart2", "# particle 1 vs # particle 2 in each mixed event pair; # partilce 1; # particle 2"}, {kMeNpart1, o2::framework::kTH1F, "hMeNpart1", "# particle 1 in each mixing bin; # partilce 1; Entries"}, {kMeNpart2, o2::framework::kTH1F, "hMeNpart2", "# particle 2 in each mixing bin; # particle 2; Entries"}, - {kMeAverageNpart1VsAverageNpart2, o2::framework::kTH2F, "hMeAverageNpart1VsAverageNpart2", "average # particle 1 vs average # particle in ME; Average # partilce 1; Average #particle 2"}, {kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2, o2::framework::kTHnSparseF, "hVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2", "Mixing bins; V_{z,1} (cm); multiplicity_{1}; centrality_{1} (%); V_{z,2} (cm); multiplicity_{2}; centrality_{2} (%)"}, }}; @@ -267,9 +271,10 @@ constexpr std::array, kPairHistogramLast> {kKstarVsMtVsMass1VsMass2VsPt1VsPt2VsMultVsCent, {confAnalysis.kstar, confAnalysis.mt, confAnalysis.mass1, confAnalysis.mass2, confAnalysis.pt1, confAnalysis.pt2, confAnalysis.multiplicity, confAnalysis.centrality}}, \ {kDalitz, {confAnalysis.kstar, confAnalysis.dalitzMtot, confAnalysis.dalitzM12, confAnalysis.dalitzM13}}, \ {kSeNpart1VsNpart2, {confMixing.particleBinning, confMixing.particleBinning}}, \ + {kMeMixingDepth, {confMixing.particleBinning}}, \ + {kMeNpart1VsNpart2, {confMixing.particleBinning, confMixing.particleBinning}}, \ {kMeNpart1, {confMixing.particleBinning}}, \ {kMeNpart2, {confMixing.particleBinning}}, \ - {kMeAverageNpart1VsAverageNpart2, {confMixing.particleBinning, confMixing.particleBinning}}, \ {kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2, {confMixing.vtxBins, confMixing.multBins, confMixing.centBins, confMixing.vtxBins, confMixing.multBins, confMixing.centBins}}, #define PAIR_HIST_MC_MAP(conf) \ @@ -373,15 +378,8 @@ class PairHistManager mMassInvMin = ConfPairCuts.massInvMin.value; mMassInvMax = ConfPairCuts.massInvMax.value; - if constexpr (isFlagSet(mode, modes::Mode::kSe)) { - mSeMixingQa = ConfMixing.enableSameEventQa.value; - initSeMixingQa(Specs); - } - - if constexpr (isFlagSet(mode, modes::Mode::kMe)) { - mMeMixingQa = ConfMixing.enableMixedEventQa.value; - initMeMixingQa(Specs); - } + mPairCorrelationQa = ConfMixing.enablePairCorrelationQa.value; + mEventMixingQa = ConfMixing.enableEventMixingQa.value; if constexpr (isFlagSet(mode, modes::Mode::kAnalysis)) { initAnalysis(Specs); @@ -390,6 +388,14 @@ class PairHistManager if constexpr (isFlagSet(mode, modes::Mode::kMc)) { initMc(Specs); } + + if constexpr (isFlagSet(mode, modes::Mode::kSe)) { + initSeMixingQa(Specs); + } + + if constexpr (isFlagSet(mode, modes::Mode::kMe)) { + initMeMixingQa(Specs); + } } void setMass(int PdgParticle1, int PdgParticle2) @@ -565,14 +571,71 @@ class PairHistManager } } - template - void fillMixingQa(T1 const& particles1, T2 const& particles2) + template + void trackParticlesPerMixingBin(T1 const& particle1, T2 const& particle2) { - if constexpr (isFlagSet(mode, modes::Mode::kSe)) { - fillMixingQaSe(particles1, particles2); + mUniqueParticles1PerMixingBin.emplace(particle1.globalIndex(), 0); + mUniqueParticles1PerMixingBin.at(particle1.globalIndex())++; + mUniqueParticles2PerMixingBin.emplace(particle2.globalIndex(), 0); + mUniqueParticles2PerMixingBin.at(particle2.globalIndex())++; + } + + void resetTrackedParticlesPerMixingBin() + { + mUniqueParticles1PerMixingBin.clear(); + mUniqueParticles2PerMixingBin.clear(); + } + + template + void trackParticlesPerEvent(T1 const& particle1, T2 const& particle2) + { + mUniqueParticles1PerEvent.insert(particle1.globalIndex()); + mUniqueParticles2PerEvent.insert(particle2.globalIndex()); + } + + template + void fillMixingQaMe(T1 const& col1, T2 const& col2) + { + if (mEventMixingQa) { + mHistogramRegistry->fill(HIST(prefix) + HIST(MixingQaDir) + HIST(getHistName(kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2, HistTable)), col1.posZ(), col1.mult(), col1.cent(), col2.posZ(), col2.mult(), col2.cent()); } - if constexpr (isFlagSet(mode, modes::Mode::kMe)) { - // fillMc(); + } + + void resetTrackedParticlesPerEvent() + { + mUniqueParticles1PerEvent.clear(); + mUniqueParticles2PerEvent.clear(); + } + + void fillMixingQaSe() + { + if (mPairCorrelationQa) { + mHistogramRegistry->fill(HIST(prefix) + HIST(MixingQaDir) + HIST(getHistName(kSeNpart1VsNpart2, HistTable)), mUniqueParticles1PerEvent.size(), mUniqueParticles2PerEvent.size()); + } + } + + void fillMixingQaMePerEvent() + { + if (mPairCorrelationQa) { + mHistogramRegistry->fill(HIST(prefix) + HIST(MixingQaDir) + HIST(getHistName(kMeNpart1VsNpart2, HistTable)), mUniqueParticles1PerEvent.size(), mUniqueParticles2PerEvent.size()); + } + } + + void fillMixingQaMePerMixingBin(int windowSize) + { + if (!mPairCorrelationQa || windowSize <= 0) { + return; + } + mHistogramRegistry->fill(HIST(prefix) + HIST(MixingQaDir) + HIST(getHistName(kMeMixingDepth, HistTable)), windowSize); + for (const auto& [_, nPart1] : mUniqueParticles1PerMixingBin) { + mHistogramRegistry->fill( + HIST(prefix) + HIST(MixingQaDir) + HIST(getHistName(kMeNpart1, HistTable)), + nPart1); + } + for (const auto& [_, nPart2] : mUniqueParticles2PerMixingBin) { + mHistogramRegistry->fill( + HIST(prefix) + HIST(MixingQaDir) + HIST(getHistName(kMeNpart2, HistTable)), + nPart2); } } @@ -665,7 +728,7 @@ class PairHistManager void initSeMixingQa(std::map> const& Specs) { std::string mcDir = std::string(prefix) + std::string(MixingQaDir); - if (mSeMixingQa) { + if (mPairCorrelationQa) { mHistogramRegistry->add(mcDir + getHistNameV2(kSeNpart1VsNpart2, HistTable), getHistDesc(kSeNpart1VsNpart2, HistTable), getHistType(kSeNpart1VsNpart2, HistTable), {Specs.at(kSeNpart1VsNpart2)}); } } @@ -673,10 +736,13 @@ class PairHistManager void initMeMixingQa(std::map> const& Specs) { std::string mcDir = std::string(prefix) + std::string(MixingQaDir); - if (mMeMixingQa) { + if (mPairCorrelationQa) { + mHistogramRegistry->add(mcDir + getHistNameV2(kMeMixingDepth, HistTable), getHistDesc(kMeMixingDepth, HistTable), getHistType(kMeMixingDepth, HistTable), {Specs.at(kMeMixingDepth)}); + mHistogramRegistry->add(mcDir + getHistNameV2(kMeNpart1VsNpart2, HistTable), getHistDesc(kMeNpart1VsNpart2, HistTable), getHistType(kMeNpart1VsNpart2, HistTable), {Specs.at(kMeNpart1VsNpart2)}); mHistogramRegistry->add(mcDir + getHistNameV2(kMeNpart1, HistTable), getHistDesc(kMeNpart1, HistTable), getHistType(kMeNpart1, HistTable), {Specs.at(kMeNpart1)}); mHistogramRegistry->add(mcDir + getHistNameV2(kMeNpart2, HistTable), getHistDesc(kMeNpart2, HistTable), getHistType(kMeNpart2, HistTable), {Specs.at(kMeNpart2)}); - mHistogramRegistry->add(mcDir + getHistNameV2(kMeAverageNpart1VsAverageNpart2, HistTable), getHistDesc(kMeAverageNpart1VsAverageNpart2, HistTable), getHistType(kMeAverageNpart1VsAverageNpart2, HistTable), {Specs.at(kMeAverageNpart1VsAverageNpart2)}); + } + if (mEventMixingQa) { mHistogramRegistry->add(mcDir + getHistNameV2(kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2, HistTable), getHistDesc(kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2, HistTable), getHistType(kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2, HistTable), {Specs.at(kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2)}); } } @@ -766,14 +832,6 @@ class PairHistManager } } - template - void fillMixingQaSe(T1 const& particles1, T2 const& particles2) - { - if (mSeMixingQa) { - mHistogramRegistry->fill(HIST(prefix) + HIST(MixingQaDir) + HIST(getHistName(kSeNpart1VsNpart2, HistTable)), particles1.size(), particles2.size()); - } - } - float getKt(ROOT::Math::PtEtaPhiMVector const& part1, ROOT::Math::PtEtaPhiMVector const& part2) { auto sum = (part1 + part2); @@ -894,8 +952,14 @@ class PairHistManager bool mPlotDalitz = false; // qa - bool mSeMixingQa = false; - bool mMeMixingQa = false; + bool mPairCorrelationQa = false; + bool mEventMixingQa = false; + + std::set mUniqueParticles1PerEvent = {}; + std::set mUniqueParticles2PerEvent = {}; + + std::unordered_map mUniqueParticles1PerMixingBin = {}; + std::unordered_map mUniqueParticles2PerMixingBin = {}; }; }; // namespace pairhistmanager diff --git a/PWGCF/Femto/Core/pairProcessHelpers.h b/PWGCF/Femto/Core/pairProcessHelpers.h index 9279921b00b..3579046dbe3 100644 --- a/PWGCF/Femto/Core/pairProcessHelpers.h +++ b/PWGCF/Femto/Core/pairProcessHelpers.h @@ -51,6 +51,7 @@ void processSameEvent(T1 const& SliceParticle, T7& PcManager, PairOrder pairOrder) { + PairHistManager.resetTrackedParticlesPerEvent(); for (auto const& part : SliceParticle) { ParticleHistManager.template fill(part, TrackTable); } @@ -80,8 +81,10 @@ void processSameEvent(T1 const& SliceParticle, // if pair cuts are configured check them before filling if (PairHistManager.checkPairCuts()) { PairHistManager.template fill(); + PairHistManager.trackParticlesPerEvent(p1, p2); } } + PairHistManager.fillMixingQaSe(); } // process same event for identical particles with mc information @@ -112,6 +115,7 @@ void processSameEvent(T1 const& SliceParticle, T12& PcManager, PairOrder pairOrder) { + PairHistManager.resetTrackedParticlesPerEvent(); for (auto const& part : SliceParticle) { if (!ParticleCleaner.isClean(part, mcParticles, mcMothers, mcPartonicMothers)) { continue; @@ -149,8 +153,10 @@ void processSameEvent(T1 const& SliceParticle, // if pair cuts are configured check them before filling if (PairHistManager.checkPairCuts()) { PairHistManager.template fill(); + PairHistManager.trackParticlesPerEvent(p1, p2); } } + PairHistManager.fillMixingQaSe(); } // process same event for non-identical particles @@ -174,6 +180,7 @@ void processSameEvent(T1 const& SliceParticle1, T8& CprManager, T9& PcManager) { + PairHistManager.resetTrackedParticlesPerEvent(); // Fill single particle histograms for (auto const& part : SliceParticle1) { ParticleHistManager1.template fill(part, TrackTable); @@ -195,8 +202,10 @@ void processSameEvent(T1 const& SliceParticle1, CprManager.fill(PairHistManager.getKstar()); if (PairHistManager.checkPairCuts()) { PairHistManager.template fill(); + PairHistManager.trackParticlesPerEvent(p1, p2); } } + PairHistManager.fillMixingQaSe(); } // process same event for non-identical particles with mc information @@ -232,6 +241,7 @@ void processSameEvent(T1 const& SliceParticle1, T14& CprManager, T15& PcManager) { + PairHistManager.resetTrackedParticlesPerEvent(); // Fill single particle histograms for (auto const& part : SliceParticle1) { if (!ParticleCleaner1.isClean(part, mcParticles, mcMothers, mcPartonicMothers)) { @@ -264,8 +274,10 @@ void processSameEvent(T1 const& SliceParticle1, CprManager.fill(PairHistManager.getKstar()); if (PairHistManager.checkPairCuts()) { PairHistManager.template fill(); + PairHistManager.trackParticlesPerEvent(p1, p2); } } + PairHistManager.fillMixingQaSe(); } // process mixed event @@ -291,7 +303,21 @@ void processMixedEvent(T1 const& Collisions, T9& CprManager, T10& PcManager) { - for (auto const& [collision1, collision2] : o2::soa::selfCombinations(policy, depth, -1, Collisions, Collisions)) { + bool firstBin = true; + int windowSize = 0; + PairHistManager.resetTrackedParticlesPerEvent(); + PairHistManager.resetTrackedParticlesPerMixingBin(); + auto pairGenerator = o2::soa::selfCombinations(policy, depth, -1, Collisions, Collisions); + for (auto pairIterator = pairGenerator.begin(); pairIterator != pairGenerator.end(); pairIterator++) { + auto const& [collision1, collision2] = *pairIterator; + if (pairIterator.isNewWindow()) { // is true for the first bin, so we skip + if (!firstBin) { + PairHistManager.fillMixingQaMePerMixingBin(windowSize); + PairHistManager.resetTrackedParticlesPerMixingBin(); + } + windowSize = pairIterator.currentWindowNeighbours(); + firstBin = false; + } if (collision1.magField() != collision2.magField()) { continue; } @@ -301,6 +327,9 @@ void processMixedEvent(T1 const& Collisions, if (sliceParticle1.size() == 0 || sliceParticle2.size() == 0) { continue; } + + PairHistManager.resetTrackedParticlesPerEvent(); + PairHistManager.fillMixingQaMe(collision1, collision2); for (auto const& [p1, p2] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(sliceParticle1, sliceParticle2))) { // pair cleaning if (!PcManager.isCleanPair(p1, p2, TrackTable)) { @@ -315,12 +344,16 @@ void processMixedEvent(T1 const& Collisions, CprManager.fill(PairHistManager.getKstar()); if (PairHistManager.checkPairCuts()) { PairHistManager.template fill(); + PairHistManager.trackParticlesPerEvent(p1, p2); + PairHistManager.trackParticlesPerMixingBin(p1, p2); } } + PairHistManager.fillMixingQaMePerEvent(); } + PairHistManager.fillMixingQaMePerMixingBin(windowSize); // fill last window } -// process mixed event with mc information +// process mixed event with mc information template sliceByCached(o2::aod::femtobase::stored::fColId, collision1.globalIndex(), cache); - auto sliceParticle2 = Partition2->sliceByCached(o2::aod::femtobase::stored::fColId, collision2.globalIndex(), cache); + + auto sliceParticle1 = Partition1->sliceByCached( + o2::aod::femtobase::stored::fColId, + collision1.globalIndex(), + cache); + auto sliceParticle2 = Partition2->sliceByCached( + o2::aod::femtobase::stored::fColId, + collision2.globalIndex(), + cache); + if (sliceParticle1.size() == 0 || sliceParticle2.size() == 0) { continue; } - for (auto const& [p1, p2] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(sliceParticle1, sliceParticle2))) { - // particle cleaning + + PairHistManager.resetTrackedParticlesPerEvent(); + PairHistManager.fillMixingQaMe(collision1, collision2); + for (auto const& [p1, p2] : + o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(sliceParticle1, sliceParticle2))) { + // particle cleaning (MC-specific) if (!ParticleCleaner1.isClean(p1, mcParticles, mcMothers, mcPartonicMothers) || !ParticleCleaner2.isClean(p2, mcParticles, mcMothers, mcPartonicMothers)) { continue; @@ -375,7 +436,7 @@ void processMixedEvent(T1 const& Collisions, if (!PcManager.isCleanPair(p1, p2, TrackTable)) { continue; } - // Close pair rejection + // close pair rejection CprManager.setPair(p1, p2, TrackTable); if (CprManager.isClosePair()) { continue; @@ -384,9 +445,14 @@ void processMixedEvent(T1 const& Collisions, CprManager.fill(PairHistManager.getKstar()); if (PairHistManager.checkPairCuts()) { PairHistManager.template fill(); + PairHistManager.trackParticlesPerEvent(p1, p2); + PairHistManager.trackParticlesPerMixingBin(p1, p2); } } + PairHistManager.fillMixingQaMePerEvent(); } + // final window + PairHistManager.fillMixingQaMePerMixingBin(windowSize); } } // namespace pairprocesshelpers diff --git a/PWGCF/Femto/Core/partitions.h b/PWGCF/Femto/Core/partitions.h index 52f2d7bb135..136cf6615ee 100644 --- a/PWGCF/Femto/Core/partitions.h +++ b/PWGCF/Femto/Core/partitions.h @@ -27,7 +27,7 @@ // macro for track momentum, i.e. ||q|*pT/q| * cosh(eta) // there is no ncosh function, so we have to make our own, i.e. cosh(x) = (exp(x)+exp(-x))/2 -#define TRACK_MOMENTUM(chargeAbs, signedPt, eta) nabs((chargeAbs) * (signedPt)) * (nexp(eta) + nexp(-1.f * (eta))) / 2.f +#define TRACK_MOMENTUM(chargeAbs, signedPt, eta) (nabs((chargeAbs) * (signedPt)) * (nexp(eta) + nexp(-1.f * (eta))) / 2.f) // standard track partition #define MAKE_TRACK_PARTITION(selection) \ diff --git a/PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx b/PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx index e399f6e8399..688d95a4d0a 100644 --- a/PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx +++ b/PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx @@ -58,7 +58,7 @@ struct FemtoPairTrackTrack { // for analysis which require particles at high pt, add tof mass so sidebands can be used using FemtoTracksWithMass = o2::soa::Join; - using FemtoTracksWithLabel = o2::soa::Join; + using FemtoTracksWithLabel = o2::soa::Join; o2::framework::SliceCache cache; @@ -84,8 +84,8 @@ struct FemtoPairTrackTrack { o2::framework::Partition trackWithMassPartition2 = MAKE_TRACK_PARTITION_WITH_MASS(confTrackSelections2); o2::framework::Preslice perColtracksWithMass = o2::aod::femtobase::stored::fColId; - o2::framework::Partition trackWithLabelPartition1 = MAKE_TRACK_PARTITION_WITH_MASS(confTrackSelections1); - o2::framework::Partition trackWithLabelPartition2 = MAKE_TRACK_PARTITION_WITH_MASS(confTrackSelections2); + o2::framework::Partition trackWithLabelPartition1 = MAKE_TRACK_PARTITION(confTrackSelections1); + o2::framework::Partition trackWithLabelPartition2 = MAKE_TRACK_PARTITION(confTrackSelections2); o2::framework::Preslice perColtracksWithLabel = o2::aod::femtobase::stored::fColId; // setup pairs diff --git a/PWGCF/Femto/Tasks/femtoPairV0V0.cxx b/PWGCF/Femto/Tasks/femtoPairV0V0.cxx index 44bf36b9635..02cedd702f5 100644 --- a/PWGCF/Femto/Tasks/femtoPairV0V0.cxx +++ b/PWGCF/Femto/Tasks/femtoPairV0V0.cxx @@ -151,8 +151,8 @@ struct FemtoPairV0V0 { void init(o2::framework::InitContext&) { // TODO: implement lambda-k0short - bool processData = doprocessLambdaLambdaSameEvent || doprocessLambdaLambdaSameEvent || doprocessK0shortK0shortSameEvent || doprocessK0shortK0shortSameEvent; - bool processMc = doprocessLambdaLambdaSameEventMc || doprocessLambdaLambdaSameEventMc || doprocessK0shortK0shortSameEventMc || doprocessK0shortK0shortSameEventMc; + bool processData = doprocessLambdaLambdaSameEvent || doprocessLambdaLambdaMixedEvent || doprocessK0shortK0shortSameEvent || doprocessK0shortK0shortMixedEvent; + bool processMc = doprocessLambdaLambdaSameEventMc || doprocessLambdaLambdaMixedEventMc || doprocessK0shortK0shortSameEventMc || doprocessK0shortK0shortMixedEventMc; if (processData && processMc) { LOG(fatal) << "Both data and mc processing is enabled. Breaking..."; @@ -173,7 +173,6 @@ struct FemtoPairV0V0 { // setup histograms std::map> colHistSpec; - std::map> trackHistSpec; std::map> posDauSpec; std::map> negDauSpec; std::map> lambdaHistSpec;