From 84b1e6435f35730538d753690f284ea66607778e Mon Sep 17 00:00:00 2001 From: AlexianL Date: Fri, 17 Jul 2026 11:37:24 +0200 Subject: [PATCH 01/10] modifications, not validated --- PWGHF/HFC/Tasks/taskFlow.cxx | 210 +++++++++++++++++++++++++++++++++-- 1 file changed, 199 insertions(+), 11 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index feff1396b0a..037ceeafe8a 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -22,13 +22,15 @@ #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/DataModel/CandidateSelectionTables.h" #include "PWGHF/DataModel/TrackIndexSkimmingTables.h" -#include "PWGHF/Utils/utilsPid.h" #include "PWGMM/Mult/DataModel/bestCollisionTable.h" #include "Common/CCDB/EventSelectionParams.h" #include "Common/CCDB/RCTSelectionFlags.h" #include "Common/Core/RecoDecay.h" +#include "Common/Core/fwdtrackUtilities.h" +#include "Common/DataModel/Centrality.h" #include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/McCollisionExtra.h" #include "Common/DataModel/Multiplicity.h" #include "Common/DataModel/TrackSelectionTables.h" @@ -38,7 +40,6 @@ #include #include #include -#include #include #include #include @@ -57,7 +58,7 @@ #include #include -#include +#include #include #include @@ -136,6 +137,7 @@ enum MftTrackSelectionStep { Pt, DCAxy, DCAz, + Chi2OverNdf, IsLTF, IsCA, NMftTrackSelectionSteps @@ -298,11 +300,13 @@ struct HfTaskFlow { Configurable etaMftTrackMin{"etaMftTrackMin", -3.36f, "Minimum value for the eta of MFT tracks when used in cut function"}; Configurable etaMftTrackMaxFilter{"etaMftTrackMaxFilter", -2.0f, "Maximum value for the eta of MFT tracks when used in filter"}; Configurable etaMftTrackMinFilter{"etaMftTrackMinFilter", -3.9f, "Minimum value for the eta of MFT tracks when used in filter"}; + Configurable maxChi2OverNdf{"maxChi2OverNdf", 1000.f, "maximum chi2/ndf for MFT tracks"}; Configurable mftMaxDCAxy{"mftMaxDCAxy", 2.0f, "Cut on dcaXY for MFT tracks"}; Configurable mftMaxDCAz{"mftMaxDCAz", 2.0f, "Cut on dcaZ for MFT tracks"}; Configurable nClustersMftTrack{"nClustersMftTrack", 5, "Minimum number of clusters for the reconstruction of MFT tracks"}; Configurable ptMftTrackMax{"ptMftTrackMax", 10.0f, "max value of MFT tracks pT when used in cut function"}; Configurable ptMftTrackMin{"ptMftTrackMin", 0.f, "min value of MFT tracks pT when used in cut function"}; + Configurable useMftChi2OverNdfCut{"useMftChi2OverNdfCut", false, "use mft track chi2/ndf cut"}; Configurable useMftPtCut{"useMftPtCut", false, "if true, use the Mft pt function cut"}; Configurable useOnlyCATracks{"useOnlyCATracks", false, "if true, use strictly MFT tracks reconstructed with CA algo."}; Configurable useOnlyLTFTracks{"useOnlyLTFTracks", false, "if true, use strictly MFT tracks reconstructed with LTF algo."}; @@ -342,8 +346,10 @@ struct HfTaskFlow { using HfCandidatesSelD0 = soa::Filtered>; using HfCandidatesSelLc = soa::Filtered>; using FilteredTracksWDcaSel = soa::Filtered>; + using FilteredTracksWDcaSelWLabels = soa::Filtered>; using FilteredMftTracks = soa::Filtered; + using FilteredMftTracksWCollsMcLabels = soa::Filtered>; // ========================= // using declarations : MC @@ -351,6 +357,7 @@ struct HfTaskFlow { using SmallGroupMcCollisions = soa::SmallGroups>; using FilteredMcCollisionsWMult = soa::Filtered>; + using FilteredMcCollisionsWMultWCollsExtra = soa::Filtered>; using FilteredMcParticles = soa::Filtered; // ========================= @@ -498,6 +505,7 @@ struct HfTaskFlow { labelsMftTracksSelection[MftTrackSelectionStep::Pt] = "MFT tracks after pT selection"; labelsMftTracksSelection[MftTrackSelectionStep::DCAxy] = "MFT tracks after DCAxy selection"; labelsMftTracksSelection[MftTrackSelectionStep::DCAz] = "MFT tracks after DCAz selection"; + labelsMftTracksSelection[MftTrackSelectionStep::Chi2OverNdf] = "MFT tracks after Chi2OverNdf selection"; labelsMftTracksSelection[MftTrackSelectionStep::IsLTF] = "Linear Track Finder MFT tracks"; labelsMftTracksSelection[MftTrackSelectionStep::IsCA] = "Cellular Automaton MFT tracks"; registry.get(HIST("Data/Mft/hMftTracksSelection"))->SetMinimum(0); @@ -661,8 +669,7 @@ struct HfTaskFlow { registry.add("Data/hEfficiencyTrigger", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); registry.add("Data/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtAssoc}, {configAxis.axisEtaAssociated}, {configAxis.axisVertex}}}); - registry.add("Data/hMultiplicity_uncorrected", "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); - registry.add("Data/hMultiplicity_corrected", "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); + registry.add("Data/hMultiplicity_uncorrected_vs_corrected", "", {HistType::kTH2D, {{configAxis.axisMultiplicity}, {configAxis.axisMultiplicity}}}); if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { registry.add("Trig_hist_TPC_MFT", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); @@ -918,6 +925,13 @@ struct HfTaskFlow { } } + if (doprocessTrackEfficiencies) { + registry.add("MC/hEfficiencyTrigger", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); + registry.add("MC/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaAssociated}, {configAxis.axisVertex}}}); + registry.add("Data/hEfficiencyTrigger", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); + registry.add("Data/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtAssoc}, {configAxis.axisEtaAssociated}, {configAxis.axisVertex}}}); + } + } // End of init() function // ========================= @@ -1434,6 +1448,17 @@ struct HfTaskFlow { registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::DCAz); } + if (configMft.useMftChi2OverNdfCut) { + float ndfMftTrack = std::max(2.0f * mftTrack.nClusters() - 5.0f, 1.0f); + float mftChi2OverNdf = mftTrack.chi2() / ndfMftTrack; + if (mftChi2OverNdf > configMft.maxChi2OverNdf) { + return false; + } + } + if (fillHistograms) { + registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::Chi2OverNdf); + } + // cut on the track algorithm of MFT tracks if (mftTrack.isCA()) { if (fillHistograms) { @@ -1988,16 +2013,33 @@ struct HfTaskFlow { if (configTask.doEtaDependentFlow) { if (fitType == isFT0A) { - registry.fill(HIST("Trig_hist_TPC_FT0A"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + if constexpr (std::is_same_v) { + registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + } else { + registry.fill(HIST("Trig_hist_TPC_FT0A"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + } } else { - registry.fill(HIST("Trig_hist_TPC_FT0C"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + if constexpr (std::is_same_v) { + registry.fill(HIST("Trig_hist_MFT_FT0C"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + } else { + registry.fill(HIST("Trig_hist_TPC_FT0C"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + } } } if (configTask.doVariationContainers) { if (fitType == isFT0A) { - registry.fill(HIST("Trig_hist_TPC_FT0A"), sampleIndex, posZ, track1.pt(), triggerWeight); // think about event weight in near future + + if constexpr (std::is_same_v) { + registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, track1.pt(), triggerWeight); // think about event weight in near future + } else { + registry.fill(HIST("Trig_hist_TPC_FT0A"), sampleIndex, posZ, track1.pt(), triggerWeight); // think about event weight in near future + } } else { - registry.fill(HIST("Trig_hist_TPC_FT0C"), sampleIndex, posZ, track1.pt(), triggerWeight); // think about event weight in near future + if constexpr (std::is_same_v) { + registry.fill(HIST("Trig_hist_MFT_FT0C"), sampleIndex, posZ, track1.pt(), triggerWeight); // think about event weight in near future + } else { + registry.fill(HIST("Trig_hist_TPC_FT0C"), sampleIndex, posZ, track1.pt(), triggerWeight); // think about event weight in near future + } } } @@ -3019,10 +3061,10 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - registry.fill(HIST("Data/hMultiplicity_uncorrected"), multiplicity); + auto uncorrected_multiplicity = multiplicity; + registry.fill(HIST("Data/hMultiplicity_uncorrected_vs_corrected"), uncorrected_multiplicity, multiplicity); if (configCollision.useMultiplicityFromTracksCorrected) { multiplicity = getCorrectedMultiplicity(tracks); - registry.fill(HIST("Data/hMultiplicity_corrected"), multiplicity); } if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { @@ -4274,6 +4316,152 @@ struct HfTaskFlow { } PROCESS_SWITCH(HfTaskFlow, processMixedMcGen, "MC Gen : Process mixed-event correlations", false); + void processTrackEfficiencies(FilteredMcCollisionsWMultWCollsExtra::iterator const& mcCollision, + SmallGroupMcCollisions const& reconstructedCollisions, + FilteredTracksWDcaSelWLabels const& tpcTracks, FilteredMftTracksWCollsMcLabels const& /*mftTracks*/, + soa::Filtered> const& reassociated3dMftTracks, + FilteredMcParticles const& mcParticles) + { + if (std::abs(mcCollision.posZ()) >= configCollision.zVertexMax) { + return; + } + + // check whether we have a selected reconstructed collision corresponding to the MC collision + bool hasReconstructedCollision = false; + for (const auto& reconstructedCollision : reconstructedCollisions) { + if (!isAcceptedCollision(reconstructedCollision)) { + continue; + } + if (reconstructedCollision.globalIndex() != mcCollision.bestCollisionIndex()) { + continue; + } + // auto groupedTpcTracks = tpcTracks.sliceBy(perColTracks, reconstructedCollision.globalIndex()); + hasReconstructedCollision = true; + } + + // fill histogram for MC Gen TPC particles + for (const auto& particle : mcParticles) { + auto pdgParticle = pdg->GetParticle(particle.pdgCode()); + // check MC related properties of the particle + if (!particle.isPhysicalPrimary() || !particle.producedByGenerator()) { + continue; + } + // check charge of the particle + if (pdgParticle == nullptr || std::abs(pdgParticle->Charge()) == 0) { + continue; + } + // check kinematics of the particle for TPC + if (std::abs(particle.eta()) <= configTask.etaMcParticlesTriggerMax && + particle.pt() >= configTask.ptMcParticlesTriggerMin && + particle.pt() <= configTask.ptMcParticlesTriggerMax) { + if (hasReconstructedCollision) { + registry.fill(HIST("MC/hEfficiencyTrigger"), mcCollision.posZ(), particle.eta(), particle.pt()); + } + } + // check kinematics of the particle for MFT + if (particle.eta() <= configTask.etaMcParticlesAssocMax && + particle.eta() >= configTask.etaMcParticlesAssocMin && + particle.pt() >= configTask.ptMcParticlesAssocMin && + particle.pt() <= configTask.ptMcParticlesAssocMax) { + if (hasReconstructedCollision) { + registry.fill(HIST("MC/hEfficiencyAssociated"), mcCollision.posZ(), particle.eta(), particle.pt()); + } + } + } + + // // fill histogram for MC Gen TPC particles + // for (const auto& tpcParticle : mcParticles) { + // auto pdgTpcParticle = pdg->GetParticle(tpcParticle.pdgCode()); + // // check MC related properties of the particle + // if (!tpcParticle.isPhysicalPrimary() || !tpcParticle.producedByGenerator()) { + // continue; + // } + // // check charge of the particle + // if (pdgTpcParticle == nullptr || std::abs(pdgTpcParticle->Charge()) == 0) { + // continue; + // } + // // check kinematics of the particle + // if (std::abs(tpcParticle.eta()) > configTask.etaMcParticlesTriggerMax || + // tpcParticle.pt() < configTask.ptMcParticlesTriggerMin || + // tpcParticle.pt() > configTask.ptMcParticlesTriggerMax) { + // continue; + // } + // if (hasReconstructedCollision) { + // registry.fill(HIST("MC/hEfficiencyTrigger"), mcCollision.posZ(), tpcParticle.eta(), tpcParticle.pt()); + // } + // } + + // // fill histogram for MC Gen MFT particles + // for (const auto& mftParticle : mcParticles) { + // auto pdgMftParticle = pdg->GetParticle(mftParticle.pdgCode()); + // // check MC related properties of the particle + // if (!mftParticle.isPhysicalPrimary() || !mftParticle.producedByGenerator()) { + // continue; + // } + // // check charge of the particle + // if (pdgMftParticle == nullptr || std::abs(pdgMftParticle->Charge()) == 0) { + // continue; + // } + // // check kinematics of the particle + // if (mftParticle.eta() > configTask.etaMcParticlesAssocMax || + // mftParticle.eta() < configTask.etaMcParticlesAssocMin || + // mftParticle.pt() < configTask.ptMcParticlesAssocMin || + // mftParticle.pt() > configTask.ptMcParticlesAssocMax) { + // continue; + // } + + // if (hasReconstructedCollision) { + // registry.fill(HIST("MC/hEfficiencyAssociated"), mcCollision.posZ(), mftParticle.eta(), mftParticle.pt()); + // } + // } + + // fill histogram for reconstructed TPC tracks + for (const auto& reconstructedCollision : reconstructedCollisions) { + if (!isAcceptedCollision(reconstructedCollision)) { + continue; + } + if (reconstructedCollision.globalIndex() != mcCollision.bestCollisionIndex()) { + continue; + } + + auto groupedTpcTracks = tpcTracks.sliceBy(perColTracks, reconstructedCollision.globalIndex()); + for (const auto& tpcTrack : groupedTpcTracks) { + if (!isAcceptedCentralTrack(tpcTrack)) { + continue; + } + if (!tpcTrack.has_mcParticle()) { + continue; + } + auto tpcParticle = tpcTrack.template mcParticle_as(); + if (reconstructedCollision.mcCollisionId() != tpcParticle.mcCollisionId()) { + continue; + } + if (tpcParticle.isPhysicalPrimary()) { + registry.fill(HIST("Data/hEfficiencyTrigger"), mcCollision.posZ(), tpcParticle.eta(), tpcParticle.pt()); + } + } + + auto groupedreassociated3dMftTracks = reassociated3dMftTracks.sliceBy(perColReassociated3dTracks, reconstructedCollision.globalIndex()); + for (const auto& reassociated3dMftTrack : reassociated3dMftTracks) { + if (!reassociated3dMftTrack.has_mcParticle()) { + continue; + } + auto templatedMftTrack = reassociated3dMftTrack.template mfttrack_as(); + if (!isAcceptedMftTrack(templatedMftTrack, reassociated3dMftTrack.bestDCAXY(), reassociated3dMftTrack.bestDCAZ(), false)) { + continue; + } + auto mftParticle = templatedMftTrack.template mcParticle_as(); + if (reconstructedCollision.mcCollisionId() != mftParticle.mcCollisionId()) { + continue; + } + if (mftParticle.isPhysicalPrimary()) { + registry.fill(HIST("Data/hEfficiencyAssociated"), mcCollision.posZ(), mftParticle.eta(), mftParticle.pt()); + } + } + } + } + PROCESS_SWITCH(HfTaskFlow, processTrackEfficiencies, "process track efficiencies for TPC and MFT", false); + }; // End of struct WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) From 803bb8b6b44823adee5f915ed440e80f2763a4a8 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Fri, 17 Jul 2026 13:56:05 +0200 Subject: [PATCH 02/10] modifications, validated --- PWGHF/HFC/Tasks/taskFlow.cxx | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 037ceeafe8a..de845492a20 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -890,7 +890,7 @@ struct HfTaskFlow { if (doprocessSameMcGen) { registry.add("MC/hEfficiencyTrigger", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); - registry.add("MC/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaAssociated}, {configAxis.axisVertex}}}); + registry.add("MC/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtAssoc}, {configAxis.axisEtaAssociated}, {configAxis.axisVertex}}}); if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { addHistograms(); @@ -4355,7 +4355,7 @@ struct HfTaskFlow { particle.pt() >= configTask.ptMcParticlesTriggerMin && particle.pt() <= configTask.ptMcParticlesTriggerMax) { if (hasReconstructedCollision) { - registry.fill(HIST("MC/hEfficiencyTrigger"), mcCollision.posZ(), particle.eta(), particle.pt()); + registry.fill(HIST("MC/hEfficiencyTrigger"), particle.pt(), particle.eta(), mcCollision.posZ()); } } // check kinematics of the particle for MFT @@ -4364,7 +4364,7 @@ struct HfTaskFlow { particle.pt() >= configTask.ptMcParticlesAssocMin && particle.pt() <= configTask.ptMcParticlesAssocMax) { if (hasReconstructedCollision) { - registry.fill(HIST("MC/hEfficiencyAssociated"), mcCollision.posZ(), particle.eta(), particle.pt()); + registry.fill(HIST("MC/hEfficiencyAssociated"), particle.pt(), particle.eta(), mcCollision.posZ()); } } } @@ -4437,7 +4437,7 @@ struct HfTaskFlow { continue; } if (tpcParticle.isPhysicalPrimary()) { - registry.fill(HIST("Data/hEfficiencyTrigger"), mcCollision.posZ(), tpcParticle.eta(), tpcParticle.pt()); + registry.fill(HIST("Data/hEfficiencyTrigger"), tpcParticle.pt(), tpcParticle.eta(), mcCollision.posZ()); } } @@ -4455,7 +4455,7 @@ struct HfTaskFlow { continue; } if (mftParticle.isPhysicalPrimary()) { - registry.fill(HIST("Data/hEfficiencyAssociated"), mcCollision.posZ(), mftParticle.eta(), mftParticle.pt()); + registry.fill(HIST("Data/hEfficiencyAssociated"), mftParticle.pt(), mftParticle.eta(), mcCollision.posZ()); } } } From d7fa02959931aab366b552793cd8f672e2043ae8 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Fri, 17 Jul 2026 14:07:36 +0200 Subject: [PATCH 03/10] remove comments --- PWGHF/HFC/Tasks/taskFlow.cxx | 47 ------------------------------------ 1 file changed, 47 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index de845492a20..14adfa3da57 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -4335,7 +4335,6 @@ struct HfTaskFlow { if (reconstructedCollision.globalIndex() != mcCollision.bestCollisionIndex()) { continue; } - // auto groupedTpcTracks = tpcTracks.sliceBy(perColTracks, reconstructedCollision.globalIndex()); hasReconstructedCollision = true; } @@ -4369,52 +4368,6 @@ struct HfTaskFlow { } } - // // fill histogram for MC Gen TPC particles - // for (const auto& tpcParticle : mcParticles) { - // auto pdgTpcParticle = pdg->GetParticle(tpcParticle.pdgCode()); - // // check MC related properties of the particle - // if (!tpcParticle.isPhysicalPrimary() || !tpcParticle.producedByGenerator()) { - // continue; - // } - // // check charge of the particle - // if (pdgTpcParticle == nullptr || std::abs(pdgTpcParticle->Charge()) == 0) { - // continue; - // } - // // check kinematics of the particle - // if (std::abs(tpcParticle.eta()) > configTask.etaMcParticlesTriggerMax || - // tpcParticle.pt() < configTask.ptMcParticlesTriggerMin || - // tpcParticle.pt() > configTask.ptMcParticlesTriggerMax) { - // continue; - // } - // if (hasReconstructedCollision) { - // registry.fill(HIST("MC/hEfficiencyTrigger"), mcCollision.posZ(), tpcParticle.eta(), tpcParticle.pt()); - // } - // } - - // // fill histogram for MC Gen MFT particles - // for (const auto& mftParticle : mcParticles) { - // auto pdgMftParticle = pdg->GetParticle(mftParticle.pdgCode()); - // // check MC related properties of the particle - // if (!mftParticle.isPhysicalPrimary() || !mftParticle.producedByGenerator()) { - // continue; - // } - // // check charge of the particle - // if (pdgMftParticle == nullptr || std::abs(pdgMftParticle->Charge()) == 0) { - // continue; - // } - // // check kinematics of the particle - // if (mftParticle.eta() > configTask.etaMcParticlesAssocMax || - // mftParticle.eta() < configTask.etaMcParticlesAssocMin || - // mftParticle.pt() < configTask.ptMcParticlesAssocMin || - // mftParticle.pt() > configTask.ptMcParticlesAssocMax) { - // continue; - // } - - // if (hasReconstructedCollision) { - // registry.fill(HIST("MC/hEfficiencyAssociated"), mcCollision.posZ(), mftParticle.eta(), mftParticle.pt()); - // } - // } - // fill histogram for reconstructed TPC tracks for (const auto& reconstructedCollision : reconstructedCollisions) { if (!isAcceptedCollision(reconstructedCollision)) { From f01540da83ffd28f8dcccacb3f56ab3bf0cd25e6 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Fri, 17 Jul 2026 18:26:07 +0200 Subject: [PATCH 04/10] add DCA QA plots --- PWGHF/HFC/Tasks/taskFlow.cxx | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 14adfa3da57..56009d9554e 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -439,6 +439,8 @@ struct HfTaskFlow { ConfigurableAxis axisEtaEfficiency{"axisEtaEfficiency", {1, -1.0, 1.0}, "eta axis for efficiency histograms"}; ConfigurableAxis axisEtaAssociated{"axisEtaAssociated", {48, -4, -2}, "eta axis for MFT histograms"}; ConfigurableAxis axisEtaTrigger{"axisEtaTrigger", {48, -1, 1}, "eta axis for TPC histograms"}; + ConfigurableAxis axisDcaXY{"axisDcaXY", {100, 0, 2}, "dcaXY axis for MFT histograms"}; + ConfigurableAxis axisDcaZ{"axisDcaZ", {100, -2, 2}, "dcaZ axis for MFT histograms"}; ConfigurableAxis axisDeltaPhi{"axisDeltaPhi", {72, -PIHalf, PIHalf * 3}, "delta phi axis for histograms"}; ConfigurableAxis axisDeltaEta{"axisDeltaEta", {48, -2.4, 2.4}, "delta eta axis for histograms"}; ConfigurableAxis axisMultiplicity{"axisMultiplicity", {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 100.1}, "multiplicity axis for histograms"}; @@ -527,6 +529,8 @@ struct HfTaskFlow { registry.add("Data/Mft/hPtMft", "", {HistType::kTH1D, {configAxis.axisPt}}); registry.add("Data/Mft/hPtVsClustersLTF", "", {HistType::kTH2D, {configAxis.axisPt, configAxis.axisNClusters}}); registry.add("Data/Mft/hPtVsClustersCA", "", {HistType::kTH2D, {configAxis.axisPt, configAxis.axisNClusters}}); + registry.add("Data/Mft/hDcaXYMft", "", {HistType::kTH1D, {configAxis.axisDcaXY}}); + registry.add("Data/Mft/hDcaZMft", "", {HistType::kTH1D, {configAxis.axisDcaZ}}); registry.add("Data/Mft/hNMftTracks", "", {HistType::kTH1F, {configAxis.axisMultiplicity}}); registry.add("Data/Mft/hNBestCollisionFwd", "", {HistType::kTH1F, {configAxis.axisMultiplicity}}); } @@ -1445,6 +1449,8 @@ struct HfTaskFlow { } if (fillHistograms) { + registry.fill(HIST("Data/Mft/hDcaXYMft"), dcaXY); + registry.fill(HIST("Data/Mft/hDcaZMft"), dcaZ); registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::DCAz); } From b4afdc0656363e142bc4dd2905587b62d5ac0981 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Thu, 23 Jul 2026 10:37:13 +0200 Subject: [PATCH 05/10] save, not validated --- PWGHF/HFC/Tasks/taskFlow.cxx | 33 +++++++++++++++++++++++++++++++-- 1 file changed, 31 insertions(+), 2 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 56009d9554e..6c5b71e53e9 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -138,6 +138,7 @@ enum MftTrackSelectionStep { DCAxy, DCAz, Chi2OverNdf, + Phi, IsLTF, IsCA, NMftTrackSelectionSteps @@ -304,9 +305,14 @@ struct HfTaskFlow { Configurable mftMaxDCAxy{"mftMaxDCAxy", 2.0f, "Cut on dcaXY for MFT tracks"}; Configurable mftMaxDCAz{"mftMaxDCAz", 2.0f, "Cut on dcaZ for MFT tracks"}; Configurable nClustersMftTrack{"nClustersMftTrack", 5, "Minimum number of clusters for the reconstruction of MFT tracks"}; + Configurable phiMftTrackMin{"phiMftTrackMin", 0.1, "Minimum value for the phi of MFT tracks when used in cut function"}; + Configurable phiMftTrackMiddleMin{"phiMftTrackMiddleMin", PI - 0.1, "cut to remove before phi = pi for MFT tracks when used in cut function"}; + Configurable phiMftTrackMiddleMax{"phiMftTrackMiddleMax", PI + 0.1, "cut to remove after phi = pi for MFT tracks when used in cut function"}; + Configurable phiMftTrackMax{"phiMftTrackMax", 2 * PI - 0.1, "Maximum value for the phi of MFT tracks when used in cut function"}; Configurable ptMftTrackMax{"ptMftTrackMax", 10.0f, "max value of MFT tracks pT when used in cut function"}; Configurable ptMftTrackMin{"ptMftTrackMin", 0.f, "min value of MFT tracks pT when used in cut function"}; Configurable useMftChi2OverNdfCut{"useMftChi2OverNdfCut", false, "use mft track chi2/ndf cut"}; + Configurable useMftPhiCut{"useMftPhiCut", false, "if true, use the Mft phi function cut"}; Configurable useMftPtCut{"useMftPtCut", false, "if true, use the Mft pt function cut"}; Configurable useOnlyCATracks{"useOnlyCATracks", false, "if true, use strictly MFT tracks reconstructed with CA algo."}; Configurable useOnlyLTFTracks{"useOnlyLTFTracks", false, "if true, use strictly MFT tracks reconstructed with LTF algo."}; @@ -508,6 +514,7 @@ struct HfTaskFlow { labelsMftTracksSelection[MftTrackSelectionStep::DCAxy] = "MFT tracks after DCAxy selection"; labelsMftTracksSelection[MftTrackSelectionStep::DCAz] = "MFT tracks after DCAz selection"; labelsMftTracksSelection[MftTrackSelectionStep::Chi2OverNdf] = "MFT tracks after Chi2OverNdf selection"; + labelsMftTracksSelection[MftTrackSelectionStep::Phi] = "MFT tracks after phi selection"; labelsMftTracksSelection[MftTrackSelectionStep::IsLTF] = "Linear Track Finder MFT tracks"; labelsMftTracksSelection[MftTrackSelectionStep::IsCA] = "Cellular Automaton MFT tracks"; registry.get(HIST("Data/Mft/hMftTracksSelection"))->SetMinimum(0); @@ -1465,6 +1472,18 @@ struct HfTaskFlow { registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::Chi2OverNdf); } + if (configMft.useMftPhiCut) { + auto phiMftTrack = mftTrack.phi(); + o2::math_utils::bringTo02Pi(phiMftTrack); + if (phiMftTrack > configMft.phiMftTrackMax || phiMftTrack < configMft.phiMftTrackMin || + (phiMftTrack > configMft.phiMftTrackMiddleMin && phiMftTrack < configMft.phiMftTrackMiddleMax)) { + return false; + } + } + if (fillHistograms) { + registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::Phi); + } + // cut on the track algorithm of MFT tracks if (mftTrack.isCA()) { if (fillHistograms) { @@ -4368,8 +4387,18 @@ struct HfTaskFlow { particle.eta() >= configTask.etaMcParticlesAssocMin && particle.pt() >= configTask.ptMcParticlesAssocMin && particle.pt() <= configTask.ptMcParticlesAssocMax) { - if (hasReconstructedCollision) { - registry.fill(HIST("MC/hEfficiencyAssociated"), particle.pt(), particle.eta(), mcCollision.posZ()); + + if (configMft.useMftPhiCut) { + if (particle.phi() < configMft.phiMftTrackMax && particle.phi() > configMft.phiMftTrackMin && + !(particle.phi() > configMft.phiMftTrackMiddleMin && particle.phi() < configMft.phiMftTrackMiddleMax)) { + if (hasReconstructedCollision) { + registry.fill(HIST("MC/hEfficiencyAssociated"), particle.pt(), particle.eta(), mcCollision.posZ()); + } + } + } else { + if (hasReconstructedCollision) { + registry.fill(HIST("MC/hEfficiencyAssociated"), particle.pt(), particle.eta(), mcCollision.posZ()); + } } } } From bfb1afa799e462f06aca37cf3d9480dc487a8993 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Thu, 23 Jul 2026 14:46:51 +0200 Subject: [PATCH 06/10] implement centrality, not finished --- PWGHF/HFC/Tasks/taskFlow.cxx | 34 +++++++++++++++++++++++++++++++++- 1 file changed, 33 insertions(+), 1 deletion(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 6c5b71e53e9..f08be858929 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -144,6 +144,12 @@ enum MftTrackSelectionStep { NMftTrackSelectionSteps }; +enum CentralityEstimators { + CentFT0C = 0, + CentFT0CVariants1s, + CentFT0M +}; + enum MultiplicityEstimators { MultNTracksPV = 0, MultNumContrib, @@ -175,6 +181,7 @@ enum TrackSelection { static constexpr std::string_view WhatDataType[] = {"Data/", "MC/"}; static constexpr std::string_view WhatCorrelationCase[] = {"TpcTpc/", "TpcMft/", "TpcFv0a/", "MftFv0a/", "TpcFt0a/", "MftFt0a/", "TpcFt0c/", "Ft0aFt0c/"}; static constexpr std::string_view WhatParticles[] = {"ChPartChPart/", "D0ChPart/", "LcChPart/"}; +static constexpr std::string_view WhatCentralityEstimator[] = {"centFT0C", "centFT0CVariants1s", "centFT0M"}; static constexpr std::string_view WhatMultiplicityEstimator[] = {"multNTracksPV", "multNumContrib", "multFT0C", "multFT0M"}; auto static constexpr MinFt0cCell = 96; @@ -234,6 +241,7 @@ struct HfTaskFlow { // configurables for collisions struct : ConfigurableGroup { std::string prefix = "ConfigCollision_group"; + Configurable centralityEstimator{"centralityEstimator", 0, "0: centFT0C, 1: centFT0CVariants1s, 2: centFT0M"}; Configurable isApplyGoodItsLayersAll{"isApplyGoodItsLayersAll", false, "Enable GoodITSLayersAll"}; Configurable isApplyGoodZvtxFT0vsPV{"isApplyGoodZvtxFT0vsPV", false, "Enable GoodZvtxFT0vsPV cut"}; Configurable isApplyNoCollInRofStandard{"isApplyNoCollInRofStandard", false, ""}; @@ -244,7 +252,7 @@ struct HfTaskFlow { Configurable isApplySameBunchPileup{"isApplySameBunchPileup", false, "Enable SameBunchPileup cut"}; Configurable maxMultiplicity{"maxMultiplicity", 300, "maximum multiplicity selection for collision"}; Configurable minMultiplicity{"minMultiplicity", 0, "minimum multiplicity selection for collision"}; - Configurable multiplicityEstimator{"multiplicityEstimator", 0, "0: multNTracksPV, 1: numContrib, 2: multFT0C, 3: multFT0M, 4: centFT0C, 5: centFT0CVariants1s, 6: centFT0M, 7: centFV0A, 8: centNTracksPV, 9: centNGlobal, 10: centMFT"}; + Configurable multiplicityEstimator{"multiplicityEstimator", 0, "0: multNTracksPV, 1: numContrib, 2: multFT0C, 3: multFT0M"}; Configurable useMultiplicityFromTracks{"useMultiplicityFromTracks", false, "Use multiplicity from counting tracks"}; Configurable useMultiplicityFromTracksCorrected{"useMultiplicityFromTracksCorrected", false, "Use multiplicity from counting tracks, corrected but takes a lot of computation time"}; Configurable requireRCTFlagChecker{"requireRCTFlagChecker", false, "Check event quality in run condition table"}; @@ -1014,6 +1022,30 @@ struct HfTaskFlow { } } + template + float getCentralityEstimator(TCollision const& collision, bool isSameEvent) + { + switch (configCollision.centralityEstimator) { + case CentralityEstimators::CentFT0C: + if (isSameEvent) { + registry.fill(HIST("Data/hCentrality_centFT0C"), collision.centFT0C()); + } + return collision.centFT0C(); + case CentralityEstimators::CentFT0CVariants1s: + if (isSameEvent) { + registry.fill(HIST("Data/hCentrality_centFT0CVariants1s"), collision.centFT0CVariants1s()); + } + return collision.centFT0CVariants1s(); + case CentralityEstimators::CentFT0M: + if (isSameEvent) { + registry.fill(HIST("Data/hCentrality_centFT0M"), collision.centFT0M()); + } + return collision.centFT0M(); + default: + return collision.centFT0C(); + } + } + template float getDPhiStar(TTrack const& track1, TTrackAssoc const& track2, float radius, int magField) { From 7271ad8f866532c7921bcb23e405afd1671211be Mon Sep 17 00:00:00 2001 From: AlexianL Date: Fri, 24 Jul 2026 13:53:38 +0200 Subject: [PATCH 07/10] add centrality, validated --- PWGHF/HFC/Tasks/taskFlow.cxx | 564 +++++++++++++++++++++++++---------- 1 file changed, 406 insertions(+), 158 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index f08be858929..88570af3216 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -146,7 +146,7 @@ enum MftTrackSelectionStep { enum CentralityEstimators { CentFT0C = 0, - CentFT0CVariants1s, + CentFT0CVariant1, CentFT0M }; @@ -181,7 +181,7 @@ enum TrackSelection { static constexpr std::string_view WhatDataType[] = {"Data/", "MC/"}; static constexpr std::string_view WhatCorrelationCase[] = {"TpcTpc/", "TpcMft/", "TpcFv0a/", "MftFv0a/", "TpcFt0a/", "MftFt0a/", "TpcFt0c/", "Ft0aFt0c/"}; static constexpr std::string_view WhatParticles[] = {"ChPartChPart/", "D0ChPart/", "LcChPart/"}; -static constexpr std::string_view WhatCentralityEstimator[] = {"centFT0C", "centFT0CVariants1s", "centFT0M"}; +static constexpr std::string_view WhatCentralityEstimator[] = {"centFT0C", "CentFT0CVariant1", "centFT0M"}; static constexpr std::string_view WhatMultiplicityEstimator[] = {"multNTracksPV", "multNumContrib", "multFT0C", "multFT0M"}; auto static constexpr MinFt0cCell = 96; @@ -223,6 +223,7 @@ struct HfTaskFlow { Configurable etaMcParticlesAssocMax{"etaMcParticlesAssocMax", -2.4f, "Maximum value for the eta of MC particles when used in cut function"}; Configurable etaMcParticlesAssocMin{"etaMcParticlesAssocMin", -3.6f, "Minimum value for the eta of MC particles when used in cut function"}; Configurable fillOnlyStepAll{"fillOnlyStepAll", true, "Fill Mc Gen QA plots only for StepAll, or only for Primaries"}; + Configurable loadCentralityWeight{"loadCentralityWeight", "", "Ccdb path to centrality weight correction"}; Configurable loadEfficienciesForTpc{"loadEfficienciesForTpc", "", "Ccdb path to Tpc tracks efficiency correction"}; Configurable loadEfficienciesForMft{"loadEfficienciesForMft", "", "Ccdb path to Mft tracks efficiency correction"}; Configurable loadEfficienciesForNch{"loadEfficienciesForNch", "", "Ccdb path to Nch estimation efficiency correction"}; @@ -241,7 +242,7 @@ struct HfTaskFlow { // configurables for collisions struct : ConfigurableGroup { std::string prefix = "ConfigCollision_group"; - Configurable centralityEstimator{"centralityEstimator", 0, "0: centFT0C, 1: centFT0CVariants1s, 2: centFT0M"}; + Configurable centralityEstimator{"centralityEstimator", 0, "0: centFT0C, 1: CentFT0CVariant1, 2: centFT0M"}; Configurable isApplyGoodItsLayersAll{"isApplyGoodItsLayersAll", false, "Enable GoodITSLayersAll"}; Configurable isApplyGoodZvtxFT0vsPV{"isApplyGoodZvtxFT0vsPV", false, "Enable GoodZvtxFT0vsPV cut"}; Configurable isApplyNoCollInRofStandard{"isApplyNoCollInRofStandard", false, ""}; @@ -250,9 +251,12 @@ struct HfTaskFlow { Configurable isApplyNoCollInTimeRangeStrict{"isApplyNoCollInTimeRangeStrict", false, ""}; Configurable isApplyNoHighMultCollInPrevRof{"isApplyNoHighMultCollInPrevRof", false, ""}; Configurable isApplySameBunchPileup{"isApplySameBunchPileup", false, "Enable SameBunchPileup cut"}; + Configurable maxCentrality{"maxCentrality", 20, "maximum centrality"}; + Configurable minCentrality{"minCentrality", 0, "minimum centrality"}; Configurable maxMultiplicity{"maxMultiplicity", 300, "maximum multiplicity selection for collision"}; Configurable minMultiplicity{"minMultiplicity", 0, "minimum multiplicity selection for collision"}; Configurable multiplicityEstimator{"multiplicityEstimator", 0, "0: multNTracksPV, 1: numContrib, 2: multFT0C, 3: multFT0M"}; + Configurable useCentrality{"useCentrality", false, "use centrality instead of multiplicity"}; Configurable useMultiplicityFromTracks{"useMultiplicityFromTracks", false, "Use multiplicity from counting tracks"}; Configurable useMultiplicityFromTracksCorrected{"useMultiplicityFromTracksCorrected", false, "Use multiplicity from counting tracks, corrected but takes a lot of computation time"}; Configurable requireRCTFlagChecker{"requireRCTFlagChecker", false, "Check event quality in run condition table"}; @@ -316,7 +320,7 @@ struct HfTaskFlow { Configurable phiMftTrackMin{"phiMftTrackMin", 0.1, "Minimum value for the phi of MFT tracks when used in cut function"}; Configurable phiMftTrackMiddleMin{"phiMftTrackMiddleMin", PI - 0.1, "cut to remove before phi = pi for MFT tracks when used in cut function"}; Configurable phiMftTrackMiddleMax{"phiMftTrackMiddleMax", PI + 0.1, "cut to remove after phi = pi for MFT tracks when used in cut function"}; - Configurable phiMftTrackMax{"phiMftTrackMax", 2 * PI - 0.1, "Maximum value for the phi of MFT tracks when used in cut function"}; + Configurable phiMftTrackMax{"phiMftTrackMax", TwoPI - 0.1, "Maximum value for the phi of MFT tracks when used in cut function"}; Configurable ptMftTrackMax{"ptMftTrackMax", 10.0f, "max value of MFT tracks pT when used in cut function"}; Configurable ptMftTrackMin{"ptMftTrackMin", 0.f, "min value of MFT tracks pT when used in cut function"}; Configurable useMftChi2OverNdfCut{"useMftChi2OverNdfCut", false, "use mft track chi2/ndf cut"}; @@ -348,6 +352,7 @@ struct HfTaskFlow { TH3D* mEfficiencyTpc = nullptr; TH3D* mEfficiencyMft = nullptr; TH1D* mEfficiencyNch = nullptr; + TH1D* mCentralityWeight = nullptr; bool areCorrectionsLoaded = false; // o2::aod::rctsel::RCTFlagsChecker rctChecker{"CBT_muon_glo", false, false, true}; @@ -356,7 +361,7 @@ struct HfTaskFlow { // using declarations : DATA // ========================= - using FilteredCollisionsWSelMult = soa::Filtered>; + using FilteredCollisionsWSelMult = soa::Filtered>; using HfCandidatesSelD0 = soa::Filtered>; using HfCandidatesSelLc = soa::Filtered>; using FilteredTracksWDcaSel = soa::Filtered>; @@ -449,6 +454,7 @@ struct HfTaskFlow { ConfigurableAxis axisMass{"axisMass", {1, 1.5848, 2.1848}, "axis of invariant mass of candidates"}; ConfigurableAxis binsMixingMultiplicity{"binsMixingMultiplicity", {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 100.1}, "multiplicity bins for event mixing"}; ConfigurableAxis binsMixingVertex{"binsMixingVertex", {20, -10, 10}, "vertex bins for event mixing"}; + ConfigurableAxis axisCentrality{"axisCentrality", {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100}, "centrality axis for histograms"}; ConfigurableAxis axisNClusters{"axisNClusters", {9, 1, 10}, "axis for number of clusters of MFT tracks"}; ConfigurableAxis axisEtaEfficiency{"axisEtaEfficiency", {1, -1.0, 1.0}, "eta axis for efficiency histograms"}; ConfigurableAxis axisEtaAssociated{"axisEtaAssociated", {48, -4, -2}, "eta axis for MFT histograms"}; @@ -579,6 +585,7 @@ struct HfTaskFlow { registry.add("Data/hVtxZ", "v_{z} (cm)", {HistType::kTH1D, {configAxis.axisVertex}}); registry.add("Data/hNTracks", "", {HistType::kTH1F, {configAxis.axisMultiplicity}}); registry.add(Form("Data/hMultiplicity_%s", WhatMultiplicityEstimator[configCollision.multiplicityEstimator].data()), "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); + registry.add(Form("Data/hCentrality_%s", WhatCentralityEstimator[configCollision.centralityEstimator].data()), "", {HistType::kTH1D, {configAxis.axisCentrality}}); registry.add("Data/hEventCounter", "hEventCounter", {HistType::kTH1D, {{EventSelectionStep::NEventSelectionSteps, -0.5, +EventSelectionStep::NEventSelectionSteps - 0.5}}}); std::string labels[EventSelectionStep::NEventSelectionSteps]; @@ -1031,11 +1038,11 @@ struct HfTaskFlow { registry.fill(HIST("Data/hCentrality_centFT0C"), collision.centFT0C()); } return collision.centFT0C(); - case CentralityEstimators::CentFT0CVariants1s: + case CentralityEstimators::CentFT0CVariant1: if (isSameEvent) { - registry.fill(HIST("Data/hCentrality_centFT0CVariants1s"), collision.centFT0CVariants1s()); + registry.fill(HIST("Data/hCentrality_centFT0CVariant1"), collision.centFT0CVariant1()); } - return collision.centFT0CVariants1s(); + return collision.centFT0CVariant1(); case CentralityEstimators::CentFT0M: if (isSameEvent) { registry.fill(HIST("Data/hCentrality_centFT0M"), collision.centFT0M()); @@ -1235,6 +1242,13 @@ struct HfTaskFlow { } LOGF(info, "Loaded efficiency histogram from %s (%p)", configTask.loadEfficienciesForNch.value.c_str(), (void*)mEfficiencyNch); } + if (configTask.loadCentralityWeight.value.empty() == false) { + mCentralityWeight = ccdb->getForTimeStamp(configTask.loadCentralityWeight, timestamp); + if (mCentralityWeight == nullptr) { + LOGF(fatal, "Could not load centrality weight correction from %s", configTask.loadCentralityWeight.value.c_str()); + } + LOGF(info, "Loaded centrality weight from %s (%p)", configTask.loadCentralityWeight.value.c_str(), (void*)mCentralityWeight); + } areCorrectionsLoaded = true; } @@ -1311,6 +1325,21 @@ struct HfTaskFlow { return trackCounter; } + bool getCentralityWeight(float& weightCent, const float centrality) + { + float weight = 1.; + if (mCentralityWeight) { + weight = mCentralityWeight->GetBinContent(mCentralityWeight->FindBin(centrality)); + } else { + weight = 1.0; + } + if (weight == 0) { + return false; + } + weightCent = weight; + return true; + } + // ========================= // Cuts with functions // ========================= @@ -1571,7 +1600,7 @@ struct HfTaskFlow { template void fillCorrelations(TTarget target, CorrelationContainer::CFStep step, TTracksTrig const& tracks1, TTracksAssoc const& tracks2, - float multiplicity, float posZ, bool sameEvent, int magneticField) + float multiplicity, float posZ, bool sameEvent, int magneticField, float centralityWeight) { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; @@ -1616,17 +1645,17 @@ struct HfTaskFlow { // fill single-track distributions if (!fillingHFcontainer) { // if not HF-h case - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, centralityWeight * triggerWeight); if (configTask.doEtaDependentFlow) { - registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.eta(), centralityWeight * triggerWeight); } if (configTask.doVariationContainers) { - registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.pt(), triggerWeight); + registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.pt(), centralityWeight * triggerWeight); } } else { - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, centralityWeight * triggerWeight); } // FILL QA PLOTS for trigger particle @@ -1764,17 +1793,17 @@ struct HfTaskFlow { // fill pair correlations if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, - triggerWeight * associatedWeight); + centralityWeight * triggerWeight * associatedWeight); } else if (configTask.doEtaDependentFlow) { target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, - triggerWeight * associatedWeight); + centralityWeight * triggerWeight * associatedWeight); } else { target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, - triggerWeight * associatedWeight); + centralityWeight * triggerWeight * associatedWeight); } } else { target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, invmass, - triggerWeight * associatedWeight); + centralityWeight * triggerWeight * associatedWeight); } // FILL QA PLOTS for associated particle @@ -1808,7 +1837,7 @@ struct HfTaskFlow { template void fillCorrelationsReassociatedMftTracks(TTarget target, CorrelationContainer::CFStep step, TTracksTrig const& tracks1, TTracksAssoc const& tracks2, - float multiplicity, float posZ, bool sameEvent, bool cutAmbiguousTracks) + float multiplicity, float posZ, bool sameEvent, bool cutAmbiguousTracks, float centralityWeight) { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; @@ -1849,17 +1878,17 @@ struct HfTaskFlow { // fill single-track distributions if (!fillingHFcontainer) { // if not HF-h case - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, centralityWeight * triggerWeight); if (configTask.doEtaDependentFlow) { - registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.eta(), centralityWeight * triggerWeight); } if (configTask.doVariationContainers) { - registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.pt(), triggerWeight); + registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.pt(), centralityWeight * triggerWeight); } } else { - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, centralityWeight * triggerWeight); } // FILL QA PLOTS for trigger particle @@ -1973,17 +2002,17 @@ struct HfTaskFlow { if (!fillingHFcontainer) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, - triggerWeight * associatedWeight); + centralityWeight * triggerWeight * associatedWeight); } else if (configTask.doEtaDependentFlow) { target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, - triggerWeight * associatedWeight); + centralityWeight * triggerWeight * associatedWeight); } else { target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, - triggerWeight * associatedWeight); + centralityWeight * triggerWeight * associatedWeight); } } else { target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, invmass, - triggerWeight * associatedWeight); + centralityWeight * triggerWeight * associatedWeight); } // FILL QA PLOTS for associated particle @@ -2007,7 +2036,7 @@ struct HfTaskFlow { template void fillCorrelationsFIT(TTarget target, CorrelationContainer::CFStep step, TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TFits const&, - float multiplicity, float posZ, bool sameEvent, int fitType) + float multiplicity, float posZ, bool sameEvent, int fitType, float centralityWeight) { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; @@ -2066,20 +2095,20 @@ struct HfTaskFlow { // fill single-track distributions if (!fillingHFcontainer) { // if not HF-h case - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, centralityWeight * triggerWeight); if (configTask.doEtaDependentFlow) { if (fitType == isFT0A) { if constexpr (std::is_same_v) { - registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, track1.eta(), centralityWeight * triggerWeight); } else { - registry.fill(HIST("Trig_hist_TPC_FT0A"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist_TPC_FT0A"), sampleIndex, posZ, track1.eta(), centralityWeight * triggerWeight); } } else { if constexpr (std::is_same_v) { - registry.fill(HIST("Trig_hist_MFT_FT0C"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist_MFT_FT0C"), sampleIndex, posZ, track1.eta(), centralityWeight * triggerWeight); } else { - registry.fill(HIST("Trig_hist_TPC_FT0C"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist_TPC_FT0C"), sampleIndex, posZ, track1.eta(), centralityWeight * triggerWeight); } } } @@ -2087,21 +2116,21 @@ struct HfTaskFlow { if (fitType == isFT0A) { if constexpr (std::is_same_v) { - registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, track1.pt(), triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, track1.pt(), centralityWeight * triggerWeight); } else { - registry.fill(HIST("Trig_hist_TPC_FT0A"), sampleIndex, posZ, track1.pt(), triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist_TPC_FT0A"), sampleIndex, posZ, track1.pt(), centralityWeight * triggerWeight); } } else { if constexpr (std::is_same_v) { - registry.fill(HIST("Trig_hist_MFT_FT0C"), sampleIndex, posZ, track1.pt(), triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist_MFT_FT0C"), sampleIndex, posZ, track1.pt(), centralityWeight * triggerWeight); } else { - registry.fill(HIST("Trig_hist_TPC_FT0C"), sampleIndex, posZ, track1.pt(), triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist_TPC_FT0C"), sampleIndex, posZ, track1.pt(), centralityWeight * triggerWeight); } } } } else { - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, centralityWeight * triggerWeight); } // FILL QA PLOTS for trigger particle @@ -2163,14 +2192,14 @@ struct HfTaskFlow { // if (!fillingHFcontainer) { // if (!configTask.doEtaDependentFlow) { // target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, - // triggerWeight * associatedWeight); + // centralityWeight * triggerWeight * associatedWeight); // } else { // target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, - // triggerWeight * associatedWeight); + // centralityWeight * triggerWeight * associatedWeight); // } // } else { // target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, invmass, - // triggerWeight * associatedWeight); + // centralityWeight * triggerWeight * associatedWeight); // } // // FILL QA PLOTS for associated particle @@ -2216,17 +2245,17 @@ struct HfTaskFlow { if (!fillingHFcontainer) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { target->getPairHist()->Fill(step, eta1 - eta2, 0.5, pt1, multiplicity, deltaPhi, posZ, - amplitude * triggerWeight * associatedWeight); + amplitude * centralityWeight * triggerWeight * associatedWeight); } else if (configTask.doEtaDependentFlow) { target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, - amplitude * triggerWeight * associatedWeight); + amplitude * centralityWeight * triggerWeight * associatedWeight); } else { target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, - amplitude * triggerWeight * associatedWeight); + amplitude * centralityWeight * triggerWeight * associatedWeight); } } else { target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, invmass, - amplitude * triggerWeight * associatedWeight); + amplitude * centralityWeight * triggerWeight * associatedWeight); } // FILL QA PLOTS for associated particle @@ -2268,7 +2297,7 @@ struct HfTaskFlow { template void fillCorrelationsFITReassociatedMftTracks(TTarget target, CorrelationContainer::CFStep step, TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TFits const&, - float multiplicity, float posZ, bool sameEvent, bool cutAmbiguousTracks, int fitType) + float multiplicity, float posZ, bool sameEvent, bool cutAmbiguousTracks, int fitType, float centralityWeight) { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; @@ -2318,13 +2347,13 @@ struct HfTaskFlow { continue; } - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, centralityWeight * triggerWeight); if (configTask.doEtaDependentFlow) { - registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, eta1, triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, eta1, centralityWeight * triggerWeight); } if (configTask.doVariationContainers) { - registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, pt1, triggerWeight); + registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, pt1, centralityWeight * triggerWeight); } // FILL QA PLOTS for trigger particle @@ -2351,10 +2380,10 @@ struct HfTaskFlow { // if (!configTask.doEtaDependentFlow) { // target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, - // triggerWeight * associatedWeight); + // centralityWeight * triggerWeight * associatedWeight); // } else { // target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, - // triggerWeight * associatedWeight); + // centralityWeight * triggerWeight * associatedWeight); // } // // FILL QA PLOTS for associated particle @@ -2389,13 +2418,13 @@ struct HfTaskFlow { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { target->getPairHist()->Fill(step, eta1 - eta2, 0.5, pt1, multiplicity, deltaPhi, posZ, - amplitude * triggerWeight * associatedWeight); + amplitude * centralityWeight * triggerWeight * associatedWeight); } else if (configTask.doEtaDependentFlow) { target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, - amplitude * triggerWeight * associatedWeight); + amplitude * centralityWeight * triggerWeight * associatedWeight); } else { target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, - amplitude * triggerWeight * associatedWeight); + amplitude * centralityWeight * triggerWeight * associatedWeight); } // FILL QA PLOTS for associated particle @@ -2412,7 +2441,7 @@ struct HfTaskFlow { template void fillCorrelationsFt0aFt0c(TTarget target, CorrelationContainer::CFStep step, TFT0As const& ft0as, TFT0Cs const& ft0cs, - float multiplicity, float posZ, bool sameEvent) + float multiplicity, float posZ, bool sameEvent, float centralityWeight) { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; @@ -2423,18 +2452,18 @@ struct HfTaskFlow { for (std::size_t indexChannelA = 0; indexChannelA < ft0as.channelA().size(); indexChannelA++) { loopCounter++; int channelIdA = 0; - float amplitude = 0.; - getChannel(ft0as, indexChannelA, channelIdA, isFT0A, amplitude); + float amplitudeA = 0.; + getChannel(ft0as, indexChannelA, channelIdA, isFT0A, amplitudeA); auto phiA = getPhiFT0(channelIdA, isFT0A); auto etaA = getEtaFT0(channelIdA, isFT0A); - target->getTriggerHist()->Fill(step, 0.5, multiplicity, posZ, amplitude * triggerWeight); + target->getTriggerHist()->Fill(step, 0.5, multiplicity, posZ, amplitudeA * centralityWeight * triggerWeight); if (configTask.doEtaDependentFlow) { - registry.fill(HIST("Trig_hist_FT0A_FT0C"), sampleIndex, posZ, etaA, triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist_FT0A_FT0C"), sampleIndex, posZ, etaA, amplitudeA * centralityWeight * triggerWeight); } if (configTask.doVariationContainers) { - registry.fill(HIST("Trig_hist_FT0A_FT0C"), sampleIndex, posZ, 0.5, triggerWeight); + registry.fill(HIST("Trig_hist_FT0A_FT0C"), sampleIndex, posZ, 0.5, amplitudeA * centralityWeight * triggerWeight); } if (sameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { @@ -2445,21 +2474,21 @@ struct HfTaskFlow { for (std::size_t indexChannelC = 0; indexChannelC < ft0cs.channelC().size(); indexChannelC++) { int channelIdC = 0; - float amplitude = 0.; - getChannel(ft0cs, indexChannelC, channelIdC, isFT0C, amplitude); + float amplitudeC = 0.; + getChannel(ft0cs, indexChannelC, channelIdC, isFT0C, amplitudeC); auto phiC = getPhiFT0(channelIdC, isFT0C); auto etaC = getEtaFT0(channelIdC, isFT0C); float deltaPhi = RecoDecay::constrainAngle(phiA - phiC, -PIHalf); if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { target->getPairHist()->Fill(step, etaA - etaC, 0.5, 0.5, multiplicity, deltaPhi, posZ, - amplitude * triggerWeight * associatedWeight); + amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); } else if (configTask.doEtaDependentFlow) { target->getPairHist()->Fill(step, sampleIndex, posZ, etaC, etaA, deltaPhi, etaA - etaC, - amplitude * triggerWeight * associatedWeight); + amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); } else { target->getPairHist()->Fill(step, sampleIndex, posZ, 0.5, multiplicity, deltaPhi, etaA - etaC, - amplitude * triggerWeight * associatedWeight); + amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); } if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { @@ -2506,7 +2535,7 @@ struct HfTaskFlow { target->getTriggerHist()->Fill(step, track1.pt(), multiplicity, posZ, triggerWeight); if (configTask.doEtaDependentFlow) { - registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.eta(), triggerWeight); } if (configTask.doVariationContainers) { registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.pt(), triggerWeight); @@ -2637,12 +2666,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision1, false); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, true)); + if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } corrContainer->fillEvent(multiplicity, step); - fillCorrelations(corrContainer, step, tracks1, tracks2, multiplicity, collision1.posZ(), false, getMagneticField(bc.timestamp())); + fillCorrelations(corrContainer, step, tracks1, tracks2, multiplicity, collision1.posZ(), false, getMagneticField(bc.timestamp()), centralityWeight); } } @@ -2689,15 +2726,24 @@ struct HfTaskFlow { } else { multiplicity = getMultiplicityEstimator(collision1, false); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, true)); + if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } auto slicedTriggerTracks = tracks1.sliceBy(presliceTrigger, collision1.globalIndex()); auto slicedAssociatedTracks = tracks2.sliceBy(presliceAssociated, collision2.globalIndex()); corrContainer->fillEvent(multiplicity, step); - fillCorrelations(corrContainer, step, slicedTriggerTracks, slicedAssociatedTracks, multiplicity, collision1.posZ(), false, getMagneticField(bc.timestamp())); + fillCorrelations(corrContainer, step, slicedTriggerTracks, slicedAssociatedTracks, multiplicity, collision1.posZ(), false, getMagneticField(bc.timestamp()), centralityWeight); } } @@ -2742,8 +2788,17 @@ struct HfTaskFlow { } else { multiplicity = getMultiplicityEstimator(collision1, false); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, true)); + if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } // if TPC-MFT cases @@ -2752,13 +2807,13 @@ struct HfTaskFlow { auto slicedAssociatedTracks = tracks2.sliceBy(presliceAssociated, collision2.globalIndex()); corrContainer->fillEvent(multiplicity, step); - fillCorrelationsReassociatedMftTracks(corrContainer, step, slicedTriggerTracks, slicedAssociatedTracks, multiplicity, collision1.posZ(), false, cutAmbiguousTracks); + fillCorrelationsReassociatedMftTracks(corrContainer, step, slicedTriggerTracks, slicedAssociatedTracks, multiplicity, collision1.posZ(), false, cutAmbiguousTracks, centralityWeight); } else if ((collision1.has_foundFT0() && collision2.has_foundFT0())) { // if MFT-FT0A cases auto slicedTriggerTracks = tracks1.sliceBy(presliceTrigger, collision1.globalIndex()); const auto& ft0 = collision2.foundFT0(); corrContainer->fillEvent(multiplicity, step); - fillCorrelationsFITReassociatedMftTracks(corrContainer, step, slicedTriggerTracks, ft0, tracks2, multiplicity, collision1.posZ(), false, cutAmbiguousTracks, isFT0A); + fillCorrelationsFITReassociatedMftTracks(corrContainer, step, slicedTriggerTracks, ft0, tracks2, multiplicity, collision1.posZ(), false, cutAmbiguousTracks, isFT0A, centralityWeight); } } // end of for loop } @@ -2836,12 +2891,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision1, false); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, true)); + if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } corrContainer->fillEvent(multiplicity, step); - fillCorrelationsFIT(corrContainer, step, slicedTriggerTracks, ft0, tracks2, multiplicity, collision1.posZ(), false, fitType); + fillCorrelationsFIT(corrContainer, step, slicedTriggerTracks, ft0, tracks2, multiplicity, collision1.posZ(), false, fitType, centralityWeight); } } // end of if condition for TPC-FT0 or MFT-FT0s } // end of for loop @@ -2894,12 +2957,21 @@ struct HfTaskFlow { } else { multiplicity = getMultiplicityEstimator(collision1, false); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, true)); + if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } corrContainer->fillEvent(multiplicity, step); - fillCorrelationsFt0aFt0c(corrContainer, step, ft0as, ft0cs, multiplicity, collision1.posZ(), true); + fillCorrelationsFt0aFt0c(corrContainer, step, ft0as, ft0cs, multiplicity, collision1.posZ(), true, centralityWeight); } } // end of for loop } @@ -2936,12 +3008,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelations(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, tracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + fillCorrelations(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, tracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp()), centralityWeight); } PROCESS_SWITCH(HfTaskFlow, processSameTpcTpcChCh, "DATA : Process same-event correlations for TPC-TPC h-h case", false); @@ -2975,12 +3055,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, tracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, tracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp()), centralityWeight); } PROCESS_SWITCH(HfTaskFlow, processSameTpcTpcD0Ch, "DATA : Process same-event correlations for TPC-TPC D0-h case", false); @@ -3014,12 +3102,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, tracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, tracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp()), centralityWeight); } PROCESS_SWITCH(HfTaskFlow, processSameTpcTpcLcCh, "DATA : Process same-event correlations for TPC-TPC Lc-h case", false); @@ -3046,16 +3142,24 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelations(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + fillCorrelations(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp()), centralityWeight); } else { sameEventTpcMft->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelations(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + fillCorrelations(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp()), centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChCh, "DATA : Process same-event correlations for TPC-MFT h-h case", false); @@ -3082,16 +3186,24 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false, centralityWeight); } else { sameEventTpcMft->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChChReassociated, "DATA : Process same-event correlations for TPC-MFT h-h case reassociated", false); @@ -3118,22 +3230,30 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - auto uncorrected_multiplicity = multiplicity; - registry.fill(HIST("Data/hMultiplicity_uncorrected_vs_corrected"), uncorrected_multiplicity, multiplicity); + auto uncorrectedMultiplicity = multiplicity; + registry.fill(HIST("Data/hMultiplicity_uncorrected_vs_corrected"), uncorrectedMultiplicity, multiplicity); if (configCollision.useMultiplicityFromTracksCorrected) { multiplicity = getCorrectedMultiplicity(tracks); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false, centralityWeight); } else { sameEventTpcMft->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChChReassociated3d, "DATA : Process same-event correlations for TPC-MFT h-h case 3d reassociated", false); @@ -3160,16 +3280,24 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, true); + fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, true, centralityWeight); } else { sameEventTpcMft->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, true); + fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, true, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChChNonAmbiguous, "DATA : Process same-event correlations for TPC-MFT h-h case with non-ambiguous tracks", false); @@ -3204,12 +3332,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp()), centralityWeight); } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftD0Ch, "DATA : Process same-event correlations for TPC-MFT D0-h case", false); @@ -3233,12 +3369,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + fillCorrelationsReassociatedMftTracks(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, reassociatedMftTracks, multiplicity, collision.posZ(), true, false, centralityWeight); } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftD0ChReassociated, "DATA : Process same-event correlations for TPC-MFT D0-h case reassociated", false); @@ -3272,12 +3416,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp()), centralityWeight); } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftLcCh, "DATA : Process same-event correlations for TPC-MFT Lc-h case", false); @@ -3301,12 +3453,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + fillCorrelationsReassociatedMftTracks(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, reassociatedMftTracks, multiplicity, collision.posZ(), true, false, centralityWeight); } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftLcChReassociated, "DATA : Process same-event correlations for TPC-MFT Lc-h case reassociated", false); @@ -3514,16 +3674,24 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A, centralityWeight); } else { sameEventTpcFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEventTpcFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + fillCorrelationsFIT(sameEventTpcFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A, centralityWeight); } } } @@ -3556,12 +3724,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcFt0aD0Ch, "DATA : Process same-event correlations for TPC-FT0-A D0-h case", false); @@ -3593,12 +3769,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcFt0aLcCh, "DATA : Process same-event correlations for TPC-FT0-A Lc-h case", false); @@ -3630,16 +3814,24 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A, centralityWeight); } else { sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + fillCorrelationsFIT(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A, centralityWeight); } } } @@ -3669,16 +3861,24 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A, centralityWeight); } else { sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A, centralityWeight); } } } @@ -3708,16 +3908,24 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A, centralityWeight); } else { sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A, centralityWeight); } } } @@ -3747,16 +3955,24 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, true, isFT0A); + fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, true, isFT0A, centralityWeight); } else { sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, true, isFT0A); + fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, true, isFT0A, centralityWeight); } } } @@ -3789,12 +4005,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0cs, multiplicity, collision.posZ(), true, isFT0C); + fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0cs, multiplicity, collision.posZ(), true, isFT0C, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcFt0cChCh, "DATA : Process same-event correlations for TPC-FT0C h-h case", false); @@ -3826,12 +4050,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, ft0, ft0cs, multiplicity, collision.posZ(), true, isFT0C); + fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, ft0, ft0cs, multiplicity, collision.posZ(), true, isFT0C, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcFt0cD0Ch, "DATA : Process same-event correlations for TPC-FT0C D0-h case", false); @@ -3863,12 +4095,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, ft0, ft0cs, multiplicity, collision.posZ(), true, isFT0C); + fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, ft0, ft0cs, multiplicity, collision.posZ(), true, isFT0C, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcFt0cLcCh, "DATA : Process same-event correlations for TPC-FT0C Lc-h case", false); @@ -3899,12 +4139,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); + if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + return; + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } } sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFt0aFt0c(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, ft0, ft0, multiplicity, collision.posZ(), true); + fillCorrelationsFt0aFt0c(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, ft0, ft0, multiplicity, collision.posZ(), true, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameFt0aFt0cChCh, "DATA : Process same-event correlations for FT0A-FT0C h-h case", false); From ebe1715fd0a0cc8b34cd2a942cce5ad42b1deb22 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Fri, 24 Jul 2026 14:09:18 +0200 Subject: [PATCH 08/10] add centrality, validated --- PWGHF/HFC/Tasks/taskFlow.cxx | 3 --- 1 file changed, 3 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 88570af3216..ba5f3a7a6c0 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -1415,9 +1415,6 @@ struct HfTaskFlow { } if (fillHistograms) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsRctFlagChecked); - } - - if (fillHistograms) { registry.fill(HIST("Data/hEventCounter"), EventSelectionStep::AfterEventSelection); } From c4c4219c6db22ed246230d8575ccfb2d540d8bf4 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Fri, 24 Jul 2026 14:58:45 +0200 Subject: [PATCH 09/10] add centrality, validated --- PWGHF/HFC/Tasks/taskFlow.cxx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index ba5f3a7a6c0..e0f1f457128 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -1226,28 +1226,28 @@ struct HfTaskFlow { if (mEfficiencyTpc == nullptr) { LOGF(fatal, "Could not load efficiency histogram for TPC tracks from %s", configTask.loadEfficienciesForTpc.value.c_str()); } - LOGF(info, "Loaded efficiency histogram from %s (%p)", configTask.loadEfficienciesForTpc.value.c_str(), (void*)mEfficiencyTpc); + LOGF(info, "Loaded efficiency histogram from %s (%p)", configTask.loadEfficienciesForTpc.value.c_str(), static_cast(mEfficiencyTpc)); } if (configTask.loadEfficienciesForMft.value.empty() == false) { mEfficiencyMft = ccdb->getForTimeStamp(configTask.loadEfficienciesForTpc, timestamp); if (mEfficiencyMft == nullptr) { LOGF(fatal, "Could not load efficiency histogram for MFT tracks from %s", configTask.loadEfficienciesForMft.value.c_str()); } - LOGF(info, "Loaded efficiency histogram from %s (%p)", configTask.loadEfficienciesForMft.value.c_str(), (void*)mEfficiencyMft); + LOGF(info, "Loaded efficiency histogram from %s (%p)", configTask.loadEfficienciesForMft.value.c_str(), static_cast(mEfficiencyMft)); } if (configTask.loadEfficienciesForNch.value.empty() == false) { mEfficiencyNch = ccdb->getForTimeStamp(configTask.loadEfficienciesForNch, timestamp); if (!mEfficiencyNch) { LOGF(fatal, "Could not load efficiency histogram for Nch estimator from %s", configTask.loadEfficienciesForNch.value.c_str()); } - LOGF(info, "Loaded efficiency histogram from %s (%p)", configTask.loadEfficienciesForNch.value.c_str(), (void*)mEfficiencyNch); + LOGF(info, "Loaded efficiency histogram from %s (%p)", configTask.loadEfficienciesForNch.value.c_str(), static_cast(mEfficiencyNch)); } if (configTask.loadCentralityWeight.value.empty() == false) { mCentralityWeight = ccdb->getForTimeStamp(configTask.loadCentralityWeight, timestamp); if (mCentralityWeight == nullptr) { LOGF(fatal, "Could not load centrality weight correction from %s", configTask.loadCentralityWeight.value.c_str()); } - LOGF(info, "Loaded centrality weight from %s (%p)", configTask.loadCentralityWeight.value.c_str(), (void*)mCentralityWeight); + LOGF(info, "Loaded centrality weight from %s (%p)", configTask.loadCentralityWeight.value.c_str(), static_cast(mCentralityWeight)); } areCorrectionsLoaded = true; } From 1620bfa07d74aafc666aefd97c5d7df4d71342ee Mon Sep 17 00:00:00 2001 From: AlexianL Date: Fri, 24 Jul 2026 15:40:44 +0200 Subject: [PATCH 10/10] add centrality, validated --- PWGHF/HFC/Tasks/taskFlow.cxx | 146 +++++++++++++++++------------------ 1 file changed, 73 insertions(+), 73 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index e0f1f457128..6ac799fff5d 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -1596,8 +1596,8 @@ struct HfTaskFlow { template void fillCorrelations(TTarget target, CorrelationContainer::CFStep step, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, - float multiplicity, float posZ, bool sameEvent, int magneticField, float centralityWeight) + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, + float multiplicity, float posZ, bool isSameEvent, int magneticField, float centralityWeight) { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; @@ -1605,7 +1605,7 @@ struct HfTaskFlow { int sampleIndex = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE - for (const auto& track1 : tracks1) { + for (const auto& track1 : tracksTrigger) { loopCounter++; if constexpr (std::is_same_v) { @@ -1656,7 +1656,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for trigger particle - if (sameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { if constexpr (!std::is_same_v) { // IF TPC-TPC case if constexpr (std::is_same_v) { // IF D0 CASE -> TPC-TPC D0-h fillTriggerQa(multiplicity, eta1, phi1, pt1); @@ -1677,7 +1677,7 @@ struct HfTaskFlow { } // ASSOCIATED PARTICLE - for (const auto& track2 : tracks2) { + for (const auto& track2 : tracksAssoc) { if constexpr (std::is_same_v) { if (!isAcceptedCentralTrack(track2)) { @@ -1688,7 +1688,7 @@ struct HfTaskFlow { // apply cuts for MFT tracks if constexpr (std::is_same_v) { - if (sameEvent && loopCounter == 1) { // To avoid double counting, we fill the plots only the first time + if (isSameEvent && loopCounter == 1) { // To avoid double counting, we fill the plots only the first time registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::NoSelection); if (!isAcceptedMftTrack(track2, 0.f, 0.f, true)) { @@ -1705,10 +1705,10 @@ struct HfTaskFlow { continue; } - if (configCentral.isApplyPtOrderingSameEvent && sameEvent && (track1.pt() <= track2.pt())) { + if (configCentral.isApplyPtOrderingSameEvent && isSameEvent && (track1.pt() <= track2.pt())) { continue; } - if (configCentral.isApplyPtOrderingMixedEvent && !sameEvent && (track1.pt() <= track2.pt())) { + if (configCentral.isApplyPtOrderingMixedEvent && !isSameEvent && (track1.pt() <= track2.pt())) { continue; } @@ -1804,7 +1804,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for associated particle - if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { if constexpr (!std::is_same_v) { // IF TPC-TPC case if constexpr (std::is_same_v) { // IF D0 CASE -> TPC-TPC D0-h fillAssociatedQa(multiplicity, eta2, phi2); @@ -1833,8 +1833,8 @@ struct HfTaskFlow { template void fillCorrelationsReassociatedMftTracks(TTarget target, CorrelationContainer::CFStep step, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, - float multiplicity, float posZ, bool sameEvent, bool cutAmbiguousTracks, float centralityWeight) + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, + float multiplicity, float posZ, bool isSameEvent, bool cutAmbiguousTracks, float centralityWeight) { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; @@ -1842,7 +1842,7 @@ struct HfTaskFlow { int sampleIndex = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE - for (const auto& track1 : tracks1) { + for (const auto& track1 : tracksTrigger) { loopCounter++; if constexpr (std::is_same_v) { @@ -1889,7 +1889,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for trigger particle - if (sameEvent) { + if (isSameEvent) { if constexpr (std::is_same_v) { fillTriggerQa(multiplicity, eta1, phi1, pt1); } else if constexpr (std::is_same_v) { @@ -1901,10 +1901,10 @@ struct HfTaskFlow { } // ASSOCIATED PARTICLE - for (const auto& track2 : tracks2) { + for (const auto& track2 : tracksAssoc) { // Fill QA plot for all MFT tracks () (only if cutAmbiguousTracks is false to avoid double counting) - if (!cutAmbiguousTracks && sameEvent && (loopCounter == 1)) { + if (!cutAmbiguousTracks && isSameEvent && (loopCounter == 1)) { registry.fill(HIST("Data/Mft/hAmbiguityOfMftTracks"), MftTrackAmbiguityStep::AllMftTracks); } @@ -1920,7 +1920,7 @@ struct HfTaskFlow { reassociatedMftTrackDcaZ = track2.bestDCAZ(); } - if (sameEvent && loopCounter == 1) { // To avoid double counting, we fill the plots only the first time + if (isSameEvent && loopCounter == 1) { // To avoid double counting, we fill the plots only the first time registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::NoSelection); if (!isAcceptedMftTrack(reassociatedMftTrack, reassociatedMftTrackDcaXY, reassociatedMftTrackDcaZ, true)) { @@ -1933,15 +1933,15 @@ struct HfTaskFlow { } // Fill QA plot for MFT tracks after physical selection (eta + clusters) - if (!cutAmbiguousTracks && sameEvent && (loopCounter == 1)) { + if (!cutAmbiguousTracks && isSameEvent && (loopCounter == 1)) { registry.fill(HIST("Data/Mft/hAmbiguityOfMftTracks"), MftTrackAmbiguityStep::AfterTrackSelection); } // We check if the track is ambiguous or non-ambiguous (QA plots are filled in isAmbiguousMftTrack) // Fill plots only if cutAmbiguousTracks is false (to avoid double counting) - if (isAmbiguousMftTrack(track2, (!cutAmbiguousTracks && sameEvent && (loopCounter == 1)))) { + if (isAmbiguousMftTrack(track2, (!cutAmbiguousTracks && isSameEvent && (loopCounter == 1)))) { // If the MFT track is ambiguous we may cut or not on the ambiguous track - if (sameEvent && (loopCounter == 1)) { + if (isSameEvent && (loopCounter == 1)) { registry.fill(HIST("Data/Mft/hReassociationMftTracks"), ReassociationMftTracks::NotReassociatedMftTracks); } if (cutAmbiguousTracks) { @@ -1950,7 +1950,7 @@ struct HfTaskFlow { } if (reassociatedMftTrack.collisionId() != track2.bestCollisionId()) { - if (sameEvent && (loopCounter == 1)) { + if (isSameEvent && (loopCounter == 1)) { registry.fill(HIST("Data/Mft/hReassociationMftTracks"), ReassociationMftTracks::ReassociatedMftTracks); } } @@ -1972,10 +1972,10 @@ struct HfTaskFlow { continue; } - if (configCentral.isApplyPtOrderingSameEvent && sameEvent && (track1.pt() <= reassociatedMftTrack.pt())) { + if (configCentral.isApplyPtOrderingSameEvent && isSameEvent && (track1.pt() <= reassociatedMftTrack.pt())) { continue; } - if (configCentral.isApplyPtOrderingMixedEvent && !sameEvent && (track1.pt() <= reassociatedMftTrack.pt())) { + if (configCentral.isApplyPtOrderingMixedEvent && !isSameEvent && (track1.pt() <= reassociatedMftTrack.pt())) { continue; } @@ -2013,7 +2013,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for associated particle - if (sameEvent && (loopCounter == 1)) { + if (isSameEvent && (loopCounter == 1)) { if constexpr (std::is_same_v) { fillAssociatedQa(multiplicity, eta2, phi2); registry.fill(HIST("Data/Mft/hPtMft"), pt2); @@ -2032,8 +2032,8 @@ struct HfTaskFlow { template void fillCorrelationsFIT(TTarget target, CorrelationContainer::CFStep step, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TFits const&, - float multiplicity, float posZ, bool sameEvent, int fitType, float centralityWeight) + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, TFits const&, + float multiplicity, float posZ, bool isSameEvent, int fitType, float centralityWeight) { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; @@ -2041,7 +2041,7 @@ struct HfTaskFlow { int sampleIndex = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE - for (auto const& track1 : tracks1) { + for (auto const& track1 : tracksTrigger) { loopCounter++; if constexpr (std::is_same_v) { @@ -2049,7 +2049,7 @@ struct HfTaskFlow { continue; } } else if constexpr (std::is_same_v) { - if (sameEvent && loopCounter == 1) { // To avoid double counting, we fill the plots only the first time + if (isSameEvent && loopCounter == 1) { // To avoid double counting, we fill the plots only the first time registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::NoSelection); if (!isAcceptedMftTrack(track1, 0.f, 0.f, true)) { @@ -2131,7 +2131,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for trigger particle - if (sameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { if constexpr (!std::is_same_v) { // If not FilteredMftTracks as trigger -> TPC-FV0a correlations if constexpr (std::is_same_v) { // IF D0 CASE -> TPC-FV0a D0-h if constexpr (std::is_same_v) { // IF NEITHER D0 NOR LC -> @@ -2200,7 +2200,7 @@ struct HfTaskFlow { // } // // FILL QA PLOTS for associated particle - // if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + // if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { // if constexpr (!std::is_same_v) { // If not FilteredMftTracks as trigger -> TPC-FV0a correlations // if constexpr (std::is_same_v) { // IF D0 CASE -> TPC-FV0a D0-h // fillAssociatedQa(multiplicity, eta2, phi2); @@ -2222,9 +2222,9 @@ struct HfTaskFlow { // select the right channel size if it is FT0a or FT0c std::size_t channelSize = 0; if (fitType == isFT0C) { - channelSize = tracks2.channelC().size(); + channelSize = tracksAssoc.channelC().size(); } else if (fitType == isFT0A) { - channelSize = tracks2.channelA().size(); + channelSize = tracksAssoc.channelA().size(); } else { LOGF(fatal, "Cor Index %d out of range", fitType); } @@ -2233,7 +2233,7 @@ struct HfTaskFlow { int channelId = 0; float amplitude = 0.; - getChannel(tracks2, indexChannel, channelId, fitType, amplitude); + getChannel(tracksAssoc, indexChannel, channelId, fitType, amplitude); auto phi2 = getPhiFT0(channelId, fitType); auto eta2 = getEtaFT0(channelId, fitType); float deltaPhi = phi1 - phi2; @@ -2256,7 +2256,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for associated particle - if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { if constexpr (!std::is_same_v) { // If not FilteredMftTracks as trigger -> TPC-Ft0a correlations if constexpr (std::is_same_v) { // IF D0 CASE -> TPC-FV0a D0-h if (fitType == isFT0A) { @@ -2293,8 +2293,8 @@ struct HfTaskFlow { template void fillCorrelationsFITReassociatedMftTracks(TTarget target, CorrelationContainer::CFStep step, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TFits const&, - float multiplicity, float posZ, bool sameEvent, bool cutAmbiguousTracks, int fitType, float centralityWeight) + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, TFits const&, + float multiplicity, float posZ, bool isSameEvent, bool cutAmbiguousTracks, int fitType, float centralityWeight) { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; @@ -2302,7 +2302,7 @@ struct HfTaskFlow { int sampleIndex = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE - for (auto const& track1 : tracks1) { + for (auto const& track1 : tracksTrigger) { loopCounter++; auto reassociatedMftTrack = track1.template mfttrack_as(); @@ -2317,7 +2317,7 @@ struct HfTaskFlow { reassociatedMftTrackDcaZ = track1.bestDCAZ(); } - if (sameEvent && loopCounter == 1) { // To avoid double counting, we fill the plots only the first time + if (isSameEvent && loopCounter == 1) { // To avoid double counting, we fill the plots only the first time registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::NoSelection); if (!isAcceptedMftTrack(reassociatedMftTrack, reassociatedMftTrackDcaXY, reassociatedMftTrackDcaZ, true)) { @@ -2354,7 +2354,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for trigger particle - if (sameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { if constexpr (std::is_same_v) { fillTriggerQa(multiplicity, eta1, phi1, pt1); } else if constexpr (std::is_same_v) { @@ -2384,7 +2384,7 @@ struct HfTaskFlow { // } // // FILL QA PLOTS for associated particle - // if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + // if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { // fillAssociatedQa(multiplicity, eta2, phi2); // } // end of if condition to fill QA plots for associated particle // } // end of loop over FV0 channel indices @@ -2396,9 +2396,9 @@ struct HfTaskFlow { // select the right channel size if it is FT0a or FT0c std::size_t channelSize = 0; if (fitType == isFT0C) { - channelSize = tracks2.channelC().size(); + channelSize = tracksAssoc.channelC().size(); } else if (fitType == isFT0A) { - channelSize = tracks2.channelA().size(); + channelSize = tracksAssoc.channelA().size(); } else { LOGF(fatal, "Cor Index %d out of range", fitType); } @@ -2407,7 +2407,7 @@ struct HfTaskFlow { int channelId = 0; float amplitude = 0.; - getChannel(tracks2, indexChannel, channelId, fitType, amplitude); + getChannel(tracksAssoc, indexChannel, channelId, fitType, amplitude); auto phi2 = getPhiFT0(channelId, fitType); auto eta2 = getEtaFT0(channelId, fitType); float deltaPhi = phi1 - phi2; @@ -2425,7 +2425,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for associated particle - if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { if (fitType == isFT0A) { fillAssociatedQa(multiplicity, eta2, phi2); } @@ -2438,7 +2438,7 @@ struct HfTaskFlow { template void fillCorrelationsFt0aFt0c(TTarget target, CorrelationContainer::CFStep step, TFT0As const& ft0as, TFT0Cs const& ft0cs, - float multiplicity, float posZ, bool sameEvent, float centralityWeight) + float multiplicity, float posZ, bool isSameEvent, float centralityWeight) { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; @@ -2463,7 +2463,7 @@ struct HfTaskFlow { registry.fill(HIST("Trig_hist_FT0A_FT0C"), sampleIndex, posZ, 0.5, amplitudeA * centralityWeight * triggerWeight); } - if (sameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { fillTriggerQa(multiplicity, etaA, phiA, 0.5); } // end of fill trigger QA @@ -2488,7 +2488,7 @@ struct HfTaskFlow { amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); } - if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { fillAssociatedQa(multiplicity, etaC, phiC); } // end of fill associated QA } // end of associated loop @@ -2497,8 +2497,8 @@ struct HfTaskFlow { template void fillCorrelationsMonteCarlo(TTarget target, CorrelationContainer::CFStep step, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, - float multiplicity, float posZ, bool sameEvent) + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, + float multiplicity, float posZ, bool isSameEvent) { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; @@ -2516,7 +2516,7 @@ struct HfTaskFlow { } } - for (auto const& track1 : tracks1) { + for (auto const& track1 : tracksTrigger) { loopCounter++; if (track1.eta() < configTask.etaMcParticlesTriggerMin || track1.eta() > configTask.etaMcParticlesTriggerMax) { @@ -2539,7 +2539,7 @@ struct HfTaskFlow { } // FILL QA FOR TRIGGER PARTICLE - if (sameEvent && fillQaPlots) { + if (isSameEvent && fillQaPlots) { registry.fill(HIST("MC/hEfficiencyTrigger"), track1.pt(), track1.eta(), posZ); if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); @@ -2560,7 +2560,7 @@ struct HfTaskFlow { } } - for (auto const& track2 : tracks2) { + for (auto const& track2 : tracksAssoc) { if (track1.globalIndex() == track2.globalIndex()) { continue; @@ -2590,7 +2590,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for associated particle - if (sameEvent && fillQaPlots && (loopCounter == 1)) { + if (isSameEvent && fillQaPlots && (loopCounter == 1)) { registry.fill(HIST("MC/hEfficiencyAssociated"), track2.pt(), track2.eta(), posZ); if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { fillAssociatedQa(multiplicity, track2.eta(), track2.phi()); @@ -2620,7 +2620,7 @@ struct HfTaskFlow { template void mixCollisions(TCollisions const& collisions, CorrelationContainer::CFStep step, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, OutputObj& corrContainer, aod::BCsWithTimestamps const&) { // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { @@ -2628,8 +2628,8 @@ struct HfTaskFlow { // return multiplicity; // }; - auto getMultiplicity = [&tracks1, this](FilteredCollisionsWSelMult::iterator const& collision) { - auto associatedTracks = tracks1.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); + auto getMultiplicity = [&tracksTrigger, this](FilteredCollisionsWSelMult::iterator const& collision) { + auto associatedTracks = tracksTrigger.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); // auto mult = 0.f; if (configCollision.useMultiplicityFromTracks) { return associatedTracks.size(); @@ -2642,7 +2642,7 @@ struct HfTaskFlow { using BinningTypeData = FlexibleBinningPolicy, aod::collision::PosZ, decltype(getMultiplicity)>; BinningTypeData binningWithTracksSize{{getMultiplicity}, {configAxis.binsMixingVertex, configAxis.binsMixingMultiplicity}, true}; - auto tracksTuple = std::make_tuple(tracks1, tracks2); + auto tracksTuple = std::make_tuple(tracksTrigger, tracksAssoc); Pair pair{binningWithTracksSize, configTask.nMixedEvents, -1, collisions, tracksTuple, &cache}; for (const auto& [collision1, tracks1, collision2, tracks2] : pair) { @@ -2682,7 +2682,7 @@ struct HfTaskFlow { template void mixCollisionsBis(TCollisions const& collisions, CorrelationContainer::CFStep step, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TPresliceTrigger const& presliceTrigger, TPresliceAssociated const& presliceAssociated, + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, TPresliceTrigger const& presliceTrigger, TPresliceAssociated const& presliceAssociated, OutputObj& corrContainer, aod::BCsWithTimestamps const&) { // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { @@ -2690,8 +2690,8 @@ struct HfTaskFlow { // return multiplicity; // }; - auto getMultiplicity = [&tracks1, this](FilteredCollisionsWSelMult::iterator const& collision) { - auto associatedTracks = tracks1.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); + auto getMultiplicity = [&tracksTrigger, this](FilteredCollisionsWSelMult::iterator const& collision) { + auto associatedTracks = tracksTrigger.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); auto mult = associatedTracks.size(); if (configCollision.useMultiplicityFromTracks) { return mult; @@ -2719,7 +2719,7 @@ struct HfTaskFlow { loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks1.size(); + multiplicity = tracksTrigger.size(); } else { multiplicity = getMultiplicityEstimator(collision1, false); } @@ -2736,8 +2736,8 @@ struct HfTaskFlow { } } - auto slicedTriggerTracks = tracks1.sliceBy(presliceTrigger, collision1.globalIndex()); - auto slicedAssociatedTracks = tracks2.sliceBy(presliceAssociated, collision2.globalIndex()); + auto slicedTriggerTracks = tracksTrigger.sliceBy(presliceTrigger, collision1.globalIndex()); + auto slicedAssociatedTracks = tracksAssoc.sliceBy(presliceAssociated, collision2.globalIndex()); corrContainer->fillEvent(multiplicity, step); fillCorrelations(corrContainer, step, slicedTriggerTracks, slicedAssociatedTracks, multiplicity, collision1.posZ(), false, getMagneticField(bc.timestamp()), centralityWeight); @@ -2746,7 +2746,7 @@ struct HfTaskFlow { template void mixCollisionsReassociatedMftTracks(TCollisions const& collisions, CorrelationContainer::CFStep step, TTracksTpc const& tracksTpc, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TPresliceTrigger const& presliceTrigger, TPresliceAssociated const& presliceAssociated, + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, TPresliceTrigger const& presliceTrigger, TPresliceAssociated const& presliceAssociated, OutputObj& corrContainer, bool cutAmbiguousTracks, aod::BCsWithTimestamps const&) { // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { @@ -2800,24 +2800,24 @@ struct HfTaskFlow { // if TPC-MFT cases if constexpr (std::is_same_v) { - auto slicedTriggerTracks = tracks1.sliceBy(presliceTrigger, collision1.globalIndex()); - auto slicedAssociatedTracks = tracks2.sliceBy(presliceAssociated, collision2.globalIndex()); + auto slicedTriggerTracks = tracksTrigger.sliceBy(presliceTrigger, collision1.globalIndex()); + auto slicedAssociatedTracks = tracksAssoc.sliceBy(presliceAssociated, collision2.globalIndex()); corrContainer->fillEvent(multiplicity, step); fillCorrelationsReassociatedMftTracks(corrContainer, step, slicedTriggerTracks, slicedAssociatedTracks, multiplicity, collision1.posZ(), false, cutAmbiguousTracks, centralityWeight); } else if ((collision1.has_foundFT0() && collision2.has_foundFT0())) { // if MFT-FT0A cases - auto slicedTriggerTracks = tracks1.sliceBy(presliceTrigger, collision1.globalIndex()); + auto slicedTriggerTracks = tracksTrigger.sliceBy(presliceTrigger, collision1.globalIndex()); const auto& ft0 = collision2.foundFT0(); corrContainer->fillEvent(multiplicity, step); - fillCorrelationsFITReassociatedMftTracks(corrContainer, step, slicedTriggerTracks, ft0, tracks2, multiplicity, collision1.posZ(), false, cutAmbiguousTracks, isFT0A, centralityWeight); + fillCorrelationsFITReassociatedMftTracks(corrContainer, step, slicedTriggerTracks, ft0, tracksAssoc, multiplicity, collision1.posZ(), false, cutAmbiguousTracks, isFT0A, centralityWeight); } } // end of for loop } template void mixCollisionsFIT(TCollisions const& collisions, CorrelationContainer::CFStep step, TTracksTpc const& tracksTpc, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TPreslice const& preslice, + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, TPreslice const& preslice, OutputObj& corrContainer, int fitType, aod::BCsWithTimestamps const&) { // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { @@ -2825,8 +2825,8 @@ struct HfTaskFlow { // return multiplicity; // }; - auto getMultiplicity = [&tracks1, this](FilteredCollisionsWSelMult::iterator const& collision) { - auto associatedTracks = tracks1.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); + auto getMultiplicity = [&tracksTrigger, this](FilteredCollisionsWSelMult::iterator const& collision) { + auto associatedTracks = tracksTrigger.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); auto mult = associatedTracks.size(); if (configCollision.useMultiplicityFromTracks) { return mult; @@ -2854,7 +2854,7 @@ struct HfTaskFlow { // if constexpr (std::is_same_v) { // IF ASSOCIATED PARTICLE FROM FV0A // if (collision1.has_foundFV0() && collision2.has_foundFV0()) { - // auto slicedTriggerTracks = tracks1.sliceBy(preslice, collision1.globalIndex()); + // auto slicedTriggerTracks = tracksTrigger.sliceBy(preslice, collision1.globalIndex()); // auto tracksForMultiplicity = tracksTpc.sliceByCached(o2::aod::track::collisionId, collision1.globalIndex(), cache); // const auto& fv0 = collision2.foundFV0(); @@ -2877,7 +2877,7 @@ struct HfTaskFlow { if constexpr (std::is_same_v) { if (collision1.has_foundFT0() && collision2.has_foundFT0()) { - auto slicedTriggerTracks = tracks1.sliceBy(preslice, collision1.globalIndex()); + auto slicedTriggerTracks = tracksTrigger.sliceBy(preslice, collision1.globalIndex()); auto tracksForMultiplicity = tracksTpc.sliceByCached(o2::aod::track::collisionId, collision1.globalIndex(), cache); const auto& ft0 = collision2.foundFT0(); @@ -2901,7 +2901,7 @@ struct HfTaskFlow { } corrContainer->fillEvent(multiplicity, step); - fillCorrelationsFIT(corrContainer, step, slicedTriggerTracks, ft0, tracks2, multiplicity, collision1.posZ(), false, fitType, centralityWeight); + fillCorrelationsFIT(corrContainer, step, slicedTriggerTracks, ft0, tracksAssoc, multiplicity, collision1.posZ(), false, fitType, centralityWeight); } } // end of if condition for TPC-FT0 or MFT-FT0s } // end of for loop