From 8589d36b7595040380d2245fdc1ea25e80479434 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Mon, 5 Oct 2026 13:19:41 +0200 Subject: [PATCH 1/9] update --- PWGHF/HFC/Tasks/taskFlow.cxx | 661 +++++++++++++++++++++++------------ 1 file changed, 429 insertions(+), 232 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 1337864b67b..372e3ce68e0 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -234,6 +234,8 @@ struct HfTaskFlow { Configurable nMixedEvents{"nMixedEvents", 5, "Number of mixed events per event"}; Configurable nSamples{"nSamples", 10, "number of different samples for correlations"}; Configurable nameCorrelationContainer{"nameCorrelationContainer", "", "Add the possibility to the rename the correlation container as configurable"}; + Configurable removeQAForSystematics{"removeQAForSystematics", false, "Remove QA plots for systematics, deactivate all plots except trigger hist"}; + Configurable useCutNeutralParticles{"useCutNeutralParticles", false, "Choose to use or not use neutral particles in the correlation analysis"}; Configurable useEfficiencyCorrection{"useEfficiencyCorrection", false, "Choose to use or not use efficiency correction, if not used, weight is set to 1"}; Configurable useOnlyPrimaryInMc{"useOnlyPrimaryInMc", false, "Choose to use or not use only primaries for McGen"}; } configTask; @@ -419,7 +421,7 @@ struct HfTaskFlow { // Filters & partitions : MC // ========================= - Filter mcParticleFilter = (((aod::mcparticle::eta > configTask.etaMcParticlesTriggerMin) && (aod::mcparticle::eta < configTask.etaMcParticlesTriggerMax)) || ((aod::mcparticle::eta > configTask.etaMcParticlesAssocMin) && (aod::mcparticle::eta < configTask.etaMcParticlesAssocMax)) || (nabs(aod::mcparticle::eta) < configCentral.etaCentralTrackMax)) && (aod::mcparticle::pt > configTask.ptMcParticlesTriggerMin) && (aod::mcparticle::pt < configTask.ptMcParticlesTriggerMax); + Filter mcParticleFilter = (((aod::mcparticle::eta > configTask.etaMcParticlesTriggerMin) && (aod::mcparticle::eta < configTask.etaMcParticlesTriggerMax)) || ((aod::mcparticle::eta > configTask.etaMcParticlesAssocMin) && (aod::mcparticle::eta < configTask.etaMcParticlesAssocMax)) || (nabs(aod::mcparticle::eta) < configCentral.etaCentralTrackMax)) && (aod::mcparticle::pt < configTask.ptMcParticlesTriggerMax); // Filter for MCcollisions Filter mcCollisionFilter = nabs(aod::mccollision::posZ) < configCollision.zVertexMax; @@ -454,6 +456,7 @@ struct HfTaskFlow { 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 axisChi2Ndf{"axisChi2Ndf", {100, 0, 100}, "chi2/ndf axis for MFT 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"}; @@ -546,6 +549,7 @@ struct HfTaskFlow { registry.get(HIST("Data/Mft/hReassociationMftTracks"))->GetXaxis()->SetBinLabel(iBin + 1, labelsReassociationMftTracks[iBin].data()); } + registry.add("Data/Mft/hChi2OverNdfMft", "", {HistType::kTH1D, {configAxis.axisChi2Ndf}}); 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}}); @@ -581,47 +585,51 @@ struct HfTaskFlow { rctChecker.init(configCollision.setRCTFlagCheckerLabel, configCollision.requireZDCCheck, configCollision.requireRCTFlagCheckerLimitAcceptanceAsBad, true); correlationAnalysisRctChecker.init({kFT0Bad, kITSBad, kTPCBadTracking, kTPCBadPID, kMFTBad, kITSLimAccMCRepr, kMFTLimAccMCRepr, kTPCLimAccMCRepr}); - 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]; - labels[EventSelectionStep::AllEvents] = "all"; - labels[EventSelectionStep::AfterEventSelection] = "after Physics selection"; - registry.get(HIST("Data/hEventCounter"))->SetMinimum(0); - - for (int iBin = 0; iBin < EventSelectionStep::NEventSelectionSteps; iBin++) { - registry.get(HIST("Data/hEventCounter"))->GetXaxis()->SetBinLabel(iBin + 1, labels[iBin].data()); - } - - registry.add("Data/hPreciseEventCounter", "hPreciseEventCounter", {HistType::kTH1D, {{SpecificEventSelectionStep::NSpecificEventSelectionSteps, -0.5, +SpecificEventSelectionStep::NSpecificEventSelectionSteps - 0.5}}}); - std::string labelsPreciseEventSelection[SpecificEventSelectionStep::NSpecificEventSelectionSteps]; - labelsPreciseEventSelection[SpecificEventSelectionStep::AllEventsPrecise] = "all"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsSel8] = "sel8"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoSameBunchPileup] = "IsNoSameBunchPileup"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsGoodItsLayersAll] = "IsGoodItsLayersAll"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsGoodZvtxFT0vsPV] = "IsGoodZvtxFT0vsPV"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoCollInRofStandard] = "IsNoCollInRofStandard"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoCollInRofStrict] = "IsNoCollInRofStrict"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoCollInTimeRangeStandard] = "IsNoCollInTimeRangeStandard"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoCollInTimeRangeStrict] = "IsNoCollInTimeRangeStrict"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoHighMultCollInPrevRof] = "IsNoHighMultCollInPrevRof"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsRctFlagChecked] = "IsRctFlagChecked"; - registry.get(HIST("Data/hPreciseEventCounter"))->SetMinimum(0); - - for (int iBin = 0; iBin < SpecificEventSelectionStep::NSpecificEventSelectionSteps; iBin++) { - registry.get(HIST("Data/hPreciseEventCounter"))->GetXaxis()->SetBinLabel(iBin + 1, labelsPreciseEventSelection[iBin].data()); - } - - mPairCuts.SetHistogramRegistry(®istry); - if (configCentral.pairCut->get("Photon") > 0 || configCentral.pairCut->get("K0") > 0 || configCentral.pairCut->get("Lambda") > 0 || configCentral.pairCut->get("Phi") > 0 || configCentral.pairCut->get("Rho") > 0) { - mPairCuts.SetPairCut(PairCuts::Photon, configCentral.pairCut->get("Photon")); - mPairCuts.SetPairCut(PairCuts::K0, configCentral.pairCut->get("K0")); - mPairCuts.SetPairCut(PairCuts::Lambda, configCentral.pairCut->get("Lambda")); - mPairCuts.SetPairCut(PairCuts::Phi, configCentral.pairCut->get("Phi")); - mPairCuts.SetPairCut(PairCuts::Rho, configCentral.pairCut->get("Rho")); + if (!configTask.removeQAForSystematics) { + 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/hCentralityWeighted", "", {HistType::kTH1D, {configAxis.axisCentrality}}); + registry.add("Data/hCentralityUsed", "", {HistType::kTH1D, {configAxis.axisCentrality}}); + + registry.add("Data/hEventCounter", "hEventCounter", {HistType::kTH1D, {{EventSelectionStep::NEventSelectionSteps, -0.5, +EventSelectionStep::NEventSelectionSteps - 0.5}}}); + std::string labels[EventSelectionStep::NEventSelectionSteps]; + labels[EventSelectionStep::AllEvents] = "all"; + labels[EventSelectionStep::AfterEventSelection] = "after Physics selection"; + registry.get(HIST("Data/hEventCounter"))->SetMinimum(0); + + for (int iBin = 0; iBin < EventSelectionStep::NEventSelectionSteps; iBin++) { + registry.get(HIST("Data/hEventCounter"))->GetXaxis()->SetBinLabel(iBin + 1, labels[iBin].data()); + } + + registry.add("Data/hPreciseEventCounter", "hPreciseEventCounter", {HistType::kTH1D, {{SpecificEventSelectionStep::NSpecificEventSelectionSteps, -0.5, +SpecificEventSelectionStep::NSpecificEventSelectionSteps - 0.5}}}); + std::string labelsPreciseEventSelection[SpecificEventSelectionStep::NSpecificEventSelectionSteps]; + labelsPreciseEventSelection[SpecificEventSelectionStep::AllEventsPrecise] = "all"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsSel8] = "sel8"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoSameBunchPileup] = "IsNoSameBunchPileup"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsGoodItsLayersAll] = "IsGoodItsLayersAll"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsGoodZvtxFT0vsPV] = "IsGoodZvtxFT0vsPV"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoCollInRofStandard] = "IsNoCollInRofStandard"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoCollInRofStrict] = "IsNoCollInRofStrict"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoCollInTimeRangeStandard] = "IsNoCollInTimeRangeStandard"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoCollInTimeRangeStrict] = "IsNoCollInTimeRangeStrict"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoHighMultCollInPrevRof] = "IsNoHighMultCollInPrevRof"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsRctFlagChecked] = "IsRctFlagChecked"; + registry.get(HIST("Data/hPreciseEventCounter"))->SetMinimum(0); + + for (int iBin = 0; iBin < SpecificEventSelectionStep::NSpecificEventSelectionSteps; iBin++) { + registry.get(HIST("Data/hPreciseEventCounter"))->GetXaxis()->SetBinLabel(iBin + 1, labelsPreciseEventSelection[iBin].data()); + } + + mPairCuts.SetHistogramRegistry(®istry); + if (configCentral.pairCut->get("Photon") > 0 || configCentral.pairCut->get("K0") > 0 || configCentral.pairCut->get("Lambda") > 0 || configCentral.pairCut->get("Phi") > 0 || configCentral.pairCut->get("Rho") > 0) { + mPairCuts.SetPairCut(PairCuts::Photon, configCentral.pairCut->get("Photon")); + mPairCuts.SetPairCut(PairCuts::K0, configCentral.pairCut->get("K0")); + mPairCuts.SetPairCut(PairCuts::Lambda, configCentral.pairCut->get("Lambda")); + mPairCuts.SetPairCut(PairCuts::Phi, configCentral.pairCut->get("Phi")); + mPairCuts.SetPairCut(PairCuts::Rho, configCentral.pairCut->get("Rho")); + } } // ========================= @@ -659,7 +667,9 @@ struct HfTaskFlow { // ========================= if (doprocessSameTpcTpcChCh) { - addHistograms(); + if (!configTask.removeQAForSystematics) { + addHistograms(); + } if (!configTask.doEtaDependentFlow) { sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); @@ -671,14 +681,18 @@ struct HfTaskFlow { } if (doprocessSameTpcTpcD0Ch) { - addHistograms(); + if (!configTask.removeQAForSystematics) { + addHistograms(); + } sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); } if (doprocessSameTpcTpcLcCh) { - addHistograms(); + if (!configTask.removeQAForSystematics) { + addHistograms(); + } sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); @@ -689,12 +703,14 @@ struct HfTaskFlow { // ========================= if (doprocessSameTpcMftChCh || doprocessSameTpcMftChChReassociated || doprocessSameTpcMftChChReassociated3d || doprocessSameTpcMftChChNonAmbiguous) { - addHistograms(); - addMftHistograms(); - 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_vs_corrected", "", {HistType::kTH2D, {{configAxis.axisMultiplicity}, {configAxis.axisMultiplicity}}}); + + if (!configTask.removeQAForSystematics) { + addHistograms(); + addMftHistograms(); + 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_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}}}); @@ -712,16 +728,21 @@ struct HfTaskFlow { } if (doprocessSameTpcMftD0Ch || doprocessSameTpcMftD0ChReassociated) { - addHistograms(); - addMftHistograms(); + if (!configTask.removeQAForSystematics) { + addHistograms(); + addMftHistograms(); + } sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); } if (doprocessSameTpcMftLcCh || doprocessSameTpcMftLcChReassociated) { - addHistograms(); - addMftHistograms(); + + if (!configTask.removeQAForSystematics) { + addHistograms(); + addMftHistograms(); + } sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); @@ -780,9 +801,11 @@ struct HfTaskFlow { // ========================= if (doprocessSameTpcFt0aChCh) { - addHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + if (!configTask.removeQAForSystematics) { + addHistograms(); + registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { registry.add("Trig_hist_TPC_FT0A", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); @@ -800,18 +823,24 @@ struct HfTaskFlow { } if (doprocessSameTpcFt0aD0Ch) { - addHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + if (!configTask.removeQAForSystematics) { + addHistograms(); + registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + } sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); } if (doprocessSameTpcFt0aLcCh) { - addHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + if (!configTask.removeQAForSystematics) { + addHistograms(); + registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + } sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); @@ -822,10 +851,13 @@ struct HfTaskFlow { // ========================= if (doprocessSameMftFt0aChCh || doprocessSameMftFt0aChChReassociated || doprocessSameMftFt0aChChReassociated3d || doprocessSameMftFt0aChChNonAmbiguous) { - addHistograms(); - addMftHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + if (!configTask.removeQAForSystematics) { + addHistograms(); + addMftHistograms(); + registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { registry.add("Trig_hist_MFT_FT0A", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); @@ -847,9 +879,12 @@ struct HfTaskFlow { // ========================= if (doprocessSameTpcFt0cChCh) { - addHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + if (!configTask.removeQAForSystematics) { + addHistograms(); + registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { registry.add("Trig_hist_TPC_FT0C", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); @@ -867,18 +902,24 @@ struct HfTaskFlow { } if (doprocessSameTpcFt0cD0Ch) { - addHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + if (!configTask.removeQAForSystematics) { + addHistograms(); + registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + } sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); } if (doprocessSameTpcFt0cLcCh) { - addHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + if (!configTask.removeQAForSystematics) { + addHistograms(); + registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + } sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); @@ -889,9 +930,12 @@ struct HfTaskFlow { // ========================= if (doprocessSameFt0aFt0cChCh) { - addHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + if (!configTask.removeQAForSystematics) { + addHistograms(); + registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { registry.add("Trig_hist_FT0A_FT0C", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); @@ -914,25 +958,27 @@ struct HfTaskFlow { if (doprocessSameMcGen) { - registry.add("MC/hEfficiencyTrigger", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); - registry.add("MC/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtAssoc}, {configAxis.axisEtaAssociated}, {configAxis.axisVertex}}}); - - if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFv0a)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFv0a)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0a)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFt0a)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0c)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::Ft0aFt0c)) { - addHistograms(); + if (!configTask.removeQAForSystematics) { + registry.add("MC/hEfficiencyTrigger", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); + registry.add("MC/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtAssoc}, {configAxis.axisEtaAssociated}, {configAxis.axisVertex}}}); + + if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFv0a)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFv0a)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0a)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFt0a)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0c)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::Ft0aFt0c)) { + addHistograms(); + } } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -951,12 +997,15 @@ 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}}}); + if (!configTask.removeQAForSystematics) { + 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}}}); + } } + registry.print(); } // End of init() function // ========================= @@ -1004,22 +1053,22 @@ struct HfTaskFlow { { switch (configCollision.multiplicityEstimator) { case MultiplicityEstimators::MultNTracksPV: - if (isSameEvent) { + if (isSameEvent && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hMultiplicity_multNTracksPV"), collision.multNTracksPV()); } return collision.multNTracksPV(); case MultiplicityEstimators::MultNumContrib: - if (isSameEvent) { + if (isSameEvent && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hMultiplicity_multNumContrib"), collision.numContrib()); } return collision.numContrib(); case MultiplicityEstimators::MultFT0C: - if (isSameEvent) { + if (isSameEvent && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hMultiplicity_multFT0C"), collision.multFT0C()); } return collision.multFT0C(); case MultiplicityEstimators::MultFT0M: - if (isSameEvent) { + if (isSameEvent && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hMultiplicity_multFT0M"), collision.multFT0M()); } return collision.multFT0M(); @@ -1033,17 +1082,17 @@ struct HfTaskFlow { { switch (configCollision.centralityEstimator) { case CentralityEstimators::CentFT0C: - if (isSameEvent) { + if (isSameEvent && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hCentrality_centFT0C"), collision.centFT0C()); } return collision.centFT0C(); case CentralityEstimators::CentFT0CVariant1: - if (isSameEvent) { + if (isSameEvent && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hCentrality_centFT0CVariant1"), collision.centFT0CVariant1()); } return collision.centFT0CVariant1(); case CentralityEstimators::CentFT0M: - if (isSameEvent) { + if (isSameEvent && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hCentrality_centFT0M"), collision.centFT0M()); } return collision.centFT0M(); @@ -1184,9 +1233,13 @@ struct HfTaskFlow { } else { LOGF(fatal, "Cor Index %d out of range", fitType); } - registry.fill(HIST("Data/FT0Amp"), rID, amplitude); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/FT0Amp"), rID, amplitude); + } amplitude = amplitude / cstFT0RelGain[id]; - registry.fill(HIST("Data/FT0AmpCorr"), rID, amplitude); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/FT0AmpCorr"), rID, amplitude); + } } void loadGain(aod::BCsWithTimestamps::iterator const& bc) @@ -1335,6 +1388,11 @@ struct HfTaskFlow { if (weight == 0) { return false; } + + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityWeighted"), centrality, weight); + } + weightCent = weight; return true; } @@ -1347,7 +1405,7 @@ struct HfTaskFlow { template bool isAcceptedCollision(TCollision const& collision, bool fillHistograms = false) { - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hEventCounter"), EventSelectionStep::AllEvents); registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::AllEventsPrecise); } @@ -1355,55 +1413,55 @@ struct HfTaskFlow { if (!collision.sel8()) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsSel8); } if (configCollision.isApplySameBunchPileup && !collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsNoSameBunchPileup); } if (configCollision.isApplyGoodItsLayersAll && !collision.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsGoodItsLayersAll); } if (configCollision.isApplyGoodZvtxFT0vsPV && !collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsGoodZvtxFT0vsPV); } if (configCollision.isApplyNoCollInRofStandard && !collision.selection_bit(o2::aod::evsel::kNoCollInRofStandard)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsNoCollInRofStandard); } if (configCollision.isApplyNoCollInRofStrict && !collision.selection_bit(o2::aod::evsel::kNoCollInRofStrict)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsNoCollInRofStrict); } if (configCollision.isApplyNoCollInTimeRangeStandard && !collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsNoCollInTimeRangeStandard); } if (configCollision.isApplyNoCollInTimeRangeStrict && !collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStrict)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsNoCollInTimeRangeStrict); } if (configCollision.isApplyNoHighMultCollInPrevRof && !collision.selection_bit(o2::aod::evsel::kNoHighMultCollInPrevRof)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsNoHighMultCollInPrevRof); } if (configCollision.requireRCTFlagChecker && !rctChecker(collision)) { @@ -1412,12 +1470,14 @@ struct HfTaskFlow { if (configCollision.requireCorrelationAnalysisRCTFlagChecker && !correlationAnalysisRctChecker(collision)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsRctFlagChecked); registry.fill(HIST("Data/hEventCounter"), EventSelectionStep::AfterEventSelection); } - registry.fill(HIST("Data/hVtxZ"), collision.posZ()); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hVtxZ"), collision.posZ()); + } return true; } @@ -1479,7 +1539,7 @@ struct HfTaskFlow { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::Eta); } @@ -1488,7 +1548,7 @@ struct HfTaskFlow { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::Cluster); } @@ -1497,7 +1557,8 @@ struct HfTaskFlow { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { + registry.fill(HIST("Data/Mft/hPtMft"), mftTrack.pt()); registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::Pt); } @@ -1505,14 +1566,14 @@ struct HfTaskFlow { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::DCAxy); } if (configMft.cutOnDcaZ && std::abs(dcaZ) > configMft.mftMaxDCAz) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hDcaXYMft"), dcaXY); registry.fill(HIST("Data/Mft/hDcaZMft"), dcaZ); registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::DCAz); @@ -1525,7 +1586,8 @@ struct HfTaskFlow { return false; } } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { + registry.fill(HIST("Data/Mft/hChi2OverNdfMft"), mftTrack.chi2() / std::max(2.0f * mftTrack.nClusters() - 5.0f, 1.0f)); registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::Chi2OverNdf); } @@ -1537,13 +1599,13 @@ struct HfTaskFlow { return false; } } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::Phi); } // cut on the track algorithm of MFT tracks if (mftTrack.isCA()) { - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::IsCA); registry.fill(HIST("Data/Mft/hPtVsClustersCA"), mftTrack.pt(), mftTrack.nClusters()); } @@ -1553,7 +1615,7 @@ struct HfTaskFlow { } } else { - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::IsLTF); registry.fill(HIST("Data/Mft/hPtVsClustersLTF"), mftTrack.pt(), mftTrack.nClusters()); } @@ -1571,13 +1633,13 @@ struct HfTaskFlow { bool isAmbiguousMftTrack(TTrack const& mftTrack, bool fillHistograms) { if (mftTrack.ambDegree() > 1) { - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hAmbiguityOfMftTracks"), MftTrackAmbiguityStep::NumberOfAmbiguousTracks); } return true; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hAmbiguityOfMftTracks"), MftTrackAmbiguityStep::NumberOfNonAmbiguousTracks); } return false; @@ -1655,7 +1717,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for trigger particle - if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed) && !configTask.removeQAForSystematics) { 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); @@ -1688,7 +1750,9 @@ struct HfTaskFlow { if constexpr (std::is_same_v) { 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 (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::NoSelection); + } if (!isAcceptedMftTrack(track2, 0.f, 0.f, true)) { continue; @@ -1803,7 +1867,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for associated particle - if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed) && !configTask.removeQAForSystematics) { 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); @@ -1815,13 +1879,10 @@ struct HfTaskFlow { } else { // IF TPC-MFT case if constexpr (std::is_same_v) { // IF D0 CASE -> TPC-MFT D0-h fillAssociatedQa(multiplicity, eta2, phi2); - registry.fill(HIST("Data/Mft/hPtMft"), pt2); } else if constexpr (std::is_same_v) { // IF LC CASE -> TPC-MFT Lc-h fillAssociatedQa(multiplicity, eta2, phi2); - registry.fill(HIST("Data/Mft/hPtMft"), pt2); } else { // IF NEITHER D0 NOR LC -> TPC-MFT h-h fillAssociatedQa(multiplicity, eta2, phi2); - registry.fill(HIST("Data/Mft/hPtMft"), pt2); } // end of if condition for TPC-TPC or TPC-MFT case } } @@ -1888,7 +1949,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for trigger particle - if (isSameEvent) { + if (isSameEvent && !configTask.removeQAForSystematics) { if constexpr (std::is_same_v) { fillTriggerQa(multiplicity, eta1, phi1, pt1); } else if constexpr (std::is_same_v) { @@ -1903,7 +1964,7 @@ struct HfTaskFlow { for (const auto& track2 : tracksAssoc) { // Fill QA plot for all MFT tracks () (only if cutAmbiguousTracks is false to avoid double counting) - if (!cutAmbiguousTracks && isSameEvent && (loopCounter == 1)) { + if (!cutAmbiguousTracks && isSameEvent && (loopCounter == 1) && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hAmbiguityOfMftTracks"), MftTrackAmbiguityStep::AllMftTracks); } @@ -1920,7 +1981,10 @@ struct HfTaskFlow { } 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 (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::NoSelection); + } if (!isAcceptedMftTrack(reassociatedMftTrack, reassociatedMftTrackDcaXY, reassociatedMftTrackDcaZ, true)) { continue; @@ -1932,7 +1996,7 @@ struct HfTaskFlow { } // Fill QA plot for MFT tracks after physical selection (eta + clusters) - if (!cutAmbiguousTracks && isSameEvent && (loopCounter == 1)) { + if (!cutAmbiguousTracks && isSameEvent && (loopCounter == 1) && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hAmbiguityOfMftTracks"), MftTrackAmbiguityStep::AfterTrackSelection); } @@ -1940,7 +2004,7 @@ struct HfTaskFlow { // Fill plots only if cutAmbiguousTracks is false (to avoid double counting) if (isAmbiguousMftTrack(track2, (!cutAmbiguousTracks && isSameEvent && (loopCounter == 1)))) { // If the MFT track is ambiguous we may cut or not on the ambiguous track - if (isSameEvent && (loopCounter == 1)) { + if (isSameEvent && (loopCounter == 1) && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hReassociationMftTracks"), ReassociationMftTracks::NotReassociatedMftTracks); } if (cutAmbiguousTracks) { @@ -1949,7 +2013,7 @@ struct HfTaskFlow { } if (reassociatedMftTrack.collisionId() != track2.bestCollisionId()) { - if (isSameEvent && (loopCounter == 1)) { + if (isSameEvent && (loopCounter == 1) && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hReassociationMftTracks"), ReassociationMftTracks::ReassociatedMftTracks); } } @@ -2012,16 +2076,13 @@ struct HfTaskFlow { } // FILL QA PLOTS for associated particle - if (isSameEvent && (loopCounter == 1)) { + if (isSameEvent && (loopCounter == 1) && !configTask.removeQAForSystematics) { if constexpr (std::is_same_v) { fillAssociatedQa(multiplicity, eta2, phi2); - registry.fill(HIST("Data/Mft/hPtMft"), pt2); } else if constexpr (std::is_same_v) { fillAssociatedQa(multiplicity, eta2, phi2); - registry.fill(HIST("Data/Mft/hPtMft"), pt2); } else { fillAssociatedQa(multiplicity, eta2, phi2); - registry.fill(HIST("Data/Mft/hPtMft"), pt2); registry.fill(HIST("Data/hEfficiencyAssociated"), pt2, eta2, posZ); } } // end of fill QA @@ -2049,7 +2110,10 @@ struct HfTaskFlow { } } else if constexpr (std::is_same_v) { 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 (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::NoSelection); + } if (!isAcceptedMftTrack(track1, 0.f, 0.f, true)) { continue; @@ -2130,7 +2194,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for trigger particle - if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed) && !configTask.removeQAForSystematics) { 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 -> @@ -2255,7 +2319,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for associated particle - if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed) && !configTask.removeQAForSystematics) { 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) { @@ -2308,16 +2372,18 @@ struct HfTaskFlow { auto reassociatedMftTrackDcaXY = 0.f; auto reassociatedMftTrackDcaZ = 0.f; - if constexpr (std::is_same_v, TTracksAssoc>) { + if constexpr (std::is_same_v, TTracksTrig>) { reassociatedMftTrackDcaXY = track1.bestDCAXY(); } - if constexpr (std::is_same_v, TTracksAssoc>) { + if constexpr (std::is_same_v, TTracksTrig>) { reassociatedMftTrackDcaXY = track1.bestDCAXY(); reassociatedMftTrackDcaZ = track1.bestDCAZ(); } 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 (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::NoSelection); + } if (!isAcceptedMftTrack(reassociatedMftTrack, reassociatedMftTrackDcaXY, reassociatedMftTrackDcaZ, true)) { continue; @@ -2353,7 +2419,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for trigger particle - if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed) && !configTask.removeQAForSystematics) { if constexpr (std::is_same_v) { fillTriggerQa(multiplicity, eta1, phi1, pt1); } else if constexpr (std::is_same_v) { @@ -2424,7 +2490,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for associated particle - if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed) && !configTask.removeQAForSystematics) { if (fitType == isFT0A) { fillAssociatedQa(multiplicity, eta2, phi2); } @@ -2462,7 +2528,7 @@ struct HfTaskFlow { registry.fill(HIST("Trig_hist_FT0A_FT0C"), sampleIndex, posZ, 0.5, amplitudeA * centralityWeight * triggerWeight); } - if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed) && !configTask.removeQAForSystematics) { fillTriggerQa(multiplicity, etaA, phiA, 0.5); } // end of fill trigger QA @@ -2487,7 +2553,7 @@ struct HfTaskFlow { amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); } - if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed) && !configTask.removeQAForSystematics) { fillAssociatedQa(multiplicity, etaC, phiC); } // end of fill associated QA } // end of associated loop @@ -2518,6 +2584,11 @@ struct HfTaskFlow { for (auto const& track1 : tracksTrigger) { loopCounter++; + if (configTask.useCutNeutralParticles) { + auto pdgTriggerParticle = pdg->GetParticle(track1.pdgCode()); + if (!pdgTriggerParticle || std::abs(pdgTriggerParticle->Charge()) < 0.01) continue; + } + if (track1.eta() < configTask.etaMcParticlesTriggerMin || track1.eta() > configTask.etaMcParticlesTriggerMax) { continue; } @@ -2538,7 +2609,7 @@ struct HfTaskFlow { } // FILL QA FOR TRIGGER PARTICLE - if (isSameEvent && fillQaPlots) { + if (isSameEvent && fillQaPlots && !configTask.removeQAForSystematics) { 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()); @@ -2561,6 +2632,11 @@ struct HfTaskFlow { for (auto const& track2 : tracksAssoc) { + if (configTask.useCutNeutralParticles) { + auto pdgAssociatedParticle = pdg->GetParticle(track2.pdgCode()); + if (!pdgAssociatedParticle || std::abs(pdgAssociatedParticle->Charge()) < 0.01) continue; + } + if (track1.globalIndex() == track2.globalIndex()) { continue; } @@ -2589,7 +2665,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for associated particle - if (isSameEvent && fillQaPlots && (loopCounter == 1)) { + if (isSameEvent && fillQaPlots && (loopCounter == 1) && !configTask.removeQAForSystematics) { registry.fill(HIST("MC/hEfficiencyAssociated"), track2.pt(), track2.eta(), posZ); if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { fillAssociatedQa(multiplicity, track2.eta(), track2.phi()); @@ -2824,8 +2900,8 @@ struct HfTaskFlow { // return multiplicity; // }; - auto getMultiplicity = [&tracksTrigger, this](FilteredCollisionsWSelMult::iterator const& collision) { - auto associatedTracks = tracksTrigger.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); + auto getMultiplicity = [&tracksTpc, this](FilteredCollisionsWSelMult::iterator const& collision) { + auto associatedTracks = tracksTpc.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); auto mult = associatedTracks.size(); if (configCollision.useMultiplicityFromTracks) { return mult; @@ -2994,7 +3070,10 @@ struct HfTaskFlow { return; } - registry.fill(HIST("Data/hNTracks"), tracks.size()); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hNTracks"), tracks.size()); + } + auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; @@ -3005,11 +3084,15 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -3041,7 +3124,10 @@ struct HfTaskFlow { return; } + if (!configTask.removeQAForSystematics) { registry.fill(HIST("Data/hNTracks"), tracks.size()); + } + auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; @@ -3052,11 +3138,17 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } + } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -3088,7 +3180,10 @@ struct HfTaskFlow { return; } - registry.fill(HIST("Data/hNTracks"), tracks.size()); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hNTracks"), tracks.size()); + } + auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; @@ -3099,11 +3194,15 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -3128,7 +3227,10 @@ struct HfTaskFlow { return; } - registry.fill(HIST("Data/hNTracks"), tracks.size()); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hNTracks"), tracks.size()); + } + auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; @@ -3139,11 +3241,15 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -3170,9 +3276,12 @@ struct HfTaskFlow { return; } - registry.fill(HIST("Data/hNTracks"), tracks.size()); - registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); - registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hNTracks"), tracks.size()); + registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); + registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); + } + auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; @@ -3183,11 +3292,17 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } + } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -3213,10 +3328,13 @@ struct HfTaskFlow { if (!(isAcceptedCollision(collision, true))) { return; } + + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hNTracks"), tracks.size()); + registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); + registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); + } - registry.fill(HIST("Data/hNTracks"), tracks.size()); - registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); - registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; @@ -3227,17 +3345,27 @@ struct HfTaskFlow { } auto uncorrectedMultiplicity = multiplicity; - registry.fill(HIST("Data/hMultiplicity_uncorrected_vs_corrected"), uncorrectedMultiplicity, multiplicity); + + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hMultiplicity_uncorrected_vs_corrected"), uncorrectedMultiplicity, multiplicity); + } + if (configCollision.useMultiplicityFromTracksCorrected) { multiplicity = getCorrectedMultiplicity(tracks); } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } + } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -3264,9 +3392,12 @@ struct HfTaskFlow { return; // when process function has iterator } - registry.fill(HIST("Data/hNTracks"), tracks.size()); - registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); - registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hNTracks"), tracks.size()); + registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); + registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); + } + auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; @@ -3277,11 +3408,17 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } + } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -3329,11 +3466,15 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -3366,11 +3507,15 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -3413,11 +3558,15 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -3450,11 +3599,15 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -3670,17 +3823,21 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - 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; - } + float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { + return; + } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; } + } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3721,11 +3878,15 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -3766,11 +3927,15 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -3811,11 +3976,15 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -3858,11 +4027,15 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -3905,11 +4078,15 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -3952,11 +4129,15 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -4002,11 +4183,15 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -4047,11 +4232,15 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -4092,11 +4281,15 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -4136,11 +4329,15 @@ struct HfTaskFlow { } float centralityWeight = 1.0f; + float centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { return; } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } } else { if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; @@ -4605,10 +4802,10 @@ struct HfTaskFlow { auto groupedCollisions1 = collisions.sliceBy(collisionPerMcCollision, collision1.globalIndex()); auto groupedCollisions2 = collisions.sliceBy(collisionPerMcCollision, collision2.globalIndex()); if (groupedCollisions1.size() == 0) { - return; + continue; } if (groupedCollisions2.size() == 0) { - return; + continue; } mixedEvent->fillEvent(multiplicityCollision1, CorrelationContainer::kCFStepAll); From c1908ec4074a9fb78e5c08633cece12352651ba7 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Tue, 6 Oct 2026 16:21:11 +0200 Subject: [PATCH 2/9] make code clearer, add inner and outer selections on FIT --- PWGHF/HFC/Tasks/taskFlow.cxx | 667 ++++++++++++----------------------- 1 file changed, 225 insertions(+), 442 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 372e3ce68e0..e464d7b06bc 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -103,6 +103,24 @@ enum DataType { Mc }; +enum FT0DetectorChannels { + FT0AInnerRingMin = 0, + FT0AInnerRingMax = 31, + FT0AOuterRingMin = 32, + FT0AOuterRingMax = 95, + FT0CInnerRingMin = 96, + FT0CInnerRingMax = 143, + FT0COuterRingMin = 144, + FT0COuterRingMax = 207 +}; + +enum FT0InnerOrOuter { + FT0Error = 0, + FT0InnerRing = 1, + FT0OuterRing = 2, + NFT0InnerOrOuterSteps +}; + enum ReassociationMftTracks { NotReassociatedMftTracks = 0, ReassociatedMftTracks, @@ -336,6 +354,7 @@ struct HfTaskFlow { std::string prefix = "ConfigFit_group"; Configurable cfgGainEqPath{"cfgGainEqPath", "Analysis/EventPlane/GainEq", "CCDB path for gain equalization constants"}; Configurable cfgCorrLevel{"cfgCorrLevel", 1, "calibration step: 0 = no corr, 1 = gain corr"}; + Configurable discriminateInnerOrOuter{"discriminateInnerOrOuter", false, "if true, fill correlationContainer with either Inner ou Outer for FIT, if false, fill with real eta information"}; } configFit; SliceCache cache; @@ -589,6 +608,8 @@ 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("Data/hMultiplicityTracksSize", "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); + registry.add("Data/hMultiplicityUsed", "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); registry.add(Form("Data/hCentrality_%s", WhatCentralityEstimator[configCollision.centralityEstimator].data()), "", {HistType::kTH1D, {configAxis.axisCentrality}}); registry.add("Data/hCentralityWeighted", "", {HistType::kTH1D, {configAxis.axisCentrality}}); registry.add("Data/hCentralityUsed", "", {HistType::kTH1D, {configAxis.axisCentrality}}); @@ -707,8 +728,6 @@ struct HfTaskFlow { if (!configTask.removeQAForSystematics) { addHistograms(); addMftHistograms(); - 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_vs_corrected", "", {HistType::kTH2D, {{configAxis.axisMultiplicity}, {configAxis.axisMultiplicity}}}); } @@ -805,6 +824,12 @@ struct HfTaskFlow { addHistograms(); registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + registry.add("Data/FT0IsInnerOrOuter", "FT0IsInnerOrOuter", {HistType::kTH1D, {{FT0InnerOrOuter::NFT0InnerOrOuterSteps, -0.5, +FT0InnerOrOuter::NFT0InnerOrOuterSteps - 0.5}}}); + std::string labels[FT0InnerOrOuter::NFT0InnerOrOuterSteps]; + labels[FT0InnerOrOuter::FT0InnerRing] = "FT0InnerRing"; + labels[FT0InnerOrOuter::FT0OuterRing] = "FT0OuterRing"; + registry.get(HIST("Data/FT0IsInnerOrOuter"))->SetMinimum(0); } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -857,6 +882,12 @@ struct HfTaskFlow { addMftHistograms(); registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + registry.add("Data/FT0IsInnerOrOuter", "FT0IsInnerOrOuter", {HistType::kTH1D, {{FT0InnerOrOuter::NFT0InnerOrOuterSteps, -0.5, +FT0InnerOrOuter::NFT0InnerOrOuterSteps - 0.5}}}); + std::string labels[FT0InnerOrOuter::NFT0InnerOrOuterSteps]; + labels[FT0InnerOrOuter::FT0InnerRing] = "FT0InnerRing"; + labels[FT0InnerOrOuter::FT0OuterRing] = "FT0OuterRing"; + registry.get(HIST("Data/FT0IsInnerOrOuter"))->SetMinimum(0); } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -884,6 +915,12 @@ struct HfTaskFlow { addHistograms(); registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + registry.add("Data/FT0IsInnerOrOuter", "FT0IsInnerOrOuter", {HistType::kTH1D, {{FT0InnerOrOuter::NFT0InnerOrOuterSteps, -0.5, +FT0InnerOrOuter::NFT0InnerOrOuterSteps - 0.5}}}); + std::string labels[FT0InnerOrOuter::NFT0InnerOrOuterSteps]; + labels[FT0InnerOrOuter::FT0InnerRing] = "FT0InnerRing"; + labels[FT0InnerOrOuter::FT0OuterRing] = "FT0OuterRing"; + registry.get(HIST("Data/FT0IsInnerOrOuter"))->SetMinimum(0); } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -935,6 +972,12 @@ struct HfTaskFlow { addHistograms(); registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + registry.add("Data/FT0IsInnerOrOuter", "FT0IsInnerOrOuter", {HistType::kTH1D, {{FT0InnerOrOuter::NFT0InnerOrOuterSteps, -0.5, +FT0InnerOrOuter::NFT0InnerOrOuterSteps - 0.5}}}); + std::string labels[FT0InnerOrOuter::NFT0InnerOrOuterSteps]; + labels[FT0InnerOrOuter::FT0InnerRing] = "FT0InnerRing"; + labels[FT0InnerOrOuter::FT0OuterRing] = "FT0OuterRing"; + registry.get(HIST("Data/FT0IsInnerOrOuter"))->SetMinimum(0); } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -959,8 +1002,6 @@ struct HfTaskFlow { if (doprocessSameMcGen) { if (!configTask.removeQAForSystematics) { - registry.add("MC/hEfficiencyTrigger", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); - registry.add("MC/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtAssoc}, {configAxis.axisEtaAssociated}, {configAxis.axisVertex}}}); if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { addHistograms(); @@ -1268,6 +1309,43 @@ struct HfTaskFlow { } } + int isInnerOrOuter(int channelId, int fitType) { + if (fitType == isFT0C) { + if (channelId >= FT0DetectorChannels::FT0CInnerRingMin && channelId <= FT0DetectorChannels::FT0CInnerRingMax) { + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/FT0IsInnerOrOuter"), FT0InnerOrOuter::FT0InnerRing); + } + return FT0InnerOrOuter::FT0InnerRing; + } else if (channelId >= FT0DetectorChannels::FT0COuterRingMin && channelId <= FT0DetectorChannels::FT0COuterRingMax) { + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/FT0IsInnerOrOuter"), FT0InnerOrOuter::FT0OuterRing); + } + return FT0InnerOrOuter::FT0OuterRing; + } else { + LOGF(fatal, "Channel ID %d out of range for FT0C", channelId); + return FT0InnerOrOuter::FT0Error; + } + } else if (fitType == isFT0A) { + if (channelId >= FT0DetectorChannels::FT0AInnerRingMin && channelId <= FT0DetectorChannels::FT0AInnerRingMax) { + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/FT0IsInnerOrOuter"), FT0InnerOrOuter::FT0InnerRing); + } + return FT0InnerOrOuter::FT0InnerRing; + } else if (channelId >= FT0DetectorChannels::FT0AOuterRingMin && channelId <= FT0DetectorChannels::FT0AOuterRingMax) { + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/FT0IsInnerOrOuter"), FT0InnerOrOuter::FT0OuterRing); + } + return FT0InnerOrOuter::FT0OuterRing; + } else { + LOGF(fatal, "Channel ID %d out of range for FT0A", channelId); + return FT0InnerOrOuter::FT0Error; + } + } else { + LOGF(fatal, "Fit type %d is not valid for FT0", fitType); + return FT0InnerOrOuter::FT0Error; + } + } + void loadEfficiencyCorrection(uint64_t timestamp) { if (areCorrectionsLoaded) { @@ -1401,6 +1479,39 @@ struct HfTaskFlow { // Cuts with functions // ========================= + template + bool isAcceptedEventActivity(TCollision const& collision, TTracks const& tracks, int& multiplicity, float& centrality, float& centralityWeight) + { + if (configCollision.useMultiplicityFromTracks) { + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hMultiplicityTracksSize"), tracks.size()); + } + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } + + centrality = getCentralityEstimator(collision, true); + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { + return false; + } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return false; + } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hMultiplicityUsed"), multiplicity); + } + } + + return true; + } + // FIXME: Some collisions are rejected here, what causes (part of) differences with the D0 task template bool isAcceptedCollision(TCollision const& collision, bool fillHistograms = false) @@ -1956,7 +2067,6 @@ struct HfTaskFlow { fillTriggerQa(multiplicity, eta1, phi1, pt1); } else { fillTriggerQa(multiplicity, eta1, phi1, pt1); - registry.fill(HIST("Data/hEfficiencyTrigger"), pt1, eta1, posZ); } } @@ -2083,7 +2193,6 @@ struct HfTaskFlow { fillAssociatedQa(multiplicity, eta2, phi2); } else { fillAssociatedQa(multiplicity, eta2, phi2); - registry.fill(HIST("Data/hEfficiencyAssociated"), pt2, eta2, posZ); } } // end of fill QA } // end of loop over tracks2 @@ -2307,8 +2416,13 @@ struct HfTaskFlow { target->getPairHist()->Fill(step, eta1 - eta2, 0.5, pt1, multiplicity, deltaPhi, posZ, amplitude * centralityWeight * triggerWeight * associatedWeight); } else if (configTask.doEtaDependentFlow) { - target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, - amplitude * centralityWeight * triggerWeight * associatedWeight); + if (!configFit.discriminateInnerOrOuter) { + target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, + amplitude * centralityWeight * triggerWeight * associatedWeight); + } else { + target->getPairHist()->Fill(step, sampleIndex, posZ, isInnerOrOuter(channelId, fitType), eta1, deltaPhi, eta1 - eta2, + amplitude * centralityWeight * triggerWeight * associatedWeight); + } } else { target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, amplitude * centralityWeight * triggerWeight * associatedWeight); @@ -2482,8 +2596,13 @@ struct HfTaskFlow { target->getPairHist()->Fill(step, eta1 - eta2, 0.5, pt1, multiplicity, deltaPhi, posZ, amplitude * centralityWeight * triggerWeight * associatedWeight); } else if (configTask.doEtaDependentFlow) { - target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, - amplitude * centralityWeight * triggerWeight * associatedWeight); + if (!configFit.discriminateInnerOrOuter) { + target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, + amplitude * centralityWeight * triggerWeight * associatedWeight); + } else { + target->getPairHist()->Fill(step, sampleIndex, posZ, isInnerOrOuter(channelId, fitType), eta1, deltaPhi, eta1 - eta2, + amplitude * centralityWeight * triggerWeight * associatedWeight); + } } else { target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, amplitude * centralityWeight * triggerWeight * associatedWeight); @@ -2610,7 +2729,6 @@ struct HfTaskFlow { // FILL QA FOR TRIGGER PARTICLE if (isSameEvent && fillQaPlots && !configTask.removeQAForSystematics) { - 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()); } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { @@ -2666,7 +2784,6 @@ struct HfTaskFlow { // FILL QA PLOTS for associated particle if (isSameEvent && fillQaPlots && (loopCounter == 1) && !configTask.removeQAForSystematics) { - registry.fill(HIST("MC/hEfficiencyAssociated"), track2.pt(), track2.eta(), posZ); if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { fillAssociatedQa(multiplicity, track2.eta(), track2.phi()); } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { @@ -3077,26 +3194,11 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3131,30 +3233,14 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } - - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } + float centrality = 0.f; + float centralityWeight = 1.f; - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } + sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, tracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp()), centralityWeight); } @@ -3187,26 +3273,11 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3234,26 +3305,11 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -3285,28 +3341,11 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -3338,38 +3377,20 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } - + float centrality = 0.f; + float centralityWeight = 1.f; auto uncorrectedMultiplicity = multiplicity; if (!configTask.removeQAForSystematics) { registry.fill(HIST("Data/hMultiplicity_uncorrected_vs_corrected"), uncorrectedMultiplicity, multiplicity); } - + if (configCollision.useMultiplicityFromTracksCorrected) { multiplicity = getCorrectedMultiplicity(tracks); } - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -3401,28 +3422,11 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } - - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } + float centrality = 0.f; + float centralityWeight = 1.f; - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -3459,26 +3463,11 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3500,26 +3489,11 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3551,26 +3525,11 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3589,29 +3548,14 @@ struct HfTaskFlow { return; // when process function has iterator } - auto multiplicity = 0; auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + auto multiplicity = 0; + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3815,29 +3759,16 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - registry.fill(HIST("Data/hNTracks"), tracks.size()); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } - - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); + registry.fill(HIST("Data/hNTracks"), tracks.size()); } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + auto multiplicity = 0; + float centrality = 0.f; + float centralityWeight = 1.f; + + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { return; } - } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3871,26 +3802,11 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3920,26 +3836,11 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3969,26 +3870,11 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -4020,26 +3906,11 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -4071,26 +3942,11 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -4122,26 +3978,11 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -4174,28 +4015,15 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - registry.fill(HIST("Data/hNTracks"), tracks.size()); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hNTracks"), tracks.size()); } + auto multiplicity = 0; + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -4225,26 +4053,11 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -4274,26 +4087,11 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -4322,26 +4120,11 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float centrality = 0.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - float centrality = getCentralityEstimator(collision, true); - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, centrality); - if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { - return; - } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityUsed"), centrality); - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); From e192a7690d7fd95daf9e6aef91dc8d4707d036d1 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Tue, 6 Oct 2026 17:08:56 +0200 Subject: [PATCH 3/9] ready to PR --- PWGHF/HFC/Tasks/taskFlow.cxx | 1 + 1 file changed, 1 insertion(+) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index e464d7b06bc..cd07d45b694 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -1020,6 +1020,7 @@ struct HfTaskFlow { } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::Ft0aFt0c)) { addHistograms(); } + } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { From a23ccbca044036a39cf208bb89faec739381dba8 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Wed, 7 Oct 2026 14:27:19 +0200 Subject: [PATCH 4/9] funtioning MC gen --- PWGHF/HFC/Tasks/taskFlow.cxx | 59 +++++++++++++++++++++--------------- 1 file changed, 35 insertions(+), 24 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index cd07d45b694..fc07315c21e 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -82,7 +82,7 @@ using namespace o2::framework; using namespace o2::framework::expressions; enum CorrelationCase { - TpcTpc, + TpcTpc = 0, TpcMft, TpcFv0a, MftFv0a, @@ -395,9 +395,11 @@ struct HfTaskFlow { // ========================= using SmallGroupMcCollisions = soa::SmallGroups>; - using FilteredMcCollisionsWMult = soa::Filtered>; + // using FilteredMcCollisionsWMult = soa::Filtered>; + using FilteredMcCollisionsWMult = soa::Join; using FilteredMcCollisionsWMultWCollsExtra = soa::Filtered>; - using FilteredMcParticles = soa::Filtered; + // using FilteredMcParticles = soa::Filtered; + using FilteredMcParticles = aod::McParticles; // ========================= // Filters & partitions : DATA @@ -440,10 +442,11 @@ struct HfTaskFlow { // Filters & partitions : MC // ========================= - Filter mcParticleFilter = (((aod::mcparticle::eta > configTask.etaMcParticlesTriggerMin) && (aod::mcparticle::eta < configTask.etaMcParticlesTriggerMax)) || ((aod::mcparticle::eta > configTask.etaMcParticlesAssocMin) && (aod::mcparticle::eta < configTask.etaMcParticlesAssocMax)) || (nabs(aod::mcparticle::eta) < configCentral.etaCentralTrackMax)) && (aod::mcparticle::pt < configTask.ptMcParticlesTriggerMax); + // // Filter for McParticles + // Filter mcParticleFilter = (((aod::mcparticle::eta > configTask.etaMcParticlesTriggerMin) && (aod::mcparticle::eta < configTask.etaMcParticlesTriggerMax)) || ((aod::mcparticle::eta > configTask.etaMcParticlesAssocMin) && (aod::mcparticle::eta < configTask.etaMcParticlesAssocMax)) || (nabs(aod::mcparticle::eta) < configCentral.etaCentralTrackMax)) && (aod::mcparticle::pt < configTask.ptMcParticlesTriggerMax); - // Filter for MCcollisions - Filter mcCollisionFilter = nabs(aod::mccollision::posZ) < configCollision.zVertexMax; + // // Filter for MCcollisions + // Filter mcCollisionFilter = nabs(aod::mccollision::posZ) < configCollision.zVertexMax; // ========================= // Preslice : DATA @@ -2666,8 +2669,16 @@ struct HfTaskFlow { target->getPairHist()->Fill(step, etaA - etaC, 0.5, 0.5, multiplicity, deltaPhi, posZ, amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); } else if (configTask.doEtaDependentFlow) { - target->getPairHist()->Fill(step, sampleIndex, posZ, etaC, etaA, deltaPhi, etaA - etaC, - amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); + // target->getPairHist()->Fill(step, sampleIndex, posZ, etaC, etaA, deltaPhi, etaA - etaC, + // amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); + + if (!configFit.discriminateInnerOrOuter) { + target->getPairHist()->Fill(step, sampleIndex, posZ, etaC, etaA, deltaPhi, etaA - etaC, + amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); + } else { + target->getPairHist()->Fill(step, sampleIndex, posZ, isInnerOrOuter(channelIdA, isFT0A), isInnerOrOuter(channelIdC, isFT0C), deltaPhi, etaA - etaC, + amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); + } } else { target->getPairHist()->Fill(step, sampleIndex, posZ, 0.5, multiplicity, deltaPhi, etaA - etaC, amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); @@ -2689,20 +2700,8 @@ struct HfTaskFlow { auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision int sampleIndex = gRandom->Uniform(0, configTask.nSamples); - bool fillQaPlots = false; - - if (configTask.fillOnlyStepAll) { - if (step == CorrelationContainer::kCFStepAll) { - fillQaPlots = true; - } - } else { - if (step == CorrelationContainer::kCFStepTrackedOnlyPrim) { - fillQaPlots = true; - } - } for (auto const& track1 : tracksTrigger) { - loopCounter++; if (configTask.useCutNeutralParticles) { auto pdgTriggerParticle = pdg->GetParticle(track1.pdgCode()); @@ -2729,7 +2728,7 @@ struct HfTaskFlow { } // FILL QA FOR TRIGGER PARTICLE - if (isSameEvent && fillQaPlots && !configTask.removeQAForSystematics) { + if (isSameEvent && !configTask.removeQAForSystematics) { if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { @@ -2748,6 +2747,8 @@ struct HfTaskFlow { fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); } } + + loopCounter++; for (auto const& track2 : tracksAssoc) { @@ -2769,8 +2770,8 @@ struct HfTaskFlow { continue; } - float deltaPhi = RecoDecay::constrainAngle(track2.phi() - track1.phi(), -PIHalf); - float deltaEta = track2.eta() - track1.eta(); + float deltaPhi = RecoDecay::constrainAngle(track1.phi() - track2.phi(), -PIHalf); + float deltaEta = track1.eta() - track2.eta(); if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { target->getPairHist()->Fill(step, deltaEta, track2.pt(), track1.pt(), multiplicity, deltaPhi, posZ, @@ -2784,7 +2785,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for associated particle - if (isSameEvent && fillQaPlots && (loopCounter == 1) && !configTask.removeQAForSystematics) { + if (isSameEvent && (loopCounter == 1) && !configTask.removeQAForSystematics) { if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { fillAssociatedQa(multiplicity, track2.eta(), track2.phi()); } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { @@ -4142,6 +4143,11 @@ struct HfTaskFlow { FilteredMcParticles const& mcParticles, SmallGroupMcCollisions const& collisions) { + + if (mcParticles.size() == 0) { // guard against empty filtered batch + return; + } + auto multiplicity = 0; if (configCollision.useMultiplicityFromTracks) { for (const auto& track : mcParticles) { @@ -4557,6 +4563,11 @@ struct HfTaskFlow { for (auto it = pairs.begin(); it != pairs.end(); it++) { auto& [collision1, tracks1, collision2, tracks2] = *it; + + if (tracks1.size() == 0 || tracks2.size() == 0) { // guard against empty filtered batch + return; + } + auto multiplicityCollision1 = 0; auto multiplicityCollision2 = 0; From 4a76ac927353e700d9820adcb9c23480dd5394df Mon Sep 17 00:00:00 2001 From: AlexianL Date: Wed, 7 Oct 2026 17:02:29 +0200 Subject: [PATCH 5/9] remove magic numbers --- PWGHF/HFC/Tasks/taskFlow.cxx | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index fc07315c21e..0e2f24cf712 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -186,6 +186,7 @@ enum SpecificEventSelectionStep { IsNoCollInTimeRangeStrict, IsNoHighMultCollInPrevRof, IsRctFlagChecked, + IsFoundFT0, NSpecificEventSelectionSteps }; @@ -278,6 +279,7 @@ struct HfTaskFlow { 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 useNoFoundFT0Cut{"useNoFoundFT0Cut", false, "Use cut on no FT0 signal"}; Configurable requireRCTFlagChecker{"requireRCTFlagChecker", false, "Check event quality in run condition table"}; Configurable requireCorrelationAnalysisRCTFlagChecker{"requireCorrelationAnalysisRCTFlagChecker", false, "Check event quality in run condition table for correlation analysis"}; Configurable setRCTFlagCheckerLabel{"setRCTFlagCheckerLabel", "CBT_muon_global", "Evt sel: RCT flag checker label"}; @@ -640,6 +642,7 @@ struct HfTaskFlow { labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoCollInTimeRangeStrict] = "IsNoCollInTimeRangeStrict"; labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoHighMultCollInPrevRof] = "IsNoHighMultCollInPrevRof"; labelsPreciseEventSelection[SpecificEventSelectionStep::IsRctFlagChecked] = "IsRctFlagChecked"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsFoundFT0] = "IsFoundFT0"; registry.get(HIST("Data/hPreciseEventCounter"))->SetMinimum(0); for (int iBin = 0; iBin < SpecificEventSelectionStep::NSpecificEventSelectionSteps; iBin++) { @@ -1587,10 +1590,16 @@ struct HfTaskFlow { } if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsRctFlagChecked); - registry.fill(HIST("Data/hEventCounter"), EventSelectionStep::AfterEventSelection); + } + if (configCollision.useNoFoundFT0Cut && !collision.has_foundFT0()) { + return false; + } + if (fillHistograms && !configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsFoundFT0); } if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hEventCounter"), EventSelectionStep::AfterEventSelection); registry.fill(HIST("Data/hVtxZ"), collision.posZ()); } @@ -2705,7 +2714,9 @@ struct HfTaskFlow { if (configTask.useCutNeutralParticles) { auto pdgTriggerParticle = pdg->GetParticle(track1.pdgCode()); - if (!pdgTriggerParticle || std::abs(pdgTriggerParticle->Charge()) < 0.01) continue; + if (!pdgTriggerParticle || std::abs(pdgTriggerParticle->Charge()) < o2::constants::math::Almost0) { + continue; + } } if (track1.eta() < configTask.etaMcParticlesTriggerMin || track1.eta() > configTask.etaMcParticlesTriggerMax) { @@ -2754,7 +2765,9 @@ struct HfTaskFlow { if (configTask.useCutNeutralParticles) { auto pdgAssociatedParticle = pdg->GetParticle(track2.pdgCode()); - if (!pdgAssociatedParticle || std::abs(pdgAssociatedParticle->Charge()) < 0.01) continue; + if (!pdgAssociatedParticle || std::abs(pdgAssociatedParticle->Charge()) < o2::constants::math::Almost0) { + continue; + } } if (track1.globalIndex() == track2.globalIndex()) { From 63db0d8c242a952579dc2ede9ac9b46e10f0c2df Mon Sep 17 00:00:00 2001 From: AlexianL Date: Wed, 7 Oct 2026 17:08:34 +0200 Subject: [PATCH 6/9] fix clang --- PWGHF/HFC/Tasks/taskFlow.cxx | 65 ++++++++++++++++++------------------ 1 file changed, 32 insertions(+), 33 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 0e2f24cf712..c6b0bb332c0 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -116,7 +116,7 @@ enum FT0DetectorChannels { enum FT0InnerOrOuter { FT0Error = 0, - FT0InnerRing = 1, + FT0InnerRing = 1, FT0OuterRing = 2, NFT0InnerOrOuterSteps }; @@ -397,7 +397,7 @@ struct HfTaskFlow { // ========================= using SmallGroupMcCollisions = soa::SmallGroups>; - // using FilteredMcCollisionsWMult = soa::Filtered>; + // using FilteredMcCollisionsWMult = soa::Filtered>; using FilteredMcCollisionsWMult = soa::Join; using FilteredMcCollisionsWMultWCollsExtra = soa::Filtered>; // using FilteredMcParticles = soa::Filtered; @@ -730,7 +730,7 @@ struct HfTaskFlow { // ========================= if (doprocessSameTpcMftChCh || doprocessSameTpcMftChChReassociated || doprocessSameTpcMftChChReassociated3d || doprocessSameTpcMftChChNonAmbiguous) { - + if (!configTask.removeQAForSystematics) { addHistograms(); addMftHistograms(); @@ -763,7 +763,7 @@ struct HfTaskFlow { } if (doprocessSameTpcMftLcCh || doprocessSameTpcMftLcChReassociated) { - + if (!configTask.removeQAForSystematics) { addHistograms(); addMftHistograms(); @@ -854,7 +854,7 @@ struct HfTaskFlow { } if (doprocessSameTpcFt0aD0Ch) { - + if (!configTask.removeQAForSystematics) { addHistograms(); registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); @@ -882,7 +882,7 @@ struct HfTaskFlow { // ========================= if (doprocessSameMftFt0aChCh || doprocessSameMftFt0aChChReassociated || doprocessSameMftFt0aChChReassociated3d || doprocessSameMftFt0aChChNonAmbiguous) { - + if (!configTask.removeQAForSystematics) { addHistograms(); addMftHistograms(); @@ -916,7 +916,7 @@ struct HfTaskFlow { // ========================= if (doprocessSameTpcFt0cChCh) { - + if (!configTask.removeQAForSystematics) { addHistograms(); registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); @@ -945,7 +945,7 @@ struct HfTaskFlow { } if (doprocessSameTpcFt0cD0Ch) { - + if (!configTask.removeQAForSystematics) { addHistograms(); registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); @@ -957,7 +957,7 @@ struct HfTaskFlow { } if (doprocessSameTpcFt0cLcCh) { - + if (!configTask.removeQAForSystematics) { addHistograms(); registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); @@ -973,7 +973,7 @@ struct HfTaskFlow { // ========================= if (doprocessSameFt0aFt0cChCh) { - + if (!configTask.removeQAForSystematics) { addHistograms(); registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); @@ -1026,7 +1026,6 @@ struct HfTaskFlow { } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::Ft0aFt0c)) { addHistograms(); } - } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -1316,7 +1315,8 @@ struct HfTaskFlow { } } - int isInnerOrOuter(int channelId, int fitType) { + int isInnerOrOuter(int channelId, int fitType) + { if (fitType == isFT0C) { if (channelId >= FT0DetectorChannels::FT0CInnerRingMin && channelId <= FT0DetectorChannels::FT0CInnerRingMax) { if (!configTask.removeQAForSystematics) { @@ -1473,9 +1473,9 @@ struct HfTaskFlow { if (weight == 0) { return false; } - + if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentralityWeighted"), centrality, weight); + registry.fill(HIST("Data/hCentralityWeighted"), centrality, weight); } weightCent = weight; @@ -1487,7 +1487,7 @@ struct HfTaskFlow { // ========================= template - bool isAcceptedEventActivity(TCollision const& collision, TTracks const& tracks, int& multiplicity, float& centrality, float& centralityWeight) + bool isAcceptedEventActivity(TCollision const& collision, TTracks const& tracks, int& multiplicity, float& centrality, float& centralityWeight) { if (configCollision.useMultiplicityFromTracks) { if (!configTask.removeQAForSystematics) { @@ -1497,7 +1497,7 @@ struct HfTaskFlow { } else { multiplicity = getMultiplicityEstimator(collision, true); } - + centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { getCentralityWeight(centralityWeight, centrality); @@ -2609,13 +2609,13 @@ struct HfTaskFlow { target->getPairHist()->Fill(step, eta1 - eta2, 0.5, pt1, multiplicity, deltaPhi, posZ, amplitude * centralityWeight * triggerWeight * associatedWeight); } else if (configTask.doEtaDependentFlow) { - if (!configFit.discriminateInnerOrOuter) { - target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, - amplitude * centralityWeight * triggerWeight * associatedWeight); - } else { - target->getPairHist()->Fill(step, sampleIndex, posZ, isInnerOrOuter(channelId, fitType), eta1, deltaPhi, eta1 - eta2, - amplitude * centralityWeight * triggerWeight * associatedWeight); - } + if (!configFit.discriminateInnerOrOuter) { + target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, + amplitude * centralityWeight * triggerWeight * associatedWeight); + } else { + target->getPairHist()->Fill(step, sampleIndex, posZ, isInnerOrOuter(channelId, fitType), eta1, deltaPhi, eta1 - eta2, + amplitude * centralityWeight * triggerWeight * associatedWeight); + } } else { target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, amplitude * centralityWeight * triggerWeight * associatedWeight); @@ -2680,7 +2680,7 @@ struct HfTaskFlow { } else if (configTask.doEtaDependentFlow) { // target->getPairHist()->Fill(step, sampleIndex, posZ, etaC, etaA, deltaPhi, etaA - etaC, // amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); - + if (!configFit.discriminateInnerOrOuter) { target->getPairHist()->Fill(step, sampleIndex, posZ, etaC, etaA, deltaPhi, etaA - etaC, amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); @@ -2714,7 +2714,7 @@ struct HfTaskFlow { if (configTask.useCutNeutralParticles) { auto pdgTriggerParticle = pdg->GetParticle(track1.pdgCode()); - if (!pdgTriggerParticle || std::abs(pdgTriggerParticle->Charge()) < o2::constants::math::Almost0) { + if (!pdgTriggerParticle || std::abs(pdgTriggerParticle->Charge()) < o2::constants::math::Almost0) { continue; } } @@ -2758,7 +2758,7 @@ struct HfTaskFlow { fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); } } - + loopCounter++; for (auto const& track2 : tracksAssoc) { @@ -3242,7 +3242,7 @@ struct HfTaskFlow { } if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hNTracks"), tracks.size()); + registry.fill(HIST("Data/hNTracks"), tracks.size()); } auto bc = collision.template bc_as(); @@ -3255,7 +3255,6 @@ struct HfTaskFlow { return; } - sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, tracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp()), centralityWeight); } @@ -3352,7 +3351,7 @@ struct HfTaskFlow { registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); } - + auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; @@ -3382,7 +3381,7 @@ struct HfTaskFlow { if (!(isAcceptedCollision(collision, true))) { return; } - + if (!configTask.removeQAForSystematics) { registry.fill(HIST("Data/hNTracks"), tracks.size()); registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); @@ -3395,7 +3394,7 @@ struct HfTaskFlow { float centrality = 0.f; float centralityWeight = 1.f; auto uncorrectedMultiplicity = multiplicity; - + if (!configTask.removeQAForSystematics) { registry.fill(HIST("Data/hMultiplicity_uncorrected_vs_corrected"), uncorrectedMultiplicity, multiplicity); } @@ -3918,6 +3917,7 @@ struct HfTaskFlow { loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { + loadGain(bc); const auto& ft0 = collision.foundFT0(); auto multiplicity = 0; @@ -4156,7 +4156,7 @@ struct HfTaskFlow { FilteredMcParticles const& mcParticles, SmallGroupMcCollisions const& collisions) { - + if (mcParticles.size() == 0) { // guard against empty filtered batch return; } @@ -4576,7 +4576,6 @@ struct HfTaskFlow { for (auto it = pairs.begin(); it != pairs.end(); it++) { auto& [collision1, tracks1, collision2, tracks2] = *it; - if (tracks1.size() == 0 || tracks2.size() == 0) { // guard against empty filtered batch return; } From 621b4f6bdb5ae6e5dcf6ff514d0f5645dc47cdf6 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Wed, 7 Oct 2026 17:13:44 +0200 Subject: [PATCH 7/9] solve clang2 --- PWGHF/HFC/Tasks/taskFlow.cxx | 1 + 1 file changed, 1 insertion(+) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index c6b0bb332c0..82f61071ce4 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -3954,6 +3954,7 @@ struct HfTaskFlow { loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { + loadGain(bc); const auto& ft0 = collision.foundFT0(); auto multiplicity = 0; From 03c9faa2f71818bd555d590adbd86e9411b82e5a Mon Sep 17 00:00:00 2001 From: AlexianL Date: Thu, 8 Oct 2026 20:20:13 +0200 Subject: [PATCH 8/9] add o2linter fix --- PWGHF/HFC/Tasks/taskFlow.cxx | 256 +++++++++++++++++------------------ 1 file changed, 124 insertions(+), 132 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 82f61071ce4..0afde98f88d 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -63,6 +63,7 @@ #include #include +#include #include #include #include @@ -115,9 +116,9 @@ enum FT0DetectorChannels { }; enum FT0InnerOrOuter { - FT0Error = 0, - FT0InnerRing = 1, - FT0OuterRing = 2, + FT0Error, + FT0InnerRing, + FT0OuterRing, NFT0InnerOrOuterSteps }; @@ -195,12 +196,11 @@ enum TrackSelection { TrackSelectionGlobalTrack }; -// static constexpr std::string_view whatEventType[] = {"SameEvent/", "MixedEvent/"}; -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", "CentFT0CVariant1", "centFT0M"}; -static constexpr std::string_view WhatMultiplicityEstimator[] = {"multNTracksPV", "multNumContrib", "multFT0C", "multFT0M"}; +static constexpr std::array WhatDataType = {"Data/", "MC/"}; +static constexpr std::array WhatCorrelationCase = {"TpcTpc/", "TpcMft/", "TpcFv0a/", "MftFv0a/", "TpcFt0a/", "MftFt0a/", "TpcFt0c/", "Ft0aFt0c/"}; +static constexpr std::array WhatParticles = {"ChPartChPart/", "D0ChPart/", "LcChPart/"}; +static constexpr std::array WhatCentralityEstimator = {"centFT0C", "CentFT0CVariant1", "centFT0M"}; +static constexpr std::array WhatMultiplicityEstimator = {"multNTracksPV", "multNumContrib", "multFT0C", "multFT0M"}; auto static constexpr MinFt0cCell = 96; static constexpr TrackSelectionFlags::flagtype TrackSelectionIts = @@ -215,7 +215,7 @@ static constexpr TrackSelectionFlags::flagtype TrackSelectionDca = static constexpr TrackSelectionFlags::flagtype TrackSelectionDcaxyOnly = TrackSelectionFlags::kDCAxy; -static constexpr float PairCutDefaults[1][5] = {{-1, -1, -1, -1, -1}}; +static constexpr std::array, 1> PairCutDefaults{{{{-1, -1, -1, -1, -1}}}}; struct HfTaskFlow { @@ -308,7 +308,7 @@ struct HfTaskFlow { Configurable minMergingRadius{"minMergingRadius", 0.8, "max radius for merging cut"}; Configurable minTpcClusters{"minTpcClusters", 50.0f, "cut for minimum TPC clusters"}; Configurable minTpcCrossedRows{"minTpcCrossedRows", 70.0f, "cut for minimum TOC crossed rows"}; - Configurable> pairCut{"pairCut", {PairCutDefaults[0], 5, {"Photon", "K0", "Lambda", "Phi", "Rho"}}, "Pair cuts on various particles"}; + Configurable> pairCut{"pairCut", {PairCutDefaults[0].data(), 5, {"Photon", "K0", "Lambda", "Phi", "Rho"}}, "Pair cuts on various particles"}; Configurable ptCentralTrackMin{"ptCentralTrackMin", 0.2f, "min. pT of central tracks"}; Configurable ptCentralTrackMax{"ptCentralTrackMax", 10.0f, "max. pT of central tracks"}; Configurable trackSelectionType{"trackSelectionType", 1, "Track selection: 0 -> kGlobalTrack or isGlobalTrackSDD , 1 -> kGlobalTrack, 2 -> kGlobalTrackWoPtEta, 3 -> kGlobalTrackWoDCA, 4 -> No globalTrack selection"}; @@ -367,7 +367,7 @@ struct HfTaskFlow { o2::ccdb::CcdbApi ccdbApi; o2::ft0::Geometry ft0Det; // o2::fv0::Geometry* fv0Det{}; - std::vector cstFT0RelGain{}; + std::vector cstFT0RelGain; RCTFlagsChecker rctChecker; RCTFlagsChecker correlationAnalysisRctChecker{kFT0Bad, kITSBad, kTPCBadTracking, kTPCBadPID, kMFTBad, kITSLimAccMCRepr, kMFTLimAccMCRepr, kTPCLimAccMCRepr}; @@ -534,7 +534,7 @@ struct HfTaskFlow { void addMftHistograms() { registry.add("Data/Mft/hAmbiguityOfMftTracks", "hAmbiguityOfMftTracks", {HistType::kTH1D, {{MftTrackAmbiguityStep::NMftAmbiguitySteps, -0.5, +MftTrackAmbiguityStep::NMftAmbiguitySteps - 0.5}}}); - std::string labelsAmbiguityOfMftTracks[MftTrackAmbiguityStep::NMftAmbiguitySteps]; + std::array labelsAmbiguityOfMftTracks{}; labelsAmbiguityOfMftTracks[MftTrackAmbiguityStep::AllMftTracks] = "all MFT tracks"; labelsAmbiguityOfMftTracks[MftTrackAmbiguityStep::AfterTrackSelection] = "MFT tracks after selection"; labelsAmbiguityOfMftTracks[MftTrackAmbiguityStep::NumberOfAmbiguousTracks] = "how much tracks are ambigous"; @@ -546,7 +546,7 @@ struct HfTaskFlow { } registry.add("Data/Mft/hMftTracksSelection", "hMftTracksSelection", {HistType::kTH1D, {{MftTrackSelectionStep::NMftTrackSelectionSteps, -0.5, +MftTrackSelectionStep::NMftTrackSelectionSteps - 0.5}}}); - std::string labelsMftTracksSelection[MftTrackSelectionStep::NMftTrackSelectionSteps]; + std::array labelsMftTracksSelection{}; labelsMftTracksSelection[MftTrackSelectionStep::NoSelection] = "all MFT tracks"; labelsMftTracksSelection[MftTrackSelectionStep::Eta] = "MFT tracks after eta selection"; labelsMftTracksSelection[MftTrackSelectionStep::Cluster] = "MFT tracks after clusters selection"; @@ -564,7 +564,7 @@ struct HfTaskFlow { } registry.add("Data/Mft/hReassociationMftTracks", "hReassociationMftTracks", {HistType::kTH1D, {{ReassociationMftTracks::NReassociationMftTracksSteps, -0.5, +ReassociationMftTracks::NReassociationMftTracksSteps - 0.5}}}); - std::string labelsReassociationMftTracks[ReassociationMftTracks::NReassociationMftTracksSteps]; + std::array labelsReassociationMftTracks{}; labelsReassociationMftTracks[ReassociationMftTracks::NotReassociatedMftTracks] = "Ambiguous MFT tracks after track selection"; labelsReassociationMftTracks[ReassociationMftTracks::ReassociatedMftTracks] = "Reassociated MFT tracks by DCAxy method"; registry.get(HIST("Data/Mft/hReassociationMftTracks"))->SetMinimum(0); @@ -583,6 +583,22 @@ struct HfTaskFlow { registry.add("Data/Mft/hNBestCollisionFwd", "", {HistType::kTH1F, {configAxis.axisMultiplicity}}); } + void addFt0Histograms() + { + registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + registry.add("Data/FT0IsInnerOrOuter", "FT0IsInnerOrOuter", {HistType::kTH1D, {{FT0InnerOrOuter::NFT0InnerOrOuterSteps, -0.5, +FT0InnerOrOuter::NFT0InnerOrOuterSteps - 0.5}}}); + std::array labels{}; + labels[FT0InnerOrOuter::FT0InnerRing] = "FT0InnerRing"; + labels[FT0InnerOrOuter::FT0OuterRing] = "FT0OuterRing"; + registry.get(HIST("Data/FT0IsInnerOrOuter"))->SetMinimum(0); + + for (int iBin = 0; iBin < FT0InnerOrOuter::NFT0InnerOrOuterSteps; iBin++) { + registry.get(HIST("Data/FT0IsInnerOrOuter"))->GetXaxis()->SetBinLabel(iBin + 1, labels[iBin].data()); + } + } + // ========================= // init() // ========================= @@ -620,7 +636,7 @@ struct HfTaskFlow { registry.add("Data/hCentralityUsed", "", {HistType::kTH1D, {configAxis.axisCentrality}}); registry.add("Data/hEventCounter", "hEventCounter", {HistType::kTH1D, {{EventSelectionStep::NEventSelectionSteps, -0.5, +EventSelectionStep::NEventSelectionSteps - 0.5}}}); - std::string labels[EventSelectionStep::NEventSelectionSteps]; + std::array labels{}; labels[EventSelectionStep::AllEvents] = "all"; labels[EventSelectionStep::AfterEventSelection] = "after Physics selection"; registry.get(HIST("Data/hEventCounter"))->SetMinimum(0); @@ -630,7 +646,7 @@ struct HfTaskFlow { } registry.add("Data/hPreciseEventCounter", "hPreciseEventCounter", {HistType::kTH1D, {{SpecificEventSelectionStep::NSpecificEventSelectionSteps, -0.5, +SpecificEventSelectionStep::NSpecificEventSelectionSteps - 0.5}}}); - std::string labelsPreciseEventSelection[SpecificEventSelectionStep::NSpecificEventSelectionSteps]; + std::array labelsPreciseEventSelection{}; labelsPreciseEventSelection[SpecificEventSelectionStep::AllEventsPrecise] = "all"; labelsPreciseEventSelection[SpecificEventSelectionStep::IsSel8] = "sel8"; labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoSameBunchPileup] = "IsNoSameBunchPileup"; @@ -828,14 +844,7 @@ struct HfTaskFlow { if (doprocessSameTpcFt0aChCh) { if (!configTask.removeQAForSystematics) { addHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - - registry.add("Data/FT0IsInnerOrOuter", "FT0IsInnerOrOuter", {HistType::kTH1D, {{FT0InnerOrOuter::NFT0InnerOrOuterSteps, -0.5, +FT0InnerOrOuter::NFT0InnerOrOuterSteps - 0.5}}}); - std::string labels[FT0InnerOrOuter::NFT0InnerOrOuterSteps]; - labels[FT0InnerOrOuter::FT0InnerRing] = "FT0InnerRing"; - labels[FT0InnerOrOuter::FT0OuterRing] = "FT0OuterRing"; - registry.get(HIST("Data/FT0IsInnerOrOuter"))->SetMinimum(0); + addFt0Histograms(); } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -886,14 +895,7 @@ struct HfTaskFlow { if (!configTask.removeQAForSystematics) { addHistograms(); addMftHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - - registry.add("Data/FT0IsInnerOrOuter", "FT0IsInnerOrOuter", {HistType::kTH1D, {{FT0InnerOrOuter::NFT0InnerOrOuterSteps, -0.5, +FT0InnerOrOuter::NFT0InnerOrOuterSteps - 0.5}}}); - std::string labels[FT0InnerOrOuter::NFT0InnerOrOuterSteps]; - labels[FT0InnerOrOuter::FT0InnerRing] = "FT0InnerRing"; - labels[FT0InnerOrOuter::FT0OuterRing] = "FT0OuterRing"; - registry.get(HIST("Data/FT0IsInnerOrOuter"))->SetMinimum(0); + addFt0Histograms(); } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -919,14 +921,7 @@ struct HfTaskFlow { if (!configTask.removeQAForSystematics) { addHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - - registry.add("Data/FT0IsInnerOrOuter", "FT0IsInnerOrOuter", {HistType::kTH1D, {{FT0InnerOrOuter::NFT0InnerOrOuterSteps, -0.5, +FT0InnerOrOuter::NFT0InnerOrOuterSteps - 0.5}}}); - std::string labels[FT0InnerOrOuter::NFT0InnerOrOuterSteps]; - labels[FT0InnerOrOuter::FT0InnerRing] = "FT0InnerRing"; - labels[FT0InnerOrOuter::FT0OuterRing] = "FT0OuterRing"; - registry.get(HIST("Data/FT0IsInnerOrOuter"))->SetMinimum(0); + addFt0Histograms(); } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -976,14 +971,9 @@ struct HfTaskFlow { if (!configTask.removeQAForSystematics) { addHistograms(); + addFt0Histograms(); registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - - registry.add("Data/FT0IsInnerOrOuter", "FT0IsInnerOrOuter", {HistType::kTH1D, {{FT0InnerOrOuter::NFT0InnerOrOuterSteps, -0.5, +FT0InnerOrOuter::NFT0InnerOrOuterSteps - 0.5}}}); - std::string labels[FT0InnerOrOuter::NFT0InnerOrOuterSteps]; - labels[FT0InnerOrOuter::FT0InnerRing] = "FT0InnerRing"; - labels[FT0InnerOrOuter::FT0OuterRing] = "FT0OuterRing"; - registry.get(HIST("Data/FT0IsInnerOrOuter"))->SetMinimum(0); } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -1292,7 +1282,7 @@ struct HfTaskFlow { void loadGain(aod::BCsWithTimestamps::iterator const& bc) { cstFT0RelGain.clear(); - cstFT0RelGain = {}; + // cstFT0RelGain = {}; std::string fullPath; auto timestamp = bc.timestamp(); @@ -1358,28 +1348,28 @@ struct HfTaskFlow { if (areCorrectionsLoaded) { return; } - if (configTask.loadEfficienciesForTpc.value.empty() == false) { + if (!configTask.loadEfficienciesForTpc.value.empty()) { mEfficiencyTpc = ccdb->getForTimeStamp(configTask.loadEfficienciesForTpc, timestamp); 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(), static_cast(mEfficiencyTpc)); } - if (configTask.loadEfficienciesForMft.value.empty() == false) { + if (!configTask.loadEfficienciesForMft.value.empty()) { mEfficiencyMft = ccdb->getForTimeStamp(configTask.loadEfficienciesForMft, 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(), static_cast(mEfficiencyMft)); } - if (configTask.loadEfficienciesForNch.value.empty() == false) { + if (!configTask.loadEfficienciesForNch.value.empty()) { 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(), static_cast(mEfficiencyNch)); } - if (configTask.loadCentralityWeight.value.empty() == false) { + if (!configTask.loadCentralityWeight.value.empty()) { mCentralityWeight = ccdb->getForTimeStamp(configTask.loadCentralityWeight, timestamp); if (mCentralityWeight == nullptr) { LOGF(fatal, "Could not load centrality weight correction from %s", configTask.loadCentralityWeight.value.c_str()); @@ -1430,14 +1420,14 @@ struct HfTaskFlow { } template - double getCorrectedMultiplicity(const TTracks& tracks) // function to count the number of tracks in the event and fill the histogram + float getCorrectedMultiplicity(const TTracks& tracks) // function to count the number of tracks in the event and fill the histogram { - auto trackCounter = 0; + float trackCounter = 0.f; auto weightMultiplicity = 1.0f; for (auto const& track : tracks) { - if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { - trackCounter += 1; + if (std::abs(track.eta()) > configCentral.etaCentralTrackMax || track.pt() <= configCentral.ptCentralTrackMin || track.pt() >= configCentral.ptCentralTrackMax) { + continue; } auto efficiencyNch = 1.0f; @@ -1449,12 +1439,13 @@ struct HfTaskFlow { } if (efficiencyNch == 0) { - return false; + // return false; + efficiencyNch = 1.0f; } weightMultiplicity = 1. / efficiencyNch; } else { - weightMultiplicity = 0; + weightMultiplicity = 1.0f; } trackCounter += weightMultiplicity; @@ -1487,7 +1478,7 @@ struct HfTaskFlow { // ========================= template - bool isAcceptedEventActivity(TCollision const& collision, TTracks const& tracks, int& multiplicity, float& centrality, float& centralityWeight) + bool isAcceptedEventActivity(TCollision const& collision, TTracks const& tracks, auto& multiplicity, float& centrality, float& centralityWeight) { if (configCollision.useMultiplicityFromTracks) { if (!configTask.removeQAForSystematics) { @@ -1787,7 +1778,7 @@ struct HfTaskFlow { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision - int sampleIndex = gRandom->Uniform(0, configTask.nSamples); + int sampleIndex = static_cast(gRandom->Uniform(0, configTask.nSamples)); // TRIGGER PARTICLE for (const auto& track1 : tracksTrigger) { @@ -1919,19 +1910,19 @@ struct HfTaskFlow { const double kLimit = 3.0 * configCentral.mergingCut; - bool bIsBelow = false; + [[maybe_unused]] bool bIsBelow = false; if (std::abs(dPhiStarLow) < kLimit || std::abs(dPhiStarHigh) < kLimit || dPhiStarLow * dPhiStarHigh < 0) { - for (double rad(configCentral.minMergingRadius); rad < configCentral.maxMergingRadius; rad += 0.01) { // FIXME: Variable 'rad' with floating point type 'double' should not be used as a loop counter. + constexpr double StepRad = 0.01; + const int nSteps = static_cast((configCentral.maxMergingRadius - configCentral.minMergingRadius) / StepRad); + for (int iStep = 1; iStep < nSteps; ++iStep) { + double rad = configCentral.minMergingRadius + iStep * StepRad; double dPhiStar = getDPhiStar(track1, track2, rad, magneticField); if (std::abs(dPhiStar) < kLimit) { bIsBelow = true; break; } } - if (bIsBelow) { - continue; - } } } } @@ -2023,7 +2014,7 @@ struct HfTaskFlow { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision - int sampleIndex = gRandom->Uniform(0, configTask.nSamples); + int sampleIndex = static_cast(gRandom->Uniform(0, configTask.nSamples)); // TRIGGER PARTICLE for (const auto& track1 : tracksTrigger) { @@ -2220,7 +2211,7 @@ struct HfTaskFlow { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision - int sampleIndex = gRandom->Uniform(0, configTask.nSamples); + int sampleIndex = static_cast(gRandom->Uniform(0, configTask.nSamples)); // TRIGGER PARTICLE for (auto const& track1 : tracksTrigger) { @@ -2489,7 +2480,7 @@ struct HfTaskFlow { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision - int sampleIndex = gRandom->Uniform(0, configTask.nSamples); + int sampleIndex = static_cast(gRandom->Uniform(0, configTask.nSamples)); // TRIGGER PARTICLE for (auto const& track1 : tracksTrigger) { @@ -2640,7 +2631,7 @@ struct HfTaskFlow { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision - int sampleIndex = gRandom->Uniform(0, configTask.nSamples); + int sampleIndex = static_cast(gRandom->Uniform(0, configTask.nSamples)); // TRIGGER PARTICLE FROM FT0A for (std::size_t indexChannelA = 0; indexChannelA < ft0as.channelA().size(); indexChannelA++) { @@ -2708,7 +2699,7 @@ struct HfTaskFlow { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision - int sampleIndex = gRandom->Uniform(0, configTask.nSamples); + int sampleIndex = static_cast(gRandom->Uniform(0, configTask.nSamples)); for (auto const& track1 : tracksTrigger) { @@ -2863,7 +2854,7 @@ struct HfTaskFlow { auto bc = collision1.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; + float multiplicity = 0.f; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracks1.size(); } else { @@ -2874,14 +2865,14 @@ struct HfTaskFlow { 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; + continue; } } + if (!configCollision.useCentrality && (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity)) { + continue; + } + corrContainer->fillEvent(multiplicity, step); fillCorrelations(corrContainer, step, tracks1, tracks2, multiplicity, collision1.posZ(), false, getMagneticField(bc.timestamp()), centralityWeight); } @@ -2924,7 +2915,7 @@ struct HfTaskFlow { auto bc = collision1.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; + float multiplicity = 0.f; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracksTrigger.size(); } else { @@ -2935,14 +2926,14 @@ struct HfTaskFlow { 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; + continue; } } + if (!configCollision.useCentrality && (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity)) { + continue; + } + auto slicedTriggerTracks = tracksTrigger.sliceBy(presliceTrigger, collision1.globalIndex()); auto slicedAssociatedTracks = tracksAssoc.sliceBy(presliceAssociated, collision2.globalIndex()); @@ -2986,7 +2977,7 @@ struct HfTaskFlow { auto bc = collision1.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto tracksForMultiplicity = tracksTpc.sliceByCached(o2::aod::track::collisionId, collision1.globalIndex(), cache); - auto multiplicity = 0; + float multiplicity = 0.f; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracksForMultiplicity.size(); } else { @@ -2997,14 +2988,14 @@ struct HfTaskFlow { 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; + continue; } } + if (!configCollision.useCentrality && (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity)) { + continue; + } + // if TPC-MFT cases if constexpr (std::is_same_v) { auto slicedTriggerTracks = tracksTrigger.sliceBy(presliceTrigger, collision1.globalIndex()); @@ -3065,7 +3056,7 @@ struct HfTaskFlow { // auto tracksForMultiplicity = tracksTpc.sliceByCached(o2::aod::track::collisionId, collision1.globalIndex(), cache); // const auto& fv0 = collision2.foundFV0(); - // auto multiplicity = 0; + // float multiplicity = 0.f; // if (configCollision.useMultiplicityFromTracks) { // multiplicity = tracksForMultiplicity.size(); // } else { @@ -3073,7 +3064,7 @@ struct HfTaskFlow { // } // if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - // return; + // continue; // } // corrContainer->fillEvent(multiplicity, step); @@ -3088,7 +3079,7 @@ struct HfTaskFlow { auto tracksForMultiplicity = tracksTpc.sliceByCached(o2::aod::track::collisionId, collision1.globalIndex(), cache); const auto& ft0 = collision2.foundFT0(); - auto multiplicity = 0; + float multiplicity = 0.f; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracksForMultiplicity.size(); } else { @@ -3099,14 +3090,14 @@ struct HfTaskFlow { 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; + continue; } } + if (!configCollision.useCentrality && (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity)) { + continue; + } + corrContainer->fillEvent(multiplicity, step); fillCorrelationsFIT(corrContainer, step, slicedTriggerTracks, ft0, tracksAssoc, multiplicity, collision1.posZ(), false, fitType, centralityWeight); } @@ -3155,7 +3146,7 @@ struct HfTaskFlow { auto bc = collision1.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto tracksForMultiplicity = tracksTpc.sliceByCached(o2::aod::track::collisionId, collision1.globalIndex(), cache); - auto multiplicity = 0; + float multiplicity = 0.f; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracksForMultiplicity.size(); } else { @@ -3166,14 +3157,14 @@ struct HfTaskFlow { 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; + continue; } } + if (!configCollision.useCentrality && (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity)) { + continue; + } + corrContainer->fillEvent(multiplicity, step); fillCorrelationsFt0aFt0c(corrContainer, step, ft0as, ft0cs, multiplicity, collision1.posZ(), true, centralityWeight); } @@ -3208,7 +3199,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -3247,7 +3238,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -3286,7 +3277,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -3318,7 +3309,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -3354,7 +3345,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -3390,21 +3381,22 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; - auto uncorrectedMultiplicity = multiplicity; - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hMultiplicity_uncorrected_vs_corrected"), uncorrectedMultiplicity, multiplicity); + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } + auto uncorrectedMultiplicity = multiplicity; + if (configCollision.useMultiplicityFromTracksCorrected) { multiplicity = getCorrectedMultiplicity(tracks); } - if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { - return; + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hMultiplicity_uncorrected_vs_corrected"), uncorrectedMultiplicity, multiplicity); } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -3435,7 +3427,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -3476,7 +3468,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -3502,7 +3494,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -3538,7 +3530,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -3564,7 +3556,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -3776,7 +3768,7 @@ struct HfTaskFlow { if (!configTask.removeQAForSystematics) { registry.fill(HIST("Data/hNTracks"), tracks.size()); } - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -3815,7 +3807,7 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -3849,7 +3841,7 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -3883,7 +3875,7 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -3920,7 +3912,7 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -3957,7 +3949,7 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -3993,7 +3985,7 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -4034,7 +4026,7 @@ struct HfTaskFlow { if (!configTask.removeQAForSystematics) { registry.fill(HIST("Data/hNTracks"), tracks.size()); } - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -4068,7 +4060,7 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -4102,7 +4094,7 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -4135,7 +4127,7 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; + float multiplicity = 0.f; float centrality = 0.f; float centralityWeight = 1.f; @@ -4162,7 +4154,7 @@ struct HfTaskFlow { return; } - auto multiplicity = 0; + float multiplicity = 0.f; if (configCollision.useMultiplicityFromTracks) { for (const auto& track : mcParticles) { if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { @@ -4554,7 +4546,7 @@ struct HfTaskFlow { auto getTracksSize = [&mcParticles, this](soa::Join::iterator const& mcCollision) { auto associatedTracks = mcParticles.sliceByCached(o2::aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), this->cache); - auto multiplicity = 0; + float multiplicity = 0.f; if (configCollision.useMultiplicityFromTracks) { for (const auto& track : associatedTracks) { if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { @@ -4711,7 +4703,7 @@ struct HfTaskFlow { } auto groupedreassociated3dMftTracks = reassociated3dMftTracks.sliceBy(perColReassociated3dTracks, reconstructedCollision.globalIndex()); - for (const auto& reassociated3dMftTrack : reassociated3dMftTracks) { + for (const auto& reassociated3dMftTrack : groupedreassociated3dMftTracks) { if (!reassociated3dMftTrack.has_mcParticle()) { continue; } From e96f130ea1ec4c36c3b38f0fff0d200cf9aef8fc Mon Sep 17 00:00:00 2001 From: AlexianL Date: Fri, 9 Oct 2026 14:56:18 +0200 Subject: [PATCH 9/9] add centrality in MC gen --- PWGHF/HFC/Tasks/taskFlow.cxx | 140 ++++++++++++++++++++++++----------- 1 file changed, 95 insertions(+), 45 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 0afde98f88d..26378bbb90e 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -399,7 +399,7 @@ struct HfTaskFlow { using SmallGroupMcCollisions = soa::SmallGroups>; // using FilteredMcCollisionsWMult = soa::Filtered>; using FilteredMcCollisionsWMult = soa::Join; - using FilteredMcCollisionsWMultWCollsExtra = soa::Filtered>; + using FilteredMcCollisionsWMultWCollsExtra = soa::Join; // using FilteredMcParticles = soa::Filtered; using FilteredMcParticles = aod::McParticles; @@ -3088,7 +3088,7 @@ struct HfTaskFlow { float centralityWeight = 1.0f; if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, true)); + getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, false)); if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { continue; } @@ -3200,7 +3200,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -3239,7 +3239,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -3278,7 +3278,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -3310,7 +3310,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -3346,7 +3346,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -3382,7 +3382,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -3428,7 +3428,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -3469,7 +3469,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -3495,7 +3495,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -3531,7 +3531,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -3557,7 +3557,7 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -3769,7 +3769,7 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); } float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -3808,7 +3808,7 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -3842,7 +3842,7 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -3876,7 +3876,7 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -3913,7 +3913,7 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -3950,7 +3950,7 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -3986,7 +3986,7 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -4027,7 +4027,7 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); } float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -4061,7 +4061,7 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -4095,7 +4095,7 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -4128,7 +4128,7 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); float multiplicity = 0.f; - float centrality = 0.f; + float centrality = -1.f; float centralityWeight = 1.f; if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { @@ -4145,7 +4145,7 @@ struct HfTaskFlow { // MONTE-CARLO // =================================================================================================================================================================================================================================================================== - void processSameMcGen(FilteredMcCollisionsWMult::iterator const& mcCollision, + void processSameMcGen(FilteredMcCollisionsWMultWCollsExtra::iterator const& mcCollision, FilteredMcParticles const& mcParticles, SmallGroupMcCollisions const& collisions) { @@ -4154,6 +4154,10 @@ struct HfTaskFlow { return; } + if (collisions.size() == 0) { + return; + } + float multiplicity = 0.f; if (configCollision.useMultiplicityFromTracks) { for (const auto& track : mcParticles) { @@ -4165,12 +4169,27 @@ struct HfTaskFlow { multiplicity = mcCollision.multMCPVz(); } - if ((multiplicity < configCollision.minMultiplicity) || (multiplicity >= configCollision.maxMultiplicity)) { - return; + float centrality = -1.f; + for (const auto& collision : collisions) { + // if (!collision.sel8()) { + // continue; + // } + // if (collision.globalIndex() != mcCollision.bestCollisionIndex()) { + // continue; + // } + centrality = getCentralityEstimator(collision, false); + // break; } - if (collisions.size() == 0) { - return; + if (configCollision.useCentrality) { + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { + return; + } + } + if (!configCollision.useCentrality) { + if ((multiplicity < configCollision.minMultiplicity) || (multiplicity >= configCollision.maxMultiplicity)) { + return; + } } sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepAll); @@ -4539,12 +4558,12 @@ struct HfTaskFlow { // MONTE-CARLO // =================================================================================================================================================================================================================================================================== - void processMixedMcGen(FilteredMcCollisionsWMult const& mcCollisions, + void processMixedMcGen(FilteredMcCollisionsWMultWCollsExtra const& mcCollisions, FilteredMcParticles const& mcParticles, SmallGroupMcCollisions const& collisions) { - auto getTracksSize = [&mcParticles, this](soa::Join::iterator const& mcCollision) { + auto getTracksSize = [&mcParticles, this](soa::Join::iterator const& mcCollision) { auto associatedTracks = mcParticles.sliceByCached(o2::aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), this->cache); float multiplicity = 0.f; if (configCollision.useMultiplicityFromTracks) { @@ -4564,17 +4583,26 @@ struct HfTaskFlow { auto tracksTuple = std::make_tuple(mcParticles, mcParticles); - Pair pairs{binningOnVtxAndMult, configTask.nMixedEvents, -1, mcCollisions, tracksTuple, &cache}; // -1 is the number of the bin to skip + Pair pairs{binningOnVtxAndMult, configTask.nMixedEvents, -1, mcCollisions, tracksTuple, &cache}; // -1 is the number of the bin to skip for (auto it = pairs.begin(); it != pairs.end(); it++) { auto& [collision1, tracks1, collision2, tracks2] = *it; if (tracks1.size() == 0 || tracks2.size() == 0) { // guard against empty filtered batch - return; + continue; } - auto multiplicityCollision1 = 0; - auto multiplicityCollision2 = 0; + auto groupedCollisions1 = collisions.sliceBy(collisionPerMcCollision, collision1.globalIndex()); + auto groupedCollisions2 = collisions.sliceBy(collisionPerMcCollision, collision2.globalIndex()); + if (groupedCollisions1.size() == 0) { + continue; + } + if (groupedCollisions2.size() == 0) { + continue; + } + + float multiplicityCollision1 = 0.f; + float multiplicityCollision2 = 0.f; if (configCollision.useMultiplicityFromTracks) { for (const auto& track : tracks1) { @@ -4592,20 +4620,42 @@ struct HfTaskFlow { multiplicityCollision2 = collision2.multMCPVz(); } - if ((multiplicityCollision1 < configCollision.minMultiplicity || multiplicityCollision1 >= configCollision.maxMultiplicity)) { - continue; + float centralityCollision1 = 999.f; + float centralityCollision2 = 999.f; + for (const auto& reconstructedCollision1 : groupedCollisions1) { + // if (!collision1.sel8()) { + // continue; + // } + // if (reconstructedCollision1.globalIndex() != collision1.bestCollisionIndex()) { + // continue; + // } + centralityCollision1 = getCentralityEstimator(reconstructedCollision1, false); + // break; } - if ((multiplicityCollision2 < configCollision.minMultiplicity || multiplicityCollision2 >= configCollision.maxMultiplicity)) { - continue; + for (const auto& reconstructedCollision2 : groupedCollisions2) { + // if (reconstructedCollision2.globalIndex() != collision2.bestCollisionIndex()) { + // continue; + // } + centralityCollision2 = getCentralityEstimator(reconstructedCollision2, false); + // break; } - auto groupedCollisions1 = collisions.sliceBy(collisionPerMcCollision, collision1.globalIndex()); - auto groupedCollisions2 = collisions.sliceBy(collisionPerMcCollision, collision2.globalIndex()); - if (groupedCollisions1.size() == 0) { - continue; + if (configCollision.useCentrality) { + if (centralityCollision1 < configCollision.minCentrality || centralityCollision1 >= configCollision.maxCentrality) { + continue; + } + if (centralityCollision2 < configCollision.minCentrality || centralityCollision2 >= configCollision.maxCentrality) { + continue; + } } - if (groupedCollisions2.size() == 0) { - continue; + + if (!configCollision.useCentrality) { + if ((multiplicityCollision1 < configCollision.minMultiplicity || multiplicityCollision1 >= configCollision.maxMultiplicity)) { + continue; + } + if ((multiplicityCollision2 < configCollision.minMultiplicity || multiplicityCollision2 >= configCollision.maxMultiplicity)) { + continue; + } } mixedEvent->fillEvent(multiplicityCollision1, CorrelationContainer::kCFStepAll);