From bce41017907cd1eab828a3cef80b0e2df962a145 Mon Sep 17 00:00:00 2001 From: Anton Riedel Date: Fri, 19 Jun 2026 17:24:50 +0200 Subject: [PATCH 1/3] Fix: fix triplet processing for 2 + 1 case --- PWGCF/Femto/Core/tripletProcessHelpers.h | 139 ++++++++++------------- 1 file changed, 63 insertions(+), 76 deletions(-) diff --git a/PWGCF/Femto/Core/tripletProcessHelpers.h b/PWGCF/Femto/Core/tripletProcessHelpers.h index 8aa6727c02b..76f5ded7447 100644 --- a/PWGCF/Femto/Core/tripletProcessHelpers.h +++ b/PWGCF/Femto/Core/tripletProcessHelpers.h @@ -101,15 +101,8 @@ void processSameEvent(T1 const& SliceParticle, // process same event for identical 2 particles and 1 other particle template + typename T1, typename T2, typename T3, typename T4, + typename T5, typename T6, typename T7, typename T8, typename T9> void processSameEvent(T1 const& SliceParticle1, // 1&2 have same species T2 const& SliceParticle3, T3 const& TrackTable, @@ -128,37 +121,39 @@ void processSameEvent(T1 const& SliceParticle1, // 1&2 have same species ParticleHistManager3.template fill(part, TrackTable); } - for (auto const& [p1, p2, p3] : o2::soa::combinations(o2::soa::CombinationsStrictlyUpperIndexPolicy(SliceParticle1, SliceParticle1, SliceParticle3))) { + for (auto const& p3 : SliceParticle3) { + for (auto const& [p1, p2] : o2::soa::combinations(o2::soa::CombinationsStrictlyUpperIndexPolicy(SliceParticle1, SliceParticle1))) { - // check if triplet is clean - if (!TcManager.isCleanTriplet(p1, p2, p3, TrackTable)) { - continue; - } + // check if triplet is clean + if (!TcManager.isCleanTriplet(p1, p2, p3, TrackTable)) { + continue; + } - // check if triplet is close - CtrManager.setTriplet(p1, p2, p3, TrackTable); - if (CtrManager.isCloseTriplet()) { - continue; - } + // check if triplet is close + CtrManager.setTriplet(p1, p2, p3, TrackTable); + if (CtrManager.isCloseTriplet()) { + continue; + } - // Randomize triplet order if enabled - // only kOrder123 and kOrder213 are meaningful here since particle 1 & 2 are the same species - switch (tripletOrder) { - case kOrder213: - TripletHistManager.setTriplet(p2, p1, p3, Collision); - break; - case kOrder123: - default: - TripletHistManager.setTriplet(p1, p2, p3, Collision); - break; - } + // Randomize triplet order if enabled + // only kOrder123 and kOrder213 are meaningful here since particle 1 & 2 are the same species + switch (tripletOrder) { + case kOrder213: + TripletHistManager.setTriplet(p2, p1, p3, Collision); + break; + case kOrder123: + default: + TripletHistManager.setTriplet(p1, p2, p3, Collision); + break; + } - // fill deta-dphi histograms with q3 cutoff - CtrManager.fill(TripletHistManager.getQ3()); + // fill deta-dphi histograms with q3 cutoff + CtrManager.fill(TripletHistManager.getQ3()); - // if triplet cuts are configured check them before filling - if (TripletHistManager.checkTripletCuts()) { - TripletHistManager.template fill(); + // if triplet cuts are configured check them before filling + if (TripletHistManager.checkTripletCuts()) { + TripletHistManager.template fill(); + } } } } @@ -198,7 +193,7 @@ void processSameEvent(T1 const& SliceParticle1, ParticleHistManager3.template fill(part, TrackTable); } - for (auto const& [p1, p2, p3] : o2::soa::combinations(o2::soa::CombinationsStrictlyUpperIndexPolicy(SliceParticle1, SliceParticle2, SliceParticle3))) { + for (auto const& [p1, p2, p3] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(SliceParticle1, SliceParticle2, SliceParticle3))) { // check if triplet is clean if (!TcManager.isCleanTriplet(p1, p2, p3, TrackTable)) { @@ -291,19 +286,8 @@ void processSameEvent(T1 const& SliceParticle, // process same event for 2 identical particles and one other with mc information template + typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, + typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13> void processSameEvent(T1 const& SliceParticle1, T2 const& SliceParticle3, T3 const& TrackTable, @@ -325,32 +309,35 @@ void processSameEvent(T1 const& SliceParticle1, for (auto const& part : SliceParticle3) { ParticleHistManager3.template fill(part, TrackTable, mcParticles, mcMothers, mcPartonicMothers); } - for (auto const& [p1, p2, p3] : o2::soa::combinations(o2::soa::CombinationsStrictlyUpperIndexPolicy(SliceParticle1, SliceParticle1, SliceParticle3))) { - // check if triplet is clean - if (!TcManager.isCleanTriplet(p1, p2, p3, TrackTable, mcPartonicMothers)) { - continue; - } - // check if triplet is close - CtrManager.setTriplet(p1, p2, p3, TrackTable); - if (CtrManager.isCloseTriplet()) { - continue; - } - // Randomize triplet order if enabled - // only kOrder123 and kOrder213 are meaningful here since particle 1 & 2 are the same species - switch (tripletOrder) { - case kOrder213: - TripletHistManager.setTripletMc(p2, p1, p3, mcParticles, Collision, mcCollisions); - break; - case kOrder123: - default: - TripletHistManager.setTripletMc(p1, p2, p3, mcParticles, Collision, mcCollisions); - break; - } - // fill deta-dphi histograms with q3 cutoff - CtrManager.fill(TripletHistManager.getQ3()); - // if triplet cuts are configured check them before filling - if (TripletHistManager.checkTripletCuts()) { - TripletHistManager.template fill(); + + for (auto const& p3 : SliceParticle3) { + for (auto const& [p1, p2] : o2::soa::combinations(o2::soa::CombinationsStrictlyUpperIndexPolicy(SliceParticle1, SliceParticle1))) { + // check if triplet is clean + if (!TcManager.isCleanTriplet(p1, p2, p3, TrackTable, mcPartonicMothers)) { + continue; + } + // check if triplet is close + CtrManager.setTriplet(p1, p2, p3, TrackTable); + if (CtrManager.isCloseTriplet()) { + continue; + } + // Randomize triplet order if enabled + // only kOrder123 and kOrder213 are meaningful here since particle 1 & 2 are the same species + switch (tripletOrder) { + case kOrder213: + TripletHistManager.setTripletMc(p2, p1, p3, mcParticles, Collision, mcCollisions); + break; + case kOrder123: + default: + TripletHistManager.setTripletMc(p1, p2, p3, mcParticles, Collision, mcCollisions); + break; + } + // fill deta-dphi histograms with q3 cutoff + CtrManager.fill(TripletHistManager.getQ3()); + // if triplet cuts are configured check them before filling + if (TripletHistManager.checkTripletCuts()) { + TripletHistManager.template fill(); + } } } } @@ -397,7 +384,7 @@ void processSameEvent(T1 const& SliceParticle1, for (auto const& part : SliceParticle3) { ParticleHistManager3.template fill(part, TrackTable, mcParticles, mcMothers, mcPartonicMothers); } - for (auto const& [p1, p2, p3] : o2::soa::combinations(o2::soa::CombinationsStrictlyUpperIndexPolicy(SliceParticle1, SliceParticle2, SliceParticle3))) { + for (auto const& [p1, p2, p3] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(SliceParticle1, SliceParticle2, SliceParticle3))) { // check if triplet is clean if (!TcManager.isCleanTriplet(p1, p2, p3, TrackTable, mcPartonicMothers)) { continue; From dd304b517a662a9252fe68c9c0741fa95f308867 Mon Sep 17 00:00:00 2001 From: Anton Riedel Date: Fri, 19 Jun 2026 22:09:16 +0200 Subject: [PATCH 2/3] Fix: fix triplet event mixing and add qa --- PWGCF/Femto/Core/tripletBuilder.h | 65 +++---- PWGCF/Femto/Core/tripletHistManager.h | 161 +++++++++++++++--- PWGCF/Femto/Core/tripletProcessHelpers.h | 117 +++++++++++++ .../Tasks/femtoTripletTrackTrackCascade.cxx | 28 +-- .../Tasks/femtoTripletTrackTrackTrack.cxx | 16 +- .../Femto/Tasks/femtoTripletTrackTrackV0.cxx | 18 +- 6 files changed, 320 insertions(+), 85 deletions(-) diff --git a/PWGCF/Femto/Core/tripletBuilder.h b/PWGCF/Femto/Core/tripletBuilder.h index 147dd6f6ada..279afb54d74 100644 --- a/PWGCF/Femto/Core/tripletBuilder.h +++ b/PWGCF/Femto/Core/tripletBuilder.h @@ -65,7 +65,8 @@ class TripletTrackTrackTrackBuilder TripletTrackTrackTrackBuilder() = default; ~TripletTrackTrackTrackBuilder() = default; - template (registry, colHistSpec, confCollisionBinning); - mTripletHistManagerSe.template init(registry, pairHistSpec, confTripletBinning, confTripletCuts); - mTripletHistManagerMe.template init(registry, pairHistSpec, confTripletBinning, confTripletCuts); + mColHistManager.template init(registry, colHistSpec, confCollisionBinning); + mTripletHistManagerSe.template init(registry, pairHistSpec, confTripletBinning, confTripletCuts, confMixing); + mTripletHistManagerMe.template init(registry, pairHistSpec, confTripletBinning, confTripletCuts, confMixing); - mTc.template init(confTripletCuts); + mTc.template init(confTripletCuts); if (mTrack1Track2Track3AreSameSpecies) { // Track1 & Track2 & Track3 are the same particle species - mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); + mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); mTripletHistManagerSe.setMass(confTrackSelection1.pdgCodeAbs.value, confTrackSelection1.pdgCodeAbs.value, confTrackSelection1.pdgCodeAbs.value); mTripletHistManagerSe.setCharge(confTrackSelection1.chargeAbs.value, confTrackSelection1.chargeAbs.value, confTrackSelection1.chargeAbs.value); @@ -123,8 +124,8 @@ class TripletTrackTrackTrackBuilder mCtrMe.init(registry, cprHistSpec, confCtr, confTrackSelection1.chargeAbs.value, confTrackSelection1.chargeAbs.value, confTrackSelection1.chargeAbs.value); } else if (mTrack1Track2AreSameSpecies) { // Track1 & Track2 & are the same particle species and track 3 is something else - mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); - mTrackHistManager3.template init(registry, trackHistSpec3, confTrackSelection3); + mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); + mTrackHistManager3.template init(registry, trackHistSpec3, confTrackSelection3); mTripletHistManagerSe.setMass(confTrackSelection1.pdgCodeAbs.value, confTrackSelection1.pdgCodeAbs.value, confTrackSelection3.pdgCodeAbs.value); mTripletHistManagerSe.setCharge(confTrackSelection1.chargeAbs.value, confTrackSelection1.chargeAbs.value, confTrackSelection3.chargeAbs.value); @@ -135,9 +136,9 @@ class TripletTrackTrackTrackBuilder mCtrMe.init(registry, cprHistSpec, confCtr, confTrackSelection1.chargeAbs.value, confTrackSelection1.chargeAbs.value, confTrackSelection3.chargeAbs.value); } else { // all three tracks are different - mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); - mTrackHistManager2.template init(registry, trackHistSpec2, confTrackSelection2); - mTrackHistManager3.template init(registry, trackHistSpec3, confTrackSelection3); + mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); + mTrackHistManager2.template init(registry, trackHistSpec2, confTrackSelection2); + mTrackHistManager3.template init(registry, trackHistSpec3, confTrackSelection3); mTripletHistManagerSe.setMass(confTrackSelection1.pdgCodeAbs.value, confTrackSelection2.pdgCodeAbs.value, confTrackSelection3.pdgCodeAbs.value); mTripletHistManagerSe.setCharge(confTrackSelection1.chargeAbs.value, confTrackSelection2.chargeAbs.value, confTrackSelection3.chargeAbs.value); @@ -389,7 +390,8 @@ class TripletTrackTrackV0Builder TripletTrackTrackV0Builder() = default; ~TripletTrackTrackV0Builder() = default; - template (registry, colHistSpec, confCollisionBinning); - mTripletHistManagerSe.template init(registry, tripletHistSpec, confTripletBinning, confTripletCuts); - mTripletHistManagerMe.template init(registry, tripletHistSpec, confTripletBinning, confTripletCuts); + mColHistManager.template init(registry, colHistSpec, confCollisionBinning); + mTripletHistManagerSe.template init(registry, tripletHistSpec, confTripletBinning, confTripletCuts, confMixing); + mTripletHistManagerMe.template init(registry, tripletHistSpec, confTripletBinning, confTripletCuts, confMixing); - mTc.template init(confTripletCuts); + mTc.template init(confTripletCuts); if (mTrack1Track2AreSameSpecies) { // Track1 & Track2 & are the same particle species and track 3 is something else - mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); - mV0HistManager.template init(registry, v0histSpec, confV0Selection, posDauhistSpec, negDauhistSpec); + mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); + mV0HistManager.template init(registry, v0histSpec, confV0Selection, posDauhistSpec, negDauhistSpec); mTripletHistManagerSe.setMass(confTrackSelection1.pdgCodeAbs.value, confTrackSelection1.pdgCodeAbs.value, confV0Selection.pdgCodeAbs.value); mTripletHistManagerSe.setCharge(confTrackSelection1.chargeAbs.value, confTrackSelection1.chargeAbs.value, 1); @@ -447,9 +449,9 @@ class TripletTrackTrackV0Builder mCtrMe.init(registry, ctrHistSpec, confCtr, confTrackSelection1.chargeAbs.value, confTrackSelection1.chargeAbs.value); } else { // all three tracks are different - mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); - mTrackHistManager2.template init(registry, trackHistSpec2, confTrackSelection2); - mV0HistManager.template init(registry, v0histSpec, confV0Selection, posDauhistSpec, negDauhistSpec); + mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); + mTrackHistManager2.template init(registry, trackHistSpec2, confTrackSelection2); + mV0HistManager.template init(registry, v0histSpec, confV0Selection, posDauhistSpec, negDauhistSpec); mTripletHistManagerSe.setMass(confTrackSelection1.pdgCodeAbs.value, confTrackSelection2.pdgCodeAbs.value, confV0Selection.pdgCodeAbs.value); mTripletHistManagerSe.setCharge(confTrackSelection1.chargeAbs.value, confTrackSelection2.chargeAbs.value, 1); @@ -650,7 +652,8 @@ class TripletTrackTrackCascadeBuilder TripletTrackTrackCascadeBuilder() = default; ~TripletTrackTrackCascadeBuilder() = default; - template (registry, colHistSpec, confCollisionBinning); - mTripletHistManagerSe.template init(registry, tripletHistSpec, confTripletBinning, confTripletCuts); - mTripletHistManagerMe.template init(registry, tripletHistSpec, confTripletBinning, confTripletCuts); + mColHistManager.template init(registry, colHistSpec, confCollisionBinning); + mTripletHistManagerSe.template init(registry, tripletHistSpec, confTripletBinning, confTripletCuts, confMixing); + mTripletHistManagerMe.template init(registry, tripletHistSpec, confTripletBinning, confTripletCuts, confMixing); - mTc.template init(confTripletCuts); + mTc.template init(confTripletCuts); if (mTrack1Track2AreSameSpecies) { // Track1 & Track2 & are the same particle species and track 3 is something else - mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); - mCascadeHistManager.template init(registry, cascadeHistSpec, confCascadeSelection, bachelorHistSpec, posDauHistSpec, negDauHistSpec); + mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); + mCascadeHistManager.template init(registry, cascadeHistSpec, confCascadeSelection, bachelorHistSpec, posDauHistSpec, negDauHistSpec); mTrackCleaner.init(confTrackCleaner); mCascadeCleaner.init(confCascadeCleaner); mTripletHistManagerSe.setMass(confTrackSelection1.pdgCodeAbs.value, confTrackSelection1.pdgCodeAbs.value, confCascadeSelection.pdgCodeAbs.value); @@ -721,9 +724,9 @@ class TripletTrackTrackCascadeBuilder mCtrMe.init(registry, ctrHistSpec, cprHistSpecBachelor, cprHistSpecV0Daughter, confCtr, confCprBachelor, confCprV0Daughter, confTrackSelection1.chargeAbs.value, confTrackSelection1.chargeAbs.value); } else { // all three tracks are different - mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); - mTrackHistManager2.template init(registry, trackHistSpec2, confTrackSelection2); - mCascadeHistManager.template init(registry, cascadeHistSpec, confCascadeSelection, bachelorHistSpec, posDauHistSpec, negDauHistSpec); + mTrackHistManager1.template init(registry, trackHistSpec1, confTrackSelection1); + mTrackHistManager2.template init(registry, trackHistSpec2, confTrackSelection2); + mCascadeHistManager.template init(registry, cascadeHistSpec, confCascadeSelection, bachelorHistSpec, posDauHistSpec, negDauHistSpec); mTripletHistManagerSe.setMass(confTrackSelection1.pdgCodeAbs.value, confTrackSelection2.pdgCodeAbs.value, confCascadeSelection.pdgCodeAbs.value); mTripletHistManagerSe.setCharge(confTrackSelection1.chargeAbs.value, confTrackSelection2.chargeAbs.value, 1); diff --git a/PWGCF/Femto/Core/tripletHistManager.h b/PWGCF/Femto/Core/tripletHistManager.h index 4ccaea86a9a..47c1cce83ed 100644 --- a/PWGCF/Femto/Core/tripletHistManager.h +++ b/PWGCF/Femto/Core/tripletHistManager.h @@ -33,6 +33,7 @@ #include #include #include +#include #include namespace o2::analysis::femto @@ -69,6 +70,13 @@ enum TripletHist { kTrueMultVsMult, kTrueCentVsCent, + // mixing qa + kSeNpart1VsNpart2VsNpart3, // unique particles 1,2,3 in each same event + kMeMixingWindowRaw, // mixing window size + kMeMixingWindowEffective, // mixing window size, counting event triplets with particle triplets + kMeNpart1VsNpart2VsNpart3, // unique particles 1,2,3 in each mixed event + kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2VsVtz3VsMult3VsCent3, // correlation of event properties in each mixing bin (super heavy! use with caution) + kTripletHistogramLast }; @@ -90,6 +98,9 @@ struct ConfMixing : o2::framework::ConfigurableGroup { o2::framework::Configurable seed{"seed", -1, "Seed to randomize particle 1/2/3 (if they are identical). Set to negative value to deactivate. Set to 0 to generate unique seed in time."}; o2::framework::Configurable particle123AreSameSpecies{"particle123AreSameSpecies", false, "Particle 1,2 and 3 are of the same species"}; o2::framework::Configurable particle12AreSameSpecies{"particle12AreSameSpecies", false, "Particle 1 and 2 are of the same species"}; + o2::framework::Configurable enablePairCorrelationQa{"enablePairCorrelationQa", true, "Enable triplet-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", {20, -0.5f, 19.5f}, "Binning for particle number correlation in triplets"}; }; struct ConfTripletBinning : o2::framework::ConfigurableGroup { @@ -151,23 +162,34 @@ constexpr std::array, kTripletHistogramLast> {kTrueMtVsMt, o2::framework::HistType::kTH2F, "hTrueMtVsMt", "m_{T,True} vs m_{T}; m_{T,True} (GeV/#it{c}^{2}); m_{T} (GeV/#it{c}^{2})"}, {kTrueMultVsMult, o2::framework::HistType::kTH2F, "hTrueMultVsMult", "Multiplicity_{True} vs Multiplicity; Multiplicity_{True} ; Multiplicity"}, {kTrueCentVsCent, o2::framework::HistType::kTH2F, "hTrueCentVsCent", "Centrality_{True} vs Centrality; Centrality_{True} (%); Centrality (%)"}, + // mixing qa + {kSeNpart1VsNpart2VsNpart3, o2::framework::HistType::kTHnSparseF, "hSeNpart1VsNpart2VsNpart3", "# unique particle 1 vs # unique particle 2 vs # unique particle 3 in each same event; # particle 1; # particle 2; # particle 3;"}, + {kMeMixingWindowRaw, o2::framework::HistType::kTH1F, "hMeMixingWindowRaw", "Raw Mixing Window; Raw Mixing Window; Entries"}, + {kMeMixingWindowEffective, o2::framework::HistType::kTH1F, "hMeMixingWindowEffective", "Effective Mixing Window; Effective Mixing Window; Entries"}, + {kMeNpart1VsNpart2VsNpart3, o2::framework::HistType::kTHnSparseF, "hMeNpart1VsNpart2VsNpart3", "# unique particle 1 vs # unique particle 2 vs # unique particle 3 in each mixing bin; # particle 1; # particle 2; # particle 3;"}, + {kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2VsVtz3VsMult3VsCent3, o2::framework::HistType::kTHnSparseF, "hVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2VsVtz3VsMult3VsCent3", "Mixing bins; V_{z,1} (cm); mult_{1}; cent_{1} (%); V_{z,2} (cm); mult_{2}; cent_{2} (%); V_{z,3} (cm); mult_{3}; cent_{3} (%);"}, }}; -#define TRIPLET_HIST_ANALYSIS_MAP(conf) \ - {kQ3, {conf.q3}}, \ - {kMt, {conf.mt}}, \ - {kPt1VsQ3, {conf.pt1, conf.q3}}, \ - {kPt2VsQ3, {conf.pt2, conf.q3}}, \ - {kPt3VsQ3, {conf.pt3, conf.q3}}, \ - {kQ3VsMt, {conf.q3, conf.mt}}, \ - {kQ3VsMult, {conf.q3, conf.multiplicity}}, \ - {kQ3VsCent, {conf.q3, conf.centrality}}, \ - {kPt1VsPt2VsPt3, {conf.pt1, conf.pt2, conf.pt3}}, \ - {kQ3VsPt1VsPt2VsPt3, {conf.q3, conf.pt1, conf.pt2, conf.pt3}}, \ - {kQ3VsMtVsMult, {conf.q3, conf.mt, conf.multiplicity}}, \ - {kQ3VsMtVsMultVsCent, {conf.q3, conf.mt, conf.multiplicity, conf.centrality}}, \ - {kQ3VsMtVsPt1VsPt2VsPt3VsMult, {conf.q3, conf.mt, conf.pt1, conf.pt2, conf.pt3, conf.multiplicity}}, \ - {kQ3VsMtVsPt1VsPt2VsPt3VsMultVsCent, {conf.q3, conf.mt, conf.pt1, conf.pt2, conf.pt3, conf.multiplicity, conf.centrality}}, +#define TRIPLET_HIST_ANALYSIS_MAP(conf, confMixing) \ + {kQ3, {conf.q3}}, \ + {kMt, {conf.mt}}, \ + {kPt1VsQ3, {conf.pt1, conf.q3}}, \ + {kPt2VsQ3, {conf.pt2, conf.q3}}, \ + {kPt3VsQ3, {conf.pt3, conf.q3}}, \ + {kQ3VsMt, {conf.q3, conf.mt}}, \ + {kQ3VsMult, {conf.q3, conf.multiplicity}}, \ + {kQ3VsCent, {conf.q3, conf.centrality}}, \ + {kPt1VsPt2VsPt3, {conf.pt1, conf.pt2, conf.pt3}}, \ + {kQ3VsPt1VsPt2VsPt3, {conf.q3, conf.pt1, conf.pt2, conf.pt3}}, \ + {kQ3VsMtVsMult, {conf.q3, conf.mt, conf.multiplicity}}, \ + {kQ3VsMtVsMultVsCent, {conf.q3, conf.mt, conf.multiplicity, conf.centrality}}, \ + {kQ3VsMtVsPt1VsPt2VsPt3VsMult, {conf.q3, conf.mt, conf.pt1, conf.pt2, conf.pt3, conf.multiplicity}}, \ + {kQ3VsMtVsPt1VsPt2VsPt3VsMultVsCent, {conf.q3, conf.mt, conf.pt1, conf.pt2, conf.pt3, conf.multiplicity, conf.centrality}}, \ + {kSeNpart1VsNpart2VsNpart3, {confMixing.particleBinning, confMixing.particleBinning, confMixing.particleBinning}}, \ + {kMeMixingWindowRaw, {confMixing.particleBinning}}, \ + {kMeMixingWindowEffective, {confMixing.particleBinning}}, \ + {kMeNpart1VsNpart2VsNpart3, {confMixing.particleBinning, confMixing.particleBinning, confMixing.particleBinning}}, \ + {kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2VsVtz3VsMult3VsCent3, {confMixing.vtxBins, confMixing.multBins, confMixing.centBins, confMixing.vtxBins, confMixing.multBins, confMixing.centBins, confMixing.vtxBins, confMixing.multBins, confMixing.centBins}}, #define TRIPLET_HIST_MC_MAP(conf) \ {kTrueQ3VsQ3, {conf.q3, conf.q3}}, \ @@ -175,18 +197,18 @@ constexpr std::array, kTripletHistogramLast> {kTrueMultVsMult, {conf.multiplicity, conf.multiplicity}}, \ {kTrueCentVsCent, {conf.centrality, conf.centrality}}, -template -auto makeTripletHistSpecMap(const T& confPairBinning) +template +auto makeTripletHistSpecMap(T1 const& confPairBinning, T2 const& confMixing) { return std::map>{ - TRIPLET_HIST_ANALYSIS_MAP(confPairBinning)}; + TRIPLET_HIST_ANALYSIS_MAP(confPairBinning, confMixing)}; }; -template -auto makeTripletMcHistSpecMap(const T& confPairBinning) +template +auto makeTripletMcHistSpecMap(T1 const& confPairBinning, T2 const& confMixing) { return std::map>{ - TRIPLET_HIST_ANALYSIS_MAP(confPairBinning) + TRIPLET_HIST_ANALYSIS_MAP(confPairBinning, confMixing) TRIPLET_HIST_MC_MAP(confPairBinning)}; }; @@ -216,11 +238,12 @@ class TripletHistManager TripletHistManager() = default; ~TripletHistManager() = default; - template + template void init(o2::framework::HistogramRegistry* registry, std::map> const& Specs, T1 const& ConfTripletBinning, - T2 const& ConfTripletCuts) + T2 const& ConfTripletCuts, + T3 const& ConfMixing) { mHistogramRegistry = registry; @@ -244,6 +267,9 @@ class TripletHistManager mPlotQ3VsMtVsPt1VsPt2VsPt3VsMult = ConfTripletBinning.plotQ3VsMtVsPt1VsPt2VsPt3VsMult.value; mPlotQ3VsMtVsPt1VsPt2VsPt3VsMultVsCent = ConfTripletBinning.plotQ3VsMtVsPt1VsPt2VsPt3VsMultVsCent.value; + mPairCorrelationQa = ConfMixing.enablePairCorrelationQa.value; + mEventMixingQa = ConfMixing.enableEventMixingQa.value; + if constexpr (isFlagSet(mode, modes::Mode::kAnalysis)) { initAnalysis(Specs); } @@ -251,6 +277,12 @@ class TripletHistManager 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, int PdgParticle3) @@ -385,6 +417,60 @@ class TripletHistManager float getQ3() const { return mQ3; } + template + void trackParticlesPerEvent(T1 const& particle1, T2 const& particle2, T3 const& particle3) + { + if (!mPairCorrelationQa) { + return; + } + mParticles1PerEvent.insert(particle1.globalIndex()); + mParticles2PerEvent.insert(particle2.globalIndex()); + mParticles3PerEvent.insert(particle3.globalIndex()); + } + + template + void fillMixingQaMe(T1 const& col1, T2 const& col2, T3 const& col3) + { + if (mEventMixingQa) { + mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(getHistName(kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2VsVtz3VsMult3VsCent3, HistTable)), + col1.posZ(), col1.mult(), col1.cent(), + col2.posZ(), col2.mult(), col2.cent(), + col3.posZ(), col3.mult(), col3.cent()); + } + } + + void resetTrackedParticlesPerEvent() + { + mParticles1PerEvent.clear(); + mParticles1PerEvent.reserve(100); + mParticles2PerEvent.clear(); + mParticles2PerEvent.reserve(100); + mParticles3PerEvent.clear(); + mParticles3PerEvent.reserve(100); + } + + void fillMixingQaSe() + { + if (mPairCorrelationQa) { + mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(getHistName(kSeNpart1VsNpart2VsNpart3, HistTable)), mParticles1PerEvent.size(), mParticles2PerEvent.size(), mParticles3PerEvent.size()); + } + } + + void fillMixingQaMePerEvent() + { + if (mPairCorrelationQa) { + mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(getHistName(kMeNpart1VsNpart2VsNpart3, HistTable)), mParticles1PerEvent.size(), mParticles2PerEvent.size(), mParticles3PerEvent.size()); + } + } + + void fillMixingQaMePerMixingBin(int windowSizeRaw, int windowSizeEffective) + { + if (mPairCorrelationQa) { + mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(getHistName(kMeMixingWindowRaw, HistTable)), windowSizeRaw); + mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(getHistName(kMeMixingWindowEffective, HistTable)), windowSizeEffective); + } + } + private: ROOT::Math::PxPyPzEVector getqij(ROOT::Math::PxPyPzEVector const& vi, ROOT::Math::PxPyPzEVector const& vj) { @@ -454,6 +540,27 @@ class TripletHistManager mHistogramRegistry->add(mcDir + getHistNameV2(kTrueCentVsCent, HistTable), getHistDesc(kTrueCentVsCent, HistTable), getHistType(kTrueCentVsCent, HistTable), {Specs.at(kTrueCentVsCent)}); } + void initSeMixingQa(std::map> const& Specs) + { + std::string dir = std::string(prefix) + std::string(QaDir); + if (mPairCorrelationQa) { + mHistogramRegistry->add(dir + getHistNameV2(kSeNpart1VsNpart2VsNpart3, HistTable), getHistDesc(kSeNpart1VsNpart2VsNpart3, HistTable), getHistType(kSeNpart1VsNpart2VsNpart3, HistTable), {Specs.at(kSeNpart1VsNpart2VsNpart3)}); + } + } + + void initMeMixingQa(std::map> const& Specs) + { + std::string dir = std::string(prefix) + std::string(QaDir); + if (mPairCorrelationQa) { + mHistogramRegistry->add(dir + getHistNameV2(kMeMixingWindowRaw, HistTable), getHistDesc(kMeMixingWindowRaw, HistTable), getHistType(kMeMixingWindowRaw, HistTable), {Specs.at(kMeMixingWindowRaw)}); + mHistogramRegistry->add(dir + getHistNameV2(kMeMixingWindowEffective, HistTable), getHistDesc(kMeMixingWindowEffective, HistTable), getHistType(kMeMixingWindowEffective, HistTable), {Specs.at(kMeMixingWindowEffective)}); + mHistogramRegistry->add(dir + getHistNameV2(kMeNpart1VsNpart2VsNpart3, HistTable), getHistDesc(kMeNpart1VsNpart2VsNpart3, HistTable), getHistType(kMeNpart1VsNpart2VsNpart3, HistTable), {Specs.at(kMeNpart1VsNpart2VsNpart3)}); + } + if (mEventMixingQa) { + mHistogramRegistry->add(dir + getHistNameV2(kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2VsVtz3VsMult3VsCent3, HistTable), getHistDesc(kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2VsVtz3VsMult3VsCent3, HistTable), getHistType(kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2VsVtz3VsMult3VsCent3, HistTable), {Specs.at(kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2VsVtz3VsMult3VsCent3)}); + } + } + void fillAnalysis() { if (mPlot1d) { @@ -578,6 +685,14 @@ class TripletHistManager bool mPlotQ3VsMtVsMultVsCent = false; bool mPlotQ3VsMtVsPt1VsPt2VsPt3VsMult = false; bool mPlotQ3VsMtVsPt1VsPt2VsPt3VsMultVsCent = false; + + // mixing qa + bool mPairCorrelationQa = false; + bool mEventMixingQa = false; + + std::unordered_set mParticles1PerEvent = {}; + std::unordered_set mParticles2PerEvent = {}; + std::unordered_set mParticles3PerEvent = {}; }; } // namespace triplethistmanager diff --git a/PWGCF/Femto/Core/tripletProcessHelpers.h b/PWGCF/Femto/Core/tripletProcessHelpers.h index 76f5ded7447..8c81fb3d4e5 100644 --- a/PWGCF/Femto/Core/tripletProcessHelpers.h +++ b/PWGCF/Femto/Core/tripletProcessHelpers.h @@ -20,6 +20,7 @@ #include "PWGCF/Femto/DataModel/FemtoTables.h" #include +#include #include @@ -53,6 +54,8 @@ void processSameEvent(T1 const& SliceParticle, T7& TcManager, TripletOrder tripletOrder) { + TripletHistManager.resetTrackedParticlesPerEvent(); + for (auto const& part : SliceParticle) { ParticleHistManager.template fill(part, TrackTable); } @@ -95,8 +98,11 @@ void processSameEvent(T1 const& SliceParticle, // if triplet cuts are configured check them before filling if (TripletHistManager.checkTripletCuts()) { TripletHistManager.template fill(); + TripletHistManager.trackParticlesPerEvent(p1, p2, p3); } } + + TripletHistManager.fillMixingQaSe(); } // process same event for identical 2 particles and 1 other particle @@ -114,6 +120,8 @@ void processSameEvent(T1 const& SliceParticle1, // 1&2 have same species T9& TcManager, TripletOrder tripletOrder) { + TripletHistManager.resetTrackedParticlesPerEvent(); + for (auto const& part : SliceParticle1) { ParticleHistManager1.template fill(part, TrackTable); } @@ -153,9 +161,12 @@ void processSameEvent(T1 const& SliceParticle1, // 1&2 have same species // if triplet cuts are configured check them before filling if (TripletHistManager.checkTripletCuts()) { TripletHistManager.template fill(); + TripletHistManager.trackParticlesPerEvent(p1, p2, p3); } } } + + TripletHistManager.fillMixingQaSe(); } // process same event for 3 different particles @@ -183,6 +194,8 @@ void processSameEvent(T1 const& SliceParticle1, T10& CtrManager, T11& TcManager) { + TripletHistManager.resetTrackedParticlesPerEvent(); + for (auto const& part : SliceParticle1) { ParticleHistManager1.template fill(part, TrackTable); } @@ -214,8 +227,11 @@ void processSameEvent(T1 const& SliceParticle1, // if triplet cuts are configured check them before filling if (TripletHistManager.checkTripletCuts()) { TripletHistManager.template fill(); + TripletHistManager.trackParticlesPerEvent(p1, p2, p3); } } + + TripletHistManager.fillMixingQaSe(); } // process same event for 3 identical particles with mc information @@ -244,9 +260,12 @@ void processSameEvent(T1 const& SliceParticle, T11& TcManager, TripletOrder tripletOrder) { + TripletHistManager.resetTrackedParticlesPerEvent(); + for (auto const& part : SliceParticle) { ParticleHistManager.template fill(part, TrackTable, mcParticles, mcMothers, mcPartonicMothers); } + for (auto const& [p1, p2, p3] : o2::soa::combinations(o2::soa::CombinationsStrictlyUpperIndexPolicy(SliceParticle, SliceParticle, SliceParticle))) { // check if triplet is clean if (!TcManager.isCleanTriplet(p1, p2, p3, TrackTable, mcPartonicMothers)) { @@ -280,8 +299,11 @@ void processSameEvent(T1 const& SliceParticle, // if triplet cuts are configured check them before filling if (TripletHistManager.checkTripletCuts()) { TripletHistManager.template fill(); + TripletHistManager.trackParticlesPerEvent(p1, p2, p3); } } + + TripletHistManager.fillMixingQaSe(); } // process same event for 2 identical particles and one other with mc information @@ -303,6 +325,8 @@ void processSameEvent(T1 const& SliceParticle1, T13& TcManager, TripletOrder tripletOrder) { + TripletHistManager.resetTrackedParticlesPerEvent(); + for (auto const& part : SliceParticle1) { ParticleHistManager1.template fill(part, TrackTable, mcParticles, mcMothers, mcPartonicMothers); } @@ -337,9 +361,12 @@ void processSameEvent(T1 const& SliceParticle1, // if triplet cuts are configured check them before filling if (TripletHistManager.checkTripletCuts()) { TripletHistManager.template fill(); + TripletHistManager.trackParticlesPerEvent(p1, p2, p3); } } } + + TripletHistManager.fillMixingQaSe(); } // process same event for 3 different particles with mc information @@ -375,6 +402,8 @@ void processSameEvent(T1 const& SliceParticle1, T14& CtrManager, T15& TcManager) { + TripletHistManager.resetTrackedParticlesPerEvent(); + for (auto const& part : SliceParticle1) { ParticleHistManager1.template fill(part, TrackTable, mcParticles, mcMothers, mcPartonicMothers); } @@ -384,6 +413,7 @@ void processSameEvent(T1 const& SliceParticle1, for (auto const& part : SliceParticle3) { ParticleHistManager3.template fill(part, TrackTable, mcParticles, mcMothers, mcPartonicMothers); } + for (auto const& [p1, p2, p3] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(SliceParticle1, SliceParticle2, SliceParticle3))) { // check if triplet is clean if (!TcManager.isCleanTriplet(p1, p2, p3, TrackTable, mcPartonicMothers)) { @@ -400,8 +430,11 @@ void processSameEvent(T1 const& SliceParticle1, // if triplet cuts are configured check them before filling if (TripletHistManager.checkTripletCuts()) { TripletHistManager.template fill(); + TripletHistManager.trackParticlesPerEvent(p1, p2, p3); } } + + TripletHistManager.fillMixingQaSe(); } // process mixed event @@ -429,19 +462,47 @@ void processMixedEvent(T1 const& Collisions, T10& CtrManager, T11& TcManager) { + int64_t lastCollisionIndex = -1; + int windowSizeRaw = 0; + int windowSizeEffective = 0; + for (auto const& [collision1, collision2, collision3] : o2::soa::selfCombinations(policy, depth, -1, Collisions, Collisions, Collisions)) { + + // --- new window --- + if (collision1.globalIndex() != lastCollisionIndex) { + if (lastCollisionIndex != -1) { + TripletHistManager.fillMixingQaMePerMixingBin(windowSizeRaw, windowSizeEffective); + } + windowSizeRaw = 0; + windowSizeEffective = 0; + lastCollisionIndex = collision1.globalIndex(); + } + + ++windowSizeRaw; + if (collision1.magField() != collision2.magField() || collision2.magField() != collision3.magField() || collision1.magField() != collision3.magField()) { + LOG(warn) << "Tried mixing events with different magnetic field."; continue; } + CtrManager.setMagField(collision1.magField()); + auto sliceParticle1 = Partition1->sliceByCached(o2::aod::femtobase::stored::fColId, collision1.globalIndex(), cache); auto sliceParticle2 = Partition2->sliceByCached(o2::aod::femtobase::stored::fColId, collision2.globalIndex(), cache); auto sliceParticle3 = Partition3->sliceByCached(o2::aod::femtobase::stored::fColId, collision3.globalIndex(), cache); + + TripletHistManager.resetTrackedParticlesPerEvent(); + if (sliceParticle1.size() == 0 || sliceParticle2.size() == 0 || sliceParticle3.size() == 0) { + TripletHistManager.fillMixingQaMePerEvent(); continue; } + + bool hasValidTriplet = false; + TripletHistManager.fillMixingQaMe(collision1, collision2, collision3); + for (auto const& [p1, p2, p3] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(sliceParticle1, sliceParticle2, sliceParticle3))) { // pair cleaning if (!TcManager.isCleanTriplet(p1, p2, p3, TrackTable)) { @@ -452,12 +513,27 @@ void processMixedEvent(T1 const& Collisions, if (CtrManager.isCloseTriplet()) { continue; } + TripletHistManager.setTriplet(p1, p2, p3, collision1, collision2, collision3); CtrManager.fill(TripletHistManager.getQ3()); + if (TripletHistManager.checkTripletCuts()) { + hasValidTriplet = true; + TripletHistManager.trackParticlesPerEvent(p1, p2, p3); TripletHistManager.template fill(); } } + + if (hasValidTriplet) { + ++windowSizeEffective; + } + + TripletHistManager.fillMixingQaMePerEvent(); + } + + // --- final window --- + if (windowSizeRaw > 0) { + TripletHistManager.fillMixingQaMePerMixingBin(windowSizeRaw, windowSizeEffective); } } @@ -490,19 +566,46 @@ void processMixedEvent(T1 const& Collisions, T12& CtrManager, T13& TcManager) { + int64_t lastCollisionIndex = -1; + int windowSizeRaw = 0; + int windowSizeEffective = 0; + for (auto const& [collision1, collision2, collision3] : o2::soa::selfCombinations(policy, depth, -1, Collisions, Collisions, Collisions)) { + + if (collision1.globalIndex() != lastCollisionIndex) { + if (lastCollisionIndex != -1) { + TripletHistManager.fillMixingQaMePerMixingBin(windowSizeRaw, windowSizeEffective); + } + windowSizeRaw = 0; + windowSizeEffective = 0; + lastCollisionIndex = collision1.globalIndex(); + } + + ++windowSizeRaw; + if (collision1.magField() != collision2.magField() || collision2.magField() != collision3.magField() || collision1.magField() != collision3.magField()) { + LOG(warn) << "Tried mixing events with different magnetic field."; continue; } + CtrManager.setMagField(collision1.magField()); + auto sliceParticle1 = Partition1->sliceByCached(o2::aod::femtobase::stored::fColId, collision1.globalIndex(), cache); auto sliceParticle2 = Partition2->sliceByCached(o2::aod::femtobase::stored::fColId, collision2.globalIndex(), cache); auto sliceParticle3 = Partition3->sliceByCached(o2::aod::femtobase::stored::fColId, collision3.globalIndex(), cache); + + TripletHistManager.resetTrackedParticlesPerEvent(); + if (sliceParticle1.size() == 0 || sliceParticle2.size() == 0 || sliceParticle3.size() == 0) { + TripletHistManager.fillMixingQaMePerEvent(); continue; } + + bool hasValidTriplet = false; + TripletHistManager.fillMixingQaMe(collision1, collision2, collision3); + for (auto const& [p1, p2, p3] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(sliceParticle1, sliceParticle2, sliceParticle3))) { // pair cleaning if (!TcManager.isCleanTriplet(p1, p2, p3, TrackTable)) { @@ -513,12 +616,26 @@ void processMixedEvent(T1 const& Collisions, if (CtrManager.isCloseTriplet()) { continue; } + TripletHistManager.setTripletMc(p1, p2, p3, mcParticles, collision1, collision2, collision3, mcCollisions); CtrManager.fill(TripletHistManager.getQ3()); + if (TripletHistManager.checkTripletCuts()) { + hasValidTriplet = true; + TripletHistManager.trackParticlesPerEvent(p1, p2, p3); TripletHistManager.template fill(); } } + + if (hasValidTriplet) { + ++windowSizeEffective; + } + + TripletHistManager.fillMixingQaMePerEvent(); + } + + if (windowSizeRaw > 0) { + TripletHistManager.fillMixingQaMePerMixingBin(windowSizeRaw, windowSizeEffective); } } diff --git a/PWGCF/Femto/Tasks/femtoTripletTrackTrackCascade.cxx b/PWGCF/Femto/Tasks/femtoTripletTrackTrackCascade.cxx index ae9f0ca2783..8da8a4daa0c 100644 --- a/PWGCF/Femto/Tasks/femtoTripletTrackTrackCascade.cxx +++ b/PWGCF/Femto/Tasks/femtoTripletTrackTrackCascade.cxx @@ -223,14 +223,14 @@ struct FemtoTripletTrackTrackCascade { bachelorHistSpec = trackhistmanager::makeTrackHistSpecMap(confBachelorBinning); posDauSpec = trackhistmanager::makeTrackHistSpecMap(confPosDauBinning); negDauSpec = trackhistmanager::makeTrackHistSpecMap(confNegDauBinning); - tripletTrackTrackCascadeHistSpec = triplethistmanager::makeTripletHistSpecMap(confTripletBinning); + tripletTrackTrackCascadeHistSpec = triplethistmanager::makeTripletHistSpecMap(confTripletBinning, confMixing); if (processXi) { xiHistSpec = cascadehistmanager::makeCascadeHistSpecMap(confXiBinning); - tripletTrackTrackXiBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confTrackCleaner1, confCtr, confXiSelection, confXiCleaner, confCprBachelor, confCprV0Daughter, confMixing, confTripletBinning, confTripletCuts, colHistSpec, trackHistSpec1, trackHistSpec2, xiHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, tripletTrackTrackCascadeHistSpec, cprHistSpecBachelor, cprHistSpecV0Daughter, ctrHistSpec); + tripletTrackTrackXiBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confTrackCleaner1, confCtr, confXiSelection, confXiCleaner, confCprBachelor, confCprV0Daughter, confMixing, confTripletBinning, confTripletCuts, colHistSpec, trackHistSpec1, trackHistSpec2, xiHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, tripletTrackTrackCascadeHistSpec, cprHistSpecBachelor, cprHistSpecV0Daughter, ctrHistSpec); } else { omegaHistSpec = cascadehistmanager::makeCascadeHistSpecMap(confOmegaBinning); - tripletTrackTrackOmegaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confTrackCleaner1, confCtr, confOmegaSelection, confOmegaCleaner, confCprBachelor, confCprV0Daughter, confMixing, confTripletBinning, confTripletCuts, colHistSpec, trackHistSpec1, trackHistSpec2, omegaHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, tripletTrackTrackCascadeHistSpec, cprHistSpecBachelor, cprHistSpecV0Daughter, ctrHistSpec); + tripletTrackTrackOmegaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confTrackCleaner1, confCtr, confOmegaSelection, confOmegaCleaner, confCprBachelor, confCprV0Daughter, confMixing, confTripletBinning, confTripletCuts, colHistSpec, trackHistSpec1, trackHistSpec2, omegaHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, tripletTrackTrackCascadeHistSpec, cprHistSpecBachelor, cprHistSpecV0Daughter, ctrHistSpec); } } else { colHistSpec = colhistmanager::makeColMcHistSpecMap(confCollisionBinning); @@ -239,13 +239,13 @@ struct FemtoTripletTrackTrackCascade { bachelorHistSpec = trackhistmanager::makeTrackMcHistSpecMap(confBachelorBinning); posDauSpec = trackhistmanager::makeTrackMcHistSpecMap(confPosDauBinning); negDauSpec = trackhistmanager::makeTrackMcHistSpecMap(confNegDauBinning); - tripletTrackTrackCascadeHistSpec = triplethistmanager::makeTripletMcHistSpecMap(confTripletBinning); + tripletTrackTrackCascadeHistSpec = triplethistmanager::makeTripletMcHistSpecMap(confTripletBinning, confMixing); if (processXi) { xiHistSpec = cascadehistmanager::makeCascadeMcHistSpecMap(confXiBinning); - tripletTrackTrackXiBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confTrackCleaner1, confCtr, confXiSelection, confXiCleaner, confCprBachelor, confCprV0Daughter, confMixing, confTripletBinning, confTripletCuts, colHistSpec, trackHistSpec1, trackHistSpec2, xiHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, tripletTrackTrackCascadeHistSpec, cprHistSpecBachelor, cprHistSpecV0Daughter, ctrHistSpec); + tripletTrackTrackXiBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confTrackCleaner1, confCtr, confXiSelection, confXiCleaner, confCprBachelor, confCprV0Daughter, confMixing, confTripletBinning, confTripletCuts, colHistSpec, trackHistSpec1, trackHistSpec2, xiHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, tripletTrackTrackCascadeHistSpec, cprHistSpecBachelor, cprHistSpecV0Daughter, ctrHistSpec); } else { omegaHistSpec = cascadehistmanager::makeCascadeMcHistSpecMap(confOmegaBinning); - tripletTrackTrackOmegaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confTrackCleaner1, confCtr, confOmegaSelection, confOmegaCleaner, confCprBachelor, confCprV0Daughter, confMixing, confTripletBinning, confTripletCuts, colHistSpec, trackHistSpec1, trackHistSpec2, omegaHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, tripletTrackTrackCascadeHistSpec, cprHistSpecBachelor, cprHistSpecV0Daughter, ctrHistSpec); + tripletTrackTrackOmegaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confTrackCleaner1, confCtr, confOmegaSelection, confOmegaCleaner, confCprBachelor, confCprV0Daughter, confMixing, confTripletBinning, confTripletCuts, colHistSpec, trackHistSpec1, trackHistSpec2, omegaHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, tripletTrackTrackCascadeHistSpec, cprHistSpecBachelor, cprHistSpecV0Daughter, ctrHistSpec); } } hRegistry.print(); @@ -253,49 +253,49 @@ struct FemtoTripletTrackTrackCascade { void processXiSameEvent(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoXis const& /*xis*/) { - tripletTrackTrackXiBuilder.processSameEvent(col, tracks, trackPartition1, trackPartition2, xiPartition, cache); + tripletTrackTrackXiBuilder.processSameEvent(col, tracks, trackPartition1, trackPartition2, xiPartition, cache); } PROCESS_SWITCH(FemtoTripletTrackTrackCascade, 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) { - tripletTrackTrackXiBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, xiWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); + tripletTrackTrackXiBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, xiWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); } PROCESS_SWITCH(FemtoTripletTrackTrackCascade, 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*/) { - tripletTrackTrackXiBuilder.processMixedEvent(cols, tracks, trackPartition1, trackPartition2, xiPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + tripletTrackTrackXiBuilder.processMixedEvent(cols, tracks, trackPartition1, trackPartition2, xiPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoTripletTrackTrackCascade, 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*/) { - tripletTrackTrackXiBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, xiWithLabelPartition, mcParticles, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + tripletTrackTrackXiBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, xiWithLabelPartition, mcParticles, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoTripletTrackTrackCascade, processXiMixedEventMc, "Enable processing mixed event processing for tracks and xis with mc information", false); void processOmegaSameEvent(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoOmegas const& /*omega*/) { - tripletTrackTrackOmegaBuilder.processSameEvent(col, tracks, trackPartition1, trackPartition2, omegaPartition, cache); + tripletTrackTrackOmegaBuilder.processSameEvent(col, tracks, trackPartition1, trackPartition2, omegaPartition, cache); } PROCESS_SWITCH(FemtoTripletTrackTrackCascade, 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) { - tripletTrackTrackOmegaBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, omegaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); + tripletTrackTrackOmegaBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, omegaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); } PROCESS_SWITCH(FemtoTripletTrackTrackCascade, 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*/) { - tripletTrackTrackOmegaBuilder.processMixedEvent(cols, tracks, trackPartition1, trackPartition2, omegaPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + tripletTrackTrackOmegaBuilder.processMixedEvent(cols, tracks, trackPartition1, trackPartition2, omegaPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoTripletTrackTrackCascade, 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*/) { - tripletTrackTrackOmegaBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, omegaWithLabelPartition, mcParticles, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + tripletTrackTrackOmegaBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, omegaWithLabelPartition, mcParticles, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoTripletTrackTrackCascade, processOmegaMixedEventMc, "Enable processing mixed event processing for tracks and omegas with mc information", false); }; diff --git a/PWGCF/Femto/Tasks/femtoTripletTrackTrackTrack.cxx b/PWGCF/Femto/Tasks/femtoTripletTrackTrackTrack.cxx index 05dcdd5b153..7a9bab7b357 100644 --- a/PWGCF/Femto/Tasks/femtoTripletTrackTrackTrack.cxx +++ b/PWGCF/Femto/Tasks/femtoTripletTrackTrackTrack.cxx @@ -144,40 +144,40 @@ struct FemtoTripletTrackTrackTrack { trackHistSpec1 = trackhistmanager::makeTrackHistSpecMap(confTrackBinning1); trackHistSpec2 = trackhistmanager::makeTrackHistSpecMap(confTrackBinning2); trackHistSpec3 = trackhistmanager::makeTrackHistSpecMap(confTrackBinning3); - tripletHistSpec = triplethistmanager::makeTripletHistSpecMap(confTripletBinning); - tripletTrackTrackTrackBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confTrackSelections3, confCtr, confMixing, confTripletBinning, confTripletCuts, colHistSpec, trackHistSpec1, trackHistSpec2, trackHistSpec3, tripletHistSpec, ctrHistSpec); + tripletHistSpec = triplethistmanager::makeTripletHistSpecMap(confTripletBinning, confMixing); + tripletTrackTrackTrackBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confTrackSelections3, confCtr, confMixing, confTripletBinning, confTripletCuts, colHistSpec, trackHistSpec1, trackHistSpec2, trackHistSpec3, tripletHistSpec, ctrHistSpec); } else { colHistSpec = colhistmanager::makeColMcHistSpecMap(confCollisionBinning); trackHistSpec1 = trackhistmanager::makeTrackMcHistSpecMap(confTrackBinning1); trackHistSpec2 = trackhistmanager::makeTrackMcHistSpecMap(confTrackBinning2); trackHistSpec3 = trackhistmanager::makeTrackMcHistSpecMap(confTrackBinning3); - tripletHistSpec = triplethistmanager::makeTripletMcHistSpecMap(confTripletBinning); - tripletTrackTrackTrackBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confTrackSelections3, confCtr, confMixing, confTripletBinning, confTripletCuts, colHistSpec, trackHistSpec1, trackHistSpec2, trackHistSpec3, tripletHistSpec, ctrHistSpec); + tripletHistSpec = triplethistmanager::makeTripletMcHistSpecMap(confTripletBinning, confMixing); + tripletTrackTrackTrackBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confTrackSelections3, confCtr, confMixing, confTripletBinning, confTripletCuts, colHistSpec, trackHistSpec1, trackHistSpec2, trackHistSpec3, tripletHistSpec, ctrHistSpec); } hRegistry.print(); }; void processSameEvent(FilteredFemtoCollision const& col, FemtoTracks const& tracks) { - tripletTrackTrackTrackBuilder.processSameEvent(col, tracks, trackPartition1, trackPartition2, trackPartition3, cache); + tripletTrackTrackTrackBuilder.processSameEvent(col, tracks, trackPartition1, trackPartition2, trackPartition3, cache); } PROCESS_SWITCH(FemtoTripletTrackTrackTrack, processSameEvent, "Enable processing same event processing", true); 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) { - tripletTrackTrackTrackBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, trackWithLabelPartition3, mcParticles, mcMothers, mcPartonicMothers, cache); + tripletTrackTrackTrackBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, trackWithLabelPartition3, mcParticles, mcMothers, mcPartonicMothers, cache); } PROCESS_SWITCH(FemtoTripletTrackTrackTrack, processSameEventMc, "Enable processing same event processing", false); void processMixedEvent(FilteredFemtoCollisions const& cols, FemtoTracks const& tracks) { - tripletTrackTrackTrackBuilder.processMixedEvent(cols, tracks, trackPartition1, trackPartition2, trackPartition3, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + tripletTrackTrackTrackBuilder.processMixedEvent(cols, tracks, trackPartition1, trackPartition2, trackPartition3, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoTripletTrackTrackTrack, processMixedEvent, "Enable processing mixed event processing", true); void processMixedEventMc(FilteredFemtoCollisionsWithLabel const& cols, o2::aod::FMcCols const& mcCols, FemtoTracksWithLabel const& tracks, o2::aod::FMcParticles const& mcParticles) { - tripletTrackTrackTrackBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, trackWithLabelPartition3, mcParticles, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + tripletTrackTrackTrackBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, trackWithLabelPartition3, mcParticles, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoTripletTrackTrackTrack, processMixedEventMc, "Enable processing mixed event processing", false); }; diff --git a/PWGCF/Femto/Tasks/femtoTripletTrackTrackV0.cxx b/PWGCF/Femto/Tasks/femtoTripletTrackTrackV0.cxx index 9c4f5e1cf1b..6913ef69e97 100644 --- a/PWGCF/Femto/Tasks/femtoTripletTrackTrackV0.cxx +++ b/PWGCF/Femto/Tasks/femtoTripletTrackTrackV0.cxx @@ -1,4 +1,4 @@ -// Copyright 2019-2025 CERN and copyright holders of ALICE O2. +// Copyright 2019-2025 CERN and copyright holders of ALICE O2.tracktrackv // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. // All rights not expressly granted are reserved. // @@ -168,8 +168,8 @@ struct FemtoTripletTrackTrackV0 { lambdaHistSpec = v0histmanager::makeV0HistSpecMap(confLambdaBinning); posDauSpec = trackhistmanager::makeTrackHistSpecMap(confPosDauBinning); negDauSpec = trackhistmanager::makeTrackHistSpecMap(confNegDauBinning); - tripletHistSpec = triplethistmanager::makeTripletHistSpecMap(confTripletBinning); - tripletTrackTrackLambdaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confLambdaSelection, confCtr, confMixing, confTripletBinning, confTripletCuts, colHistSpec, trackHistSpec1, trackHistSpec2, lambdaHistSpec, posDauSpec, negDauSpec, tripletHistSpec, ctrHistSpec); + tripletHistSpec = triplethistmanager::makeTripletHistSpecMap(confTripletBinning, confMixing); + tripletTrackTrackLambdaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confLambdaSelection, confCtr, confMixing, confTripletBinning, confTripletCuts, colHistSpec, trackHistSpec1, trackHistSpec2, lambdaHistSpec, posDauSpec, negDauSpec, tripletHistSpec, ctrHistSpec); } else { colHistSpec = colhistmanager::makeColMcHistSpecMap(confCollisionBinning); trackHistSpec1 = trackhistmanager::makeTrackMcHistSpecMap(confTrackBinning1); @@ -177,33 +177,33 @@ struct FemtoTripletTrackTrackV0 { lambdaHistSpec = v0histmanager::makeV0McHistSpecMap(confLambdaBinning); posDauSpec = trackhistmanager::makeTrackMcHistSpecMap(confPosDauBinning); negDauSpec = trackhistmanager::makeTrackMcHistSpecMap(confNegDauBinning); - tripletHistSpec = triplethistmanager::makeTripletMcHistSpecMap(confTripletBinning); - tripletTrackTrackLambdaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confLambdaSelection, confCtr, confMixing, confTripletBinning, confTripletCuts, colHistSpec, trackHistSpec1, trackHistSpec2, lambdaHistSpec, posDauSpec, negDauSpec, tripletHistSpec, ctrHistSpec); + tripletHistSpec = triplethistmanager::makeTripletMcHistSpecMap(confTripletBinning, confMixing); + tripletTrackTrackLambdaBuilder.init(&hRegistry, confCollisionBinning, confTrackSelections1, confTrackSelections2, confLambdaSelection, confCtr, confMixing, confTripletBinning, confTripletCuts, colHistSpec, trackHistSpec1, trackHistSpec2, lambdaHistSpec, posDauSpec, negDauSpec, tripletHistSpec, ctrHistSpec); } hRegistry.print(); }; void processSameEvent(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoLambdas const& /*lambdas*/) { - tripletTrackTrackLambdaBuilder.processSameEvent(col, tracks, trackPartition1, trackPartition2, lambdaPartition, cache); + tripletTrackTrackLambdaBuilder.processSameEvent(col, tracks, trackPartition1, trackPartition2, lambdaPartition, cache); } PROCESS_SWITCH(FemtoTripletTrackTrackV0, processSameEvent, "Enable processing same event processing", true); void processSameEventMc(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) { - tripletTrackTrackLambdaBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, lambdaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); + tripletTrackTrackLambdaBuilder.processSameEvent(col, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, lambdaWithLabelPartition, mcParticles, mcMothers, mcPartonicMothers, cache); } PROCESS_SWITCH(FemtoTripletTrackTrackV0, processSameEventMc, "Enable processing same event processing", false); void processMixedEvent(FilteredFemtoCollisions const& cols, FemtoTracks const& tracks, FemtoLambdas const& /*lambdas*/) { - tripletTrackTrackLambdaBuilder.processMixedEvent(cols, tracks, trackPartition1, trackPartition2, lambdaPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + tripletTrackTrackLambdaBuilder.processMixedEvent(cols, tracks, trackPartition1, trackPartition2, lambdaPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoTripletTrackTrackV0, processMixedEvent, "Enable processing mixed event processing", true); void processMixedEventMc(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*/) { - tripletTrackTrackLambdaBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, lambdaWithLabelPartition, mcParticles, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + tripletTrackTrackLambdaBuilder.processMixedEvent(cols, mcCols, tracks, trackWithLabelPartition1, trackWithLabelPartition2, lambdaWithLabelPartition, mcParticles, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoTripletTrackTrackV0, processMixedEventMc, "Enable processing mixed event processing", false); }; From d41f37076b19a15608a54c85339178890abdd1b2 Mon Sep 17 00:00:00 2001 From: Anton Riedel Date: Fri, 19 Jun 2026 22:12:07 +0200 Subject: [PATCH 3/3] Fix: fix header --- PWGCF/Femto/Tasks/femtoTripletTrackTrackV0.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGCF/Femto/Tasks/femtoTripletTrackTrackV0.cxx b/PWGCF/Femto/Tasks/femtoTripletTrackTrackV0.cxx index 6913ef69e97..7517c7493a4 100644 --- a/PWGCF/Femto/Tasks/femtoTripletTrackTrackV0.cxx +++ b/PWGCF/Femto/Tasks/femtoTripletTrackTrackV0.cxx @@ -1,4 +1,4 @@ -// Copyright 2019-2025 CERN and copyright holders of ALICE O2.tracktrackv +// Copyright 2019-2025 CERN and copyright holders of ALICE O2. // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. // All rights not expressly granted are reserved. //