From c85bf7a8a401adbb932f207ba71605ee65fad302 Mon Sep 17 00:00:00 2001 From: huinaibing Date: Wed, 12 Aug 2026 19:21:21 +0800 Subject: [PATCH 1/7] [PWGCF] Add hist to calculate v22 - deltaPt --- PWGCF/Flow/Tasks/pidFlowPtCorr.cxx | 394 ++++++++++++++++++++++++----- 1 file changed, 327 insertions(+), 67 deletions(-) diff --git a/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx b/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx index 54c7912b6ab..35841923c31 100644 --- a/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx +++ b/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx @@ -84,7 +84,7 @@ struct PidFlowPtCorr { std::string prefix = "trkQualityOpts"; // track selections Configurable cfgCutEta{"cfgCutEta", 0.8f, "Eta range for tracks"}; - Configurable cfgRangeEta{"cfgRangeEta", 0.4f, "Eta range for mean Pt"}; + Configurable cfgRangeEta{"cfgRangeEta", 0.4f, "Independent |eta| half-width for mean-pT particles"}; Configurable cfgCutPtMin{"cfgCutPtMin", 0.2f, "Minimal pT for ref tracks"}; Configurable cfgCutPtMax{"cfgCutPtMax", 10.0f, "Maximal pT for ref tracks"}; Configurable cfgCutPtMinPi{"cfgCutPtMinPi", 0.2f, "Minimal pT for pion POI"}; @@ -139,7 +139,7 @@ struct PidFlowPtCorr { } correctionPathOpts; Configurable> cfgRunNumbers{"cfgRunNumbers", (std::vector{544095, 544098, 544116, 544121, 544122, 544123, 544124}), "Preconfigured run numbers"}; - Configurable cfgEtaGap{"cfgEtaGap", 0.4, "eta gap for cumulant calculation, note that gap is -0.4 ~ 0.4 total 0.8, note that eta range for meanpt calculation needs to be within etagap"}; + Configurable cfgEtaGap{"cfgEtaGap", 0.4, "Eta-gap half-width for flow particles; 0.4 selects (-etaMax,-0.4) and (0.4,etaMax)"}; Configurable cfgFlowNbootstrap{"cfgFlowNbootstrap", 30, "Number of subsamples for bootstrap"}; // switch @@ -155,6 +155,9 @@ struct PidFlowPtCorr { Configurable cfgClosureTest{"cfgClosureTest", 0, "choose (val) percent particle from charged to pass Pion PID selection"}; Configurable cfgOutPutMC1D{"cfgOutPutMC1D", true, "Fill MC graphs, note that if the processMCgen is open,this MUST be open"}; Configurable cfgAddPidResponseMatrixHistograms{"cfgAddPidResponseMatrixHistograms", false, "Add PID response matrix histograms; enable together with processPidResponseMatrix"}; + Configurable cfgAddC22DeltaPtHistograms{"cfgAddC22DeltaPtHistograms", false, "Add histograms for processDataC22DeltaPt; enable together with processDataC22DeltaPt"}; + Configurable cfgC22DeltaPtUsePure{"cfgC22DeltaPtUsePure", false, "true: use PID POI-POI Pure profiles; false: use PID POI-ref and ref-ref profiles"}; + Configurable cfgAddMeanPtCentNbsHistograms{"cfgAddMeanPtCentNbsHistograms", false, "Add meanptCentNbs TProfile3D histograms"}; Configurable cfgProcessQAOutput{"cfgProcessQAOutput", false, "QA plots for processQA"}; Configurable cfgUseNUAWithPt{"cfgUseNUAWithPt", false, "false: use original GFWWeights (phi,eta,vz) NUA; true: use THnSparse (phi,eta,vz,pt) NUA loaded from cfgAcceptancePathWithPt"}; @@ -333,6 +336,7 @@ struct PidFlowPtCorr { funcProcessSim, funcProcessQA, funcProcessPidResponseMatrix, + funcProcessDataC22DeltaPt, funcNumber }; @@ -564,6 +568,37 @@ struct PidFlowPtCorr { // processPidResponseMatrix registry.addClone("hEventCount/processData", "hEventCount/processPidResponseMatrix"); + if (switchsOpts.cfgAddC22DeltaPtHistograms.value) { + registry.addClone("hEventCount/processData", "hEventCount/processDataC22DeltaPt"); + registry.add("c22DeltaPt/c22dmeanptCharged", "Charged c_{2}{2} versus charged event [p_{T}];Centrality (%);[p_{T}]_{ch} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + + // Store the ensemble mean pT required for the offline delta[pT]/<[pT]> + // transformation. The profile weight is the NUE-corrected particle count. + registry.add("c22DeltaPt/hMeanPtCharged", "Charged mean p_{T};Centrality (%);Bootstrap subsample;[p_{T}]_{ch} (GeV/#it{c})", {HistType::kTProfile2D, {axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("c22DeltaPt/hMeanPtPion", "Pion mean p_{T};Centrality (%);Bootstrap subsample;[p_{T}]_{#pi} (GeV/#it{c})", {HistType::kTProfile2D, {axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("c22DeltaPt/hMeanPtKaon", "Kaon mean p_{T};Centrality (%);Bootstrap subsample;[p_{T}]_{K} (GeV/#it{c})", {HistType::kTProfile2D, {axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("c22DeltaPt/hMeanPtProton", "Proton mean p_{T};Centrality (%);Bootstrap subsample;[p_{T}]_{p} (GeV/#it{c})", {HistType::kTProfile2D, {axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + + // Ref-ref is required in either PID mode: Pure/ref-ref or POI-ref/ref-ref. + // Separate copies are binned by the event mean pT of each PID species. + registry.add("c22DeltaPt/c22dmeanptPionRefRef", "Ref-ref c_{2}{2} versus pion event [p_{T}];Centrality (%);[p_{T}]_{#pi} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("c22DeltaPt/c22dmeanptKaonRefRef", "Ref-ref c_{2}{2} versus kaon event [p_{T}];Centrality (%);[p_{T}]_{K} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("c22DeltaPt/c22dmeanptProtonRefRef", "Ref-ref c_{2}{2} versus proton event [p_{T}];Centrality (%);[p_{T}]_{p} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + + // Select one PID correlation method at initialization so disabled-mode + // profiles are neither allocated nor filled. + if (switchsOpts.cfgC22DeltaPtUsePure.value) { + registry.add("c22DeltaPt/c22dmeanptPionPure", "Pion POI-POI c_{2}{2} versus pion event [p_{T}];Centrality (%);[p_{T}]_{#pi} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("c22DeltaPt/c22dmeanptKaonPure", "Kaon POI-POI c_{2}{2} versus kaon event [p_{T}];Centrality (%);[p_{T}]_{K} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("c22DeltaPt/c22dmeanptProtonPure", "Proton POI-POI c_{2}{2} versus proton event [p_{T}];Centrality (%);[p_{T}]_{p} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + } else { + // For each PID species, compare POI-ref and ref-ref using the same PID mean-pT axis. + registry.add("c22DeltaPt/c22dmeanptPionPOIRef", "Pion POI-ref c_{2}{2} versus pion event [p_{T}];Centrality (%);[p_{T}]_{#pi} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("c22DeltaPt/c22dmeanptKaonPOIRef", "Kaon POI-ref c_{2}{2} versus kaon event [p_{T}];Centrality (%);[p_{T}]_{K} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("c22DeltaPt/c22dmeanptProtonPOIRef", "Proton POI-ref c_{2}{2} versus proton event [p_{T}];Centrality (%);[p_{T}]_{p} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + } + } + registry.add("hInteractionRate", "", {HistType::kTH1D, {{1000, 0, 1000}}}); // end set bin label for eventcount @@ -639,40 +674,32 @@ struct PidFlowPtCorr { fFCPr->Initialize(oba4PID, axisMultiplicity, cfgFlowNbootstrap); // end init fFCPID - registry.add("c22dmeanpt", ";Centrality (%) ; C_{2}{2} ", {HistType::kTProfile2D, {axisMultiplicity, cfgaxisMeanPt}}); - registry.add("pi/c22dmeanpt", ";Centrality (%) ; C_{2}{2} ", {HistType::kTProfile2D, {axisMultiplicity, cfgaxisMeanPt}}); - registry.add("ka/c22dmeanpt", ";Centrality (%) ; C_{2}{2} ", {HistType::kTProfile2D, {axisMultiplicity, cfgaxisMeanPt}}); - registry.add("pr/c22dmeanpt", ";Centrality (%) ; C_{2}{2} ", {HistType::kTProfile2D, {axisMultiplicity, cfgaxisMeanPt}}); + if (switchsOpts.cfgAddMeanPtCentNbsHistograms.value) { + // TProfile3D axes: event mean pT, centrality, and bootstrap subsample. + registry.add("meanptCentNbs/hCharged", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hChargedMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - // init tprofile3d for <2'> - meanpt - // charged - registry.add("meanptCentNbs/hCharged", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hChargedMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - // end charged + registry.add("meanptCentNbs/hChargedPionWithNpair", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hChargedPionFull", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hPion", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hPionMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - // pid - registry.add("meanptCentNbs/hChargedPionWithNpair", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hChargedPionFull", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hPion", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hPionMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - - if (switchsOpts.cfgClosureTest.value != 0) { - registry.add("meanptCentNbs/hPionMeanptWeightC22pure", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hPionMeanptWeightMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hPionMeanptWeightC22prime", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - } + if (switchsOpts.cfgClosureTest.value != 0) { + registry.add("meanptCentNbs/hPionMeanptWeightC22pure", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hPionMeanptWeightMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hPionMeanptWeightC22prime", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + } - registry.add("meanptCentNbs/hChargedKaonWithNpair", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hChargedKaonFull", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hKaon", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hKaonMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hChargedKaonWithNpair", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hChargedKaonFull", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hKaon", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hKaonMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hChargedProtonWithNpair", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hChargedProtonFull", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hProton", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hProtonMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - // end pid - // end init tprofile3d for <2'> - meanpt + registry.add("meanptCentNbs/hChargedProtonWithNpair", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hChargedProtonFull", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hProton", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hProtonMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + } /// @note init QA plot for processQA if (switchsOpts.cfgProcessQAOutput.value) { @@ -1211,8 +1238,11 @@ struct PidFlowPtCorr { return; } - registry.fill(HIST("meanptCentNbs/hCharged"), ptSum / nch, cent, rndm * cfgFlowNbootstrap, val, nch * dnx); - registry.fill(HIST("meanptCentNbs/hChargedMeanpt"), ptSum / nch, cent, rndm * cfgFlowNbootstrap, ptSum / nch, 1.); + // These large TProfile3D objects are optional; keep FlowContainer output independent of this switch. + if (switchsOpts.cfgAddMeanPtCentNbsHistograms.value) { + registry.fill(HIST("meanptCentNbs/hCharged"), ptSum / nch, cent, rndm * cfgFlowNbootstrap, val, nch * dnx); + registry.fill(HIST("meanptCentNbs/hChargedMeanpt"), ptSum / nch, cent, rndm * cfgFlowNbootstrap, ptSum / nch, 1.); + } fFCCh->FillProfile("hMeanPtWeightFull", cent, (ptSum / nch), nch * dnx, rndm); } @@ -1256,15 +1286,17 @@ struct PidFlowPtCorr { return; } - registry.fill(HIST("meanptCentNbs/hPion"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, pidc22, nPid * npairPid); - registry.fill(HIST("meanptCentNbs/hChargedPionFull"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, val, dnx * nPid); - registry.fill(HIST("meanptCentNbs/hChargedPionWithNpair"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, val, dnx); - registry.fill(HIST("meanptCentNbs/hPionMeanpt"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, pidPtSum / nPid, 1.); + if (switchsOpts.cfgAddMeanPtCentNbsHistograms.value) { + registry.fill(HIST("meanptCentNbs/hPion"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, pidc22, nPid * npairPid); + registry.fill(HIST("meanptCentNbs/hChargedPionFull"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, val, dnx * nPid); + registry.fill(HIST("meanptCentNbs/hChargedPionWithNpair"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, val, dnx); + registry.fill(HIST("meanptCentNbs/hPionMeanpt"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, pidPtSum / nPid, 1.); + } fFCPi->FillProfile("hMeanPtWeightFull", cent, (pidPtSum / nPid), nPid * npairPid, rndm); fFCPi->FillProfile("hMeanPtWeightCharged", cent, (pidPtSum / nPid), dnx * nPid, rndm); - if (switchsOpts.cfgClosureTest.value != 0) { + if (switchsOpts.cfgAddMeanPtCentNbsHistograms.value && switchsOpts.cfgClosureTest.value != 0) { double npair4c22pure = fGFW->Calculate(corrconfigs.at(29), 0, true).real(); if (npair4c22pure > minVal4Float) { registry.fill(HIST("meanptCentNbs/hPionMeanptWeightC22pure"), @@ -1297,10 +1329,12 @@ struct PidFlowPtCorr { return; } - registry.fill(HIST("meanptCentNbs/hKaon"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, pidc22, nPid * npairPid); - registry.fill(HIST("meanptCentNbs/hChargedKaonFull"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, val, dnx * nPid); - registry.fill(HIST("meanptCentNbs/hChargedKaonWithNpair"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, val, dnx); - registry.fill(HIST("meanptCentNbs/hKaonMeanpt"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, pidPtSum / nPid, 1.); + if (switchsOpts.cfgAddMeanPtCentNbsHistograms.value) { + registry.fill(HIST("meanptCentNbs/hKaon"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, pidc22, nPid * npairPid); + registry.fill(HIST("meanptCentNbs/hChargedKaonFull"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, val, dnx * nPid); + registry.fill(HIST("meanptCentNbs/hChargedKaonWithNpair"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, val, dnx); + registry.fill(HIST("meanptCentNbs/hKaonMeanpt"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, pidPtSum / nPid, 1.); + } fFCKa->FillProfile("hMeanPtWeightFull", cent, (pidPtSum / nPid), nPid * npairPid, rndm); fFCKa->FillProfile("hMeanPtWeightCharged", cent, (pidPtSum / nPid), dnx * nPid, rndm); @@ -1319,10 +1353,12 @@ struct PidFlowPtCorr { return; } - registry.fill(HIST("meanptCentNbs/hProton"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, pidc22, nPid * npairPid); - registry.fill(HIST("meanptCentNbs/hChargedProtonFull"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, val, dnx * nPid); - registry.fill(HIST("meanptCentNbs/hChargedProtonWithNpair"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, val, dnx); - registry.fill(HIST("meanptCentNbs/hProtonMeanpt"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, pidPtSum / nPid, 1.); + if (switchsOpts.cfgAddMeanPtCentNbsHistograms.value) { + registry.fill(HIST("meanptCentNbs/hProton"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, pidc22, nPid * npairPid); + registry.fill(HIST("meanptCentNbs/hChargedProtonFull"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, val, dnx * nPid); + registry.fill(HIST("meanptCentNbs/hChargedProtonWithNpair"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, val, dnx); + registry.fill(HIST("meanptCentNbs/hProtonMeanpt"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, pidPtSum / nPid, 1.); + } fFCPr->FillProfile("hMeanPtWeightFull", cent, (pidPtSum / nPid), nPid * npairPid, rndm); fFCPr->FillProfile("hMeanPtWeightCharged", cent, (pidPtSum / nPid), dnx * nPid, rndm); @@ -1469,7 +1505,7 @@ struct PidFlowPtCorr { } template - void fillProfilePOIvnpt(const GFW::CorrConfig& corrconf, const ConstStr& tarName, const double& cent, const double& ptSum, const double& nch) + void fillProfilePOIvnpt(const GFW::CorrConfig& corrconf, const ConstStr& tarName, const double& cent, const double& ptSum, const double& nch, const double& rndm) { double dnx = 0.0, val = 0.0; dnx = fGFW->Calculate(corrconf, 0, true).real(); @@ -1479,7 +1515,30 @@ struct PidFlowPtCorr { val = fGFW->Calculate(corrconf, 0, false).real() / dnx; if (std::fabs(val) < 1) { - registry.fill(tarName, cent, ptSum / nch, val, dnx); + registry.fill(tarName, cent, ptSum / nch, rndm * cfgFlowNbootstrap, val, dnx); + } + } + + /** + * @brief Fill one event-level POI-ref value formed from the two eta orientations. + * @details The two correlators share one profile entry. Their numerators and pair + * counts are added before division. The PID mean pT is only the profile + * coordinate, so the profile is weighted by the combined pair count alone. + */ + template + void fillProfilePOIvnpt(const GFW::CorrConfig& corrconfA, const GFW::CorrConfig& corrconfB, const ConstStr& tarName, const double& cent, const double& ptSum, const double& nPid, const double& rndm) + { + const double dnxA = fGFW->Calculate(corrconfA, 0, true).real(); + const double dnxB = fGFW->Calculate(corrconfB, 0, true).real(); + const double dnx = dnxA + dnxB; + if (dnx == 0.) { + return; + } + + const double numerator = fGFW->Calculate(corrconfA, 0, false).real() + fGFW->Calculate(corrconfB, 0, false).real(); + const double val = numerator / dnx; + if (std::fabs(val) < 1.) { + registry.fill(tarName, cent, ptSum / nPid, rndm * cfgFlowNbootstrap, val, dnx); } } @@ -1922,6 +1981,9 @@ struct PidFlowPtCorr { case MyFunctionName::funcProcessPidResponseMatrix: registry.fill(HIST("hEventCount/processPidResponseMatrix"), position); break; + case MyFunctionName::funcProcessDataC22DeltaPt: + registry.fill(HIST("hEventCount/processDataC22DeltaPt"), position); + break; default: // LOGF(warning, "could not find event count graph"); @@ -2481,14 +2543,6 @@ struct PidFlowPtCorr { fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(33), cent, rndm, ptSum, nch, "covV3Pt"); fillFCvnpt(MyParticleType::kProton, corrconfigs.at(34), cent, rndm, ptSum, nch, "covV3Pt"); - fillProfilePOIvnpt(corrconfigs.at(0), HIST("c22dmeanpt"), cent, ptSum, nch); - fillProfilePOIvnpt(corrconfigs.at(5), HIST("pi/c22dmeanpt"), cent, ptSum, nch); - fillProfilePOIvnpt(corrconfigs.at(6), HIST("pi/c22dmeanpt"), cent, ptSum, nch); - fillProfilePOIvnpt(corrconfigs.at(7), HIST("ka/c22dmeanpt"), cent, ptSum, nch); - fillProfilePOIvnpt(corrconfigs.at(8), HIST("ka/c22dmeanpt"), cent, ptSum, nch); - fillProfilePOIvnpt(corrconfigs.at(9), HIST("pr/c22dmeanpt"), cent, ptSum, nch); - fillProfilePOIvnpt(corrconfigs.at(10), HIST("pr/c22dmeanpt"), cent, ptSum, nch); - fillFC4PtC22(cent, ptSum, nch, rndm); if (nPionWeighted > 0) { fillFC4PtC22(cent, rndm, MyParticleType::kPion, pionPtSum, nPionWeighted); @@ -2634,6 +2688,216 @@ struct PidFlowPtCorr { } PROCESS_SWITCH(PidFlowPtCorr, processData, "", true); + /** + * @brief Fill charged and identified-particle c22 versus event mean pT. + * @note Each profile uses the mean pT of the same particle sample on its pT axis: + * charged, pion, kaon, or proton. The corresponding FlowContainer hMeanPt + * observable provides the ensemble mean pT needed to convert that axis to + * delta[pT]/<[pT]> offline. + */ + void processDataC22DeltaPt(AodCollisions::iterator const& collision, aod::BCsWithTimestamps const&, AodTracks const& tracks) + { + if (!switchsOpts.cfgAddC22DeltaPtHistograms.value) { + return; + } + const double rndm = fRndm->Rndm(); + + /// @note event selection + registry.fill(HIST("hEventCount/processDataC22DeltaPt"), 0.5); + if (tracks.size() < 1) { + return; + } + + fGFW->Clear(); + const auto cent = getCentrality(collision); + if (!collision.sel8()) { + return; + } + registry.fill(HIST("hEventCount/processDataC22DeltaPt"), 1.5); + + auto bc = collision.bc_as(); + const double interactionRate = getInteractionRate(bc.timestamp(), bc.runNumber()); + if (!eventSelected(collision, cent, interactionRate, MyFunctionName::funcProcessDataC22DeltaPt)) { + return; + } + // event selection + + loadCorrections(bc.timestamp()); + + /// @note local density corr + const float vtxz = collision.posZ(); + + double psi2Est = 0.; + double psi3Est = 0.; + double psi4Est = 0.; + double v2 = 0.; + double v3 = 0.; + double v4 = 0.; + if (switchsOpts.cfgDoLocDenCorr.value) { + double q2x = 0.; + double q2y = 0.; + double q3x = 0.; + double q3y = 0.; + double q4x = 0.; + double q4y = 0.; + for (const auto& track : tracks) { + if (!isWithinRefPtRange(track.pt())) { + continue; + } + q2x += std::cos(2. * track.phi()); + q2y += std::sin(2. * track.phi()); + q3x += std::cos(3. * track.phi()); + q3y += std::sin(3. * track.phi()); + q4x += std::cos(4. * track.phi()); + q4y += std::sin(4. * track.phi()); + } + psi2Est = std::atan2(q2y, q2x) / 2.; + psi3Est = std::atan2(q3y, q3x) / 3.; + psi4Est = std::atan2(q4y, q4x) / 4.; + v2 = funcV2->Eval(cent); + v3 = funcV3->Eval(cent); + v4 = funcV4->Eval(cent); + } + // end local density corr + + // Event-wise mean-pT numerators and NUE-corrected particle counts. Charged + // particles use the reference pT range; each PID species uses its own POI pT range. + double ptSum = 0.; + double nch = 0.; + double pionPtSum = 0.; + double kaonPtSum = 0.; + double protonPtSum = 0.; + double nPionWeighted = 0.; + double nKaonWeighted = 0.; + double nProtonWeighted = 0.; + + for (const auto& track : tracks) { + // The mean-pT samples use the same track-quality and eta selections. The pT + // selection and NUE correction are then applied independently for charged and PID. + if (!trackSelectedForFlow(track) || std::fabs(track.eta()) >= trkQualityOpts.cfgRangeEta.value) { + continue; + } + + if (isWithinRefPtRange(track.pt())) { + float weff = 1.f; + setParticleNUEWeight(weff, track, cent); + nch += weff; + ptSum += weff * track.pt(); + } + + const int pid = getPidConfigurable(track); + if (!isWithinPOIPtRange(pid, track.pt())) { + continue; + } + + float weffPid = 1.f; + setParticleNUEWeight(weffPid, track, cent, pid); + if (pid == MyParticleType::kPion) { + nPionWeighted += weffPid; + pionPtSum += weffPid * track.pt(); + } else if (pid == MyParticleType::kKaon) { + nKaonWeighted += weffPid; + kaonPtSum += weffPid * track.pt(); + } else if (pid == MyParticleType::kProton) { + nProtonWeighted += weffPid; + protonPtSum += weffPid * track.pt(); + } + } + if (nch <= 0.) { + return; + } + + // Fill the GFW regions in a separate pass. Bit 1 is the charged reference + // sample; bits 2, 4, and 8 are pion, kaon, and proton POIs, respectively. + for (const auto& track : tracks) { + if (!trackSelectedForFlow(track)) { + continue; + } + + float weff = 1.f; + float wacc = 1.f; + setParticleNUEWeight(weff, track, cent); + setParticleNUAWeight(wacc, track, vtxz); + + if (isWithinRefPtRange(track.pt())) { + if (switchsOpts.cfgDoLocDenCorr.value) { + const double fphi = 1. + 2. * (v2 * std::cos(2. * (track.phi() - psi2Est)) + + v3 * std::cos(3. * (track.phi() - psi3Est)) + + v4 * std::cos(4. * (track.phi() - psi4Est))); + const int ptBinForEff = hFindPtBin->FindBin(track.pt()); + if (ptBinForEff >= 1 && ptBinForEff <= hFindPtBin->GetNbinsX()) { + const double localDensityEff = funcEff[ptBinForEff - 1]->Eval(fphi * tracks.size()); + if (localDensityEff > 0.) { + weff /= localDensityEff; + } + } + } + /// @note passed selection: global cut + pt cut + fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, 1); + } + + const int pid = getPidConfigurable(track); + if (!isWithinPOIPtRange(pid, track.pt())) { + continue; + } + + float weffPid = 1.f; + float waccPid = 1.f; + setParticleNUEWeight(weffPid, track, cent, pid); + setParticleNUAWeight(waccPid, track, vtxz, pid); + + if (pid == MyParticleType::kPion) { + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, 2); + } else if (pid == MyParticleType::kKaon) { + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, 4); + } else if (pid == MyParticleType::kProton) { + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, 8); + } + } + + // All profiles from one event use the same bootstrap subsample. Mean-pT profiles + // retain the NUE-corrected particle-count weight used by FlowContainer hMeanPt. + registry.fill(HIST("c22DeltaPt/hMeanPtCharged"), cent, rndm * cfgFlowNbootstrap, ptSum / nch, nch); + if (nPionWeighted > 0.) { + registry.fill(HIST("c22DeltaPt/hMeanPtPion"), cent, rndm * cfgFlowNbootstrap, pionPtSum / nPionWeighted, nPionWeighted); + fillProfilePOIvnpt(corrconfigs.at(0), HIST("c22DeltaPt/c22dmeanptPionRefRef"), cent, pionPtSum, nPionWeighted, rndm); + } + if (nKaonWeighted > 0.) { + registry.fill(HIST("c22DeltaPt/hMeanPtKaon"), cent, rndm * cfgFlowNbootstrap, kaonPtSum / nKaonWeighted, nKaonWeighted); + fillProfilePOIvnpt(corrconfigs.at(0), HIST("c22DeltaPt/c22dmeanptKaonRefRef"), cent, kaonPtSum, nKaonWeighted, rndm); + } + if (nProtonWeighted > 0.) { + registry.fill(HIST("c22DeltaPt/hMeanPtProton"), cent, rndm * cfgFlowNbootstrap, protonPtSum / nProtonWeighted, nProtonWeighted); + fillProfilePOIvnpt(corrconfigs.at(0), HIST("c22DeltaPt/c22dmeanptProtonRefRef"), cent, protonPtSum, nProtonWeighted, rndm); + } + + // Charged and PID-binned ref-ref are common to both modes. The numerator is + // selected between PID Pure and POI-ref by cfgC22DeltaPtUsePure. + fillProfilePOIvnpt(corrconfigs.at(0), HIST("c22DeltaPt/c22dmeanptCharged"), cent, ptSum, nch, rndm); + if (switchsOpts.cfgC22DeltaPtUsePure.value) { + if (nPionWeighted > 0.) { + fillProfilePOIvnpt(corrconfigs.at(29), HIST("c22DeltaPt/c22dmeanptPionPure"), cent, pionPtSum, nPionWeighted, rndm); + } + if (nKaonWeighted > 0.) { + fillProfilePOIvnpt(corrconfigs.at(30), HIST("c22DeltaPt/c22dmeanptKaonPure"), cent, kaonPtSum, nKaonWeighted, rndm); + } + if (nProtonWeighted > 0.) { + fillProfilePOIvnpt(corrconfigs.at(31), HIST("c22DeltaPt/c22dmeanptProtonPure"), cent, protonPtSum, nProtonWeighted, rndm); + } + } else { + if (nPionWeighted > 0.) { + fillProfilePOIvnpt(corrconfigs.at(5), corrconfigs.at(6), HIST("c22DeltaPt/c22dmeanptPionPOIRef"), cent, pionPtSum, nPionWeighted, rndm); + } + if (nKaonWeighted > 0.) { + fillProfilePOIvnpt(corrconfigs.at(7), corrconfigs.at(8), HIST("c22DeltaPt/c22dmeanptKaonPOIRef"), cent, kaonPtSum, nKaonWeighted, rndm); + } + if (nProtonWeighted > 0.) { + fillProfilePOIvnpt(corrconfigs.at(9), corrconfigs.at(10), HIST("c22DeltaPt/c22dmeanptProtonPOIRef"), cent, protonPtSum, nProtonWeighted, rndm); + } + } + } + PROCESS_SWITCH(PidFlowPtCorr, processDataC22DeltaPt, "Fill c22dmeanpt profiles", false); + /** * @brief Run the flow calculation on generated MC particles for a closure test. * @note Reconstructed collisions are only used to obtain the centrality. The selection is @@ -2647,7 +2911,9 @@ struct PidFlowPtCorr { FilteredTracksWithMCLabel const&) { registry.fill(HIST("hEventCount/processData"), 0.5); - if (collisions.size() <= 0 || mcParticles.size() <= 0) { + // A generated event must be associated with exactly one reconstructed collision. + // Otherwise the same truth particles would be filled more than once. + if (collisions.size() != 1 || mcParticles.size() <= 0) { return; } @@ -2855,14 +3121,6 @@ struct PidFlowPtCorr { fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(33), cent, rndm, ptSum, nch, "covV3Pt"); fillFCvnpt(MyParticleType::kProton, corrconfigs.at(34), cent, rndm, ptSum, nch, "covV3Pt"); - fillProfilePOIvnpt(corrconfigs.at(0), HIST("c22dmeanpt"), cent, ptSum, nch); - fillProfilePOIvnpt(corrconfigs.at(5), HIST("pi/c22dmeanpt"), cent, ptSum, nch); - fillProfilePOIvnpt(corrconfigs.at(6), HIST("pi/c22dmeanpt"), cent, ptSum, nch); - fillProfilePOIvnpt(corrconfigs.at(7), HIST("ka/c22dmeanpt"), cent, ptSum, nch); - fillProfilePOIvnpt(corrconfigs.at(8), HIST("ka/c22dmeanpt"), cent, ptSum, nch); - fillProfilePOIvnpt(corrconfigs.at(9), HIST("pr/c22dmeanpt"), cent, ptSum, nch); - fillProfilePOIvnpt(corrconfigs.at(10), HIST("pr/c22dmeanpt"), cent, ptSum, nch); - fillFC4PtC22(cent, ptSum, nch, rndm); if (nPionWeighted > 0.) { fillFC4PtC22(cent, rndm, MyParticleType::kPion, pionPtSum, nPionWeighted); @@ -3371,7 +3629,9 @@ struct PidFlowPtCorr { FilteredTracksWithMCLabel const& tracks) { registry.fill(HIST("hEventCount/processSim"), 0.5); - if (collisions.size() <= 0) { + // Keep the generated denominator aligned with one reconstructed collision. + // Multiple associations would otherwise fill the same MC particles repeatedly. + if (collisions.size() != 1) { return; } From 56ae29e25144b1497e870d74abe9625dca868627 Mon Sep 17 00:00:00 2001 From: "Q.Y. Xia" <91366503+huinaibing@users.noreply.github.com> Date: Thu, 13 Aug 2026 19:44:19 +0800 Subject: [PATCH 2/7] update file in order to redo checks as the check error is caused by timeout --- PWGCF/Flow/Tasks/pidFlowPtCorr.cxx | 1 - 1 file changed, 1 deletion(-) diff --git a/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx b/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx index 35841923c31..d5bdfa90f39 100644 --- a/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx +++ b/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx @@ -134,7 +134,6 @@ struct PidFlowPtCorr { Configurable> cfgAcceptancePath{"cfgAcceptancePath", (std::vector{"Users/f/fcui/NUA/NUAREFPartical", "Users/f/fcui/NUA/NUAK0s", "Users/f/fcui/NUA/NUALambda", "Users/f/fcui/NUA/NUAXi", "Users/f/fcui/NUA/NUAOmega"}), "CCDB path to acceptance object"}; Configurable> cfgAcceptancePathWithPt{"cfgAcceptancePathWithPt", (std::vector{"Users/f/fcui/NUA/NUAREFParticalWithPt"}), "CCDB path to acceptance THnSparse(phi,eta,vz,pt) object, same content as cfgAcceptancePath but with an extra pt axis"}; - Configurable> cfgEfficiencyPath{"cfgEfficiencyPath", (std::vector{"PathtoRef"}), "CCDB path to efficiency object"}; } correctionPathOpts; From c963572969441905ad235e0ac013f8ac5dda86b4 Mon Sep 17 00:00:00 2001 From: "Q.Y. Xia" <91366503+huinaibing@users.noreply.github.com> Date: Thu, 13 Aug 2026 20:17:57 +0800 Subject: [PATCH 3/7] add a braket to init the val --- PWGCF/Flow/Tasks/pidFlowPtCorr.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx b/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx index d5bdfa90f39..fd53b5a7d5f 100644 --- a/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx +++ b/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx @@ -1659,7 +1659,7 @@ struct PidFlowPtCorr { if (!hist) { return 1; } - std::array bins; + std::array bins{}; bins[0] = hist->GetAxis(0)->FindBin(phi); bins[1] = hist->GetAxis(1)->FindBin(eta); bins[2] = hist->GetAxis(2)->FindBin(vz); From fdcaf51bd333046c3f47200380173b056366cbf1 Mon Sep 17 00:00:00 2001 From: huinaibing Date: Fri, 14 Aug 2026 17:28:37 +0800 Subject: [PATCH 4/7] add unidentified particle rho calculation; improve code readability --- PWGCF/Flow/Tasks/pidFlowPtCorr.cxx | 987 +++++++++++++++++++---------- 1 file changed, 649 insertions(+), 338 deletions(-) diff --git a/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx b/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx index fd53b5a7d5f..8da7295be05 100644 --- a/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx +++ b/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx @@ -62,6 +62,7 @@ #include #include #include +#include #include #include #include @@ -134,6 +135,7 @@ struct PidFlowPtCorr { Configurable> cfgAcceptancePath{"cfgAcceptancePath", (std::vector{"Users/f/fcui/NUA/NUAREFPartical", "Users/f/fcui/NUA/NUAK0s", "Users/f/fcui/NUA/NUALambda", "Users/f/fcui/NUA/NUAXi", "Users/f/fcui/NUA/NUAOmega"}), "CCDB path to acceptance object"}; Configurable> cfgAcceptancePathWithPt{"cfgAcceptancePathWithPt", (std::vector{"Users/f/fcui/NUA/NUAREFParticalWithPt"}), "CCDB path to acceptance THnSparse(phi,eta,vz,pt) object, same content as cfgAcceptancePath but with an extra pt axis"}; + Configurable> cfgEfficiencyPath{"cfgEfficiencyPath", (std::vector{"PathtoRef"}), "CCDB path to efficiency object"}; } correctionPathOpts; @@ -157,6 +159,13 @@ struct PidFlowPtCorr { Configurable cfgAddC22DeltaPtHistograms{"cfgAddC22DeltaPtHistograms", false, "Add histograms for processDataC22DeltaPt; enable together with processDataC22DeltaPt"}; Configurable cfgC22DeltaPtUsePure{"cfgC22DeltaPtUsePure", false, "true: use PID POI-POI Pure profiles; false: use PID POI-ref and ref-ref profiles"}; Configurable cfgAddMeanPtCentNbsHistograms{"cfgAddMeanPtCentNbsHistograms", false, "Add meanptCentNbs TProfile3D histograms"}; + // These switches suppress result allocation and filling only. Charged reference + // Q-vectors are still calculated when a PID or unidentified output needs them. + Configurable cfgOutputCharged{"cfgOutputCharged", true, "Output charged-particle flow, mean-pT, and c22DeltaPt observables"}; + Configurable cfgOutputPion{"cfgOutputPion", true, "Output pion flow, mean-pT, and c22DeltaPt observables"}; + Configurable cfgOutputKaon{"cfgOutputKaon", true, "Output kaon flow, mean-pT, and c22DeltaPt observables"}; + Configurable cfgOutputProton{"cfgOutputProton", true, "Output proton flow, mean-pT, and c22DeltaPt observables"}; + Configurable cfgOutputUnidentified{"cfgOutputUnidentified", true, "Output PID-failed or ambiguous flow, mean-pT, and c22DeltaPt observables"}; Configurable cfgProcessQAOutput{"cfgProcessQAOutput", false, "QA plots for processQA"}; Configurable cfgUseNUAWithPt{"cfgUseNUAWithPt", false, "false: use original GFWWeights (phi,eta,vz) NUA; true: use THnSparse (phi,eta,vz,pt) NUA loaded from cfgAcceptancePathWithPt"}; @@ -282,6 +291,7 @@ struct PidFlowPtCorr { OutputObj fFCPi{FlowContainer("FlowContainerPi")}; OutputObj fFCKa{FlowContainer("FlowContainerKa")}; OutputObj fFCPr{FlowContainer("FlowContainerPr")}; + OutputObj fFCUnidentified{FlowContainer("FlowContainerUnidentified")}; // end val used for bootstrap // define global variables @@ -300,9 +310,127 @@ struct PidFlowPtCorr { kPion, kKaon, kProton, + kUnidentified, kNumberOfParticles }; + // Keep the vector layout in one named index table. The nested particle groups + // make each corrconfigs access describe both the particle and correlator type. + struct CorrConfigIndex { + struct Charged { + static constexpr std::size_t kC22Gap = 0; + static constexpr std::size_t kC24 = 1; + static constexpr std::size_t kC22Full = 2; + static constexpr std::size_t kC32Gap = 3; + static constexpr std::size_t kC34Gap = 4; + }; + + struct Pion { + static constexpr std::size_t kC22GapA = 5; + static constexpr std::size_t kC22GapB = 6; + static constexpr std::size_t kC24A = 11; + static constexpr std::size_t kC24B = 12; + static constexpr std::size_t kC32GapA = 17; + static constexpr std::size_t kC32GapB = 18; + static constexpr std::size_t kC34A = 23; + static constexpr std::size_t kC34B = 24; + static constexpr std::size_t kC22Pure = 29; + static constexpr std::size_t kC32Pure = 32; + static constexpr std::size_t kC22FullA = 35; + static constexpr std::size_t kC22FullB = 36; + }; + + struct Kaon { + static constexpr std::size_t kC22GapA = 7; + static constexpr std::size_t kC22GapB = 8; + static constexpr std::size_t kC24A = 13; + static constexpr std::size_t kC24B = 14; + static constexpr std::size_t kC32GapA = 19; + static constexpr std::size_t kC32GapB = 20; + static constexpr std::size_t kC34A = 25; + static constexpr std::size_t kC34B = 26; + static constexpr std::size_t kC22Pure = 30; + static constexpr std::size_t kC32Pure = 33; + static constexpr std::size_t kC22FullA = 37; + static constexpr std::size_t kC22FullB = 38; + }; + + struct Proton { + static constexpr std::size_t kC22GapA = 9; + static constexpr std::size_t kC22GapB = 10; + static constexpr std::size_t kC24A = 15; + static constexpr std::size_t kC24B = 16; + static constexpr std::size_t kC32GapA = 21; + static constexpr std::size_t kC32GapB = 22; + static constexpr std::size_t kC34A = 27; + static constexpr std::size_t kC34B = 28; + static constexpr std::size_t kC22Pure = 31; + static constexpr std::size_t kC32Pure = 34; + static constexpr std::size_t kC22FullA = 39; + static constexpr std::size_t kC22FullB = 40; + }; + + // Unidentified correlations are appended after the original configurations + // so the charged and identified-particle vector layout remains unchanged. + struct Unidentified { + static constexpr std::size_t kC22GapA = 41; + static constexpr std::size_t kC22GapB = 42; + static constexpr std::size_t kC24A = 43; + static constexpr std::size_t kC24B = 44; + static constexpr std::size_t kC22Pure = 45; + static constexpr std::size_t kC22FullA = 46; + static constexpr std::size_t kC22FullB = 47; + }; + + static constexpr std::size_t kCount = 48; + }; + + // GFW region bitmasks are grouped by particle type and region role. POI and + // overlap use distinct bits because the overlap weight can differ from POI. + struct GFWBitMask { + struct Charged { + static constexpr int kReference = 1 << 0; + }; + + struct Pion { + static constexpr int kPOI = 1 << 1; + static constexpr int kOverlap = 1 << 4; + }; + + struct Kaon { + static constexpr int kPOI = 1 << 2; + static constexpr int kOverlap = 1 << 5; + }; + + struct Proton { + static constexpr int kPOI = 1 << 3; + static constexpr int kOverlap = 1 << 6; + }; + + struct Unidentified { + static constexpr int kPOI = 1 << 7; + static constexpr int kOverlap = 1 << 8; + }; + }; + + bool isParticleOutputEnabled(MyParticleType type) + { + switch (type) { + case MyParticleType::kCharged: + return switchsOpts.cfgOutputCharged.value; + case MyParticleType::kPion: + return switchsOpts.cfgOutputPion.value; + case MyParticleType::kKaon: + return switchsOpts.cfgOutputKaon.value; + case MyParticleType::kProton: + return switchsOpts.cfgOutputProton.value; + case MyParticleType::kUnidentified: + return switchsOpts.cfgOutputUnidentified.value; + default: + return false; + } + } + enum CentEstimators { kCentFT0C = 0, kCentFT0CVariant1, @@ -569,32 +697,61 @@ struct PidFlowPtCorr { if (switchsOpts.cfgAddC22DeltaPtHistograms.value) { registry.addClone("hEventCount/processData", "hEventCount/processDataC22DeltaPt"); - registry.add("c22DeltaPt/c22dmeanptCharged", "Charged c_{2}{2} versus charged event [p_{T}];Centrality (%);[p_{T}]_{ch} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); // Store the ensemble mean pT required for the offline delta[pT]/<[pT]> // transformation. The profile weight is the NUE-corrected particle count. - registry.add("c22DeltaPt/hMeanPtCharged", "Charged mean p_{T};Centrality (%);Bootstrap subsample;[p_{T}]_{ch} (GeV/#it{c})", {HistType::kTProfile2D, {axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("c22DeltaPt/hMeanPtPion", "Pion mean p_{T};Centrality (%);Bootstrap subsample;[p_{T}]_{#pi} (GeV/#it{c})", {HistType::kTProfile2D, {axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("c22DeltaPt/hMeanPtKaon", "Kaon mean p_{T};Centrality (%);Bootstrap subsample;[p_{T}]_{K} (GeV/#it{c})", {HistType::kTProfile2D, {axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("c22DeltaPt/hMeanPtProton", "Proton mean p_{T};Centrality (%);Bootstrap subsample;[p_{T}]_{p} (GeV/#it{c})", {HistType::kTProfile2D, {axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + if (switchsOpts.cfgOutputCharged.value) { + registry.add("c22DeltaPt/c22dmeanptCharged", "Charged c_{2}{2} versus charged event [p_{T}];Centrality (%);[p_{T}]_{ch} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("c22DeltaPt/hMeanPtCharged", "Charged mean p_{T};Centrality (%);Bootstrap subsample;[p_{T}]_{ch} (GeV/#it{c})", {HistType::kTProfile2D, {axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + } + if (switchsOpts.cfgOutputPion.value) { + registry.add("c22DeltaPt/hMeanPtPion", "Pion mean p_{T};Centrality (%);Bootstrap subsample;[p_{T}]_{#pi} (GeV/#it{c})", {HistType::kTProfile2D, {axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("c22DeltaPt/c22dmeanptPionRefRef", "Ref-ref c_{2}{2} versus pion event [p_{T}];Centrality (%);[p_{T}]_{#pi} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + } + if (switchsOpts.cfgOutputKaon.value) { + registry.add("c22DeltaPt/hMeanPtKaon", "Kaon mean p_{T};Centrality (%);Bootstrap subsample;[p_{T}]_{K} (GeV/#it{c})", {HistType::kTProfile2D, {axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("c22DeltaPt/c22dmeanptKaonRefRef", "Ref-ref c_{2}{2} versus kaon event [p_{T}];Centrality (%);[p_{T}]_{K} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + } + if (switchsOpts.cfgOutputProton.value) { + registry.add("c22DeltaPt/hMeanPtProton", "Proton mean p_{T};Centrality (%);Bootstrap subsample;[p_{T}]_{p} (GeV/#it{c})", {HistType::kTProfile2D, {axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("c22DeltaPt/c22dmeanptProtonRefRef", "Ref-ref c_{2}{2} versus proton event [p_{T}];Centrality (%);[p_{T}]_{p} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + } + if (switchsOpts.cfgOutputUnidentified.value) { + registry.add("c22DeltaPt/hMeanPtUnidentified", "Unidentified mean p_{T};Centrality (%);Bootstrap subsample;[p_{T}]_{unidentified} (GeV/#it{c})", {HistType::kTProfile2D, {axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("c22DeltaPt/c22dmeanptUnidentifiedRefRef", "Ref-ref c_{2}{2} versus unidentified event [p_{T}];Centrality (%);[p_{T}]_{unidentified} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + } // Ref-ref is required in either PID mode: Pure/ref-ref or POI-ref/ref-ref. // Separate copies are binned by the event mean pT of each PID species. - registry.add("c22DeltaPt/c22dmeanptPionRefRef", "Ref-ref c_{2}{2} versus pion event [p_{T}];Centrality (%);[p_{T}]_{#pi} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("c22DeltaPt/c22dmeanptKaonRefRef", "Ref-ref c_{2}{2} versus kaon event [p_{T}];Centrality (%);[p_{T}]_{K} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("c22DeltaPt/c22dmeanptProtonRefRef", "Ref-ref c_{2}{2} versus proton event [p_{T}];Centrality (%);[p_{T}]_{p} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); - // Select one PID correlation method at initialization so disabled-mode // profiles are neither allocated nor filled. if (switchsOpts.cfgC22DeltaPtUsePure.value) { - registry.add("c22DeltaPt/c22dmeanptPionPure", "Pion POI-POI c_{2}{2} versus pion event [p_{T}];Centrality (%);[p_{T}]_{#pi} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("c22DeltaPt/c22dmeanptKaonPure", "Kaon POI-POI c_{2}{2} versus kaon event [p_{T}];Centrality (%);[p_{T}]_{K} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("c22DeltaPt/c22dmeanptProtonPure", "Proton POI-POI c_{2}{2} versus proton event [p_{T}];Centrality (%);[p_{T}]_{p} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + if (switchsOpts.cfgOutputPion.value) { + registry.add("c22DeltaPt/c22dmeanptPionPure", "Pion POI-POI c_{2}{2} versus pion event [p_{T}];Centrality (%);[p_{T}]_{#pi} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + } + if (switchsOpts.cfgOutputKaon.value) { + registry.add("c22DeltaPt/c22dmeanptKaonPure", "Kaon POI-POI c_{2}{2} versus kaon event [p_{T}];Centrality (%);[p_{T}]_{K} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + } + if (switchsOpts.cfgOutputProton.value) { + registry.add("c22DeltaPt/c22dmeanptProtonPure", "Proton POI-POI c_{2}{2} versus proton event [p_{T}];Centrality (%);[p_{T}]_{p} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + } + if (switchsOpts.cfgOutputUnidentified.value) { + registry.add("c22DeltaPt/c22dmeanptUnidentifiedPure", "Unidentified POI-POI c_{2}{2} versus unidentified event [p_{T}];Centrality (%);[p_{T}]_{unidentified} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + } } else { // For each PID species, compare POI-ref and ref-ref using the same PID mean-pT axis. - registry.add("c22DeltaPt/c22dmeanptPionPOIRef", "Pion POI-ref c_{2}{2} versus pion event [p_{T}];Centrality (%);[p_{T}]_{#pi} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("c22DeltaPt/c22dmeanptKaonPOIRef", "Kaon POI-ref c_{2}{2} versus kaon event [p_{T}];Centrality (%);[p_{T}]_{K} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("c22DeltaPt/c22dmeanptProtonPOIRef", "Proton POI-ref c_{2}{2} versus proton event [p_{T}];Centrality (%);[p_{T}]_{p} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + if (switchsOpts.cfgOutputPion.value) { + registry.add("c22DeltaPt/c22dmeanptPionPOIRef", "Pion POI-ref c_{2}{2} versus pion event [p_{T}];Centrality (%);[p_{T}]_{#pi} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + } + if (switchsOpts.cfgOutputKaon.value) { + registry.add("c22DeltaPt/c22dmeanptKaonPOIRef", "Kaon POI-ref c_{2}{2} versus kaon event [p_{T}];Centrality (%);[p_{T}]_{K} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + } + if (switchsOpts.cfgOutputProton.value) { + registry.add("c22DeltaPt/c22dmeanptProtonPOIRef", "Proton POI-ref c_{2}{2} versus proton event [p_{T}];Centrality (%);[p_{T}]_{p} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + } + if (switchsOpts.cfgOutputUnidentified.value) { + registry.add("c22DeltaPt/c22dmeanptUnidentifiedPOIRef", "Unidentified POI-ref c_{2}{2} versus unidentified event [p_{T}];Centrality (%);[p_{T}]_{unidentified} (GeV/#it{c});Bootstrap subsample;c_{2}{2}", {HistType::kTProfile3D, {axisMultiplicity, cfgaxisMeanPt, meanptC22GraphOpts.cfgaxisBootstrap}}); + } } } @@ -649,8 +806,10 @@ struct PidFlowPtCorr { // end fill TObjArray for charged // init fFCCh - fFCCh->SetName("FlowContainerCharged"); - fFCCh->Initialize(oba4Ch, axisMultiplicity, cfgFlowNbootstrap); + if (switchsOpts.cfgOutputCharged.value) { + fFCCh->SetName("FlowContainerCharged"); + fFCCh->Initialize(oba4Ch, axisMultiplicity, cfgFlowNbootstrap); + } // end init fFCCh // init fFCPID @@ -663,41 +822,59 @@ struct PidFlowPtCorr { oba4PID->Add(new TNamed("hMeanPtWeightCharged", "hMeanPtWeightCharged")); - fFCPi->SetName("FlowContainerPi"); - fFCPi->Initialize(oba4PID, axisMultiplicity, cfgFlowNbootstrap); - - fFCKa->SetName("FlowContainerKa"); - fFCKa->Initialize(oba4PID, axisMultiplicity, cfgFlowNbootstrap); - - fFCPr->SetName("FlowContainerPr"); - fFCPr->Initialize(oba4PID, axisMultiplicity, cfgFlowNbootstrap); + if (switchsOpts.cfgOutputPion.value) { + fFCPi->SetName("FlowContainerPi"); + fFCPi->Initialize(oba4PID, axisMultiplicity, cfgFlowNbootstrap); + } + if (switchsOpts.cfgOutputKaon.value) { + fFCKa->SetName("FlowContainerKa"); + fFCKa->Initialize(oba4PID, axisMultiplicity, cfgFlowNbootstrap); + } + if (switchsOpts.cfgOutputProton.value) { + fFCPr->SetName("FlowContainerPr"); + fFCPr->Initialize(oba4PID, axisMultiplicity, cfgFlowNbootstrap); + } + if (switchsOpts.cfgOutputUnidentified.value) { + fFCUnidentified->SetName("FlowContainerUnidentified"); + fFCUnidentified->Initialize(oba4PID, axisMultiplicity, cfgFlowNbootstrap); + } // end init fFCPID if (switchsOpts.cfgAddMeanPtCentNbsHistograms.value) { // TProfile3D axes: event mean pT, centrality, and bootstrap subsample. - registry.add("meanptCentNbs/hCharged", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hChargedMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - - registry.add("meanptCentNbs/hChargedPionWithNpair", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hChargedPionFull", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hPion", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hPionMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - - if (switchsOpts.cfgClosureTest.value != 0) { - registry.add("meanptCentNbs/hPionMeanptWeightC22pure", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hPionMeanptWeightMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hPionMeanptWeightC22prime", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + if (switchsOpts.cfgOutputCharged.value) { + registry.add("meanptCentNbs/hCharged", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hChargedMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + } + if (switchsOpts.cfgOutputPion.value) { + registry.add("meanptCentNbs/hChargedPionWithNpair", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hChargedPionFull", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hPion", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hPionMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + if (switchsOpts.cfgClosureTest.value != 0) { + registry.add("meanptCentNbs/hPionMeanptWeightC22pure", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hPionMeanptWeightMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hPionMeanptWeightC22prime", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + } + } + if (switchsOpts.cfgOutputKaon.value) { + registry.add("meanptCentNbs/hChargedKaonWithNpair", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hChargedKaonFull", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hKaon", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hKaonMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + } + if (switchsOpts.cfgOutputProton.value) { + registry.add("meanptCentNbs/hChargedProtonWithNpair", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hChargedProtonFull", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hProton", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hProtonMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + } + if (switchsOpts.cfgOutputUnidentified.value) { + registry.add("meanptCentNbs/hChargedUnidentifiedWithNpair", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hChargedUnidentifiedFull", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hUnidentified", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); + registry.add("meanptCentNbs/hUnidentifiedMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); } - - registry.add("meanptCentNbs/hChargedKaonWithNpair", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hChargedKaonFull", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hKaon", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hKaonMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - - registry.add("meanptCentNbs/hChargedProtonWithNpair", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hChargedProtonFull", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hProton", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); - registry.add("meanptCentNbs/hProtonMeanpt", "", {HistType::kTProfile3D, {cfgaxisMeanPt, axisMultiplicity, meanptC22GraphOpts.cfgaxisBootstrap}}); } /// @note init QA plot for processQA @@ -726,42 +903,48 @@ struct PidFlowPtCorr { // Data stored in fGFW double etaMax = trkQualityOpts.cfgCutEta.value; double etaGap = cfgEtaGap; - // bit mask: 0000001 for CHARGED PARTICLES - fGFW->AddRegion("reffull", -etaMax, etaMax, 1, 1); // ("name", etamin, etamax, ptbinnum, bitmask)eta region -0.8 to 0.8 - fGFW->AddRegion("refN08", -etaMax, -etaGap, 1, 1); - fGFW->AddRegion("refP08", etaGap, etaMax, 1, 1); - fGFW->AddRegion("refN", -etaMax, 0, 1, 1); - fGFW->AddRegion("refP", 0, etaMax, 1, 1); - - // bit mask: 0000010 for PIONS - fGFW->AddRegion("poiPiN08", -etaMax, -etaGap, 1, 2); - fGFW->AddRegion("poiPiP08", etaGap, etaMax, 1, 2); - fGFW->AddRegion("poiPiN", -etaMax, 0, 1, 2); - fGFW->AddRegion("poiPiP", 0, etaMax, 1, 2); - - // bit mask: 0010000 for overlap pions - fGFW->AddRegion("olPiN", -etaMax, 0, 1, 16); - fGFW->AddRegion("olPiP", 0, etaMax, 1, 16); - - // bit mask: 0000100 for KAONS - fGFW->AddRegion("poiKaN08", -etaMax, -etaGap, 1, 4); - fGFW->AddRegion("poiKaP08", etaGap, etaMax, 1, 4); - fGFW->AddRegion("poiKaN", -etaMax, 0, 1, 4); - fGFW->AddRegion("poiKaP", 0, etaMax, 1, 4); - - // bit mask: 0100000 for overlap kaons - fGFW->AddRegion("olKaN", -etaMax, 0, 1, 32); - fGFW->AddRegion("olKaP", 0, etaMax, 1, 32); - - // bit mask: 0001000 for PROTONS - fGFW->AddRegion("poiPrN08", -etaMax, -etaGap, 1, 8); - fGFW->AddRegion("poiPrP08", etaGap, etaMax, 1, 8); - fGFW->AddRegion("poiPrN", -etaMax, 0, 1, 8); - fGFW->AddRegion("poiPrP", 0, etaMax, 1, 8); - - // bit mask: 1000000 for overlap protons - fGFW->AddRegion("olPrN", -etaMax, 0, 1, 64); - fGFW->AddRegion("olPrP", 0, etaMax, 1, 64); + // Charged reference regions. + fGFW->AddRegion("reffull", -etaMax, etaMax, 1, GFWBitMask::Charged::kReference); // ("name", etamin, etamax, ptbinnum, bitmask)eta region -0.8 to 0.8 + fGFW->AddRegion("refN08", -etaMax, -etaGap, 1, GFWBitMask::Charged::kReference); + fGFW->AddRegion("refP08", etaGap, etaMax, 1, GFWBitMask::Charged::kReference); + fGFW->AddRegion("refN", -etaMax, 0, 1, GFWBitMask::Charged::kReference); + fGFW->AddRegion("refP", 0, etaMax, 1, GFWBitMask::Charged::kReference); + + // Pion POI and overlap regions. + fGFW->AddRegion("poiPiN08", -etaMax, -etaGap, 1, GFWBitMask::Pion::kPOI); + fGFW->AddRegion("poiPiP08", etaGap, etaMax, 1, GFWBitMask::Pion::kPOI); + fGFW->AddRegion("poiPiN", -etaMax, 0, 1, GFWBitMask::Pion::kPOI); + fGFW->AddRegion("poiPiP", 0, etaMax, 1, GFWBitMask::Pion::kPOI); + + fGFW->AddRegion("olPiN", -etaMax, 0, 1, GFWBitMask::Pion::kOverlap); + fGFW->AddRegion("olPiP", 0, etaMax, 1, GFWBitMask::Pion::kOverlap); + + // Kaon POI and overlap regions. + fGFW->AddRegion("poiKaN08", -etaMax, -etaGap, 1, GFWBitMask::Kaon::kPOI); + fGFW->AddRegion("poiKaP08", etaGap, etaMax, 1, GFWBitMask::Kaon::kPOI); + fGFW->AddRegion("poiKaN", -etaMax, 0, 1, GFWBitMask::Kaon::kPOI); + fGFW->AddRegion("poiKaP", 0, etaMax, 1, GFWBitMask::Kaon::kPOI); + + fGFW->AddRegion("olKaN", -etaMax, 0, 1, GFWBitMask::Kaon::kOverlap); + fGFW->AddRegion("olKaP", 0, etaMax, 1, GFWBitMask::Kaon::kOverlap); + + // Proton POI and overlap regions. + fGFW->AddRegion("poiPrN08", -etaMax, -etaGap, 1, GFWBitMask::Proton::kPOI); + fGFW->AddRegion("poiPrP08", etaGap, etaMax, 1, GFWBitMask::Proton::kPOI); + fGFW->AddRegion("poiPrN", -etaMax, 0, 1, GFWBitMask::Proton::kPOI); + fGFW->AddRegion("poiPrP", 0, etaMax, 1, GFWBitMask::Proton::kPOI); + + fGFW->AddRegion("olPrN", -etaMax, 0, 1, GFWBitMask::Proton::kOverlap); + fGFW->AddRegion("olPrP", 0, etaMax, 1, GFWBitMask::Proton::kOverlap); + + // Tracks for which the PID selection returns -1. They use the charged + // pT range and corrections, but have independent POI and overlap masks. + fGFW->AddRegion("poiUnidentifiedN08", -etaMax, -etaGap, 1, GFWBitMask::Unidentified::kPOI); + fGFW->AddRegion("poiUnidentifiedP08", etaGap, etaMax, 1, GFWBitMask::Unidentified::kPOI); + fGFW->AddRegion("poiUnidentifiedN", -etaMax, 0, 1, GFWBitMask::Unidentified::kPOI); + fGFW->AddRegion("poiUnidentifiedP", 0, etaMax, 1, GFWBitMask::Unidentified::kPOI); + fGFW->AddRegion("olUnidentifiedN", -etaMax, 0, 1, GFWBitMask::Unidentified::kOverlap); + fGFW->AddRegion("olUnidentifiedP", 0, etaMax, 1, GFWBitMask::Unidentified::kOverlap); // end data region add // pushback @@ -811,6 +994,17 @@ struct PidFlowPtCorr { corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPrN {2} refP {-2}", "Prot0gap22a", false)); corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPrP {2} refN {-2}", "Prot0gap22b", false)); // 40 + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiUnidentifiedN08 {2} refP08 {-2}", "Unidentified08gap22a", false)); // 41 + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiUnidentifiedP08 {2} refN08 {-2}", "Unidentified08gap22b", false)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiUnidentifiedN refN | olUnidentifiedN {2 2} refP {-2 -2}", "Unidentified0gap24a", false)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiUnidentifiedP refP | olUnidentifiedP {2 2} refN {-2 -2}", "Unidentified0gap24b", false)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiUnidentifiedN08 {2} poiUnidentifiedP08 {-2}", "UnidentifiedPure08gap22", false)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiUnidentifiedN {2} refP {-2}", "Unidentified0gap22a", false)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiUnidentifiedP {2} refN {-2}", "Unidentified0gap22b", false)); // 47 + + if (corrconfigs.size() != CorrConfigIndex::kCount) { + LOGF(fatal, "Correlation index table expects %zu configurations, but %zu were created", CorrConfigIndex::kCount, corrconfigs.size()); + } fGFW->CreateRegions(); // finalize the initialization // params @@ -1224,15 +1418,18 @@ struct PidFlowPtCorr { */ void fillFC4PtC22(const double& cent, const double& ptSum, const double& nch, const double& rndm) { + if (!isParticleOutputEnabled(MyParticleType::kCharged)) { + return; + } double dnx = 0.0, val = 0.0; - dnx = fGFW->Calculate(corrconfigs.at(0), 0, true).real(); + dnx = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), 0, true).real(); if (dnx == 0) { return; } // <2> - val = fGFW->Calculate(corrconfigs.at(0), 0, false).real() / dnx; + val = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), 0, false).real() / dnx; if (std::fabs(val) >= 1) { return; } @@ -1257,16 +1454,19 @@ struct PidFlowPtCorr { */ void fillFC4PtC22(const double& cent, const double& rndm, MyParticleType type, const double& pidPtSum, const double& nPid) { + if (!isParticleOutputEnabled(type)) { + return; + } // <2> double dnx = 0.0, val = 0.0; - dnx = fGFW->Calculate(corrconfigs.at(0), 0, true).real(); + dnx = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), 0, true).real(); if (dnx == 0) { return; } // <2> - val = fGFW->Calculate(corrconfigs.at(0), 0, false).real() / dnx; + val = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), 0, false).real() / dnx; if (std::fabs(val) >= 1) { return; } @@ -1275,12 +1475,12 @@ struct PidFlowPtCorr { double npairPid = 0; switch (type) { case MyParticleType::kPion: - pidc22 = getPidC22InOneEvent(corrconfigs.at(5), corrconfigs.at(6)); + pidc22 = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Pion::kC22GapA), corrconfigs.at(CorrConfigIndex::Pion::kC22GapB)); if (pidc22 == 0) { return; } - npairPid = fGFW->Calculate(corrconfigs.at(5), 0, true).real() + fGFW->Calculate(corrconfigs.at(6), 0, true).real(); + npairPid = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Pion::kC22GapA), 0, true).real() + fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Pion::kC22GapB), 0, true).real(); if (npairPid == 0) { return; } @@ -1296,12 +1496,12 @@ struct PidFlowPtCorr { fFCPi->FillProfile("hMeanPtWeightCharged", cent, (pidPtSum / nPid), dnx * nPid, rndm); if (switchsOpts.cfgAddMeanPtCentNbsHistograms.value && switchsOpts.cfgClosureTest.value != 0) { - double npair4c22pure = fGFW->Calculate(corrconfigs.at(29), 0, true).real(); + double npair4c22pure = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), 0, true).real(); if (npair4c22pure > minVal4Float) { registry.fill(HIST("meanptCentNbs/hPionMeanptWeightC22pure"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, pidPtSum / nPid, - nPid * npairPid * fGFW->Calculate(corrconfigs.at(29), 0, false).real() / npair4c22pure); + nPid * npairPid * fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), 0, false).real() / npair4c22pure); } registry.fill(HIST("meanptCentNbs/hPionMeanptWeightMeanpt"), @@ -1318,12 +1518,12 @@ struct PidFlowPtCorr { // end pion case MyParticleType::kKaon: - pidc22 = getPidC22InOneEvent(corrconfigs.at(7), corrconfigs.at(8)); + pidc22 = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Kaon::kC22GapA), corrconfigs.at(CorrConfigIndex::Kaon::kC22GapB)); if (pidc22 == 0) { return; } - npairPid = fGFW->Calculate(corrconfigs.at(7), 0, true).real() + fGFW->Calculate(corrconfigs.at(8), 0, true).real(); + npairPid = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Kaon::kC22GapA), 0, true).real() + fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Kaon::kC22GapB), 0, true).real(); if (npairPid == 0) { return; } @@ -1342,12 +1542,12 @@ struct PidFlowPtCorr { // end kaon case MyParticleType::kProton: - pidc22 = getPidC22InOneEvent(corrconfigs.at(9), corrconfigs.at(10)); + pidc22 = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Proton::kC22GapA), corrconfigs.at(CorrConfigIndex::Proton::kC22GapB)); if (pidc22 == 0) { return; } - npairPid = fGFW->Calculate(corrconfigs.at(9), 0, true).real() + fGFW->Calculate(corrconfigs.at(10), 0, true).real(); + npairPid = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Proton::kC22GapA), 0, true).real() + fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Proton::kC22GapB), 0, true).real(); if (npairPid == 0) { return; } @@ -1365,6 +1565,28 @@ struct PidFlowPtCorr { break; // end proton + case MyParticleType::kUnidentified: + pidc22 = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Unidentified::kC22GapA), corrconfigs.at(CorrConfigIndex::Unidentified::kC22GapB)); + if (pidc22 == 0) { + return; + } + + npairPid = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Unidentified::kC22GapA), 0, true).real() + fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Unidentified::kC22GapB), 0, true).real(); + if (npairPid == 0) { + return; + } + + if (switchsOpts.cfgAddMeanPtCentNbsHistograms.value) { + registry.fill(HIST("meanptCentNbs/hUnidentified"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, pidc22, nPid * npairPid); + registry.fill(HIST("meanptCentNbs/hChargedUnidentifiedFull"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, val, dnx * nPid); + registry.fill(HIST("meanptCentNbs/hChargedUnidentifiedWithNpair"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, val, dnx); + registry.fill(HIST("meanptCentNbs/hUnidentifiedMeanpt"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, pidPtSum / nPid, 1.); + } + + fFCUnidentified->FillProfile("hMeanPtWeightFull", cent, pidPtSum / nPid, nPid * npairPid, rndm); + fFCUnidentified->FillProfile("hMeanPtWeightCharged", cent, pidPtSum / nPid, dnx * nPid, rndm); + break; + default: return; break; @@ -1374,6 +1596,9 @@ struct PidFlowPtCorr { bool fillFC(MyParticleType type, const GFW::CorrConfig& corrconf, const double& cent, const double& rndm, const char* tarName) { + if (!isParticleOutputEnabled(type)) { + return false; + } double dnx = 0.0; // calculate #sum exp{i * 0 (#phi_{i} - #phi_{j})} == N_{pairs} // note that weight is ignored in the formula but not in the calculation, for c24 is similar @@ -1400,6 +1625,9 @@ struct PidFlowPtCorr { case MyParticleType::kProton: fFCPr->FillProfile(tarName, cent, val, dnx, rndm); break; + case MyParticleType::kUnidentified: + fFCUnidentified->FillProfile(tarName, cent, val, dnx, rndm); + break; default: LOGF(warning, "particle not found"); @@ -1448,6 +1676,9 @@ struct PidFlowPtCorr { const char* tarName, bool useWeightOne = false) { + if (!isParticleOutputEnabled(type)) { + return; + } double dnx = fGFW->Calculate(corrconf, 0, true).real(); if (dnx == 0) { return; @@ -1468,6 +1699,9 @@ struct PidFlowPtCorr { case MyParticleType::kProton: fFCPr->FillProfile(tarName, cent, val * (ptSum / nch), useWeightOne ? 1.0 : dnx * nch, rndm); break; + case MyParticleType::kUnidentified: + fFCUnidentified->FillProfile(tarName, cent, val * (ptSum / nch), useWeightOne ? 1.0 : dnx * nch, rndm); + break; default: LOGF(warning, "particle not found"); @@ -2247,22 +2481,27 @@ struct PidFlowPtCorr { double pionPtSum = 0; double kaonPtSum = 0; double protonPtSum = 0; + double unidentifiedPtSum = 0; double nPionWeighted = 0; double nKaonWeighted = 0; double nProtonWeighted = 0; + double nUnidentifiedWeighted = 0; double pionPtSumw2 = 0; double kaonPtSumw2 = 0; double protonPtSumw2 = 0; + double unidentifiedPtSumw2 = 0; double nPionSquare = 0; double nKaonSquare = 0; double nProtonSquare = 0; + double nUnidentifiedSquare = 0; double pionPtSquareSum = 0; double kaonPtSquareSum = 0; double protonPtSquareSum = 0; + double unidentifiedPtSquareSum = 0; // end val for pid particles // Calculate mean-pT moments and PID-particle sums. @@ -2289,19 +2528,22 @@ struct PidFlowPtCorr { } // end calculate nch and pt - // calculate POI (pi/ka/pr) sums, each with its own independent pt range + // Calculate identified POIs with species corrections. Tracks returning + // pid == -1 form the unidentified POI and use charged pT/NUE settings. if (std::fabs(track.eta()) < trkQualityOpts.cfgRangeEta.value) { // ------------------------------ // Unified PID logic (configurable) // ------------------------------ int pid = getPidConfigurable(track); - float weffPid = 1.; - // do nue - setParticleNUEWeight(weffPid, track, cent, pid); - // end do nue - - // Apply the species-specific POI pT range before accumulating moments. - if (isWithinPOIPtRange(pid, track.pt())) { + if (pid == -1 && withinPtRef) { + nUnidentifiedWeighted += weff; + nUnidentifiedSquare += weff * weff; + unidentifiedPtSum += weff * track.pt(); + unidentifiedPtSumw2 += weff * weff * track.pt(); + unidentifiedPtSquareSum += weff * weff * track.pt() * track.pt(); + } else if (isWithinPOIPtRange(pid, track.pt())) { + float weffPid = 1.; + setParticleNUEWeight(weffPid, track, cent, pid); if (pid == MyParticleType::kPion) { nPionWeighted += weffPid; nPionSquare += weffPid * weffPid; @@ -2395,26 +2637,29 @@ struct PidFlowPtCorr { registry.fill(HIST("ptSpectra/hPtCentData"), track.pt(), cent); } - // fill GFW - // bit mask 1: fill CHARGED PARTICLES - fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, 1); //(eta, ptbin, phi, wacc*weff, bitmask) + // Fill the charged reference regions. + fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, GFWBitMask::Charged::kReference); //(eta, ptbin, phi, wacc*weff, bitmask) } // ------------------------------ // Unified PID logic (configurable) // ------------------------------ int pid = getPidConfigurable(track); - float waccPid = 1; - float weffPid = 1; - this->setParticleNUAWeight(waccPid, track, vtxz, pid); - this->setParticleNUEWeight(weffPid, track, cent, pid); - - // Fill GFW and counters using the same species-specific POI pT range. - if (isWithinPOIPtRange(pid, track.pt())) { + if (pid == -1 && withinPtRefGlobal) { + // Unidentified tracks have no PID-specific correction. Reuse exactly + // the charged NUA/NUE (including the optional local-density factor). + fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, GFWBitMask::Unidentified::kPOI); + fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, GFWBitMask::Unidentified::kOverlap, wacc * weff); + } else if (isWithinPOIPtRange(pid, track.pt())) { + float waccPid = 1; + float weffPid = 1; + this->setParticleNUAWeight(waccPid, track, vtxz, pid); + this->setParticleNUEWeight(weffPid, track, cent, pid); + + // Fill GFW and counters using the same species-specific POI pT range. if (pid == MyParticleType::kPion) { - // bitmask 18: 0010010 - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, 2); - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, 16, wacc * weff); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Pion::kPOI); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Pion::kOverlap, wacc * weff); registry.fill(HIST("hPhiPi"), track.phi()); registry.fill(HIST("hPhicorrPi"), track.phi(), waccPid); registry.fill(HIST("hPhiCorrNUANUEPi"), track.phi(), waccPid * weffPid); @@ -2422,9 +2667,8 @@ struct PidFlowPtCorr { registry.fill(HIST("hPtCorrPi"), track.pt(), weffPid); numOfPi++; } else if (pid == MyParticleType::kKaon) { - // bitmask 36: 0100100 - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, 4); - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, 32, wacc * weff); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Kaon::kPOI); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Kaon::kOverlap, wacc * weff); registry.fill(HIST("hPhiKa"), track.phi()); registry.fill(HIST("hPhicorrKa"), track.phi(), waccPid); registry.fill(HIST("hPhiCorrNUANUEKa"), track.phi(), waccPid * weffPid); @@ -2432,9 +2676,8 @@ struct PidFlowPtCorr { registry.fill(HIST("hPtCorrKa"), track.pt(), weffPid); numOfKa++; } else if (pid == MyParticleType::kProton) { - // bitmask 72: 1001000 - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, 8); - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, 64, wacc * weff); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Proton::kPOI); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Proton::kOverlap, wacc * weff); registry.fill(HIST("hPhiPr"), track.phi()); registry.fill(HIST("hPhicorrPr"), track.phi(), waccPid); registry.fill(HIST("hPhiCorrNUANUEPr"), track.phi(), waccPid * weffPid); @@ -2460,87 +2703,98 @@ struct PidFlowPtCorr { // fill hist using fGFW if (nch > 0) { - fillFC(MyParticleType::kCharged, corrconfigs.at(0), cent, rndm, "c22"); - fillFC(MyParticleType::kCharged, corrconfigs.at(1), cent, rndm, "c24"); - fillFC(MyParticleType::kCharged, corrconfigs.at(2), cent, rndm, "c22Full"); - fillFC(MyParticleType::kCharged, corrconfigs.at(3), cent, rndm, "c32"); - fillFC(MyParticleType::kCharged, corrconfigs.at(4), cent, rndm, "c34"); - - fillFC(MyParticleType::kPion, corrconfigs.at(35), cent, rndm, "c22Full"); - fillFC(MyParticleType::kPion, corrconfigs.at(36), cent, rndm, "c22Full"); - fillFC(MyParticleType::kKaon, corrconfigs.at(37), cent, rndm, "c22Full"); - fillFC(MyParticleType::kKaon, corrconfigs.at(38), cent, rndm, "c22Full"); - fillFC(MyParticleType::kProton, corrconfigs.at(39), cent, rndm, "c22Full"); - fillFC(MyParticleType::kProton, corrconfigs.at(40), cent, rndm, "c22Full"); - - fillFC(MyParticleType::kPion, corrconfigs.at(11), cent, rndm, "c24"); - fillFC(MyParticleType::kPion, corrconfigs.at(12), cent, rndm, "c24"); - fillFC(MyParticleType::kKaon, corrconfigs.at(13), cent, rndm, "c24"); - fillFC(MyParticleType::kKaon, corrconfigs.at(14), cent, rndm, "c24"); - fillFC(MyParticleType::kProton, corrconfigs.at(15), cent, rndm, "c24"); - fillFC(MyParticleType::kProton, corrconfigs.at(16), cent, rndm, "c24"); - - fillFC(MyParticleType::kPion, corrconfigs.at(17), cent, rndm, "c32"); - fillFC(MyParticleType::kPion, corrconfigs.at(18), cent, rndm, "c32"); - fillFC(MyParticleType::kKaon, corrconfigs.at(19), cent, rndm, "c32"); - fillFC(MyParticleType::kKaon, corrconfigs.at(20), cent, rndm, "c32"); - fillFC(MyParticleType::kProton, corrconfigs.at(21), cent, rndm, "c32"); - fillFC(MyParticleType::kProton, corrconfigs.at(22), cent, rndm, "c32"); - - fillFC(MyParticleType::kPion, corrconfigs.at(23), cent, rndm, "c34"); - fillFC(MyParticleType::kPion, corrconfigs.at(24), cent, rndm, "c34"); - fillFC(MyParticleType::kKaon, corrconfigs.at(25), cent, rndm, "c34"); - fillFC(MyParticleType::kKaon, corrconfigs.at(26), cent, rndm, "c34"); - fillFC(MyParticleType::kProton, corrconfigs.at(27), cent, rndm, "c34"); - fillFC(MyParticleType::kProton, corrconfigs.at(28), cent, rndm, "c34"); - - bool filledPi = fillFC(MyParticleType::kPion, corrconfigs.at(29), cent, rndm, "c22pure"); - bool filledKa = fillFC(MyParticleType::kKaon, corrconfigs.at(30), cent, rndm, "c22pure"); - bool filledPr = fillFC(MyParticleType::kProton, corrconfigs.at(31), cent, rndm, "c22pure"); - - fillFC(MyParticleType::kPion, corrconfigs.at(32), cent, rndm, "c32pure"); - fillFC(MyParticleType::kKaon, corrconfigs.at(33), cent, rndm, "c32pure"); - fillFC(MyParticleType::kProton, corrconfigs.at(34), cent, rndm, "c32pure"); + fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, "c22"); + fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC24), cent, rndm, "c24"); + fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Full), cent, rndm, "c22Full"); + fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC32Gap), cent, rndm, "c32"); + fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC34Gap), cent, rndm, "c34"); + + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22FullA), cent, rndm, "c22Full"); + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22FullB), cent, rndm, "c22Full"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22FullA), cent, rndm, "c22Full"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22FullB), cent, rndm, "c22Full"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22FullA), cent, rndm, "c22Full"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22FullB), cent, rndm, "c22Full"); + fillFC(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22FullA), cent, rndm, "c22Full"); + fillFC(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22FullB), cent, rndm, "c22Full"); + + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC24A), cent, rndm, "c24"); + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC24B), cent, rndm, "c24"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC24A), cent, rndm, "c24"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC24B), cent, rndm, "c24"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC24A), cent, rndm, "c24"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC24B), cent, rndm, "c24"); + fillFC(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC24A), cent, rndm, "c24"); + fillFC(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC24B), cent, rndm, "c24"); + + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32GapA), cent, rndm, "c32"); + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32GapB), cent, rndm, "c32"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32GapA), cent, rndm, "c32"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32GapB), cent, rndm, "c32"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32GapA), cent, rndm, "c32"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32GapB), cent, rndm, "c32"); + + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC34A), cent, rndm, "c34"); + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC34B), cent, rndm, "c34"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC34A), cent, rndm, "c34"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC34B), cent, rndm, "c34"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC34A), cent, rndm, "c34"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC34B), cent, rndm, "c34"); + + bool filledPi = fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, "c22pure"); + bool filledKa = fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, "c22pure"); + bool filledPr = fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, "c22pure"); + bool filledUnidentified = fillFC(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22Pure), cent, rndm, "c22pure"); + + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32Pure), cent, rndm, "c32pure"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32Pure), cent, rndm, "c32pure"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32Pure), cent, rndm, "c32pure"); if (filledPi || !switchsOpts.cfgCheck2MethodDiff.value) { - fillFC(MyParticleType::kPion, corrconfigs.at(5), cent, rndm, "c22"); - fillFC(MyParticleType::kPion, corrconfigs.at(6), cent, rndm, "c22"); + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22GapA), cent, rndm, "c22"); + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22GapB), cent, rndm, "c22"); } if (filledKa || !switchsOpts.cfgCheck2MethodDiff.value) { - fillFC(MyParticleType::kKaon, corrconfigs.at(7), cent, rndm, "c22"); - fillFC(MyParticleType::kKaon, corrconfigs.at(8), cent, rndm, "c22"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22GapA), cent, rndm, "c22"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22GapB), cent, rndm, "c22"); } if (filledPr || !switchsOpts.cfgCheck2MethodDiff.value) { - fillFC(MyParticleType::kProton, corrconfigs.at(9), cent, rndm, "c22"); - fillFC(MyParticleType::kProton, corrconfigs.at(10), cent, rndm, "c22"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22GapA), cent, rndm, "c22"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22GapB), cent, rndm, "c22"); + } + if (filledUnidentified || !switchsOpts.cfgCheck2MethodDiff.value) { + fillFC(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22GapA), cent, rndm, "c22"); + fillFC(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22GapB), cent, rndm, "c22"); } - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(0), cent, rndm, nch, nch, "c22TrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(0), cent, rndm, nch, nch, "c22TrackWeightOne", true); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, nch, nch, "c22TrackWeightOne", true); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(1), cent, rndm, nch, nch, "c24TrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(2), cent, rndm, nch, nch, "c22FullTrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(3), cent, rndm, nch, nch, "c32TrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(4), cent, rndm, nch, nch, "c34TrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC24), cent, rndm, nch, nch, "c24TrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Full), cent, rndm, nch, nch, "c22FullTrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC32Gap), cent, rndm, nch, nch, "c32TrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC34Gap), cent, rndm, nch, nch, "c34TrackWeight"); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(29), cent, rndm, nch, nch, "c22TrackWeight"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(30), cent, rndm, nch, nch, "c22TrackWeight"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(31), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(32), cent, rndm, nch, nch, "c32TrackWeight"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(33), cent, rndm, nch, nch, "c32TrackWeight"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(34), cent, rndm, nch, nch, "c32TrackWeight"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(0), cent, rndm, ptSum, nch, "covV2Pt"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(0), cent, rndm, ptSum, nch, "covV2PtWeightOne", true); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, ptSum, nch, "covV2PtWeightOne", true); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(29), cent, rndm, ptSum, nch, "covV2Pt"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(30), cent, rndm, ptSum, nch, "covV2Pt"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(31), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(3), cent, rndm, ptSum, nch, "covV3Pt"); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(32), cent, rndm, ptSum, nch, "covV3Pt"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(33), cent, rndm, ptSum, nch, "covV3Pt"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(34), cent, rndm, ptSum, nch, "covV3Pt"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC32Gap), cent, rndm, ptSum, nch, "covV3Pt"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); fillFC4PtC22(cent, ptSum, nch, rndm); if (nPionWeighted > 0) { @@ -2554,61 +2808,73 @@ struct PidFlowPtCorr { if (nProtonWeighted > 0) { fillFC4PtC22(cent, rndm, MyParticleType::kProton, protonPtSum, nProtonWeighted); } + if (nUnidentifiedWeighted > 0) { + fillFC4PtC22(cent, rndm, MyParticleType::kUnidentified, unidentifiedPtSum, nUnidentifiedWeighted); + } if (switchsOpts.cfgOutPutPtSpectra.value) { // charged calculation - double NpairCharged = fGFW->Calculate(corrconfigs.at(0), 0, true).real(); - double chargedC22 = NpairCharged > 0 ? fGFW->Calculate(corrconfigs.at(0), 0, false).real() / NpairCharged : 0; + double NpairCharged = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), 0, true).real(); + double chargedC22 = NpairCharged > 0 ? fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), 0, false).real() / NpairCharged : 0; // end charged calculation // pi - double pidChargedC22Pi = getPidC22InOneEvent(corrconfigs.at(5), corrconfigs.at(6)); + double pidChargedC22Pi = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Pion::kC22GapA), corrconfigs.at(CorrConfigIndex::Pion::kC22GapB)); if (pidChargedC22Pi > 0 && chargedC22 > 0) { registry.fill(HIST("c22PrimeVsc22/Pi"), pidChargedC22Pi, chargedC22); } // end pi // Ka - double pidKaonC22 = getPidC22InOneEvent(corrconfigs.at(7), corrconfigs.at(8)); + double pidKaonC22 = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Kaon::kC22GapA), corrconfigs.at(CorrConfigIndex::Kaon::kC22GapB)); if (pidKaonC22 > 0 && chargedC22 > 0) { registry.fill(HIST("c22PrimeVsc22/Ka"), pidKaonC22, chargedC22); } // end Ka // Pr - double pidProtonC22 = getPidC22InOneEvent(corrconfigs.at(9), corrconfigs.at(10)); + double pidProtonC22 = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Proton::kC22GapA), corrconfigs.at(CorrConfigIndex::Proton::kC22GapB)); if (pidProtonC22 > 0 && chargedC22 > 0) { registry.fill(HIST("c22PrimeVsc22/Pr"), pidProtonC22, chargedC22); } // end Pr } - fFCCh->FillProfile("hMeanPt", cent, (ptSum / nch), nch, rndm); - fFCCh->FillProfile("hMeanPtWeightOne", cent, (ptSum / nch), 1., rndm); + if (switchsOpts.cfgOutputCharged.value) { + fFCCh->FillProfile("hMeanPt", cent, (ptSum / nch), nch, rndm); + fFCCh->FillProfile("hMeanPtWeightOne", cent, (ptSum / nch), 1., rndm); + } - if (nPionWeighted > 0) { + if (nPionWeighted > 0 && switchsOpts.cfgOutputPion.value) { fFCPi->FillProfile("hMeanPt", cent, (pionPtSum / nPionWeighted), nPionWeighted, rndm); fFCPi->FillProfile("hMeanPtWeightOne", cent, (pionPtSum / nPionWeighted), 1., rndm); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(29), cent, rndm, pionPtSum, nPionWeighted, "covV2PtPID"); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(29), cent, rndm, nPionWeighted, nPionWeighted, "c22TrackWeightPID"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, pionPtSum, nPionWeighted, "covV2PtPID"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, nPionWeighted, nPionWeighted, "c22TrackWeightPID"); } - if (nKaonWeighted > 0) { + if (nKaonWeighted > 0 && switchsOpts.cfgOutputKaon.value) { fFCKa->FillProfile("hMeanPt", cent, (kaonPtSum / nKaonWeighted), nKaonWeighted, rndm); fFCKa->FillProfile("hMeanPtWeightOne", cent, (kaonPtSum / nKaonWeighted), 1., rndm); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(30), cent, rndm, kaonPtSum, nKaonWeighted, "covV2PtPID"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(30), cent, rndm, nKaonWeighted, nKaonWeighted, "c22TrackWeightPID"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, kaonPtSum, nKaonWeighted, "covV2PtPID"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, nKaonWeighted, nKaonWeighted, "c22TrackWeightPID"); } - if (nProtonWeighted > 0) { + if (nProtonWeighted > 0 && switchsOpts.cfgOutputProton.value) { fFCPr->FillProfile("hMeanPt", cent, (protonPtSum / nProtonWeighted), nProtonWeighted, rndm); fFCPr->FillProfile("hMeanPtWeightOne", cent, (protonPtSum / nProtonWeighted), 1., rndm); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(31), cent, rndm, protonPtSum, nProtonWeighted, "covV2PtPID"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(31), cent, rndm, nProtonWeighted, nProtonWeighted, "c22TrackWeightPID"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, protonPtSum, nProtonWeighted, "covV2PtPID"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, nProtonWeighted, nProtonWeighted, "c22TrackWeightPID"); + } + + if (nUnidentifiedWeighted > 0 && switchsOpts.cfgOutputUnidentified.value) { + fFCUnidentified->FillProfile("hMeanPt", cent, unidentifiedPtSum / nUnidentifiedWeighted, nUnidentifiedWeighted, rndm); + fFCUnidentified->FillProfile("hMeanPtWeightOne", cent, unidentifiedPtSum / nUnidentifiedWeighted, 1., rndm); + fillFCvnpt(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22Pure), cent, rndm, unidentifiedPtSum, nUnidentifiedWeighted, "covV2PtPID"); + fillFCvnpt(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22Pure), cent, rndm, nUnidentifiedWeighted, nUnidentifiedWeighted, "c22TrackWeightPID"); } double nchDiff = nch * nch - nchSquare; - if (nchDiff > minVal4Float) { + if (nchDiff > minVal4Float && switchsOpts.cfgOutputCharged.value) { fFCCh->FillProfile("ptSquareAve", cent, (ptSum * ptSum - ptSquareSum) / nchDiff, nchDiff, rndm); @@ -2627,7 +2893,7 @@ struct PidFlowPtCorr { } double pionDiff = nPionWeighted * nPionWeighted - nPionSquare; - if (pionDiff > minVal4Float) { + if (pionDiff > minVal4Float && switchsOpts.cfgOutputPion.value) { fFCPi->FillProfile("ptSquareAve", cent, (pionPtSum * pionPtSum - pionPtSquareSum) / pionDiff, pionDiff, rndm); @@ -2646,7 +2912,7 @@ struct PidFlowPtCorr { } double kaonDiff = nKaonWeighted * nKaonWeighted - nKaonSquare; - if (kaonDiff > minVal4Float) { + if (kaonDiff > minVal4Float && switchsOpts.cfgOutputKaon.value) { fFCKa->FillProfile("ptSquareAve", cent, (kaonPtSum * kaonPtSum - kaonPtSquareSum) / kaonDiff, kaonDiff, rndm); @@ -2665,7 +2931,7 @@ struct PidFlowPtCorr { } double protonDiff = nProtonWeighted * nProtonWeighted - nProtonSquare; - if (protonDiff > minVal4Float) { + if (protonDiff > minVal4Float && switchsOpts.cfgOutputProton.value) { fFCPr->FillProfile("ptSquareAve", cent, (protonPtSum * protonPtSum - protonPtSquareSum) / protonDiff, protonDiff, rndm); @@ -2683,14 +2949,31 @@ struct PidFlowPtCorr { 1., rndm); } + double unidentifiedDiff = nUnidentifiedWeighted * nUnidentifiedWeighted - nUnidentifiedSquare; + if (unidentifiedDiff > minVal4Float && switchsOpts.cfgOutputUnidentified.value) { + fFCUnidentified->FillProfile("ptSquareAve", cent, + (unidentifiedPtSum * unidentifiedPtSum - unidentifiedPtSquareSum) / unidentifiedDiff, + unidentifiedDiff, rndm); + fFCUnidentified->FillProfile("ptSquareAveWeightOne", cent, + (unidentifiedPtSum * unidentifiedPtSum - unidentifiedPtSquareSum) / unidentifiedDiff, + 1., rndm); + fFCUnidentified->FillProfile("ptAve", cent, + (nUnidentifiedWeighted * unidentifiedPtSum - unidentifiedPtSumw2) / unidentifiedDiff, + unidentifiedDiff, rndm); + fFCUnidentified->FillProfile("ptAveWeightOne", cent, + (nUnidentifiedWeighted * unidentifiedPtSum - unidentifiedPtSumw2) / unidentifiedDiff, + 1., rndm); + } + } // end fill hist using fillProfile } PROCESS_SWITCH(PidFlowPtCorr, processData, "", true); /** - * @brief Fill charged and identified-particle c22 versus event mean pT. + * @brief Fill charged, identified-particle, and unidentified-particle c22 versus event mean pT. * @note Each profile uses the mean pT of the same particle sample on its pT axis: - * charged, pion, kaon, or proton. The corresponding FlowContainer hMeanPt + * charged, pion, kaon, proton, or PID-failed/ambiguous unidentified tracks. + * The corresponding FlowContainer hMeanPt * observable provides the ensemble mean pT needed to convert that axis to * delta[pT]/<[pT]> offline. */ @@ -2766,9 +3049,11 @@ struct PidFlowPtCorr { double pionPtSum = 0.; double kaonPtSum = 0.; double protonPtSum = 0.; + double unidentifiedPtSum = 0.; double nPionWeighted = 0.; double nKaonWeighted = 0.; double nProtonWeighted = 0.; + double nUnidentifiedWeighted = 0.; for (const auto& track : tracks) { // The mean-pT samples use the same track-quality and eta selections. The pT @@ -2777,14 +3062,20 @@ struct PidFlowPtCorr { continue; } - if (isWithinRefPtRange(track.pt())) { - float weff = 1.f; - setParticleNUEWeight(weff, track, cent); + float weff = 1.f; + setParticleNUEWeight(weff, track, cent); + const bool withinPtRef = isWithinRefPtRange(track.pt()); + if (withinPtRef) { nch += weff; ptSum += weff * track.pt(); } const int pid = getPidConfigurable(track); + if (pid == -1 && withinPtRef) { + nUnidentifiedWeighted += weff; + unidentifiedPtSum += weff * track.pt(); + continue; + } if (!isWithinPOIPtRange(pid, track.pt())) { continue; } @@ -2806,8 +3097,7 @@ struct PidFlowPtCorr { return; } - // Fill the GFW regions in a separate pass. Bit 1 is the charged reference - // sample; bits 2, 4, and 8 are pion, kaon, and proton POIs, respectively. + // Fill the charged reference and particle-specific POI regions in a separate pass. for (const auto& track : tracks) { if (!trackSelectedForFlow(track)) { continue; @@ -2818,7 +3108,8 @@ struct PidFlowPtCorr { setParticleNUEWeight(weff, track, cent); setParticleNUAWeight(wacc, track, vtxz); - if (isWithinRefPtRange(track.pt())) { + const bool withinPtRef = isWithinRefPtRange(track.pt()); + if (withinPtRef) { if (switchsOpts.cfgDoLocDenCorr.value) { const double fphi = 1. + 2. * (v2 * std::cos(2. * (track.phi() - psi2Est)) + v3 * std::cos(3. * (track.phi() - psi3Est)) + @@ -2832,10 +3123,14 @@ struct PidFlowPtCorr { } } /// @note passed selection: global cut + pt cut - fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, 1); + fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, GFWBitMask::Charged::kReference); } const int pid = getPidConfigurable(track); + if (pid == -1 && withinPtRef) { + fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, GFWBitMask::Unidentified::kPOI); + continue; + } if (!isWithinPOIPtRange(pid, track.pt())) { continue; } @@ -2846,52 +3141,66 @@ struct PidFlowPtCorr { setParticleNUAWeight(waccPid, track, vtxz, pid); if (pid == MyParticleType::kPion) { - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, 2); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Pion::kPOI); } else if (pid == MyParticleType::kKaon) { - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, 4); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Kaon::kPOI); } else if (pid == MyParticleType::kProton) { - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, 8); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Proton::kPOI); } } // All profiles from one event use the same bootstrap subsample. Mean-pT profiles // retain the NUE-corrected particle-count weight used by FlowContainer hMeanPt. - registry.fill(HIST("c22DeltaPt/hMeanPtCharged"), cent, rndm * cfgFlowNbootstrap, ptSum / nch, nch); - if (nPionWeighted > 0.) { + if (switchsOpts.cfgOutputCharged.value) { + registry.fill(HIST("c22DeltaPt/hMeanPtCharged"), cent, rndm * cfgFlowNbootstrap, ptSum / nch, nch); + } + if (nPionWeighted > 0. && switchsOpts.cfgOutputPion.value) { registry.fill(HIST("c22DeltaPt/hMeanPtPion"), cent, rndm * cfgFlowNbootstrap, pionPtSum / nPionWeighted, nPionWeighted); - fillProfilePOIvnpt(corrconfigs.at(0), HIST("c22DeltaPt/c22dmeanptPionRefRef"), cent, pionPtSum, nPionWeighted, rndm); + fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), HIST("c22DeltaPt/c22dmeanptPionRefRef"), cent, pionPtSum, nPionWeighted, rndm); } - if (nKaonWeighted > 0.) { + if (nKaonWeighted > 0. && switchsOpts.cfgOutputKaon.value) { registry.fill(HIST("c22DeltaPt/hMeanPtKaon"), cent, rndm * cfgFlowNbootstrap, kaonPtSum / nKaonWeighted, nKaonWeighted); - fillProfilePOIvnpt(corrconfigs.at(0), HIST("c22DeltaPt/c22dmeanptKaonRefRef"), cent, kaonPtSum, nKaonWeighted, rndm); + fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), HIST("c22DeltaPt/c22dmeanptKaonRefRef"), cent, kaonPtSum, nKaonWeighted, rndm); } - if (nProtonWeighted > 0.) { + if (nProtonWeighted > 0. && switchsOpts.cfgOutputProton.value) { registry.fill(HIST("c22DeltaPt/hMeanPtProton"), cent, rndm * cfgFlowNbootstrap, protonPtSum / nProtonWeighted, nProtonWeighted); - fillProfilePOIvnpt(corrconfigs.at(0), HIST("c22DeltaPt/c22dmeanptProtonRefRef"), cent, protonPtSum, nProtonWeighted, rndm); + fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), HIST("c22DeltaPt/c22dmeanptProtonRefRef"), cent, protonPtSum, nProtonWeighted, rndm); + } + if (nUnidentifiedWeighted > 0. && switchsOpts.cfgOutputUnidentified.value) { + registry.fill(HIST("c22DeltaPt/hMeanPtUnidentified"), cent, rndm * cfgFlowNbootstrap, unidentifiedPtSum / nUnidentifiedWeighted, nUnidentifiedWeighted); + fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), HIST("c22DeltaPt/c22dmeanptUnidentifiedRefRef"), cent, unidentifiedPtSum, nUnidentifiedWeighted, rndm); } // Charged and PID-binned ref-ref are common to both modes. The numerator is // selected between PID Pure and POI-ref by cfgC22DeltaPtUsePure. - fillProfilePOIvnpt(corrconfigs.at(0), HIST("c22DeltaPt/c22dmeanptCharged"), cent, ptSum, nch, rndm); + if (switchsOpts.cfgOutputCharged.value) { + fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), HIST("c22DeltaPt/c22dmeanptCharged"), cent, ptSum, nch, rndm); + } if (switchsOpts.cfgC22DeltaPtUsePure.value) { - if (nPionWeighted > 0.) { - fillProfilePOIvnpt(corrconfigs.at(29), HIST("c22DeltaPt/c22dmeanptPionPure"), cent, pionPtSum, nPionWeighted, rndm); + if (nPionWeighted > 0. && switchsOpts.cfgOutputPion.value) { + fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), HIST("c22DeltaPt/c22dmeanptPionPure"), cent, pionPtSum, nPionWeighted, rndm); } - if (nKaonWeighted > 0.) { - fillProfilePOIvnpt(corrconfigs.at(30), HIST("c22DeltaPt/c22dmeanptKaonPure"), cent, kaonPtSum, nKaonWeighted, rndm); + if (nKaonWeighted > 0. && switchsOpts.cfgOutputKaon.value) { + fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), HIST("c22DeltaPt/c22dmeanptKaonPure"), cent, kaonPtSum, nKaonWeighted, rndm); } - if (nProtonWeighted > 0.) { - fillProfilePOIvnpt(corrconfigs.at(31), HIST("c22DeltaPt/c22dmeanptProtonPure"), cent, protonPtSum, nProtonWeighted, rndm); + if (nProtonWeighted > 0. && switchsOpts.cfgOutputProton.value) { + fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), HIST("c22DeltaPt/c22dmeanptProtonPure"), cent, protonPtSum, nProtonWeighted, rndm); + } + if (nUnidentifiedWeighted > 0. && switchsOpts.cfgOutputUnidentified.value) { + fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Unidentified::kC22Pure), HIST("c22DeltaPt/c22dmeanptUnidentifiedPure"), cent, unidentifiedPtSum, nUnidentifiedWeighted, rndm); } } else { - if (nPionWeighted > 0.) { - fillProfilePOIvnpt(corrconfigs.at(5), corrconfigs.at(6), HIST("c22DeltaPt/c22dmeanptPionPOIRef"), cent, pionPtSum, nPionWeighted, rndm); + if (nPionWeighted > 0. && switchsOpts.cfgOutputPion.value) { + fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Pion::kC22GapA), corrconfigs.at(CorrConfigIndex::Pion::kC22GapB), HIST("c22DeltaPt/c22dmeanptPionPOIRef"), cent, pionPtSum, nPionWeighted, rndm); } - if (nKaonWeighted > 0.) { - fillProfilePOIvnpt(corrconfigs.at(7), corrconfigs.at(8), HIST("c22DeltaPt/c22dmeanptKaonPOIRef"), cent, kaonPtSum, nKaonWeighted, rndm); + if (nKaonWeighted > 0. && switchsOpts.cfgOutputKaon.value) { + fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Kaon::kC22GapA), corrconfigs.at(CorrConfigIndex::Kaon::kC22GapB), HIST("c22DeltaPt/c22dmeanptKaonPOIRef"), cent, kaonPtSum, nKaonWeighted, rndm); } - if (nProtonWeighted > 0.) { - fillProfilePOIvnpt(corrconfigs.at(9), corrconfigs.at(10), HIST("c22DeltaPt/c22dmeanptProtonPOIRef"), cent, protonPtSum, nProtonWeighted, rndm); + if (nProtonWeighted > 0. && switchsOpts.cfgOutputProton.value) { + fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Proton::kC22GapA), corrconfigs.at(CorrConfigIndex::Proton::kC22GapB), HIST("c22DeltaPt/c22dmeanptProtonPOIRef"), cent, protonPtSum, nProtonWeighted, rndm); + } + if (nUnidentifiedWeighted > 0. && switchsOpts.cfgOutputUnidentified.value) { + fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Unidentified::kC22GapA), corrconfigs.at(CorrConfigIndex::Unidentified::kC22GapB), HIST("c22DeltaPt/c22dmeanptUnidentifiedPOIRef"), cent, unidentifiedPtSum, nUnidentifiedWeighted, rndm); } } } @@ -2997,15 +3306,15 @@ struct PidFlowPtCorr { if (switchsOpts.cfgOutPutPtSpectra.value) { registry.fill(HIST("ptSpectra/hPtCentData"), pt, cent); } - fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., 1); + fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., GFWBitMask::Charged::kReference); } if (!isWithinPOIPtRange(pid, pt)) { continue; } if (pid == MyParticleType::kPion) { - fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., 2); - fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., 16, 1.); + fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., GFWBitMask::Pion::kPOI); + fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., GFWBitMask::Pion::kOverlap, 1.); registry.fill(HIST("hPhiPi"), mcParticle.phi()); registry.fill(HIST("hPhicorrPi"), mcParticle.phi()); registry.fill(HIST("hPhiCorrNUANUEPi"), mcParticle.phi()); @@ -3013,8 +3322,8 @@ struct PidFlowPtCorr { registry.fill(HIST("hPtCorrPi"), pt); ++numOfPi; } else if (pid == MyParticleType::kKaon) { - fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., 4); - fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., 32, 1.); + fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., GFWBitMask::Kaon::kPOI); + fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., GFWBitMask::Kaon::kOverlap, 1.); registry.fill(HIST("hPhiKa"), mcParticle.phi()); registry.fill(HIST("hPhicorrKa"), mcParticle.phi()); registry.fill(HIST("hPhiCorrNUANUEKa"), mcParticle.phi()); @@ -3022,8 +3331,8 @@ struct PidFlowPtCorr { registry.fill(HIST("hPtCorrKa"), pt); ++numOfKa; } else if (pid == MyParticleType::kProton) { - fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., 8); - fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., 64, 1.); + fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., GFWBitMask::Proton::kPOI); + fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., GFWBitMask::Proton::kOverlap, 1.); registry.fill(HIST("hPhiPr"), mcParticle.phi()); registry.fill(HIST("hPhicorrPr"), mcParticle.phi()); registry.fill(HIST("hPhiCorrNUANUEPr"), mcParticle.phi()); @@ -3044,81 +3353,81 @@ struct PidFlowPtCorr { continue; } - fillFC(MyParticleType::kCharged, corrconfigs.at(0), cent, rndm, "c22"); - fillFC(MyParticleType::kCharged, corrconfigs.at(1), cent, rndm, "c24"); - fillFC(MyParticleType::kCharged, corrconfigs.at(2), cent, rndm, "c22Full"); - fillFC(MyParticleType::kCharged, corrconfigs.at(3), cent, rndm, "c32"); - fillFC(MyParticleType::kCharged, corrconfigs.at(4), cent, rndm, "c34"); - - fillFC(MyParticleType::kPion, corrconfigs.at(35), cent, rndm, "c22Full"); - fillFC(MyParticleType::kPion, corrconfigs.at(36), cent, rndm, "c22Full"); - fillFC(MyParticleType::kKaon, corrconfigs.at(37), cent, rndm, "c22Full"); - fillFC(MyParticleType::kKaon, corrconfigs.at(38), cent, rndm, "c22Full"); - fillFC(MyParticleType::kProton, corrconfigs.at(39), cent, rndm, "c22Full"); - fillFC(MyParticleType::kProton, corrconfigs.at(40), cent, rndm, "c22Full"); - - fillFC(MyParticleType::kPion, corrconfigs.at(11), cent, rndm, "c24"); - fillFC(MyParticleType::kPion, corrconfigs.at(12), cent, rndm, "c24"); - fillFC(MyParticleType::kKaon, corrconfigs.at(13), cent, rndm, "c24"); - fillFC(MyParticleType::kKaon, corrconfigs.at(14), cent, rndm, "c24"); - fillFC(MyParticleType::kProton, corrconfigs.at(15), cent, rndm, "c24"); - fillFC(MyParticleType::kProton, corrconfigs.at(16), cent, rndm, "c24"); - - fillFC(MyParticleType::kPion, corrconfigs.at(17), cent, rndm, "c32"); - fillFC(MyParticleType::kPion, corrconfigs.at(18), cent, rndm, "c32"); - fillFC(MyParticleType::kKaon, corrconfigs.at(19), cent, rndm, "c32"); - fillFC(MyParticleType::kKaon, corrconfigs.at(20), cent, rndm, "c32"); - fillFC(MyParticleType::kProton, corrconfigs.at(21), cent, rndm, "c32"); - fillFC(MyParticleType::kProton, corrconfigs.at(22), cent, rndm, "c32"); - - fillFC(MyParticleType::kPion, corrconfigs.at(23), cent, rndm, "c34"); - fillFC(MyParticleType::kPion, corrconfigs.at(24), cent, rndm, "c34"); - fillFC(MyParticleType::kKaon, corrconfigs.at(25), cent, rndm, "c34"); - fillFC(MyParticleType::kKaon, corrconfigs.at(26), cent, rndm, "c34"); - fillFC(MyParticleType::kProton, corrconfigs.at(27), cent, rndm, "c34"); - fillFC(MyParticleType::kProton, corrconfigs.at(28), cent, rndm, "c34"); - - const bool filledPi = fillFC(MyParticleType::kPion, corrconfigs.at(29), cent, rndm, "c22pure"); - const bool filledKa = fillFC(MyParticleType::kKaon, corrconfigs.at(30), cent, rndm, "c22pure"); - const bool filledPr = fillFC(MyParticleType::kProton, corrconfigs.at(31), cent, rndm, "c22pure"); - fillFC(MyParticleType::kPion, corrconfigs.at(32), cent, rndm, "c32pure"); - fillFC(MyParticleType::kKaon, corrconfigs.at(33), cent, rndm, "c32pure"); - fillFC(MyParticleType::kProton, corrconfigs.at(34), cent, rndm, "c32pure"); + fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, "c22"); + fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC24), cent, rndm, "c24"); + fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Full), cent, rndm, "c22Full"); + fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC32Gap), cent, rndm, "c32"); + fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC34Gap), cent, rndm, "c34"); + + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22FullA), cent, rndm, "c22Full"); + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22FullB), cent, rndm, "c22Full"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22FullA), cent, rndm, "c22Full"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22FullB), cent, rndm, "c22Full"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22FullA), cent, rndm, "c22Full"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22FullB), cent, rndm, "c22Full"); + + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC24A), cent, rndm, "c24"); + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC24B), cent, rndm, "c24"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC24A), cent, rndm, "c24"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC24B), cent, rndm, "c24"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC24A), cent, rndm, "c24"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC24B), cent, rndm, "c24"); + + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32GapA), cent, rndm, "c32"); + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32GapB), cent, rndm, "c32"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32GapA), cent, rndm, "c32"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32GapB), cent, rndm, "c32"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32GapA), cent, rndm, "c32"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32GapB), cent, rndm, "c32"); + + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC34A), cent, rndm, "c34"); + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC34B), cent, rndm, "c34"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC34A), cent, rndm, "c34"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC34B), cent, rndm, "c34"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC34A), cent, rndm, "c34"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC34B), cent, rndm, "c34"); + + const bool filledPi = fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, "c22pure"); + const bool filledKa = fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, "c22pure"); + const bool filledPr = fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, "c22pure"); + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32Pure), cent, rndm, "c32pure"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32Pure), cent, rndm, "c32pure"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32Pure), cent, rndm, "c32pure"); if (filledPi || !switchsOpts.cfgCheck2MethodDiff.value) { - fillFC(MyParticleType::kPion, corrconfigs.at(5), cent, rndm, "c22"); - fillFC(MyParticleType::kPion, corrconfigs.at(6), cent, rndm, "c22"); + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22GapA), cent, rndm, "c22"); + fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22GapB), cent, rndm, "c22"); } if (filledKa || !switchsOpts.cfgCheck2MethodDiff.value) { - fillFC(MyParticleType::kKaon, corrconfigs.at(7), cent, rndm, "c22"); - fillFC(MyParticleType::kKaon, corrconfigs.at(8), cent, rndm, "c22"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22GapA), cent, rndm, "c22"); + fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22GapB), cent, rndm, "c22"); } if (filledPr || !switchsOpts.cfgCheck2MethodDiff.value) { - fillFC(MyParticleType::kProton, corrconfigs.at(9), cent, rndm, "c22"); - fillFC(MyParticleType::kProton, corrconfigs.at(10), cent, rndm, "c22"); - } - - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(0), cent, rndm, nch, nch, "c22TrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(0), cent, rndm, nch, nch, "c22TrackWeightOne", true); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(1), cent, rndm, nch, nch, "c24TrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(2), cent, rndm, nch, nch, "c22FullTrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(3), cent, rndm, nch, nch, "c32TrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(4), cent, rndm, nch, nch, "c34TrackWeight"); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(29), cent, rndm, nch, nch, "c22TrackWeight"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(30), cent, rndm, nch, nch, "c22TrackWeight"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(31), cent, rndm, nch, nch, "c22TrackWeight"); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(32), cent, rndm, nch, nch, "c32TrackWeight"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(33), cent, rndm, nch, nch, "c32TrackWeight"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(34), cent, rndm, nch, nch, "c32TrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(0), cent, rndm, ptSum, nch, "covV2Pt"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(0), cent, rndm, ptSum, nch, "covV2PtWeightOne", true); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(29), cent, rndm, ptSum, nch, "covV2Pt"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(30), cent, rndm, ptSum, nch, "covV2Pt"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(31), cent, rndm, ptSum, nch, "covV2Pt"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(3), cent, rndm, ptSum, nch, "covV3Pt"); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(32), cent, rndm, ptSum, nch, "covV3Pt"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(33), cent, rndm, ptSum, nch, "covV3Pt"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(34), cent, rndm, ptSum, nch, "covV3Pt"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22GapA), cent, rndm, "c22"); + fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22GapB), cent, rndm, "c22"); + } + + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, nch, nch, "c22TrackWeightOne", true); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC24), cent, rndm, nch, nch, "c24TrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Full), cent, rndm, nch, nch, "c22FullTrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC32Gap), cent, rndm, nch, nch, "c32TrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC34Gap), cent, rndm, nch, nch, "c34TrackWeight"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, ptSum, nch, "covV2PtWeightOne", true); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC32Gap), cent, rndm, ptSum, nch, "covV3Pt"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); fillFC4PtC22(cent, ptSum, nch, rndm); if (nPionWeighted > 0.) { @@ -3131,33 +3440,35 @@ struct PidFlowPtCorr { fillFC4PtC22(cent, rndm, MyParticleType::kProton, protonPtSum, nProtonWeighted); } - fFCCh->FillProfile("hMeanPt", cent, ptSum / nch, nch, rndm); - fFCCh->FillProfile("hMeanPtWeightOne", cent, ptSum / nch, 1., rndm); - if (nPionWeighted > 0.) { + if (switchsOpts.cfgOutputCharged.value) { + fFCCh->FillProfile("hMeanPt", cent, ptSum / nch, nch, rndm); + fFCCh->FillProfile("hMeanPtWeightOne", cent, ptSum / nch, 1., rndm); + } + if (nPionWeighted > 0. && switchsOpts.cfgOutputPion.value) { fFCPi->FillProfile("hMeanPt", cent, pionPtSum / nPionWeighted, nPionWeighted, rndm); fFCPi->FillProfile("hMeanPtWeightOne", cent, pionPtSum / nPionWeighted, 1., rndm); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(29), cent, rndm, pionPtSum, nPionWeighted, "covV2PtPID"); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(29), cent, rndm, nPionWeighted, nPionWeighted, "c22TrackWeightPID"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, pionPtSum, nPionWeighted, "covV2PtPID"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, nPionWeighted, nPionWeighted, "c22TrackWeightPID"); } - if (nKaonWeighted > 0.) { + if (nKaonWeighted > 0. && switchsOpts.cfgOutputKaon.value) { fFCKa->FillProfile("hMeanPt", cent, kaonPtSum / nKaonWeighted, nKaonWeighted, rndm); fFCKa->FillProfile("hMeanPtWeightOne", cent, kaonPtSum / nKaonWeighted, 1., rndm); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(30), cent, rndm, kaonPtSum, nKaonWeighted, "covV2PtPID"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(30), cent, rndm, nKaonWeighted, nKaonWeighted, "c22TrackWeightPID"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, kaonPtSum, nKaonWeighted, "covV2PtPID"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, nKaonWeighted, nKaonWeighted, "c22TrackWeightPID"); } - if (nProtonWeighted > 0.) { + if (nProtonWeighted > 0. && switchsOpts.cfgOutputProton.value) { fFCPr->FillProfile("hMeanPt", cent, protonPtSum / nProtonWeighted, nProtonWeighted, rndm); fFCPr->FillProfile("hMeanPtWeightOne", cent, protonPtSum / nProtonWeighted, 1., rndm); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(31), cent, rndm, protonPtSum, nProtonWeighted, "covV2PtPID"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(31), cent, rndm, nProtonWeighted, nProtonWeighted, "c22TrackWeightPID"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, protonPtSum, nProtonWeighted, "covV2PtPID"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, nProtonWeighted, nProtonWeighted, "c22TrackWeightPID"); } if (switchsOpts.cfgOutPutPtSpectra.value) { - const double nPairCharged = fGFW->Calculate(corrconfigs.at(0), 0, true).real(); - const double chargedC22 = nPairCharged > 0. ? fGFW->Calculate(corrconfigs.at(0), 0, false).real() / nPairCharged : 0.; - const double pidChargedC22Pi = getPidC22InOneEvent(corrconfigs.at(5), corrconfigs.at(6)); - const double pidKaonC22 = getPidC22InOneEvent(corrconfigs.at(7), corrconfigs.at(8)); - const double pidProtonC22 = getPidC22InOneEvent(corrconfigs.at(9), corrconfigs.at(10)); + const double nPairCharged = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), 0, true).real(); + const double chargedC22 = nPairCharged > 0. ? fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), 0, false).real() / nPairCharged : 0.; + const double pidChargedC22Pi = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Pion::kC22GapA), corrconfigs.at(CorrConfigIndex::Pion::kC22GapB)); + const double pidKaonC22 = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Kaon::kC22GapA), corrconfigs.at(CorrConfigIndex::Kaon::kC22GapB)); + const double pidProtonC22 = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Proton::kC22GapA), corrconfigs.at(CorrConfigIndex::Proton::kC22GapB)); if (pidChargedC22Pi > 0. && chargedC22 > 0.) { registry.fill(HIST("c22PrimeVsc22/Pi"), pidChargedC22Pi, chargedC22); } @@ -3170,28 +3481,28 @@ struct PidFlowPtCorr { } const double nchDiff = nch * nch - nchSquare; - if (nchDiff > minVal4Float) { + if (nchDiff > minVal4Float && switchsOpts.cfgOutputCharged.value) { fFCCh->FillProfile("ptSquareAve", cent, (ptSum * ptSum - ptSquareSum) / nchDiff, nchDiff, rndm); fFCCh->FillProfile("ptSquareAveWeightOne", cent, (ptSum * ptSum - ptSquareSum) / nchDiff, 1., rndm); fFCCh->FillProfile("ptAve", cent, (nch * ptSum - ptSumw2) / nchDiff, nchDiff, rndm); fFCCh->FillProfile("ptAveWeightOne", cent, (nch * ptSum - ptSumw2) / nchDiff, 1., rndm); } const double pionDiff = nPionWeighted * nPionWeighted - nPionSquare; - if (pionDiff > minVal4Float) { + if (pionDiff > minVal4Float && switchsOpts.cfgOutputPion.value) { fFCPi->FillProfile("ptSquareAve", cent, (pionPtSum * pionPtSum - pionPtSquareSum) / pionDiff, pionDiff, rndm); fFCPi->FillProfile("ptSquareAveWeightOne", cent, (pionPtSum * pionPtSum - pionPtSquareSum) / pionDiff, 1., rndm); fFCPi->FillProfile("ptAve", cent, (nPionWeighted * pionPtSum - pionPtSumw2) / pionDiff, pionDiff, rndm); fFCPi->FillProfile("ptAveWeightOne", cent, (nPionWeighted * pionPtSum - pionPtSumw2) / pionDiff, 1., rndm); } const double kaonDiff = nKaonWeighted * nKaonWeighted - nKaonSquare; - if (kaonDiff > minVal4Float) { + if (kaonDiff > minVal4Float && switchsOpts.cfgOutputKaon.value) { fFCKa->FillProfile("ptSquareAve", cent, (kaonPtSum * kaonPtSum - kaonPtSquareSum) / kaonDiff, kaonDiff, rndm); fFCKa->FillProfile("ptSquareAveWeightOne", cent, (kaonPtSum * kaonPtSum - kaonPtSquareSum) / kaonDiff, 1., rndm); fFCKa->FillProfile("ptAve", cent, (nKaonWeighted * kaonPtSum - kaonPtSumw2) / kaonDiff, kaonDiff, rndm); fFCKa->FillProfile("ptAveWeightOne", cent, (nKaonWeighted * kaonPtSum - kaonPtSumw2) / kaonDiff, 1., rndm); } const double protonDiff = nProtonWeighted * nProtonWeighted - nProtonSquare; - if (protonDiff > minVal4Float) { + if (protonDiff > minVal4Float && switchsOpts.cfgOutputProton.value) { fFCPr->FillProfile("ptSquareAve", cent, (protonPtSum * protonPtSum - protonPtSquareSum) / protonDiff, protonDiff, rndm); fFCPr->FillProfile("ptSquareAveWeightOne", cent, (protonPtSum * protonPtSum - protonPtSquareSum) / protonDiff, 1., rndm); fFCPr->FillProfile("ptAve", cent, (nProtonWeighted * protonPtSum - protonPtSumw2) / protonDiff, protonDiff, rndm); From 82e6466d68b71c1d14ad63ef175954f635a48e02 Mon Sep 17 00:00:00 2001 From: huinaibing Date: Fri, 14 Aug 2026 18:08:41 +0800 Subject: [PATCH 5/7] change struct to namespace --- PWGCF/Flow/Tasks/pidFlowPtCorr.cxx | 733 +++++++++++++++-------------- 1 file changed, 385 insertions(+), 348 deletions(-) diff --git a/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx b/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx index 8da7295be05..7349b55f9c8 100644 --- a/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx +++ b/PWGCF/Flow/Tasks/pidFlowPtCorr.cxx @@ -72,6 +72,142 @@ using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; +namespace +{ +// Keep the corrconfigs vector layout in one named index table. Namespace +// grouping avoids storing compile-time constants as analysis-task members. +namespace corrConfigIndex +{ +namespace charged +{ +enum : std::size_t { + kC22Gap = 0, + kC24 = 1, + kC22Full = 2, + kC32Gap = 3, + kC34Gap = 4 +}; +} // namespace charged + +namespace pion +{ +enum : std::size_t { + kC22GapA = 5, + kC22GapB = 6, + kC24A = 11, + kC24B = 12, + kC32GapA = 17, + kC32GapB = 18, + kC34A = 23, + kC34B = 24, + kC22Pure = 29, + kC32Pure = 32, + kC22FullA = 35, + kC22FullB = 36 +}; +} // namespace pion + +namespace kaon +{ +enum : std::size_t { + kC22GapA = 7, + kC22GapB = 8, + kC24A = 13, + kC24B = 14, + kC32GapA = 19, + kC32GapB = 20, + kC34A = 25, + kC34B = 26, + kC22Pure = 30, + kC32Pure = 33, + kC22FullA = 37, + kC22FullB = 38 +}; +} // namespace kaon + +namespace proton +{ +enum : std::size_t { + kC22GapA = 9, + kC22GapB = 10, + kC24A = 15, + kC24B = 16, + kC32GapA = 21, + kC32GapB = 22, + kC34A = 27, + kC34B = 28, + kC22Pure = 31, + kC32Pure = 34, + kC22FullA = 39, + kC22FullB = 40 +}; +} // namespace proton + +// Unidentified correlations are appended after the original configurations +// so the charged and identified-particle vector layout remains unchanged. +namespace unidentified +{ +enum : std::size_t { + kC22GapA = 41, + kC22GapB = 42, + kC24A = 43, + kC24B = 44, + kC22Pure = 45, + kC22FullA = 46, + kC22FullB = 47 +}; +} // namespace unidentified + +enum : std::size_t { + kCount = 48 +}; +} // namespace corrConfigIndex + +// GFW region bitmasks are grouped by particle type and region role. POI and +// overlap use distinct bits because the overlap weight can differ from POI. +namespace gfwBitMask +{ +namespace charged +{ +enum : int { + kReference = 1 << 0 +}; +} // namespace charged + +namespace pion +{ +enum : int { + kPOI = 1 << 1, + kOverlap = 1 << 4 +}; +} // namespace pion + +namespace kaon +{ +enum : int { + kPOI = 1 << 2, + kOverlap = 1 << 5 +}; +} // namespace kaon + +namespace proton +{ +enum : int { + kPOI = 1 << 3, + kOverlap = 1 << 6 +}; +} // namespace proton + +namespace unidentified +{ +enum : int { + kPOI = 1 << 7, + kOverlap = 1 << 8 +}; +} // namespace unidentified +} // namespace gfwBitMask +} // namespace + struct PidFlowPtCorr { // configurable double minVal4Float = 1e-3; @@ -314,105 +450,6 @@ struct PidFlowPtCorr { kNumberOfParticles }; - // Keep the vector layout in one named index table. The nested particle groups - // make each corrconfigs access describe both the particle and correlator type. - struct CorrConfigIndex { - struct Charged { - static constexpr std::size_t kC22Gap = 0; - static constexpr std::size_t kC24 = 1; - static constexpr std::size_t kC22Full = 2; - static constexpr std::size_t kC32Gap = 3; - static constexpr std::size_t kC34Gap = 4; - }; - - struct Pion { - static constexpr std::size_t kC22GapA = 5; - static constexpr std::size_t kC22GapB = 6; - static constexpr std::size_t kC24A = 11; - static constexpr std::size_t kC24B = 12; - static constexpr std::size_t kC32GapA = 17; - static constexpr std::size_t kC32GapB = 18; - static constexpr std::size_t kC34A = 23; - static constexpr std::size_t kC34B = 24; - static constexpr std::size_t kC22Pure = 29; - static constexpr std::size_t kC32Pure = 32; - static constexpr std::size_t kC22FullA = 35; - static constexpr std::size_t kC22FullB = 36; - }; - - struct Kaon { - static constexpr std::size_t kC22GapA = 7; - static constexpr std::size_t kC22GapB = 8; - static constexpr std::size_t kC24A = 13; - static constexpr std::size_t kC24B = 14; - static constexpr std::size_t kC32GapA = 19; - static constexpr std::size_t kC32GapB = 20; - static constexpr std::size_t kC34A = 25; - static constexpr std::size_t kC34B = 26; - static constexpr std::size_t kC22Pure = 30; - static constexpr std::size_t kC32Pure = 33; - static constexpr std::size_t kC22FullA = 37; - static constexpr std::size_t kC22FullB = 38; - }; - - struct Proton { - static constexpr std::size_t kC22GapA = 9; - static constexpr std::size_t kC22GapB = 10; - static constexpr std::size_t kC24A = 15; - static constexpr std::size_t kC24B = 16; - static constexpr std::size_t kC32GapA = 21; - static constexpr std::size_t kC32GapB = 22; - static constexpr std::size_t kC34A = 27; - static constexpr std::size_t kC34B = 28; - static constexpr std::size_t kC22Pure = 31; - static constexpr std::size_t kC32Pure = 34; - static constexpr std::size_t kC22FullA = 39; - static constexpr std::size_t kC22FullB = 40; - }; - - // Unidentified correlations are appended after the original configurations - // so the charged and identified-particle vector layout remains unchanged. - struct Unidentified { - static constexpr std::size_t kC22GapA = 41; - static constexpr std::size_t kC22GapB = 42; - static constexpr std::size_t kC24A = 43; - static constexpr std::size_t kC24B = 44; - static constexpr std::size_t kC22Pure = 45; - static constexpr std::size_t kC22FullA = 46; - static constexpr std::size_t kC22FullB = 47; - }; - - static constexpr std::size_t kCount = 48; - }; - - // GFW region bitmasks are grouped by particle type and region role. POI and - // overlap use distinct bits because the overlap weight can differ from POI. - struct GFWBitMask { - struct Charged { - static constexpr int kReference = 1 << 0; - }; - - struct Pion { - static constexpr int kPOI = 1 << 1; - static constexpr int kOverlap = 1 << 4; - }; - - struct Kaon { - static constexpr int kPOI = 1 << 2; - static constexpr int kOverlap = 1 << 5; - }; - - struct Proton { - static constexpr int kPOI = 1 << 3; - static constexpr int kOverlap = 1 << 6; - }; - - struct Unidentified { - static constexpr int kPOI = 1 << 7; - static constexpr int kOverlap = 1 << 8; - }; - }; - bool isParticleOutputEnabled(MyParticleType type) { switch (type) { @@ -904,47 +941,47 @@ struct PidFlowPtCorr { double etaMax = trkQualityOpts.cfgCutEta.value; double etaGap = cfgEtaGap; // Charged reference regions. - fGFW->AddRegion("reffull", -etaMax, etaMax, 1, GFWBitMask::Charged::kReference); // ("name", etamin, etamax, ptbinnum, bitmask)eta region -0.8 to 0.8 - fGFW->AddRegion("refN08", -etaMax, -etaGap, 1, GFWBitMask::Charged::kReference); - fGFW->AddRegion("refP08", etaGap, etaMax, 1, GFWBitMask::Charged::kReference); - fGFW->AddRegion("refN", -etaMax, 0, 1, GFWBitMask::Charged::kReference); - fGFW->AddRegion("refP", 0, etaMax, 1, GFWBitMask::Charged::kReference); + fGFW->AddRegion("reffull", -etaMax, etaMax, 1, gfwBitMask::charged::kReference); // ("name", etamin, etamax, ptbinnum, bitmask)eta region -0.8 to 0.8 + fGFW->AddRegion("refN08", -etaMax, -etaGap, 1, gfwBitMask::charged::kReference); + fGFW->AddRegion("refP08", etaGap, etaMax, 1, gfwBitMask::charged::kReference); + fGFW->AddRegion("refN", -etaMax, 0, 1, gfwBitMask::charged::kReference); + fGFW->AddRegion("refP", 0, etaMax, 1, gfwBitMask::charged::kReference); // Pion POI and overlap regions. - fGFW->AddRegion("poiPiN08", -etaMax, -etaGap, 1, GFWBitMask::Pion::kPOI); - fGFW->AddRegion("poiPiP08", etaGap, etaMax, 1, GFWBitMask::Pion::kPOI); - fGFW->AddRegion("poiPiN", -etaMax, 0, 1, GFWBitMask::Pion::kPOI); - fGFW->AddRegion("poiPiP", 0, etaMax, 1, GFWBitMask::Pion::kPOI); + fGFW->AddRegion("poiPiN08", -etaMax, -etaGap, 1, gfwBitMask::pion::kPOI); + fGFW->AddRegion("poiPiP08", etaGap, etaMax, 1, gfwBitMask::pion::kPOI); + fGFW->AddRegion("poiPiN", -etaMax, 0, 1, gfwBitMask::pion::kPOI); + fGFW->AddRegion("poiPiP", 0, etaMax, 1, gfwBitMask::pion::kPOI); - fGFW->AddRegion("olPiN", -etaMax, 0, 1, GFWBitMask::Pion::kOverlap); - fGFW->AddRegion("olPiP", 0, etaMax, 1, GFWBitMask::Pion::kOverlap); + fGFW->AddRegion("olPiN", -etaMax, 0, 1, gfwBitMask::pion::kOverlap); + fGFW->AddRegion("olPiP", 0, etaMax, 1, gfwBitMask::pion::kOverlap); // Kaon POI and overlap regions. - fGFW->AddRegion("poiKaN08", -etaMax, -etaGap, 1, GFWBitMask::Kaon::kPOI); - fGFW->AddRegion("poiKaP08", etaGap, etaMax, 1, GFWBitMask::Kaon::kPOI); - fGFW->AddRegion("poiKaN", -etaMax, 0, 1, GFWBitMask::Kaon::kPOI); - fGFW->AddRegion("poiKaP", 0, etaMax, 1, GFWBitMask::Kaon::kPOI); + fGFW->AddRegion("poiKaN08", -etaMax, -etaGap, 1, gfwBitMask::kaon::kPOI); + fGFW->AddRegion("poiKaP08", etaGap, etaMax, 1, gfwBitMask::kaon::kPOI); + fGFW->AddRegion("poiKaN", -etaMax, 0, 1, gfwBitMask::kaon::kPOI); + fGFW->AddRegion("poiKaP", 0, etaMax, 1, gfwBitMask::kaon::kPOI); - fGFW->AddRegion("olKaN", -etaMax, 0, 1, GFWBitMask::Kaon::kOverlap); - fGFW->AddRegion("olKaP", 0, etaMax, 1, GFWBitMask::Kaon::kOverlap); + fGFW->AddRegion("olKaN", -etaMax, 0, 1, gfwBitMask::kaon::kOverlap); + fGFW->AddRegion("olKaP", 0, etaMax, 1, gfwBitMask::kaon::kOverlap); // Proton POI and overlap regions. - fGFW->AddRegion("poiPrN08", -etaMax, -etaGap, 1, GFWBitMask::Proton::kPOI); - fGFW->AddRegion("poiPrP08", etaGap, etaMax, 1, GFWBitMask::Proton::kPOI); - fGFW->AddRegion("poiPrN", -etaMax, 0, 1, GFWBitMask::Proton::kPOI); - fGFW->AddRegion("poiPrP", 0, etaMax, 1, GFWBitMask::Proton::kPOI); + fGFW->AddRegion("poiPrN08", -etaMax, -etaGap, 1, gfwBitMask::proton::kPOI); + fGFW->AddRegion("poiPrP08", etaGap, etaMax, 1, gfwBitMask::proton::kPOI); + fGFW->AddRegion("poiPrN", -etaMax, 0, 1, gfwBitMask::proton::kPOI); + fGFW->AddRegion("poiPrP", 0, etaMax, 1, gfwBitMask::proton::kPOI); - fGFW->AddRegion("olPrN", -etaMax, 0, 1, GFWBitMask::Proton::kOverlap); - fGFW->AddRegion("olPrP", 0, etaMax, 1, GFWBitMask::Proton::kOverlap); + fGFW->AddRegion("olPrN", -etaMax, 0, 1, gfwBitMask::proton::kOverlap); + fGFW->AddRegion("olPrP", 0, etaMax, 1, gfwBitMask::proton::kOverlap); // Tracks for which the PID selection returns -1. They use the charged // pT range and corrections, but have independent POI and overlap masks. - fGFW->AddRegion("poiUnidentifiedN08", -etaMax, -etaGap, 1, GFWBitMask::Unidentified::kPOI); - fGFW->AddRegion("poiUnidentifiedP08", etaGap, etaMax, 1, GFWBitMask::Unidentified::kPOI); - fGFW->AddRegion("poiUnidentifiedN", -etaMax, 0, 1, GFWBitMask::Unidentified::kPOI); - fGFW->AddRegion("poiUnidentifiedP", 0, etaMax, 1, GFWBitMask::Unidentified::kPOI); - fGFW->AddRegion("olUnidentifiedN", -etaMax, 0, 1, GFWBitMask::Unidentified::kOverlap); - fGFW->AddRegion("olUnidentifiedP", 0, etaMax, 1, GFWBitMask::Unidentified::kOverlap); + fGFW->AddRegion("poiUnidentifiedN08", -etaMax, -etaGap, 1, gfwBitMask::unidentified::kPOI); + fGFW->AddRegion("poiUnidentifiedP08", etaGap, etaMax, 1, gfwBitMask::unidentified::kPOI); + fGFW->AddRegion("poiUnidentifiedN", -etaMax, 0, 1, gfwBitMask::unidentified::kPOI); + fGFW->AddRegion("poiUnidentifiedP", 0, etaMax, 1, gfwBitMask::unidentified::kPOI); + fGFW->AddRegion("olUnidentifiedN", -etaMax, 0, 1, gfwBitMask::unidentified::kOverlap); + fGFW->AddRegion("olUnidentifiedP", 0, etaMax, 1, gfwBitMask::unidentified::kOverlap); // end data region add // pushback @@ -1002,8 +1039,8 @@ struct PidFlowPtCorr { corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiUnidentifiedN {2} refP {-2}", "Unidentified0gap22a", false)); corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiUnidentifiedP {2} refN {-2}", "Unidentified0gap22b", false)); // 47 - if (corrconfigs.size() != CorrConfigIndex::kCount) { - LOGF(fatal, "Correlation index table expects %zu configurations, but %zu were created", CorrConfigIndex::kCount, corrconfigs.size()); + if (corrconfigs.size() != corrConfigIndex::kCount) { + LOGF(fatal, "Correlation index table expects %zu configurations, but %zu were created", static_cast(corrConfigIndex::kCount), corrconfigs.size()); } fGFW->CreateRegions(); // finalize the initialization @@ -1423,13 +1460,13 @@ struct PidFlowPtCorr { } double dnx = 0.0, val = 0.0; - dnx = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), 0, true).real(); + dnx = fGFW->Calculate(corrconfigs.at(corrConfigIndex::charged::kC22Gap), 0, true).real(); if (dnx == 0) { return; } // <2> - val = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), 0, false).real() / dnx; + val = fGFW->Calculate(corrconfigs.at(corrConfigIndex::charged::kC22Gap), 0, false).real() / dnx; if (std::fabs(val) >= 1) { return; } @@ -1460,13 +1497,13 @@ struct PidFlowPtCorr { // <2> double dnx = 0.0, val = 0.0; - dnx = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), 0, true).real(); + dnx = fGFW->Calculate(corrconfigs.at(corrConfigIndex::charged::kC22Gap), 0, true).real(); if (dnx == 0) { return; } // <2> - val = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), 0, false).real() / dnx; + val = fGFW->Calculate(corrconfigs.at(corrConfigIndex::charged::kC22Gap), 0, false).real() / dnx; if (std::fabs(val) >= 1) { return; } @@ -1475,12 +1512,12 @@ struct PidFlowPtCorr { double npairPid = 0; switch (type) { case MyParticleType::kPion: - pidc22 = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Pion::kC22GapA), corrconfigs.at(CorrConfigIndex::Pion::kC22GapB)); + pidc22 = getPidC22InOneEvent(corrconfigs.at(corrConfigIndex::pion::kC22GapA), corrconfigs.at(corrConfigIndex::pion::kC22GapB)); if (pidc22 == 0) { return; } - npairPid = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Pion::kC22GapA), 0, true).real() + fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Pion::kC22GapB), 0, true).real(); + npairPid = fGFW->Calculate(corrconfigs.at(corrConfigIndex::pion::kC22GapA), 0, true).real() + fGFW->Calculate(corrconfigs.at(corrConfigIndex::pion::kC22GapB), 0, true).real(); if (npairPid == 0) { return; } @@ -1496,12 +1533,12 @@ struct PidFlowPtCorr { fFCPi->FillProfile("hMeanPtWeightCharged", cent, (pidPtSum / nPid), dnx * nPid, rndm); if (switchsOpts.cfgAddMeanPtCentNbsHistograms.value && switchsOpts.cfgClosureTest.value != 0) { - double npair4c22pure = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), 0, true).real(); + double npair4c22pure = fGFW->Calculate(corrconfigs.at(corrConfigIndex::pion::kC22Pure), 0, true).real(); if (npair4c22pure > minVal4Float) { registry.fill(HIST("meanptCentNbs/hPionMeanptWeightC22pure"), pidPtSum / nPid, cent, rndm * cfgFlowNbootstrap, pidPtSum / nPid, - nPid * npairPid * fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), 0, false).real() / npair4c22pure); + nPid * npairPid * fGFW->Calculate(corrconfigs.at(corrConfigIndex::pion::kC22Pure), 0, false).real() / npair4c22pure); } registry.fill(HIST("meanptCentNbs/hPionMeanptWeightMeanpt"), @@ -1518,12 +1555,12 @@ struct PidFlowPtCorr { // end pion case MyParticleType::kKaon: - pidc22 = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Kaon::kC22GapA), corrconfigs.at(CorrConfigIndex::Kaon::kC22GapB)); + pidc22 = getPidC22InOneEvent(corrconfigs.at(corrConfigIndex::kaon::kC22GapA), corrconfigs.at(corrConfigIndex::kaon::kC22GapB)); if (pidc22 == 0) { return; } - npairPid = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Kaon::kC22GapA), 0, true).real() + fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Kaon::kC22GapB), 0, true).real(); + npairPid = fGFW->Calculate(corrconfigs.at(corrConfigIndex::kaon::kC22GapA), 0, true).real() + fGFW->Calculate(corrconfigs.at(corrConfigIndex::kaon::kC22GapB), 0, true).real(); if (npairPid == 0) { return; } @@ -1542,12 +1579,12 @@ struct PidFlowPtCorr { // end kaon case MyParticleType::kProton: - pidc22 = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Proton::kC22GapA), corrconfigs.at(CorrConfigIndex::Proton::kC22GapB)); + pidc22 = getPidC22InOneEvent(corrconfigs.at(corrConfigIndex::proton::kC22GapA), corrconfigs.at(corrConfigIndex::proton::kC22GapB)); if (pidc22 == 0) { return; } - npairPid = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Proton::kC22GapA), 0, true).real() + fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Proton::kC22GapB), 0, true).real(); + npairPid = fGFW->Calculate(corrconfigs.at(corrConfigIndex::proton::kC22GapA), 0, true).real() + fGFW->Calculate(corrconfigs.at(corrConfigIndex::proton::kC22GapB), 0, true).real(); if (npairPid == 0) { return; } @@ -1566,12 +1603,12 @@ struct PidFlowPtCorr { // end proton case MyParticleType::kUnidentified: - pidc22 = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Unidentified::kC22GapA), corrconfigs.at(CorrConfigIndex::Unidentified::kC22GapB)); + pidc22 = getPidC22InOneEvent(corrconfigs.at(corrConfigIndex::unidentified::kC22GapA), corrconfigs.at(corrConfigIndex::unidentified::kC22GapB)); if (pidc22 == 0) { return; } - npairPid = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Unidentified::kC22GapA), 0, true).real() + fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Unidentified::kC22GapB), 0, true).real(); + npairPid = fGFW->Calculate(corrconfigs.at(corrConfigIndex::unidentified::kC22GapA), 0, true).real() + fGFW->Calculate(corrconfigs.at(corrConfigIndex::unidentified::kC22GapB), 0, true).real(); if (npairPid == 0) { return; } @@ -2638,7 +2675,7 @@ struct PidFlowPtCorr { } // Fill the charged reference regions. - fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, GFWBitMask::Charged::kReference); //(eta, ptbin, phi, wacc*weff, bitmask) + fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, gfwBitMask::charged::kReference); //(eta, ptbin, phi, wacc*weff, bitmask) } // ------------------------------ @@ -2648,8 +2685,8 @@ struct PidFlowPtCorr { if (pid == -1 && withinPtRefGlobal) { // Unidentified tracks have no PID-specific correction. Reuse exactly // the charged NUA/NUE (including the optional local-density factor). - fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, GFWBitMask::Unidentified::kPOI); - fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, GFWBitMask::Unidentified::kOverlap, wacc * weff); + fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, gfwBitMask::unidentified::kPOI); + fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, gfwBitMask::unidentified::kOverlap, wacc * weff); } else if (isWithinPOIPtRange(pid, track.pt())) { float waccPid = 1; float weffPid = 1; @@ -2658,8 +2695,8 @@ struct PidFlowPtCorr { // Fill GFW and counters using the same species-specific POI pT range. if (pid == MyParticleType::kPion) { - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Pion::kPOI); - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Pion::kOverlap, wacc * weff); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, gfwBitMask::pion::kPOI); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, gfwBitMask::pion::kOverlap, wacc * weff); registry.fill(HIST("hPhiPi"), track.phi()); registry.fill(HIST("hPhicorrPi"), track.phi(), waccPid); registry.fill(HIST("hPhiCorrNUANUEPi"), track.phi(), waccPid * weffPid); @@ -2667,8 +2704,8 @@ struct PidFlowPtCorr { registry.fill(HIST("hPtCorrPi"), track.pt(), weffPid); numOfPi++; } else if (pid == MyParticleType::kKaon) { - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Kaon::kPOI); - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Kaon::kOverlap, wacc * weff); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, gfwBitMask::kaon::kPOI); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, gfwBitMask::kaon::kOverlap, wacc * weff); registry.fill(HIST("hPhiKa"), track.phi()); registry.fill(HIST("hPhicorrKa"), track.phi(), waccPid); registry.fill(HIST("hPhiCorrNUANUEKa"), track.phi(), waccPid * weffPid); @@ -2676,8 +2713,8 @@ struct PidFlowPtCorr { registry.fill(HIST("hPtCorrKa"), track.pt(), weffPid); numOfKa++; } else if (pid == MyParticleType::kProton) { - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Proton::kPOI); - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Proton::kOverlap, wacc * weff); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, gfwBitMask::proton::kPOI); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, gfwBitMask::proton::kOverlap, wacc * weff); registry.fill(HIST("hPhiPr"), track.phi()); registry.fill(HIST("hPhicorrPr"), track.phi(), waccPid); registry.fill(HIST("hPhiCorrNUANUEPr"), track.phi(), waccPid * weffPid); @@ -2703,98 +2740,98 @@ struct PidFlowPtCorr { // fill hist using fGFW if (nch > 0) { - fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, "c22"); - fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC24), cent, rndm, "c24"); - fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Full), cent, rndm, "c22Full"); - fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC32Gap), cent, rndm, "c32"); - fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC34Gap), cent, rndm, "c34"); - - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22FullA), cent, rndm, "c22Full"); - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22FullB), cent, rndm, "c22Full"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22FullA), cent, rndm, "c22Full"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22FullB), cent, rndm, "c22Full"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22FullA), cent, rndm, "c22Full"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22FullB), cent, rndm, "c22Full"); - fillFC(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22FullA), cent, rndm, "c22Full"); - fillFC(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22FullB), cent, rndm, "c22Full"); - - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC24A), cent, rndm, "c24"); - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC24B), cent, rndm, "c24"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC24A), cent, rndm, "c24"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC24B), cent, rndm, "c24"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC24A), cent, rndm, "c24"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC24B), cent, rndm, "c24"); - fillFC(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC24A), cent, rndm, "c24"); - fillFC(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC24B), cent, rndm, "c24"); - - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32GapA), cent, rndm, "c32"); - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32GapB), cent, rndm, "c32"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32GapA), cent, rndm, "c32"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32GapB), cent, rndm, "c32"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32GapA), cent, rndm, "c32"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32GapB), cent, rndm, "c32"); - - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC34A), cent, rndm, "c34"); - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC34B), cent, rndm, "c34"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC34A), cent, rndm, "c34"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC34B), cent, rndm, "c34"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC34A), cent, rndm, "c34"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC34B), cent, rndm, "c34"); - - bool filledPi = fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, "c22pure"); - bool filledKa = fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, "c22pure"); - bool filledPr = fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, "c22pure"); - bool filledUnidentified = fillFC(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22Pure), cent, rndm, "c22pure"); - - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32Pure), cent, rndm, "c32pure"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32Pure), cent, rndm, "c32pure"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32Pure), cent, rndm, "c32pure"); + fillFC(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC22Gap), cent, rndm, "c22"); + fillFC(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC24), cent, rndm, "c24"); + fillFC(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC22Full), cent, rndm, "c22Full"); + fillFC(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC32Gap), cent, rndm, "c32"); + fillFC(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC34Gap), cent, rndm, "c34"); + + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22FullA), cent, rndm, "c22Full"); + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22FullB), cent, rndm, "c22Full"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22FullA), cent, rndm, "c22Full"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22FullB), cent, rndm, "c22Full"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22FullA), cent, rndm, "c22Full"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22FullB), cent, rndm, "c22Full"); + fillFC(MyParticleType::kUnidentified, corrconfigs.at(corrConfigIndex::unidentified::kC22FullA), cent, rndm, "c22Full"); + fillFC(MyParticleType::kUnidentified, corrconfigs.at(corrConfigIndex::unidentified::kC22FullB), cent, rndm, "c22Full"); + + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC24A), cent, rndm, "c24"); + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC24B), cent, rndm, "c24"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC24A), cent, rndm, "c24"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC24B), cent, rndm, "c24"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC24A), cent, rndm, "c24"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC24B), cent, rndm, "c24"); + fillFC(MyParticleType::kUnidentified, corrconfigs.at(corrConfigIndex::unidentified::kC24A), cent, rndm, "c24"); + fillFC(MyParticleType::kUnidentified, corrconfigs.at(corrConfigIndex::unidentified::kC24B), cent, rndm, "c24"); + + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC32GapA), cent, rndm, "c32"); + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC32GapB), cent, rndm, "c32"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC32GapA), cent, rndm, "c32"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC32GapB), cent, rndm, "c32"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC32GapA), cent, rndm, "c32"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC32GapB), cent, rndm, "c32"); + + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC34A), cent, rndm, "c34"); + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC34B), cent, rndm, "c34"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC34A), cent, rndm, "c34"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC34B), cent, rndm, "c34"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC34A), cent, rndm, "c34"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC34B), cent, rndm, "c34"); + + bool filledPi = fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22Pure), cent, rndm, "c22pure"); + bool filledKa = fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22Pure), cent, rndm, "c22pure"); + bool filledPr = fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22Pure), cent, rndm, "c22pure"); + bool filledUnidentified = fillFC(MyParticleType::kUnidentified, corrconfigs.at(corrConfigIndex::unidentified::kC22Pure), cent, rndm, "c22pure"); + + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC32Pure), cent, rndm, "c32pure"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC32Pure), cent, rndm, "c32pure"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC32Pure), cent, rndm, "c32pure"); if (filledPi || !switchsOpts.cfgCheck2MethodDiff.value) { - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22GapA), cent, rndm, "c22"); - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22GapB), cent, rndm, "c22"); + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22GapA), cent, rndm, "c22"); + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22GapB), cent, rndm, "c22"); } if (filledKa || !switchsOpts.cfgCheck2MethodDiff.value) { - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22GapA), cent, rndm, "c22"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22GapB), cent, rndm, "c22"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22GapA), cent, rndm, "c22"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22GapB), cent, rndm, "c22"); } if (filledPr || !switchsOpts.cfgCheck2MethodDiff.value) { - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22GapA), cent, rndm, "c22"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22GapB), cent, rndm, "c22"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22GapA), cent, rndm, "c22"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22GapB), cent, rndm, "c22"); } if (filledUnidentified || !switchsOpts.cfgCheck2MethodDiff.value) { - fillFC(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22GapA), cent, rndm, "c22"); - fillFC(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22GapB), cent, rndm, "c22"); + fillFC(MyParticleType::kUnidentified, corrconfigs.at(corrConfigIndex::unidentified::kC22GapA), cent, rndm, "c22"); + fillFC(MyParticleType::kUnidentified, corrconfigs.at(corrConfigIndex::unidentified::kC22GapB), cent, rndm, "c22"); } - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, nch, nch, "c22TrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, nch, nch, "c22TrackWeightOne", true); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC22Gap), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC22Gap), cent, rndm, nch, nch, "c22TrackWeightOne", true); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC24), cent, rndm, nch, nch, "c24TrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Full), cent, rndm, nch, nch, "c22FullTrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC32Gap), cent, rndm, nch, nch, "c32TrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC34Gap), cent, rndm, nch, nch, "c34TrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC24), cent, rndm, nch, nch, "c24TrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC22Full), cent, rndm, nch, nch, "c22FullTrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC32Gap), cent, rndm, nch, nch, "c32TrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC34Gap), cent, rndm, nch, nch, "c34TrackWeight"); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); - fillFCvnpt(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kUnidentified, corrconfigs.at(corrConfigIndex::unidentified::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, ptSum, nch, "covV2Pt"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, ptSum, nch, "covV2PtWeightOne", true); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC22Gap), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC22Gap), cent, rndm, ptSum, nch, "covV2PtWeightOne", true); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); - fillFCvnpt(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kUnidentified, corrconfigs.at(corrConfigIndex::unidentified::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC32Gap), cent, rndm, ptSum, nch, "covV3Pt"); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC32Gap), cent, rndm, ptSum, nch, "covV3Pt"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); fillFC4PtC22(cent, ptSum, nch, rndm); if (nPionWeighted > 0) { @@ -2814,26 +2851,26 @@ struct PidFlowPtCorr { if (switchsOpts.cfgOutPutPtSpectra.value) { // charged calculation - double NpairCharged = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), 0, true).real(); - double chargedC22 = NpairCharged > 0 ? fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), 0, false).real() / NpairCharged : 0; + double NpairCharged = fGFW->Calculate(corrconfigs.at(corrConfigIndex::charged::kC22Gap), 0, true).real(); + double chargedC22 = NpairCharged > 0 ? fGFW->Calculate(corrconfigs.at(corrConfigIndex::charged::kC22Gap), 0, false).real() / NpairCharged : 0; // end charged calculation // pi - double pidChargedC22Pi = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Pion::kC22GapA), corrconfigs.at(CorrConfigIndex::Pion::kC22GapB)); + double pidChargedC22Pi = getPidC22InOneEvent(corrconfigs.at(corrConfigIndex::pion::kC22GapA), corrconfigs.at(corrConfigIndex::pion::kC22GapB)); if (pidChargedC22Pi > 0 && chargedC22 > 0) { registry.fill(HIST("c22PrimeVsc22/Pi"), pidChargedC22Pi, chargedC22); } // end pi // Ka - double pidKaonC22 = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Kaon::kC22GapA), corrconfigs.at(CorrConfigIndex::Kaon::kC22GapB)); + double pidKaonC22 = getPidC22InOneEvent(corrconfigs.at(corrConfigIndex::kaon::kC22GapA), corrconfigs.at(corrConfigIndex::kaon::kC22GapB)); if (pidKaonC22 > 0 && chargedC22 > 0) { registry.fill(HIST("c22PrimeVsc22/Ka"), pidKaonC22, chargedC22); } // end Ka // Pr - double pidProtonC22 = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Proton::kC22GapA), corrconfigs.at(CorrConfigIndex::Proton::kC22GapB)); + double pidProtonC22 = getPidC22InOneEvent(corrconfigs.at(corrConfigIndex::proton::kC22GapA), corrconfigs.at(corrConfigIndex::proton::kC22GapB)); if (pidProtonC22 > 0 && chargedC22 > 0) { registry.fill(HIST("c22PrimeVsc22/Pr"), pidProtonC22, chargedC22); } @@ -2848,29 +2885,29 @@ struct PidFlowPtCorr { if (nPionWeighted > 0 && switchsOpts.cfgOutputPion.value) { fFCPi->FillProfile("hMeanPt", cent, (pionPtSum / nPionWeighted), nPionWeighted, rndm); fFCPi->FillProfile("hMeanPtWeightOne", cent, (pionPtSum / nPionWeighted), 1., rndm); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, pionPtSum, nPionWeighted, "covV2PtPID"); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, nPionWeighted, nPionWeighted, "c22TrackWeightPID"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22Pure), cent, rndm, pionPtSum, nPionWeighted, "covV2PtPID"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22Pure), cent, rndm, nPionWeighted, nPionWeighted, "c22TrackWeightPID"); } if (nKaonWeighted > 0 && switchsOpts.cfgOutputKaon.value) { fFCKa->FillProfile("hMeanPt", cent, (kaonPtSum / nKaonWeighted), nKaonWeighted, rndm); fFCKa->FillProfile("hMeanPtWeightOne", cent, (kaonPtSum / nKaonWeighted), 1., rndm); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, kaonPtSum, nKaonWeighted, "covV2PtPID"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, nKaonWeighted, nKaonWeighted, "c22TrackWeightPID"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22Pure), cent, rndm, kaonPtSum, nKaonWeighted, "covV2PtPID"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22Pure), cent, rndm, nKaonWeighted, nKaonWeighted, "c22TrackWeightPID"); } if (nProtonWeighted > 0 && switchsOpts.cfgOutputProton.value) { fFCPr->FillProfile("hMeanPt", cent, (protonPtSum / nProtonWeighted), nProtonWeighted, rndm); fFCPr->FillProfile("hMeanPtWeightOne", cent, (protonPtSum / nProtonWeighted), 1., rndm); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, protonPtSum, nProtonWeighted, "covV2PtPID"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, nProtonWeighted, nProtonWeighted, "c22TrackWeightPID"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22Pure), cent, rndm, protonPtSum, nProtonWeighted, "covV2PtPID"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22Pure), cent, rndm, nProtonWeighted, nProtonWeighted, "c22TrackWeightPID"); } if (nUnidentifiedWeighted > 0 && switchsOpts.cfgOutputUnidentified.value) { fFCUnidentified->FillProfile("hMeanPt", cent, unidentifiedPtSum / nUnidentifiedWeighted, nUnidentifiedWeighted, rndm); fFCUnidentified->FillProfile("hMeanPtWeightOne", cent, unidentifiedPtSum / nUnidentifiedWeighted, 1., rndm); - fillFCvnpt(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22Pure), cent, rndm, unidentifiedPtSum, nUnidentifiedWeighted, "covV2PtPID"); - fillFCvnpt(MyParticleType::kUnidentified, corrconfigs.at(CorrConfigIndex::Unidentified::kC22Pure), cent, rndm, nUnidentifiedWeighted, nUnidentifiedWeighted, "c22TrackWeightPID"); + fillFCvnpt(MyParticleType::kUnidentified, corrconfigs.at(corrConfigIndex::unidentified::kC22Pure), cent, rndm, unidentifiedPtSum, nUnidentifiedWeighted, "covV2PtPID"); + fillFCvnpt(MyParticleType::kUnidentified, corrconfigs.at(corrConfigIndex::unidentified::kC22Pure), cent, rndm, nUnidentifiedWeighted, nUnidentifiedWeighted, "c22TrackWeightPID"); } double nchDiff = nch * nch - nchSquare; @@ -3123,12 +3160,12 @@ struct PidFlowPtCorr { } } /// @note passed selection: global cut + pt cut - fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, GFWBitMask::Charged::kReference); + fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, gfwBitMask::charged::kReference); } const int pid = getPidConfigurable(track); if (pid == -1 && withinPtRef) { - fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, GFWBitMask::Unidentified::kPOI); + fGFW->Fill(track.eta(), 0, track.phi(), wacc * weff, gfwBitMask::unidentified::kPOI); continue; } if (!isWithinPOIPtRange(pid, track.pt())) { @@ -3141,11 +3178,11 @@ struct PidFlowPtCorr { setParticleNUAWeight(waccPid, track, vtxz, pid); if (pid == MyParticleType::kPion) { - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Pion::kPOI); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, gfwBitMask::pion::kPOI); } else if (pid == MyParticleType::kKaon) { - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Kaon::kPOI); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, gfwBitMask::kaon::kPOI); } else if (pid == MyParticleType::kProton) { - fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, GFWBitMask::Proton::kPOI); + fGFW->Fill(track.eta(), 0, track.phi(), waccPid * weffPid, gfwBitMask::proton::kPOI); } } @@ -3156,51 +3193,51 @@ struct PidFlowPtCorr { } if (nPionWeighted > 0. && switchsOpts.cfgOutputPion.value) { registry.fill(HIST("c22DeltaPt/hMeanPtPion"), cent, rndm * cfgFlowNbootstrap, pionPtSum / nPionWeighted, nPionWeighted); - fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), HIST("c22DeltaPt/c22dmeanptPionRefRef"), cent, pionPtSum, nPionWeighted, rndm); + fillProfilePOIvnpt(corrconfigs.at(corrConfigIndex::charged::kC22Gap), HIST("c22DeltaPt/c22dmeanptPionRefRef"), cent, pionPtSum, nPionWeighted, rndm); } if (nKaonWeighted > 0. && switchsOpts.cfgOutputKaon.value) { registry.fill(HIST("c22DeltaPt/hMeanPtKaon"), cent, rndm * cfgFlowNbootstrap, kaonPtSum / nKaonWeighted, nKaonWeighted); - fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), HIST("c22DeltaPt/c22dmeanptKaonRefRef"), cent, kaonPtSum, nKaonWeighted, rndm); + fillProfilePOIvnpt(corrconfigs.at(corrConfigIndex::charged::kC22Gap), HIST("c22DeltaPt/c22dmeanptKaonRefRef"), cent, kaonPtSum, nKaonWeighted, rndm); } if (nProtonWeighted > 0. && switchsOpts.cfgOutputProton.value) { registry.fill(HIST("c22DeltaPt/hMeanPtProton"), cent, rndm * cfgFlowNbootstrap, protonPtSum / nProtonWeighted, nProtonWeighted); - fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), HIST("c22DeltaPt/c22dmeanptProtonRefRef"), cent, protonPtSum, nProtonWeighted, rndm); + fillProfilePOIvnpt(corrconfigs.at(corrConfigIndex::charged::kC22Gap), HIST("c22DeltaPt/c22dmeanptProtonRefRef"), cent, protonPtSum, nProtonWeighted, rndm); } if (nUnidentifiedWeighted > 0. && switchsOpts.cfgOutputUnidentified.value) { registry.fill(HIST("c22DeltaPt/hMeanPtUnidentified"), cent, rndm * cfgFlowNbootstrap, unidentifiedPtSum / nUnidentifiedWeighted, nUnidentifiedWeighted); - fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), HIST("c22DeltaPt/c22dmeanptUnidentifiedRefRef"), cent, unidentifiedPtSum, nUnidentifiedWeighted, rndm); + fillProfilePOIvnpt(corrconfigs.at(corrConfigIndex::charged::kC22Gap), HIST("c22DeltaPt/c22dmeanptUnidentifiedRefRef"), cent, unidentifiedPtSum, nUnidentifiedWeighted, rndm); } // Charged and PID-binned ref-ref are common to both modes. The numerator is // selected between PID Pure and POI-ref by cfgC22DeltaPtUsePure. if (switchsOpts.cfgOutputCharged.value) { - fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), HIST("c22DeltaPt/c22dmeanptCharged"), cent, ptSum, nch, rndm); + fillProfilePOIvnpt(corrconfigs.at(corrConfigIndex::charged::kC22Gap), HIST("c22DeltaPt/c22dmeanptCharged"), cent, ptSum, nch, rndm); } if (switchsOpts.cfgC22DeltaPtUsePure.value) { if (nPionWeighted > 0. && switchsOpts.cfgOutputPion.value) { - fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), HIST("c22DeltaPt/c22dmeanptPionPure"), cent, pionPtSum, nPionWeighted, rndm); + fillProfilePOIvnpt(corrconfigs.at(corrConfigIndex::pion::kC22Pure), HIST("c22DeltaPt/c22dmeanptPionPure"), cent, pionPtSum, nPionWeighted, rndm); } if (nKaonWeighted > 0. && switchsOpts.cfgOutputKaon.value) { - fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), HIST("c22DeltaPt/c22dmeanptKaonPure"), cent, kaonPtSum, nKaonWeighted, rndm); + fillProfilePOIvnpt(corrconfigs.at(corrConfigIndex::kaon::kC22Pure), HIST("c22DeltaPt/c22dmeanptKaonPure"), cent, kaonPtSum, nKaonWeighted, rndm); } if (nProtonWeighted > 0. && switchsOpts.cfgOutputProton.value) { - fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), HIST("c22DeltaPt/c22dmeanptProtonPure"), cent, protonPtSum, nProtonWeighted, rndm); + fillProfilePOIvnpt(corrconfigs.at(corrConfigIndex::proton::kC22Pure), HIST("c22DeltaPt/c22dmeanptProtonPure"), cent, protonPtSum, nProtonWeighted, rndm); } if (nUnidentifiedWeighted > 0. && switchsOpts.cfgOutputUnidentified.value) { - fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Unidentified::kC22Pure), HIST("c22DeltaPt/c22dmeanptUnidentifiedPure"), cent, unidentifiedPtSum, nUnidentifiedWeighted, rndm); + fillProfilePOIvnpt(corrconfigs.at(corrConfigIndex::unidentified::kC22Pure), HIST("c22DeltaPt/c22dmeanptUnidentifiedPure"), cent, unidentifiedPtSum, nUnidentifiedWeighted, rndm); } } else { if (nPionWeighted > 0. && switchsOpts.cfgOutputPion.value) { - fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Pion::kC22GapA), corrconfigs.at(CorrConfigIndex::Pion::kC22GapB), HIST("c22DeltaPt/c22dmeanptPionPOIRef"), cent, pionPtSum, nPionWeighted, rndm); + fillProfilePOIvnpt(corrconfigs.at(corrConfigIndex::pion::kC22GapA), corrconfigs.at(corrConfigIndex::pion::kC22GapB), HIST("c22DeltaPt/c22dmeanptPionPOIRef"), cent, pionPtSum, nPionWeighted, rndm); } if (nKaonWeighted > 0. && switchsOpts.cfgOutputKaon.value) { - fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Kaon::kC22GapA), corrconfigs.at(CorrConfigIndex::Kaon::kC22GapB), HIST("c22DeltaPt/c22dmeanptKaonPOIRef"), cent, kaonPtSum, nKaonWeighted, rndm); + fillProfilePOIvnpt(corrconfigs.at(corrConfigIndex::kaon::kC22GapA), corrconfigs.at(corrConfigIndex::kaon::kC22GapB), HIST("c22DeltaPt/c22dmeanptKaonPOIRef"), cent, kaonPtSum, nKaonWeighted, rndm); } if (nProtonWeighted > 0. && switchsOpts.cfgOutputProton.value) { - fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Proton::kC22GapA), corrconfigs.at(CorrConfigIndex::Proton::kC22GapB), HIST("c22DeltaPt/c22dmeanptProtonPOIRef"), cent, protonPtSum, nProtonWeighted, rndm); + fillProfilePOIvnpt(corrconfigs.at(corrConfigIndex::proton::kC22GapA), corrconfigs.at(corrConfigIndex::proton::kC22GapB), HIST("c22DeltaPt/c22dmeanptProtonPOIRef"), cent, protonPtSum, nProtonWeighted, rndm); } if (nUnidentifiedWeighted > 0. && switchsOpts.cfgOutputUnidentified.value) { - fillProfilePOIvnpt(corrconfigs.at(CorrConfigIndex::Unidentified::kC22GapA), corrconfigs.at(CorrConfigIndex::Unidentified::kC22GapB), HIST("c22DeltaPt/c22dmeanptUnidentifiedPOIRef"), cent, unidentifiedPtSum, nUnidentifiedWeighted, rndm); + fillProfilePOIvnpt(corrconfigs.at(corrConfigIndex::unidentified::kC22GapA), corrconfigs.at(corrConfigIndex::unidentified::kC22GapB), HIST("c22DeltaPt/c22dmeanptUnidentifiedPOIRef"), cent, unidentifiedPtSum, nUnidentifiedWeighted, rndm); } } } @@ -3306,15 +3343,15 @@ struct PidFlowPtCorr { if (switchsOpts.cfgOutPutPtSpectra.value) { registry.fill(HIST("ptSpectra/hPtCentData"), pt, cent); } - fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., GFWBitMask::Charged::kReference); + fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., gfwBitMask::charged::kReference); } if (!isWithinPOIPtRange(pid, pt)) { continue; } if (pid == MyParticleType::kPion) { - fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., GFWBitMask::Pion::kPOI); - fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., GFWBitMask::Pion::kOverlap, 1.); + fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., gfwBitMask::pion::kPOI); + fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., gfwBitMask::pion::kOverlap, 1.); registry.fill(HIST("hPhiPi"), mcParticle.phi()); registry.fill(HIST("hPhicorrPi"), mcParticle.phi()); registry.fill(HIST("hPhiCorrNUANUEPi"), mcParticle.phi()); @@ -3322,8 +3359,8 @@ struct PidFlowPtCorr { registry.fill(HIST("hPtCorrPi"), pt); ++numOfPi; } else if (pid == MyParticleType::kKaon) { - fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., GFWBitMask::Kaon::kPOI); - fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., GFWBitMask::Kaon::kOverlap, 1.); + fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., gfwBitMask::kaon::kPOI); + fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., gfwBitMask::kaon::kOverlap, 1.); registry.fill(HIST("hPhiKa"), mcParticle.phi()); registry.fill(HIST("hPhicorrKa"), mcParticle.phi()); registry.fill(HIST("hPhiCorrNUANUEKa"), mcParticle.phi()); @@ -3331,8 +3368,8 @@ struct PidFlowPtCorr { registry.fill(HIST("hPtCorrKa"), pt); ++numOfKa; } else if (pid == MyParticleType::kProton) { - fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., GFWBitMask::Proton::kPOI); - fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., GFWBitMask::Proton::kOverlap, 1.); + fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., gfwBitMask::proton::kPOI); + fGFW->Fill(mcParticle.eta(), 0, mcParticle.phi(), 1., gfwBitMask::proton::kOverlap, 1.); registry.fill(HIST("hPhiPr"), mcParticle.phi()); registry.fill(HIST("hPhicorrPr"), mcParticle.phi()); registry.fill(HIST("hPhiCorrNUANUEPr"), mcParticle.phi()); @@ -3353,81 +3390,81 @@ struct PidFlowPtCorr { continue; } - fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, "c22"); - fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC24), cent, rndm, "c24"); - fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Full), cent, rndm, "c22Full"); - fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC32Gap), cent, rndm, "c32"); - fillFC(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC34Gap), cent, rndm, "c34"); - - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22FullA), cent, rndm, "c22Full"); - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22FullB), cent, rndm, "c22Full"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22FullA), cent, rndm, "c22Full"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22FullB), cent, rndm, "c22Full"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22FullA), cent, rndm, "c22Full"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22FullB), cent, rndm, "c22Full"); - - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC24A), cent, rndm, "c24"); - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC24B), cent, rndm, "c24"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC24A), cent, rndm, "c24"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC24B), cent, rndm, "c24"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC24A), cent, rndm, "c24"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC24B), cent, rndm, "c24"); - - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32GapA), cent, rndm, "c32"); - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32GapB), cent, rndm, "c32"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32GapA), cent, rndm, "c32"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32GapB), cent, rndm, "c32"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32GapA), cent, rndm, "c32"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32GapB), cent, rndm, "c32"); - - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC34A), cent, rndm, "c34"); - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC34B), cent, rndm, "c34"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC34A), cent, rndm, "c34"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC34B), cent, rndm, "c34"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC34A), cent, rndm, "c34"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC34B), cent, rndm, "c34"); - - const bool filledPi = fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, "c22pure"); - const bool filledKa = fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, "c22pure"); - const bool filledPr = fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, "c22pure"); - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32Pure), cent, rndm, "c32pure"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32Pure), cent, rndm, "c32pure"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32Pure), cent, rndm, "c32pure"); + fillFC(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC22Gap), cent, rndm, "c22"); + fillFC(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC24), cent, rndm, "c24"); + fillFC(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC22Full), cent, rndm, "c22Full"); + fillFC(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC32Gap), cent, rndm, "c32"); + fillFC(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC34Gap), cent, rndm, "c34"); + + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22FullA), cent, rndm, "c22Full"); + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22FullB), cent, rndm, "c22Full"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22FullA), cent, rndm, "c22Full"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22FullB), cent, rndm, "c22Full"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22FullA), cent, rndm, "c22Full"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22FullB), cent, rndm, "c22Full"); + + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC24A), cent, rndm, "c24"); + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC24B), cent, rndm, "c24"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC24A), cent, rndm, "c24"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC24B), cent, rndm, "c24"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC24A), cent, rndm, "c24"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC24B), cent, rndm, "c24"); + + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC32GapA), cent, rndm, "c32"); + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC32GapB), cent, rndm, "c32"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC32GapA), cent, rndm, "c32"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC32GapB), cent, rndm, "c32"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC32GapA), cent, rndm, "c32"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC32GapB), cent, rndm, "c32"); + + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC34A), cent, rndm, "c34"); + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC34B), cent, rndm, "c34"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC34A), cent, rndm, "c34"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC34B), cent, rndm, "c34"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC34A), cent, rndm, "c34"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC34B), cent, rndm, "c34"); + + const bool filledPi = fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22Pure), cent, rndm, "c22pure"); + const bool filledKa = fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22Pure), cent, rndm, "c22pure"); + const bool filledPr = fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22Pure), cent, rndm, "c22pure"); + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC32Pure), cent, rndm, "c32pure"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC32Pure), cent, rndm, "c32pure"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC32Pure), cent, rndm, "c32pure"); if (filledPi || !switchsOpts.cfgCheck2MethodDiff.value) { - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22GapA), cent, rndm, "c22"); - fillFC(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22GapB), cent, rndm, "c22"); + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22GapA), cent, rndm, "c22"); + fillFC(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22GapB), cent, rndm, "c22"); } if (filledKa || !switchsOpts.cfgCheck2MethodDiff.value) { - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22GapA), cent, rndm, "c22"); - fillFC(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22GapB), cent, rndm, "c22"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22GapA), cent, rndm, "c22"); + fillFC(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22GapB), cent, rndm, "c22"); } if (filledPr || !switchsOpts.cfgCheck2MethodDiff.value) { - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22GapA), cent, rndm, "c22"); - fillFC(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22GapB), cent, rndm, "c22"); - } - - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, nch, nch, "c22TrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, nch, nch, "c22TrackWeightOne", true); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC24), cent, rndm, nch, nch, "c24TrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Full), cent, rndm, nch, nch, "c22FullTrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC32Gap), cent, rndm, nch, nch, "c32TrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC34Gap), cent, rndm, nch, nch, "c34TrackWeight"); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, ptSum, nch, "covV2Pt"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), cent, rndm, ptSum, nch, "covV2PtWeightOne", true); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); - fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(CorrConfigIndex::Charged::kC32Gap), cent, rndm, ptSum, nch, "covV3Pt"); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22GapA), cent, rndm, "c22"); + fillFC(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22GapB), cent, rndm, "c22"); + } + + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC22Gap), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC22Gap), cent, rndm, nch, nch, "c22TrackWeightOne", true); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC24), cent, rndm, nch, nch, "c24TrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC22Full), cent, rndm, nch, nch, "c22FullTrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC32Gap), cent, rndm, nch, nch, "c32TrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC34Gap), cent, rndm, nch, nch, "c34TrackWeight"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22Pure), cent, rndm, nch, nch, "c22TrackWeight"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC32Pure), cent, rndm, nch, nch, "c32TrackWeight"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC22Gap), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC22Gap), cent, rndm, ptSum, nch, "covV2PtWeightOne", true); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22Pure), cent, rndm, ptSum, nch, "covV2Pt"); + fillFCvnpt(MyParticleType::kCharged, corrconfigs.at(corrConfigIndex::charged::kC32Gap), cent, rndm, ptSum, nch, "covV3Pt"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC32Pure), cent, rndm, ptSum, nch, "covV3Pt"); fillFC4PtC22(cent, ptSum, nch, rndm); if (nPionWeighted > 0.) { @@ -3447,28 +3484,28 @@ struct PidFlowPtCorr { if (nPionWeighted > 0. && switchsOpts.cfgOutputPion.value) { fFCPi->FillProfile("hMeanPt", cent, pionPtSum / nPionWeighted, nPionWeighted, rndm); fFCPi->FillProfile("hMeanPtWeightOne", cent, pionPtSum / nPionWeighted, 1., rndm); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, pionPtSum, nPionWeighted, "covV2PtPID"); - fillFCvnpt(MyParticleType::kPion, corrconfigs.at(CorrConfigIndex::Pion::kC22Pure), cent, rndm, nPionWeighted, nPionWeighted, "c22TrackWeightPID"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22Pure), cent, rndm, pionPtSum, nPionWeighted, "covV2PtPID"); + fillFCvnpt(MyParticleType::kPion, corrconfigs.at(corrConfigIndex::pion::kC22Pure), cent, rndm, nPionWeighted, nPionWeighted, "c22TrackWeightPID"); } if (nKaonWeighted > 0. && switchsOpts.cfgOutputKaon.value) { fFCKa->FillProfile("hMeanPt", cent, kaonPtSum / nKaonWeighted, nKaonWeighted, rndm); fFCKa->FillProfile("hMeanPtWeightOne", cent, kaonPtSum / nKaonWeighted, 1., rndm); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, kaonPtSum, nKaonWeighted, "covV2PtPID"); - fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(CorrConfigIndex::Kaon::kC22Pure), cent, rndm, nKaonWeighted, nKaonWeighted, "c22TrackWeightPID"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22Pure), cent, rndm, kaonPtSum, nKaonWeighted, "covV2PtPID"); + fillFCvnpt(MyParticleType::kKaon, corrconfigs.at(corrConfigIndex::kaon::kC22Pure), cent, rndm, nKaonWeighted, nKaonWeighted, "c22TrackWeightPID"); } if (nProtonWeighted > 0. && switchsOpts.cfgOutputProton.value) { fFCPr->FillProfile("hMeanPt", cent, protonPtSum / nProtonWeighted, nProtonWeighted, rndm); fFCPr->FillProfile("hMeanPtWeightOne", cent, protonPtSum / nProtonWeighted, 1., rndm); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, protonPtSum, nProtonWeighted, "covV2PtPID"); - fillFCvnpt(MyParticleType::kProton, corrconfigs.at(CorrConfigIndex::Proton::kC22Pure), cent, rndm, nProtonWeighted, nProtonWeighted, "c22TrackWeightPID"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22Pure), cent, rndm, protonPtSum, nProtonWeighted, "covV2PtPID"); + fillFCvnpt(MyParticleType::kProton, corrconfigs.at(corrConfigIndex::proton::kC22Pure), cent, rndm, nProtonWeighted, nProtonWeighted, "c22TrackWeightPID"); } if (switchsOpts.cfgOutPutPtSpectra.value) { - const double nPairCharged = fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), 0, true).real(); - const double chargedC22 = nPairCharged > 0. ? fGFW->Calculate(corrconfigs.at(CorrConfigIndex::Charged::kC22Gap), 0, false).real() / nPairCharged : 0.; - const double pidChargedC22Pi = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Pion::kC22GapA), corrconfigs.at(CorrConfigIndex::Pion::kC22GapB)); - const double pidKaonC22 = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Kaon::kC22GapA), corrconfigs.at(CorrConfigIndex::Kaon::kC22GapB)); - const double pidProtonC22 = getPidC22InOneEvent(corrconfigs.at(CorrConfigIndex::Proton::kC22GapA), corrconfigs.at(CorrConfigIndex::Proton::kC22GapB)); + const double nPairCharged = fGFW->Calculate(corrconfigs.at(corrConfigIndex::charged::kC22Gap), 0, true).real(); + const double chargedC22 = nPairCharged > 0. ? fGFW->Calculate(corrconfigs.at(corrConfigIndex::charged::kC22Gap), 0, false).real() / nPairCharged : 0.; + const double pidChargedC22Pi = getPidC22InOneEvent(corrconfigs.at(corrConfigIndex::pion::kC22GapA), corrconfigs.at(corrConfigIndex::pion::kC22GapB)); + const double pidKaonC22 = getPidC22InOneEvent(corrconfigs.at(corrConfigIndex::kaon::kC22GapA), corrconfigs.at(corrConfigIndex::kaon::kC22GapB)); + const double pidProtonC22 = getPidC22InOneEvent(corrconfigs.at(corrConfigIndex::proton::kC22GapA), corrconfigs.at(corrConfigIndex::proton::kC22GapB)); if (pidChargedC22Pi > 0. && chargedC22 > 0.) { registry.fill(HIST("c22PrimeVsc22/Pi"), pidChargedC22Pi, chargedC22); } From a78dc56a9a182b6ea85e504bc78720105d5101ee Mon Sep 17 00:00:00 2001 From: huinaibing Date: Fri, 14 Aug 2026 20:55:17 +0800 Subject: [PATCH 6/7] Trigger CI From de7f9c0eb79fc821a0647dccc538e29a01d18286 Mon Sep 17 00:00:00 2001 From: huinaibing Date: Fri, 14 Aug 2026 22:38:17 +0800 Subject: [PATCH 7/7] Trigger CI again