From d90806bd7a57ca6692c4949f82289979768e39c6 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Tue, 5 May 2026 14:46:29 +0200 Subject: [PATCH 01/10] correct FT0 gain eq, add MFT qa plot --- PWGHF/HFC/Tasks/taskFlow.cxx | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 437fe9dcad9..8dc949e2a20 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -379,6 +379,7 @@ struct HfTaskFlow { ConfigurableAxis axisMass{"axisMass", {1, 1.5848, 2.1848}, "axis of invariant mass of candidates"}; ConfigurableAxis binsMixingMultiplicity{"binsMixingMultiplicity", {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 100.1}, "multiplicity bins for event mixing"}; ConfigurableAxis binsMixingVertex{"binsMixingVertex", {20, -10, 10}, "vertex bins for event mixing"}; + ConfigurableAxis axisNClusters{"axisNClusters", {11, 0, 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"}; ConfigurableAxis axisEtaTrigger{"axisEtaTrigger", {48, -1, 1}, "eta axis for TPC histograms"}; @@ -465,6 +466,8 @@ struct HfTaskFlow { } registry.add("Data/Mft/hPtMft", "", {HistType::kTH1D, {configAxis.axisPt}}); + registry.add("Data/Mft/hPtVsClustersLTF", "", {HistType::kTH2D, {configAxis.axisPt, configAxis.axisNClusters}}); + registry.add("Data/Mft/hPtVsClustersCA", "", {HistType::kTH2D, {configAxis.axisPt, configAxis.axisNClusters}}); registry.add("Data/Mft/hNMftTracks", "", {HistType::kTH1F, {configAxis.axisMultiplicity}}); registry.add("Data/Mft/hNBestCollisionFwd", "", {HistType::kTH1F, {configAxis.axisMultiplicity}}); } @@ -939,7 +942,7 @@ struct HfTaskFlow { LOGF(fatal, "Cor Index %d out of range", fitType); } registry.fill(HIST("Data/FT0Amp"), rID, amplitude); - amplitude = amplitude / cstFT0RelGain[iCh]; + amplitude = amplitude / cstFT0RelGain[id]; registry.fill(HIST("Data/FT0AmpCorr"), rID, amplitude); } @@ -1153,6 +1156,7 @@ struct HfTaskFlow { if (mftTrack.isCA()) { if (fillHistograms) { registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::IsCA); + registry.fill(HIST("Data/Mft/hPtVsClustersCA"), mftTrack.pt(), mftTrack.nClusters()); } if (configMft.useOnlyLTFTracks) { @@ -1162,6 +1166,7 @@ struct HfTaskFlow { } else { if (fillHistograms) { registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::IsLTF); + registry.fill(HIST("Data/Mft/hPtVsClustersLTF"), mftTrack.pt(), mftTrack.nClusters()); } if (configMft.useOnlyCATracks) { From ec908ed85d2e21a4c9c04953af2a6615c0633945 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Tue, 5 May 2026 17:53:29 +0200 Subject: [PATCH 02/10] add possibility of eta-dependent flow --- PWGHF/HFC/Tasks/taskFlow.cxx | 176 +++++++++++++++++++++++++++-------- 1 file changed, 139 insertions(+), 37 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 8dc949e2a20..178941b886e 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -202,6 +202,7 @@ struct HfTaskFlow { struct : ConfigurableGroup { std::string prefix = "ConfigTask_group"; Configurable centralityBinsForMc{"centralityBinsForMc", false, "falsce = OFF, true = ON for data like multiplicity/centrality bins for MC steps"}; + Configurable doEtaDependentFlow{"doEtaDependentFlow", false, "Flag to know if eta dependent flow should be done"}; Configurable doHeavyFlavor{"doHeavyFlavor", false, "Flag to know we in the heavy flavor case or not"}; Configurable doReferenceFlow{"doReferenceFlow", false, "Flag to know if reference flow should be done"}; Configurable isReadoutCenter{"isReadoutCenter", false, "Enable Readout Center"}; @@ -379,7 +380,7 @@ struct HfTaskFlow { ConfigurableAxis axisMass{"axisMass", {1, 1.5848, 2.1848}, "axis of invariant mass of candidates"}; ConfigurableAxis binsMixingMultiplicity{"binsMixingMultiplicity", {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 100.1}, "multiplicity bins for event mixing"}; ConfigurableAxis binsMixingVertex{"binsMixingVertex", {20, -10, 10}, "vertex bins for event mixing"}; - ConfigurableAxis axisNClusters{"axisNClusters", {11, 0, 10}, "axis for number of clusters of MFT tracks"}; + ConfigurableAxis axisNClusters{"axisNClusters", {10, 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"}; ConfigurableAxis axisEtaTrigger{"axisEtaTrigger", {48, -1, 1}, "eta axis for TPC histograms"}; @@ -550,6 +551,12 @@ struct HfTaskFlow { {configAxis.axisMultiplicity, "multiplicity"}, {configAxis.axisDeltaPhi, "#Delta#varphi (rad)"}, {configAxis.axisVertex, "z-vtx (cm)"}}; + std::vector const corrAxisEta = {{configAxis.axisDeltaEta, "#Delta#eta"}, + {configAxis.axisEtaAssociated, "#eta_{associated}"}, + {configAxis.axisEtaTrigger, "#eta_{trigger}"}, + {configAxis.axisMultiplicity, "multiplicity"}, + {configAxis.axisDeltaPhi, "#Delta#varphi (rad)"}, + {configAxis.axisVertex, "z-vtx (cm)"}}; std::vector const effAxis = {{configAxis.axisEtaEfficiency, "#eta"}, {configAxis.axisPtEfficiency, "p_{T} (GeV/c)"}, {configAxis.axisVertexEfficiency, "z-vtx (cm)"}}; @@ -565,8 +572,13 @@ struct HfTaskFlow { if (doprocessSameTpcTpcChCh) { addHistograms(); - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + if (!configTask.doEtaDependentFlow) { + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + } else { + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + } } if (doprocessSameTpcTpcD0Ch) { @@ -591,8 +603,13 @@ struct HfTaskFlow { addHistograms(); addMftHistograms(); - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + if (!configTask.doEtaDependentFlow) { + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + } else { + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + } } if (doprocessSameTpcMftD0Ch || doprocessSameTpcMftD0ChReassociated) { @@ -618,8 +635,13 @@ struct HfTaskFlow { if (doprocessSameTpcFv0aChCh) { addHistograms(); - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + if (!configTask.doEtaDependentFlow) { + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + } else { + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + } } if (doprocessSameTpcFv0aD0Ch) { @@ -645,8 +667,13 @@ struct HfTaskFlow { addHistograms(); addMftHistograms(); - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + if (!configTask.doEtaDependentFlow) { + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + } else { + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + } } // ========================= @@ -658,8 +685,13 @@ struct HfTaskFlow { registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + if (!configTask.doEtaDependentFlow) { + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + } else { + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + } } if (doprocessSameTpcFt0aD0Ch) { @@ -690,8 +722,13 @@ struct HfTaskFlow { registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + if (!configTask.doEtaDependentFlow) { + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + } else { + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + } } // ========================= @@ -703,8 +740,13 @@ struct HfTaskFlow { registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + if (!configTask.doEtaDependentFlow) { + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + } else { + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + } } if (doprocessSameTpcFt0cD0Ch) { @@ -734,8 +776,13 @@ struct HfTaskFlow { registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + if (!configTask.doEtaDependentFlow) { + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + } else { + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + } } } // End of init() function @@ -1247,8 +1294,12 @@ struct HfTaskFlow { } // fill single-track distributions - if (!fillingHFcontainer) { // if not HF-h case - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + if (!fillingHFcontainer) { // if not HF-h case + if (!configTask.doEtaDependentFlow) { // if not eta-differential flow, fill vs pt, otherwise fill vs eta + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + } else { + target->getTriggerHist()->Fill(step, eta1, multiplicity, posZ, triggerWeight); + } } else { target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, triggerWeight); } @@ -1375,8 +1426,13 @@ struct HfTaskFlow { if (!fillingHFcontainer) { // fill pair correlations - target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, - triggerWeight * associatedWeight); + if (!configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, + triggerWeight * associatedWeight); + } else { + target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + triggerWeight * associatedWeight); + } } else { target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, invmass, triggerWeight * associatedWeight); @@ -1450,7 +1506,11 @@ struct HfTaskFlow { // fill single-track distributions if (!fillingHFcontainer) { // if not HF-h case - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + if (!configTask.doEtaDependentFlow) { + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + } else { + target->getTriggerHist()->Fill(step, eta1, multiplicity, posZ, triggerWeight); + } } else { target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, triggerWeight); } @@ -1561,8 +1621,13 @@ struct HfTaskFlow { deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); if (!fillingHFcontainer) { - target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, - triggerWeight * associatedWeight); + if (!configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, + triggerWeight * associatedWeight); + } else { + target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + triggerWeight * associatedWeight); + } } else { target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, invmass, triggerWeight * associatedWeight); @@ -1640,7 +1705,11 @@ struct HfTaskFlow { // fill single-track distributions if (!fillingHFcontainer) { // if not HF-h case - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + if (!configTask.doEtaDependentFlow) { + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + } else { + target->getTriggerHist()->Fill(step, eta1, multiplicity, posZ, triggerWeight); + } } else { target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, triggerWeight); } @@ -1702,8 +1771,13 @@ struct HfTaskFlow { deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); // set range of delta phi in (-pi/2 , 3/2*pi) if (!fillingHFcontainer) { - target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, - triggerWeight * associatedWeight); + if (!configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, + triggerWeight * associatedWeight); + } else { + target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + triggerWeight * associatedWeight); + } } else { target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, invmass, triggerWeight * associatedWeight); @@ -1750,8 +1824,13 @@ struct HfTaskFlow { deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); // set range of delta phi in (-pi/2 , 3/2*pi) if (!fillingHFcontainer) { - target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, - amplitude * triggerWeight * associatedWeight); + if (!configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, + amplitude * triggerWeight * associatedWeight); + } else { + target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + amplitude * triggerWeight * associatedWeight); + } } else { target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, invmass, amplitude * triggerWeight * associatedWeight); @@ -1842,7 +1921,11 @@ struct HfTaskFlow { float phi1 = reassociatedMftTrack.phi(); o2::math_utils::bringTo02Pi(phi1); - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + if (!configTask.doEtaDependentFlow) { + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + } else { + target->getTriggerHist()->Fill(step, eta1, multiplicity, posZ, triggerWeight); + } // FILL QA PLOTS for trigger particle if (sameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { @@ -1866,8 +1949,13 @@ struct HfTaskFlow { float deltaPhi = phi1 - phi2; deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); // set range of delta phi in (-pi/2 , 3/2*pi) - target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, - triggerWeight * associatedWeight); + if (!configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, + triggerWeight * associatedWeight); + } else { + target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + triggerWeight * associatedWeight); + } // FILL QA PLOTS for associated particle if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { @@ -1899,8 +1987,13 @@ struct HfTaskFlow { float deltaPhi = phi1 - phi2; deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); // set range of delta phi in (-pi/2 , 3/2*pi) - target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, - amplitude * triggerWeight * associatedWeight); + if (!configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, + amplitude * triggerWeight * associatedWeight); + } else { + target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + amplitude * triggerWeight * associatedWeight); + } // FILL QA PLOTS for associated particle if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { @@ -1932,7 +2025,11 @@ struct HfTaskFlow { auto phiA = getPhiFT0(channelIdA, isFT0A); auto etaA = getEtaFT0(channelIdA, isFT0A); - target->getTriggerHist()->Fill(step, 0.f, multiplicity, posZ, amplitude * triggerWeight); + if (!configTask.doEtaDependentFlow) { + target->getTriggerHist()->Fill(step, 0.f, multiplicity, posZ, amplitude * triggerWeight); + } else { + target->getTriggerHist()->Fill(step, etaA, multiplicity, posZ, amplitude * triggerWeight); + } if (sameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { fillTriggerQa(multiplicity, etaA, phiA, 0.f); @@ -1948,8 +2045,13 @@ struct HfTaskFlow { auto etaC = getEtaFT0(channelIdC, isFT0C); float deltaPhi = RecoDecay::constrainAngle(phiA - phiC, -PIHalf); - target->getPairHist()->Fill(step, etaA - etaC, 0.f, 0.f, multiplicity, deltaPhi, posZ, - amplitude * triggerWeight * associatedWeight); + if (!configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, etaA - etaC, 0.f, 0.f, multiplicity, deltaPhi, posZ, + amplitude * triggerWeight * associatedWeight); + } else { + target->getPairHist()->Fill(step, etaA - etaC, etaC, etaA, multiplicity, deltaPhi, posZ, + amplitude * triggerWeight * associatedWeight); + } if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { fillAssociatedQa(multiplicity, etaC, phiC); From 91fc1ab2acbd3bf6ba1c09d42caec951265f0578 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Wed, 6 May 2026 10:05:40 +0200 Subject: [PATCH 03/10] change default value --- PWGHF/HFC/Tasks/taskFlow.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 178941b886e..f41fd055852 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -380,7 +380,7 @@ struct HfTaskFlow { ConfigurableAxis axisMass{"axisMass", {1, 1.5848, 2.1848}, "axis of invariant mass of candidates"}; ConfigurableAxis binsMixingMultiplicity{"binsMixingMultiplicity", {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 100.1}, "multiplicity bins for event mixing"}; ConfigurableAxis binsMixingVertex{"binsMixingVertex", {20, -10, 10}, "vertex bins for event mixing"}; - ConfigurableAxis axisNClusters{"axisNClusters", {10, 1, 10}, "axis for number of clusters of MFT tracks"}; + 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"}; ConfigurableAxis axisEtaTrigger{"axisEtaTrigger", {48, -1, 1}, "eta axis for TPC histograms"}; From 6f2e8b75c48b2094f8abcd2f2fb35f4b1d1aa9ea Mon Sep 17 00:00:00 2001 From: AlexianL Date: Fri, 29 May 2026 17:11:54 +0200 Subject: [PATCH 04/10] add variations in container --- PWGHF/HFC/Tasks/taskFlow.cxx | 1147 ++++++++++++++++++++++------------ 1 file changed, 744 insertions(+), 403 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index f41fd055852..c150728186f 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -204,10 +204,21 @@ struct HfTaskFlow { Configurable centralityBinsForMc{"centralityBinsForMc", false, "falsce = OFF, true = ON for data like multiplicity/centrality bins for MC steps"}; Configurable doEtaDependentFlow{"doEtaDependentFlow", false, "Flag to know if eta dependent flow should be done"}; Configurable doHeavyFlavor{"doHeavyFlavor", false, "Flag to know we in the heavy flavor case or not"}; + Configurable doMonteCarlo{"doMonteCarlo", false, "Flag to know if Monte Carlo should be done"}; Configurable doReferenceFlow{"doReferenceFlow", false, "Flag to know if reference flow should be done"}; + Configurable doVariationContainers{"doVariationContainers", false, "Flag to know if variation containers should be filled"}; + Configurable etaMcParticlesTriggerMax{"etaMcParticlesTriggerMax", 0.8f, "Maximum value for the eta of MC particles when used in cut function"}; + Configurable etaMcParticlesTriggerMin{"etaMcParticlesTriggerMin", -0.8f, "Minimum value for the eta of MC particles when used in cut function"}; + Configurable etaMcParticlesAssocMax{"etaMcParticlesAssocMax", -2.4f, "Maximum value for the eta of MC particles when used in cut function"}; + Configurable etaMcParticlesAssocMin{"etaMcParticlesAssocMin", -3.6f, "Minimum value for the eta of MC particles when used in cut function"}; + Configurable ptMcParticlesTriggerMax{"ptMcParticlesTriggerMax", 3.0f, "Maximum value for the pT of MC particles when used in cut function"}; + Configurable ptMcParticlesTriggerMin{"ptMcParticlesTriggerMin", 0.2f, "Minimum value for the pT of MC particles when used in cut function"}; + Configurable ptMcParticlesAssocMax{"ptMcParticlesAssocMax", 100.0f, "Maximum value for the pT of MC particles when used in cut function"}; + Configurable ptMcParticlesAssocMin{"ptMcParticlesAssocMin", 0.f, "Minimum value for the pT of MC particles when used in cut function"}; Configurable isReadoutCenter{"isReadoutCenter", false, "Enable Readout Center"}; 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"}; } configTask; // configurables for collisions @@ -295,8 +306,6 @@ struct HfTaskFlow { Configurable cfgCorrLevel{"cfgCorrLevel", 1, "calibration step: 0 = no corr, 1 = gain corr"}; } configFit; - TF1* fPtDepDCAxy = nullptr; - SliceCache cache; Service pdg{}; Service ccdb{}; @@ -320,6 +329,12 @@ struct HfTaskFlow { using FilteredMftTracks = soa::Filtered; + // ========================= + // using declarations : MC + // ========================= + + using SmallGroupMcCollisions = soa::SmallGroups>; + // ========================= // Filters & partitions : DATA // ========================= @@ -366,10 +381,17 @@ struct HfTaskFlow { Preslice perColLcs = aod::track::collisionId; Preslice perColMftTracks = o2::aod::fwdtrack::collisionId; Preslice perColTracks = aod::track::collisionId; + Preslice perMcColMcParticles = aod::mcparticle::mcCollisionId; PresliceUnsorted> perColReassociated2dTracks = o2::aod::fwdtrack::collisionId; PresliceUnsorted> perColReassociated3dTracks = o2::aod::fwdtrack::collisionId; + // ========================= + // Preslice : MC + // ========================= + + PresliceUnsorted collisionPerMcCollision = aod::mccollisionlabel::mcCollisionId; + // configurables for containers // TODO: flow of HF will need to be done vs. invariant mass, in the signal and side-band regions // either 1) add invariant mass axis or 2) define several containers for different inv. mass regions @@ -406,13 +428,15 @@ struct HfTaskFlow { // Correlation containers used for data OutputObj sameEvent{"sameEvent"}; OutputObj mixedEvent{"mixedEvent"}; + OutputObj sameEventTpcMft{"sameEvent_TPC_MFT"}; + OutputObj mixedEventTpcMft{"mixedEvent_TPC_MFT"}; + OutputObj sameEventTpcFt0a{"sameEvent_TPC_FT0A"}; + OutputObj mixedEventTpcFt0a{"mixedEvent_TPC_FT0A"}; + OutputObj sameEventMftFt0a{"sameEvent_MFT_FT0A"}; + OutputObj mixedEventMftFt0a{"mixedEvent_MFT_FT0A"}; OutputObj sameEventHf{"sameEventHf"}; OutputObj mixedEventHf{"mixedEventHf"}; - // Correlation containers used for Monte-Carlo - OutputObj sameEventHfMc{"sameEventHfMc"}; - OutputObj mixedEventHfMc{"mixedEventHfMc"}; - template void addHistograms() { @@ -551,12 +575,18 @@ struct HfTaskFlow { {configAxis.axisMultiplicity, "multiplicity"}, {configAxis.axisDeltaPhi, "#Delta#varphi (rad)"}, {configAxis.axisVertex, "z-vtx (cm)"}}; - std::vector const corrAxisEta = {{configAxis.axisDeltaEta, "#Delta#eta"}, - {configAxis.axisEtaAssociated, "#eta_{associated}"}, + std::vector const corrAxisEta = {{configAxis.axisSamples, "sampling"}, + {configAxis.axisVertex, "z-vtx (cm)"}, {configAxis.axisEtaTrigger, "#eta_{trigger}"}, - {configAxis.axisMultiplicity, "multiplicity"}, + {configAxis.axisEtaAssociated, "#eta_{associated}"}, {configAxis.axisDeltaPhi, "#Delta#varphi (rad)"}, - {configAxis.axisVertex, "z-vtx (cm)"}}; + {configAxis.axisDeltaEta, "#Delta#eta"}}; + std::vector const corrAxisVariations = {{configAxis.axisSamples, "sampling"}, + {configAxis.axisVertex, "z-vtx (cm)"}, + {configAxis.axisPtTrigger, "p_{T} (GeV/c)"}, + {configAxis.axisMultiplicity, "multiplicity"}, + {configAxis.axisDeltaPhi, "#Delta#varphi (rad)"}, + {configAxis.axisDeltaEta, "#Delta#eta"}}; std::vector const effAxis = {{configAxis.axisEtaEfficiency, "#eta"}, {configAxis.axisPtEfficiency, "p_{T} (GeV/c)"}, {configAxis.axisVertexEfficiency, "z-vtx (cm)"}}; @@ -603,12 +633,18 @@ struct HfTaskFlow { addHistograms(); addMftHistograms(); - if (!configTask.doEtaDependentFlow) { + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + registry.add("Trig_hist_TPC_MFT", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + } else if (configTask.doEtaDependentFlow) { + registry.add("Trig_hist_TPC_MFT", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisEtaTrigger}}}); + sameEventTpcMft.setObject(new CorrelationContainer("sameEvent_TPC_MFT", "sameEvent_TPC_MFT", corrAxisEta, effAxis, {})); + mixedEventTpcMft.setObject(new CorrelationContainer("mixedEvent_TPC_MFT", "mixedEvent_TPC_MFT", corrAxisEta, effAxis, {})); } else { - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + registry.add("Trig_hist_TPC_MFT", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); + sameEventTpcMft.setObject(new CorrelationContainer("sameEvent_TPC_MFT", "sameEvent_TPC_MFT", corrAxisVariations, effAxis, {})); + mixedEventTpcMft.setObject(new CorrelationContainer("mixedEvent_TPC_MFT", "mixedEvent_TPC_MFT", corrAxisVariations, effAxis, {})); } } @@ -632,49 +668,49 @@ struct HfTaskFlow { // Initialization of histograms and CorrelationContainers for TpcFv0a cases // ========================= - if (doprocessSameTpcFv0aChCh) { - addHistograms(); + // if (doprocessSameTpcFv0aChCh) { + // addHistograms(); - if (!configTask.doEtaDependentFlow) { - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); - } else { - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); - } - } + // if (!configTask.doEtaDependentFlow) { + // sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); + // mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + // } else { + // sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); + // mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + // } + // } - if (doprocessSameTpcFv0aD0Ch) { - addHistograms(); + // if (doprocessSameTpcFv0aD0Ch) { + // addHistograms(); - sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); - mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); - } + // sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); + // mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); + // } - if (doprocessSameTpcFv0aLcCh) { - addHistograms(); + // if (doprocessSameTpcFv0aLcCh) { + // addHistograms(); - sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); - mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); - } + // sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); + // mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); + // } // ========================= // Initialization of histograms and CorrelationContainers for MftFv0a cases // ========================= - // if (doprocessSameMftFv0aChCh || doprocessSameMftFv0aChChReassociated || doprocessSameMftFv0aReassociated3d || doprocessSameMftFv0aChChNonAmbiguous) { - if (doprocessSameMftFv0aChCh || doprocessSameMftFv0aChChReassociated || doprocessSameMftFv0aChChNonAmbiguous) { - addHistograms(); - addMftHistograms(); + // // if (doprocessSameMftFv0aChCh || doprocessSameMftFv0aChChReassociated || doprocessSameMftFv0aReassociated3d || doprocessSameMftFv0aChChNonAmbiguous) { + // if (doprocessSameMftFv0aChCh || doprocessSameMftFv0aChChReassociated || doprocessSameMftFv0aChChNonAmbiguous) { + // addHistograms(); + // addMftHistograms(); - if (!configTask.doEtaDependentFlow) { - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); - } else { - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); - } - } + // if (!configTask.doEtaDependentFlow) { + // sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); + // mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + // } else { + // sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); + // mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + // } + // } // ========================= // Initialization of histograms and CorrelationContainers for TpcFt0a cases @@ -685,12 +721,18 @@ struct HfTaskFlow { registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - if (!configTask.doEtaDependentFlow) { + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + registry.add("Trig_hist_TPC_FT0A", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + } else if (configTask.doEtaDependentFlow) { + registry.add("Trig_hist_TPC_FT0A", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisEtaTrigger}}}); + sameEventTpcFt0a.setObject(new CorrelationContainer("sameEvent_TPC_FT0A", "sameEvent_TPC_FT0A", corrAxisEta, effAxis, {})); + mixedEventTpcFt0a.setObject(new CorrelationContainer("mixedEvent_TPC_FT0A", "mixedEvent_TPC_FT0A", corrAxisEta, effAxis, {})); } else { - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + registry.add("Trig_hist_TPC_FT0A", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); + sameEventTpcFt0a.setObject(new CorrelationContainer("sameEvent_TPC_FT0A", "sameEvent_TPC_FT0A", corrAxisVariations, effAxis, {})); + mixedEventTpcFt0a.setObject(new CorrelationContainer("mixedEvent_TPC_FT0A", "mixedEvent_TPC_FT0A", corrAxisVariations, effAxis, {})); } } @@ -722,12 +764,18 @@ struct HfTaskFlow { registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - if (!configTask.doEtaDependentFlow) { + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + registry.add("Trig_hist_MFT_FT0A", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + } else if (configTask.doEtaDependentFlow) { + registry.add("Trig_hist_MFT_FT0A", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisEtaTrigger}}}); + sameEventMftFt0a.setObject(new CorrelationContainer("sameEvent_MFT_FT0A", "sameEvent_MFT_FT0A", corrAxisEta, effAxis, {})); + mixedEventMftFt0a.setObject(new CorrelationContainer("mixedEvent_MFT_FT0A", "mixedEvent_MFT_FT0A", corrAxisEta, effAxis, {})); } else { - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + registry.add("Trig_hist_MFT_FT0A", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); + sameEventMftFt0a.setObject(new CorrelationContainer("sameEvent_MFT_FT0A", "sameEvent_MFT_FT0A", corrAxisVariations, effAxis, {})); + mixedEventMftFt0a.setObject(new CorrelationContainer("mixedEvent_MFT_FT0A", "mixedEvent_MFT_FT0A", corrAxisVariations, effAxis, {})); } } @@ -740,12 +788,18 @@ struct HfTaskFlow { registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - if (!configTask.doEtaDependentFlow) { + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + registry.add("Trig_hist_TPC_FT0C", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); - } else { + } else if (configTask.doEtaDependentFlow) { + registry.add("Trig_hist_TPC_FT0C", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisEtaTrigger}}}); sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + } else { + registry.add("Trig_hist_TPC_FT0C", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisVariations, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisVariations, effAxis, {})); } } @@ -776,15 +830,42 @@ struct HfTaskFlow { registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - if (!configTask.doEtaDependentFlow) { + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + registry.add("Trig_hist_FT0A_FT0C", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); - } else { + } else if (configTask.doEtaDependentFlow) { + registry.add("Trig_hist_FT0A_FT0C ", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisEtaTrigger}}}); sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + } else { + registry.add("Trig_hist_FT0A_FT0C", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisVariations, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisVariations, effAxis, {})); } } + // ========================= + // Initialization of histograms and CorrelationContainers for McGen cases + // ========================= + + // if (doprocessSameMcGen) { + + // if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + // registry.add("Trig_hist", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); + // sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); + // mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + // } else if (configTask.doEtaDependentFlow){ + // registry.add("Trig_hist", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisEtaTrigger}}}); + // sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); + // mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + // } else { + // registry.add("Trig_hist", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); + // sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisVariations, effAxis, {})); + // mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisVariations, effAxis, {})); + // } + // } + } // End of init() function // ========================= @@ -904,29 +985,29 @@ struct HfTaskFlow { return RecoDecay::phi(chPos.X() + (*offsetFT0)[i].getX(), chPos.Y() + (*offsetFT0)[i].getY()); } - double getPhiFV0(unsigned int chno) const - { - int const cellsInLeft[] = {0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 40, 33, 41, 34, 42, 35, 43}; - bool const isChnoInLeft = std::find(std::begin(cellsInLeft), std::end(cellsInLeft), chno) != std::end(cellsInLeft); - float offsetX{}, offsetY{}; - if (isChnoInLeft) { - offsetX = (*offsetFV0)[0].getX(); - offsetY = (*offsetFV0)[0].getY(); - } else { - offsetX = (*offsetFV0)[1].getX(); - offsetY = (*offsetFV0)[1].getY(); - } + // double getPhiFV0(unsigned int chno) const + // { + // int const cellsInLeft[] = {0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 40, 33, 41, 34, 42, 35, 43}; + // bool const isChnoInLeft = std::find(std::begin(cellsInLeft), std::end(cellsInLeft), chno) != std::end(cellsInLeft); + // float offsetX{}, offsetY{}; + // if (isChnoInLeft) { + // offsetX = (*offsetFV0)[0].getX(); + // offsetY = (*offsetFV0)[0].getY(); + // } else { + // offsetX = (*offsetFV0)[1].getX(); + // offsetY = (*offsetFV0)[1].getY(); + // } - o2::fv0::Point3Dsimple chPos{}; - chPos = fv0Det->getReadoutCenter(chno); + // o2::fv0::Point3Dsimple chPos{}; + // chPos = fv0Det->getReadoutCenter(chno); - // if (configTask.isReadoutCenter) - // chPos = fv0Det->getReadoutCenter(chno); - // else - // chPos = fv0Det->getCellCenter(chno); + // // if (configTask.isReadoutCenter) + // // chPos = fv0Det->getReadoutCenter(chno); + // // else + // // chPos = fv0Det->getCellCenter(chno); - return RecoDecay::phi(chPos.x + offsetX, chPos.y + offsetY); - } + // return RecoDecay::phi(chPos.x + offsetX, chPos.y + offsetY); + // } double getEtaFT0(uint chno, int i) { @@ -943,35 +1024,35 @@ struct HfTaskFlow { return -std::log(std::tan(0.5 * theta)); } - double getEtaFV0(unsigned int chno) const - { - int const cellsInLeft[] = {0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 40, 33, 41, 34, 42, 35, 43}; - bool const isChnoInLeft = std::find(std::begin(cellsInLeft), std::end(cellsInLeft), chno) != std::end(cellsInLeft); - float offsetX{}, offsetY{}, offsetZ{}; - if (isChnoInLeft) { - offsetX = (*offsetFV0)[0].getX(); - offsetY = (*offsetFV0)[0].getY(); - offsetZ = (*offsetFV0)[0].getZ(); - } else { - offsetX = (*offsetFV0)[1].getX(); - offsetY = (*offsetFV0)[1].getY(); - offsetZ = (*offsetFV0)[1].getZ(); - } - - o2::fv0::Point3Dsimple chPos{}; - chPos = fv0Det->getReadoutCenter(chno); - // if (configTask.isReadoutCenter) - // chPos = fv0Det->getReadoutCenter(chno); - // else - // chPos = fv0Det->getCellCenter(chno); - - auto x = chPos.x + offsetX; - auto y = chPos.y + offsetY; - auto z = chPos.z + offsetZ; - auto r = std::sqrt(x * x + y * y); - auto theta = std::atan2(r, z); - return -std::log(std::tan(0.5 * theta)); - } + // double getEtaFV0(unsigned int chno) const + // { + // int const cellsInLeft[] = {0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 40, 33, 41, 34, 42, 35, 43}; + // bool const isChnoInLeft = std::find(std::begin(cellsInLeft), std::end(cellsInLeft), chno) != std::end(cellsInLeft); + // float offsetX{}, offsetY{}, offsetZ{}; + // if (isChnoInLeft) { + // offsetX = (*offsetFV0)[0].getX(); + // offsetY = (*offsetFV0)[0].getY(); + // offsetZ = (*offsetFV0)[0].getZ(); + // } else { + // offsetX = (*offsetFV0)[1].getX(); + // offsetY = (*offsetFV0)[1].getY(); + // offsetZ = (*offsetFV0)[1].getZ(); + // } + + // o2::fv0::Point3Dsimple chPos{}; + // chPos = fv0Det->getReadoutCenter(chno); + // // if (configTask.isReadoutCenter) + // // chPos = fv0Det->getReadoutCenter(chno); + // // else + // // chPos = fv0Det->getCellCenter(chno); + + // auto x = chPos.x + offsetX; + // auto y = chPos.y + offsetY; + // auto z = chPos.z + offsetZ; + // auto r = std::sqrt(x * x + y * y); + // auto theta = std::atan2(r, z); + // return -std::log(std::tan(0.5 * theta)); + // } template void getChannel(TFT0s const& ft0, std::size_t const& iCh, int& id, int fitType, float& amplitude) @@ -1259,7 +1340,7 @@ struct HfTaskFlow { auto triggerWeight = 1; auto associatedWeight = 1; 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 = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE for (const auto& track1 : tracks1) { @@ -1294,12 +1375,16 @@ struct HfTaskFlow { } // fill single-track distributions - if (!fillingHFcontainer) { // if not HF-h case - if (!configTask.doEtaDependentFlow) { // if not eta-differential flow, fill vs pt, otherwise fill vs eta - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); - } else { - target->getTriggerHist()->Fill(step, eta1, multiplicity, posZ, triggerWeight); + if (!fillingHFcontainer) { // if not HF-h case + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + + if (configTask.doEtaDependentFlow) { + registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + } + if (configTask.doVariationContainers) { + registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.pt(), triggerWeight); } + } else { target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, triggerWeight); } @@ -1426,11 +1511,14 @@ struct HfTaskFlow { if (!fillingHFcontainer) { // fill pair correlations - if (!configTask.doEtaDependentFlow) { + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, triggerWeight * associatedWeight); + } else if (configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, + triggerWeight * associatedWeight); } else { - target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, triggerWeight * associatedWeight); } } else { @@ -1474,7 +1562,7 @@ struct HfTaskFlow { auto triggerWeight = 1; auto associatedWeight = 1; 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 = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE for (const auto& track1 : tracks1) { @@ -1506,11 +1594,15 @@ struct HfTaskFlow { // fill single-track distributions if (!fillingHFcontainer) { // if not HF-h case - if (!configTask.doEtaDependentFlow) { - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); - } else { - target->getTriggerHist()->Fill(step, eta1, multiplicity, posZ, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + + if (configTask.doEtaDependentFlow) { + registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + } + if (configTask.doVariationContainers) { + registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.pt(), triggerWeight); } + } else { target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, triggerWeight); } @@ -1621,11 +1713,14 @@ struct HfTaskFlow { deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); if (!fillingHFcontainer) { - if (!configTask.doEtaDependentFlow) { + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, triggerWeight * associatedWeight); + } else if (configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, + triggerWeight * associatedWeight); } else { - target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, triggerWeight * associatedWeight); } } else { @@ -1658,7 +1753,7 @@ struct HfTaskFlow { auto triggerWeight = 1; auto associatedWeight = 1; 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 = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE for (auto const& track1 : tracks1) { @@ -1705,11 +1800,23 @@ struct HfTaskFlow { // fill single-track distributions if (!fillingHFcontainer) { // if not HF-h case - if (!configTask.doEtaDependentFlow) { - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); - } else { - target->getTriggerHist()->Fill(step, eta1, multiplicity, posZ, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + + if (configTask.doEtaDependentFlow) { + if (fitType == isFT0A) { + registry.fill(HIST("Trig_hist_TPC_FT0A"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + } else { + registry.fill(HIST("Trig_hist_TPC_FT0C"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + } } + if (configTask.doVariationContainers) { + if (fitType == isFT0A) { + registry.fill(HIST("Trig_hist_TPC_FT0A"), sampleIndex, posZ, track1.pt(), triggerWeight); // think about event weight in near future + } else { + registry.fill(HIST("Trig_hist_TPC_FT0C"), sampleIndex, posZ, track1.pt(), triggerWeight); // think about event weight in near future + } + } + } else { target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, triggerWeight); } @@ -1760,45 +1867,45 @@ struct HfTaskFlow { } } // end of if condition to fill QA plots for trigger particle - // ASSOCIATED PARTICLE IF USING FV0 - if constexpr (std::is_same_v) { - for (std::size_t indexChannel = 0; indexChannel < tracks2.channel().size(); indexChannel++) { - - auto channelId = tracks2.channel()[indexChannel]; - auto phi2 = getPhiFV0(channelId); - auto eta2 = getEtaFV0(channelId); - float deltaPhi = phi1 - phi2; - deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); // set range of delta phi in (-pi/2 , 3/2*pi) - - if (!fillingHFcontainer) { - if (!configTask.doEtaDependentFlow) { - target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, - triggerWeight * associatedWeight); - } else { - target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, - triggerWeight * associatedWeight); - } - } else { - target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, invmass, - triggerWeight * associatedWeight); - } - - // FILL QA PLOTS for associated particle - if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { - if constexpr (!std::is_same_v) { // If not FilteredMftTracks as trigger -> TPC-FV0a correlations - if constexpr (std::is_same_v) { // IF D0 CASE -> TPC-FV0a D0-h - fillAssociatedQa(multiplicity, eta2, phi2); - } else if constexpr (std::is_same_v) { // IF LC CASE -> TPC-FV0a Lc-h - fillAssociatedQa(multiplicity, eta2, phi2); - } else if constexpr (std::is_same_v) { // IF NEITHER D0 NOR LC -> ch. part. - ch. part - fillAssociatedQa(multiplicity, eta2, phi2); - } - } else { // If FilteredMftTracks as trigger -> MFT-FV0a (non reassoc/ambiguous) correlations - fillAssociatedQa(multiplicity, eta2, phi2); - } - } // end of if condition to fill QA plots for associated particle - } // end of loop over FV0 channel indices - } // end of if condition for FV0s + // // ASSOCIATED PARTICLE IF USING FV0 + // if constexpr (std::is_same_v) { + // for (std::size_t indexChannel = 0; indexChannel < tracks2.channel().size(); indexChannel++) { + + // auto channelId = tracks2.channel()[indexChannel]; + // auto phi2 = getPhiFV0(channelId); + // auto eta2 = getEtaFV0(channelId); + // float deltaPhi = phi1 - phi2; + // deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); // set range of delta phi in (-pi/2 , 3/2*pi) + + // if (!fillingHFcontainer) { + // if (!configTask.doEtaDependentFlow) { + // target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, + // triggerWeight * associatedWeight); + // } else { + // target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + // triggerWeight * associatedWeight); + // } + // } else { + // target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, invmass, + // triggerWeight * associatedWeight); + // } + + // // FILL QA PLOTS for associated particle + // if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + // if constexpr (!std::is_same_v) { // If not FilteredMftTracks as trigger -> TPC-FV0a correlations + // if constexpr (std::is_same_v) { // IF D0 CASE -> TPC-FV0a D0-h + // fillAssociatedQa(multiplicity, eta2, phi2); + // } else if constexpr (std::is_same_v) { // IF LC CASE -> TPC-FV0a Lc-h + // fillAssociatedQa(multiplicity, eta2, phi2); + // } else if constexpr (std::is_same_v) { // IF NEITHER D0 NOR LC -> ch. part. - ch. part + // fillAssociatedQa(multiplicity, eta2, phi2); + // } + // } else { // If FilteredMftTracks as trigger -> MFT-FV0a (non reassoc/ambiguous) correlations + // fillAssociatedQa(multiplicity, eta2, phi2); + // } + // } // end of if condition to fill QA plots for associated particle + // } // end of loop over FV0 channel indices + // } // end of if condition for FV0s // ASSOCIATED PARTICLE IF USING FT0 if constexpr (std::is_same_v) { @@ -1824,11 +1931,14 @@ struct HfTaskFlow { deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); // set range of delta phi in (-pi/2 , 3/2*pi) if (!fillingHFcontainer) { - if (!configTask.doEtaDependentFlow) { - target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + target->getPairHist()->Fill(step, eta1 - eta2, 0.5, pt1, multiplicity, deltaPhi, posZ, + amplitude * triggerWeight * associatedWeight); + } else if (configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, amplitude * triggerWeight * associatedWeight); } else { - target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, amplitude * triggerWeight * associatedWeight); } } else { @@ -1880,7 +1990,7 @@ struct HfTaskFlow { auto triggerWeight = 1; auto associatedWeight = 1; 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 = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE for (auto const& track1 : tracks1) { @@ -1921,10 +2031,13 @@ struct HfTaskFlow { float phi1 = reassociatedMftTrack.phi(); o2::math_utils::bringTo02Pi(phi1); - if (!configTask.doEtaDependentFlow) { - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); - } else { - target->getTriggerHist()->Fill(step, eta1, multiplicity, posZ, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + + if (configTask.doEtaDependentFlow) { + registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, eta1, triggerWeight); // think about event weight in near future + } + if (configTask.doVariationContainers) { + registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, pt1, triggerWeight); } // FILL QA PLOTS for trigger particle @@ -1938,31 +2051,31 @@ struct HfTaskFlow { } } // end of if condition to fill QA plots for trigger particle - // ASSOCIATED PARTICLE FOR FV0s - if constexpr (std::is_same_v) { - for (std::size_t indexChannel = 0; indexChannel < tracks2.channel().size(); indexChannel++) { + // // ASSOCIATED PARTICLE FOR FV0s + // if constexpr (std::is_same_v) { + // for (std::size_t indexChannel = 0; indexChannel < tracks2.channel().size(); indexChannel++) { - auto channelId = tracks2.channel()[indexChannel]; - auto phi2 = getPhiFV0(channelId); - auto eta2 = getEtaFV0(channelId); + // auto channelId = tracks2.channel()[indexChannel]; + // auto phi2 = getPhiFV0(channelId); + // auto eta2 = getEtaFV0(channelId); - float deltaPhi = phi1 - phi2; - deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); // set range of delta phi in (-pi/2 , 3/2*pi) + // float deltaPhi = phi1 - phi2; + // deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); // set range of delta phi in (-pi/2 , 3/2*pi) - if (!configTask.doEtaDependentFlow) { - target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, - triggerWeight * associatedWeight); - } else { - target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, - triggerWeight * associatedWeight); - } + // if (!configTask.doEtaDependentFlow) { + // target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, + // triggerWeight * associatedWeight); + // } else { + // target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + // triggerWeight * associatedWeight); + // } - // FILL QA PLOTS for associated particle - if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { - fillAssociatedQa(multiplicity, eta2, phi2); - } // end of if condition to fill QA plots for associated particle - } // end of loop over FV0 channel indices - } // end of if condition for FV0s + // // FILL QA PLOTS for associated particle + // if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + // fillAssociatedQa(multiplicity, eta2, phi2); + // } // end of if condition to fill QA plots for associated particle + // } // end of loop over FV0 channel indices + // } // end of if condition for FV0s // ASSOCIATED PARTICLE FOR FT0s if constexpr (std::is_same_v) { @@ -1987,11 +2100,14 @@ struct HfTaskFlow { float deltaPhi = phi1 - phi2; deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); // set range of delta phi in (-pi/2 , 3/2*pi) - if (!configTask.doEtaDependentFlow) { - target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + target->getPairHist()->Fill(step, eta1 - eta2, 0.5, pt1, multiplicity, deltaPhi, posZ, + amplitude * triggerWeight * associatedWeight); + } else if (configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, amplitude * triggerWeight * associatedWeight); } else { - target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, amplitude * triggerWeight * associatedWeight); } @@ -2014,7 +2130,7 @@ struct HfTaskFlow { auto triggerWeight = 1; auto associatedWeight = 1; 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 = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE FROM FT0A for (std::size_t indexChannelA = 0; indexChannelA < ft0as.channelA().size(); indexChannelA++) { @@ -2025,14 +2141,17 @@ struct HfTaskFlow { auto phiA = getPhiFT0(channelIdA, isFT0A); auto etaA = getEtaFT0(channelIdA, isFT0A); - if (!configTask.doEtaDependentFlow) { - target->getTriggerHist()->Fill(step, 0.f, multiplicity, posZ, amplitude * triggerWeight); - } else { - target->getTriggerHist()->Fill(step, etaA, multiplicity, posZ, amplitude * triggerWeight); + target->getTriggerHist()->Fill(step, 0.5, multiplicity, posZ, amplitude * triggerWeight); + + if (configTask.doEtaDependentFlow) { + registry.fill(HIST("Trig_hist_FT0A_FT0C"), sampleIndex, posZ, etaA, triggerWeight); // think about event weight in near future + } + if (configTask.doVariationContainers) { + registry.fill(HIST("Trig_hist_FT0A_FT0C"), sampleIndex, posZ, 0.5, triggerWeight); } if (sameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { - fillTriggerQa(multiplicity, etaA, phiA, 0.f); + fillTriggerQa(multiplicity, etaA, phiA, 0.5); } // end of fill trigger QA // ASSOCIATED PARTICLE FROM FT0C @@ -2045,11 +2164,14 @@ struct HfTaskFlow { auto etaC = getEtaFT0(channelIdC, isFT0C); float deltaPhi = RecoDecay::constrainAngle(phiA - phiC, -PIHalf); - if (!configTask.doEtaDependentFlow) { - target->getPairHist()->Fill(step, etaA - etaC, 0.f, 0.f, multiplicity, deltaPhi, posZ, + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + target->getPairHist()->Fill(step, etaA - etaC, 0.5, 0.5, multiplicity, deltaPhi, posZ, + amplitude * triggerWeight * associatedWeight); + } else if (configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, sampleIndex, posZ, etaC, etaA, deltaPhi, etaA - etaC, amplitude * triggerWeight * associatedWeight); } else { - target->getPairHist()->Fill(step, etaA - etaC, etaC, etaA, multiplicity, deltaPhi, posZ, + target->getPairHist()->Fill(step, sampleIndex, posZ, 0.5, multiplicity, deltaPhi, etaA - etaC, amplitude * triggerWeight * associatedWeight); } @@ -2060,6 +2182,68 @@ struct HfTaskFlow { } // end of trigger loop } // end of fillCorrelationsFt0aFt0c + template + void fillCorrelationsMonteCarlo(TTarget target, CorrelationContainer::CFStep step, + TTracksTrig const& tracks1, TTracksAssoc const& tracks2, + float multiplicity, float posZ, bool sameEvent) + { + auto triggerWeight = 1; + auto associatedWeight = 1; + 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); + + for (auto const& track1 : tracks1) { + + if (track1.eta() < configTask.etaMcParticlesTriggerMin || track1.eta() > configTask.etaMcParticlesTriggerMax) { + continue; + } + if (track1.pt() < configTask.ptMcParticlesTriggerMin || track1.pt() > configTask.ptMcParticlesTriggerMax) { + continue; + } + if (step >= CorrelationContainer::kCFStepTrackedOnlyPrim && !track1.isPhysicalPrimary()) { + continue; + } + + target->getTriggerHist()->Fill(step, track1.pt(), multiplicity, posZ, triggerWeight); + if (configTask.doEtaDependentFlow) { + registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.eta(), triggerWeight); + } else { + registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.pt(), triggerWeight); + } + + for (auto const& track2 : tracks2) { + + if (track1.globalIndex() == track2.globalIndex()) { + continue; + } + if (track2.eta() < configTask.etaMcParticlesAssocMin || track2.eta() > configTask.etaMcParticlesAssocMax) { + continue; + } + if (track2.pt() < configTask.ptMcParticlesAssocMin || track2.pt() > configTask.ptMcParticlesAssocMax) { + continue; + } + if (step >= CorrelationContainer::kCFStepTrackedOnlyPrim && !track2.isPhysicalPrimary()) { + continue; + } + + float deltaPhi = RecoDecay::constrainAngle(track2.phi() - track1.phi(), -PIHalf); + float deltaEta = track2.eta() - track1.eta(); + + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + target->getPairHist()->Fill(step, deltaEta, track2.pt(), track1.pt(), multiplicity, deltaPhi, posZ, + triggerWeight * associatedWeight); + } else if (configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, sampleIndex, posZ, track2.eta(), track1.eta(), deltaPhi, deltaEta, + triggerWeight * associatedWeight); + } else { + target->getPairHist()->Fill(step, sampleIndex, posZ, track1.pt(), multiplicity, deltaPhi, deltaEta, + triggerWeight * associatedWeight); + } + } // end of loop over track2 + + } // end of loop over track1 + } + // =============================================================================================================================================================================== // mixCollisions for RECONSTRUCTED events // =============================================================================================================================================================================== @@ -2397,8 +2581,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelations(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelations(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + } else { + sameEventTpcMft->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelations(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + } } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChCh, "DATA : Process same-event correlations for TPC-MFT h-h case", false); @@ -2420,8 +2609,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + } else { + sameEventTpcMft->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + } } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChChReassociated, "DATA : Process same-event correlations for TPC-MFT h-h case reassociated", false); @@ -2445,8 +2639,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + } else { + sameEventTpcMft->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + } } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChChReassociated3d, "DATA : Process same-event correlations for TPC-MFT h-h case 3d reassociated", false); @@ -2468,8 +2667,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, true); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, true); + } else { + sameEventTpcMft->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, true); + } } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChChNonAmbiguous, "DATA : Process same-event correlations for TPC-MFT h-h case with non-ambiguous tracks", false); @@ -2583,130 +2787,130 @@ struct HfTaskFlow { // DATA : process same event correlations: TPC-FV0A Ch. Part. - Ch. Part // ===================================== - void processSameTpcFv0aChCh(FilteredCollisionsWSelMult::iterator const& collision, - FilteredTracksWDcaSel const& tracks, - aod::FV0As const& fv0as) - { - if (!(isAcceptedCollision(collision, true))) { - return; - } - - if (collision.has_foundFV0()) { - const auto& fv0 = collision.foundFV0(); - - registry.fill(HIST("Data/hNTracks"), tracks.size()); - const auto multiplicity = getMultiplicityEstimator(collision, true); - - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { - return; - } - - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, fv0, fv0as, multiplicity, collision.posZ(), true, isFV0A); - } - } - PROCESS_SWITCH(HfTaskFlow, processSameTpcFv0aChCh, "DATA : Process same-event correlations for TPC-FV0-A h-h case", false); - - // ===================================== - // DATA : process same event correlations: TPC-FV0A D0 - Ch. Part - // ===================================== - - void processSameTpcFv0aD0Ch(FilteredCollisionsWSelMult::iterator const& collision, - HfCandidatesSelD0 const& candidates, - aod::FV0As const& fv0as) - { - if (!(isAcceptedCollision(collision, true))) { - return; - } - - if (collision.has_foundFV0()) { - const auto& fv0 = collision.foundFV0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); - - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { - return; - } - - sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, fv0, fv0as, multiplicity, collision.posZ(), true, isFV0A); - } - } - PROCESS_SWITCH(HfTaskFlow, processSameTpcFv0aD0Ch, "DATA : Process same-event correlations for TPC-FV0-A D0-h case", false); - - // ===================================== - // DATA : process same event correlations: TPC-FV0A Lc - Ch. Part - // ===================================== - - void processSameTpcFv0aLcCh(FilteredCollisionsWSelMult::iterator const& collision, - HfCandidatesSelLc const& candidates, - aod::FV0As const& fv0as) - { - if (!(isAcceptedCollision(collision, true))) { - return; - } - - if (collision.has_foundFV0()) { - const auto& fv0 = collision.foundFV0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); - - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { - return; - } - - sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, fv0, fv0as, multiplicity, collision.posZ(), true, isFV0A); - } - } - PROCESS_SWITCH(HfTaskFlow, processSameTpcFv0aLcCh, "DATA : Process same-event correlations for TPC-FV0-A Lc-h case", false); - - // ===================================== - // DATA : process same event correlations: MFT-FV0A Ch. Part. - Ch. Part - // ===================================== - - void processSameMftFv0aChCh(FilteredCollisionsWSelMult::iterator const& collision, - FilteredMftTracks const& mftTracks, - aod::FV0As const& fv0as) - { - if (!(isAcceptedCollision(collision, true))) { - return; - } - - if (collision.has_foundFV0()) { - const auto& fv0 = collision.foundFV0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); - - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { - return; - } - - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, fv0, fv0as, multiplicity, collision.posZ(), true, isFV0A); - } - } - PROCESS_SWITCH(HfTaskFlow, processSameMftFv0aChCh, "DATA : Process same-event correlations for MFT-FV0-A h-h case", false); - - void processSameMftFv0aChChReassociated(FilteredCollisionsWSelMult::iterator const& collision, - soa::SmallGroups const& reassociatedMftTracks, - FilteredMftTracks const&, - aod::FV0As const& fv0as) - { - if (!(isAcceptedCollision(collision, true))) { - return; - } - - if (collision.has_foundFV0()) { - const auto& fv0 = collision.foundFV0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); - - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { - return; - } - - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, fv0, fv0as, multiplicity, collision.posZ(), true, false, isFV0A); - } - } - PROCESS_SWITCH(HfTaskFlow, processSameMftFv0aChChReassociated, "DATA : Process same-event correlations for MFT-FV0a h-h case reassociated", false); + // void processSameTpcFv0aChCh(FilteredCollisionsWSelMult::iterator const& collision, + // FilteredTracksWDcaSel const& tracks, + // aod::FV0As const& fv0as) + // { + // if (!(isAcceptedCollision(collision, true))) { + // return; + // } + + // if (collision.has_foundFV0()) { + // const auto& fv0 = collision.foundFV0(); + + // registry.fill(HIST("Data/hNTracks"), tracks.size()); + // const auto multiplicity = getMultiplicityEstimator(collision, true); + + // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // return; + // } + + // sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + // fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, fv0, fv0as, multiplicity, collision.posZ(), true, isFV0A); + // } + // } + // PROCESS_SWITCH(HfTaskFlow, processSameTpcFv0aChCh, "DATA : Process same-event correlations for TPC-FV0-A h-h case", false); + + // // ===================================== + // // DATA : process same event correlations: TPC-FV0A D0 - Ch. Part + // // ===================================== + + // void processSameTpcFv0aD0Ch(FilteredCollisionsWSelMult::iterator const& collision, + // HfCandidatesSelD0 const& candidates, + // aod::FV0As const& fv0as) + // { + // if (!(isAcceptedCollision(collision, true))) { + // return; + // } + + // if (collision.has_foundFV0()) { + // const auto& fv0 = collision.foundFV0(); + // const auto multiplicity = getMultiplicityEstimator(collision, true); + + // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // return; + // } + + // sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + // fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, fv0, fv0as, multiplicity, collision.posZ(), true, isFV0A); + // } + // } + // PROCESS_SWITCH(HfTaskFlow, processSameTpcFv0aD0Ch, "DATA : Process same-event correlations for TPC-FV0-A D0-h case", false); + + // // ===================================== + // // DATA : process same event correlations: TPC-FV0A Lc - Ch. Part + // // ===================================== + + // void processSameTpcFv0aLcCh(FilteredCollisionsWSelMult::iterator const& collision, + // HfCandidatesSelLc const& candidates, + // aod::FV0As const& fv0as) + // { + // if (!(isAcceptedCollision(collision, true))) { + // return; + // } + + // if (collision.has_foundFV0()) { + // const auto& fv0 = collision.foundFV0(); + // const auto multiplicity = getMultiplicityEstimator(collision, true); + + // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // return; + // } + + // sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + // fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, fv0, fv0as, multiplicity, collision.posZ(), true, isFV0A); + // } + // } + // PROCESS_SWITCH(HfTaskFlow, processSameTpcFv0aLcCh, "DATA : Process same-event correlations for TPC-FV0-A Lc-h case", false); + + // // ===================================== + // // DATA : process same event correlations: MFT-FV0A Ch. Part. - Ch. Part + // // ===================================== + + // void processSameMftFv0aChCh(FilteredCollisionsWSelMult::iterator const& collision, + // FilteredMftTracks const& mftTracks, + // aod::FV0As const& fv0as) + // { + // if (!(isAcceptedCollision(collision, true))) { + // return; + // } + + // if (collision.has_foundFV0()) { + // const auto& fv0 = collision.foundFV0(); + // const auto multiplicity = getMultiplicityEstimator(collision, true); + + // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // return; + // } + + // sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + // fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, fv0, fv0as, multiplicity, collision.posZ(), true, isFV0A); + // } + // } + // PROCESS_SWITCH(HfTaskFlow, processSameMftFv0aChCh, "DATA : Process same-event correlations for MFT-FV0-A h-h case", false); + + // void processSameMftFv0aChChReassociated(FilteredCollisionsWSelMult::iterator const& collision, + // soa::SmallGroups const& reassociatedMftTracks, + // FilteredMftTracks const&, + // aod::FV0As const& fv0as) + // { + // if (!(isAcceptedCollision(collision, true))) { + // return; + // } + + // if (collision.has_foundFV0()) { + // const auto& fv0 = collision.foundFV0(); + // const auto multiplicity = getMultiplicityEstimator(collision, true); + + // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // return; + // } + + // sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + // fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, fv0, fv0as, multiplicity, collision.posZ(), true, false, isFV0A); + // } + // } + // PROCESS_SWITCH(HfTaskFlow, processSameMftFv0aChChReassociated, "DATA : Process same-event correlations for MFT-FV0a h-h case reassociated", false); /* void processSameMftFv0aChChReassociated3d(FilteredCollisionsWSelMult::iterator const& collision, @@ -2733,28 +2937,28 @@ struct HfTaskFlow { PROCESS_SWITCH(HfTaskFlow, processSameMftFv0aChChReassociated3d, "DATA : Process same-event correlations for MFT-FV0a h-h case 3d reassociated", false); */ - void processSameMftFv0aChChNonAmbiguous(FilteredCollisionsWSelMult::iterator const& collision, - soa::SmallGroups const& reassociatedMftTracks, - FilteredMftTracks const&, - aod::FV0As const& fv0as) - { - if (!(isAcceptedCollision(collision, true))) { - return; - } + // void processSameMftFv0aChChNonAmbiguous(FilteredCollisionsWSelMult::iterator const& collision, + // soa::SmallGroups const& reassociatedMftTracks, + // FilteredMftTracks const&, + // aod::FV0As const& fv0as) + // { + // if (!(isAcceptedCollision(collision, true))) { + // return; + // } - if (collision.has_foundFV0()) { - const auto& fv0 = collision.foundFV0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + // if (collision.has_foundFV0()) { + // const auto& fv0 = collision.foundFV0(); + // const auto multiplicity = getMultiplicityEstimator(collision, true); - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { - return; - } + // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // return; + // } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, fv0, fv0as, multiplicity, collision.posZ(), true, true, isFV0A); - } - } - PROCESS_SWITCH(HfTaskFlow, processSameMftFv0aChChNonAmbiguous, "DATA : Process same-event correlations for MFT-FV0a h-h non-ambiguous case", false); + // sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + // fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, fv0, fv0as, multiplicity, collision.posZ(), true, true, isFV0A); + // } + // } + // PROCESS_SWITCH(HfTaskFlow, processSameMftFv0aChChNonAmbiguous, "DATA : Process same-event correlations for MFT-FV0a h-h non-ambiguous case", false); // ===================================== // DATA : process same event correlations: TPC-FT0A Ch. Part. - Ch. Part @@ -2781,8 +2985,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + } else { + sameEventTpcFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFIT(sameEventTpcFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + } } } PROCESS_SWITCH(HfTaskFlow, processSameTpcFt0aChCh, "DATA : Process same-event correlations for TPC-FT0-A h-h case", false); @@ -2871,8 +3080,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + } else { + sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFIT(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + } } } PROCESS_SWITCH(HfTaskFlow, processSameMftFt0aChCh, "DATA : Process same-event correlations for MFT-FT0-A h-h case", false); @@ -2898,8 +3112,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + } else { + sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + } } } PROCESS_SWITCH(HfTaskFlow, processSameMftFt0aChChReassociated, "DATA : Process same-event correlations for MFT-FT0-A h-h case reassociated", false); @@ -2925,8 +3144,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + } else { + sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + } } } PROCESS_SWITCH(HfTaskFlow, processSameMftFt0aChChReassociated3d, "DATA : Process same-event correlations for MFT-FT0-A h-h case reassociated 3d", false); @@ -2952,8 +3176,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, true, isFT0A); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, true, isFT0A); + } else { + sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, true, isFT0A); + } } } PROCESS_SWITCH(HfTaskFlow, processSameMftFt0aChChNonAmbiguous, "DATA : Process same-event correlations for MFT-FT0-A h-h case non ambiguous", false); @@ -3078,6 +3307,33 @@ struct HfTaskFlow { } PROCESS_SWITCH(HfTaskFlow, processSameFt0aFt0cChCh, "DATA : Process same-event correlations for FT0A-FT0C h-h case", false); + // =================================================================================================================================================================================================================================================================== + // MONTE-CARLO + // =================================================================================================================================================================================================================================================================== + + // void processSameMcGen(aod::McCollisions::iterator const& mcCollision, + // aod::McParticles const& mcParticles, + // SmallGroupMcCollisions const& collisions) + // { + // if (!(abs(mcCollision.posZ()) <= configCollision.zVertexMax)) { + // return; + // } + // if ( (mcParticles.size() < configCollision.minMultiplicity) || (mcParticles.size() > configCollision.maxMultiplicity) ) { + // return; + // } + + // sameEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepAll); + // fillCorrelationsMonteCarlo(sameEvent, CorrelationContainer::CFStep::kCFStepAll, mcParticles, mcParticles, mcParticles.size(), mcCollision.posZ(), true); + + // if (collisions.size() == 0) { + // return; + // } + + // sameEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepTrackedOnlyPrim); + // fillCorrelationsMonteCarlo(sameEvent, CorrelationContainer::CFStep::kCFStepTrackedOnlyPrim, mcParticles, mcParticles, mcParticles.size(), mcCollision.posZ(), true); + // } + // PROCESS_SWITCH(HfTaskFlow, processSameMcGen, "MC Gen : Process same-event correlations", false); + // =================================================================================================================================================================================================================================================================== // =================================================================================================================================================================================================================================================================== // MIXED EVENT PROCESS FUNCTIONS @@ -3135,7 +3391,11 @@ struct HfTaskFlow { FilteredMftTracks const& mftTracks, aod::BCsWithTimestamps const& bcs) { - mixCollisions(collisions, CorrelationContainer::kCFStepReconstructed, tracks, mftTracks, mixedEvent, bcs); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisions(collisions, CorrelationContainer::kCFStepReconstructed, tracks, mftTracks, mixedEvent, bcs); + } else { + mixCollisions(collisions, CorrelationContainer::kCFStepReconstructed, tracks, mftTracks, mixedEventTpcMft, bcs); + } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChCh, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -3144,7 +3404,11 @@ struct HfTaskFlow { FilteredMftTracks const& mftTracks, aod::BCsWithTimestamps const& bcs) { - mixCollisionsBis(collisions, CorrelationContainer::kCFStepReconstructed, tracks, mftTracks, perColTracks, perColMftTracks, mixedEvent, bcs); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsBis(collisions, CorrelationContainer::kCFStepReconstructed, tracks, mftTracks, perColTracks, perColMftTracks, mixedEvent, bcs); + } else { + mixCollisionsBis(collisions, CorrelationContainer::kCFStepReconstructed, tracks, mftTracks, perColTracks, perColMftTracks, mixedEventTpcMft, bcs); + } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChBis, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -3153,7 +3417,11 @@ struct HfTaskFlow { FilteredMftTracks const& /*mftTracks*/, soa::SmallGroups const& reassociated2dMftTracks) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, false); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, false); + } else { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, false); + } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChReassociated2d, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -3162,7 +3430,11 @@ struct HfTaskFlow { FilteredMftTracks const& /*mftTracks*/, soa::SmallGroups const& reassociated3dMftTracks) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEvent, false); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEvent, false); + } else { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEventTpcMft, false); + } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChReassociated3d, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -3171,7 +3443,11 @@ struct HfTaskFlow { FilteredMftTracks const& /*mftTracks*/, soa::SmallGroups const& reassociated2dMftTracks) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, true); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, true); + } else { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, true); + } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChNonAmbiguous, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -3206,49 +3482,49 @@ struct HfTaskFlow { // DATA : process mixed event correlations: TPC-FV0-A ch part. - ch. part. case // ===================================== - void processMixedTpcFv0aChCh(FilteredCollisionsWSelMult const& collisions, - FilteredTracksWDcaSel const& tracks, - aod::FV0As const& fv0as) - { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, fv0as, perColTracks, mixedEvent, isFV0A); - } - PROCESS_SWITCH(HfTaskFlow, processMixedTpcFv0aChCh, "DATA : Process mixed-event correlations for TPC-FV0-A h-h case", false); + // void processMixedTpcFv0aChCh(FilteredCollisionsWSelMult const& collisions, + // FilteredTracksWDcaSel const& tracks, + // aod::FV0As const& fv0as) + // { + // mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, fv0as, perColTracks, mixedEvent, isFV0A); + // } + // PROCESS_SWITCH(HfTaskFlow, processMixedTpcFv0aChCh, "DATA : Process mixed-event correlations for TPC-FV0-A h-h case", false); // ===================================== // DATA : process mixed event correlations: TPC-FV0-A D0 - ch. part. case // ===================================== - void processMixedTpcFv0aD0Ch(FilteredCollisionsWSelMult const& collisions, - HfCandidatesSelD0 const& candidates, - aod::FV0As const& fv0as) - { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, fv0as, perColD0s, mixedEventHf, isFV0A); - } - PROCESS_SWITCH(HfTaskFlow, processMixedTpcFv0aD0Ch, "DATA : Process mixed-event correlations for TPC-FV0-A D0-h case", false); + // void processMixedTpcFv0aD0Ch(FilteredCollisionsWSelMult const& collisions, + // HfCandidatesSelD0 const& candidates, + // aod::FV0As const& fv0as) + // { + // mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, fv0as, perColD0s, mixedEventHf, isFV0A); + // } + // PROCESS_SWITCH(HfTaskFlow, processMixedTpcFv0aD0Ch, "DATA : Process mixed-event correlations for TPC-FV0-A D0-h case", false); // ===================================== // DATA : process mixed event correlations: TPC-FV0-A Lc - ch. part. case // ===================================== - void processMixedTpcFv0aLcCh(FilteredCollisionsWSelMult const& collisions, - HfCandidatesSelLc const& candidates, - aod::FV0As const& fv0as) - { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, fv0as, perColLcs, mixedEventHf, isFV0A); - } - PROCESS_SWITCH(HfTaskFlow, processMixedTpcFv0aLcCh, "DATA : Process mixed-event correlations for TPC-FV0-A Lc-h case", false); + // void processMixedTpcFv0aLcCh(FilteredCollisionsWSelMult const& collisions, + // HfCandidatesSelLc const& candidates, + // aod::FV0As const& fv0as) + // { + // mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, fv0as, perColLcs, mixedEventHf, isFV0A); + // } + // PROCESS_SWITCH(HfTaskFlow, processMixedTpcFv0aLcCh, "DATA : Process mixed-event correlations for TPC-FV0-A Lc-h case", false); // ===================================== // DATA : process mixed event correlations: TPC-FV0-A ch part. - ch. part. case // ===================================== - void processMixedMftFv0aChCh(FilteredCollisionsWSelMult const& collisions, - FilteredMftTracks const& mftTracks, - aod::FV0As const& fv0as) - { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, fv0as, perColMftTracks, mixedEvent, isFV0A); - } - PROCESS_SWITCH(HfTaskFlow, processMixedMftFv0aChCh, "DATA : Process mixed-event correlations for Mft-FV0-A h-h case", false); + // void processMixedMftFv0aChCh(FilteredCollisionsWSelMult const& collisions, + // FilteredMftTracks const& mftTracks, + // aod::FV0As const& fv0as) + // { + // mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, fv0as, perColMftTracks, mixedEvent, isFV0A); + // } + // PROCESS_SWITCH(HfTaskFlow, processMixedMftFv0aChCh, "DATA : Process mixed-event correlations for Mft-FV0-A h-h case", false); // ===================================== // DATA : process mixed event correlations: TPC-FT0-A ch part. - ch. part. case @@ -3258,7 +3534,11 @@ struct HfTaskFlow { FilteredTracksWDcaSel const& tracks, aod::FT0s const& ft0s) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEvent, isFT0A); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEvent, isFT0A); + } else { + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEventTpcFt0a, isFT0A); + } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcFt0aChCh, "DATA : Process mixed-event correlations for TPC-FT0-A h-h case", false); @@ -3294,7 +3574,11 @@ struct HfTaskFlow { FilteredMftTracks const& mftTracks, aod::FT0s const& ft0s) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, ft0s, perColMftTracks, mixedEvent, isFT0A); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, ft0s, perColMftTracks, mixedEvent, isFT0A); + } else { + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, ft0s, perColMftTracks, mixedEventMftFt0a, isFT0A); + } } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChCh, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); @@ -3303,7 +3587,11 @@ struct HfTaskFlow { soa::SmallGroups const& reassociated2dMftTracks, aod::FT0s const& ft0s) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, false); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, false); + } else { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, false); + } } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChChReassociated2d, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); @@ -3312,7 +3600,11 @@ struct HfTaskFlow { soa::SmallGroups const& reassociated3dMftTracks, aod::FT0s const& ft0s) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEvent, false); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEvent, false); + } else { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEventMftFt0a, false); + } } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChChReassociated3d, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); @@ -3321,7 +3613,11 @@ struct HfTaskFlow { soa::SmallGroups const& reassociated2dMftTracks, aod::FT0s const& ft0s) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, true); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, true); + } else { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, true); + } } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChChNonAmbiguous, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); @@ -3372,6 +3668,51 @@ struct HfTaskFlow { } PROCESS_SWITCH(HfTaskFlow, processMixedFt0aFt0cChCh, "DATA : Process mixed-event correlations for FT0A-FT0C h-h case", false); + // =================================================================================================================================================================================================================================================================== + // MONTE-CARLO + // =================================================================================================================================================================================================================================================================== + + // void processMixedMcGen(aod::McCollisions const& mcCollisions, + // aod::McParticles const& mcParticles, + // SmallGroupMcCollisions const& collisions) + // { + // auto getTracksSize = [&mcParticles, this](aod::McCollisions::iterator const& mcCollision) { + // auto associatedTracks = mcParticles.sliceByCached(o2::aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), this->cache); + // auto multiplicity = associatedTracks.size(); + // return multiplicity; + // }; + + // using MixedBinning = FlexibleBinningPolicy, aod::mccollision::PosZ, decltype(getTracksSize)>; + // MixedBinning const binningOnVtxAndMult{{getTracksSize}, {configAxis.binsMixingVertex, configAxis.binsMixingMultiplicity}, true}; + + // for (auto const& [collision1, collision2] : soa::selfCombinations(binningOnVtxAndMult, configTask.nMixedEvents, -1, mcCollisions, mcCollisions)) { + + // auto tracks1 = mcParticles.sliceBy(perMcColMcParticles, collision1.globalIndex()); + // auto tracks2 = mcParticles.sliceBy(perMcColMcParticles, collision2.globalIndex()); + + // if ((tracks1.size() < configCollision.minMultiplicity || tracks1.size() >= configCollision.maxMultiplicity)) { + // continue; + // } + // if ((tracks2.size() < configCollision.minMultiplicity || tracks2.size() >= configCollision.maxMultiplicity)) { + // continue; + // } + + // auto groupedCollisions = collisions.sliceBy(collisionPerMcCollision, collision1.globalIndex()); + + // mixedEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepAll); + // fillCorrelationsMonteCarlo(mixedEvent, CorrelationContainer::CFStep::kCFStepAll, mcParticles, mcParticles, mcParticles.size(), collision1.posZ(), false); + + // if (groupedCollisions.size() == 0) { + // return; + // } + + // mixedEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepTrackedOnlyPrim); + // fillCorrelationsMonteCarlo(mixedEvent, CorrelationContainer::CFStep::kCFStepTrackedOnlyPrim, mcParticles, mcParticles, mcParticles.size(), collision1.posZ(), false); + // } + + // } + // PROCESS_SWITCH(HfTaskFlow, processMixedMcGen, "MC Gen : Process mixed-event correlations", false); + }; // End of struct WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) From 42eddecba99d7aadcc80ffaa76f9f6ce1384149f Mon Sep 17 00:00:00 2001 From: AlexianL Date: Sat, 30 May 2026 22:11:48 +0200 Subject: [PATCH 05/10] comment function that is not used yet --- PWGHF/HFC/Tasks/taskFlow.cxx | 114 +++++++++++++++++------------------ 1 file changed, 57 insertions(+), 57 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index c150728186f..4f0f9c68b7b 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -2182,67 +2182,67 @@ struct HfTaskFlow { } // end of trigger loop } // end of fillCorrelationsFt0aFt0c - template - void fillCorrelationsMonteCarlo(TTarget target, CorrelationContainer::CFStep step, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, - float multiplicity, float posZ, bool sameEvent) - { - auto triggerWeight = 1; - auto associatedWeight = 1; - 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); - - for (auto const& track1 : tracks1) { - - if (track1.eta() < configTask.etaMcParticlesTriggerMin || track1.eta() > configTask.etaMcParticlesTriggerMax) { - continue; - } - if (track1.pt() < configTask.ptMcParticlesTriggerMin || track1.pt() > configTask.ptMcParticlesTriggerMax) { - continue; - } - if (step >= CorrelationContainer::kCFStepTrackedOnlyPrim && !track1.isPhysicalPrimary()) { - continue; - } - - target->getTriggerHist()->Fill(step, track1.pt(), multiplicity, posZ, triggerWeight); - if (configTask.doEtaDependentFlow) { - registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.eta(), triggerWeight); - } else { - registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.pt(), triggerWeight); - } + // template + // void fillCorrelationsMonteCarlo(TTarget target, CorrelationContainer::CFStep step, + // TTracksTrig const& tracks1, TTracksAssoc const& tracks2, + // float multiplicity, float posZ, bool sameEvent) + // { + // auto triggerWeight = 1; + // auto associatedWeight = 1; + // 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); - for (auto const& track2 : tracks2) { + // for (auto const& track1 : tracks1) { - if (track1.globalIndex() == track2.globalIndex()) { - continue; - } - if (track2.eta() < configTask.etaMcParticlesAssocMin || track2.eta() > configTask.etaMcParticlesAssocMax) { - continue; - } - if (track2.pt() < configTask.ptMcParticlesAssocMin || track2.pt() > configTask.ptMcParticlesAssocMax) { - continue; - } - if (step >= CorrelationContainer::kCFStepTrackedOnlyPrim && !track2.isPhysicalPrimary()) { - continue; - } - - float deltaPhi = RecoDecay::constrainAngle(track2.phi() - track1.phi(), -PIHalf); - float deltaEta = track2.eta() - track1.eta(); + // if (track1.eta() < configTask.etaMcParticlesTriggerMin || track1.eta() > configTask.etaMcParticlesTriggerMax) { + // continue; + // } + // if (track1.pt() < configTask.ptMcParticlesTriggerMin || track1.pt() > configTask.ptMcParticlesTriggerMax) { + // continue; + // } + // if (step >= CorrelationContainer::kCFStepTrackedOnlyPrim && !track1.isPhysicalPrimary()) { + // continue; + // } - if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - target->getPairHist()->Fill(step, deltaEta, track2.pt(), track1.pt(), multiplicity, deltaPhi, posZ, - triggerWeight * associatedWeight); - } else if (configTask.doEtaDependentFlow) { - target->getPairHist()->Fill(step, sampleIndex, posZ, track2.eta(), track1.eta(), deltaPhi, deltaEta, - triggerWeight * associatedWeight); - } else { - target->getPairHist()->Fill(step, sampleIndex, posZ, track1.pt(), multiplicity, deltaPhi, deltaEta, - triggerWeight * associatedWeight); - } - } // end of loop over track2 + // target->getTriggerHist()->Fill(step, track1.pt(), multiplicity, posZ, triggerWeight); + // if (configTask.doEtaDependentFlow) { + // registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.eta(), triggerWeight); + // } else { + // registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.pt(), triggerWeight); + // } - } // end of loop over track1 - } + // for (auto const& track2 : tracks2) { + + // if (track1.globalIndex() == track2.globalIndex()) { + // continue; + // } + // if (track2.eta() < configTask.etaMcParticlesAssocMin || track2.eta() > configTask.etaMcParticlesAssocMax) { + // continue; + // } + // if (track2.pt() < configTask.ptMcParticlesAssocMin || track2.pt() > configTask.ptMcParticlesAssocMax) { + // continue; + // } + // if (step >= CorrelationContainer::kCFStepTrackedOnlyPrim && !track2.isPhysicalPrimary()) { + // continue; + // } + + // float deltaPhi = RecoDecay::constrainAngle(track2.phi() - track1.phi(), -PIHalf); + // float deltaEta = track2.eta() - track1.eta(); + + // if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + // target->getPairHist()->Fill(step, deltaEta, track2.pt(), track1.pt(), multiplicity, deltaPhi, posZ, + // triggerWeight * associatedWeight); + // } else if (configTask.doEtaDependentFlow) { + // target->getPairHist()->Fill(step, sampleIndex, posZ, track2.eta(), track1.eta(), deltaPhi, deltaEta, + // triggerWeight * associatedWeight); + // } else { + // target->getPairHist()->Fill(step, sampleIndex, posZ, track1.pt(), multiplicity, deltaPhi, deltaEta, + // triggerWeight * associatedWeight); + // } + // } // end of loop over track2 + + // } // end of loop over track1 + // } // =============================================================================================================================================================================== // mixCollisions for RECONSTRUCTED events From ff661abd8792f205b76f215725e87f001253a47b Mon Sep 17 00:00:00 2001 From: AlexianL Date: Mon, 8 Jun 2026 21:38:57 +0200 Subject: [PATCH 06/10] add possibility to estimate multiplicity by counting tracks-> validated, add MC gen -> not validated yet --- PWGHF/HFC/Tasks/taskFlow.cxx | 453 +++++++++++++++++++++++------------ 1 file changed, 297 insertions(+), 156 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 4f0f9c68b7b..3ffb463a164 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -202,6 +202,7 @@ struct HfTaskFlow { struct : ConfigurableGroup { std::string prefix = "ConfigTask_group"; Configurable centralityBinsForMc{"centralityBinsForMc", false, "falsce = OFF, true = ON for data like multiplicity/centrality bins for MC steps"}; + Configurable chooseCorrelationCase{"chooseCorrelationCase", 0, "0: Tpc-Tpc, 1: Tpc-Mft, 2: Tpc-Fv0a, 3: Mft-Fv0a, 4: Tpc-Ft0a, 5: Mft-Ft0a, 6: Tpc-Ft0c, 7: Ft0a-Ft0c"}; Configurable doEtaDependentFlow{"doEtaDependentFlow", false, "Flag to know if eta dependent flow should be done"}; Configurable doHeavyFlavor{"doHeavyFlavor", false, "Flag to know we in the heavy flavor case or not"}; Configurable doMonteCarlo{"doMonteCarlo", false, "Flag to know if Monte Carlo should be done"}; @@ -235,6 +236,7 @@ struct HfTaskFlow { Configurable maxMultiplicity{"maxMultiplicity", 300, "maximum multiplicity selection for collision"}; Configurable minMultiplicity{"minMultiplicity", 0, "minimum multiplicity selection for collision"}; Configurable multiplicityEstimator{"multiplicityEstimator", 0, "0: multNTracksPV, 1: numContrib, 2: multFT0C, 3: multFT0M, 4: centFT0C, 5: centFT0CVariants1s, 6: centFT0M, 7: centFV0A, 8: centNTracksPV, 9: centNGlobal, 10: centMFT"}; + Configurable useMultiplicityFromTracks{"useMultiplicityFromTracks", false, "Use multiplicity from counting tracks"}; 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"}; @@ -577,8 +579,8 @@ struct HfTaskFlow { {configAxis.axisVertex, "z-vtx (cm)"}}; std::vector const corrAxisEta = {{configAxis.axisSamples, "sampling"}, {configAxis.axisVertex, "z-vtx (cm)"}, - {configAxis.axisEtaTrigger, "#eta_{trigger}"}, {configAxis.axisEtaAssociated, "#eta_{associated}"}, + {configAxis.axisEtaTrigger, "#eta_{trigger}"}, {configAxis.axisDeltaPhi, "#Delta#varphi (rad)"}, {configAxis.axisDeltaEta, "#Delta#eta"}}; std::vector const corrAxisVariations = {{configAxis.axisSamples, "sampling"}, @@ -849,22 +851,38 @@ struct HfTaskFlow { // Initialization of histograms and CorrelationContainers for McGen cases // ========================= - // if (doprocessSameMcGen) { + if (doprocessSameMcGen) { - // if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - // registry.add("Trig_hist", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); - // sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); - // mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); - // } else if (configTask.doEtaDependentFlow){ - // registry.add("Trig_hist", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisEtaTrigger}}}); - // sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); - // mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); - // } else { - // registry.add("Trig_hist", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); - // sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisVariations, effAxis, {})); - // mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisVariations, effAxis, {})); - // } - // } + if (configTask.chooseCorrelationCase == CorrelationCase::TpcTpc) { + addHistograms(); + } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcMft) { + addHistograms(); + } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFv0a) { + addHistograms(); + } else if (configTask.chooseCorrelationCase == CorrelationCase::MftFv0a) { + addHistograms(); + } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFt0a) { + addHistograms(); + } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFt0c) { + addHistograms(); + } else if (configTask.chooseCorrelationCase == CorrelationCase::Ft0aFt0c) { + addHistograms(); + } + + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + registry.add("Trig_hist", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + } else if (configTask.doEtaDependentFlow) { + registry.add("Trig_hist", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisEtaTrigger}}}); + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + } else { + registry.add("Trig_hist", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisVariations, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisVariations, effAxis, {})); + } + } } // End of init() function @@ -909,7 +927,7 @@ struct HfTaskFlow { } template - float getMultiplicityEstimator(TCollision collision, bool isSameEvent) + int64_t getMultiplicityEstimator(TCollision collision, bool isSameEvent) { switch (configCollision.multiplicityEstimator) { case MultiplicityEstimators::MultNTracksPV: @@ -2182,67 +2200,109 @@ struct HfTaskFlow { } // end of trigger loop } // end of fillCorrelationsFt0aFt0c - // template - // void fillCorrelationsMonteCarlo(TTarget target, CorrelationContainer::CFStep step, - // TTracksTrig const& tracks1, TTracksAssoc const& tracks2, - // float multiplicity, float posZ, bool sameEvent) - // { - // auto triggerWeight = 1; - // auto associatedWeight = 1; - // 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); + template + void fillCorrelationsMonteCarlo(TTarget target, CorrelationContainer::CFStep step, + TTracksTrig const& tracks1, TTracksAssoc const& tracks2, + float multiplicity, float posZ, bool sameEvent) + { + auto triggerWeight = 1; + auto associatedWeight = 1; + 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); - // for (auto const& track1 : tracks1) { + for (auto const& track1 : tracks1) { + loopCounter++; - // if (track1.eta() < configTask.etaMcParticlesTriggerMin || track1.eta() > configTask.etaMcParticlesTriggerMax) { - // continue; - // } - // if (track1.pt() < configTask.ptMcParticlesTriggerMin || track1.pt() > configTask.ptMcParticlesTriggerMax) { - // continue; - // } - // if (step >= CorrelationContainer::kCFStepTrackedOnlyPrim && !track1.isPhysicalPrimary()) { - // continue; - // } + if (track1.eta() < configTask.etaMcParticlesTriggerMin || track1.eta() > configTask.etaMcParticlesTriggerMax) { + continue; + } + if (track1.pt() < configTask.ptMcParticlesTriggerMin || track1.pt() > configTask.ptMcParticlesTriggerMax) { + continue; + } + if (step >= CorrelationContainer::kCFStepTrackedOnlyPrim && !track1.isPhysicalPrimary()) { + continue; + } - // target->getTriggerHist()->Fill(step, track1.pt(), multiplicity, posZ, triggerWeight); - // if (configTask.doEtaDependentFlow) { - // registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.eta(), triggerWeight); - // } else { - // registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.pt(), triggerWeight); - // } + target->getTriggerHist()->Fill(step, track1.pt(), multiplicity, posZ, triggerWeight); - // for (auto const& track2 : tracks2) { - - // if (track1.globalIndex() == track2.globalIndex()) { - // continue; - // } - // if (track2.eta() < configTask.etaMcParticlesAssocMin || track2.eta() > configTask.etaMcParticlesAssocMax) { - // continue; - // } - // if (track2.pt() < configTask.ptMcParticlesAssocMin || track2.pt() > configTask.ptMcParticlesAssocMax) { - // continue; - // } - // if (step >= CorrelationContainer::kCFStepTrackedOnlyPrim && !track2.isPhysicalPrimary()) { - // continue; - // } - - // float deltaPhi = RecoDecay::constrainAngle(track2.phi() - track1.phi(), -PIHalf); - // float deltaEta = track2.eta() - track1.eta(); - - // if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - // target->getPairHist()->Fill(step, deltaEta, track2.pt(), track1.pt(), multiplicity, deltaPhi, posZ, - // triggerWeight * associatedWeight); - // } else if (configTask.doEtaDependentFlow) { - // target->getPairHist()->Fill(step, sampleIndex, posZ, track2.eta(), track1.eta(), deltaPhi, deltaEta, - // triggerWeight * associatedWeight); - // } else { - // target->getPairHist()->Fill(step, sampleIndex, posZ, track1.pt(), multiplicity, deltaPhi, deltaEta, - // triggerWeight * associatedWeight); - // } - // } // end of loop over track2 - - // } // end of loop over track1 - // } + if (configTask.doEtaDependentFlow) { + registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + } + if (configTask.doVariationContainers) { + registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.pt(), triggerWeight); + } + + // FILL QA FOR TRIGGER PARTICLE + if (sameEvent) { + if (configTask.chooseCorrelationCase == CorrelationCase::TpcTpc) { + fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); + } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcMft) { + fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); + } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFv0a) { + fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); + } else if (configTask.chooseCorrelationCase == CorrelationCase::MftFv0a) { + fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); + } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFt0a) { + fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); + } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFt0c) { + fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); + } else if (configTask.chooseCorrelationCase == CorrelationCase::Ft0aFt0c) { + fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); + } + } + + for (auto const& track2 : tracks2) { + + if (track1.globalIndex() == track2.globalIndex()) { + continue; + } + if (track2.eta() < configTask.etaMcParticlesAssocMin || track2.eta() > configTask.etaMcParticlesAssocMax) { + continue; + } + if (track2.pt() < configTask.ptMcParticlesAssocMin || track2.pt() > configTask.ptMcParticlesAssocMax) { + continue; + } + if (step >= CorrelationContainer::kCFStepTrackedOnlyPrim && !track2.isPhysicalPrimary()) { + continue; + } + + float deltaPhi = RecoDecay::constrainAngle(track2.phi() - track1.phi(), -PIHalf); + float deltaEta = track2.eta() - track1.eta(); + + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + target->getPairHist()->Fill(step, deltaEta, track2.pt(), track1.pt(), multiplicity, deltaPhi, posZ, + triggerWeight * associatedWeight); + } else if (configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, sampleIndex, posZ, track2.eta(), track1.eta(), deltaPhi, deltaEta, + triggerWeight * associatedWeight); + } else { + target->getPairHist()->Fill(step, sampleIndex, posZ, track1.pt(), multiplicity, deltaPhi, deltaEta, + triggerWeight * associatedWeight); + } + + // FILL QA PLOTS for associated particle + if (sameEvent && (loopCounter == 1)) { + if (configTask.chooseCorrelationCase == CorrelationCase::TpcTpc) { + fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); + } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcMft) { + fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); + } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFv0a) { + fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); + } else if (configTask.chooseCorrelationCase == CorrelationCase::MftFv0a) { + fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); + } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFt0a) { + fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); + } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFt0c) { + fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); + } else if (configTask.chooseCorrelationCase == CorrelationCase::Ft0aFt0c) { + fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); + } + } // end of fill QA + + } // end of loop over track2 + + } // end of loop over track1 + } // =============================================================================================================================================================================== // mixCollisions for RECONSTRUCTED events @@ -2253,9 +2313,19 @@ struct HfTaskFlow { TTracksTrig const& tracks1, TTracksAssoc const& tracks2, OutputObj& corrContainer, aod::BCsWithTimestamps const&) { - auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { - auto multiplicity = getMultiplicityEstimator(collision, false); - return multiplicity; + // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { + // auto multiplicity = getMultiplicityEstimator(collision, false); + // return multiplicity; + // }; + + auto getMultiplicity = [&tracks1, this](FilteredCollisionsWSelMult::iterator const& collision) { + auto associatedTracks = tracks1.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); + auto mult = associatedTracks.size(); + if (configCollision.useMultiplicityFromTracks) { + return mult; + } else { + return getMultiplicityEstimator(collision, false); + } }; // The first one that I call "Data" should work for data and mc rec @@ -2291,9 +2361,19 @@ struct HfTaskFlow { TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TPresliceTrigger const& presliceTrigger, TPresliceAssociated const& presliceAssociated, OutputObj& corrContainer, aod::BCsWithTimestamps const&) { - auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { - auto multiplicity = getMultiplicityEstimator(collision, false); - return multiplicity; + // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { + // auto multiplicity = getMultiplicityEstimator(collision, false); + // return multiplicity; + // }; + + auto getMultiplicity = [&tracks1, this](FilteredCollisionsWSelMult::iterator const& collision) { + auto associatedTracks = tracks1.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); + auto mult = associatedTracks.size(); + if (configCollision.useMultiplicityFromTracks) { + return mult; + } else { + return getMultiplicityEstimator(collision, false); + } }; using MixedBinning = FlexibleBinningPolicy, aod::collision::PosZ, decltype(getMultiplicity)>; @@ -2324,14 +2404,24 @@ struct HfTaskFlow { } } - template - void mixCollisionsReassociatedMftTracks(TCollisions const& collisions, CorrelationContainer::CFStep step, + template + void mixCollisionsReassociatedMftTracks(TCollisions const& collisions, CorrelationContainer::CFStep step, TTracksTpc const& tracksTpc, TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TPresliceTrigger const& presliceTrigger, TPresliceAssociated const& presliceAssociated, OutputObj& corrContainer, bool cutAmbiguousTracks) { - auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { - auto multiplicity = getMultiplicityEstimator(collision, false); - return multiplicity; + // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { + // auto multiplicity = getMultiplicityEstimator(collision, false); + // return multiplicity; + // }; + + 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; + } else { + return getMultiplicityEstimator(collision, false); + } }; using MixedBinning = FlexibleBinningPolicy, aod::collision::PosZ, decltype(getMultiplicity)>; @@ -2372,9 +2462,19 @@ struct HfTaskFlow { TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TPreslice const& preslice, OutputObj& corrContainer, int fitType) { - auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { - auto multiplicity = getMultiplicityEstimator(collision, false); - return multiplicity; + // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { + // auto multiplicity = getMultiplicityEstimator(collision, false); + // return multiplicity; + // }; + + auto getMultiplicity = [&tracks1, this](FilteredCollisionsWSelMult::iterator const& collision) { + auto associatedTracks = tracks1.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); + auto mult = associatedTracks.size(); + if (configCollision.useMultiplicityFromTracks) { + return mult; + } else { + return getMultiplicityEstimator(collision, false); + } }; using MixedBinning = FlexibleBinningPolicy, aod::collision::PosZ, decltype(getMultiplicity)>; @@ -2420,14 +2520,24 @@ struct HfTaskFlow { } // end of for loop } - template + template void mixCollisionsFt0aFt0c(TCollisions const& collisions, CorrelationContainer::CFStep step, - TFT0as const&, TFT0cs const&, + TTracksTpc const& tracksTpc, TFT0as const&, TFT0cs const&, OutputObj& corrContainer) { - auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { - auto multiplicity = getMultiplicityEstimator(collision, false); - return multiplicity; + // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { + // auto multiplicity = getMultiplicityEstimator(collision, false); + // return multiplicity; + // }; + + 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; + } else { + return getMultiplicityEstimator(collision, false); + } }; using MixedBinning = FlexibleBinningPolicy, aod::collision::PosZ, decltype(getMultiplicity)>; @@ -3311,28 +3421,35 @@ struct HfTaskFlow { // MONTE-CARLO // =================================================================================================================================================================================================================================================================== - // void processSameMcGen(aod::McCollisions::iterator const& mcCollision, - // aod::McParticles const& mcParticles, - // SmallGroupMcCollisions const& collisions) - // { - // if (!(abs(mcCollision.posZ()) <= configCollision.zVertexMax)) { - // return; - // } - // if ( (mcParticles.size() < configCollision.minMultiplicity) || (mcParticles.size() > configCollision.maxMultiplicity) ) { - // return; - // } + void processSameMcGen(aod::McCollisions::iterator const& mcCollision, + aod::McParticles const& mcParticles, + SmallGroupMcCollisions const& collisions) + { + if (!(abs(mcCollision.posZ()) <= configCollision.zVertexMax)) { + return; + } - // sameEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepAll); - // fillCorrelationsMonteCarlo(sameEvent, CorrelationContainer::CFStep::kCFStepAll, mcParticles, mcParticles, mcParticles.size(), mcCollision.posZ(), true); + int multiplicity = 0; + for (const auto& track : mcParticles) { + if (std::abs(track.eta()) < configCentral.etaCentralTrackMax) + multiplicity += 1; + } - // if (collisions.size() == 0) { - // return; - // } + if ((multiplicity < configCollision.minMultiplicity) || (multiplicity >= configCollision.maxMultiplicity)) { + return; + } - // sameEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepTrackedOnlyPrim); - // fillCorrelationsMonteCarlo(sameEvent, CorrelationContainer::CFStep::kCFStepTrackedOnlyPrim, mcParticles, mcParticles, mcParticles.size(), mcCollision.posZ(), true); - // } - // PROCESS_SWITCH(HfTaskFlow, processSameMcGen, "MC Gen : Process same-event correlations", false); + sameEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepAll); + fillCorrelationsMonteCarlo(sameEvent, CorrelationContainer::CFStep::kCFStepAll, mcParticles, mcParticles, multiplicity, mcCollision.posZ(), true); + + if (collisions.size() == 0) { + return; + } + + sameEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepTrackedOnlyPrim); + fillCorrelationsMonteCarlo(sameEvent, CorrelationContainer::CFStep::kCFStepTrackedOnlyPrim, mcParticles, mcParticles, multiplicity, mcCollision.posZ(), true); + } + PROCESS_SWITCH(HfTaskFlow, processSameMcGen, "MC Gen : Process same-event correlations", false); // =================================================================================================================================================================================================================================================================== // =================================================================================================================================================================================================================================================================== @@ -3418,9 +3535,9 @@ struct HfTaskFlow { soa::SmallGroups const& reassociated2dMftTracks) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, false); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, false); } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChReassociated2d, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -3431,9 +3548,9 @@ struct HfTaskFlow { soa::SmallGroups const& reassociated3dMftTracks) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEvent, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEvent, false); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEventTpcMft, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEventTpcMft, false); } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChReassociated3d, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -3444,9 +3561,9 @@ struct HfTaskFlow { soa::SmallGroups const& reassociated2dMftTracks) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, true); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, true); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, true); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, true); } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChNonAmbiguous, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -3584,39 +3701,42 @@ struct HfTaskFlow { void processMixedMftFt0aChChReassociated2d(FilteredCollisionsWSelMult const& collisions, FilteredMftTracks const& /*mftTracks*/, + FilteredTracksWDcaSel const& tracksTpc, soa::SmallGroups const& reassociated2dMftTracks, aod::FT0s const& ft0s) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, false); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, false); } } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChChReassociated2d, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); void processMixedMftFt0aChChReassociated3d(FilteredCollisionsWSelMult const& collisions, FilteredMftTracks const& /*mftTracks*/, + FilteredTracksWDcaSel const& tracksTpc, soa::SmallGroups const& reassociated3dMftTracks, aod::FT0s const& ft0s) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEvent, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEvent, false); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEventMftFt0a, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEventMftFt0a, false); } } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChChReassociated3d, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); void processMixedMftFt0aChChNonAmbiguous(FilteredCollisionsWSelMult const& collisions, FilteredMftTracks const& /*mftTracks*/, + FilteredTracksWDcaSel const& tracksTpc, soa::SmallGroups const& reassociated2dMftTracks, aod::FT0s const& ft0s) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, true); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, true); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, true); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, true); } } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChChNonAmbiguous, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); @@ -3662,9 +3782,10 @@ struct HfTaskFlow { // ===================================== void processMixedFt0aFt0cChCh(FilteredCollisionsWSelMult const& collisions, + FilteredTracksWDcaSel const& tracksTpc, aod::FT0s const& ft0s) { - mixCollisionsFt0aFt0c(collisions, CorrelationContainer::kCFStepReconstructed, ft0s, ft0s, mixedEvent); + mixCollisionsFt0aFt0c(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, ft0s, ft0s, mixedEvent); } PROCESS_SWITCH(HfTaskFlow, processMixedFt0aFt0cChCh, "DATA : Process mixed-event correlations for FT0A-FT0C h-h case", false); @@ -3672,46 +3793,66 @@ struct HfTaskFlow { // MONTE-CARLO // =================================================================================================================================================================================================================================================================== - // void processMixedMcGen(aod::McCollisions const& mcCollisions, - // aod::McParticles const& mcParticles, - // SmallGroupMcCollisions const& collisions) - // { - // auto getTracksSize = [&mcParticles, this](aod::McCollisions::iterator const& mcCollision) { - // auto associatedTracks = mcParticles.sliceByCached(o2::aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), this->cache); - // auto multiplicity = associatedTracks.size(); - // return multiplicity; - // }; + void processMixedMcGen(aod::McCollisions const& mcCollisions, + aod::McParticles const& mcParticles, + SmallGroupMcCollisions const& collisions) + { + // auto getTracksSize = [&mcParticles, this](aod::McCollisions::iterator const& mcCollision) { + // auto associatedTracks = mcParticles.sliceByCached(o2::aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), this->cache); + // auto multiplicity = associatedTracks.size(); + // return multiplicity; + // }; + + auto getTracksSize = [&mcParticles, this](aod::McCollisions::iterator const& mcCollision) { + auto associatedTracks = mcParticles.sliceByCached(o2::aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), this->cache); + int multiplicity = 0; + for (const auto& track : associatedTracks) { + if (std::abs(track.eta()) < configCentral.etaCentralTrackMax) + multiplicity += 1; + } + return multiplicity; + }; - // using MixedBinning = FlexibleBinningPolicy, aod::mccollision::PosZ, decltype(getTracksSize)>; - // MixedBinning const binningOnVtxAndMult{{getTracksSize}, {configAxis.binsMixingVertex, configAxis.binsMixingMultiplicity}, true}; + using MixedBinning = FlexibleBinningPolicy, aod::mccollision::PosZ, decltype(getTracksSize)>; + MixedBinning const binningOnVtxAndMult{{getTracksSize}, {configAxis.binsMixingVertex, configAxis.binsMixingMultiplicity}, true}; - // for (auto const& [collision1, collision2] : soa::selfCombinations(binningOnVtxAndMult, configTask.nMixedEvents, -1, mcCollisions, mcCollisions)) { + for (auto const& [collision1, collision2] : soa::selfCombinations(binningOnVtxAndMult, configTask.nMixedEvents, -1, mcCollisions, mcCollisions)) { - // auto tracks1 = mcParticles.sliceBy(perMcColMcParticles, collision1.globalIndex()); - // auto tracks2 = mcParticles.sliceBy(perMcColMcParticles, collision2.globalIndex()); + auto tracks1 = mcParticles.sliceBy(perMcColMcParticles, collision1.globalIndex()); + auto tracks2 = mcParticles.sliceBy(perMcColMcParticles, collision2.globalIndex()); - // if ((tracks1.size() < configCollision.minMultiplicity || tracks1.size() >= configCollision.maxMultiplicity)) { - // continue; - // } - // if ((tracks2.size() < configCollision.minMultiplicity || tracks2.size() >= configCollision.maxMultiplicity)) { - // continue; - // } + int multiplicityCollision1 = 0; + for (const auto& track : tracks1) { + if (std::abs(track.eta()) < configCentral.etaCentralTrackMax) + multiplicityCollision1 += 1; + } + int multiplicityCollision2 = 0; + for (const auto& track : tracks2) { + if (std::abs(track.eta()) < configCentral.etaCentralTrackMax) + multiplicityCollision2 += 1; + } - // auto groupedCollisions = collisions.sliceBy(collisionPerMcCollision, collision1.globalIndex()); + if ((multiplicityCollision1 < configCollision.minMultiplicity || multiplicityCollision1 >= configCollision.maxMultiplicity)) { + continue; + } + if ((multiplicityCollision2 < configCollision.minMultiplicity || multiplicityCollision2 >= configCollision.maxMultiplicity)) { + continue; + } - // mixedEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepAll); - // fillCorrelationsMonteCarlo(mixedEvent, CorrelationContainer::CFStep::kCFStepAll, mcParticles, mcParticles, mcParticles.size(), collision1.posZ(), false); + auto groupedCollisions = collisions.sliceBy(collisionPerMcCollision, collision1.globalIndex()); - // if (groupedCollisions.size() == 0) { - // return; - // } + mixedEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepAll); + fillCorrelationsMonteCarlo(mixedEvent, CorrelationContainer::CFStep::kCFStepAll, mcParticles, mcParticles, multiplicityCollision1, collision1.posZ(), false); - // mixedEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepTrackedOnlyPrim); - // fillCorrelationsMonteCarlo(mixedEvent, CorrelationContainer::CFStep::kCFStepTrackedOnlyPrim, mcParticles, mcParticles, mcParticles.size(), collision1.posZ(), false); - // } + if (groupedCollisions.size() == 0) { + return; + } - // } - // PROCESS_SWITCH(HfTaskFlow, processMixedMcGen, "MC Gen : Process mixed-event correlations", false); + mixedEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepTrackedOnlyPrim); + fillCorrelationsMonteCarlo(mixedEvent, CorrelationContainer::CFStep::kCFStepTrackedOnlyPrim, mcParticles, mcParticles, multiplicityCollision1, collision1.posZ(), false); + } + } + PROCESS_SWITCH(HfTaskFlow, processMixedMcGen, "MC Gen : Process mixed-event correlations", false); }; // End of struct From 66b44805ccf1bfab4aa1db9906c65d40a665a7f3 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Tue, 9 Jun 2026 15:16:56 +0200 Subject: [PATCH 07/10] MC working --- PWGHF/HFC/Tasks/taskFlow.cxx | 404 +++++++++++++++++++++++++---------- 1 file changed, 288 insertions(+), 116 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 3ffb463a164..7832373ad3b 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -212,6 +212,7 @@ struct HfTaskFlow { Configurable etaMcParticlesTriggerMin{"etaMcParticlesTriggerMin", -0.8f, "Minimum value for the eta of MC particles when used in cut function"}; Configurable etaMcParticlesAssocMax{"etaMcParticlesAssocMax", -2.4f, "Maximum value for the eta of MC particles when used in cut function"}; Configurable etaMcParticlesAssocMin{"etaMcParticlesAssocMin", -3.6f, "Minimum value for the eta of MC particles when used in cut function"}; + Configurable fillOnlyStepAll{"fillOnlyStepAll", true, "Fill Mc Gen QA plots only for StepAll, or only for Primaries"}; Configurable ptMcParticlesTriggerMax{"ptMcParticlesTriggerMax", 3.0f, "Maximum value for the pT of MC particles when used in cut function"}; Configurable ptMcParticlesTriggerMin{"ptMcParticlesTriggerMin", 0.2f, "Minimum value for the pT of MC particles when used in cut function"}; Configurable ptMcParticlesAssocMax{"ptMcParticlesAssocMax", 100.0f, "Maximum value for the pT of MC particles when used in cut function"}; @@ -320,6 +321,8 @@ struct HfTaskFlow { RCTFlagsChecker rctChecker; RCTFlagsChecker correlationAnalysisRctChecker{kFT0Bad, kITSBad, kTPCBadTracking, kTPCBadPID, kMFTBad}; + // o2::aod::rctsel::RCTFlagsChecker rctChecker{"CBT_muon_glo", false, false, true}; + // ========================= // using declarations : DATA // ========================= @@ -523,7 +526,7 @@ struct HfTaskFlow { // ========================= rctChecker.init(configCollision.setRCTFlagCheckerLabel, configCollision.requireZDCCheck, configCollision.requireRCTFlagCheckerLimitAcceptanceAsBad, true); - correlationAnalysisRctChecker.init({kFT0Bad, kITSBad, kTPCBadTracking, kTPCBadPID, kMFTBad}, 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}}); @@ -853,19 +856,19 @@ struct HfTaskFlow { if (doprocessSameMcGen) { - if (configTask.chooseCorrelationCase == CorrelationCase::TpcTpc) { + if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { addHistograms(); - } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcMft) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { addHistograms(); - } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFv0a) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFv0a)) { addHistograms(); - } else if (configTask.chooseCorrelationCase == CorrelationCase::MftFv0a) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFv0a)) { addHistograms(); - } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFt0a) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0a)) { addHistograms(); - } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFt0c) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0c)) { addHistograms(); - } else if (configTask.chooseCorrelationCase == CorrelationCase::Ft0aFt0c) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::Ft0aFt0c)) { addHistograms(); } @@ -912,19 +915,19 @@ struct HfTaskFlow { // Helper functions // ========================= - HfProngSpecies getSpecies(int pdgCode) - { - switch (std::abs(pdgCode)) { - case PDG_t::kPiPlus: // positive or negative pion - return HfProngSpecies::Pion; - case PDG_t::kKPlus: // positive or negative kaon - return HfProngSpecies::Kaon; - case PDG_t::kProton: // proton or proton bar - return HfProngSpecies::Proton; - default: // NOTE. The efficiency histogram is hardcoded to contain 4 species. Anything special will have the last slot. - return HfProngSpecies::NHfProngSpecies; - } - } + // HfProngSpecies getSpecies(int pdgCode) + // { + // switch (std::abs(pdgCode)) { + // case PDG_t::kPiPlus: // positive or negative pion + // return HfProngSpecies::Pion; + // case PDG_t::kKPlus: // positive or negative kaon + // return HfProngSpecies::Kaon; + // case PDG_t::kProton: // proton or proton bar + // return HfProngSpecies::Proton; + // default: // NOTE. The efficiency histogram is hardcoded to contain 4 species. Anything special will have the last slot. + // return HfProngSpecies::NHfProngSpecies; + // } + // } template int64_t getMultiplicityEstimator(TCollision collision, bool isSameEvent) @@ -2209,6 +2212,17 @@ struct HfTaskFlow { auto associatedWeight = 1; 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 : tracks1) { loopCounter++; @@ -2233,20 +2247,20 @@ struct HfTaskFlow { } // FILL QA FOR TRIGGER PARTICLE - if (sameEvent) { - if (configTask.chooseCorrelationCase == CorrelationCase::TpcTpc) { + if (sameEvent && fillQaPlots) { + if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); - } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcMft) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); - } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFv0a) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFv0a)) { fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); - } else if (configTask.chooseCorrelationCase == CorrelationCase::MftFv0a) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFv0a)) { fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); - } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFt0a) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0a)) { fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); - } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFt0c) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0c)) { fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); - } else if (configTask.chooseCorrelationCase == CorrelationCase::Ft0aFt0c) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::Ft0aFt0c)) { fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); } } @@ -2281,26 +2295,24 @@ struct HfTaskFlow { } // FILL QA PLOTS for associated particle - if (sameEvent && (loopCounter == 1)) { - if (configTask.chooseCorrelationCase == CorrelationCase::TpcTpc) { + if (sameEvent && fillQaPlots && (loopCounter == 1)) { + if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); - } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcMft) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); - } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFv0a) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFv0a)) { fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); - } else if (configTask.chooseCorrelationCase == CorrelationCase::MftFv0a) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFv0a)) { fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); - } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFt0a) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0a)) { fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); - } else if (configTask.chooseCorrelationCase == CorrelationCase::TpcFt0c) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0c)) { fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); - } else if (configTask.chooseCorrelationCase == CorrelationCase::Ft0aFt0c) { + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::Ft0aFt0c)) { fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); } } // end of fill QA - } // end of loop over track2 - } // end of loop over track1 } @@ -2345,9 +2357,14 @@ struct HfTaskFlow { } auto bc = collision1.template bc_as(); - const auto multiplicity = getMultiplicityEstimator(collision1, false); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks1.size(); + } else { + multiplicity = getMultiplicityEstimator(collision1, false); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2390,8 +2407,13 @@ struct HfTaskFlow { if (collision1.globalIndex() == collision2.globalIndex()) { continue; } - const auto multiplicity = getMultiplicityEstimator(collision1, false); - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks1.size(); + } else { + multiplicity = getMultiplicityEstimator(collision1, false); + } + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2435,8 +2457,13 @@ struct HfTaskFlow { if (collision1.globalIndex() == collision2.globalIndex()) { continue; } - const auto multiplicity = getMultiplicityEstimator(collision1, false); - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracksTpc.size(); + } else { + multiplicity = getMultiplicityEstimator(collision1, false); + } + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2493,11 +2520,17 @@ struct HfTaskFlow { if constexpr (std::is_same_v) { // IF ASSOCIATED PARTICLE FROM FV0A if (collision1.has_foundFV0() && collision2.has_foundFV0()) { - const auto multiplicity = getMultiplicityEstimator(collision1, false); auto slicedTriggerTracks = tracks1.sliceBy(preslice, collision1.globalIndex()); const auto& fv0 = collision2.foundFV0(); - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks1.size(); + } else { + multiplicity = getMultiplicityEstimator(collision1, false); + } + + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2509,9 +2542,18 @@ struct HfTaskFlow { if constexpr (std::is_same_v) { if (collision1.has_foundFT0() && collision2.has_foundFT0()) { - const auto multiplicity = getMultiplicityEstimator(collision1, false); auto slicedTriggerTracks = tracks1.sliceBy(preslice, collision1.globalIndex()); const auto& ft0 = collision2.foundFT0(); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks1.size(); + } else { + multiplicity = getMultiplicityEstimator(collision1, false); + } + + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } corrContainer->fillEvent(multiplicity, step); fillCorrelationsFIT(corrContainer, step, slicedTriggerTracks, ft0, tracks2, multiplicity, collision1.posZ(), false, fitType); @@ -2555,11 +2597,16 @@ struct HfTaskFlow { if (collision1.has_foundFT0() && collision2.has_foundFT0()) { - const auto multiplicity = getMultiplicityEstimator(collision1, false); const auto& ft0as = collision1.foundFT0(); const auto& ft0cs = collision2.foundFT0(); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracksTpc.size(); + } else { + multiplicity = getMultiplicityEstimator(collision1, false); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2593,9 +2640,14 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); auto bc = collision.template bc_as(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2626,9 +2678,14 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); auto bc = collision.template bc_as(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2659,9 +2716,14 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); auto bc = collision.template bc_as(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2685,9 +2747,14 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); auto bc = collision.template bc_as(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2713,9 +2780,14 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2742,10 +2814,14 @@ struct HfTaskFlow { registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); - // const auto multiplicity = collision.multNTracksPV(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2771,9 +2847,14 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2793,7 +2874,7 @@ struct HfTaskFlow { void processSameTpcMftD0Ch(FilteredCollisionsWSelMult::iterator const& collision, HfCandidatesSelD0 const& candidates, - FilteredTracksWDcaSel const& /*tracks*/, + FilteredTracksWDcaSel const& tracks, FilteredMftTracks const& mftTracks, aod::BCsWithTimestamps const&) { @@ -2809,9 +2890,14 @@ struct HfTaskFlow { } auto bc = collision.template bc_as(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2823,15 +2909,21 @@ struct HfTaskFlow { void processSameTpcMftD0ChReassociated(FilteredCollisionsWSelMult::iterator const& collision, HfCandidatesSelD0 const& candidates, soa::SmallGroups const& reassociatedMftTracks, + FilteredTracksWDcaSel const& tracks, FilteredMftTracks const&) { if (!(isAcceptedCollision(collision, true))) { return; // when process function has iterator } - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2846,7 +2938,7 @@ struct HfTaskFlow { void processSameTpcMftLcCh(FilteredCollisionsWSelMult::iterator const& collision, HfCandidatesSelLc const& candidates, - FilteredTracksWDcaSel const& /*tracks*/, + FilteredTracksWDcaSel const& tracks, FilteredMftTracks const& mftTracks, aod::BCsWithTimestamps const&) { @@ -2862,9 +2954,14 @@ struct HfTaskFlow { } auto bc = collision.template bc_as(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2876,15 +2973,21 @@ struct HfTaskFlow { void processSameTpcMftLcChReassociated(FilteredCollisionsWSelMult::iterator const& collision, HfCandidatesSelLc const& candidates, soa::SmallGroups const& reassociatedMftTracks, + FilteredTracksWDcaSel const& tracks, FilteredMftTracks const&) { if (!(isAcceptedCollision(collision, true))) { return; // when process function has iterator } - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2909,9 +3012,9 @@ struct HfTaskFlow { // const auto& fv0 = collision.foundFV0(); // registry.fill(HIST("Data/hNTracks"), tracks.size()); - // const auto multiplicity = getMultiplicityEstimator(collision, true); + // auto multiplicity = getMultiplicityEstimator(collision, true); - // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { // return; // } @@ -2935,9 +3038,9 @@ struct HfTaskFlow { // if (collision.has_foundFV0()) { // const auto& fv0 = collision.foundFV0(); - // const auto multiplicity = getMultiplicityEstimator(collision, true); + // auto multiplicity = getMultiplicityEstimator(collision, true); - // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { // return; // } @@ -2961,9 +3064,9 @@ struct HfTaskFlow { // if (collision.has_foundFV0()) { // const auto& fv0 = collision.foundFV0(); - // const auto multiplicity = getMultiplicityEstimator(collision, true); + // auto multiplicity = getMultiplicityEstimator(collision, true); - // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { // return; // } @@ -2987,9 +3090,9 @@ struct HfTaskFlow { // if (collision.has_foundFV0()) { // const auto& fv0 = collision.foundFV0(); - // const auto multiplicity = getMultiplicityEstimator(collision, true); + // auto multiplicity = getMultiplicityEstimator(collision, true); - // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { // return; // } @@ -3010,9 +3113,9 @@ struct HfTaskFlow { // if (collision.has_foundFV0()) { // const auto& fv0 = collision.foundFV0(); - // const auto multiplicity = getMultiplicityEstimator(collision, true); + // auto multiplicity = getMultiplicityEstimator(collision, true); - // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { // return; // } @@ -3034,9 +3137,9 @@ struct HfTaskFlow { if (collision.has_foundFV0()) { const auto& fv0 = collision.foundFV0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = getMultiplicityEstimator(collision, true); - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3058,9 +3161,9 @@ struct HfTaskFlow { // if (collision.has_foundFV0()) { // const auto& fv0 = collision.foundFV0(); - // const auto multiplicity = getMultiplicityEstimator(collision, true); + // auto multiplicity = getMultiplicityEstimator(collision, true); - // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { // return; // } @@ -3089,9 +3192,14 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); registry.fill(HIST("Data/hNTracks"), tracks.size()); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3113,6 +3221,7 @@ struct HfTaskFlow { void processSameTpcFt0aD0Ch(FilteredCollisionsWSelMult::iterator const& collision, HfCandidatesSelD0 const& candidates, aod::FT0s const& ft0as, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { @@ -3124,9 +3233,14 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3143,6 +3257,7 @@ struct HfTaskFlow { void processSameTpcFt0aLcCh(FilteredCollisionsWSelMult::iterator const& collision, HfCandidatesSelLc const& candidates, aod::FT0s const& ft0as, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { @@ -3154,9 +3269,14 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3173,6 +3293,7 @@ struct HfTaskFlow { void processSameMftFt0aChCh(FilteredCollisionsWSelMult::iterator const& collision, FilteredMftTracks const& mftTracks, aod::FT0s const& ft0as, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { @@ -3184,9 +3305,14 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3205,6 +3331,7 @@ struct HfTaskFlow { soa::SmallGroups const& reassociatedMftTracks, FilteredMftTracks const&, aod::FT0s const& ft0as, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { @@ -3216,9 +3343,14 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3237,6 +3369,7 @@ struct HfTaskFlow { soa::SmallGroups const& reassociatedMftTracks, FilteredMftTracks const&, aod::FT0s const& ft0as, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { @@ -3248,9 +3381,14 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3269,6 +3407,7 @@ struct HfTaskFlow { soa::SmallGroups const& reassociatedMftTracks, FilteredMftTracks const&, aod::FT0s const& ft0as, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { @@ -3280,9 +3419,14 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3316,9 +3460,14 @@ struct HfTaskFlow { loadGain(bc); const auto& ft0 = collision.foundFT0(); registry.fill(HIST("Data/hNTracks"), tracks.size()); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3335,6 +3484,7 @@ struct HfTaskFlow { void processSameTpcFt0cD0Ch(FilteredCollisionsWSelMult::iterator const& collision, HfCandidatesSelD0 const& candidates, aod::FT0s const& ft0cs, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { @@ -3346,9 +3496,14 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3365,6 +3520,7 @@ struct HfTaskFlow { void processSameTpcFt0cLcCh(FilteredCollisionsWSelMult::iterator const& collision, HfCandidatesSelLc const& candidates, aod::FT0s const& ft0cs, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { @@ -3376,9 +3532,14 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3394,6 +3555,7 @@ struct HfTaskFlow { void processSameFt0aFt0cChCh(FilteredCollisionsWSelMult::iterator const& collision, aod::FT0s const&, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { @@ -3405,9 +3567,14 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3431,8 +3598,9 @@ struct HfTaskFlow { int multiplicity = 0; for (const auto& track : mcParticles) { - if (std::abs(track.eta()) < configCentral.etaCentralTrackMax) + if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { multiplicity += 1; + } } if ((multiplicity < configCollision.minMultiplicity) || (multiplicity >= configCollision.maxMultiplicity)) { @@ -3807,8 +3975,9 @@ struct HfTaskFlow { auto associatedTracks = mcParticles.sliceByCached(o2::aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), this->cache); int multiplicity = 0; for (const auto& track : associatedTracks) { - if (std::abs(track.eta()) < configCentral.etaCentralTrackMax) + if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { multiplicity += 1; + } } return multiplicity; }; @@ -3822,14 +3991,17 @@ struct HfTaskFlow { auto tracks2 = mcParticles.sliceBy(perMcColMcParticles, collision2.globalIndex()); int multiplicityCollision1 = 0; + int multiplicityCollision2 = 0; + for (const auto& track : tracks1) { - if (std::abs(track.eta()) < configCentral.etaCentralTrackMax) + if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { multiplicityCollision1 += 1; + } } - int multiplicityCollision2 = 0; for (const auto& track : tracks2) { - if (std::abs(track.eta()) < configCentral.etaCentralTrackMax) + if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { multiplicityCollision2 += 1; + } } if ((multiplicityCollision1 < configCollision.minMultiplicity || multiplicityCollision1 >= configCollision.maxMultiplicity)) { From 18674451074fb9a24f99d14ca0a7ea31c427d077 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Wed, 10 Jun 2026 15:57:39 +0200 Subject: [PATCH 08/10] MC good, add efficiency corrections for tracks --- PWGHF/HFC/Tasks/taskFlow.cxx | 424 +++++++++++++++++++++++++++-------- 1 file changed, 334 insertions(+), 90 deletions(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 7832373ad3b..d4248fc9618 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -213,6 +213,9 @@ struct HfTaskFlow { Configurable etaMcParticlesAssocMax{"etaMcParticlesAssocMax", -2.4f, "Maximum value for the eta of MC particles when used in cut function"}; Configurable etaMcParticlesAssocMin{"etaMcParticlesAssocMin", -3.6f, "Minimum value for the eta of MC particles when used in cut function"}; Configurable fillOnlyStepAll{"fillOnlyStepAll", true, "Fill Mc Gen QA plots only for StepAll, or only for Primaries"}; + Configurable loadEfficienciesForTpc{"loadEfficienciesForTpc", "", "Ccdb path to Tpc tracks efficiency correction"}; + Configurable loadEfficienciesForMft{"loadEfficienciesForMft", "", "Ccdb path to Mft tracks efficiency correction"}; + Configurable loadEfficienciesForNch{"loadEfficienciesForNch", "", "Ccdb path to Nch estimation efficiency correction"}; Configurable ptMcParticlesTriggerMax{"ptMcParticlesTriggerMax", 3.0f, "Maximum value for the pT of MC particles when used in cut function"}; Configurable ptMcParticlesTriggerMin{"ptMcParticlesTriggerMin", 0.2f, "Minimum value for the pT of MC particles when used in cut function"}; Configurable ptMcParticlesAssocMax{"ptMcParticlesAssocMax", 100.0f, "Maximum value for the pT of MC particles when used in cut function"}; @@ -221,6 +224,7 @@ 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 useEfficiencyCorrection{"useEfficiencyCorrection", false, "Choose to use or not use efficiency correction, if not used, weight is set to 1"}; } configTask; // configurables for collisions @@ -238,6 +242,7 @@ struct HfTaskFlow { Configurable minMultiplicity{"minMultiplicity", 0, "minimum multiplicity selection for collision"}; Configurable multiplicityEstimator{"multiplicityEstimator", 0, "0: multNTracksPV, 1: numContrib, 2: multFT0C, 3: multFT0M, 4: centFT0C, 5: centFT0CVariants1s, 6: centFT0M, 7: centFV0A, 8: centNTracksPV, 9: centNGlobal, 10: centMFT"}; Configurable useMultiplicityFromTracks{"useMultiplicityFromTracks", false, "Use multiplicity from counting tracks"}; + Configurable useMultiplicityFromTracksCorrected{"useMultiplicityFromTracksCorrected", false, "Use multiplicity from counting tracks, corrected but takes a lot of computation time"}; Configurable requireRCTFlagChecker{"requireRCTFlagChecker", false, "Check event quality in run condition table"}; 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"}; @@ -321,6 +326,11 @@ struct HfTaskFlow { RCTFlagsChecker rctChecker; RCTFlagsChecker correlationAnalysisRctChecker{kFT0Bad, kITSBad, kTPCBadTracking, kTPCBadPID, kMFTBad}; + TH3D* mEfficiencyTpc = nullptr; + TH3D* mEfficiencyMft = nullptr; + TH1D* mEfficiencyNch = nullptr; + bool areCorrectionsLoaded = false; + // o2::aod::rctsel::RCTFlagsChecker rctChecker{"CBT_muon_glo", false, false, true}; // ========================= @@ -637,6 +647,8 @@ 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.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { registry.add("Trig_hist_TPC_MFT", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); @@ -856,6 +868,9 @@ struct HfTaskFlow { if (doprocessSameMcGen) { + registry.add("MC/hEfficiencyTrigger", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); + registry.add("MC/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); + if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { addHistograms(); } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { @@ -1121,6 +1136,129 @@ struct HfTaskFlow { } } + void loadEfficiencyCorrection(uint64_t timestamp) + { + if (areCorrectionsLoaded) { + return; + } + if (configTask.loadEfficienciesForTpc.value.empty() == false) { + 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(), (void*)mEfficiencyTpc); + } + if (configTask.loadEfficienciesForMft.value.empty() == false) { + mEfficiencyMft = ccdb->getForTimeStamp(configTask.loadEfficienciesForTpc, timestamp); + if (mEfficiencyMft == nullptr) { + LOGF(fatal, "Could not load efficiency histogram for MFT tracks from %s", configTask.loadEfficienciesForMft.value.c_str()); + } + LOGF(info, "Loaded efficiency histogram from %s (%p)", configTask.loadEfficienciesForMft.value.c_str(), (void*)mEfficiencyMft); + } + if (configTask.loadEfficienciesForNch.value.empty() == false) { + mEfficiencyNch = ccdb->getForTimeStamp(configTask.loadEfficienciesForNch, timestamp); + if (!mEfficiencyNch) { + LOGF(fatal, "Could not load efficiency histogram for Nch estimator from %s", configTask.loadEfficienciesForNch.value.c_str()); + } + LOGF(info, "Loaded efficiency histogram from %s (%p)", configTask.loadEfficienciesForNch.value.c_str(), (void*)mEfficiencyNch); + } + areCorrectionsLoaded = true; + } + + bool getEfficiencyCorrectionTpc(float& weightTpc, float pt, float eta, float vertex) + { + float efficiencyTpc = 1.; + + if (mEfficiencyTpc) { + int etaBin = mEfficiencyTpc->GetXaxis()->FindBin(eta); + int ptBin = mEfficiencyTpc->FindBin(pt); + int vertexBin = mEfficiencyTpc->GetZaxis()->FindBin(vertex); + efficiencyTpc = mEfficiencyTpc->GetBinContent(etaBin, ptBin, vertexBin); + } + + if (efficiencyTpc == 0) { + return false; + } + + weightTpc = 1. / efficiencyTpc; + + return true; + } + + bool getEfficiencyCorrectionMft(float& weightMft, float pt, float eta, float vertex) + { + float efficiencyMft = 1.; + + if (mEfficiencyMft) { + int etaBin = mEfficiencyMft->GetXaxis()->FindBin(eta); + int ptBin = mEfficiencyMft->FindBin(pt); + int vertexBin = mEfficiencyMft->GetZaxis()->FindBin(vertex); + efficiencyMft = mEfficiencyMft->GetBinContent(etaBin, ptBin, vertexBin); + } + + if (efficiencyMft == 0) { + return false; + } + + weightMft = 1. / efficiencyMft; + + return true; + } + + template + double getCorrectedMultiplicity(TTracks tracks) // function to count the number of tracks in the event and fill the histogram + { + auto trackCounter = 0; + 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 (!getEfficiencyCorrection_Nch(weight_Nch, track.pt())) { + // continue; + // } + auto efficiencyNch = 1.0f; + if (configTask.useEfficiencyCorrection) { + + if (mEfficiencyNch) { + int ptBin = mEfficiencyNch->FindBin(track.pt()); + efficiencyNch = mEfficiencyNch->GetBinContent(ptBin); + } + + if (efficiencyNch == 0) { + return false; + } + + weightMultiplicity = 1. / efficiencyNch; + } else { + weightMultiplicity = 0; + } + + trackCounter += weightMultiplicity; + } + return trackCounter; + } + + // bool getEfficiencyCorrectionNch(float& weightNch, float pt) + // { + // float efficiencyNch = 1.; + + // if (mEfficiencyNch) { + // int ptBin = mEfficiencyNch->FindBin(pt); + // efficiencyNch = mEfficiencyNch->GetBinContent(ptBin); + // } + + // if (efficiencyNch == 0 ) { + // return false; + // } + + // weightNch = 1. / efficiencyNch; + + // return true; + // } + // ========================= // Cuts with functions // ========================= @@ -1358,8 +1496,8 @@ struct HfTaskFlow { TTracksTrig const& tracks1, TTracksAssoc const& tracks2, float multiplicity, float posZ, bool sameEvent, int magneticField) { - auto triggerWeight = 1; - auto associatedWeight = 1; + 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); @@ -1377,6 +1515,10 @@ struct HfTaskFlow { float const pt1 = track1.pt(); float const phi1 = track1.phi(); + if (configTask.useEfficiencyCorrection && !getEfficiencyCorrectionTpc(triggerWeight, pt1, eta1, posZ)) { + continue; + } + // TODO: add getter for NUE trigger efficiency here // calculating inv. mass to be filled into the container below @@ -1524,6 +1666,17 @@ struct HfTaskFlow { float phi2 = track2.phi(); o2::math_utils::bringTo02Pi(phi2); + if constexpr (std::is_same_v) { + if (configTask.useEfficiencyCorrection && !getEfficiencyCorrectionTpc(associatedWeight, pt2, eta2, posZ)) { + continue; + } + } + if constexpr (std::is_same_v) { + if (configTask.useEfficiencyCorrection && !getEfficiencyCorrectionMft(associatedWeight, pt2, eta2, posZ)) { + continue; + } + } + // TODO: add getter for NUE associated efficiency here float deltaPhi = phi1 - phi2; @@ -1580,8 +1733,8 @@ struct HfTaskFlow { TTracksTrig const& tracks1, TTracksAssoc const& tracks2, float multiplicity, float posZ, bool sameEvent, bool cutAmbiguousTracks) { - auto triggerWeight = 1; - auto associatedWeight = 1; + 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); @@ -1599,6 +1752,10 @@ struct HfTaskFlow { float const pt1 = track1.pt(); float const phi1 = track1.phi(); + if (configTask.useEfficiencyCorrection && !getEfficiencyCorrectionTpc(triggerWeight, pt1, eta1, posZ)) { + continue; + } + bool fillingHFcontainer = false; double invmass = 0; if constexpr (std::is_same_v || std::is_same_v) { @@ -1636,6 +1793,7 @@ struct HfTaskFlow { fillTriggerQa(multiplicity, eta1, phi1, pt1); } else { fillTriggerQa(multiplicity, eta1, phi1, pt1); + registry.fill(HIST("Data/hEfficiencyTrigger"), pt1, eta1, posZ); } } @@ -1727,7 +1885,9 @@ struct HfTaskFlow { float phi2 = reassociatedMftTrack.phi(); o2::math_utils::bringTo02Pi(phi2); - // TODO: add getter for NUE associated efficiency here + if (configTask.useEfficiencyCorrection && !getEfficiencyCorrectionMft(associatedWeight, pt2, eta2, posZ)) { + continue; + } float deltaPhi = phi1 - phi2; // set range of delta phi in (-pi/2 , 3/2*pi) @@ -1760,6 +1920,7 @@ struct HfTaskFlow { } else { fillAssociatedQa(multiplicity, eta2, phi2); registry.fill(HIST("Data/Mft/hPtMft"), pt2); + registry.fill(HIST("Data/hEfficiencyAssociated"), pt2, eta2, posZ); } } // end of fill QA } // end of loop over tracks2 @@ -1771,8 +1932,8 @@ struct HfTaskFlow { TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TFits const&, float multiplicity, float posZ, bool sameEvent, int fitType) { - auto triggerWeight = 1; - auto associatedWeight = 1; + 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); @@ -1803,6 +1964,13 @@ struct HfTaskFlow { float phi1 = track1.phi(); if constexpr (std::is_same_v) { o2::math_utils::bringTo02Pi(phi1); + if (configTask.useEfficiencyCorrection && !getEfficiencyCorrectionMft(triggerWeight, pt1, eta1, posZ)) { + continue; + } + } else { + if (configTask.useEfficiencyCorrection && !getEfficiencyCorrectionTpc(triggerWeight, pt1, eta1, posZ)) { + continue; + } } bool fillingHFcontainer = false; @@ -2008,8 +2176,8 @@ struct HfTaskFlow { TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TFits const&, float multiplicity, float posZ, bool sameEvent, bool cutAmbiguousTracks, int fitType) { - auto triggerWeight = 1; - auto associatedWeight = 1; + 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); @@ -2052,6 +2220,10 @@ struct HfTaskFlow { float phi1 = reassociatedMftTrack.phi(); o2::math_utils::bringTo02Pi(phi1); + if (configTask.useEfficiencyCorrection && !getEfficiencyCorrectionMft(triggerWeight, pt1, eta1, posZ)) { + continue; + } + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); if (configTask.doEtaDependentFlow) { @@ -2148,8 +2320,8 @@ struct HfTaskFlow { TFT0As const& ft0as, TFT0Cs const& ft0cs, float multiplicity, float posZ, bool sameEvent) { - auto triggerWeight = 1; - auto associatedWeight = 1; + 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); @@ -2248,6 +2420,7 @@ struct HfTaskFlow { // FILL QA FOR TRIGGER PARTICLE if (sameEvent && fillQaPlots) { + registry.fill(HIST("MC/hEfficiencyTrigger"), track1.pt(), track1.eta(), posZ); if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { @@ -2296,6 +2469,7 @@ struct HfTaskFlow { // FILL QA PLOTS for associated particle if (sameEvent && fillQaPlots && (loopCounter == 1)) { + registry.fill(HIST("MC/hEfficiencyAssociated"), track2.pt(), track2.eta(), posZ); if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { @@ -2332,9 +2506,9 @@ struct HfTaskFlow { auto getMultiplicity = [&tracks1, this](FilteredCollisionsWSelMult::iterator const& collision) { auto associatedTracks = tracks1.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); - auto mult = associatedTracks.size(); + // auto mult = 0.f; if (configCollision.useMultiplicityFromTracks) { - return mult; + return associatedTracks.size(); } else { return getMultiplicityEstimator(collision, false); } @@ -2357,6 +2531,7 @@ struct HfTaskFlow { } auto bc = collision1.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracks1.size(); @@ -2407,6 +2582,9 @@ struct HfTaskFlow { if (collision1.globalIndex() == collision2.globalIndex()) { continue; } + + auto bc = collision1.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracks1.size(); @@ -2417,7 +2595,6 @@ struct HfTaskFlow { return; } - auto bc = collision1.template bc_as(); auto slicedTriggerTracks = tracks1.sliceBy(presliceTrigger, collision1.globalIndex()); auto slicedAssociatedTracks = tracks2.sliceBy(presliceAssociated, collision2.globalIndex()); @@ -2429,7 +2606,7 @@ struct HfTaskFlow { template void mixCollisionsReassociatedMftTracks(TCollisions const& collisions, CorrelationContainer::CFStep step, TTracksTpc const& tracksTpc, TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TPresliceTrigger const& presliceTrigger, TPresliceAssociated const& presliceAssociated, - OutputObj& corrContainer, bool cutAmbiguousTracks) + OutputObj& corrContainer, bool cutAmbiguousTracks, aod::BCsWithTimestamps const&) { // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { // auto multiplicity = getMultiplicityEstimator(collision, false); @@ -2457,6 +2634,9 @@ struct HfTaskFlow { if (collision1.globalIndex() == collision2.globalIndex()) { continue; } + + auto bc = collision1.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracksTpc.size(); @@ -2487,7 +2667,7 @@ struct HfTaskFlow { template void mixCollisionsFIT(TCollisions const& collisions, CorrelationContainer::CFStep step, TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TPreslice const& preslice, - OutputObj& corrContainer, int fitType) + OutputObj& corrContainer, int fitType, aod::BCsWithTimestamps const&) { // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { // auto multiplicity = getMultiplicityEstimator(collision, false); @@ -2517,6 +2697,9 @@ struct HfTaskFlow { continue; } + auto bc = collision1.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); + if constexpr (std::is_same_v) { // IF ASSOCIATED PARTICLE FROM FV0A if (collision1.has_foundFV0() && collision2.has_foundFV0()) { @@ -2565,7 +2748,7 @@ struct HfTaskFlow { template void mixCollisionsFt0aFt0c(TCollisions const& collisions, CorrelationContainer::CFStep step, TTracksTpc const& tracksTpc, TFT0as const&, TFT0cs const&, - OutputObj& corrContainer) + OutputObj& corrContainer, aod::BCsWithTimestamps const&) { // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { // auto multiplicity = getMultiplicityEstimator(collision, false); @@ -2599,6 +2782,9 @@ struct HfTaskFlow { const auto& ft0as = collision1.foundFT0(); const auto& ft0cs = collision2.foundFT0(); + + auto bc = collision1.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracksTpc.size(); @@ -2640,6 +2826,7 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracks.size(); @@ -2678,6 +2865,7 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracks.size(); @@ -2716,6 +2904,7 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracks.size(); @@ -2747,6 +2936,7 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracks.size(); @@ -2771,7 +2961,8 @@ struct HfTaskFlow { void processSameTpcMftChChReassociated(FilteredCollisionsWSelMult::iterator const& collision, soa::SmallGroups const& reassociatedMftTracks, FilteredTracksWDcaSel const& tracks, - FilteredMftTracks const& mftTracks) + FilteredMftTracks const& mftTracks, + aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; @@ -2780,6 +2971,8 @@ struct HfTaskFlow { 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; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracks.size(); @@ -2804,7 +2997,8 @@ struct HfTaskFlow { void processSameTpcMftChChReassociated3d(FilteredCollisionsWSelMult::iterator const& collision, soa::SmallGroups const& reassociatedMftTracks, FilteredTracksWDcaSel const& tracks, - FilteredMftTracks const& mftTracks) + FilteredMftTracks const& mftTracks, + aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; @@ -2813,7 +3007,8 @@ struct HfTaskFlow { 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; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracks.size(); @@ -2838,7 +3033,8 @@ struct HfTaskFlow { void processSameTpcMftChChNonAmbiguous(FilteredCollisionsWSelMult::iterator const& collision, soa::SmallGroups const& reassociatedMftTracks, FilteredTracksWDcaSel const& tracks, - FilteredMftTracks const& mftTracks) + FilteredMftTracks const& mftTracks, + aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; // when process function has iterator @@ -2847,6 +3043,8 @@ struct HfTaskFlow { 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; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracks.size(); @@ -2890,6 +3088,7 @@ struct HfTaskFlow { } auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracks.size(); @@ -2910,12 +3109,15 @@ struct HfTaskFlow { HfCandidatesSelD0 const& candidates, soa::SmallGroups const& reassociatedMftTracks, FilteredTracksWDcaSel const& tracks, - FilteredMftTracks const&) + FilteredMftTracks const&, + aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; // when process function has iterator } + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracks.size(); @@ -2954,6 +3156,7 @@ struct HfTaskFlow { } auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracks.size(); @@ -2974,13 +3177,16 @@ struct HfTaskFlow { HfCandidatesSelLc const& candidates, soa::SmallGroups const& reassociatedMftTracks, FilteredTracksWDcaSel const& tracks, - FilteredMftTracks const&) + FilteredMftTracks const&, + aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { 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 { @@ -3186,7 +3392,8 @@ struct HfTaskFlow { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); @@ -3228,7 +3435,8 @@ struct HfTaskFlow { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); @@ -3264,7 +3472,8 @@ struct HfTaskFlow { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); @@ -3300,7 +3509,8 @@ struct HfTaskFlow { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); @@ -3338,7 +3548,8 @@ struct HfTaskFlow { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); @@ -3376,7 +3587,8 @@ struct HfTaskFlow { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); @@ -3414,7 +3626,8 @@ struct HfTaskFlow { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); @@ -3454,7 +3667,8 @@ struct HfTaskFlow { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); @@ -3491,7 +3705,8 @@ struct HfTaskFlow { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); @@ -3527,7 +3742,8 @@ struct HfTaskFlow { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); @@ -3562,7 +3778,8 @@ struct HfTaskFlow { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); @@ -3588,7 +3805,7 @@ struct HfTaskFlow { // MONTE-CARLO // =================================================================================================================================================================================================================================================================== - void processSameMcGen(aod::McCollisions::iterator const& mcCollision, + void processSameMcGen(soa::Join::iterator const& mcCollision, aod::McParticles const& mcParticles, SmallGroupMcCollisions const& collisions) { @@ -3596,11 +3813,15 @@ struct HfTaskFlow { return; } - int multiplicity = 0; - for (const auto& track : mcParticles) { - if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { - multiplicity += 1; + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + for (const auto& track : mcParticles) { + if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { + multiplicity += 1; + } } + } else { + multiplicity = mcCollision.multMCPVz(); } if ((multiplicity < configCollision.minMultiplicity) || (multiplicity >= configCollision.maxMultiplicity)) { @@ -3700,12 +3921,13 @@ struct HfTaskFlow { void processMixedTpcMftChChReassociated2d(FilteredCollisionsWSelMult const& collisions, FilteredTracksWDcaSel const& tracks, FilteredMftTracks const& /*mftTracks*/, - soa::SmallGroups const& reassociated2dMftTracks) + soa::SmallGroups const& reassociated2dMftTracks, + aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, false, bcs); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, false, bcs); } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChReassociated2d, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -3713,12 +3935,13 @@ struct HfTaskFlow { void processMixedTpcMftChChReassociated3d(FilteredCollisionsWSelMult const& collisions, FilteredTracksWDcaSel const& tracks, FilteredMftTracks const& /*mftTracks*/, - soa::SmallGroups const& reassociated3dMftTracks) + soa::SmallGroups const& reassociated3dMftTracks, + aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEvent, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEvent, false, bcs); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEventTpcMft, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEventTpcMft, false, bcs); } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChReassociated3d, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -3726,12 +3949,13 @@ struct HfTaskFlow { void processMixedTpcMftChChNonAmbiguous(FilteredCollisionsWSelMult const& collisions, FilteredTracksWDcaSel const& tracks, FilteredMftTracks const& /*mftTracks*/, - soa::SmallGroups const& reassociated2dMftTracks) + soa::SmallGroups const& reassociated2dMftTracks, + aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, true); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, true, bcs); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, true); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, true, bcs); } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChNonAmbiguous, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -3817,12 +4041,13 @@ struct HfTaskFlow { void processMixedTpcFt0aChCh(FilteredCollisionsWSelMult const& collisions, FilteredTracksWDcaSel const& tracks, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEvent, isFT0A); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEvent, isFT0A, bcs); } else { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEventTpcFt0a, isFT0A); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEventTpcFt0a, isFT0A, bcs); } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcFt0aChCh, "DATA : Process mixed-event correlations for TPC-FT0-A h-h case", false); @@ -3833,9 +4058,10 @@ struct HfTaskFlow { void processMixedTpcFt0aD0Ch(FilteredCollisionsWSelMult const& collisions, HfCandidatesSelD0 const& candidates, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, ft0s, perColD0s, mixedEventHf, isFT0A); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, ft0s, perColD0s, mixedEventHf, isFT0A, bcs); } PROCESS_SWITCH(HfTaskFlow, processMixedTpcFt0aD0Ch, "DATA : Process mixed-event correlations for TPC-FT0-A D0-h case", false); @@ -3845,9 +4071,10 @@ struct HfTaskFlow { void processMixedTpcFt0aLcCh(FilteredCollisionsWSelMult const& collisions, HfCandidatesSelLc const& candidates, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, ft0s, perColLcs, mixedEventHf, isFT0A); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, ft0s, perColLcs, mixedEventHf, isFT0A, bcs); } PROCESS_SWITCH(HfTaskFlow, processMixedTpcFt0aLcCh, "DATA : Process mixed-event correlations for TPC-FT0-A Lc-h case", false); @@ -3857,12 +4084,13 @@ struct HfTaskFlow { void processMixedMftFt0aChCh(FilteredCollisionsWSelMult const& collisions, FilteredMftTracks const& mftTracks, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, ft0s, perColMftTracks, mixedEvent, isFT0A); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, ft0s, perColMftTracks, mixedEvent, isFT0A, bcs); } else { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, ft0s, perColMftTracks, mixedEventMftFt0a, isFT0A); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, ft0s, perColMftTracks, mixedEventMftFt0a, isFT0A, bcs); } } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChCh, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); @@ -3871,12 +4099,13 @@ struct HfTaskFlow { FilteredMftTracks const& /*mftTracks*/, FilteredTracksWDcaSel const& tracksTpc, soa::SmallGroups const& reassociated2dMftTracks, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, false, bcs); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, false, bcs); } } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChChReassociated2d, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); @@ -3885,12 +4114,13 @@ struct HfTaskFlow { FilteredMftTracks const& /*mftTracks*/, FilteredTracksWDcaSel const& tracksTpc, soa::SmallGroups const& reassociated3dMftTracks, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEvent, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEvent, false, bcs); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEventMftFt0a, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEventMftFt0a, false, bcs); } } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChChReassociated3d, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); @@ -3899,12 +4129,13 @@ struct HfTaskFlow { FilteredMftTracks const& /*mftTracks*/, FilteredTracksWDcaSel const& tracksTpc, soa::SmallGroups const& reassociated2dMftTracks, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, true); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, true, bcs); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, true); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, true, bcs); } } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChChNonAmbiguous, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); @@ -3915,9 +4146,10 @@ struct HfTaskFlow { void processMixedTpcFt0cChCh(FilteredCollisionsWSelMult const& collisions, FilteredTracksWDcaSel const& tracks, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEvent, isFT0C); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEvent, isFT0C, bcs); } PROCESS_SWITCH(HfTaskFlow, processMixedTpcFt0cChCh, "DATA : Process mixed-event correlations for TPC-FT0C h-h case", false); @@ -3927,9 +4159,10 @@ struct HfTaskFlow { void processMixedTpcFt0cD0Ch(FilteredCollisionsWSelMult const& collisions, HfCandidatesSelD0 const& candidates, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, ft0s, perColD0s, mixedEventHf, isFT0C); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, ft0s, perColD0s, mixedEventHf, isFT0C, bcs); } PROCESS_SWITCH(HfTaskFlow, processMixedTpcFt0cD0Ch, "DATA : Process mixed-event correlations for TPC-FT0C D0-h case", false); @@ -3939,9 +4172,10 @@ struct HfTaskFlow { void processMixedTpcFt0cLcCh(FilteredCollisionsWSelMult const& collisions, HfCandidatesSelLc const& candidates, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, ft0s, perColLcs, mixedEventHf, isFT0C); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, ft0s, perColLcs, mixedEventHf, isFT0C, bcs); } PROCESS_SWITCH(HfTaskFlow, processMixedTpcFt0cLcCh, "DATA : Process mixed-event correlations for TPC-FT0C Lc-h case", false); @@ -3951,9 +4185,10 @@ struct HfTaskFlow { void processMixedFt0aFt0cChCh(FilteredCollisionsWSelMult const& collisions, FilteredTracksWDcaSel const& tracksTpc, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { - mixCollisionsFt0aFt0c(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, ft0s, ft0s, mixedEvent); + mixCollisionsFt0aFt0c(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, ft0s, ft0s, mixedEvent, bcs); } PROCESS_SWITCH(HfTaskFlow, processMixedFt0aFt0cChCh, "DATA : Process mixed-event correlations for FT0A-FT0C h-h case", false); @@ -3961,7 +4196,7 @@ struct HfTaskFlow { // MONTE-CARLO // =================================================================================================================================================================================================================================================================== - void processMixedMcGen(aod::McCollisions const& mcCollisions, + void processMixedMcGen(soa::Join const& mcCollisions, aod::McParticles const& mcParticles, SmallGroupMcCollisions const& collisions) { @@ -3971,13 +4206,17 @@ struct HfTaskFlow { // return multiplicity; // }; - auto getTracksSize = [&mcParticles, this](aod::McCollisions::iterator const& mcCollision) { + auto getTracksSize = [&mcParticles, this](soa::Join::iterator const& mcCollision) { auto associatedTracks = mcParticles.sliceByCached(o2::aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), this->cache); - int multiplicity = 0; - for (const auto& track : associatedTracks) { - if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { - multiplicity += 1; + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + for (const auto& track : associatedTracks) { + if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { + multiplicity += 1; + } } + } else { + multiplicity = mcCollision.multMCPVz(); } return multiplicity; }; @@ -3990,18 +4229,23 @@ struct HfTaskFlow { auto tracks1 = mcParticles.sliceBy(perMcColMcParticles, collision1.globalIndex()); auto tracks2 = mcParticles.sliceBy(perMcColMcParticles, collision2.globalIndex()); - int multiplicityCollision1 = 0; - int multiplicityCollision2 = 0; + auto multiplicityCollision1 = 0; + auto multiplicityCollision2 = 0; - for (const auto& track : tracks1) { - if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { - multiplicityCollision1 += 1; + if (configCollision.useMultiplicityFromTracks) { + for (const auto& track : tracks1) { + if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { + multiplicityCollision1 += 1; + } } - } - for (const auto& track : tracks2) { - if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { - multiplicityCollision2 += 1; + for (const auto& track : tracks2) { + if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { + multiplicityCollision2 += 1; + } } + } else { + multiplicityCollision1 = collision1.multMCPVz(); + multiplicityCollision2 = collision2.multMCPVz(); } if ((multiplicityCollision1 < configCollision.minMultiplicity || multiplicityCollision1 >= configCollision.maxMultiplicity)) { From c06b9b2c0cc9e2d1646567a1ca6320165cc9f4b0 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Wed, 10 Jun 2026 15:59:18 +0200 Subject: [PATCH 09/10] MC good, add efficiency corrections for tracks --- PWGHF/HFC/Tasks/taskFlow.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index d4248fc9618..4c68a7e6cee 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -3809,7 +3809,7 @@ struct HfTaskFlow { aod::McParticles const& mcParticles, SmallGroupMcCollisions const& collisions) { - if (!(abs(mcCollision.posZ()) <= configCollision.zVertexMax)) { + if (!(nabs(mcCollision.posZ()) <= configCollision.zVertexMax)) { return; } From 6cdceb398329bf1ad9cfae234a67583a10321860 Mon Sep 17 00:00:00 2001 From: AlexianL Date: Wed, 10 Jun 2026 21:00:24 +0200 Subject: [PATCH 10/10] solve issue with abs(), add std::abs() --- PWGHF/HFC/Tasks/taskFlow.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 4c68a7e6cee..f29cafc42e4 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -3809,7 +3809,7 @@ struct HfTaskFlow { aod::McParticles const& mcParticles, SmallGroupMcCollisions const& collisions) { - if (!(nabs(mcCollision.posZ()) <= configCollision.zVertexMax)) { + if (!(std::abs(mcCollision.posZ()) <= configCollision.zVertexMax)) { return; }