From 59d0769e4979a198a6c440854fc56f8ffeb95488 Mon Sep 17 00:00:00 2001 From: Maxim Virta Date: Tue, 1 Sep 2026 13:14:55 +0200 Subject: [PATCH 1/3] [PWGCF] Similar output procedure added for V02 and V0 --- PWGCF/GenericFramework/Tasks/flowGfwV02.cxx | 220 ++++++++++---------- 1 file changed, 114 insertions(+), 106 deletions(-) diff --git a/PWGCF/GenericFramework/Tasks/flowGfwV02.cxx b/PWGCF/GenericFramework/Tasks/flowGfwV02.cxx index cf8f332fb10..8f2af2662ec 100644 --- a/PWGCF/GenericFramework/Tasks/flowGfwV02.cxx +++ b/PWGCF/GenericFramework/Tasks/flowGfwV02.cxx @@ -11,7 +11,7 @@ // /// \file flowGfwV02.cxx /// \brief Skeleton copy of flowGfwLightIons with empty function bodies -/// \author Emil Gorm Nielsen, NBI, emil.gorm.nielsen@cern.ch +/// \author Maxim Virta, NBI, maxim.virta@cern.ch #include "PWGCF/DataModel/CorrelationsDerived.h" #include "PWGCF/GenericFramework/Core/FlowContainer.h" @@ -132,6 +132,7 @@ struct FlowGfwV02 { O2_DEFINE_CONFIGURABLE(cfgNormalizeByCharged, bool, true, "Enable or disable the normalization by charged particles"); O2_DEFINE_CONFIGURABLE(cfgConsistentEventFlag, int, 15, "Flag for consistent event selection"); O2_DEFINE_CONFIGURABLE(cfgMultCut, bool, true, "Use additional event cut on mult correlations"); + O2_DEFINE_CONFIGURABLE(cfgUseV02, bool, false, "Use V02 analysis"); O2_DEFINE_CONFIGURABLE(cfgUseV0, bool, false, "Use V0 analysis"); // Event selection cuts @@ -221,7 +222,6 @@ struct FlowGfwV02 { } cfg{}; // Define output - OutputObj fFC{FlowContainer("FlowContainer")}; HistogramRegistry registry{"registry"}; enum CentEstimators { @@ -413,28 +413,42 @@ struct FlowGfwV02 { AxisSpec dcaXYAxis = {200, -0.5, 0.5, "DCA_{xy} (cm)"}; AxisSpec bsAxis = {gfwMemberCache.nBootstrap, -0.5, gfwMemberCache.nBootstrap - 0.5, "Bootstrap Index"}; - registry.add("v02pt", "", {HistType::kTProfile3D, {ptAxis, centAxis, nchAxis}}); - registry.add("nchMid", "", {HistType::kTProfile3D, {ptAxis, centAxis, nchAxis}}); - registry.add("v02centmult", "", {HistType::kTProfile2D, {centAxis, nchAxis}}); - + // V0 spectra registry.add("analysis/charged/v0AB", "", {HistType::kTProfile3D, {bsAxis, ptAxis, centAxis}}); registry.add("analysis/charged/v0BA", "", {HistType::kTProfile3D, {bsAxis, ptAxis, centAxis}}); registry.add("analysis/charged/nchA", "", {HistType::kTProfile3D, {bsAxis, ptAxis, centAxis}}); registry.add("analysis/charged/nchB", "", {HistType::kTProfile3D, {bsAxis, ptAxis, centAxis}}); - registry.add("analysis/charged/ptA", "", {HistType::kTProfile3D, {bsAxis, centAxis, nchAxis}}); - registry.add("analysis/charged/ptB", "", {HistType::kTProfile3D, {bsAxis, centAxis, nchAxis}}); - registry.add("analysis/charged/ptAB", "", {HistType::kTProfile3D, {bsAxis, centAxis, nchAxis}}); + + // V02 spectra + registry.add("analysis/charged/v22npt", "", {HistType::kTProfile3D, {bsAxis, ptAxis, centAxis}}); + registry.add("analysis/charged/nchC", "", {HistType::kTProfile3D, {bsAxis, ptAxis, centAxis}}); + if (cfgUseMultiplicityFracWeights) { registry.add("analysis/charged/nchA2pc", "", {HistType::kTProfile3D, {bsAxis, ptAxis, centAxis}}); registry.add("analysis/charged/nchB2pc", "", {HistType::kTProfile3D, {bsAxis, ptAxis, centAxis}}); - registry.add("analysis/charged/ptA2pc", "", {HistType::kTProfile3D, {bsAxis, centAxis, nchAxis}}); - registry.add("analysis/charged/ptB2pc", "", {HistType::kTProfile3D, {bsAxis, centAxis, nchAxis}}); + registry.add("analysis/charged/nchC3pc", "", {HistType::kTProfile3D, {bsAxis, ptAxis, centAxis}}); } registry.addClone("analysis/charged/", "analysis/pion/"); registry.addClone("analysis/charged/", "analysis/kaon/"); registry.addClone("analysis/charged/", "analysis/proton/"); + // Only charged particles + registry.add("analysis/charged/v22pt", "", {HistType::kTProfile2D, {bsAxis, centAxis}}); + registry.add("analysis/charged/ptA", "", {HistType::kTProfile2D, {bsAxis, centAxis}}); + registry.add("analysis/charged/ptB", "", {HistType::kTProfile2D, {bsAxis, centAxis}}); + registry.add("analysis/charged/ptAB", "", {HistType::kTProfile2D, {bsAxis, centAxis}}); + registry.add("analysis/charged/ptC", "", {HistType::kTProfile2D, {bsAxis, centAxis}}); + registry.add("analysis/charged/v22", "", {HistType::kTProfile2D, {bsAxis, centAxis}}); + + if (cfgUseMultiplicityFracWeights) { + registry.add("analysis/charged/ptA2pc", "", {HistType::kTProfile2D, {bsAxis, centAxis}}); + registry.add("analysis/charged/ptB2pc", "", {HistType::kTProfile2D, {bsAxis, centAxis}}); + registry.add("analysis/charged/ptC3pc", "", {HistType::kTProfile2D, {bsAxis, centAxis}}); + registry.add("analysis/charged/v223pc", "", {HistType::kTProfile2D, {bsAxis, centAxis}}); + } + + ccdb->setURL("http://alice-ccdb.cern.ch"); ccdb->setCaching(true); ccdb->setLocalObjectValidityChecking(); @@ -510,9 +524,6 @@ struct FlowGfwV02 { oba->SetOwner(kTRUE); addConfigObjectsToObjArray(oba, corrconfigs); LOGF(info, "Number of correlators: %d", oba->GetEntries()); - fFC->SetName("FlowContainer"); - fFC->SetXAxis(fSecondAxis.get()); - fFC->Initialize(oba, centAxis, cfgNbootstrap); delete oba; if (cfgConsistentEventFlag != 0) { @@ -842,45 +853,84 @@ struct FlowGfwV02 { void fillOutputContainers(const float& centmult, const int& multiplicity, const double& rndm, const int& /*run*/ = 0) { double threshold = 1.01; - for (uint l_ind = 0; l_ind < corrconfigs.size(); ++l_ind) { - if (!corrconfigs.at(l_ind).pTDif) { - auto dnx = fGFW->Calculate(corrconfigs.at(l_ind), 0, kTRUE).real(); - if (dnx == 0) - continue; - auto val = fGFW->Calculate(corrconfigs.at(l_ind), 0, kFALSE).real() / dnx; - - if (std::abs(val) < threshold) { - fFC->FillProfile(corrconfigs.at(l_ind).Head.c_str(), centmult, val, (cfgUseMultiplicityFlowWeights) ? dnx : 1.0, rndm); - } - continue; - } - // Fill pt profiles for different particles - int pidInd = getPIDIndex(corrconfigs.at(l_ind).Head); - - auto dnx = fGFW->Calculate(corrconfigs.at(0), 0, kTRUE).real(); - if (dnx == 0) - continue; - auto val = fGFW->Calculate(corrconfigs.at(0), 0, kFALSE).real() / dnx; - double ebyeWeight = (cfgUseMultiplicityFlowWeights) ? dnx : 1.0; - for (int i = 1; i <= fSecondAxis->GetNbins(); i++) { - if (corrconfigs.at(l_ind).Head.find("nch") != std::string::npos) { - ebyeWeight = 1.0; - val = 1.0; + // Calculate V02 + if (cfgUseV02) { + double v22npt = 0; + double ptMeanMid = pidStates.hPtMid[PidCharged]->GetMean(); + double ptFractionMid = 0.; + int bootstrap = fRndm->Integer(gfwMemberCache.nBootstrap); + double dnxAB = fGFW->Calculate(corrconfigs.at(0), 0, kTRUE).real(); // V22 weight for AB + auto valAB = fGFW->Calculate(corrconfigs.at(0), 0, kFALSE).real() / dnxAB; + if (std::abs(valAB) > threshold) { + return; + } + double v22pt = valAB * ptMeanMid; + double WeightAB = (cfgUseMultiplicityFlowWeights) ? dnxAB : 1.0; + double WeightC = 1.0; + // Calculate V02 for each particle type + for (int pid = 0; pid < PidTotal; pid++) { + int normIndex = (cfgNormalizeByCharged) ? PidCharged : pid; + if (!(pidStates.hPtMid[normIndex]->Integral() > 0)) { + continue; // Mid pT distribution is not defined } - if (cfgUseMultiplicityFracWeights && pidStates.hPtMid[PidCharged]->Integral() > 0) { - ebyeWeight *= pidStates.hPtMid[PidCharged]->Integral(); + if (cfgUseMultiplicityFracWeights) { + WeightC = pidStates.hPtMid[PidCharged]->Integral(); // Mean pt/npt C weight } - double ptFraction = 0; - int normIndex = (cfgNormalizeByCharged) ? PidCharged : pidInd; // Configured to normalize by charged particles or the selected particle - if (pidStates.hPtMid[normIndex]->Integral() > 0) { - ptFraction = pidStates.hPtMid[pidInd]->GetBinContent(i) / pidStates.hPtMid[normIndex]->Integral(); - if (std::abs(val) < threshold) - fFC->FillProfile(Form("%s_pt_%i", corrconfigs.at(l_ind).Head.c_str(), i), centmult, val * ptFraction, ebyeWeight, rndm); + for (int i = 1; i <= fSecondAxis->GetNbins(); i++) { + ptFractionMid = pidStates.hPtMid[pid]->GetBinContent(i) / pidStates.hPtMid[normIndex]->Integral(); + v22npt = valAB * ptFractionMid; + + switch (pid) { + case PidCharged: + registry.fill(HIST("analysis/charged/v22npt"), bootstrap, fSecondAxis->GetBinCenter(i), centmult, v22npt, WeightC * WeightAB); + registry.fill(HIST("analysis/charged/nchC"), bootstrap, fSecondAxis->GetBinCenter(i), centmult, ptFractionMid, WeightC); + if (cfgUseMultiplicityFracWeights) { + registry.fill(HIST("analysis/charged/nchC3pc"), bootstrap, fSecondAxis->GetBinCenter(i), centmult, ptFractionMid, WeightC * WeightAB); + } + break; + case PidPions: + registry.fill(HIST("analysis/pion/v22npt"), bootstrap, fSecondAxis->GetBinCenter(i), centmult, v22npt, WeightC * WeightAB); + registry.fill(HIST("analysis/pion/nchC"), bootstrap, fSecondAxis->GetBinCenter(i), centmult, ptFractionMid, WeightC); + if (cfgUseMultiplicityFracWeights) { + registry.fill(HIST("analysis/pion/nchC3pc"), bootstrap, fSecondAxis->GetBinCenter(i), centmult, ptFractionMid, WeightC * WeightAB); + } + break; + case PidKaons: + registry.fill(HIST("analysis/kaon/v22npt"), bootstrap, fSecondAxis->GetBinCenter(i), centmult, v22npt, WeightC * WeightAB); + registry.fill(HIST("analysis/kaon/nchC"), bootstrap, fSecondAxis->GetBinCenter(i), centmult, ptFractionMid, WeightC); + if (cfgUseMultiplicityFracWeights) { + registry.fill(HIST("analysis/kaon/nchC3pc"), bootstrap, fSecondAxis->GetBinCenter(i), centmult, ptFractionMid, WeightC * WeightAB); + } + break; + case PidProtons: + registry.fill(HIST("analysis/proton/v22npt"), bootstrap, fSecondAxis->GetBinCenter(i), centmult, v22npt, WeightC * WeightAB); + registry.fill(HIST("analysis/proton/nchC"), bootstrap, fSecondAxis->GetBinCenter(i), centmult, ptFractionMid, WeightC); + if (cfgUseMultiplicityFracWeights) { + registry.fill(HIST("analysis/proton/nchC3pc"), bootstrap, fSecondAxis->GetBinCenter(i), centmult, ptFractionMid, WeightC * WeightAB); + } + break; + default: + break; + } } } - } + // Calculate NCv22pt + if (cfgUseMultiplicityFracWeights) { + WeightC = pidStates.hPtMid[PidCharged]->Integral(); + } + + registry.fill(HIST("analysis/charged/v22pt"), bootstrap, centmult, v22pt, WeightC * WeightAB); + registry.fill(HIST("analysis/charged/v22"), bootstrap, centmult, valAB, WeightAB); + registry.fill(HIST("analysis/charged/ptC"), bootstrap, centmult, ptMeanMid, WeightC); + if (cfgUseMultiplicityFracWeights) { + registry.fill(HIST("analysis/charged/v223pc"), bootstrap, centmult, valAB, WeightC * WeightAB); + registry.fill(HIST("analysis/charged/ptC3pc"), bootstrap, centmult, ptMeanMid, WeightC * WeightAB); + } + } // End of V02 + + // Calculate V0 if (cfgUseV0) { double v0corrAB = 0; double v0corrBA = 0; @@ -889,13 +939,13 @@ struct FlowGfwV02 { double ptFractionForward = 0.; double ptFractionBackward = 0.; int bootstrap = fRndm->Integer(gfwMemberCache.nBootstrap); + double WeightA = 1.0; + double WeightB = 1.0; for (int pid = 0; pid < PidTotal; pid++) { int normIndex = (cfgNormalizeByCharged) ? PidCharged : pid; if (!(pidStates.hPtForward[normIndex]->Integral() > 0) || !(pidStates.hPtBackward[normIndex]->Integral() > 0)) { continue; // Forward or backward pT distribution is not defined } - double WeightA = 1.0; - double WeightB = 1.0; if (cfgUseMultiplicityFracWeights) { WeightA = pidStates.hPtForward[PidCharged]->Integral(); WeightB = pidStates.hPtBackward[PidCharged]->Integral(); @@ -950,65 +1000,23 @@ struct FlowGfwV02 { break; } } - switch (pid) { - case PidCharged: - registry.fill(HIST("analysis/charged/ptA"), bootstrap, centmult, multiplicity, ptMeanForward, WeightA); - registry.fill(HIST("analysis/charged/ptB"), bootstrap, centmult, multiplicity, ptMeanBackward, WeightB); - if (cfgUseMultiplicityFracWeights) { - registry.fill(HIST("analysis/charged/ptA2pc"), bootstrap, centmult, multiplicity, ptMeanForward, WeightA * WeightB); - registry.fill(HIST("analysis/charged/ptB2pc"), bootstrap, centmult, multiplicity, ptMeanBackward, WeightA * WeightB); - } - registry.fill(HIST("analysis/charged/ptAB"), bootstrap, centmult, multiplicity, ptMeanForward * ptMeanBackward, WeightA * WeightB); - break; - case PidPions: - registry.fill(HIST("analysis/pion/ptA"), bootstrap, centmult, multiplicity, ptMeanForward, WeightA); - registry.fill(HIST("analysis/pion/ptB"), bootstrap, centmult, multiplicity, ptMeanBackward, WeightB); - if (cfgUseMultiplicityFracWeights) { - registry.fill(HIST("analysis/pion/ptA2pc"), bootstrap, centmult, multiplicity, ptMeanForward, WeightA * WeightB); - registry.fill(HIST("analysis/pion/ptB2pc"), bootstrap, centmult, multiplicity, ptMeanBackward, WeightA * WeightB); - } - registry.fill(HIST("analysis/pion/ptAB"), bootstrap, centmult, multiplicity, ptMeanForward * ptMeanBackward, WeightA * WeightB); - break; - case PidKaons: - registry.fill(HIST("analysis/kaon/ptA"), bootstrap, centmult, multiplicity, ptMeanForward, WeightA); - registry.fill(HIST("analysis/kaon/ptB"), bootstrap, centmult, multiplicity, ptMeanBackward, WeightB); - if (cfgUseMultiplicityFracWeights) { - registry.fill(HIST("analysis/kaon/ptA2pc"), bootstrap, centmult, multiplicity, ptMeanForward, WeightA * WeightB); - registry.fill(HIST("analysis/kaon/ptB2pc"), bootstrap, centmult, multiplicity, ptMeanBackward, WeightA * WeightB); - } - registry.fill(HIST("analysis/kaon/ptAB"), bootstrap, centmult, multiplicity, ptMeanForward * ptMeanBackward, WeightA * WeightB); - break; - case PidProtons: - registry.fill(HIST("analysis/proton/ptA"), bootstrap, centmult, multiplicity, ptMeanForward, WeightA); - registry.fill(HIST("analysis/proton/ptB"), bootstrap, centmult, multiplicity, ptMeanBackward, WeightB); - if (cfgUseMultiplicityFracWeights) { - registry.fill(HIST("analysis/proton/ptA2pc"), bootstrap, centmult, multiplicity, ptMeanForward, WeightA * WeightB); - registry.fill(HIST("analysis/proton/ptB2pc"), bootstrap, centmult, multiplicity, ptMeanBackward, WeightA * WeightB); - } - registry.fill(HIST("analysis/proton/ptAB"), bootstrap, centmult, multiplicity, ptMeanForward * ptMeanBackward, WeightA * WeightB); - break; - default: - break; - } - } - } + } // End of PID dependent parts of V0 - // Fill the profiles for each pT bin - auto dnx = fGFW->Calculate(corrconfigs.at(0), 0, kTRUE).real(); - if (dnx == 0) - return; - auto val = fGFW->Calculate(corrconfigs.at(0), 0, kFALSE).real() / dnx; - for (int i = 1; i <= fSecondAxis->GetNbins(); i++) { - double ptFraction = 0; - if (pidStates.hPtMid[PidCharged]->Integral() > 0) { - ptFraction = pidStates.hPtMid[PidCharged]->GetBinContent(i) / pidStates.hPtMid[PidCharged]->Integral(); - if (std::abs(val) < threshold) - registry.fill(HIST("v02pt"), fSecondAxis->GetBinCenter(i), centmult, multiplicity, val * ptFraction, (cfgUseMultiplicityFlowWeights) ? dnx : 1.0); - registry.fill(HIST("nchMid"), fSecondAxis->GetBinCenter(i), centmult, multiplicity, ptFraction); + // Calculate PID independent parts of V0 + if (cfgUseMultiplicityFracWeights) { + WeightA = pidStates.hPtForward[PidCharged]->Integral(); + WeightB = pidStates.hPtBackward[PidCharged]->Integral(); } - } - registry.fill(HIST("v02centmult"), centmult, multiplicity, val); - } + registry.fill(HIST("analysis/charged/ptA"), bootstrap, centmult, ptMeanForward, WeightA); + registry.fill(HIST("analysis/charged/ptB"), bootstrap, centmult, ptMeanBackward, WeightB); + if (cfgUseMultiplicityFracWeights) { + registry.fill(HIST("analysis/charged/ptA2pc"), bootstrap, centmult, ptMeanForward, WeightA * WeightB); + registry.fill(HIST("analysis/charged/ptB2pc"), bootstrap, centmult, ptMeanBackward, WeightA * WeightB); + } + registry.fill(HIST("analysis/charged/ptAB"), bootstrap, centmult, ptMeanForward * ptMeanBackward, WeightA * WeightB); + + } // End of V0 + } // End of Filling struct XAxis { float centrality; From 83d756429d21b4caebbdc1357f980fc52d9c30c7 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Tue, 1 Sep 2026 11:17:13 +0000 Subject: [PATCH 2/3] Please consider the following formatting changes --- PWGCF/GenericFramework/Tasks/flowGfwV02.cxx | 1 - 1 file changed, 1 deletion(-) diff --git a/PWGCF/GenericFramework/Tasks/flowGfwV02.cxx b/PWGCF/GenericFramework/Tasks/flowGfwV02.cxx index 8f2af2662ec..fb597610338 100644 --- a/PWGCF/GenericFramework/Tasks/flowGfwV02.cxx +++ b/PWGCF/GenericFramework/Tasks/flowGfwV02.cxx @@ -448,7 +448,6 @@ struct FlowGfwV02 { registry.add("analysis/charged/v223pc", "", {HistType::kTProfile2D, {bsAxis, centAxis}}); } - ccdb->setURL("http://alice-ccdb.cern.ch"); ccdb->setCaching(true); ccdb->setLocalObjectValidityChecking(); From fcf696c44a8d8054dc3a52ea50136e36f6d7b670 Mon Sep 17 00:00:00 2001 From: Maxim Virta Date: Tue, 1 Sep 2026 17:00:53 +0200 Subject: [PATCH 3/3] Removed unused parameters --- PWGCF/GenericFramework/Tasks/flowGfwV02.cxx | 23 ++++++++------------- 1 file changed, 9 insertions(+), 14 deletions(-) diff --git a/PWGCF/GenericFramework/Tasks/flowGfwV02.cxx b/PWGCF/GenericFramework/Tasks/flowGfwV02.cxx index fb597610338..0a7c0dc5479 100644 --- a/PWGCF/GenericFramework/Tasks/flowGfwV02.cxx +++ b/PWGCF/GenericFramework/Tasks/flowGfwV02.cxx @@ -14,7 +14,6 @@ /// \author Maxim Virta, NBI, maxim.virta@cern.ch #include "PWGCF/DataModel/CorrelationsDerived.h" -#include "PWGCF/GenericFramework/Core/FlowContainer.h" #include "PWGCF/GenericFramework/Core/GFW.h" #include "PWGCF/GenericFramework/Core/GFWConfig.h" #include "PWGCF/GenericFramework/Core/GFWWeights.h" @@ -51,7 +50,6 @@ #include #include -#include #include @@ -849,16 +847,16 @@ struct FlowGfwV02 { } template - void fillOutputContainers(const float& centmult, const int& multiplicity, const double& rndm, const int& /*run*/ = 0) + void fillOutputContainers(const float& centmult) { double threshold = 1.01; + int bootstrap = fRndm->Integer(gfwMemberCache.nBootstrap); // Calculate V02 if (cfgUseV02) { double v22npt = 0; double ptMeanMid = pidStates.hPtMid[PidCharged]->GetMean(); double ptFractionMid = 0.; - int bootstrap = fRndm->Integer(gfwMemberCache.nBootstrap); double dnxAB = fGFW->Calculate(corrconfigs.at(0), 0, kTRUE).real(); // V22 weight for AB auto valAB = fGFW->Calculate(corrconfigs.at(0), 0, kFALSE).real() / dnxAB; if (std::abs(valAB) > threshold) { @@ -937,7 +935,6 @@ struct FlowGfwV02 { double ptMeanBackward = pidStates.hPtBackward[PidCharged]->GetMean(); double ptFractionForward = 0.; double ptFractionBackward = 0.; - int bootstrap = fRndm->Integer(gfwMemberCache.nBootstrap); double WeightA = 1.0; double WeightB = 1.0; for (int pid = 0; pid < PidTotal; pid++) { @@ -1030,7 +1027,7 @@ struct FlowGfwV02 { }; template - void processCollision(TCollision const& collision, TTracks const& tracks, const XAxis& xaxis, const int& run) + void processCollision(TCollision const& collision, TTracks const& tracks, const XAxis& xaxis) { float vtxz = collision.posZ(); if (tracks.size() < 1) @@ -1053,12 +1050,10 @@ struct FlowGfwV02 { pidStates.hPtForward[PidKaons]->Reset(); pidStates.hPtForward[PidProtons]->Reset(); - float lRandom = fRndm->Rndm(); - // Loop over tracks and check if they are accepted AcceptedTracks acceptedTracks{.nPos = 0, .nNeg = 0, .nFull = 0, .nMid = 0}; for (const auto& track : tracks) { - processTrack(track, vtxz, xaxis.multiplicity, run, acceptedTracks); + processTrack(track, vtxz, xaxis.multiplicity, acceptedTracks); if (track.eta() > cfgSubeventCuts.cfgEtaSubCMin && track.eta() < cfgSubeventCuts.cfgEtaSubCMax) pidStates.hPtMid[PidCharged]->Fill(track.pt(), getEfficiency(track, PidCharged)); if (track.eta() > cfgSubeventCuts.cfgEtaSubAMin && track.eta() < cfgSubeventCuts.cfgEtaSubAMax) // add mean pT @@ -1099,7 +1094,7 @@ struct FlowGfwV02 { if (acceptedTracks.nPos < 2 || acceptedTracks.nMid < 2 || acceptedTracks.nNeg < 2) // o2-linter: disable=magic-number (at least two tracks in all three subevents) return; // Fill output containers - fillOutputContainers
(xaxis.centrality, xaxis.multiplicity, lRandom, run); + fillOutputContainers
(xaxis.centrality); } template @@ -1147,7 +1142,7 @@ struct FlowGfwV02 { } template - inline void processTrack(TTrack const& track, const float& vtxz, const int& multiplicity, const int& /*run*/, AcceptedTracks& acceptedTracks) + inline void processTrack(TTrack const& track, const float& vtxz, const int& multiplicity, AcceptedTracks& acceptedTracks) { if (cfgFillQA) { @@ -1333,7 +1328,7 @@ struct FlowGfwV02 { registry.fill(HIST("eventQA/after/centrality"), xaxis.centrality); registry.fill(HIST("eventQA/after/multiplicity"), xaxis.multiplicity); - processCollision(collision, tracks, xaxis, run); + processCollision(collision, tracks, xaxis); } PROCESS_SWITCH(FlowGfwV02, processData, "Process analysis for non-derived data", true); @@ -1350,7 +1345,7 @@ struct FlowGfwV02 { registry.fill(HIST("eventQA/after/centrality"), xaxis.centrality); registry.fill(HIST("eventQA/after/multiplicity"), xaxis.multiplicity); - // processCollision(collision, tracks, xaxis, run); + // processCollision(collision, tracks, xaxis); } PROCESS_SWITCH(FlowGfwV02, processCFDerived, "Process analysis for CF derived data", false); void processCFDerivedCorrected(aod::CFCollision const& collision, soa::Filtered> const& tracks) @@ -1363,7 +1358,7 @@ struct FlowGfwV02 { const XAxis xaxis{.centrality = collision.multiplicity(), .multiplicity = tracks.size()}; registry.fill(HIST("eventQA/after/centrality"), xaxis.centrality); registry.fill(HIST("eventQA/after/multiplicity"), xaxis.multiplicity); - // processCollision(collision, tracks, xaxis, run); + // processCollision(collision, tracks, xaxis); } PROCESS_SWITCH(FlowGfwV02, processCFDerivedCorrected, "Process analysis for CF derived data with corrections", false); };