From 00ab73bf7668f347c56024adfc978c3add1f9e32 Mon Sep 17 00:00:00 2001 From: cnkoster Date: Wed, 6 May 2026 17:01:54 +0200 Subject: [PATCH 1/2] Check secondaties vs. pt and add possibility for 3D corrections --- PWGCF/Flow/Tasks/flowSP.cxx | 825 +++++++++++++++++++----------------- 1 file changed, 444 insertions(+), 381 deletions(-) diff --git a/PWGCF/Flow/Tasks/flowSP.cxx b/PWGCF/Flow/Tasks/flowSP.cxx index f1b672c76e6..e49b5ac84a9 100644 --- a/PWGCF/Flow/Tasks/flowSP.cxx +++ b/PWGCF/Flow/Tasks/flowSP.cxx @@ -73,100 +73,109 @@ using namespace o2::aod::rctsel; #define O2_DEFINE_CONFIGURABLE(NAME, TYPE, DEFAULT, HELP) Configurable NAME{#NAME, DEFAULT, HELP}; struct FlowSP { - RCTFlagsChecker rctChecker; - + + // event selection configurable group struct : ConfigurableGroup { - O2_DEFINE_CONFIGURABLE(cfgEvtUseRCTFlagChecker, bool, false, "Evt sel: use RCT flag checker"); - O2_DEFINE_CONFIGURABLE(cfgEvtRCTFlagCheckerLabel, std::string, "CBT_hadronPID", "Evt sel: RCT flag checker label (CBT, CBT_hadronPID)"); // all Labels can be found in Common/CCDB/RCTSelectionFlags.h - O2_DEFINE_CONFIGURABLE(cfgEvtRCTFlagCheckerZDCCheck, bool, false, "Evt sel: RCT flag checker ZDC check"); - O2_DEFINE_CONFIGURABLE(cfgEvtRCTFlagCheckerLimitAcceptAsBad, bool, false, "Evt sel: RCT flag checker treat Limited Acceptance As Bad"); - } rctFlags; + O2_DEFINE_CONFIGURABLE(cEvtUseRCTFlagChecker, bool, false, "Evt sel: use RCT flag checker"); + O2_DEFINE_CONFIGURABLE(cEvtRCTFlagCheckerLabel, std::string, "CBT_hadronPID", "Evt sel: RCT flag checker label (CBT, CBT_hadronPID)"); // all Labels can be found in Common/CCDB/RCTSelectionFlags.h + O2_DEFINE_CONFIGURABLE(cEvtRCTFlagCheckerZDCCheck, bool, false, "Evt sel: RCT flag checker ZDC check"); + O2_DEFINE_CONFIGURABLE(cEvtRCTFlagCheckerLimitAcceptAsBad, bool, false, "Evt sel: RCT flag checker treat Limited Acceptance As Bad"); + O2_DEFINE_CONFIGURABLE(cEvSelsUseAdditionalEventCut, bool, true, "Bool to enable Additional Event Cut"); + O2_DEFINE_CONFIGURABLE(cEvSelsMaxOccupancy, int, 10000, "Maximum occupancy of selected events"); + O2_DEFINE_CONFIGURABLE(cEvSelsMinOccupancy, int, 0, "Minimum occupancy of selected events"); + O2_DEFINE_CONFIGURABLE(cEvSelsNoSameBunchPileupCut, bool, true, "kNoSameBunchPileupCut"); + O2_DEFINE_CONFIGURABLE(cEvSelsIsGoodZvtxFT0vsPV, bool, true, "kIsGoodZvtxFT0vsPV"); + O2_DEFINE_CONFIGURABLE(cEvSelsNoCollInTimeRangeStandard, bool, true, "kNoCollInTimeRangeStandard"); + O2_DEFINE_CONFIGURABLE(cEvSelsNoCollInTimeRangeNarrow, bool, true, "kNoCollInTimeRangeNarrow"); + O2_DEFINE_CONFIGURABLE(cEvSelsDoOccupancySel, bool, true, "Bool for event selection on detector occupancy"); + O2_DEFINE_CONFIGURABLE(cEvSelsIsVertexITSTPC, bool, true, "Selects collisions with at least one ITS-TPC track"); + O2_DEFINE_CONFIGURABLE(cEvSelsIsGoodITSLayersAll, bool, true, "Cut time intervals with dead ITS staves"); + O2_DEFINE_CONFIGURABLE(cEvSelsIsGoodITSLayer0123, bool, true, "Cut time intervals with dead ITS staves"); + + // QA Plots + O2_DEFINE_CONFIGURABLE(cFillEventQA, bool, false, "Fill histograms for event QA"); + O2_DEFINE_CONFIGURABLE(cFillTrackQA, bool, false, "Fill histograms for track QA"); + O2_DEFINE_CONFIGURABLE(cFillPIDQA, bool, false, "Fill histograms for PID QA"); + O2_DEFINE_CONFIGURABLE(cFillEventPlaneQA, bool, false, "Fill histograms for Event Plane QA"); + O2_DEFINE_CONFIGURABLE(cFillQABefore, bool, false, "Fill QA histograms before cuts, only for processData"); + O2_DEFINE_CONFIGURABLE(cFillMeanPT, bool, false, "Fill histograms for mean PX/PT"); + O2_DEFINE_CONFIGURABLE(cFillMeanPTextra, bool, false, "Fill histograms for mean PX/PT extra"); + O2_DEFINE_CONFIGURABLE(cUseCentAveragePt, bool, false, "Use in 1% centrality intervals and not cent average"); + O2_DEFINE_CONFIGURABLE(cFillWithMCParticle, bool, false, "Fill histograms with MCParticle instead of Track"); + // Flags to make and fill histograms + O2_DEFINE_CONFIGURABLE(cFillGeneralV1Histos, bool, true, "Fill histograms for vn analysis"); + O2_DEFINE_CONFIGURABLE(cFillMixedHarmonics, bool, true, "Flag to make and fill histos for mixed harmonics"); + O2_DEFINE_CONFIGURABLE(cFillEventPlane, bool, false, "Flag to make and fill histos with Event Plane"); + O2_DEFINE_CONFIGURABLE(cFillXandYterms, bool, false, "Flag to make and fill histos for with separate x and y terms for SPM"); + O2_DEFINE_CONFIGURABLE(cFillChargeDependence, bool, true, "Flag to make and fill histos for charge dependent flow"); + O2_DEFINE_CONFIGURABLE(cFillChargeDependenceQA, bool, true, "Flag to make and fill QA histos for charge dependent flow"); + O2_DEFINE_CONFIGURABLE(cFillPID, bool, false, "Flag to make and fill histos for PID flow"); + // Centrality Estimators -> standard is FT0C + O2_DEFINE_CONFIGURABLE(cCentFT0Cvariant1, bool, false, "Set centrality estimator to CentFT0Cvariant1"); + O2_DEFINE_CONFIGURABLE(cCentFT0M, bool, false, "Set centrality estimator to CentFT0M"); + O2_DEFINE_CONFIGURABLE(cCentFV0A, bool, false, "Set centrality estimator to CentFV0A"); + O2_DEFINE_CONFIGURABLE(cCentNGlobal, bool, false, "Set centrality estimator to CentNGlobal"); + // Standard selections + O2_DEFINE_CONFIGURABLE(cTrackSelsDCAxy, float, 0.2, "Cut on DCA in the transverse direction (cm)"); + O2_DEFINE_CONFIGURABLE(cTrackSelsDCAz, float, 2, "Cut on DCA in the longitudinal direction (cm)"); + O2_DEFINE_CONFIGURABLE(cTrackSelsNcls, float, 70, "Cut on number of TPC clusters found"); + O2_DEFINE_CONFIGURABLE(cTrackSelsFshcls, float, 0.4, "Cut on fraction of shared TPC clusters found"); + O2_DEFINE_CONFIGURABLE(cTrackSelsPtmin, float, 0.2, "minimum pt (GeV/c)"); + O2_DEFINE_CONFIGURABLE(cTrackSelsPtmax, float, 10, "maximum pt (GeV/c)"); + O2_DEFINE_CONFIGURABLE(cTrackSelsEta, float, 0.8, "eta cut"); + O2_DEFINE_CONFIGURABLE(cIsMCReco, bool, true, "Is MC Reco"); + O2_DEFINE_CONFIGURABLE(cEvSelsVtxZ, float, 10, "vertex cut (cm)"); + O2_DEFINE_CONFIGURABLE(cMagField, float, 99999, "Configurable magnetic field;default CCDB will be queried"); + O2_DEFINE_CONFIGURABLE(cCentMin, float, 0, "Minimum cenrality for selected events"); + O2_DEFINE_CONFIGURABLE(cCentMax, float, 90, "Maximum cenrality for selected events"); + O2_DEFINE_CONFIGURABLE(cFilterLeptons, bool, true, "Filter out leptons from MCGenerated by requiring |pdgCode| > 100"); + // NUA and NUE weights + O2_DEFINE_CONFIGURABLE(cFillWeights, bool, true, "Fill NUA weights"); + O2_DEFINE_CONFIGURABLE(cFillWeightsPOS, bool, true, "Fill NUA weights only for positive charges"); + O2_DEFINE_CONFIGURABLE(cFillWeightsNEG, bool, true, "Fill NUA weights only for negative charges"); + O2_DEFINE_CONFIGURABLE(cUseNUA1D, bool, true, "Use 1D NUA weights (only phi)"); + O2_DEFINE_CONFIGURABLE(cUseNUA2D, bool, false, "Use 2D NUA weights (phi and eta)"); + O2_DEFINE_CONFIGURABLE(cUseNUE2D, bool, false, "Use 2D NUE weights"); + O2_DEFINE_CONFIGURABLE(cUseNUE3D, bool, false, "Use 3D NUE weights (pt, eta, centrality)"); + O2_DEFINE_CONFIGURABLE(cUseNUE2Deta, bool, false, "Use 2D NUE weights TRUE: (pt and eta) FALSE: (pt and centrality)"); + // Additional track Selections + O2_DEFINE_CONFIGURABLE(cTrackSelsUseAdditionalTrackCut, bool, false, "Bool to enable Additional Track Cut"); + O2_DEFINE_CONFIGURABLE(cTrackSelsDoDCApt, bool, false, "Apply Pt dependent DCAz cut"); + O2_DEFINE_CONFIGURABLE(cTrackSelsDCApt1, float, 0.1, "DcaZ < const + (a * b) / pt^1.1 -> this sets a"); + O2_DEFINE_CONFIGURABLE(cTrackSelsDCApt2, float, 0.035, "DcaZ < const + (a * b) / pt^1.1 -> this sets b"); + O2_DEFINE_CONFIGURABLE(cTrackSelsDCAptConsMin, float, 0.1, "DcaZ < const + (a * b) / pt^1.1 -> this sets const"); + O2_DEFINE_CONFIGURABLE(cTrackSelsPIDNsigma, float, 2.0, "nSigma cut for PID"); + O2_DEFINE_CONFIGURABLE(cTrackSelDoTrackQAvsCent, bool, true, "Do track selection QA plots as function of centrality"); + // harmonics for v coefficients + O2_DEFINE_CONFIGURABLE(cHarm, int, 1, "Flow harmonic n for ux and uy: (Cos(n*phi), Sin(n*phi))"); + O2_DEFINE_CONFIGURABLE(cHarmMixed, int, 2, "Flow harmonic n for ux and uy in mixed harmonics (MH): (Cos(n*phi), Sin(n*phi))"); + // settings for CCDB data + O2_DEFINE_CONFIGURABLE(cCCDBdir_QQ, std::string, "Users/c/ckoster/ZDC/LHC23_PbPb_pass5/meanQQ/Default", "ccdb dir for average QQ values in 1% centrality bins"); + O2_DEFINE_CONFIGURABLE(cCCDBdir_SP, std::string, "", "ccdb dir for average event plane resolution in 1% centrality bins"); + O2_DEFINE_CONFIGURABLE(cCCDB_NUA, std::string, "Users/c/ckoster/flowSP/LHC23_PbPb_pass5/Default", "ccdb dir for NUA corrections"); + O2_DEFINE_CONFIGURABLE(cCCDB_NUE, std::string, "Users/c/ckoster/flowSP/LHC23_PbPb_pass5/NUE/Default", "ccdb dir for NUE corrections (pt)"); + O2_DEFINE_CONFIGURABLE(cCCDB_NUE2D, std::string, "Users/c/ckoster/flowSP/LHC23_PbPb_pass5/NUE/2D", "ccdb dir for NUE 2D corrections (pt, eta)"); + O2_DEFINE_CONFIGURABLE(cCCDB_NUE3D, std::string, "Users/c/ckoster/flowSP/LHC23_PbPb_pass5/NUE/3D", "ccdb dir for NUE 3D corrections (pt, eta, centrality)"); + O2_DEFINE_CONFIGURABLE(cCCDBdir_centrality, std::string, "", "ccdb dir for Centrality corrections"); + O2_DEFINE_CONFIGURABLE(cCCDBdir_meanPt, std::string, "", "ccdb dir for Mean Pt corrections"); + + // Confogirable axis + // ConfigurableAxis axisCentrality{"axisCentrality", {20, 0, 100}, "Centrality bins for vn "}; + // ConfigurableAxis axisMomentum{"axisMomentum", {20, 0, 10}, "Momentum bins for vn"}; + // ConfigurableAxis axisEtaVn{"axisEtaVn", {8, -0.8, 0.8}, "Eta bins for vn"}; + + // Configurables containing vector + Configurable> cEvSelsMultPv{"cEvSelsMultPv", std::vector{2223.49, -75.1444, 0.963572, -0.00570399, 1.34877e-05, 3790.99, -137.064, 2.13044, -0.017122, 5.82834e-05}, "Multiplicity cuts (PV) first 5 parameters cutLOW last 5 cutHIGH (Default is +-2sigma pass5) "}; + Configurable> cEvSelsMult{"cEvSelsMult", std::vector{1301.56, -41.4615, 0.478224, -0.00239449, 4.46966e-06, 2967.6, -102.927, 1.47488, -0.0106534, 3.28622e-05}, "Multiplicity cuts (Global) first 5 parameters cutLOW last 5 cutHIGH (Default is +-2sigma pass5) "}; + Configurable> cPtBinning{"cPtBinning", std::vector{0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2, 2.2, 2.4, 2.6, 2.8, 3, 3.5, 4, 5, 6, 8, 10}, "pT binning for vn"}; + + } cfg; - // event selection configurable group - O2_DEFINE_CONFIGURABLE(cfgEvSelsUseAdditionalEventCut, bool, true, "Bool to enable Additional Event Cut"); - O2_DEFINE_CONFIGURABLE(cfgEvSelsMaxOccupancy, int, 10000, "Maximum occupancy of selected events"); - O2_DEFINE_CONFIGURABLE(cfgEvSelsMinOccupancy, int, 0, "Minimum occupancy of selected events"); - O2_DEFINE_CONFIGURABLE(cfgEvSelsNoSameBunchPileupCut, bool, true, "kNoSameBunchPileupCut"); - O2_DEFINE_CONFIGURABLE(cfgEvSelsIsGoodZvtxFT0vsPV, bool, true, "kIsGoodZvtxFT0vsPV"); - O2_DEFINE_CONFIGURABLE(cfgEvSelsNoCollInTimeRangeStandard, bool, true, "kNoCollInTimeRangeStandard"); - O2_DEFINE_CONFIGURABLE(cfgEvSelsNoCollInTimeRangeNarrow, bool, true, "kNoCollInTimeRangeNarrow"); - O2_DEFINE_CONFIGURABLE(cfgEvSelsDoOccupancySel, bool, true, "Bool for event selection on detector occupancy"); - O2_DEFINE_CONFIGURABLE(cfgEvSelsIsVertexITSTPC, bool, true, "Selects collisions with at least one ITS-TPC track"); - O2_DEFINE_CONFIGURABLE(cfgEvSelsIsGoodITSLayersAll, bool, true, "Cut time intervals with dead ITS staves"); - O2_DEFINE_CONFIGURABLE(cfgEvSelsIsGoodITSLayer0123, bool, true, "Cut time intervals with dead ITS staves"); - - // QA Plots - O2_DEFINE_CONFIGURABLE(cfgFillEventQA, bool, false, "Fill histograms for event QA"); - O2_DEFINE_CONFIGURABLE(cfgFillTrackQA, bool, false, "Fill histograms for track QA"); - O2_DEFINE_CONFIGURABLE(cfgFillPIDQA, bool, false, "Fill histograms for PID QA"); - O2_DEFINE_CONFIGURABLE(cfgFillEventPlaneQA, bool, false, "Fill histograms for Event Plane QA"); - O2_DEFINE_CONFIGURABLE(cfgFillQABefore, bool, false, "Fill QA histograms before cuts, only for processData"); - O2_DEFINE_CONFIGURABLE(cfgFillMeanPT, bool, false, "Fill histograms for mean PX/PT"); - O2_DEFINE_CONFIGURABLE(cfgUseCentAveragePt, bool, false, "Use in 1% centrality intervals and not ecent average"); - // Flags to make and fill histograms - O2_DEFINE_CONFIGURABLE(cfgFillGeneralV1Histos, bool, true, "Fill histograms for vn analysis"); - O2_DEFINE_CONFIGURABLE(cfgFillMixedHarmonics, bool, true, "Flag to make and fill histos for mixed harmonics"); - O2_DEFINE_CONFIGURABLE(cfgFillEventPlane, bool, false, "Flag to make and fill histos with Event Plane"); - O2_DEFINE_CONFIGURABLE(cfgFillXandYterms, bool, false, "Flag to make and fill histos for with separate x and y terms for SPM"); - O2_DEFINE_CONFIGURABLE(cfgFillChargeDependence, bool, true, "Flag to make and fill histos for charge dependent flow"); - O2_DEFINE_CONFIGURABLE(cfgFillChargeDependenceQA, bool, true, "Flag to make and fill QA histos for charge dependent flow"); - O2_DEFINE_CONFIGURABLE(cfgFillPID, bool, false, "Flag to make and fill histos for PID flow"); - // Centrality Estimators -> standard is FT0C - O2_DEFINE_CONFIGURABLE(cfgCentFT0Cvariant1, bool, false, "Set centrality estimator to cfgCentFT0Cvariant1"); - O2_DEFINE_CONFIGURABLE(cfgCentFT0M, bool, false, "Set centrality estimator to cfgCentFT0M"); - O2_DEFINE_CONFIGURABLE(cfgCentFV0A, bool, false, "Set centrality estimator to cfgCentFV0A"); - O2_DEFINE_CONFIGURABLE(cfgCentNGlobal, bool, false, "Set centrality estimator to cfgCentNGlobal"); - // Standard selections - O2_DEFINE_CONFIGURABLE(cfgTrackSelsDCAxy, float, 0.2, "Cut on DCA in the transverse direction (cm)"); - O2_DEFINE_CONFIGURABLE(cfgTrackSelsDCAz, float, 2, "Cut on DCA in the longitudinal direction (cm)"); - O2_DEFINE_CONFIGURABLE(cfgTrackSelsNcls, float, 70, "Cut on number of TPC clusters found"); - O2_DEFINE_CONFIGURABLE(cfgTrackSelsFshcls, float, 0.4, "Cut on fraction of shared TPC clusters found"); - O2_DEFINE_CONFIGURABLE(cfgTrackSelsPtmin, float, 0.2, "minimum pt (GeV/c)"); - O2_DEFINE_CONFIGURABLE(cfgTrackSelsPtmax, float, 10, "maximum pt (GeV/c)"); - O2_DEFINE_CONFIGURABLE(cfgTrackSelsEta, float, 0.8, "eta cut"); - O2_DEFINE_CONFIGURABLE(cfgEvSelsVtxZ, float, 10, "vertex cut (cm)"); - O2_DEFINE_CONFIGURABLE(cfgMagField, float, 99999, "Configurable magnetic field;default CCDB will be queried"); - O2_DEFINE_CONFIGURABLE(cfgCentMin, float, 0, "Minimum cenrality for selected events"); - O2_DEFINE_CONFIGURABLE(cfgCentMax, float, 90, "Maximum cenrality for selected events"); - O2_DEFINE_CONFIGURABLE(cfgFilterLeptons, bool, true, "Filter out leptons from MCGenerated by requiring |pdgCode| > 100"); - // NUA and NUE weights - O2_DEFINE_CONFIGURABLE(cfgFillWeights, bool, true, "Fill NUA weights"); - O2_DEFINE_CONFIGURABLE(cfgFillWeightsPOS, bool, true, "Fill NUA weights only for positive charges"); - O2_DEFINE_CONFIGURABLE(cfgFillWeightsNEG, bool, true, "Fill NUA weights only for negative charges"); - O2_DEFINE_CONFIGURABLE(cfgUseNUA1D, bool, false, "Use 1D NUA weights (only phi)"); - O2_DEFINE_CONFIGURABLE(cfgUseNUA2D, bool, true, "Use 2D NUA weights (phi and eta)"); - O2_DEFINE_CONFIGURABLE(cfgUseNUE2D, bool, true, "Use 2D NUE weights"); - O2_DEFINE_CONFIGURABLE(cfgUseNUE2Deta, bool, true, "Use 2D NUE weights TRUE: (pt and eta) FALSE: (pt and centrality)"); - // Additional track Selections - O2_DEFINE_CONFIGURABLE(cfgTrackSelsUseAdditionalTrackCut, bool, false, "Bool to enable Additional Track Cut"); - O2_DEFINE_CONFIGURABLE(cfgTrackSelsDoDCApt, bool, false, "Apply Pt dependent DCAz cut"); - O2_DEFINE_CONFIGURABLE(cfgTrackSelsDCApt1, float, 0.1, "DcaZ < const + (a * b) / pt^1.1 -> this sets a"); - O2_DEFINE_CONFIGURABLE(cfgTrackSelsDCApt2, float, 0.035, "DcaZ < const + (a * b) / pt^1.1 -> this sets b"); - O2_DEFINE_CONFIGURABLE(cfgTrackSelsDCAptConsMin, float, 0.1, "DcaZ < const + (a * b) / pt^1.1 -> this sets const"); - O2_DEFINE_CONFIGURABLE(cfgTrackSelsPIDNsigma, float, 2.0, "nSigma cut for PID"); - O2_DEFINE_CONFIGURABLE(cfgTrackSelDoTrackQAvsCent, bool, true, "Do track selection QA plots as function of centrality"); - // harmonics for v coefficients - O2_DEFINE_CONFIGURABLE(cfgHarm, int, 1, "Flow harmonic n for ux and uy: (Cos(n*phi), Sin(n*phi))"); - O2_DEFINE_CONFIGURABLE(cfgHarmMixed, int, 2, "Flow harmonic n for ux and uy in mixed harmonics (MH): (Cos(n*phi), Sin(n*phi))"); - // settings for CCDB data - O2_DEFINE_CONFIGURABLE(cfgCCDBdir_QQ, std::string, "Users/c/ckoster/ZDC/LHC23_PbPb_pass5/meanQQ/Default", "ccdb dir for average QQ values in 1% centrality bins"); - O2_DEFINE_CONFIGURABLE(cfgCCDBdir_SP, std::string, "", "ccdb dir for average event plane resolution in 1% centrality bins"); - O2_DEFINE_CONFIGURABLE(cfgCCDB_NUA, std::string, "Users/c/ckoster/flowSP/LHC23_PbPb_pass5/Default", "ccdb dir for NUA corrections"); - O2_DEFINE_CONFIGURABLE(cfgCCDB_NUE, std::string, "Users/c/ckoster/flowSP/LHC23_PbPb_pass5/NUE/Default", "ccdb dir for NUE corrections (pt)"); - O2_DEFINE_CONFIGURABLE(cfgCCDB_NUE2D, std::string, "Users/c/ckoster/flowSP/LHC23_PbPb_pass5/NUE/2D", "ccdb dir for NUE 2D corrections (eta, pt)"); - O2_DEFINE_CONFIGURABLE(cfgCCDBdir_centrality, std::string, "", "ccdb dir for Centrality corrections"); - O2_DEFINE_CONFIGURABLE(cfgCCDBdir_meanPt, std::string, "", "ccdb dir for Mean Pt corrections"); - // Confogirable axis - ConfigurableAxis axisCentrality{"axisCentrality", {20, 0, 100}, "Centrality bins for vn "}; - ConfigurableAxis axisNch = {"axisNch", {400, 0, 4000}, "Global N_{ch}"}; - ConfigurableAxis axisMultpv = {"axisMultpv", {400, 0, 4000}, "N_{ch} (PV)"}; - // Configurables containing vector - Configurable> cfgEvSelsMultPv{"cfgEvSelsMultPv", std::vector{2223.49, -75.1444, 0.963572, -0.00570399, 1.34877e-05, 3790.99, -137.064, 2.13044, -0.017122, 5.82834e-05}, "Multiplicity cuts (PV) first 5 parameters cutLOW last 5 cutHIGH (Default is +-2sigma pass5) "}; - Configurable> cfgEvSelsMult{"cfgEvSelsMult", std::vector{1301.56, -41.4615, 0.478224, -0.00239449, 4.46966e-06, 2967.6, -102.927, 1.47488, -0.0106534, 3.28622e-05}, "Multiplicity cuts (Global) first 5 parameters cutLOW last 5 cutHIGH (Default is +-2sigma pass5) "}; - - Filter collisionFilter = nabs(aod::collision::posZ) < cfgEvSelsVtxZ; - Filter trackFilter = nabs(aod::track::eta) < cfgTrackSelsEta && aod::track::pt > cfgTrackSelsPtmin&& aod::track::pt < cfgTrackSelsPtmax && ((requireGlobalTrackInFilter()) || (aod::track::isGlobalTrackSDD == (uint8_t)true)) && nabs(aod::track::dcaXY) < cfgTrackSelsDCAxy&& nabs(aod::track::dcaZ) < cfgTrackSelsDCAz; - Filter trackFilterMC = nabs(aod::mcparticle::eta) < cfgTrackSelsEta && aod::mcparticle::pt > cfgTrackSelsPtmin&& aod::mcparticle::pt < cfgTrackSelsPtmax; + RCTFlagsChecker rctChecker; + + Filter collisionFilter = nabs(aod::collision::posZ) < cfg.cEvSelsVtxZ; + Filter trackFilter = nabs(aod::track::eta) < cfg.cTrackSelsEta && aod::track::pt > cfg.cTrackSelsPtmin&& aod::track::pt < cfg.cTrackSelsPtmax && ((requireGlobalTrackInFilter()) || (aod::track::isGlobalTrackSDD == (uint8_t) true) || cfg.cIsMCReco) && nabs(aod::track::dcaXY) < cfg.cTrackSelsDCAxy && nabs(aod::track::dcaZ) < cfg.cTrackSelsDCAz; + Filter trackFilterMC = nabs(aod::mcparticle::eta) < cfg.cTrackSelsEta && aod::mcparticle::pt > cfg.cTrackSelsPtmin&& aod::mcparticle::pt < cfg.cTrackSelsPtmax; using GeneralCollisions = soa::Join; using UnfilteredTracksPID = soa::Join; using UnfilteredTracks = soa::Join; @@ -196,6 +205,7 @@ struct FlowSP { struct Config { std::vector mEfficiency = {}; std::vector mEfficiency2D = {}; + std::vector mEfficiency3D = {}; std::vector mAcceptance = {}; std::vector mAcceptance2D = {}; bool correctionsLoaded = false; @@ -213,7 +223,7 @@ struct FlowSP { bool clCentrality = false; bool clMeanPt = false; - } cfg; + } conf; struct SPMvars { std::vector> wacc = {{{0, 1.0}, {1, 1.0}, {2, 1.0}, {3, 1.0}}, {{0, 1.0}, {1, 1.0}, {2, 1.0}, {3, 1.0}}, {{0, 1.0}, {1, 1.0}, {2, 1.0}, {3, 1.0}}}; // int for part species, float for weight vector for kIncl, kPos, kNeg @@ -345,6 +355,7 @@ struct FlowSP { AxisSpec axisPhi = {60, 0, constants::math::TwoPI, "#varphi"}; AxisSpec axisEta = {64, -1.6, 1.6, "#eta"}; AxisSpec axisEtaVn = {8, -.8, .8, "#eta"}; + AxisSpec axisCentrality = {20,0,100, "Centrality (%)"}; AxisSpec axisVx = {40, -0.01, 0.01, "v_{x}"}; AxisSpec axisVy = {40, -0.01, 0.01, "v_{y}"}; AxisSpec axisVz = {40, -10, 10, "v_{z}"}; @@ -360,13 +371,12 @@ struct FlowSP { AxisSpec axisBeta = {150, 0, 1.5, "Beta for PID"}; AxisSpec axisCharge = {3, 0, 3, "Charge: 0 = inclusive, 1 = positive, 2 = negative"}; AxisSpec axisPx = {100, -0.05, 0.05, "p_{x} (GeV/c)"}; + AxisSpec axisNch = {400, 0, 4000, "Global N_{ch}"}; + AxisSpec axisMultpv = {400, 0, 4000, "N_{ch} (PV)"}; + AxisSpec axisPt = {cfg.cPtBinning, "#it{p}_{T} GeV/#it{c}"}; + int ptbins = cfg.cPtBinning->size() - 1; - std::vector ptbinning = {0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2, 2.2, 2.4, 2.6, 2.8, 3, 3.5, 4, 5, 6, 8, 10}; - AxisSpec axisPt = {ptbinning, "#it{p}_{T} GeV/#it{c}"}; - - int ptbins = ptbinning.size() - 1; - - rctChecker.init(rctFlags.cfgEvtRCTFlagCheckerLabel, rctFlags.cfgEvtRCTFlagCheckerZDCCheck, rctFlags.cfgEvtRCTFlagCheckerLimitAcceptAsBad); + rctChecker.init(cfg.cEvtRCTFlagCheckerLabel, cfg.cEvtRCTFlagCheckerZDCCheck, cfg.cEvtRCTFlagCheckerLimitAcceptAsBad); histos.add("hCentrality", "Centrality; Centrality (%); ", {HistType::kTH1D, {axisCent}}); @@ -398,23 +408,23 @@ struct FlowSP { histos.get(HIST("hTrackCount"))->GetXaxis()->SetBinLabel(trackSel_ZeroCharge + 1, "Only charged"); histos.get(HIST("hTrackCount"))->GetXaxis()->SetBinLabel(trackSel_ParticleWeights + 1, "Apply weights"); - if (cfgFillWeights) { + if (cfg.cFillWeights) { registry.add("weights2D/hPhi_Eta_vz", "", kTH3D, {axisPhi, axisEta, axisVz}); registry.add("weights2D/hPhi_Eta_vz_positive", "", kTH3D, {axisPhi, axisEta, axisVz}); registry.add("weights2D/hPhi_Eta_vz_negative", "", kTH3D, {axisPhi, axisEta, axisVz}); // define output objects - fWeights->setPtBins(ptbins, &ptbinning[0]); + fWeights->setPtBins(ptbins, &cfg.cPtBinning.value[0]); fWeights->init(true, false); - fWeightsPOS->setPtBins(ptbins, &ptbinning[0]); + fWeightsPOS->setPtBins(ptbins, &cfg.cPtBinning.value[0]); fWeightsPOS->init(true, false); - fWeightsNEG->setPtBins(ptbins, &ptbinning[0]); + fWeightsNEG->setPtBins(ptbins, &cfg.cPtBinning.value[0]); fWeightsNEG->init(true, false); } - if (cfgFillEventQA) { + if (cfg.cFillEventQA) { histos.add("QA/after/hCentFT0C", " ; Cent FT0C (%); ", {HistType::kTH1D, {axisCent}}); histos.add("QA/after/hCentFT0M", "; Cent FT0M (%); ", {HistType::kTH1D, {axisCent}}); histos.add("QA/after/hCentFV0A", "; Cent FV0A (%); ", {HistType::kTH1D, {axisCent}}); @@ -431,7 +441,7 @@ struct FlowSP { histos.add("QA/after/CentFT0C_vs_CentFV0A", " ; Cent FT0C (%); Cent FV0A (%) ", {HistType::kTH2D, {axisCent, axisCent}}); histos.add("QA/after/CentFT0C_vs_CentNGlobal", " ; Cent FT0C (%); Cent NGlobal (%) ", {HistType::kTH2D, {axisCent, axisCent}}); - if (cfgFillEventPlaneQA && doprocessData) { + if (cfg.cFillEventPlaneQA && doprocessData) { histos.add("QA/after/PsiA_vs_Cent", "", {HistType::kTH2D, {axisPhiPlane, axisCent}}); histos.add("QA/after/PsiC_vs_Cent", "", {HistType::kTH2D, {axisPhiPlane, axisCent}}); histos.add("QA/after/PsiFull_vs_Cent", "", {HistType::kTH2D, {axisPhiPlane, axisCent}}); @@ -447,14 +457,14 @@ struct FlowSP { // histos.add("QA/after/DeltaPsivsPx", "", {HistType::kTH3D, {axisCent, axisPhiPlane, axisPx}}); } - if (cfgFillQABefore) { + if (cfg.cFillQABefore) { histos.addClone("QA/after/", "QA/before/"); } } if (doprocessData || doprocessMCReco || doprocessDataPID) { - if (cfgFillTrackQA) { + if (cfg.cFillTrackQA) { histos.add("incl/QA/after/pt_phi", "", {HistType::kTH2D, {axisPt, axisPhiMod}}); histos.add("incl/QA/after/hPhi_Eta_vz", "", kTH3D, {axisPhi, axisEta, axisVz}); histos.add("incl/QA/after/hPhi_Eta_vz_corrected", "", kTH3D, {axisPhi, axisEta, axisVz}); @@ -465,7 +475,7 @@ struct FlowSP { histos.add("incl/QA/after/hCrossedRows_vs_SharedClusters", "", {HistType::kTH2D, {axisCl, axisShCl}}); histos.add("incl/QA/after/hMeanPtEta", "", {HistType::kTProfile2D, {axisEta, axisCent}}); - if (cfgTrackSelDoTrackQAvsCent) { + if (cfg.cTrackSelDoTrackQAvsCent) { histos.add("incl/QA/after/hPt_Eta", "", kTH3D, {axisPt, axisEta, axisCent}); histos.add("incl/QA/after/hPt_Eta_uncorrected", "", kTH3D, {axisPt, axisEta, axisCent}); histos.add("incl/QA/after/hPhi_Eta", "", kTH3D, {axisPhi, axisEta, axisCent}); @@ -475,11 +485,11 @@ struct FlowSP { histos.add("incl/QA/after/hPhi_Eta_Pt_corrected", "", kTH3D, {axisPhi, axisEta, axisPt}); } - if (cfgFillQABefore) + if (cfg.cFillQABefore) histos.addClone("incl/QA/after/", "incl/QA/before/"); } - if (cfgFillPIDQA && doprocessDataPID) { + if (cfg.cFillPIDQA && doprocessDataPID) { histos.add("hPIDcounts", "", kTH2D, {{{4, 0, 4}, axisPt}}); histos.get(HIST("hPIDcounts"))->GetXaxis()->SetBinLabel(1, "UFO"); histos.get(HIST("hPIDcounts"))->GetXaxis()->SetBinLabel(2, "Pion"); @@ -494,7 +504,7 @@ struct FlowSP { histos.add("incl/pion/QA/after/hNsigmaTPC_pt", "", {HistType::kTH2D, {axisPt, axisNsigma}}); histos.add("incl/pion/QA/after/hNsigmaTOF_pt", "", {HistType::kTH2D, {axisPt, axisNsigma}}); - if (cfgTrackSelDoTrackQAvsCent) { + if (cfg.cTrackSelDoTrackQAvsCent) { histos.add("incl/pion/QA/after/hPt_Eta", "", kTH3D, {axisPt, axisEta, axisCent}); histos.add("incl/pion/QA/after/hPt_Eta_uncorrected", "", kTH3D, {axisPt, axisEta, axisCent}); histos.add("incl/pion/QA/after/hPhi_Eta", "", kTH3D, {axisPhi, axisEta, axisCent}); @@ -511,7 +521,7 @@ struct FlowSP { histos.add("incl/pion/QA/after/hCrossedRows_pt", "", {HistType::kTH2D, {axisPt, axisCl}}); histos.add("incl/pion/QA/after/hCrossedRows_vs_SharedClusters", "", {HistType::kTH2D, {axisCl, axisShCl}}); - if (cfgFillQABefore) { + if (cfg.cFillQABefore) { histos.addClone("incl/pion/QA/after/", "incl/pion/QA/before/"); } @@ -519,16 +529,16 @@ struct FlowSP { histos.addClone("incl/pion/", "incl/proton/"); } - if (cfgFillEventQA) { + if (cfg.cFillEventQA) { histos.add("QA/hCentFull", " ; Centrality (%); ", {HistType::kTH1D, {axisCent}}); } if (doprocessMCReco) { - registry.add("trackMCReco/after/hIsPhysicalPrimary", "", {HistType::kTH2D, {{2, 0, 2}, axisCentrality}}); + registry.add("trackMCReco/after/incl/hIsPhysicalPrimary", "", {HistType::kTH3D, {{2, 0, 2}, axisCentrality, axisPt}}); + registry.get(HIST("trackMCReco/after/incl/hIsPhysicalPrimary"))->GetXaxis()->SetBinLabel(1, "Secondary"); + registry.get(HIST("trackMCReco/after/incl/hIsPhysicalPrimary"))->GetXaxis()->SetBinLabel(2, "Primary"); registry.add("trackMCReco/hTrackSize_unFiltered", "", {HistType::kTH2D, {{100, 0, 200000}, axisCentrality}}); registry.add("trackMCReco/hTrackSize_Filtered", "", {HistType::kTH2D, {{100, 0, 20000}, axisCentrality}}); - registry.get(HIST("trackMCReco/after/hIsPhysicalPrimary"))->GetXaxis()->SetBinLabel(1, "Secondary"); - registry.get(HIST("trackMCReco/after/hIsPhysicalPrimary"))->GetXaxis()->SetBinLabel(2, "Primary"); registry.add("trackMCReco/after/incl/hPt_hadron", "", {HistType::kTH3D, {axisPt, axisEta, axisCentrality}}); registry.add("trackMCReco/after/incl/hPt_proton", "", {HistType::kTH3D, {axisPt, axisEta, axisCentrality}}); registry.add("trackMCReco/after/incl/hPt_pion", "", {HistType::kTH3D, {axisPt, axisEta, axisCentrality}}); @@ -547,7 +557,7 @@ struct FlowSP { registry.add("QQCorrelations/qAYqCX", "", kTProfile, {axisCent}); registry.add("QQCorrelations/qAXYqCXY", "", kTProfile, {axisCent}); - if (cfgFillGeneralV1Histos) { + if (cfg.cFillGeneralV1Histos) { // track properties per centrality and per eta, pt bin registry.add("incl/vnCodd", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/vnAodd", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); @@ -555,48 +565,52 @@ struct FlowSP { registry.add("incl/vnA", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/vnCSetPlane", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/vnASetPlane", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); + registry.add("incl/vnOdd", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); + registry.add("incl/vnEven", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); } - if (cfgFillMeanPT) { - registry.add("incl/meanPT/meanRelPtA", "", kTProfile2D, {axisEtaVn, axisCentrality}); - registry.add("incl/meanPT/meanRelPtC", "", kTProfile2D, {axisEtaVn, axisCentrality}); - - registry.add("incl/meanPT/hMeanPtEtaCent", "", kTProfile2D, {axisEtaVn, axisCent}); - registry.add("incl/meanPT/ptV1A", "", kTProfile2D, {axisEtaVn, axisCent}); - registry.add("incl/meanPT/ptV1C", "", kTProfile2D, {axisEtaVn, axisCent}); - registry.add("incl/meanPT/ptV1Aodd", "", kTProfile2D, {axisEtaVn, axisCent}); - registry.add("incl/meanPT/ptV1Codd", "", kTProfile2D, {axisEtaVn, axisCent}); - registry.add("incl/meanPT/hMeanPtCent", "", kTProfile, {axisCent}); - + if (cfg.cFillMeanPT) { registry.add("incl/meanPT/ptV1A3D", "", kTProfile3D, {axisPt, axisEtaVn, axisCent}); registry.add("incl/meanPT/ptV1C3D", "", kTProfile3D, {axisPt, axisEtaVn, axisCent}); - registry.add("incl/meanPT/ptV1A3Dx", "", kTProfile3D, {axisPt, axisEtaVn, axisCent}); - registry.add("incl/meanPT/ptV1C3Dx", "", kTProfile3D, {axisPt, axisEtaVn, axisCent}); + if (cfg.cFillMeanPTextra) { + registry.add("incl/meanPT/meanRelPtA", "", kTProfile2D, {axisEtaVn, axisCentrality}); + registry.add("incl/meanPT/meanRelPtC", "", kTProfile2D, {axisEtaVn, axisCentrality}); + + registry.add("incl/meanPT/hMeanPtEtaCent", "", kTProfile2D, {axisEtaVn, axisCent}); + registry.add("incl/meanPT/ptV1A", "", kTProfile2D, {axisEtaVn, axisCent}); + registry.add("incl/meanPT/ptV1C", "", kTProfile2D, {axisEtaVn, axisCent}); + registry.add("incl/meanPT/ptV1Aodd", "", kTProfile2D, {axisEtaVn, axisCent}); + registry.add("incl/meanPT/ptV1Codd", "", kTProfile2D, {axisEtaVn, axisCent}); + registry.add("incl/meanPT/hMeanPtCent", "", kTProfile, {axisCent}); - registry.add("incl/meanPT/ptV1A3Dy", "", kTProfile3D, {axisPt, axisEtaVn, axisCent}); - registry.add("incl/meanPT/ptV1C3Dy", "", kTProfile3D, {axisPt, axisEtaVn, axisCent}); + registry.add("incl/meanPT/ptV1A3Dx", "", kTProfile3D, {axisPt, axisEtaVn, axisCent}); + registry.add("incl/meanPT/ptV1C3Dx", "", kTProfile3D, {axisPt, axisEtaVn, axisCent}); - registry.add("incl/meanPT/meanPxA", "", kTH3D, {axisCent, axisPhiPlane, axisPx}); - registry.add("incl/meanPT/meanPxC", "", kTH3D, {axisCent, axisPhiPlane, axisPx}); + registry.add("incl/meanPT/ptV1A3Dy", "", kTProfile3D, {axisPt, axisEtaVn, axisCent}); + registry.add("incl/meanPT/ptV1C3Dy", "", kTProfile3D, {axisPt, axisEtaVn, axisCent}); + + registry.add("incl/meanPT/meanPxA", "", kTH3D, {axisCent, axisPhiPlane, axisPx}); + registry.add("incl/meanPT/meanPxC", "", kTH3D, {axisCent, axisPhiPlane, axisPx}); + } } - if (cfgFillXandYterms) { + if (cfg.cFillXandYterms) { registry.add("incl/vnAx", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/vnAy", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/vnCx", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/vnCy", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); } - if (cfgFillMixedHarmonics) { + if (cfg.cFillMixedHarmonics) { registry.add("incl/MH/vnAxCxUx_MH", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/MH/vnAyCyUx_MH", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/MH/vnAxCyUy_MH", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/MH/vnAyCxUy_MH", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); } - if (cfgFillEventPlane) { + if (cfg.cFillEventPlane) { registry.add("incl/vnA_EP", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/vnC_EP", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/vnFull_EP", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); } - if (cfgFillEventPlaneQA) { + if (cfg.cFillEventPlaneQA) { histos.add("QA/hSPplaneA", "hSPplaneA", kTH1D, {axisPhiPlane}); histos.add("QA/hSPplaneC", "hSPplaneC", kTH1D, {axisPhiPlane}); histos.add("QA/hSPplaneFull", "hSPplaneFull", kTH1D, {axisPhiPlane}); @@ -609,7 +623,7 @@ struct FlowSP { } // end of doProcessData - if (cfgFillChargeDependence || cfgFillChargeDependenceQA) { + if (cfg.cFillChargeDependence || cfg.cFillChargeDependenceQA) { LOGF(info, "Cloning charge dependence histograms"); registry.addClone("incl/", "pos/"); registry.addClone("incl/", "neg/"); @@ -619,7 +633,7 @@ struct FlowSP { } if (doprocessDataPID) { - if (cfgFillGeneralV1Histos) { + if (cfg.cFillGeneralV1Histos) { registry.add("incl/pion/vnCodd", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/pion/vnAodd", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/pion/vnC", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); @@ -628,18 +642,18 @@ struct FlowSP { registry.add("incl/vnASetPlane", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); } - if (cfgFillEventPlane) { + if (cfg.cFillEventPlane) { registry.add("incl/pion/vnA_EP", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/pion/vnC_EP", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/pion/vnFull_EP", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); } - if (cfgFillXandYterms) { + if (cfg.cFillXandYterms) { registry.add("incl/pion/vnAx", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/pion/vnAy", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/pion/vnCx", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/pion/vnCy", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); } - if (cfgFillMixedHarmonics) { + if (cfg.cFillMixedHarmonics) { registry.add("incl/pion/MH/vnAxCxUx_MH", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/pion/MH/vnAyCyUx_MH", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); registry.add("incl/pion/MH/vnAxCyUy_MH", "", kTProfile3D, {axisPt, axisEtaVn, axisCentrality}); @@ -647,7 +661,7 @@ struct FlowSP { } registry.addClone("incl/pion/", "incl/proton/"); registry.addClone("incl/pion/", "incl/kaon/"); - if (cfgFillChargeDependence) { + if (cfg.cFillChargeDependence) { registry.addClone("incl/", "pos/"); registry.addClone("incl/", "neg/"); } @@ -665,22 +679,22 @@ struct FlowSP { registry.addClone("trackMCGen/after/", "trackMCGen/before/"); } - if (cfgEvSelsUseAdditionalEventCut) { + if (cfg.cEvSelsUseAdditionalEventCut) { fMultPVCutLow = new TF1("fMultPVCutLow", "[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x", 0, 100); fMultPVCutHigh = new TF1("fMultPVCutHigh", "[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x", 0, 100); fMultCutLow = new TF1("fMultCutLow", "[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x", 0, 100); fMultCutHigh = new TF1("fMultCutHigh", "[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x", 0, 100); - std::vector paramsMultPVCut = cfgEvSelsMultPv; - std::vector paramsMultCut = cfgEvSelsMult; + std::vector paramsMultPVCut = cfg.cEvSelsMultPv; + std::vector paramsMultCut = cfg.cEvSelsMult; - // number of parameters required in cfgEvSelsMultPv and cfgEvSelsMult. (5 Low + 5 High) + // number of parameters required in cfg.cEvSelsMultPv and cfg.cEvSelsMult. (5 Low + 5 High) uint64_t nParams = 10; if (paramsMultPVCut.size() < nParams) { - LOGF(fatal, "cfgEvSelsMultPv not set properly.. size = %d (should be 10) --> Check your config files!", paramsMultPVCut.size()); + LOGF(fatal, "cfg.cEvSelsMultPv not set properly.. size = %d (should be 10) --> Check your config files!", paramsMultPVCut.size()); } else if (paramsMultCut.size() < nParams) { - LOGF(fatal, "cfgEvSelsMult not set properly.. size = %d (should be 10) --> Check your config files!", paramsMultCut.size()); + LOGF(fatal, "cfg.cEvSelsMult not set properly.. size = %d (should be 10) --> Check your config files!", paramsMultCut.size()); } else { fMultPVCutLow->SetParameters(paramsMultPVCut[0], paramsMultPVCut[1], paramsMultPVCut[2], paramsMultPVCut[3], paramsMultPVCut[4]); fMultPVCutHigh->SetParameters(paramsMultPVCut[5], paramsMultPVCut[6], paramsMultPVCut[7], paramsMultPVCut[8], paramsMultPVCut[9]); @@ -689,7 +703,7 @@ struct FlowSP { } } - if (cfgTrackSelsUseAdditionalTrackCut) { + if (cfg.cTrackSelsUseAdditionalTrackCut) { fPhiCutLow = new TF1("fPhiCutLow", "0.06/x+pi/18.0-0.06", 0, 100); fPhiCutHigh = new TF1("fPhiCutHigh", "0.1/x+pi/18.0+0.06", 0, 100); } @@ -736,7 +750,7 @@ struct FlowSP { ParticleType valPID = kUnidentified; for (const auto& nsigma : usedNSigma) { - if (std::abs(nsigma.first) < cfgTrackSelsPIDNsigma) { + if (std::abs(nsigma.first) < cfg.cTrackSelsPIDNsigma) { valPID = nsigma.second; nIdentified++; } @@ -783,88 +797,107 @@ struct FlowSP { void loadCorrections(uint64_t timestamp) { // corrections saved on CCDB as TList {incl, pos, neg} of GFWWeights (acc) TH1D (eff) objects! - if (cfg.correctionsLoaded) + if (conf.correctionsLoaded) return; int nWeights = 3; - if (cfgUseNUA1D) { - if (cfgCCDB_NUA.value.empty() == false) { - TList* listCorrections = ccdb->getForTimeStamp(cfgCCDB_NUA, timestamp); - cfg.mAcceptance.push_back(reinterpret_cast(listCorrections->FindObject("weights"))); - cfg.mAcceptance.push_back(reinterpret_cast(listCorrections->FindObject("weights_positive"))); - cfg.mAcceptance.push_back(reinterpret_cast(listCorrections->FindObject("weights_negative"))); - int sizeAcc = cfg.mAcceptance.size(); + if (cfg.cUseNUA1D) { + if (cfg.cCCDB_NUA.value.empty() == false) { + TList* listCorrections = ccdb->getForTimeStamp(cfg.cCCDB_NUA, timestamp); + conf.mAcceptance.push_back(reinterpret_cast(listCorrections->FindObject("weights"))); + conf.mAcceptance.push_back(reinterpret_cast(listCorrections->FindObject("weights_positive"))); + conf.mAcceptance.push_back(reinterpret_cast(listCorrections->FindObject("weights_negative"))); + int sizeAcc = conf.mAcceptance.size(); if (sizeAcc < nWeights) - LOGF(fatal, "Could not load acceptance weights from %s", cfgCCDB_NUA.value.c_str()); + LOGF(fatal, "Could not load acceptance weights from %s", cfg.cCCDB_NUA.value.c_str()); else - LOGF(info, "Loaded acceptance weights from %s", cfgCCDB_NUA.value.c_str()); + LOGF(info, "Loaded acceptance weights from %s", cfg.cCCDB_NUA.value.c_str()); } else { - LOGF(info, "cfgCCDB_NUA empty! No corrections loaded"); + LOGF(info, "cfg.cCCDB_NUA empty! No corrections loaded"); } - } else if (cfgUseNUA2D) { - if (cfgCCDB_NUA.value.empty() == false) { - TH3D* hNUA2D = ccdb->getForTimeStamp(cfgCCDB_NUA, timestamp); + } else if (cfg.cUseNUA2D) { + if (cfg.cCCDB_NUA.value.empty() == false) { + TH3D* hNUA2D = ccdb->getForTimeStamp(cfg.cCCDB_NUA, timestamp); if (!hNUA2D) { - LOGF(fatal, "Could not load acceptance weights from %s", cfgCCDB_NUA.value.c_str()); + LOGF(fatal, "Could not load acceptance weights from %s", cfg.cCCDB_NUA.value.c_str()); } else { - LOGF(info, "Loaded acceptance weights from %s", cfgCCDB_NUA.value.c_str()); - cfg.mAcceptance2D.push_back(hNUA2D); + LOGF(info, "Loaded acceptance weights from %s", cfg.cCCDB_NUA.value.c_str()); + conf.mAcceptance2D.push_back(hNUA2D); } } else { - LOGF(info, "cfgCCDB_NUA empty! No corrections loaded"); + LOGF(info, "cfg.cCCDB_NUA empty! No corrections loaded"); } } // Get Efficiency correction - if (cfgCCDB_NUE.value.empty() == false) { - TList* listCorrections = ccdb->getForTimeStamp(cfgCCDB_NUE, timestamp); - cfg.mEfficiency.push_back(reinterpret_cast(listCorrections->FindObject("Efficiency"))); - cfg.mEfficiency.push_back(reinterpret_cast(listCorrections->FindObject("Efficiency_pos"))); - cfg.mEfficiency.push_back(reinterpret_cast(listCorrections->FindObject("Efficiency_neg"))); - int sizeEff = cfg.mEfficiency.size(); + if (cfg.cCCDB_NUE.value.empty() == false) { + TList* listCorrections = ccdb->getForTimeStamp(cfg.cCCDB_NUE, timestamp); + conf.mEfficiency.push_back(reinterpret_cast(listCorrections->FindObject("Efficiency"))); + conf.mEfficiency.push_back(reinterpret_cast(listCorrections->FindObject("Efficiency_pos"))); + conf.mEfficiency.push_back(reinterpret_cast(listCorrections->FindObject("Efficiency_neg"))); + int sizeEff = conf.mEfficiency.size(); if (sizeEff < nWeights) - LOGF(fatal, "Could not load efficiency histogram for trigger particles from %s", cfgCCDB_NUE.value.c_str()); + LOGF(fatal, "Could not load efficiency histogram for trigger particles from %s", cfg.cCCDB_NUE.value.c_str()); else - LOGF(info, "Loaded efficiency histogram from %s", cfgCCDB_NUE.value.c_str()); + LOGF(info, "Loaded efficiency histogram from %s", cfg.cCCDB_NUE.value.c_str()); } else { - LOGF(info, "cfgCCDB_NUE empty! No corrections loaded"); + LOGF(info, "cfg.cCCDB_NUE empty! No corrections loaded"); } // Get Efficiency correction - if (cfgCCDB_NUE2D.value.empty() == false) { - TList* listCorrections = ccdb->getForTimeStamp(cfgCCDB_NUE2D, timestamp); - cfg.mEfficiency2D.push_back(reinterpret_cast(listCorrections->FindObject("Efficiency"))); - cfg.mEfficiency2D.push_back(reinterpret_cast(listCorrections->FindObject("Efficiency_pos"))); - cfg.mEfficiency2D.push_back(reinterpret_cast(listCorrections->FindObject("Efficiency_neg"))); - int sizeEff = cfg.mEfficiency2D.size(); + if (cfg.cCCDB_NUE2D.value.empty() == false) { + TList* listCorrections = ccdb->getForTimeStamp(cfg.cCCDB_NUE2D, timestamp); + conf.mEfficiency2D.push_back(reinterpret_cast(listCorrections->FindObject("Efficiency"))); + conf.mEfficiency2D.push_back(reinterpret_cast(listCorrections->FindObject("Efficiency_pos"))); + conf.mEfficiency2D.push_back(reinterpret_cast(listCorrections->FindObject("Efficiency_neg"))); + int sizeEff = conf.mEfficiency2D.size(); + if (sizeEff < nWeights) + LOGF(fatal, "Could not load efficiency histogram for trigger particles from %s", cfg.cCCDB_NUE.value.c_str()); + else + LOGF(info, "Loaded efficiency histogram from %s", cfg.cCCDB_NUE.value.c_str()); + } else { + LOGF(info, "cfg.cCCDB_NUE2 empty! No corrections loaded"); + } + + if (cfg.cCCDB_NUE3D.value.empty() == false) { + TList* listCorrections = ccdb->getForTimeStamp(cfg.cCCDB_NUE3D, timestamp); + conf.mEfficiency3D.push_back(reinterpret_cast(listCorrections->FindObject("Efficiency"))); + conf.mEfficiency3D.push_back(reinterpret_cast(listCorrections->FindObject("Efficiency_pos"))); + conf.mEfficiency3D.push_back(reinterpret_cast(listCorrections->FindObject("Efficiency_neg"))); + int sizeEff = conf.mEfficiency3D.size(); if (sizeEff < nWeights) - LOGF(fatal, "Could not load efficiency histogram for trigger particles from %s", cfgCCDB_NUE.value.c_str()); + LOGF(fatal, "Could not load efficiency histogram for trigger particles from %s", cfg.cCCDB_NUE.value.c_str()); else - LOGF(info, "Loaded efficiency histogram from %s", cfgCCDB_NUE.value.c_str()); + LOGF(info, "Loaded efficiency histogram from %s", cfg.cCCDB_NUE.value.c_str()); } else { - LOGF(info, "cfgCCDB_NUE2 empty! No corrections loaded"); + LOGF(info, "cfg.cCCDB_NUE2 empty! No corrections loaded"); } - cfg.correctionsLoaded = true; + conf.correctionsLoaded = true; } // From Generic Framework bool setCurrentParticleWeights(int pID, int spec, const float& phi, const float& eta, const float& pt, const float& vtxz, const float& centrality) { float eff = 1.; - int sizeEff = cfg.mEfficiency.size(); + int sizeEff = conf.mEfficiency.size(); if (sizeEff > pID) { - if (cfgUseNUE2D) { + if (cfg.cUseNUE3D) { + int binx = conf.mEfficiency3D[pID]->GetXaxis()->FindBin(pt); + int biny = conf.mEfficiency3D[pID]->GetYaxis()->FindBin(eta); + int binz = conf.mEfficiency3D[pID]->GetZaxis()->FindBin(centrality); + eff = conf.mEfficiency3D[pID]->GetBinContent(binx, biny, binz); + } else if (cfg.cUseNUE2D) { int binx; int biny; - if (cfgUseNUE2Deta) { - biny = cfg.mEfficiency2D[pID]->GetYaxis()->FindBin(pt); - binx = cfg.mEfficiency2D[pID]->GetXaxis()->FindBin(eta); + if (cfg.cUseNUE2Deta) { + biny = conf.mEfficiency2D[pID]->GetYaxis()->FindBin(pt); + binx = conf.mEfficiency2D[pID]->GetXaxis()->FindBin(eta); } else { - binx = cfg.mEfficiency2D[pID]->GetXaxis()->FindBin(pt); - biny = cfg.mEfficiency2D[pID]->GetYaxis()->FindBin(centrality); + binx = conf.mEfficiency2D[pID]->GetXaxis()->FindBin(pt); + biny = conf.mEfficiency2D[pID]->GetYaxis()->FindBin(centrality); } - eff = cfg.mEfficiency2D[pID]->GetBinContent(binx, biny); + eff = conf.mEfficiency2D[pID]->GetBinContent(binx, biny); } else { - eff = cfg.mEfficiency[pID]->GetBinContent(cfg.mEfficiency[pID]->FindBin(pt)); + eff = conf.mEfficiency[pID]->GetBinContent(conf.mEfficiency[pID]->FindBin(pt)); } } else { eff = 1.0; @@ -874,16 +907,16 @@ struct FlowSP { spm.weff[pID][spec] = 1. / eff; - if (cfgUseNUA1D) { - int sizeAcc = cfg.mAcceptance.size(); + if (cfg.cUseNUA1D) { + int sizeAcc = conf.mAcceptance.size(); if (sizeAcc > pID) { - spm.wacc[pID][spec] = cfg.mAcceptance[pID]->getNUA(phi, eta, vtxz); + spm.wacc[pID][spec] = conf.mAcceptance[pID]->getNUA(phi, eta, vtxz); } else { spm.wacc[pID][spec] = 1; } - } else if (cfgUseNUA2D) { - if (cfg.mAcceptance2D.size() > 0) { - spm.wacc[pID][spec] = getNUA2D(cfg.mAcceptance2D[0], eta, phi, vtxz); + } else if (cfg.cUseNUA2D) { + if (conf.mAcceptance2D.size() > 0) { + spm.wacc[pID][spec] = getNUA2D(conf.mAcceptance2D[0], eta, phi, vtxz); } else { spm.wacc[pID][spec] = 1; } @@ -898,20 +931,20 @@ struct FlowSP { return 0; histos.fill(HIST("hEventCount"), evSel_sel8); - if (rctFlags.cfgEvtUseRCTFlagChecker && !rctChecker(collision)) + if (cfg.cEvtUseRCTFlagChecker && !rctChecker(collision)) return 0; histos.fill(HIST("hEventCount"), evSel_RCTFlagsZDC); // Occupancy - if (cfgEvSelsDoOccupancySel) { + if (cfg.cEvSelsDoOccupancySel) { auto occupancy = collision.trackOccupancyInTimeRange(); - if (occupancy > cfgEvSelsMaxOccupancy || occupancy < cfgEvSelsMinOccupancy) { + if (occupancy > cfg.cEvSelsMaxOccupancy || occupancy < cfg.cEvSelsMinOccupancy) { return 0; } histos.fill(HIST("hEventCount"), evSel_occupancy); } - if (cfgEvSelsNoSameBunchPileupCut) { + if (cfg.cEvSelsNoSameBunchPileupCut) { if (!collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { // rejects collisions which are associated with the same "found-by-T0" bunch crossing // https://indico.cern.ch/event/1396220/#1-event-selection-with-its-rof @@ -919,7 +952,7 @@ struct FlowSP { } histos.fill(HIST("hEventCount"), evSel_kNoSameBunchPileup); } - if (cfgEvSelsIsGoodZvtxFT0vsPV) { + if (cfg.cEvSelsIsGoodZvtxFT0vsPV) { if (!collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { // removes collisions with large differences between z of PV by tracks and z of PV from FT0 A-C time difference // use this cut at low multiplicities with caution @@ -927,21 +960,21 @@ struct FlowSP { } histos.fill(HIST("hEventCount"), evSel_kIsGoodZvtxFT0vsPV); } - if (cfgEvSelsNoCollInTimeRangeStandard) { + if (cfg.cEvSelsNoCollInTimeRangeStandard) { if (!collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard)) { // Rejection of the collisions which have other events nearby return 0; } histos.fill(HIST("hEventCount"), evSel_kNoCollInTimeRangeStandard); } - if (cfgEvSelsNoCollInTimeRangeNarrow) { + if (cfg.cEvSelsNoCollInTimeRangeNarrow) { if (!collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeNarrow)) { // Rejection of the collisions which have other events nearby return 0; } histos.fill(HIST("hEventCount"), evSel_kNoCollInTimeRangeNarrow); } - if (cfgEvSelsIsVertexITSTPC) { + if (cfg.cEvSelsIsVertexITSTPC) { if (!collision.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { // selects collisions with at least one ITS-TPC track, and thus rejects vertices built from ITS-only tracks return 0; @@ -949,7 +982,7 @@ struct FlowSP { histos.fill(HIST("hEventCount"), evSel_kIsVertexITSTPC); } - if (cfgEvSelsIsGoodITSLayersAll) { + if (cfg.cEvSelsIsGoodITSLayersAll) { if (!collision.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll)) { // New event selection bits to cut time intervals with dead ITS staves // https://indico.cern.ch/event/1493023/ (09-01-2025) @@ -957,14 +990,14 @@ struct FlowSP { } histos.fill(HIST("hEventCount"), evSel_kIsGoodITSLayersAll); } - if (cfgEvSelsIsGoodITSLayer0123) { + if (cfg.cEvSelsIsGoodITSLayer0123) { if (!collision.selection_bit(o2::aod::evsel::kIsGoodITSLayer0123)) { return 0; } histos.fill(HIST("hEventCount"), evSel_kIsGoodITSLayer0123); } - if (cfgEvSelsUseAdditionalEventCut) { + if (cfg.cEvSelsUseAdditionalEventCut) { float vtxz = -999; if (collision.numContrib() > 1) { vtxz = collision.posZ(); @@ -977,7 +1010,7 @@ struct FlowSP { auto multNTracksPV = collision.multNTracksPV(); - if (vtxz > cfgEvSelsVtxZ || vtxz < -cfgEvSelsVtxZ) + if (vtxz > cfg.cEvSelsVtxZ || vtxz < -cfg.cEvSelsVtxZ) return 0; if (multNTracksPV < fMultPVCutLow->Eval(collision.centFT0C())) return 0; @@ -997,33 +1030,33 @@ struct FlowSP { template bool trackSelected(TrackObject track, const int& field) { - if (std::fabs(track.eta()) > cfgTrackSelsEta) + if (std::fabs(track.eta()) > cfg.cTrackSelsEta) return false; histos.fill(HIST("hTrackCount"), trackSel_Eta); - if (track.pt() < cfgTrackSelsPtmin || track.pt() > cfgTrackSelsPtmax) + if (track.pt() < cfg.cTrackSelsPtmin || track.pt() > cfg.cTrackSelsPtmax) return false; histos.fill(HIST("hTrackCount"), trackSel_Pt); - if (track.dcaXY() > cfgTrackSelsDCAxy) + if (track.dcaXY() > cfg.cTrackSelsDCAxy) return false; histos.fill(HIST("hTrackCount"), trackSel_DCAxy); - if (track.dcaZ() > cfgTrackSelsDCAz) + if (track.dcaZ() > cfg.cTrackSelsDCAz) return false; - if (cfgTrackSelsDoDCApt && std::fabs(track.dcaZ()) > (cfgTrackSelsDCAptConsMin + (cfgTrackSelsDCApt1 * cfgTrackSelsDCApt2) / (std::pow(track.pt(), 1.1)))) + if (cfg.cTrackSelsDoDCApt && std::fabs(track.dcaZ()) > (cfg.cTrackSelsDCAptConsMin + (cfg.cTrackSelsDCApt1 * cfg.cTrackSelsDCApt2) / (std::pow(track.pt(), 1.1)))) return false; histos.fill(HIST("hTrackCount"), trackSel_DCAz); - if (track.tpcNClsCrossedRows() < cfgTrackSelsNcls) + if (track.tpcNClsCrossedRows() < cfg.cTrackSelsNcls) return false; histos.fill(HIST("hTrackCount"), trackSel_NCls); - if (track.tpcFractionSharedCls() > cfgTrackSelsFshcls) + if (track.tpcFractionSharedCls() > cfg.cTrackSelsFshcls) return false; histos.fill(HIST("hTrackCount"), trackSel_FshCls); @@ -1037,14 +1070,14 @@ struct FlowSP { phimodn += o2::constants::math::PI / 18.0; // to center gap in the middle phimodn = fmod(phimodn, o2::constants::math::PI / 9.0); - if (cfgFillTrackQA && cfgFillQABefore) + if (cfg.cFillTrackQA && cfg.cFillQABefore) histos.fill(HIST("incl/QA/before/pt_phi"), track.pt(), phimodn); - if (cfgTrackSelsUseAdditionalTrackCut) { + if (cfg.cTrackSelsUseAdditionalTrackCut) { if (phimodn < fPhiCutHigh->Eval(track.pt()) && phimodn > fPhiCutLow->Eval(track.pt())) return false; // reject track } - if (cfgFillTrackQA) + if (cfg.cFillTrackQA) histos.fill(HIST("incl/QA/after/pt_phi"), track.pt(), phimodn); histos.fill(HIST("hTrackCount"), trackSel_TPCBoundary); return true; @@ -1053,7 +1086,7 @@ struct FlowSP { template inline void fillEventQA(CollisionObject collision, TracksObject tracks) { - if (!cfgFillEventQA) + if (!cfg.cFillEventQA) return; static constexpr std::string_view Time[] = {"before", "after"}; @@ -1074,7 +1107,7 @@ struct FlowSP { histos.fill(HIST("QA/") + HIST(Time[ft]) + HIST("/CentFT0C_vs_CentFV0A"), collision.centFT0C(), collision.centFV0A(), spm.centWeight); histos.fill(HIST("QA/") + HIST(Time[ft]) + HIST("/CentFT0C_vs_CentNGlobal"), collision.centFT0C(), collision.centNGlobal(), spm.centWeight); - if (cfgFillEventPlaneQA) { + if (cfg.cFillEventPlaneQA) { if constexpr (o2::framework::has_type_v) { double psiA = 1.0 * std::atan2(collision.qyA(), collision.qxA()); double psiC = 1.0 * std::atan2(collision.qyC(), collision.qxC()); @@ -1107,64 +1140,68 @@ struct FlowSP { if (track.eta() < 0) scale = -1.0; - if (cfgFillGeneralV1Histos) { + if (cfg.cFillGeneralV1Histos) { registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnAodd"), track.pt(), track.eta(), spm.centrality, scale * (spm.uy * spm.qyA + spm.ux * spm.qxA) / std::sqrt(std::fabs(spm.corrQQ)), weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnCodd"), track.pt(), track.eta(), spm.centrality, scale * (spm.uy * spm.qyC + spm.ux * spm.qxC) / std::sqrt(std::fabs(spm.corrQQ)), weight); + registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnOdd"), track.pt(), track.eta(), spm.centrality, scale *0.5 * ((spm.uy * spm.qyA + spm.ux * spm.qxA) - (spm.uy * spm.qyC + spm.ux * spm.qxC)) / std::sqrt(std::fabs(spm.corrQQ)), weight); + registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnEven"), track.pt(), track.eta(), spm.centrality, 0.5 * ((spm.uy * spm.qyA + spm.ux * spm.qxA) + (spm.uy * spm.qyC + spm.ux * spm.qxC)) / std::sqrt(std::fabs(spm.corrQQ)), weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnA"), track.pt(), track.eta(), spm.centrality, (spm.uy * spm.qyA + spm.ux * spm.qxA) / std::sqrt(std::fabs(spm.corrQQ)), weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnC"), track.pt(), track.eta(), spm.centrality, (spm.uy * spm.qyC + spm.ux * spm.qxC) / std::sqrt(std::fabs(spm.corrQQ)), weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnCSetPlane"), track.pt(), track.eta(), spm.centrality, (spm.uy + spm.ux) / std::sqrt(std::fabs(spm.corrQQ)), weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnASetPlane"), track.pt(), track.eta(), spm.centrality, (minusQ * spm.ux - spm.uy) / std::sqrt(std::fabs(spm.corrQQ)), weight); } - if (cfgFillMixedHarmonics) { + if (cfg.cFillMixedHarmonics) { registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("MH/vnAxCxUx_MH"), track.pt(), track.eta(), spm.centrality, (spm.uxMH * spm.qxA * spm.qxC) / spm.corrQQx, weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("MH/vnAyCyUx_MH"), track.pt(), track.eta(), spm.centrality, (spm.uxMH * spm.qyA * spm.qyC) / spm.corrQQy, weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("MH/vnAxCyUy_MH"), track.pt(), track.eta(), spm.centrality, (spm.uyMH * spm.qxA * spm.qyC) / spm.corrQQx, weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("MH/vnAyCxUy_MH"), track.pt(), track.eta(), spm.centrality, (spm.uyMH * spm.qyA * spm.qxC) / spm.corrQQy, weight); } - if (cfgFillXandYterms) { + if (cfg.cFillXandYterms) { registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnAx"), track.pt(), track.eta(), spm.centrality, (spm.ux * spm.qxA) / std::sqrt(std::fabs(spm.corrQQx)), weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnAy"), track.pt(), track.eta(), spm.centrality, (spm.uy * spm.qyA) / std::sqrt(std::fabs(spm.corrQQy)), weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnCx"), track.pt(), track.eta(), spm.centrality, (spm.ux * spm.qxC) / std::sqrt(std::fabs(spm.corrQQx)), weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnCy"), track.pt(), track.eta(), spm.centrality, (spm.uy * spm.qyC) / std::sqrt(std::fabs(spm.corrQQy)), weight); } - if (cfgFillEventPlane) { // only fill for inclusive! + if (cfg.cFillEventPlane) { // only fill for inclusive! registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnA_EP"), track.pt(), track.eta(), spm.centrality, spm.vnA, weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnC_EP"), track.pt(), track.eta(), spm.centrality, spm.vnC, weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnFull_EP"), track.pt(), track.eta(), spm.centrality, spm.vnFull, weight); } - if (cfgFillMeanPT) { - registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/hMeanPtEtaCent"), track.eta(), spm.centrality, track.pt(), weight); - registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/hMeanPtCent"), spm.centrality, track.pt(), weight); - registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1A"), track.eta(), spm.centrality, track.pt() * ((spm.uy * spm.qyA + spm.ux * spm.qxA) / (std::sqrt(std::fabs(spm.corrQQ)) * spm.meanPtWeight)), weight); - registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1C"), track.eta(), spm.centrality, track.pt() * ((spm.uy * spm.qyC + spm.ux * spm.qxC) / (std::sqrt(std::fabs(spm.corrQQ)) * spm.meanPtWeight)), weight); - - registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1Aodd"), track.eta(), spm.centrality, track.pt() * scale * ((spm.uy * spm.qyA + spm.ux * spm.qxA) / (std::sqrt(std::fabs(spm.corrQQ)) * spm.meanPtWeight)), weight); - registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1Codd"), track.eta(), spm.centrality, track.pt() * scale * ((spm.uy * spm.qyC + spm.ux * spm.qxC) / (std::sqrt(std::fabs(spm.corrQQ)) * spm.meanPtWeight)), weight); - + if (cfg.cFillMeanPT) { registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1A3D"), track.pt(), track.eta(), spm.centrality, track.pt() * ((spm.uy * spm.qyA + spm.ux * spm.qxA) / (std::sqrt(std::fabs(spm.corrQQ)) * spm.meanPtWeight)), weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1C3D"), track.pt(), track.eta(), spm.centrality, track.pt() * ((spm.uy * spm.qyC + spm.ux * spm.qxC) / (std::sqrt(std::fabs(spm.corrQQ)) * spm.meanPtWeight)), weight); - registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1A3Dx"), track.pt(), track.eta(), spm.centrality, track.pt() * ((spm.ux * spm.qxA) / (std::sqrt(std::fabs(spm.corrQQx)) * spm.meanPtWeight)), weight); - registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1C3Dx"), track.pt(), track.eta(), spm.centrality, track.pt() * ((spm.ux * spm.qxC) / (std::sqrt(std::fabs(spm.corrQQx)) * spm.meanPtWeight)), weight); + if (cfg.cFillMeanPTextra) { + registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/hMeanPtEtaCent"), track.eta(), spm.centrality, track.pt(), weight); + registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/hMeanPtCent"), spm.centrality, track.pt(), weight); + registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1A"), track.eta(), spm.centrality, track.pt() * ((spm.uy * spm.qyA + spm.ux * spm.qxA) / (std::sqrt(std::fabs(spm.corrQQ)) * spm.meanPtWeight)), weight); + registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1C"), track.eta(), spm.centrality, track.pt() * ((spm.uy * spm.qyC + spm.ux * spm.qxC) / (std::sqrt(std::fabs(spm.corrQQ)) * spm.meanPtWeight)), weight); + + registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1Aodd"), track.eta(), spm.centrality, track.pt() * scale * ((spm.uy * spm.qyA + spm.ux * spm.qxA) / (std::sqrt(std::fabs(spm.corrQQ)) * spm.meanPtWeight)), weight); + registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1Codd"), track.eta(), spm.centrality, track.pt() * scale * ((spm.uy * spm.qyC + spm.ux * spm.qxC) / (std::sqrt(std::fabs(spm.corrQQ)) * spm.meanPtWeight)), weight); - registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1A3Dy"), track.pt(), track.eta(), spm.centrality, track.pt() * ((spm.uy * spm.qyA) / (std::sqrt(std::fabs(spm.corrQQy)) * spm.meanPtWeight)), weight); - registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1C3Dy"), track.pt(), track.eta(), spm.centrality, track.pt() * ((spm.uy * spm.qyC) / (std::sqrt(std::fabs(spm.corrQQy)) * spm.meanPtWeight)), weight); + registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1A3Dx"), track.pt(), track.eta(), spm.centrality, track.pt() * ((spm.ux * spm.qxA) / (std::sqrt(std::fabs(spm.corrQQx)) * spm.meanPtWeight)), weight); + registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1C3Dx"), track.pt(), track.eta(), spm.centrality, track.pt() * ((spm.ux * spm.qxC) / (std::sqrt(std::fabs(spm.corrQQx)) * spm.meanPtWeight)), weight); + + registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1A3Dy"), track.pt(), track.eta(), spm.centrality, track.pt() * ((spm.uy * spm.qyA) / (std::sqrt(std::fabs(spm.corrQQy)) * spm.meanPtWeight)), weight); + registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("meanPT/ptV1C3Dy"), track.pt(), track.eta(), spm.centrality, track.pt() * ((spm.uy * spm.qyC) / (std::sqrt(std::fabs(spm.corrQQy)) * spm.meanPtWeight)), weight); + } } } template inline void fillTrackQA(TrackObject track) { - if (!cfgFillTrackQA) + if (!cfg.cFillTrackQA) return; static constexpr std::string_view Time[] = {"before/", "after/"}; - // NOTE: species[kUnidentified] = "" (when nocfgTrackSelDo) { - if (cfgTrackSelDoTrackQAvsCent) { + // NOTE: species[kUnidentified] = "" (when nocfg.cTrackSelDo) { + if (cfg.cTrackSelDoTrackQAvsCent) { histos.fill(HIST(Charge[ct]) + HIST(Species[par]) + HIST("QA/") + HIST(Time[ft]) + HIST("hPt_Eta"), track.pt(), track.eta(), spm.centrality, spm.wacc[ct][par] * spm.weff[ct][par]); histos.fill(HIST(Charge[ct]) + HIST(Species[par]) + HIST("QA/") + HIST(Time[ft]) + HIST("hPt_Eta_uncorrected"), track.pt(), track.eta(), spm.centrality); histos.fill(HIST(Charge[ct]) + HIST(Species[par]) + HIST("QA/") + HIST(Time[ft]) + HIST("hPhi_Eta"), track.phi(), track.eta(), spm.centrality, spm.wacc[ct][par] * spm.weff[ct][par]); @@ -1187,7 +1224,7 @@ struct FlowSP { template inline void fillPIDQA(TrackObject track) { - if (!cfgFillTrackQA) + if (!cfg.cFillTrackQA) return; if constexpr (framework::has_type_v) { histos.fill(HIST(Charge[ct]) + HIST("pion/") + HIST("QA/") + HIST(Time[ft]) + HIST("hNsigmaTOF_pt"), track.pt(), track.tofNSigmaPi()); @@ -1238,15 +1275,15 @@ struct FlowSP { } } - template + template inline void fillPrimaryHistos(McParticleObject mcparticle) { static constexpr std::string_view Time[] = {"/before", "/after"}; if (!mcparticle.isPhysicalPrimary()) { - registry.fill(HIST("trackMCReco") + HIST(Time[ft]) + HIST("/hIsPhysicalPrimary"), 0, spm.centrality); + registry.fill(HIST("trackMCReco") + HIST(Time[ft]) + HIST("/") + HIST(Charge[ct]) + HIST("hIsPhysicalPrimary"), 0, spm.centrality, mcparticle.pt()); } else { - registry.fill(HIST("trackMCReco") + HIST(Time[ft]) + HIST("/hIsPhysicalPrimary"), 1, spm.centrality); + registry.fill(HIST("trackMCReco") + HIST(Time[ft]) + HIST("/") + HIST(Charge[ct]) + HIST("hIsPhysicalPrimary"), 1, spm.centrality, mcparticle.pt()); } } @@ -1256,7 +1293,7 @@ struct FlowSP { fillTrackQA(track); fillPIDQA(track); - if (cfgFillChargeDependenceQA) { + if (cfg.cFillChargeDependenceQA) { switch (spm.charge) { case kPositive: { fillTrackQA(track); @@ -1278,30 +1315,30 @@ struct FlowSP { histos.fill(HIST("hEventCount"), evSel_FilteredEvent); auto bc = collision.bc_as(); int standardMagField = 99999; - auto field = (cfgMagField == standardMagField) ? getMagneticField(bc.timestamp()) : cfgMagField; - - if (bc.runNumber() != cfg.lastRunNumber) { - cfg.correctionsLoaded = false; - cfg.clCentrality = false; - cfg.lastRunNumber = bc.runNumber(); - cfg.mAcceptance.clear(); - LOGF(info, "Size of mAcceptance: %i (should be 0)", (int)cfg.mAcceptance.size()); + auto field = (cfg.cMagField == standardMagField) ? getMagneticField(bc.timestamp()) : cfg.cMagField; + + if (bc.runNumber() != conf.lastRunNumber) { + conf.correctionsLoaded = false; + conf.clCentrality = false; + conf.lastRunNumber = bc.runNumber(); + conf.mAcceptance.clear(); + LOGF(info, "Size of mAcceptance: %i (should be 0)", (int)conf.mAcceptance.size()); } - if (cfgFillQABefore) + if (cfg.cFillQABefore) fillEventQA(collision, tracks); loadCorrections(bc.timestamp()); spm.centrality = collision.centFT0C(); - if (cfgCentFT0Cvariant1) + if (cfg.cCentFT0Cvariant1) spm.centrality = collision.centFT0CVariant1(); - if (cfgCentFT0M) + if (cfg.cCentFT0M) spm.centrality = collision.centFT0M(); - if (cfgCentFV0A) + if (cfg.cCentFV0A) spm.centrality = collision.centFV0A(); - if (cfgCentNGlobal) + if (cfg.cCentNGlobal) spm.centrality = collision.centNGlobal(); if (!eventSelected(collision, tracks.size())) @@ -1336,10 +1373,10 @@ struct FlowSP { registry.fill(HIST("QQCorrelations/qAqCX"), spm.centrality, spm.qxA * spm.qxC); registry.fill(HIST("QQCorrelations/qAqCY"), spm.centrality, spm.qyA * spm.qyC); - if (cfgFillEventQA) { + if (cfg.cFillEventQA) { histos.fill(HIST("QA/hCentFull"), spm.centrality, 1); } - if (cfgFillEventPlaneQA) { + if (cfg.cFillEventPlaneQA) { histos.fill(HIST("QA/hSPplaneA"), spm.psiA, 1); histos.fill(HIST("QA/hSPplaneC"), spm.psiC, 1); histos.fill(HIST("QA/hSPplaneFull"), spm.psiFull, 1); @@ -1350,7 +1387,7 @@ struct FlowSP { histos.fill(HIST("QA/hFullEvPlaneRes"), spm.centrality, -1 * std::cos(spm.psiA - spm.psiC)); } - if (spm.centrality > cfgCentMax || spm.centrality < cfgCentMin) + if (spm.centrality > cfg.cCentMax || spm.centrality < cfg.cCentMin) return; histos.fill(HIST("hEventCount"), evSel_CentCuts); @@ -1359,38 +1396,38 @@ struct FlowSP { // Only load once! // If not loaded set to 1 - if (cfgCCDBdir_QQ.value.empty() == false) { - if (!cfg.clQQ) { - TList* hcorrList = ccdb->getForTimeStamp(cfgCCDBdir_QQ.value, bc.timestamp()); - cfg.hcorrQQ = reinterpret_cast(hcorrList->FindObject("qAqCXY")); - cfg.hcorrQQx = reinterpret_cast(hcorrList->FindObject("qAqCX")); - cfg.hcorrQQy = reinterpret_cast(hcorrList->FindObject("qAqCY")); - cfg.clQQ = true; + if (cfg.cCCDBdir_QQ.value.empty() == false) { + if (!conf.clQQ) { + TList* hcorrList = ccdb->getForTimeStamp(cfg.cCCDBdir_QQ.value, bc.timestamp()); + conf.hcorrQQ = reinterpret_cast(hcorrList->FindObject("qAqCXY")); + conf.hcorrQQx = reinterpret_cast(hcorrList->FindObject("qAqCX")); + conf.hcorrQQy = reinterpret_cast(hcorrList->FindObject("qAqCY")); + conf.clQQ = true; } - spm.corrQQ = cfg.hcorrQQ->GetBinContent(cfg.hcorrQQ->FindBin(spm.centrality)); - spm.corrQQx = cfg.hcorrQQx->GetBinContent(cfg.hcorrQQx->FindBin(spm.centrality)); - spm.corrQQy = cfg.hcorrQQy->GetBinContent(cfg.hcorrQQy->FindBin(spm.centrality)); + spm.corrQQ = conf.hcorrQQ->GetBinContent(conf.hcorrQQ->FindBin(spm.centrality)); + spm.corrQQx = conf.hcorrQQx->GetBinContent(conf.hcorrQQx->FindBin(spm.centrality)); + spm.corrQQy = conf.hcorrQQy->GetBinContent(conf.hcorrQQy->FindBin(spm.centrality)); } double evPlaneRes = 1.; - if (cfgCCDBdir_SP.value.empty() == false) { - if (!cfg.clEvPlaneRes) { - cfg.hEvPlaneRes = ccdb->getForTimeStamp(cfgCCDBdir_SP.value, bc.timestamp()); - cfg.clEvPlaneRes = true; + if (cfg.cCCDBdir_SP.value.empty() == false) { + if (!conf.clEvPlaneRes) { + conf.hEvPlaneRes = ccdb->getForTimeStamp(cfg.cCCDBdir_SP.value, bc.timestamp()); + conf.clEvPlaneRes = true; } - evPlaneRes = cfg.hEvPlaneRes->GetBinContent(cfg.hEvPlaneRes->FindBin(spm.centrality)); + evPlaneRes = conf.hEvPlaneRes->GetBinContent(conf.hEvPlaneRes->FindBin(spm.centrality)); if (evPlaneRes < 0) LOGF(fatal, " > 0 for centrality %.2f! Cannot determine resolution.. Change centrality ranges!!!", spm.centrality); evPlaneRes = std::sqrt(evPlaneRes); } spm.centWeight = 1.; - if (cfgCCDBdir_centrality.value.empty() == false) { - if (!cfg.clCentrality) { - cfg.hCentrality = ccdb->getForTimeStamp(cfgCCDBdir_centrality.value, bc.timestamp()); - cfg.clCentrality = true; + if (cfg.cCCDBdir_centrality.value.empty() == false) { + if (!conf.clCentrality) { + conf.hCentrality = ccdb->getForTimeStamp(cfg.cCCDBdir_centrality.value, bc.timestamp()); + conf.clCentrality = true; } - double centW = cfg.hCentrality->GetBinContent(cfg.hCentrality->FindBin(spm.centrality)); + double centW = conf.hCentrality->GetBinContent(conf.hCentrality->FindBin(spm.centrality)); if (centW < 0) { spm.centWeight = 0.; LOGF(fatal, "Centrality weight cannot be negative .. setting to 0. for (%.2f)", spm.centrality); @@ -1421,11 +1458,12 @@ struct FlowSP { if (track.sign() == 0) continue; + histos.fill(HIST("hTrackCount"), trackSel_ZeroCharge); spm.charge = ((track.sign() > 0)) ? kPositive : kNegative; - if (cfgFillQABefore) { + if (cfg.cFillQABefore) { fillAllQA(track); } @@ -1433,14 +1471,14 @@ struct FlowSP { continue; spm.meanPtWeight = 1.0; - if (cfgCCDBdir_meanPt.value.empty() == false) { - if (!cfg.clMeanPt) { - cfg.hMeanPt = ccdb->getForTimeStamp(cfgCCDBdir_meanPt.value, bc.timestamp()); - cfg.clMeanPt = true; + if (cfg.cCCDBdir_meanPt.value.empty() == false) { + if (!conf.clMeanPt) { + conf.hMeanPt = ccdb->getForTimeStamp(cfg.cCCDBdir_meanPt.value, bc.timestamp()); + conf.clMeanPt = true; } - int etaBin = cfg.hMeanPt->GetXaxis()->FindBin(track.eta()); - int centBin = cfg.hMeanPt->GetYaxis()->FindBin(spm.centrality); - double weight = cfg.hMeanPt->GetBinContent(etaBin, centBin); + int etaBin = conf.hMeanPt->GetXaxis()->FindBin(track.eta()); + int centBin = conf.hMeanPt->GetYaxis()->FindBin(spm.centrality); + double weight = conf.hMeanPt->GetBinContent(etaBin, centBin); if (weight > 0) { spm.meanPtWeight = 1.0 / weight; } else { @@ -1454,15 +1492,15 @@ struct FlowSP { // Fill NUA weights (last 0 is for Data see GFWWeights class (not a weight)) // ToDo: Add pi, ka, proton here! - if (cfgFillWeights) { + if (cfg.cFillWeights) { fWeights->fill(phi, track.eta(), spm.vz, track.pt(), spm.centrality, 0); registry.fill(HIST("weights2D/hPhi_Eta_vz"), phi, track.eta(), spm.vz, 1); } - if (cfgFillWeightsPOS && spm.charge == kPositive) { + if (cfg.cFillWeightsPOS && spm.charge == kPositive) { fWeightsPOS->fill(phi, track.eta(), spm.vz, track.pt(), spm.centrality, 0); registry.fill(HIST("weights2D/hPhi_Eta_vz_positive"), phi, track.eta(), spm.vz, 1); } - if (cfgFillWeightsNEG && spm.charge == kNegative) { + if (cfg.cFillWeightsNEG && spm.charge == kNegative) { fWeightsNEG->fill(phi, track.eta(), spm.vz, track.pt(), spm.centrality, 0); registry.fill(HIST("weights2D/hPhi_Eta_vz_negative"), phi, track.eta(), spm.vz, 1); } @@ -1478,16 +1516,16 @@ struct FlowSP { fillAllQA(track); // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - spm.ux = std::cos(cfgHarm * phi); - spm.uy = std::sin(cfgHarm * phi); + spm.ux = std::cos(cfg.cHarm * phi); + spm.uy = std::sin(cfg.cHarm * phi); - spm.uxMH = std::cos(cfgHarmMixed * phi); - spm.uyMH = std::sin(cfgHarmMixed * phi); + spm.uxMH = std::cos(cfg.cHarmMixed * phi); + spm.uyMH = std::sin(cfg.cHarmMixed * phi); // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - spm.vnA = std::cos(cfgHarm * (phi - spm.psiA)) / evPlaneRes; - spm.vnC = std::cos(cfgHarm * (phi - spm.psiC)) / evPlaneRes; - spm.vnFull = std::cos(cfgHarm * (phi - spm.psiFull)) / evPlaneRes; + spm.vnA = std::cos(cfg.cHarm * (phi - spm.psiA)) / evPlaneRes; + spm.vnC = std::cos(cfg.cHarm * (phi - spm.psiC)) / evPlaneRes; + spm.vnFull = std::cos(cfg.cHarm * (phi - spm.psiFull)) / evPlaneRes; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -1496,7 +1534,7 @@ struct FlowSP { fillHistograms(track); - if (cfgFillChargeDependence) { + if (cfg.cFillChargeDependence) { switch (spm.charge) { case kPositive: fillHistograms(track); @@ -1539,14 +1577,14 @@ struct FlowSP { double meanPxAEvent = sumPxAEvent / meanPxEventCount; double meanPxCEvent = sumPxCEvent / meanPxEventCount; - if (cfgFillMeanPT) { + if (cfg.cFillMeanPTextra) { registry.fill(HIST("incl/meanPT/meanPxA"), spm.centrality, spm.psiA - spm.psiC, meanPxAEvent); registry.fill(HIST("incl/meanPT/meanPxC"), spm.centrality, spm.psiA - spm.psiC, meanPxCEvent); } // Now we want to fill the final relPt histogram // Loop over all eta and fill bins - if (cfgFillMeanPT) { + if (cfg.cFillMeanPTextra) { int nBinsEta = 8; for (int etabin = 1; etabin <= nBinsEta; etabin++) { // eta bin is 1 --> Find centbin!! @@ -1567,7 +1605,7 @@ struct FlowSP { registry.fill(HIST("incl/meanPT/meanRelPtA"), eta, spm.centrality, drelPxA / meanPt, spm.centWeight); registry.fill(HIST("incl/meanPT/meanRelPtC"), eta, spm.centrality, drelPxC / meanPt, spm.centWeight); - if (cfgFillChargeDependence) { + if (cfg.cFillChargeDependence) { registry.fill(HIST("neg/meanPT/meanRelPtA"), eta, spm.centrality, drelPxANeg / meanPtNeg, spm.centWeight); registry.fill(HIST("pos/meanPT/meanRelPtA"), eta, spm.centrality, drelPxAPos / meanPtPos, spm.centWeight); registry.fill(HIST("neg/meanPT/meanRelPtC"), eta, spm.centrality, drelPxCNeg / meanPtNeg, spm.centWeight); @@ -1596,30 +1634,30 @@ struct FlowSP { histos.fill(HIST("hEventCount"), evSel_FilteredEvent); auto bc = collision.bc_as(); int standardMagField = 99999; - auto field = (cfgMagField == standardMagField) ? getMagneticField(bc.timestamp()) : cfgMagField; - - if (bc.runNumber() != cfg.lastRunNumber) { - cfg.correctionsLoaded = false; - cfg.clCentrality = false; - cfg.lastRunNumber = bc.runNumber(); - cfg.mAcceptance.clear(); - LOGF(info, "Size of mAcceptance: %i (should be 0)", (int)cfg.mAcceptance.size()); + auto field = (cfg.cMagField == standardMagField) ? getMagneticField(bc.timestamp()) : cfg.cMagField; + + if (bc.runNumber() != conf.lastRunNumber) { + conf.correctionsLoaded = false; + conf.clCentrality = false; + conf.lastRunNumber = bc.runNumber(); + conf.mAcceptance.clear(); + LOGF(info, "Size of mAcceptance: %i (should be 0)", (int)conf.mAcceptance.size()); } - if (cfgFillQABefore) + if (cfg.cFillQABefore) fillEventQA(collision, tracks); loadCorrections(bc.timestamp()); spm.centrality = collision.centFT0C(); - if (cfgCentFT0Cvariant1) + if (cfg.cCentFT0Cvariant1) spm.centrality = collision.centFT0CVariant1(); - if (cfgCentFT0M) + if (cfg.cCentFT0M) spm.centrality = collision.centFT0M(); - if (cfgCentFV0A) + if (cfg.cCentFV0A) spm.centrality = collision.centFV0A(); - if (cfgCentNGlobal) + if (cfg.cCentNGlobal) spm.centrality = collision.centNGlobal(); if (!eventSelected(collision, tracks.size())) @@ -1645,45 +1683,45 @@ struct FlowSP { // https://twiki.cern.ch/twiki/pub/ALICE/DirectedFlowAnalysisNote/vn_ZDC_ALICE_INT_NOTE_version02.pdf spm.psiFull = 1.0 * std::atan2(spm.qyA + spm.qyC, spm.qxA + spm.qxC); - if (spm.centrality > cfgCentMax || spm.centrality < cfgCentMin) + if (spm.centrality > cfg.cCentMax || spm.centrality < cfg.cCentMin) return; // Load correlations and SP resolution needed for Scalar Product and event plane methods. // Only load once! // If not loaded set to 1 - if (cfgCCDBdir_QQ.value.empty() == false) { - if (!cfg.clQQ) { - TList* hcorrList = ccdb->getForTimeStamp(cfgCCDBdir_QQ.value, bc.timestamp()); - cfg.hcorrQQ = reinterpret_cast(hcorrList->FindObject("qAqCXY")); - cfg.hcorrQQx = reinterpret_cast(hcorrList->FindObject("qAqCX")); - cfg.hcorrQQy = reinterpret_cast(hcorrList->FindObject("qAqCY")); - cfg.clQQ = true; + if (cfg.cCCDBdir_QQ.value.empty() == false) { + if (!conf.clQQ) { + TList* hcorrList = ccdb->getForTimeStamp(cfg.cCCDBdir_QQ.value, bc.timestamp()); + conf.hcorrQQ = reinterpret_cast(hcorrList->FindObject("qAqCXY")); + conf.hcorrQQx = reinterpret_cast(hcorrList->FindObject("qAqCX")); + conf.hcorrQQy = reinterpret_cast(hcorrList->FindObject("qAqCY")); + conf.clQQ = true; } - spm.corrQQ = cfg.hcorrQQ->GetBinContent(cfg.hcorrQQ->FindBin(spm.centrality)); - spm.corrQQx = cfg.hcorrQQx->GetBinContent(cfg.hcorrQQx->FindBin(spm.centrality)); - spm.corrQQy = cfg.hcorrQQy->GetBinContent(cfg.hcorrQQy->FindBin(spm.centrality)); + spm.corrQQ = conf.hcorrQQ->GetBinContent(conf.hcorrQQ->FindBin(spm.centrality)); + spm.corrQQx = conf.hcorrQQx->GetBinContent(conf.hcorrQQx->FindBin(spm.centrality)); + spm.corrQQy = conf.hcorrQQy->GetBinContent(conf.hcorrQQy->FindBin(spm.centrality)); } double evPlaneRes = 1.; - if (cfgCCDBdir_SP.value.empty() == false) { - if (!cfg.clEvPlaneRes) { - cfg.hEvPlaneRes = ccdb->getForTimeStamp(cfgCCDBdir_SP.value, bc.timestamp()); - cfg.clEvPlaneRes = true; + if (cfg.cCCDBdir_SP.value.empty() == false) { + if (!conf.clEvPlaneRes) { + conf.hEvPlaneRes = ccdb->getForTimeStamp(cfg.cCCDBdir_SP.value, bc.timestamp()); + conf.clEvPlaneRes = true; } - evPlaneRes = cfg.hEvPlaneRes->GetBinContent(cfg.hEvPlaneRes->FindBin(spm.centrality)); + evPlaneRes = conf.hEvPlaneRes->GetBinContent(conf.hEvPlaneRes->FindBin(spm.centrality)); if (evPlaneRes < 0) LOGF(fatal, " > 0 for centrality %.2f! Cannot determine resolution.. Change centrality ranges!!!", spm.centrality); evPlaneRes = std::sqrt(evPlaneRes); } spm.centWeight = 1.; - if (cfgCCDBdir_centrality.value.empty() == false) { - if (!cfg.clCentrality) { - cfg.hCentrality = ccdb->getForTimeStamp(cfgCCDBdir_centrality.value, bc.timestamp()); - cfg.clCentrality = true; + if (cfg.cCCDBdir_centrality.value.empty() == false) { + if (!conf.clCentrality) { + conf.hCentrality = ccdb->getForTimeStamp(cfg.cCCDBdir_centrality.value, bc.timestamp()); + conf.clCentrality = true; } - double centW = cfg.hCentrality->GetBinContent(cfg.hCentrality->FindBin(spm.centrality)); + double centW = conf.hCentrality->GetBinContent(conf.hCentrality->FindBin(spm.centrality)); if (centW < 0) { spm.centWeight = 1. / centW; } else { @@ -1696,7 +1734,7 @@ struct FlowSP { for (const auto& track : tracks) { - ParticleType trackPID = (cfgFillPID || cfgFillPIDQA) ? getTrackPID(track) : kUnidentified; + ParticleType trackPID = (cfg.cFillPID || cfg.cFillPIDQA) ? getTrackPID(track) : kUnidentified; histos.fill(HIST("hPIDcounts"), trackPID, track.pt()); @@ -1707,7 +1745,7 @@ struct FlowSP { spm.charge = ((track.sign() > 0)) ? kPositive : kNegative; - if (cfgFillQABefore) { + if (cfg.cFillQABefore) { switch (trackPID) { case kPions: fillAllQA(track); @@ -1744,16 +1782,16 @@ struct FlowSP { } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - spm.ux = std::cos(cfgHarm * phi); - spm.uy = std::sin(cfgHarm * phi); + spm.ux = std::cos(cfg.cHarm * phi); + spm.uy = std::sin(cfg.cHarm * phi); - spm.uxMH = std::cos(cfgHarmMixed * phi); - spm.uyMH = std::sin(cfgHarmMixed * phi); + spm.uxMH = std::cos(cfg.cHarmMixed * phi); + spm.uyMH = std::sin(cfg.cHarmMixed * phi); // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - spm.vnA = std::cos(cfgHarm * (phi - spm.psiA)) / evPlaneRes; - spm.vnC = std::cos(cfgHarm * (phi - spm.psiC)) / evPlaneRes; - spm.vnFull = std::cos(cfgHarm * (phi - spm.psiFull)) / evPlaneRes; + spm.vnA = std::cos(cfg.cHarm * (phi - spm.psiA)) / evPlaneRes; + spm.vnC = std::cos(cfg.cHarm * (phi - spm.psiC)) / evPlaneRes; + spm.vnFull = std::cos(cfg.cHarm * (phi - spm.psiFull)) / evPlaneRes; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -1773,7 +1811,7 @@ struct FlowSP { break; } - if (cfgFillChargeDependence) { + if (cfg.cFillChargeDependence) { switch (spm.charge) { case kPositive: { switch (trackPID) { @@ -1818,26 +1856,26 @@ struct FlowSP { { auto bc = collision.template bc_as(); int standardMagField = 99999; - auto field = (cfgMagField == standardMagField) ? getMagneticField(bc.timestamp()) : cfgMagField; + auto field = (cfg.cMagField == standardMagField) ? getMagneticField(bc.timestamp()) : cfg.cMagField; spm.vz = collision.posZ(); spm.centrality = collision.centFT0C(); - if (cfgCentFT0Cvariant1) + if (cfg.cCentFT0Cvariant1) spm.centrality = collision.centFT0CVariant1(); - if (cfgCentFT0M) + if (cfg.cCentFT0M) spm.centrality = collision.centFT0M(); - if (cfgCentFV0A) + if (cfg.cCentFV0A) spm.centrality = collision.centFV0A(); - if (cfgCentNGlobal) + if (cfg.cCentNGlobal) spm.centrality = collision.centNGlobal(); - if (cfgFillQABefore) + if (cfg.cFillQABefore) fillEventQA(collision, filteredTracks); if (!eventSelected(collision, filteredTracks.size())) return; - if (spm.centrality > cfgCentMax || spm.centrality < cfgCentMin) + if (spm.centrality > cfg.cCentMax || spm.centrality < cfg.cCentMin) return; histos.fill(HIST("hEventCount"), evSel_CentCuts); @@ -1853,28 +1891,33 @@ struct FlowSP { registry.fill(HIST("trackMCReco/hTrackSize_Filtered"), filteredTracks.size(), spm.centrality); for (const auto& track : filteredTracks) { + + if (!track.has_mcParticle()) + continue; + auto mcParticle = track.mcParticle(); + if (track.sign() == 0.0) continue; histos.fill(HIST("hTrackCount"), trackSel_ZeroCharge); - fillMCPtHistos(track, mcParticle.pdgCode()); - fillPrimaryHistos(mcParticle); - - if (!mcParticle.isPhysicalPrimary()) - continue; + if(cfg.cFillWithMCParticle){ + fillMCPtHistos(mcParticle, mcParticle.pdgCode()); + } else { + fillMCPtHistos(track, mcParticle.pdgCode()); + } spm.charge = (track.sign() > 0) ? kPositive : kNegative; int minVal = 100; - if (cfgFilterLeptons && std::abs(mcParticle.pdgCode()) < minVal) { + if (cfg.cFilterLeptons && std::abs(mcParticle.pdgCode()) < minVal) { continue; } // This neglects PID (for now) later use getPID like in data. - if (cfgFillQABefore) { + if (cfg.cFillQABefore) { fillAllQA(track); - if (cfgFillPIDQA) { + if (cfg.cFillPIDQA) { switch (std::abs(mcParticle.pdgCode())) { case kPiPlus: fillAllQA(track); @@ -1889,14 +1932,34 @@ struct FlowSP { } } + fillPrimaryHistos(mcParticle); + if(spm.charge == kPositive){ + fillPrimaryHistos(mcParticle); + } else { + fillPrimaryHistos(mcParticle); + } + if (!trackSelected(track, field)) continue; - fillMCPtHistos(track, mcParticle.pdgCode()); + fillPrimaryHistos(mcParticle); + if(spm.charge == kPositive){ + fillPrimaryHistos(mcParticle); + } else { + fillPrimaryHistos(mcParticle); + } + if (!mcParticle.isPhysicalPrimary()) + continue; + + if(cfg.cFillWithMCParticle){ + fillMCPtHistos(mcParticle, mcParticle.pdgCode()); + } else { + fillMCPtHistos(track, mcParticle.pdgCode()); + } fillAllQA(track); - if (cfgFillPIDQA) { + if (cfg.cFillPIDQA) { switch (std::abs(mcParticle.pdgCode())) { case kPions: fillAllQA(track); @@ -1910,7 +1973,7 @@ struct FlowSP { } } - fillPrimaryHistos(mcParticle); + } // end of track loop } @@ -1940,16 +2003,16 @@ struct FlowSP { auto filteredTrackSlice = filteredTracks.sliceBy(trackPerCollision, col.globalIndex()); spm.centrality = col.centFT0C(); - if (cfgCentFT0Cvariant1) + if (cfg.cCentFT0Cvariant1) spm.centrality = col.centFT0CVariant1(); - if (cfgCentFT0M) + if (cfg.cCentFT0M) spm.centrality = col.centFT0M(); - if (cfgCentFV0A) + if (cfg.cCentFV0A) spm.centrality = col.centFV0A(); - if (cfgCentNGlobal) + if (cfg.cCentNGlobal) spm.centrality = col.centNGlobal(); - if (cfgFillQABefore) + if (cfg.cFillQABefore) fillEventQA(col, filteredTrackSlice); if (trackSlice.size() < 1) { @@ -1961,7 +2024,7 @@ struct FlowSP { continue; } - if (spm.centrality > cfgCentMax || spm.centrality < cfgCentMin) { + if (spm.centrality > cfg.cCentMax || spm.centrality < cfg.cCentMin) { colSelected = false; continue; } @@ -1989,7 +2052,7 @@ struct FlowSP { spm.charge = (pdgInfo->Charge() > 0) ? kPositive : kNegative; int minVal = 100; - if (cfgFilterLeptons && std::abs(pdgCode) < minVal) { + if (cfg.cFilterLeptons && std::abs(pdgCode) < minVal) { continue; } @@ -2003,7 +2066,7 @@ struct FlowSP { registry.fill(HIST("trackMCGen/before/neg/phi_eta_vtxZ_gen"), particle.phi(), particle.eta(), vtxz); } - if (particle.eta() < -cfgTrackSelsEta || particle.eta() > cfgTrackSelsEta || particle.pt() < cfgTrackSelsPtmin || particle.pt() > cfgTrackSelsPtmax) + if (particle.eta() < -cfg.cTrackSelsEta || particle.eta() > cfg.cTrackSelsEta || particle.pt() < cfg.cTrackSelsPtmin || particle.pt() > cfg.cTrackSelsPtmax) continue; fillMCPtHistos(particle, pdgCode); From 3a268826e59f114914f34f19f77d6bcb8e46a8a4 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Wed, 6 May 2026 15:03:49 +0000 Subject: [PATCH 2/2] Please consider the following formatting changes --- PWGCF/Flow/Tasks/flowSP.cxx | 27 ++++++++++++--------------- 1 file changed, 12 insertions(+), 15 deletions(-) diff --git a/PWGCF/Flow/Tasks/flowSP.cxx b/PWGCF/Flow/Tasks/flowSP.cxx index e49b5ac84a9..37b48ee0f50 100644 --- a/PWGCF/Flow/Tasks/flowSP.cxx +++ b/PWGCF/Flow/Tasks/flowSP.cxx @@ -73,7 +73,7 @@ using namespace o2::aod::rctsel; #define O2_DEFINE_CONFIGURABLE(NAME, TYPE, DEFAULT, HELP) Configurable NAME{#NAME, DEFAULT, HELP}; struct FlowSP { - + // event selection configurable group struct : ConfigurableGroup { O2_DEFINE_CONFIGURABLE(cEvtUseRCTFlagChecker, bool, false, "Evt sel: use RCT flag checker"); @@ -159,7 +159,7 @@ struct FlowSP { O2_DEFINE_CONFIGURABLE(cCCDBdir_centrality, std::string, "", "ccdb dir for Centrality corrections"); O2_DEFINE_CONFIGURABLE(cCCDBdir_meanPt, std::string, "", "ccdb dir for Mean Pt corrections"); - // Confogirable axis + // Confogirable axis // ConfigurableAxis axisCentrality{"axisCentrality", {20, 0, 100}, "Centrality bins for vn "}; // ConfigurableAxis axisMomentum{"axisMomentum", {20, 0, 10}, "Momentum bins for vn"}; // ConfigurableAxis axisEtaVn{"axisEtaVn", {8, -0.8, 0.8}, "Eta bins for vn"}; @@ -169,12 +169,12 @@ struct FlowSP { Configurable> cEvSelsMult{"cEvSelsMult", std::vector{1301.56, -41.4615, 0.478224, -0.00239449, 4.46966e-06, 2967.6, -102.927, 1.47488, -0.0106534, 3.28622e-05}, "Multiplicity cuts (Global) first 5 parameters cutLOW last 5 cutHIGH (Default is +-2sigma pass5) "}; Configurable> cPtBinning{"cPtBinning", std::vector{0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2, 2.2, 2.4, 2.6, 2.8, 3, 3.5, 4, 5, 6, 8, 10}, "pT binning for vn"}; - } cfg; + } cfg; RCTFlagsChecker rctChecker; Filter collisionFilter = nabs(aod::collision::posZ) < cfg.cEvSelsVtxZ; - Filter trackFilter = nabs(aod::track::eta) < cfg.cTrackSelsEta && aod::track::pt > cfg.cTrackSelsPtmin&& aod::track::pt < cfg.cTrackSelsPtmax && ((requireGlobalTrackInFilter()) || (aod::track::isGlobalTrackSDD == (uint8_t) true) || cfg.cIsMCReco) && nabs(aod::track::dcaXY) < cfg.cTrackSelsDCAxy && nabs(aod::track::dcaZ) < cfg.cTrackSelsDCAz; + Filter trackFilter = nabs(aod::track::eta) < cfg.cTrackSelsEta && aod::track::pt > cfg.cTrackSelsPtmin&& aod::track::pt < cfg.cTrackSelsPtmax && ((requireGlobalTrackInFilter()) || (aod::track::isGlobalTrackSDD == (uint8_t)true) || cfg.cIsMCReco) && nabs(aod::track::dcaXY) < cfg.cTrackSelsDCAxy&& nabs(aod::track::dcaZ) < cfg.cTrackSelsDCAz; Filter trackFilterMC = nabs(aod::mcparticle::eta) < cfg.cTrackSelsEta && aod::mcparticle::pt > cfg.cTrackSelsPtmin&& aod::mcparticle::pt < cfg.cTrackSelsPtmax; using GeneralCollisions = soa::Join; using UnfilteredTracksPID = soa::Join; @@ -355,7 +355,7 @@ struct FlowSP { AxisSpec axisPhi = {60, 0, constants::math::TwoPI, "#varphi"}; AxisSpec axisEta = {64, -1.6, 1.6, "#eta"}; AxisSpec axisEtaVn = {8, -.8, .8, "#eta"}; - AxisSpec axisCentrality = {20,0,100, "Centrality (%)"}; + AxisSpec axisCentrality = {20, 0, 100, "Centrality (%)"}; AxisSpec axisVx = {40, -0.01, 0.01, "v_{x}"}; AxisSpec axisVy = {40, -0.01, 0.01, "v_{y}"}; AxisSpec axisVz = {40, -10, 10, "v_{z}"}; @@ -1143,7 +1143,7 @@ struct FlowSP { if (cfg.cFillGeneralV1Histos) { registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnAodd"), track.pt(), track.eta(), spm.centrality, scale * (spm.uy * spm.qyA + spm.ux * spm.qxA) / std::sqrt(std::fabs(spm.corrQQ)), weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnCodd"), track.pt(), track.eta(), spm.centrality, scale * (spm.uy * spm.qyC + spm.ux * spm.qxC) / std::sqrt(std::fabs(spm.corrQQ)), weight); - registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnOdd"), track.pt(), track.eta(), spm.centrality, scale *0.5 * ((spm.uy * spm.qyA + spm.ux * spm.qxA) - (spm.uy * spm.qyC + spm.ux * spm.qxC)) / std::sqrt(std::fabs(spm.corrQQ)), weight); + registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnOdd"), track.pt(), track.eta(), spm.centrality, scale * 0.5 * ((spm.uy * spm.qyA + spm.ux * spm.qxA) - (spm.uy * spm.qyC + spm.ux * spm.qxC)) / std::sqrt(std::fabs(spm.corrQQ)), weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnEven"), track.pt(), track.eta(), spm.centrality, 0.5 * ((spm.uy * spm.qyA + spm.ux * spm.qxA) + (spm.uy * spm.qyC + spm.ux * spm.qxC)) / std::sqrt(std::fabs(spm.corrQQ)), weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnA"), track.pt(), track.eta(), spm.centrality, (spm.uy * spm.qyA + spm.ux * spm.qxA) / std::sqrt(std::fabs(spm.corrQQ)), weight); registry.fill(HIST(Charge[ct]) + HIST(Species[pt]) + HIST("vnC"), track.pt(), track.eta(), spm.centrality, (spm.uy * spm.qyC + spm.ux * spm.qxC) / std::sqrt(std::fabs(spm.corrQQ)), weight); @@ -1458,7 +1458,6 @@ struct FlowSP { if (track.sign() == 0) continue; - histos.fill(HIST("hTrackCount"), trackSel_ZeroCharge); spm.charge = ((track.sign() > 0)) ? kPositive : kNegative; @@ -1901,7 +1900,7 @@ struct FlowSP { continue; histos.fill(HIST("hTrackCount"), trackSel_ZeroCharge); - if(cfg.cFillWithMCParticle){ + if (cfg.cFillWithMCParticle) { fillMCPtHistos(mcParticle, mcParticle.pdgCode()); } else { fillMCPtHistos(track, mcParticle.pdgCode()); @@ -1933,7 +1932,7 @@ struct FlowSP { } fillPrimaryHistos(mcParticle); - if(spm.charge == kPositive){ + if (spm.charge == kPositive) { fillPrimaryHistos(mcParticle); } else { fillPrimaryHistos(mcParticle); @@ -1942,16 +1941,16 @@ struct FlowSP { if (!trackSelected(track, field)) continue; - fillPrimaryHistos(mcParticle); - if(spm.charge == kPositive){ + fillPrimaryHistos(mcParticle); + if (spm.charge == kPositive) { fillPrimaryHistos(mcParticle); } else { fillPrimaryHistos(mcParticle); } if (!mcParticle.isPhysicalPrimary()) - continue; + continue; - if(cfg.cFillWithMCParticle){ + if (cfg.cFillWithMCParticle) { fillMCPtHistos(mcParticle, mcParticle.pdgCode()); } else { fillMCPtHistos(track, mcParticle.pdgCode()); @@ -1973,8 +1972,6 @@ struct FlowSP { } } - - } // end of track loop } PROCESS_SWITCH(FlowSP, processMCReco, "Process analysis for MC reconstructed events", false);