From 16f48d6321282d12420071ab89547c2e57aacb4d Mon Sep 17 00:00:00 2001 From: fsii Date: Wed, 12 Nov 2025 17:02:30 +0100 Subject: [PATCH] Update: PWGCF/EbyEFluctuations/Tasks/PartNumFluc.cxx --- PWGCF/EbyEFluctuations/Tasks/partNumFluc.cxx | 1655 ++++++++++-------- 1 file changed, 935 insertions(+), 720 deletions(-) diff --git a/PWGCF/EbyEFluctuations/Tasks/partNumFluc.cxx b/PWGCF/EbyEFluctuations/Tasks/partNumFluc.cxx index 481c16388a7..80b033234d7 100644 --- a/PWGCF/EbyEFluctuations/Tasks/partNumFluc.cxx +++ b/PWGCF/EbyEFluctuations/Tasks/partNumFluc.cxx @@ -442,19 +442,44 @@ class FluctuationCalculatorTrack std::array mQs; }; -struct QuantityHolderEvent { +struct HolderCcdb { + std::vector runNumbers; + std::vector runNumbersBad; + + std::vector pCentralityPtEtaEfficiencyTpcPiP; + std::vector pCentralityPtEtaEfficiencyTpcPiM; + std::vector pCentralityPtEtaEfficiencyTpcKaP; + std::vector pCentralityPtEtaEfficiencyTpcKaM; + std::vector pCentralityPtEtaEfficiencyTpcPrP; + std::vector pCentralityPtEtaEfficiencyTpcPrM; + std::vector pCentralityPtEtaEfficiencyTpcTofPiP; + std::vector pCentralityPtEtaEfficiencyTpcTofPiM; + std::vector pCentralityPtEtaEfficiencyTpcTofKaP; + std::vector pCentralityPtEtaEfficiencyTpcTofKaM; + std::vector pCentralityPtEtaEfficiencyTpcTofPrP; + std::vector pCentralityPtEtaEfficiencyTpcTofPrM; +}; + +struct HolderEvent { std::int32_t runNumber = 0; std::int32_t runIndex = 0; + double vz = 0.; + std::int32_t vzBinIndex = 0; std::int32_t nGlobalTracks = 0; std::int32_t nPvContributors = 0; - std::int32_t nTofBeta = 0; double meanDcaXy = 0.; double meanSquareDcaXy = 0.; double meanDcaZ = 0.; double meanSquareDcaZ = 0.; - double vz = 0.; + std::int32_t nTofBeta = 0; double centrality = 0.; std::int32_t subgroupIndex = 0; + std::int32_t nChPGenerated = 0; + std::int32_t nChMGenerated = 0; + std::int32_t nKaPGenerated = 0; + std::int32_t nKaMGenerated = 0; + std::int32_t nPrPGenerated = 0; + std::int32_t nPrMGenerated = 0; std::int32_t nChP = 0; std::int32_t nChM = 0; std::int32_t nKaP = 0; @@ -476,9 +501,31 @@ struct QuantityHolderEvent { void clear() { - runNumber = runIndex = nGlobalTracks = nPvContributors = nTofBeta = 0; - meanDcaXy = meanSquareDcaXy = meanDcaZ = meanSquareDcaZ = vz = centrality = 0.; - subgroupIndex = nChP = nChM = nKaP = nKaM = nPrP = nPrM = 0; + runNumber = 0; + runIndex = 0; + vz = 0.; + vzBinIndex = 0; + nGlobalTracks = 0; + nPvContributors = 0; + meanDcaXy = 0.; + meanSquareDcaXy = 0.; + meanDcaZ = 0.; + meanSquareDcaZ = 0.; + nTofBeta = 0; + centrality = 0.; + subgroupIndex = 0; + nChPGenerated = 0; + nChMGenerated = 0; + nKaPGenerated = 0; + nKaMGenerated = 0; + nPrPGenerated = 0; + nPrMGenerated = 0; + nChP = 0; + nChM = 0; + nKaP = 0; + nKaM = 0; + nPrP = 0; + nPrM = 0; mcParticleIndicesMatchedTpcPiP.clear(); mcParticleIndicesMatchedTpcPiM.clear(); mcParticleIndicesMatchedTpcKaP.clear(); @@ -494,7 +541,7 @@ struct QuantityHolderEvent { } }; -struct QuantityHolderTrack { +struct HolderTrack { static constexpr double TruncationAbsNSigmaPid = 999.; static constexpr double truncateNSigmaPid(const double value) { return (!(std::abs(value) < TruncationAbsNSigmaPid) ? -TruncationAbsNSigmaPid : value); } @@ -523,16 +570,30 @@ struct QuantityHolderTrack { void clear() { sign = 0; - pt = eta = phi = ptOverQ = pOverQ = rapidityPi = rapidityKa = rapidityPr = 0.; + pt = 0.; + eta = 0.; + phi = 0.; + ptOverQ = 0.; + pOverQ = 0.; + rapidityPi = 0.; + rapidityKa = 0.; + rapidityPr = 0.; hasTpcPid = false; - tpcNSigmaPi = tpcNSigmaKa = tpcNSigmaPr = 0.; + tpcNSigmaPi = 0.; + tpcNSigmaKa = 0.; + tpcNSigmaPr = 0.; hasTofPid = false; - tofNSigmaPi = tofNSigmaKa = tofNSigmaPr = tpcTofNSigmaPi = tpcTofNSigmaKa = tpcTofNSigmaPr = 0.; + tofNSigmaPi = 0.; + tofNSigmaKa = 0.; + tofNSigmaPr = 0.; + tpcTofNSigmaPi = 0.; + tpcTofNSigmaKa = 0.; + tpcTofNSigmaPr = 0.; mcParticleId = 0; } }; -struct QuantityHolderMcParticle { +struct HolderMcParticle { std::int32_t globalIndex = 0; std::int32_t pdgCode = 0; double pt = 0.; @@ -540,12 +601,20 @@ struct QuantityHolderMcParticle { void clear() { - globalIndex = pdgCode = 0; - pt = eta = 0.; + globalIndex = 0; + pdgCode = 0; + pt = 0.; + eta = 0.; } }; struct PartNumFluc { + enum class CentralityDefinitionIndices { kFV0A = 0, + kFT0M, + kFT0A, + kFT0C, + kNIndices }; + Configurable cfgCcdbPath{"cfgCcdbPath", "Users/f/fasi/test", "Path in CCDB"}; Configurable cfgFlagQaRun{"cfgFlagQaRun", false, "Run QA flag"}; @@ -554,19 +623,21 @@ struct PartNumFluc { Configurable cfgFlagQaTrack{"cfgFlagQaTrack", false, "Track QA flag"}; Configurable cfgFlagQaAcceptance{"cfgFlagQaAcceptance", false, "Acceptance QA flag"}; Configurable cfgFlagQaPid{"cfgFlagQaPid", false, "PID QA flag"}; - Configurable cfgFlagAnalysisFluctuationCh{"cfgFlagAnalysisFluctuationCh", false, "Charge number fLuctuation analysis flag"}; - Configurable cfgFlagAnalysisFluctuationKa{"cfgFlagAnalysisFluctuationKa", false, "Kaon number fLuctuation analysis flag"}; - Configurable cfgFlagAnalysisFluctuationPr{"cfgFlagAnalysisFluctuationPr", false, "(Anti)proton number fLuctuation analysis flag"}; Configurable cfgFlagCalculationPurityPi{"cfgFlagCalculationPurityPi", false, "Pion purity calculation flag"}; Configurable cfgFlagCalculationPurityKa{"cfgFlagCalculationPurityKa", false, "Kaon purity calculation flag"}; Configurable cfgFlagCalculationPurityPr{"cfgFlagCalculationPurityPr", false, "(Anti)proton purity calculation flag"}; Configurable cfgFlagCalculationEfficiencyPi{"cfgFlagCalculationEfficiencyPi", false, "Pion efficiency calculation flag"}; Configurable cfgFlagCalculationEfficiencyKa{"cfgFlagCalculationEfficiencyKa", false, "Kaon efficiency calculation flag"}; Configurable cfgFlagCalculationEfficiencyPr{"cfgFlagCalculationEfficiencyPr", false, "(Anti)proton efficiency calculation flag"}; + Configurable cfgFlagCalculationFluctuationCh{"cfgFlagCalculationFluctuationCh", false, "Charge number fluctuation calculation flag"}; + Configurable cfgFlagCalculationFluctuationKa{"cfgFlagCalculationFluctuationKa", false, "Kaon number fluctuation calculation flag"}; + Configurable cfgFlagCalculationFluctuationPr{"cfgFlagCalculationFluctuationPr", false, "(Anti)proton number fluctuation calculation flag"}; + Configurable cfgFlagRejectionRunBad{"cfgFlagRejectionRunBad", true, "Bad run rejection flag"}; Configurable cfgFlagSelectionEvent{"cfgFlagSelectionEvent", 0b00000000001111110100000000000000000000000000000000ULL, "Event selection flag"}; Configurable cfgCutMaxAbsVertexZ{"cfgCutMaxAbsVertexZ", 6., "Maximum absolute vertex z position (cm)"}; - Configurable cfgCutMinNPvContributorsDeviation{"cfgCutMinNPvContributorsDeviation", -4, "Minimum nPvContributors deviation from nGlobalTracks"}; + Configurable cfgCutMinDeviationNPvContributors{"cfgCutMinDeviationNPvContributors", -4, "Minimum nPvContributors deviation from nGlobalTracks"}; + Configurable cfgIndexDefinitionCentrality{"cfgIndexDefinitionCentrality", 1, "Centrality definition index"}; Configurable cfgFlagPvContributor{"cfgFlagPvContributor", true, "Flag of requiring PV contributor"}; Configurable cfgCutMinItsNCls{"cfgCutMinItsNCls", 5, "Minimum number of clusters ITS"}; @@ -587,30 +658,28 @@ struct PartNumFluc { Configurable cfgThresholdPtTofPr{"cfgThresholdPtTofPr", 0.8, "pT (GeV/c) threshold for TOF (anti)protons"}; Configurable cfgCutMaxAbsNSigmaPid{"cfgCutMaxAbsNSigmaPid", 2., "Maximum absolute nSigma for PID"}; // 1.5, 2.5 - Configurable cfgNCentralityBins{"cfgNCentralityBins", 20, "Number of centrality bins in fluctuation analysis"}; - Configurable cfgNSubgroups{"cfgNSubgroups", 20, "Number of subgroups in fluctuation analysis"}; + Configurable cfgNCentralityBins{"cfgNCentralityBins", 20, "Number of centrality bins in fluctuation calculation"}; + Configurable cfgNSubgroups{"cfgNSubgroups", 20, "Number of subgroups in fluctuation calculation"}; Service ccdb; - std::vector runNumbers; - std::vector runNumbersBad; - - const TProfile3D* pVzPtEtaEfficiencyTpcPiP = nullptr; - const TProfile3D* pVzPtEtaEfficiencyTpcPiM = nullptr; - const TProfile3D* pVzPtEtaEfficiencyTpcKaP = nullptr; - const TProfile3D* pVzPtEtaEfficiencyTpcKaM = nullptr; - const TProfile3D* pVzPtEtaEfficiencyTpcPrP = nullptr; - const TProfile3D* pVzPtEtaEfficiencyTpcPrM = nullptr; - const TProfile3D* pVzPtEtaEfficiencyTpcTofPiP = nullptr; - const TProfile3D* pVzPtEtaEfficiencyTpcTofPiM = nullptr; - const TProfile3D* pVzPtEtaEfficiencyTpcTofKaP = nullptr; - const TProfile3D* pVzPtEtaEfficiencyTpcTofKaM = nullptr; - const TProfile3D* pVzPtEtaEfficiencyTpcTofPrP = nullptr; - const TProfile3D* pVzPtEtaEfficiencyTpcTofPrM = nullptr; - - QuantityHolderEvent quantityHolderEvent; - QuantityHolderTrack quantityHolderTrack; - QuantityHolderMcParticle quantityHolderMcParticle; + HolderCcdb holderCcdb; + HolderEvent holderEvent; + HolderTrack holderTrack; + HolderMcParticle holderMcParticle; + + std::vector> pCentralityPtEtaEfficiencyTpcPiP; + std::vector> pCentralityPtEtaEfficiencyTpcPiM; + std::vector> pCentralityPtEtaEfficiencyTpcKaP; + std::vector> pCentralityPtEtaEfficiencyTpcKaM; + std::vector> pCentralityPtEtaEfficiencyTpcPrP; + std::vector> pCentralityPtEtaEfficiencyTpcPrM; + std::vector> pCentralityPtEtaEfficiencyTpcTofPiP; + std::vector> pCentralityPtEtaEfficiencyTpcTofPiM; + std::vector> pCentralityPtEtaEfficiencyTpcTofKaP; + std::vector> pCentralityPtEtaEfficiencyTpcTofKaM; + std::vector> pCentralityPtEtaEfficiencyTpcTofPrP; + std::vector> pCentralityPtEtaEfficiencyTpcTofPrM; std::unique_ptr fluctuationCalculatorTrackChP; std::unique_ptr fluctuationCalculatorTrackChM; @@ -625,9 +694,9 @@ struct PartNumFluc { std::unique_ptr fluctuationCalculatorTrackPrT; std::unique_ptr fluctuationCalculatorTrackPrN; + HistogramRegistry hrCalculationFluctuation{"hrCalculationFluctuation", {}, OutputObjHandlingPolicy::AnalysisObject}; HistogramRegistry hrCalculationEfficiency{"hrCalculationEfficiency", {}, OutputObjHandlingPolicy::AnalysisObject}; HistogramRegistry hrCalculationPurity{"hrCalculationPurity", {}, OutputObjHandlingPolicy::AnalysisObject}; - HistogramRegistry hrAnalysisFluctuation{"hrAnalysisFluctuation", {}, OutputObjHandlingPolicy::AnalysisObject}; HistogramRegistry hrQaAcceptance{"hrQaAcceptance", {}, OutputObjHandlingPolicy::AnalysisObject}; HistogramRegistry hrQaPid{"hrQaPid", {}, OutputObjHandlingPolicy::AnalysisObject}; HistogramRegistry hrQaTrack{"hrQaTrack", {}, OutputObjHandlingPolicy::AnalysisObject}; @@ -642,8 +711,122 @@ struct PartNumFluc { Preslice presliceTracksPerCollision = aod::track::collisionId; + template + void initCalculationFluctuation(const TList* const ccdbObject) + { + HistogramConfigSpec hcsCalculationFluctuation(HistType::kTH3F, {{cfgNCentralityBins.value, 0., 100., "Centrality (%)"}, {50, -0.5, 49.5}, {50, -0.5, 49.5}}); + HistogramConfigSpec hcsFluctuationCalculator(HistType::kTH3D, {{cfgNCentralityBins.value, 0., 100., "Centrality (%)"}, {cfgNSubgroups.value, -0.5, cfgNSubgroups.value - 0.5, "Subgroup Index"}, {fluctuation_calculator_base::NOrderVectors, -0.5, fluctuation_calculator_base::NOrderVectors - 0.5, "Order Vector Index"}}); + + if (cfgFlagCalculationFluctuationCh.value) { + holderCcdb.pCentralityPtEtaEfficiencyTpcPiP.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + holderCcdb.pCentralityPtEtaEfficiencyTpcPiM.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + holderCcdb.pCentralityPtEtaEfficiencyTpcTofPiP.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + holderCcdb.pCentralityPtEtaEfficiencyTpcTofPiM.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + for (std::int32_t const& iVzBin : std::views::iota(0, static_cast(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2))) { + holderCcdb.pCentralityPtEtaEfficiencyTpcPiP[iVzBin] = static_cast(ccdbObject->FindObject(Form("pCentralityPtEtaEfficiencyTpcPiP_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1))); + assert(holderCcdb.pCentralityPtEtaEfficiencyTpcPiP[iVzBin] && holderCcdb.pCentralityPtEtaEfficiencyTpcPiP[iVzBin]->IsA() == TProfile3D::Class()); + holderCcdb.pCentralityPtEtaEfficiencyTpcPiM[iVzBin] = static_cast(ccdbObject->FindObject(Form("pCentralityPtEtaEfficiencyTpcPiM_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1))); + assert(holderCcdb.pCentralityPtEtaEfficiencyTpcPiM[iVzBin] && holderCcdb.pCentralityPtEtaEfficiencyTpcPiM[iVzBin]->IsA() == TProfile3D::Class()); + holderCcdb.pCentralityPtEtaEfficiencyTpcTofPiP[iVzBin] = static_cast(ccdbObject->FindObject(Form("pCentralityPtEtaEfficiencyTpcTofPiP_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1))); + assert(holderCcdb.pCentralityPtEtaEfficiencyTpcTofPiP[iVzBin] && holderCcdb.pCentralityPtEtaEfficiencyTpcTofPiP[iVzBin]->IsA() == TProfile3D::Class()); + holderCcdb.pCentralityPtEtaEfficiencyTpcTofPiM[iVzBin] = static_cast(ccdbObject->FindObject(Form("pCentralityPtEtaEfficiencyTpcTofPiM_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1))); + assert(holderCcdb.pCentralityPtEtaEfficiencyTpcTofPiM[iVzBin] && holderCcdb.pCentralityPtEtaEfficiencyTpcTofPiM[iVzBin]->IsA() == TProfile3D::Class()); + } + } + + if (cfgFlagCalculationFluctuationCh.value || cfgFlagCalculationFluctuationKa.value) { + holderCcdb.pCentralityPtEtaEfficiencyTpcKaP.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + holderCcdb.pCentralityPtEtaEfficiencyTpcKaM.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaP.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaM.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + for (std::int32_t const& iVzBin : std::views::iota(0, static_cast(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2))) { + holderCcdb.pCentralityPtEtaEfficiencyTpcKaP[iVzBin] = static_cast(ccdbObject->FindObject(Form("pCentralityPtEtaEfficiencyTpcKaP_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1))); + assert(holderCcdb.pCentralityPtEtaEfficiencyTpcKaP[iVzBin] && holderCcdb.pCentralityPtEtaEfficiencyTpcKaP[iVzBin]->IsA() == TProfile3D::Class()); + holderCcdb.pCentralityPtEtaEfficiencyTpcKaM[iVzBin] = static_cast(ccdbObject->FindObject(Form("pCentralityPtEtaEfficiencyTpcKaM_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1))); + assert(holderCcdb.pCentralityPtEtaEfficiencyTpcKaM[iVzBin] && holderCcdb.pCentralityPtEtaEfficiencyTpcKaM[iVzBin]->IsA() == TProfile3D::Class()); + holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaP[iVzBin] = static_cast(ccdbObject->FindObject(Form("pCentralityPtEtaEfficiencyTpcTofKaP_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1))); + assert(holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaP[iVzBin] && holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaP[iVzBin]->IsA() == TProfile3D::Class()); + holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaM[iVzBin] = static_cast(ccdbObject->FindObject(Form("pCentralityPtEtaEfficiencyTpcTofKaM_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1))); + assert(holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaM[iVzBin] && holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaM[iVzBin]->IsA() == TProfile3D::Class()); + } + } + + if (cfgFlagCalculationFluctuationCh.value || cfgFlagCalculationFluctuationPr.value) { + holderCcdb.pCentralityPtEtaEfficiencyTpcPrP.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + holderCcdb.pCentralityPtEtaEfficiencyTpcPrM.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrP.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrM.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + for (std::int32_t const& iVzBin : std::views::iota(0, static_cast(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2))) { + holderCcdb.pCentralityPtEtaEfficiencyTpcPrP[iVzBin] = static_cast(ccdbObject->FindObject(Form("pCentralityPtEtaEfficiencyTpcPrP_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1))); + assert(holderCcdb.pCentralityPtEtaEfficiencyTpcPrP[iVzBin] && holderCcdb.pCentralityPtEtaEfficiencyTpcPrP[iVzBin]->IsA() == TProfile3D::Class()); + holderCcdb.pCentralityPtEtaEfficiencyTpcPrM[iVzBin] = static_cast(ccdbObject->FindObject(Form("pCentralityPtEtaEfficiencyTpcPrM_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1))); + assert(holderCcdb.pCentralityPtEtaEfficiencyTpcPrM[iVzBin] && holderCcdb.pCentralityPtEtaEfficiencyTpcPrM[iVzBin]->IsA() == TProfile3D::Class()); + holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrP[iVzBin] = static_cast(ccdbObject->FindObject(Form("pCentralityPtEtaEfficiencyTpcTofPrP_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1))); + assert(holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrP[iVzBin] && holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrP[iVzBin]->IsA() == TProfile3D::Class()); + holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrM[iVzBin] = static_cast(ccdbObject->FindObject(Form("pCentralityPtEtaEfficiencyTpcTofPrM_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1))); + assert(holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrM[iVzBin] && holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrM[iVzBin]->IsA() == TProfile3D::Class()); + } + } + + if (cfgFlagCalculationFluctuationCh.value) { + LOG(info) << "Enabling charge number fluctuation calculation."; + + fluctuationCalculatorTrackChP = std::make_unique(); + fluctuationCalculatorTrackChM = std::make_unique(); + fluctuationCalculatorTrackChT = std::make_unique(); + fluctuationCalculatorTrackChN = std::make_unique(); + + if constexpr (doProcessingMc) { + hrCalculationFluctuation.add("CalculationFluctuation/hCentralityNChPNChM_generated", ";;No. of h^{+};No. of h^{#minus}", hcsCalculationFluctuation); + } + hrCalculationFluctuation.add("CalculationFluctuation/hCentralityNChPNChM", ";;No. of h^{+};No. of h^{#minus}", hcsCalculationFluctuation); + hrCalculationFluctuation.add("CalculationFluctuation/hFluctuationCalculatorChP", "", hcsFluctuationCalculator); + hrCalculationFluctuation.add("CalculationFluctuation/hFluctuationCalculatorChM", "", hcsFluctuationCalculator); + hrCalculationFluctuation.add("CalculationFluctuation/hFluctuationCalculatorChT", "", hcsFluctuationCalculator); + hrCalculationFluctuation.add("CalculationFluctuation/hFluctuationCalculatorChN", "", hcsFluctuationCalculator); + } + + if (cfgFlagCalculationFluctuationKa.value) { + LOG(info) << "Enabling kaon number fluctuation calculation."; + + fluctuationCalculatorTrackKaP = std::make_unique(); + fluctuationCalculatorTrackKaM = std::make_unique(); + fluctuationCalculatorTrackKaT = std::make_unique(); + fluctuationCalculatorTrackKaN = std::make_unique(); + + if constexpr (doProcessingMc) { + hrCalculationFluctuation.add("CalculationFluctuation/hCentralityNKaPNKaM_generated", ";;No. of K^{+};No. of K^{#minus}", hcsCalculationFluctuation); + } + hrCalculationFluctuation.add("CalculationFluctuation/hCentralityNKaPNKaM", ";;No. of K^{+};No. of K^{#minus}", hcsCalculationFluctuation); + hrCalculationFluctuation.add("CalculationFluctuation/hFluctuationCalculatorKaP", "", hcsFluctuationCalculator); + hrCalculationFluctuation.add("CalculationFluctuation/hFluctuationCalculatorKaM", "", hcsFluctuationCalculator); + hrCalculationFluctuation.add("CalculationFluctuation/hFluctuationCalculatorKaT", "", hcsFluctuationCalculator); + hrCalculationFluctuation.add("CalculationFluctuation/hFluctuationCalculatorKaN", "", hcsFluctuationCalculator); + } + + if (cfgFlagCalculationFluctuationPr.value) { + LOG(info) << "Enabling (anti)proton number fluctuation calculation."; + + fluctuationCalculatorTrackPrP = std::make_unique(); + fluctuationCalculatorTrackPrM = std::make_unique(); + fluctuationCalculatorTrackPrT = std::make_unique(); + fluctuationCalculatorTrackPrN = std::make_unique(); + + if constexpr (doProcessingMc) { + hrCalculationFluctuation.add("CalculationFluctuation/hCentralityNPrPNPrM_generated", ";;No. of p;No. of #bar{p}", hcsCalculationFluctuation); + } + hrCalculationFluctuation.add("CalculationFluctuation/hCentralityNPrPNPrM", ";;No. of p;No. of #bar{p}", hcsCalculationFluctuation); + hrCalculationFluctuation.add("CalculationFluctuation/hFluctuationCalculatorPrP", "", hcsFluctuationCalculator); + hrCalculationFluctuation.add("CalculationFluctuation/hFluctuationCalculatorPrM", "", hcsFluctuationCalculator); + hrCalculationFluctuation.add("CalculationFluctuation/hFluctuationCalculatorPrT", "", hcsFluctuationCalculator); + hrCalculationFluctuation.add("CalculationFluctuation/hFluctuationCalculatorPrN", "", hcsFluctuationCalculator); + } + } + void init(InitContext&) { + gRandom->SetSeed(0); + assert(doprocessRaw ^ doprocessMc); ccdb->setURL("https://alice-ccdb.cern.ch"); @@ -656,22 +839,24 @@ struct PartNumFluc { const TGraph* const gRunNumberIsBad = static_cast(ccdbObject->FindObject("gRunNumberIsBad")); assert(gRunNumberIsBad && gRunNumberIsBad->IsA() == TGraph::Class()); - runNumbers.reserve(gRunNumberIsBad->GetN()); - runNumbersBad.reserve(gRunNumberIsBad->GetN()); + holderCcdb.runNumbers.reserve(gRunNumberIsBad->GetN()); + holderCcdb.runNumbersBad.reserve(gRunNumberIsBad->GetN()); for (std::int32_t const& iRun : std::views::iota(0, gRunNumberIsBad->GetN())) { - runNumbers.push_back(static_cast(std::llrint(gRunNumberIsBad->GetX()[iRun]))); - if (gRunNumberIsBad->GetY()[iRun]) { - runNumbersBad.push_back(static_cast(std::llrint(gRunNumberIsBad->GetX()[iRun]))); + holderCcdb.runNumbers.push_back(static_cast(std::llrint(gRunNumberIsBad->GetX()[iRun]))); + if (cfgFlagRejectionRunBad.value && gRunNumberIsBad->GetY()[iRun]) { + holderCcdb.runNumbersBad.push_back(static_cast(std::llrint(gRunNumberIsBad->GetX()[iRun]))); } } - hrCounter.add("hNEvents", ";;No. of Events", {HistType::kTH1D, {{10 + aod::evsel::kNsel, -0.5, 9.5 + static_cast(aod::evsel::kNsel), "Selection"}}}); + hrCounter.add("hNEvents", ";;No. of Events", {HistType::kTH1D, {{10 + aod::evsel::EventSelectionFlags::kNsel, -0.5, 9.5 + static_cast(aod::evsel::EventSelectionFlags::kNsel), "Selection"}}}); if (doprocessRaw) { + LOG(info) << "Enabling raw data process."; + if (cfgFlagQaRun.value) { LOG(info) << "Enabling run QA."; - HistogramConfigSpec hcsQaRun(HistType::kTProfile, {{static_cast(runNumbers.size()), -0.5, runNumbers.size() - 0.5, "Run Index"}}); + HistogramConfigSpec hcsQaRun(HistType::kTProfile, {{static_cast(holderCcdb.runNumbers.size()), -0.5, holderCcdb.runNumbers.size() - 0.5, "Run Index"}}); hrQaRun.add("QaRun/pRunIndexVx", ";;#LT#it{V}_{#it{x}}#GT (cm)", hcsQaRun); hrQaRun.add("QaRun/pRunIndexVy", ";;#LT#it{V}_{#it{y}}#GT (cm)", hcsQaRun); hrQaRun.add("QaRun/pRunIndexVz", ";;#LT#it{V}_{#it{z}}#GT (cm)", hcsQaRun); @@ -680,11 +865,11 @@ struct PartNumFluc { hrQaRun.add("QaRun/pRunIndexMultFt0c", ";;FT0C #LTMultiplicity#GT", hcsQaRun); hrQaRun.add("QaRun/pRunIndexNGlobalTracks", ";;#LTnGlobalTracks#GT", hcsQaRun); hrQaRun.add("QaRun/pRunIndexNPvContributors", ";;#LTnPvContributors#GT", hcsQaRun); - hrQaRun.add("QaRun/pRunIndexNTofBeta", ";;#LTnTofBeta#GT", hcsQaRun); hrQaRun.add("QaRun/pRunIndexMeanDcaXy", ";;#LT#LTDCA_{#it{xy}}#GT_{event}#GT (cm)", hcsQaRun); hrQaRun.add("QaRun/pRunIndexSigmaDcaXy", ";;#LT#it{#sigma}(DCA_{#it{xy}})_{event}#GT (cm)", hcsQaRun); hrQaRun.add("QaRun/pRunIndexMeanDcaZ", ";;#LT#LTDCA_{#it{z}}#GT_{event}#GT (cm)", hcsQaRun); hrQaRun.add("QaRun/pRunIndexSigmaDcaZ", ";;#LT#it{#sigma}(DCA_{#it{z}})_{event}#GT (cm)", hcsQaRun); + hrQaRun.add("QaRun/pRunIndexNTofBeta", ";;#LTnTofBeta#GT", hcsQaRun); hrQaRun.add("QaRun/pRunIndexItsNCls", ";;ITS #LTnClusters#GT", hcsQaRun); hrQaRun.add("QaRun/pRunIndexItsChi2NCls", ";;ITS #LT#it{#chi}^{2}/nClusters#GT", hcsQaRun); hrQaRun.add("QaRun/pRunIndexTpcNCls", ";;TPC #LTnClusters#GT", hcsQaRun); @@ -710,16 +895,17 @@ struct PartNumFluc { if (cfgFlagQaEvent.value) { LOG(info) << "Enabling event QA."; - AxisSpec asRunIndex(static_cast(runNumbers.size()), -0.5, runNumbers.size() - 0.5, "Run Index"); + AxisSpec asRunIndex(static_cast(holderCcdb.runNumbers.size()), -0.5, holderCcdb.runNumbers.size() - 0.5, "Run Index"); AxisSpec asNGlobalTracks(180, -0.5, 179.5, "nGlobalTracks"); hrQaEvent.add("QaEvent/hRunIndexVxVy", "", {HistType::kTHnSparseF, {asRunIndex, {150, -0.15, 0.15, "#it{V}_{#it{x}} (cm)"}, {150, -0.15, 0.15, "#it{V}_{#it{y}} (cm)"}}}); hrQaEvent.add("QaEvent/hRunIndexVz", "", {HistType::kTH2F, {asRunIndex, {300, -15., 15., "#it{V}_{#it{z}} (cm)"}}}); - hrQaEvent.add("QaEvent/hRunIndexNTofBetaNGlobalTracks", "", {HistType::kTHnSparseF, {asRunIndex, {60, -0.5, 59.5, "nTofBeta"}, asNGlobalTracks}}); hrQaEvent.add("QaEvent/hRunIndexNPvContributorsNGlobalTracks", "", {HistType::kTHnSparseF, {asRunIndex, {180, -0.5, 179.5, "nPvContributors"}, asNGlobalTracks}}); hrQaEvent.add("QaEvent/hRunIndexNGlobalTracksMeanDcaXy", "", {HistType::kTHnSparseF, {asRunIndex, asNGlobalTracks, {200, -0.5, 0.5, "#LTDCA_{#it{xy}}#GT_{event} (cm)"}}}); hrQaEvent.add("QaEvent/hRunIndexNGlobalTracksMeanDcaXy_nPvContributorsCut", "", {HistType::kTHnSparseF, {asRunIndex, asNGlobalTracks, {200, -2., 2., "#LTDCA_{#it{z}}#GT_{event} (cm)"}}}); hrQaEvent.add("QaEvent/hRunIndexNGlobalTracksMeanDcaZ", "", {HistType::kTHnSparseF, {asRunIndex, asNGlobalTracks, {200, -2., 2., "#LTDCA_{#it{z}}#GT_{event} (cm)"}}}); hrQaEvent.add("QaEvent/hRunIndexNGlobalTracksMeanDcaZ_nPvContributorsCut", "", {HistType::kTHnSparseF, {asRunIndex, asNGlobalTracks, {200, -2., 2., "#LTDCA_{#it{z}}#GT_{event} (cm)"}}}); + hrQaEvent.add("QaEvent/hRunIndexNTofBetaNGlobalTracks", "", {HistType::kTHnSparseF, {asRunIndex, {60, -0.5, 59.5, "nTofBeta"}, asNGlobalTracks}}); + hrQaEvent.add("QaEvent/hRunIndexNTofBetaNGlobalTracks_nPvContributorsCut", "", {HistType::kTHnSparseF, {asRunIndex, {60, -0.5, 59.5, "nTofBeta"}, asNGlobalTracks}}); } if (cfgFlagQaCentrality.value) { @@ -768,300 +954,253 @@ struct PartNumFluc { if (cfgFlagQaPid.value) { LOG(info) << "Enabling PID QA."; - AxisSpec asPOverQ(140, -3.5, 3.5, "#it{p}/#it{q} (GeV/#it{c})"); + AxisSpec asQaCentrality(20, 0., 100., "Centrality (%)"); + AxisSpec asPOverQ(350, -3.5, 3.5, "#it{p}/#it{q} (GeV/#it{c})"); AxisSpec asPtOverQ(80, -2., 2., "#it{p}_{T}/#it{q} (GeV/#it{c})"); AxisSpec asEta(48, -1.2, 1.2, "#it{#eta}"); - HistogramConfigSpec hcsQaPid(HistType::kTH3F, {asPtOverQ, asEta, {200, -10., 10.}}); - hrQaPid.add("QaPid/hPOverQEtaTpcLnDeDx", "", {HistType::kTH3F, {asPOverQ, asEta, {240, 3., 9., "TPC ln(d#it{E}/d#it{x} (a.u.))"}}}); - hrQaPid.add("QaPid/hPtOverQEtaTpcNSigmaPi", ";;;TPC #it{n}#it{#sigma}_{#pi}", hcsQaPid); - hrQaPid.add("QaPid/hPtOverQEtaTpcNSigmaPi_tofPi", ";;;TPC #it{n}#it{#sigma}_{#pi}", hcsQaPid); - hrQaPid.add("QaPid/hPtOverQEtaTpcNSigmaKa", ";;;TPC #it{n}#it{#sigma}_{K}", hcsQaPid); - hrQaPid.add("QaPid/hPtOverQEtaTpcNSigmaKa_tofKa", ";;;TPC #it{n}#it{#sigma}_{K}", hcsQaPid); - hrQaPid.add("QaPid/hPtOverQEtaTpcNSigmaPr", ";;;TPC #it{n}#it{#sigma}_{p}", hcsQaPid); - hrQaPid.add("QaPid/hPtOverQEtaTpcNSigmaPr_tofPr", ";;;TPC #it{n}#it{#sigma}_{p}", hcsQaPid); - hrQaPid.add("QaPid/hPOverQEtaTofInverseBeta", "", {HistType::kTH3F, {asPOverQ, asEta, {120, 0.5, 3.5, "TOF 1/#it{#beta}"}}}); - hrQaPid.add("QaPid/hPtOverQEtaTofNSigmaPi_tpcPi", ";;;TOF #it{n}#it{#sigma}_{#pi}", hcsQaPid); - hrQaPid.add("QaPid/hPtOverQEtaTofNSigmaKa_tpcKa", ";;;TOF #it{n}#it{#sigma}_{K}", hcsQaPid); - hrQaPid.add("QaPid/hPtOverQEtaTofNSigmaPr_tpcPr", ";;;TOF #it{n}#it{#sigma}_{p}", hcsQaPid); - hrQaPid.add("QaPid/hPtOverQEtaTpcTofNSigmaPi", ";;;TPC-TOF #it{n}#it{#sigma}_{#pi}", hcsQaPid); - hrQaPid.add("QaPid/hPtOverQEtaTpcTofNSigmaKa", ";;;TPC-TOF #it{n}#it{#sigma}_{K}", hcsQaPid); - hrQaPid.add("QaPid/hPtOverQEtaTpcTofNSigmaPr", ";;;TPC-TOF #it{n}#it{#sigma}_{p}", hcsQaPid); + HistogramConfigSpec hcsQaPid(HistType::kTHnSparseF, {asQaCentrality, asPtOverQ, asEta, {200, -10., 10.}}); + hrQaPid.add("QaPid/hCentralityPOverQEtaTpcLnDeDx", "", {HistType::kTHnSparseF, {asQaCentrality, asPOverQ, asEta, {240, 3., 9., "TPC ln(d#it{E}/d#it{x} (a.u.))"}}}); + hrQaPid.add("QaPid/hCentralityPtOverQEtaTpcNSigmaPi_tofPi", ";;;TPC #it{n}#it{#sigma}_{#pi}", hcsQaPid); + hrQaPid.add("QaPid/hCentralityPtOverQEtaTpcNSigmaKa_tofKa", ";;;TPC #it{n}#it{#sigma}_{K}", hcsQaPid); + hrQaPid.add("QaPid/hCentralityPtOverQEtaTpcNSigmaPr_tofPr", ";;;TPC #it{n}#it{#sigma}_{p}", hcsQaPid); + hrQaPid.add("QaPid/hCentralityPOverQEtaTofInverseBeta", "", {HistType::kTHnSparseF, {asQaCentrality, asPOverQ, asEta, {120, 0.5, 3.5, "TOF 1/#it{#beta}"}}}); + hrQaPid.add("QaPid/hCentralityPtOverQEtaTofNSigmaPi_tpcPi", ";;;TOF #it{n}#it{#sigma}_{#pi}", hcsQaPid); + hrQaPid.add("QaPid/hCentralityPtOverQEtaTofNSigmaKa_tpcKa", ";;;TOF #it{n}#it{#sigma}_{K}", hcsQaPid); + hrQaPid.add("QaPid/hCentralityPtOverQEtaTofNSigmaPr_tpcPr", ";;;TOF #it{n}#it{#sigma}_{p}", hcsQaPid); } - if (cfgFlagAnalysisFluctuationCh.value || cfgFlagAnalysisFluctuationKa.value || cfgFlagAnalysisFluctuationPr.value) { - gRandom->SetSeed(0); - - HistogramConfigSpec hcsAnalysisFluctuation(HistType::kTH3F, {{cfgNCentralityBins.value, 0., 100., "Centrality (%)"}, {60, -0.5, 59.5}, {60, -0.5, 59.5}}); - HistogramConfigSpec hcsFluctuationCalculator(HistType::kTH3D, {{cfgNCentralityBins.value, 0., 100., "Centrality (%)"}, {cfgNSubgroups.value, -0.5, cfgNSubgroups.value - 0.5, "Subgroup Index"}, {fluctuation_calculator_base::NOrderVectors, -0.5, fluctuation_calculator_base::NOrderVectors - 0.5, "Order Vector Index"}}); - - if (cfgFlagAnalysisFluctuationCh.value) { - pVzPtEtaEfficiencyTpcPiP = static_cast(ccdbObject->FindObject("pVzPtEtaEfficiencyTpcPiP")); - assert(pVzPtEtaEfficiencyTpcPiP && pVzPtEtaEfficiencyTpcPiP->IsA() == TProfile3D::Class()); - pVzPtEtaEfficiencyTpcPiM = static_cast(ccdbObject->FindObject("pVzPtEtaEfficiencyTpcPiM")); - assert(pVzPtEtaEfficiencyTpcPiM && pVzPtEtaEfficiencyTpcPiM->IsA() == TProfile3D::Class()); - pVzPtEtaEfficiencyTpcTofPiP = static_cast(ccdbObject->FindObject("pVzPtEtaEfficiencyTpcTofPiP")); - assert(pVzPtEtaEfficiencyTpcTofPiP && pVzPtEtaEfficiencyTpcTofPiP->IsA() == TProfile3D::Class()); - pVzPtEtaEfficiencyTpcTofPiM = static_cast(ccdbObject->FindObject("pVzPtEtaEfficiencyTpcTofPiM")); - assert(pVzPtEtaEfficiencyTpcTofPiM && pVzPtEtaEfficiencyTpcTofPiM->IsA() == TProfile3D::Class()); - } - - if (cfgFlagAnalysisFluctuationCh.value || cfgFlagAnalysisFluctuationKa.value) { - pVzPtEtaEfficiencyTpcKaP = static_cast(ccdbObject->FindObject("pVzPtEtaEfficiencyTpcKaP")); - assert(pVzPtEtaEfficiencyTpcKaP && pVzPtEtaEfficiencyTpcKaP->IsA() == TProfile3D::Class()); - pVzPtEtaEfficiencyTpcKaM = static_cast(ccdbObject->FindObject("pVzPtEtaEfficiencyTpcKaM")); - assert(pVzPtEtaEfficiencyTpcKaM && pVzPtEtaEfficiencyTpcKaM->IsA() == TProfile3D::Class()); - pVzPtEtaEfficiencyTpcTofKaP = static_cast(ccdbObject->FindObject("pVzPtEtaEfficiencyTpcTofKaP")); - assert(pVzPtEtaEfficiencyTpcTofKaP && pVzPtEtaEfficiencyTpcTofKaP->IsA() == TProfile3D::Class()); - pVzPtEtaEfficiencyTpcTofKaM = static_cast(ccdbObject->FindObject("pVzPtEtaEfficiencyTpcTofKaM")); - assert(pVzPtEtaEfficiencyTpcTofKaM && pVzPtEtaEfficiencyTpcTofKaM->IsA() == TProfile3D::Class()); - } - - if (cfgFlagAnalysisFluctuationCh.value || cfgFlagAnalysisFluctuationPr.value) { - pVzPtEtaEfficiencyTpcPrP = static_cast(ccdbObject->FindObject("pVzPtEtaEfficiencyTpcPrP")); - assert(pVzPtEtaEfficiencyTpcPrP && pVzPtEtaEfficiencyTpcPrP->IsA() == TProfile3D::Class()); - pVzPtEtaEfficiencyTpcPrM = static_cast(ccdbObject->FindObject("pVzPtEtaEfficiencyTpcPrM")); - assert(pVzPtEtaEfficiencyTpcPrM && pVzPtEtaEfficiencyTpcPrM->IsA() == TProfile3D::Class()); - pVzPtEtaEfficiencyTpcTofPrP = static_cast(ccdbObject->FindObject("pVzPtEtaEfficiencyTpcTofPrP")); - assert(pVzPtEtaEfficiencyTpcTofPrP && pVzPtEtaEfficiencyTpcTofPrP->IsA() == TProfile3D::Class()); - pVzPtEtaEfficiencyTpcTofPrM = static_cast(ccdbObject->FindObject("pVzPtEtaEfficiencyTpcTofPrM")); - assert(pVzPtEtaEfficiencyTpcTofPrM && pVzPtEtaEfficiencyTpcTofPrM->IsA() == TProfile3D::Class()); - } - - if (cfgFlagAnalysisFluctuationCh.value) { - LOG(info) << "Enabling charge number fluctuation analysis."; - - fluctuationCalculatorTrackChP = std::make_unique(); - fluctuationCalculatorTrackChM = std::make_unique(); - fluctuationCalculatorTrackChT = std::make_unique(); - fluctuationCalculatorTrackChN = std::make_unique(); - - hrAnalysisFluctuation.add("AnalysisFluctuation/hCentralityNChPNChM", ";;No. of h^{+};No. of h^{#minus}", hcsAnalysisFluctuation); - hrAnalysisFluctuation.add("AnalysisFluctuation/hFluctuationCalculatorChP", "", hcsFluctuationCalculator); - hrAnalysisFluctuation.add("AnalysisFluctuation/hFluctuationCalculatorChM", "", hcsFluctuationCalculator); - hrAnalysisFluctuation.add("AnalysisFluctuation/hFluctuationCalculatorChT", "", hcsFluctuationCalculator); - hrAnalysisFluctuation.add("AnalysisFluctuation/hFluctuationCalculatorChN", "", hcsFluctuationCalculator); - } - - if (cfgFlagAnalysisFluctuationKa.value) { - LOG(info) << "Enabling kaon number fluctuation analysis."; - - fluctuationCalculatorTrackKaP = std::make_unique(); - fluctuationCalculatorTrackKaM = std::make_unique(); - fluctuationCalculatorTrackKaT = std::make_unique(); - fluctuationCalculatorTrackKaN = std::make_unique(); - - hrAnalysisFluctuation.add("AnalysisFluctuation/hCentralityNKaPNKaM", ";;No. of K^{+};No. of K^{#minus}", hcsAnalysisFluctuation); - hrAnalysisFluctuation.add("AnalysisFluctuation/hFluctuationCalculatorKaP", "", hcsFluctuationCalculator); - hrAnalysisFluctuation.add("AnalysisFluctuation/hFluctuationCalculatorKaM", "", hcsFluctuationCalculator); - hrAnalysisFluctuation.add("AnalysisFluctuation/hFluctuationCalculatorKaT", "", hcsFluctuationCalculator); - hrAnalysisFluctuation.add("AnalysisFluctuation/hFluctuationCalculatorKaN", "", hcsFluctuationCalculator); - } - - if (cfgFlagAnalysisFluctuationPr.value) { - LOG(info) << "Enabling (anti)proton number fluctuation analysis."; - - fluctuationCalculatorTrackPrP = std::make_unique(); - fluctuationCalculatorTrackPrM = std::make_unique(); - fluctuationCalculatorTrackPrT = std::make_unique(); - fluctuationCalculatorTrackPrN = std::make_unique(); - - hrAnalysisFluctuation.add("AnalysisFluctuation/hCentralityNPrPNPrM", ";;No. of p;No. of #bar{p}", hcsAnalysisFluctuation); - hrAnalysisFluctuation.add("AnalysisFluctuation/hFluctuationCalculatorPrP", "", hcsFluctuationCalculator); - hrAnalysisFluctuation.add("AnalysisFluctuation/hFluctuationCalculatorPrM", "", hcsFluctuationCalculator); - hrAnalysisFluctuation.add("AnalysisFluctuation/hFluctuationCalculatorPrT", "", hcsFluctuationCalculator); - hrAnalysisFluctuation.add("AnalysisFluctuation/hFluctuationCalculatorPrN", "", hcsFluctuationCalculator); - } + if (cfgFlagCalculationFluctuationCh.value || cfgFlagCalculationFluctuationKa.value || cfgFlagCalculationFluctuationPr.value) { + initCalculationFluctuation(ccdbObject); } } else if (doprocessMc) { + LOG(info) << "Enabling MC data process."; + if (cfgFlagCalculationPurityPi.value || cfgFlagCalculationPurityKa.value || cfgFlagCalculationPurityPr.value) { - HistogramConfigSpec hcsCalculationPurity(HistType::kTProfile2D, {{20, 0., 2., "#it{p}_{T} (GeV/#it{c})"}, {24, -1.2, 1.2, "#it{#eta}"}}); + HistogramConfigSpec hcsCalculationPurity(HistType::kTProfile3D, {{20, 0., 100., "Centrality (%)"}, {20, 0., 2., "#it{p}_{T} (GeV/#it{c})"}, {24, -1.2, 1.2, "#it{#eta}"}}); if (cfgFlagCalculationPurityPi.value) { LOG(info) << "Enabling pion purity calculation."; - hrCalculationPurity.add("CalculationPurity/pPtEtaPurityTpcPiP", "", hcsCalculationPurity); - hrCalculationPurity.add("CalculationPurity/pPtEtaPurityTpcPiM", "", hcsCalculationPurity); - hrCalculationPurity.add("CalculationPurity/pPtEtaPurityTpcTofPiP", "", hcsCalculationPurity); - hrCalculationPurity.add("CalculationPurity/pPtEtaPurityTpcTofPiM", "", hcsCalculationPurity); + hrCalculationPurity.add("CalculationPurity/pCentralityPtEtaPurityTpcPiP", "", hcsCalculationPurity); + hrCalculationPurity.add("CalculationPurity/pCentralityPtEtaPurityTpcPiM", "", hcsCalculationPurity); + hrCalculationPurity.add("CalculationPurity/pCentralityPtEtaPurityTpcTofPiP", "", hcsCalculationPurity); + hrCalculationPurity.add("CalculationPurity/pCentralityPtEtaPurityTpcTofPiM", "", hcsCalculationPurity); } if (cfgFlagCalculationPurityKa.value) { LOG(info) << "Enabling kaon purity calculation."; - hrCalculationPurity.add("CalculationPurity/pPtEtaPurityTpcKaP", "", hcsCalculationPurity); - hrCalculationPurity.add("CalculationPurity/pPtEtaPurityTpcKaM", "", hcsCalculationPurity); - hrCalculationPurity.add("CalculationPurity/pPtEtaPurityTpcTofKaP", "", hcsCalculationPurity); - hrCalculationPurity.add("CalculationPurity/pPtEtaPurityTpcTofKaM", "", hcsCalculationPurity); + hrCalculationPurity.add("CalculationPurity/pCentralityPtEtaPurityTpcKaP", "", hcsCalculationPurity); + hrCalculationPurity.add("CalculationPurity/pCentralityPtEtaPurityTpcKaM", "", hcsCalculationPurity); + hrCalculationPurity.add("CalculationPurity/pCentralityPtEtaPurityTpcTofKaP", "", hcsCalculationPurity); + hrCalculationPurity.add("CalculationPurity/pCentralityPtEtaPurityTpcTofKaM", "", hcsCalculationPurity); } if (cfgFlagCalculationPurityPr.value) { LOG(info) << "Enabling (anti)proton purity calculation."; - hrCalculationPurity.add("CalculationPurity/pPtEtaPurityTpcPrP", "", hcsCalculationPurity); - hrCalculationPurity.add("CalculationPurity/pPtEtaPurityTpcPrM", "", hcsCalculationPurity); - hrCalculationPurity.add("CalculationPurity/pPtEtaPurityTpcTofPrP", "", hcsCalculationPurity); - hrCalculationPurity.add("CalculationPurity/pPtEtaPurityTpcTofPrM", "", hcsCalculationPurity); + hrCalculationPurity.add("CalculationPurity/pCentralityPtEtaPurityTpcPrP", "", hcsCalculationPurity); + hrCalculationPurity.add("CalculationPurity/pCentralityPtEtaPurityTpcPrM", "", hcsCalculationPurity); + hrCalculationPurity.add("CalculationPurity/pCentralityPtEtaPurityTpcTofPrP", "", hcsCalculationPurity); + hrCalculationPurity.add("CalculationPurity/pCentralityPtEtaPurityTpcTofPrM", "", hcsCalculationPurity); } } if (cfgFlagCalculationEfficiencyPi.value || cfgFlagCalculationEfficiencyKa.value || cfgFlagCalculationEfficiencyPr.value) { - HistogramConfigSpec hcsCalculationEfficiency(HistType::kTProfile3D, {{static_cast(std::llrint(cfgCutMaxAbsVertexZ.value * 2.)), -cfgCutMaxAbsVertexZ.value, cfgCutMaxAbsVertexZ.value, "#it{V}_{#it{z}} (cm)"}, {20, 0., 2., "#it{p}_{T} (GeV/#it{c})"}, {24, -1.2, 1.2, "#it{#eta}"}}); + HistogramConfigSpec hcsCalculationEfficiency(HistType::kTProfile3D, {{20, 0., 100., "Centrality (%)"}, {20, 0., 2., "#it{p}_{T} (GeV/#it{c})"}, {24, -1.2, 1.2, "#it{#eta}"}}); if (cfgFlagCalculationEfficiencyPi.value) { LOG(info) << "Enabling pion efficiency calculation."; - quantityHolderEvent.mcParticleIndicesMatchedTpcPiP.reserve(60); - quantityHolderEvent.mcParticleIndicesMatchedTpcPiM.reserve(60); - quantityHolderEvent.mcParticleIndicesMatchedTpcTofPiP.reserve(40); - quantityHolderEvent.mcParticleIndicesMatchedTpcTofPiM.reserve(40); - - hrCalculationEfficiency.add("CalculationEfficiency/pVzPtEtaEfficiencyTpcPiP", "", hcsCalculationEfficiency); - hrCalculationEfficiency.add("CalculationEfficiency/pVzPtEtaEfficiencyTpcPiM", "", hcsCalculationEfficiency); - hrCalculationEfficiency.add("CalculationEfficiency/pVzPtEtaEfficiencyTpcTofPiP", "", hcsCalculationEfficiency); - hrCalculationEfficiency.add("CalculationEfficiency/pVzPtEtaEfficiencyTpcTofPiM", "", hcsCalculationEfficiency); + holderEvent.mcParticleIndicesMatchedTpcPiP.reserve(60); + holderEvent.mcParticleIndicesMatchedTpcPiM.reserve(60); + holderEvent.mcParticleIndicesMatchedTpcTofPiP.reserve(40); + holderEvent.mcParticleIndicesMatchedTpcTofPiM.reserve(40); + + pCentralityPtEtaEfficiencyTpcPiP.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + pCentralityPtEtaEfficiencyTpcPiM.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + pCentralityPtEtaEfficiencyTpcTofPiP.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + pCentralityPtEtaEfficiencyTpcTofPiM.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + for (std::int32_t const& iVzBin : std::views::iota(0, static_cast(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2))) { + pCentralityPtEtaEfficiencyTpcPiP[iVzBin] = hrCalculationEfficiency.add(Form("CalculationEfficiency/pCentralityPtEtaEfficiencyTpcPiP_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1), "", hcsCalculationEfficiency); + pCentralityPtEtaEfficiencyTpcPiM[iVzBin] = hrCalculationEfficiency.add(Form("CalculationEfficiency/pCentralityPtEtaEfficiencyTpcPiM_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1), "", hcsCalculationEfficiency); + pCentralityPtEtaEfficiencyTpcTofPiP[iVzBin] = hrCalculationEfficiency.add(Form("CalculationEfficiency/pCentralityPtEtaEfficiencyTpcTofPiP_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1), "", hcsCalculationEfficiency); + pCentralityPtEtaEfficiencyTpcTofPiM[iVzBin] = hrCalculationEfficiency.add(Form("CalculationEfficiency/pCentralityPtEtaEfficiencyTpcTofPiM_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1), "", hcsCalculationEfficiency); + } } if (cfgFlagCalculationEfficiencyKa.value) { LOG(info) << "Enabling kaon efficiency calculation."; - quantityHolderEvent.mcParticleIndicesMatchedTpcKaP.reserve(30); - quantityHolderEvent.mcParticleIndicesMatchedTpcKaM.reserve(30); - quantityHolderEvent.mcParticleIndicesMatchedTpcTofKaP.reserve(20); - quantityHolderEvent.mcParticleIndicesMatchedTpcTofKaM.reserve(20); - - hrCalculationEfficiency.add("CalculationEfficiency/pVzPtEtaEfficiencyTpcKaP", "", hcsCalculationEfficiency); - hrCalculationEfficiency.add("CalculationEfficiency/pVzPtEtaEfficiencyTpcKaM", "", hcsCalculationEfficiency); - hrCalculationEfficiency.add("CalculationEfficiency/pVzPtEtaEfficiencyTpcTofKaP", "", hcsCalculationEfficiency); - hrCalculationEfficiency.add("CalculationEfficiency/pVzPtEtaEfficiencyTpcTofKaM", "", hcsCalculationEfficiency); + holderEvent.mcParticleIndicesMatchedTpcKaP.reserve(30); + holderEvent.mcParticleIndicesMatchedTpcKaM.reserve(30); + holderEvent.mcParticleIndicesMatchedTpcTofKaP.reserve(20); + holderEvent.mcParticleIndicesMatchedTpcTofKaM.reserve(20); + + pCentralityPtEtaEfficiencyTpcKaP.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + pCentralityPtEtaEfficiencyTpcKaM.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + pCentralityPtEtaEfficiencyTpcTofKaP.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + pCentralityPtEtaEfficiencyTpcTofKaM.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + for (std::int32_t const& iVzBin : std::views::iota(0, static_cast(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2))) { + pCentralityPtEtaEfficiencyTpcKaP[iVzBin] = hrCalculationEfficiency.add(Form("CalculationEfficiency/pCentralityPtEtaEfficiencyTpcKaP_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1), "", hcsCalculationEfficiency); + pCentralityPtEtaEfficiencyTpcKaM[iVzBin] = hrCalculationEfficiency.add(Form("CalculationEfficiency/pCentralityPtEtaEfficiencyTpcKaM_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1), "", hcsCalculationEfficiency); + pCentralityPtEtaEfficiencyTpcTofKaP[iVzBin] = hrCalculationEfficiency.add(Form("CalculationEfficiency/pCentralityPtEtaEfficiencyTpcTofKaP_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1), "", hcsCalculationEfficiency); + pCentralityPtEtaEfficiencyTpcTofKaM[iVzBin] = hrCalculationEfficiency.add(Form("CalculationEfficiency/pCentralityPtEtaEfficiencyTpcTofKaM_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1), "", hcsCalculationEfficiency); + } } if (cfgFlagCalculationEfficiencyPr.value) { LOG(info) << "Enabling (anti)proton efficiency calculation."; - quantityHolderEvent.mcParticleIndicesMatchedTpcPrP.reserve(30); - quantityHolderEvent.mcParticleIndicesMatchedTpcPrM.reserve(30); - quantityHolderEvent.mcParticleIndicesMatchedTpcTofPrP.reserve(20); - quantityHolderEvent.mcParticleIndicesMatchedTpcTofPrM.reserve(20); - - hrCalculationEfficiency.add("CalculationEfficiency/pVzPtEtaEfficiencyTpcPrP", "", hcsCalculationEfficiency); - hrCalculationEfficiency.add("CalculationEfficiency/pVzPtEtaEfficiencyTpcPrM", "", hcsCalculationEfficiency); - hrCalculationEfficiency.add("CalculationEfficiency/pVzPtEtaEfficiencyTpcTofPrP", "", hcsCalculationEfficiency); - hrCalculationEfficiency.add("CalculationEfficiency/pVzPtEtaEfficiencyTpcTofPrM", "", hcsCalculationEfficiency); + holderEvent.mcParticleIndicesMatchedTpcPrP.reserve(30); + holderEvent.mcParticleIndicesMatchedTpcPrM.reserve(30); + holderEvent.mcParticleIndicesMatchedTpcTofPrP.reserve(20); + holderEvent.mcParticleIndicesMatchedTpcTofPrM.reserve(20); + + pCentralityPtEtaEfficiencyTpcPrP.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + pCentralityPtEtaEfficiencyTpcPrM.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + pCentralityPtEtaEfficiencyTpcTofPrP.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + pCentralityPtEtaEfficiencyTpcTofPrM.resize(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2); + for (std::int32_t const& iVzBin : std::views::iota(0, static_cast(std::llrint(std::ceil(cfgCutMaxAbsVertexZ.value)) * 2))) { + pCentralityPtEtaEfficiencyTpcPrP[iVzBin] = hrCalculationEfficiency.add(Form("CalculationEfficiency/pCentralityPtEtaEfficiencyTpcPrP_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1), "", hcsCalculationEfficiency); + pCentralityPtEtaEfficiencyTpcPrM[iVzBin] = hrCalculationEfficiency.add(Form("CalculationEfficiency/pCentralityPtEtaEfficiencyTpcPrM_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1), "", hcsCalculationEfficiency); + pCentralityPtEtaEfficiencyTpcTofPrP[iVzBin] = hrCalculationEfficiency.add(Form("CalculationEfficiency/pCentralityPtEtaEfficiencyTpcTofPrP_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1), "", hcsCalculationEfficiency); + pCentralityPtEtaEfficiencyTpcTofPrM[iVzBin] = hrCalculationEfficiency.add(Form("CalculationEfficiency/pCentralityPtEtaEfficiencyTpcTofPrM_vz%gto%g", std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin, std::floor(-cfgCutMaxAbsVertexZ.value) + iVzBin + 1), "", hcsCalculationEfficiency); + } } } + + if (cfgFlagCalculationFluctuationCh.value || cfgFlagCalculationFluctuationKa.value || cfgFlagCalculationFluctuationPr.value) { + initCalculationFluctuation(ccdbObject); + } } - if (runNumbers.empty()) { + if (holderCcdb.runNumbers.empty()) { LOG(info) << "No run process enabled."; } else { - for (std::int32_t const& runNumber : runNumbers) { + for (std::int32_t const& runNumber : holderCcdb.runNumbers) { LOG(info) << "Enabling processing run: " << runNumber; } } - if (runNumbersBad.empty()) { + if (holderCcdb.runNumbersBad.empty()) { LOG(info) << "No run rejection enabled."; } else { - for (std::int32_t const& runNumberBad : runNumbersBad) { + for (std::int32_t const& runNumberBad : holderCcdb.runNumbersBad) { LOG(info) << "Enabling rejecting run: " << runNumberBad; } } - if ((cfgFlagSelectionEvent.value & ((1ULL << aod::evsel::kNsel) - 1)) == 0) { + if ((cfgFlagSelectionEvent.value & ((1ULL << aod::evsel::EventSelectionFlags::kNsel) - 1)) == 0) { LOG(info) << "No event selection bit enabled."; } else { - for (std::int32_t const& iEvSel : std::views::iota(0, aod::evsel::kNsel)) { + for (std::int32_t const& iEvSel : std::views::iota(0, aod::evsel::EventSelectionFlags::kNsel)) { if ((cfgFlagSelectionEvent.value >> iEvSel) & 1) { LOG(info) << "Enabling event selection bit: " << aod::evsel::selectionLabels[iEvSel]; } } } + + switch (cfgIndexDefinitionCentrality) { + default: + LOG(info) << "Enabling centrality definition: FV0A"; + break; + case static_cast(CentralityDefinitionIndices::kFT0M): + LOG(info) << "Enabling centrality definition: FT0M"; + break; + case static_cast(CentralityDefinitionIndices::kFT0A): + LOG(info) << "Enabling centrality definition: FT0A"; + break; + case static_cast(CentralityDefinitionIndices::kFT0C): + LOG(info) << "Enabling centrality definition: FT0C"; + break; + } } template std::int32_t isPi() { if constexpr (doRequiringTof && doRejectingOthers) { - if (!(std::fabs(quantityHolderTrack.tpcTofNSigmaPi) < std::min(cfgCutMaxAbsNSigmaPid.value, std::min(std::fabs(quantityHolderTrack.tpcTofNSigmaKa), std::fabs(quantityHolderTrack.tpcTofNSigmaPr))))) { + if (!(std::fabs(holderTrack.tpcTofNSigmaPi) < std::min(cfgCutMaxAbsNSigmaPid.value, std::min(std::fabs(holderTrack.tpcTofNSigmaKa), std::fabs(holderTrack.tpcTofNSigmaPr))))) { return 0; } } if constexpr (doRequiringTof && !doRejectingOthers) { - if (!(std::fabs(quantityHolderTrack.tpcTofNSigmaPi) < cfgCutMaxAbsNSigmaPid.value)) { + if (!(std::fabs(holderTrack.tpcTofNSigmaPi) < cfgCutMaxAbsNSigmaPid.value)) { return 0; } } if constexpr (!doRequiringTof && doRejectingOthers) { - if (!(std::fabs(quantityHolderTrack.tpcNSigmaPi) < std::min(cfgCutMaxAbsNSigmaPid.value, std::min(std::fabs(quantityHolderTrack.tpcNSigmaKa), std::fabs(quantityHolderTrack.tpcNSigmaPr))))) { + if (!(std::fabs(holderTrack.tpcNSigmaPi) < std::min(cfgCutMaxAbsNSigmaPid.value, std::min(std::fabs(holderTrack.tpcNSigmaKa), std::fabs(holderTrack.tpcNSigmaPr))))) { return 0; } } if constexpr (!doRequiringTof && !doRejectingOthers) { - if (!(std::fabs(quantityHolderTrack.tpcNSigmaPi) < cfgCutMaxAbsNSigmaPid.value)) { + if (!(std::fabs(holderTrack.tpcNSigmaPi) < cfgCutMaxAbsNSigmaPid.value)) { return 0; } } - return quantityHolderTrack.sign; + return holderTrack.sign; } template std::int32_t isKa() { if constexpr (doRequiringTof && doRejectingOthers) { - if (!(std::fabs(quantityHolderTrack.tpcTofNSigmaKa) < std::min(cfgCutMaxAbsNSigmaPid.value, std::min(std::fabs(quantityHolderTrack.tpcTofNSigmaPi), std::fabs(quantityHolderTrack.tpcTofNSigmaPr))))) { + if (!(std::fabs(holderTrack.tpcTofNSigmaKa) < std::min(cfgCutMaxAbsNSigmaPid.value, std::min(std::fabs(holderTrack.tpcTofNSigmaPi), std::fabs(holderTrack.tpcTofNSigmaPr))))) { return 0; } } if constexpr (doRequiringTof && !doRejectingOthers) { - if (!(std::fabs(quantityHolderTrack.tpcTofNSigmaKa) < cfgCutMaxAbsNSigmaPid.value)) { + if (!(std::fabs(holderTrack.tpcTofNSigmaKa) < cfgCutMaxAbsNSigmaPid.value)) { return 0; } } if constexpr (!doRequiringTof && doRejectingOthers) { - if (!(std::fabs(quantityHolderTrack.tpcNSigmaKa) < std::min(cfgCutMaxAbsNSigmaPid.value, std::min(std::fabs(quantityHolderTrack.tpcNSigmaPi), std::fabs(quantityHolderTrack.tpcNSigmaPr))))) { + if (!(std::fabs(holderTrack.tpcNSigmaKa) < std::min(cfgCutMaxAbsNSigmaPid.value, std::min(std::fabs(holderTrack.tpcNSigmaPi), std::fabs(holderTrack.tpcNSigmaPr))))) { return 0; } } if constexpr (!doRequiringTof && !doRejectingOthers) { - if (!(std::fabs(quantityHolderTrack.tpcNSigmaKa) < cfgCutMaxAbsNSigmaPid.value)) { + if (!(std::fabs(holderTrack.tpcNSigmaKa) < cfgCutMaxAbsNSigmaPid.value)) { return 0; } } - return quantityHolderTrack.sign; + return holderTrack.sign; } template std::int32_t isPr() { if constexpr (doRequiringTof && doRejectingOthers) { - if (!(std::fabs(quantityHolderTrack.tpcTofNSigmaPr) < std::min(cfgCutMaxAbsNSigmaPid.value, std::min(std::fabs(quantityHolderTrack.tpcTofNSigmaPi), std::fabs(quantityHolderTrack.tpcTofNSigmaKa))))) { + if (!(std::fabs(holderTrack.tpcTofNSigmaPr) < std::min(cfgCutMaxAbsNSigmaPid.value, std::min(std::fabs(holderTrack.tpcTofNSigmaPi), std::fabs(holderTrack.tpcTofNSigmaKa))))) { return 0; } } if constexpr (doRequiringTof && !doRejectingOthers) { - if (!(std::fabs(quantityHolderTrack.tpcTofNSigmaPr) < cfgCutMaxAbsNSigmaPid.value)) { + if (!(std::fabs(holderTrack.tpcTofNSigmaPr) < cfgCutMaxAbsNSigmaPid.value)) { return 0; } } if constexpr (!doRequiringTof && doRejectingOthers) { - if (!(std::fabs(quantityHolderTrack.tpcNSigmaPr) < std::min(cfgCutMaxAbsNSigmaPid.value, std::min(std::fabs(quantityHolderTrack.tpcNSigmaPi), std::fabs(quantityHolderTrack.tpcNSigmaKa))))) { + if (!(std::fabs(holderTrack.tpcNSigmaPr) < std::min(cfgCutMaxAbsNSigmaPid.value, std::min(std::fabs(holderTrack.tpcNSigmaPi), std::fabs(holderTrack.tpcNSigmaKa))))) { return 0; } } if constexpr (!doRequiringTof && !doRejectingOthers) { - if (!(std::fabs(quantityHolderTrack.tpcNSigmaPr) < cfgCutMaxAbsNSigmaPid.value)) { + if (!(std::fabs(holderTrack.tpcNSigmaPr) < cfgCutMaxAbsNSigmaPid.value)) { return 0; } } - return quantityHolderTrack.sign; + return holderTrack.sign; } bool isGoodMomentum() { - if (!(cfgCutMinPt.value < quantityHolderTrack.pt && quantityHolderTrack.pt < cfgCutMaxPt.value)) { + if (!(cfgCutMinPt.value < holderTrack.pt && holderTrack.pt < cfgCutMaxPt.value)) { return false; } - if (!(std::fabs(quantityHolderTrack.eta) < cfgCutMaxAbsEta.value)) { + if (!(std::fabs(holderTrack.eta) < cfgCutMaxAbsEta.value)) { return false; } return true; @@ -1103,16 +1242,25 @@ struct PartNumFluc { return true; } + template + bool isGoodMcParticle(const MP& mcParticle) + { + if (!mcParticle.isPhysicalPrimary()) { + return false; + } + return true; + } + template bool initMcParticle(const MP& mcParticle) { - quantityHolderMcParticle.clear(); - quantityHolderMcParticle.globalIndex = mcParticle.globalIndex(); - quantityHolderMcParticle.pdgCode = mcParticle.pdgCode(); - quantityHolderMcParticle.pt = mcParticle.pt(); - quantityHolderMcParticle.eta = mcParticle.eta(); + holderMcParticle.clear(); + holderMcParticle.globalIndex = mcParticle.globalIndex(); + holderMcParticle.pdgCode = mcParticle.pdgCode(); + holderMcParticle.pt = mcParticle.pt(); + holderMcParticle.eta = mcParticle.eta(); - if (!mcParticle.isPhysicalPrimary()) { + if (!isGoodMcParticle(mcParticle)) { return false; } @@ -1122,81 +1270,81 @@ struct PartNumFluc { template bool initTrack(const T& track) { - quantityHolderTrack.clear(); - quantityHolderTrack.sign = track.sign(); - quantityHolderTrack.pt = track.pt(); - quantityHolderTrack.eta = track.eta(); - quantityHolderTrack.phi = track.phi(); - quantityHolderTrack.ptOverQ = quantityHolderTrack.pt / quantityHolderTrack.sign; - quantityHolderTrack.pOverQ = track.p() / quantityHolderTrack.sign; - quantityHolderTrack.rapidityPi = track.rapidity(constants::physics::MassPiPlus); - quantityHolderTrack.rapidityKa = track.rapidity(constants::physics::MassKPlus); - quantityHolderTrack.rapidityPr = track.rapidity(constants::physics::MassProton); - quantityHolderTrack.hasTpcPid = (track.hasTPC() && track.tpcSignal() > 0.); - quantityHolderTrack.tpcNSigmaPi = QuantityHolderTrack::truncateNSigmaPid(track.tpcNSigmaPi()); - quantityHolderTrack.tpcNSigmaKa = QuantityHolderTrack::truncateNSigmaPid(track.tpcNSigmaKa()); - quantityHolderTrack.tpcNSigmaPr = QuantityHolderTrack::truncateNSigmaPid(track.tpcNSigmaPr()); - quantityHolderTrack.hasTofPid = (track.hasTOF() && track.beta() > 0.); - quantityHolderTrack.tofNSigmaPi = QuantityHolderTrack::truncateNSigmaPid(track.tofNSigmaPi()); - quantityHolderTrack.tofNSigmaKa = QuantityHolderTrack::truncateNSigmaPid(track.tofNSigmaKa()); - quantityHolderTrack.tofNSigmaPr = QuantityHolderTrack::truncateNSigmaPid(track.tofNSigmaPr()); - quantityHolderTrack.tpcTofNSigmaPi = QuantityHolderTrack::truncateNSigmaPid(std::sqrt(std::pow(quantityHolderTrack.tpcNSigmaPi, 2.) + std::pow(quantityHolderTrack.tofNSigmaPi, 2.))); - quantityHolderTrack.tpcTofNSigmaKa = QuantityHolderTrack::truncateNSigmaPid(std::sqrt(std::pow(quantityHolderTrack.tpcNSigmaKa, 2.) + std::pow(quantityHolderTrack.tofNSigmaKa, 2.))); - quantityHolderTrack.tpcTofNSigmaPr = QuantityHolderTrack::truncateNSigmaPid(std::sqrt(std::pow(quantityHolderTrack.tpcNSigmaPr, 2.) + std::pow(quantityHolderTrack.tofNSigmaPr, 2.))); + holderTrack.clear(); + holderTrack.sign = track.sign(); + holderTrack.pt = track.pt(); + holderTrack.eta = track.eta(); + holderTrack.phi = track.phi(); + holderTrack.ptOverQ = holderTrack.pt / holderTrack.sign; + holderTrack.pOverQ = track.p() / holderTrack.sign; + holderTrack.rapidityPi = track.rapidity(constants::physics::MassPiPlus); + holderTrack.rapidityKa = track.rapidity(constants::physics::MassKPlus); + holderTrack.rapidityPr = track.rapidity(constants::physics::MassProton); + holderTrack.hasTpcPid = (track.hasTPC() && track.tpcSignal() > 0.); + holderTrack.tpcNSigmaPi = HolderTrack::truncateNSigmaPid(track.tpcNSigmaPi()); + holderTrack.tpcNSigmaKa = HolderTrack::truncateNSigmaPid(track.tpcNSigmaKa()); + holderTrack.tpcNSigmaPr = HolderTrack::truncateNSigmaPid(track.tpcNSigmaPr()); + holderTrack.hasTofPid = (track.hasTOF() && track.beta() > 0.); + holderTrack.tofNSigmaPi = HolderTrack::truncateNSigmaPid(track.tofNSigmaPi()); + holderTrack.tofNSigmaKa = HolderTrack::truncateNSigmaPid(track.tofNSigmaKa()); + holderTrack.tofNSigmaPr = HolderTrack::truncateNSigmaPid(track.tofNSigmaPr()); + holderTrack.tpcTofNSigmaPi = HolderTrack::truncateNSigmaPid(std::sqrt(std::pow(holderTrack.tpcNSigmaPi, 2.) + std::pow(holderTrack.tofNSigmaPi, 2.))); + holderTrack.tpcTofNSigmaKa = HolderTrack::truncateNSigmaPid(std::sqrt(std::pow(holderTrack.tpcNSigmaKa, 2.) + std::pow(holderTrack.tofNSigmaKa, 2.))); + holderTrack.tpcTofNSigmaPr = HolderTrack::truncateNSigmaPid(std::sqrt(std::pow(holderTrack.tpcNSigmaPr, 2.) + std::pow(holderTrack.tofNSigmaPr, 2.))); if constexpr (doProcessingMc) { - quantityHolderTrack.mcParticleId = track.mcParticleId(); + holderTrack.mcParticleId = track.mcParticleId(); } if constexpr (doInitingEvent) { - quantityHolderEvent.nGlobalTracks++; + holderEvent.nGlobalTracks++; if (track.isPVContributor()) { - quantityHolderEvent.nPvContributors++; + holderEvent.nPvContributors++; } - if (quantityHolderTrack.hasTofPid) { - quantityHolderEvent.nTofBeta++; + holderEvent.meanDcaXy += track.dcaXY(); + holderEvent.meanSquareDcaXy += std::pow(track.dcaXY(), 2.); + holderEvent.meanDcaZ += track.dcaZ(); + holderEvent.meanSquareDcaZ += std::pow(track.dcaZ(), 2.); + if (holderTrack.hasTofPid) { + holderEvent.nTofBeta++; } - quantityHolderEvent.meanDcaXy += track.dcaXY(); - quantityHolderEvent.meanSquareDcaXy += std::pow(track.dcaXY(), 2.); - quantityHolderEvent.meanDcaZ += track.dcaZ(); - quantityHolderEvent.meanSquareDcaZ += std::pow(track.dcaZ(), 2.); } if constexpr (!doProcessingMc && doInitingEvent) { if (cfgFlagQaRun.value) { - hrQaRun.fill(HIST("QaRun/pRunIndexItsNCls"), quantityHolderEvent.runIndex, track.itsNCls()); - hrQaRun.fill(HIST("QaRun/pRunIndexItsChi2NCls"), quantityHolderEvent.runIndex, track.itsChi2NCl()); - hrQaRun.fill(HIST("QaRun/pRunIndexTpcNCls"), quantityHolderEvent.runIndex, track.tpcNClsFound()); - hrQaRun.fill(HIST("QaRun/pRunIndexTpcChi2NCls"), quantityHolderEvent.runIndex, track.tpcChi2NCl()); - hrQaRun.fill(HIST("QaRun/pRunIndexTpcNClsSharedRatio"), quantityHolderEvent.runIndex, track.tpcFractionSharedCls()); - hrQaRun.fill(HIST("QaRun/pRunIndexTpcNClsCrossedRows"), quantityHolderEvent.runIndex, track.tpcNClsCrossedRows()); - hrQaRun.fill(HIST("QaRun/pRunIndexTpcNClsCrossedRowsRatio"), quantityHolderEvent.runIndex, track.tpcCrossedRowsOverFindableCls()); - hrQaRun.fill(HIST("QaRun/pRunIndexDcaXy"), quantityHolderEvent.runIndex, track.dcaXY()); - hrQaRun.fill(HIST("QaRun/pRunIndexDcaZ"), quantityHolderEvent.runIndex, track.dcaZ()); - hrQaRun.fill(HIST("QaRun/pRunIndexPt"), quantityHolderEvent.runIndex, quantityHolderTrack.pt); - hrQaRun.fill(HIST("QaRun/pRunIndexEta"), quantityHolderEvent.runIndex, quantityHolderTrack.eta); - hrQaRun.fill(HIST("QaRun/pRunIndexPhi"), quantityHolderEvent.runIndex, quantityHolderTrack.phi); - if (quantityHolderTrack.hasTpcPid) { - hrQaRun.fill(HIST("QaRun/pRunIndexTpcDeDx"), quantityHolderEvent.runIndex, track.tpcSignal()); - if (std::fabs(quantityHolderTrack.tpcNSigmaPi) < QuantityHolderTrack::TruncationAbsNSigmaPid) { - hrQaRun.fill(HIST("QaRun/pRunIndexTpcNSigmaPi"), quantityHolderEvent.runIndex, quantityHolderTrack.tpcNSigmaPi); + hrQaRun.fill(HIST("QaRun/pRunIndexItsNCls"), holderEvent.runIndex, track.itsNCls()); + hrQaRun.fill(HIST("QaRun/pRunIndexItsChi2NCls"), holderEvent.runIndex, track.itsChi2NCl()); + hrQaRun.fill(HIST("QaRun/pRunIndexTpcNCls"), holderEvent.runIndex, track.tpcNClsFound()); + hrQaRun.fill(HIST("QaRun/pRunIndexTpcChi2NCls"), holderEvent.runIndex, track.tpcChi2NCl()); + hrQaRun.fill(HIST("QaRun/pRunIndexTpcNClsSharedRatio"), holderEvent.runIndex, track.tpcFractionSharedCls()); + hrQaRun.fill(HIST("QaRun/pRunIndexTpcNClsCrossedRows"), holderEvent.runIndex, track.tpcNClsCrossedRows()); + hrQaRun.fill(HIST("QaRun/pRunIndexTpcNClsCrossedRowsRatio"), holderEvent.runIndex, track.tpcCrossedRowsOverFindableCls()); + hrQaRun.fill(HIST("QaRun/pRunIndexDcaXy"), holderEvent.runIndex, track.dcaXY()); + hrQaRun.fill(HIST("QaRun/pRunIndexDcaZ"), holderEvent.runIndex, track.dcaZ()); + hrQaRun.fill(HIST("QaRun/pRunIndexPt"), holderEvent.runIndex, holderTrack.pt); + hrQaRun.fill(HIST("QaRun/pRunIndexEta"), holderEvent.runIndex, holderTrack.eta); + hrQaRun.fill(HIST("QaRun/pRunIndexPhi"), holderEvent.runIndex, holderTrack.phi); + if (holderTrack.hasTpcPid) { + hrQaRun.fill(HIST("QaRun/pRunIndexTpcDeDx"), holderEvent.runIndex, track.tpcSignal()); + if (std::fabs(holderTrack.tpcNSigmaPi) < HolderTrack::TruncationAbsNSigmaPid) { + hrQaRun.fill(HIST("QaRun/pRunIndexTpcNSigmaPi"), holderEvent.runIndex, holderTrack.tpcNSigmaPi); } - if (std::fabs(quantityHolderTrack.tpcNSigmaKa) < QuantityHolderTrack::TruncationAbsNSigmaPid) { - hrQaRun.fill(HIST("QaRun/pRunIndexTpcNSigmaKa"), quantityHolderEvent.runIndex, quantityHolderTrack.tpcNSigmaKa); + if (std::fabs(holderTrack.tpcNSigmaKa) < HolderTrack::TruncationAbsNSigmaPid) { + hrQaRun.fill(HIST("QaRun/pRunIndexTpcNSigmaKa"), holderEvent.runIndex, holderTrack.tpcNSigmaKa); } - if (std::fabs(quantityHolderTrack.tpcNSigmaPr) < QuantityHolderTrack::TruncationAbsNSigmaPid) { - hrQaRun.fill(HIST("QaRun/pRunIndexTpcNSigmaPr"), quantityHolderEvent.runIndex, quantityHolderTrack.tpcNSigmaPr); + if (std::fabs(holderTrack.tpcNSigmaPr) < HolderTrack::TruncationAbsNSigmaPid) { + hrQaRun.fill(HIST("QaRun/pRunIndexTpcNSigmaPr"), holderEvent.runIndex, holderTrack.tpcNSigmaPr); } } - if (quantityHolderTrack.hasTofPid) { - hrQaRun.fill(HIST("QaRun/pRunIndexTofInverseBeta"), quantityHolderEvent.runIndex, 1. / track.beta()); - if (std::fabs(quantityHolderTrack.tofNSigmaPi) < QuantityHolderTrack::TruncationAbsNSigmaPid) { - hrQaRun.fill(HIST("QaRun/pRunIndexTofNSigmaPi"), quantityHolderEvent.runIndex, quantityHolderTrack.tofNSigmaPi); + if (holderTrack.hasTofPid) { + hrQaRun.fill(HIST("QaRun/pRunIndexTofInverseBeta"), holderEvent.runIndex, 1. / track.beta()); + if (std::fabs(holderTrack.tofNSigmaPi) < HolderTrack::TruncationAbsNSigmaPid) { + hrQaRun.fill(HIST("QaRun/pRunIndexTofNSigmaPi"), holderEvent.runIndex, holderTrack.tofNSigmaPi); } - if (std::fabs(quantityHolderTrack.tofNSigmaKa) < QuantityHolderTrack::TruncationAbsNSigmaPid) { - hrQaRun.fill(HIST("QaRun/pRunIndexTofNSigmaKa"), quantityHolderEvent.runIndex, quantityHolderTrack.tofNSigmaKa); + if (std::fabs(holderTrack.tofNSigmaKa) < HolderTrack::TruncationAbsNSigmaPid) { + hrQaRun.fill(HIST("QaRun/pRunIndexTofNSigmaKa"), holderEvent.runIndex, holderTrack.tofNSigmaKa); } - if (std::fabs(quantityHolderTrack.tofNSigmaPr) < QuantityHolderTrack::TruncationAbsNSigmaPid) { - hrQaRun.fill(HIST("QaRun/pRunIndexTofNSigmaPr"), quantityHolderEvent.runIndex, quantityHolderTrack.tofNSigmaPr); + if (std::fabs(holderTrack.tofNSigmaPr) < HolderTrack::TruncationAbsNSigmaPid) { + hrQaRun.fill(HIST("QaRun/pRunIndexTofNSigmaPr"), holderEvent.runIndex, holderTrack.tofNSigmaPr); } } } @@ -1208,11 +1356,11 @@ struct PartNumFluc { hrQaTrack.fill(HIST("QaTrack/hItsChi2NCls"), track.itsChi2NCl()); hrQaTrack.fill(HIST("QaTrack/hTpcNClsNClsSharedNClsFindableNClsCrossedRows"), track.tpcNClsFound(), track.tpcNClsShared(), track.tpcNClsFindable(), track.tpcNClsCrossedRows()); hrQaTrack.fill(HIST("QaTrack/hTpcChi2NCls"), track.tpcChi2NCl()); - hrQaTrack.fill(HIST("QaTrack/hPtDcaXy"), quantityHolderTrack.pt, track.dcaXY()); - hrQaTrack.fill(HIST("QaTrack/hPtDcaZ"), quantityHolderTrack.pt, track.dcaZ()); + hrQaTrack.fill(HIST("QaTrack/hPtDcaXy"), holderTrack.pt, track.dcaXY()); + hrQaTrack.fill(HIST("QaTrack/hPtDcaZ"), holderTrack.pt, track.dcaZ()); if (track.isPVContributor()) { - hrQaTrack.fill(HIST("QaTrack/hPtDcaXy_pvContributor"), quantityHolderTrack.pt, track.dcaXY()); - hrQaTrack.fill(HIST("QaTrack/hPtDcaZ_pvContributor"), quantityHolderTrack.pt, track.dcaZ()); + hrQaTrack.fill(HIST("QaTrack/hPtDcaXy_pvContributor"), holderTrack.pt, track.dcaXY()); + hrQaTrack.fill(HIST("QaTrack/hPtDcaZ_pvContributor"), holderTrack.pt, track.dcaZ()); } } } @@ -1222,16 +1370,14 @@ struct PartNumFluc { } if constexpr (doProcessingMc && doInitingEvent) { - if ((cfgFlagCalculationEfficiencyPi.value || cfgFlagCalculationEfficiencyKa.value || cfgFlagCalculationEfficiencyPr.value) && quantityHolderTrack.hasTpcPid) { + if ((cfgFlagCalculationEfficiencyPi.value || cfgFlagCalculationEfficiencyKa.value || cfgFlagCalculationEfficiencyPr.value) && holderTrack.hasTpcPid) { if (cfgFlagCalculationEfficiencyPi.value) { switch (isPi()) { case 1: - quantityHolderEvent.mcParticleIndicesMatchedTpcPiP.push_back(quantityHolderTrack.mcParticleId); + holderEvent.mcParticleIndicesMatchedTpcPiP.push_back(holderTrack.mcParticleId); break; case -1: - quantityHolderEvent.mcParticleIndicesMatchedTpcPiM.push_back(quantityHolderTrack.mcParticleId); - break; - default: + holderEvent.mcParticleIndicesMatchedTpcPiM.push_back(holderTrack.mcParticleId); break; } } @@ -1239,12 +1385,10 @@ struct PartNumFluc { if (cfgFlagCalculationEfficiencyKa.value) { switch (isKa()) { case 1: - quantityHolderEvent.mcParticleIndicesMatchedTpcKaP.push_back(quantityHolderTrack.mcParticleId); + holderEvent.mcParticleIndicesMatchedTpcKaP.push_back(holderTrack.mcParticleId); break; case -1: - quantityHolderEvent.mcParticleIndicesMatchedTpcKaM.push_back(quantityHolderTrack.mcParticleId); - break; - default: + holderEvent.mcParticleIndicesMatchedTpcKaM.push_back(holderTrack.mcParticleId); break; } } @@ -1252,26 +1396,22 @@ struct PartNumFluc { if (cfgFlagCalculationEfficiencyPr.value) { switch (isPr()) { case 1: - quantityHolderEvent.mcParticleIndicesMatchedTpcPrP.push_back(quantityHolderTrack.mcParticleId); + holderEvent.mcParticleIndicesMatchedTpcPrP.push_back(holderTrack.mcParticleId); break; case -1: - quantityHolderEvent.mcParticleIndicesMatchedTpcPrM.push_back(quantityHolderTrack.mcParticleId); - break; - default: + holderEvent.mcParticleIndicesMatchedTpcPrM.push_back(holderTrack.mcParticleId); break; } } - if (quantityHolderTrack.hasTofPid) { + if (holderTrack.hasTofPid) { if (cfgFlagCalculationEfficiencyPi.value) { switch (isPi()) { case 1: - quantityHolderEvent.mcParticleIndicesMatchedTpcTofPiP.push_back(quantityHolderTrack.mcParticleId); + holderEvent.mcParticleIndicesMatchedTpcTofPiP.push_back(holderTrack.mcParticleId); break; case -1: - quantityHolderEvent.mcParticleIndicesMatchedTpcTofPiM.push_back(quantityHolderTrack.mcParticleId); - break; - default: + holderEvent.mcParticleIndicesMatchedTpcTofPiM.push_back(holderTrack.mcParticleId); break; } } @@ -1279,12 +1419,10 @@ struct PartNumFluc { if (cfgFlagCalculationEfficiencyKa.value) { switch (isKa()) { case 1: - quantityHolderEvent.mcParticleIndicesMatchedTpcTofKaP.push_back(quantityHolderTrack.mcParticleId); + holderEvent.mcParticleIndicesMatchedTpcTofKaP.push_back(holderTrack.mcParticleId); break; case -1: - quantityHolderEvent.mcParticleIndicesMatchedTpcTofKaM.push_back(quantityHolderTrack.mcParticleId); - break; - default: + holderEvent.mcParticleIndicesMatchedTpcTofKaM.push_back(holderTrack.mcParticleId); break; } } @@ -1292,12 +1430,10 @@ struct PartNumFluc { if (cfgFlagCalculationEfficiencyPr.value) { switch (isPr()) { case 1: - quantityHolderEvent.mcParticleIndicesMatchedTpcTofPrP.push_back(quantityHolderTrack.mcParticleId); + holderEvent.mcParticleIndicesMatchedTpcTofPrP.push_back(holderTrack.mcParticleId); break; case -1: - quantityHolderEvent.mcParticleIndicesMatchedTpcTofPrM.push_back(quantityHolderTrack.mcParticleId); - break; - default: + holderEvent.mcParticleIndicesMatchedTpcTofPrM.push_back(holderTrack.mcParticleId); break; } } @@ -1306,61 +1442,55 @@ struct PartNumFluc { } if constexpr (!doProcessingMc && !doInitingEvent) { - if (cfgFlagQaAcceptance.value && ((quantityHolderTrack.eta > 0. && quantityHolderEvent.vz > cfgCutMaxAbsVertexZ.value - 0.5) || (quantityHolderTrack.eta < 0. && quantityHolderEvent.vz < -cfgCutMaxAbsVertexZ.value + 0.5)) && quantityHolderTrack.hasTpcPid) { - hrQaAcceptance.fill(HIST("QaAcceptance/hEtaPt_tpc"), quantityHolderTrack.eta, quantityHolderTrack.pt); - hrQaAcceptance.fill(HIST("QaAcceptance/hPhi_tpc"), quantityHolderTrack.phi); + if (cfgFlagQaAcceptance.value && ((holderTrack.eta > 0. && holderEvent.vz > cfgCutMaxAbsVertexZ.value - 0.5) || (holderTrack.eta < 0. && holderEvent.vz < -cfgCutMaxAbsVertexZ.value + 0.5)) && holderTrack.hasTpcPid) { + hrQaAcceptance.fill(HIST("QaAcceptance/hEtaPt_tpc"), holderTrack.eta, holderTrack.pt); + hrQaAcceptance.fill(HIST("QaAcceptance/hPhi_tpc"), holderTrack.phi); if (std::abs(isPi()) == 1) { - hrQaAcceptance.fill(HIST("QaAcceptance/hYPt_tpcPi"), quantityHolderTrack.rapidityPi, quantityHolderTrack.pt); + hrQaAcceptance.fill(HIST("QaAcceptance/hYPt_tpcPi"), holderTrack.rapidityPi, holderTrack.pt); } if (std::abs(isKa()) == 1) { - hrQaAcceptance.fill(HIST("QaAcceptance/hYPt_tpcKa"), quantityHolderTrack.rapidityKa, quantityHolderTrack.pt); + hrQaAcceptance.fill(HIST("QaAcceptance/hYPt_tpcKa"), holderTrack.rapidityKa, holderTrack.pt); } if (std::abs(isPr()) == 1) { - hrQaAcceptance.fill(HIST("QaAcceptance/hYPt_tpcPr"), quantityHolderTrack.rapidityPr, quantityHolderTrack.pt); + hrQaAcceptance.fill(HIST("QaAcceptance/hYPt_tpcPr"), holderTrack.rapidityPr, holderTrack.pt); } - if (quantityHolderTrack.hasTofPid) { - hrQaAcceptance.fill(HIST("QaAcceptance/hEtaPt_tpcTof"), quantityHolderTrack.eta, quantityHolderTrack.pt); - hrQaAcceptance.fill(HIST("QaAcceptance/hPhi_tpcTof"), quantityHolderTrack.phi); + if (holderTrack.hasTofPid) { + hrQaAcceptance.fill(HIST("QaAcceptance/hEtaPt_tpcTof"), holderTrack.eta, holderTrack.pt); + hrQaAcceptance.fill(HIST("QaAcceptance/hPhi_tpcTof"), holderTrack.phi); if (std::abs(isPi()) == 1) { - hrQaAcceptance.fill(HIST("QaAcceptance/hYPt_tpcTofPi"), quantityHolderTrack.rapidityPi, quantityHolderTrack.pt); + hrQaAcceptance.fill(HIST("QaAcceptance/hYPt_tpcTofPi"), holderTrack.rapidityPi, holderTrack.pt); } if (std::abs(isKa()) == 1) { - hrQaAcceptance.fill(HIST("QaAcceptance/hYPt_tpcTofKa"), quantityHolderTrack.rapidityKa, quantityHolderTrack.pt); + hrQaAcceptance.fill(HIST("QaAcceptance/hYPt_tpcTofKa"), holderTrack.rapidityKa, holderTrack.pt); } if (std::abs(isPr()) == 1) { - hrQaAcceptance.fill(HIST("QaAcceptance/hYPt_tpcTofPr"), quantityHolderTrack.rapidityPr, quantityHolderTrack.pt); + hrQaAcceptance.fill(HIST("QaAcceptance/hYPt_tpcTofPr"), holderTrack.rapidityPr, holderTrack.pt); } } } - if (cfgFlagQaPid.value && quantityHolderTrack.hasTpcPid) { - hrQaPid.fill(HIST("QaPid/hPOverQEtaTpcLnDeDx"), quantityHolderTrack.pOverQ, quantityHolderTrack.eta, std::log(track.tpcSignal())); - hrQaPid.fill(HIST("QaPid/hPtOverQEtaTpcNSigmaPi"), quantityHolderTrack.ptOverQ, quantityHolderTrack.eta, quantityHolderTrack.tpcNSigmaPi); - if (std::fabs(quantityHolderTrack.tofNSigmaPi) < cfgCutMaxAbsNSigmaPid.value) { - hrQaPid.fill(HIST("QaPid/hPtOverQEtaTpcNSigmaPi_tofPi"), quantityHolderTrack.ptOverQ, quantityHolderTrack.eta, quantityHolderTrack.tpcNSigmaPi); + if (cfgFlagQaPid.value && holderTrack.hasTpcPid) { + hrQaPid.fill(HIST("QaPid/hCentralityPOverQEtaTpcLnDeDx"), holderEvent.centrality, holderTrack.pOverQ, holderTrack.eta, std::log(track.tpcSignal())); + if (std::fabs(holderTrack.tofNSigmaPi) < cfgCutMaxAbsNSigmaPid.value) { + hrQaPid.fill(HIST("QaPid/hCentralityPtOverQEtaTpcNSigmaPi_tofPi"), holderEvent.centrality, holderTrack.ptOverQ, holderTrack.eta, holderTrack.tpcNSigmaPi); } - hrQaPid.fill(HIST("QaPid/hPtOverQEtaTpcNSigmaKa"), quantityHolderTrack.ptOverQ, quantityHolderTrack.eta, quantityHolderTrack.tpcNSigmaKa); - if (std::fabs(quantityHolderTrack.tofNSigmaKa) < cfgCutMaxAbsNSigmaPid.value) { - hrQaPid.fill(HIST("QaPid/hPtOverQEtaTpcNSigmaKa_tofKa"), quantityHolderTrack.ptOverQ, quantityHolderTrack.eta, quantityHolderTrack.tpcNSigmaKa); + if (std::fabs(holderTrack.tofNSigmaKa) < cfgCutMaxAbsNSigmaPid.value) { + hrQaPid.fill(HIST("QaPid/hCentralityPtOverQEtaTpcNSigmaKa_tofKa"), holderEvent.centrality, holderTrack.ptOverQ, holderTrack.eta, holderTrack.tpcNSigmaKa); } - hrQaPid.fill(HIST("QaPid/hPtOverQEtaTpcNSigmaPr"), quantityHolderTrack.ptOverQ, quantityHolderTrack.eta, quantityHolderTrack.tpcNSigmaPr); - if (std::fabs(quantityHolderTrack.tofNSigmaPr) < cfgCutMaxAbsNSigmaPid.value) { - hrQaPid.fill(HIST("QaPid/hPtOverQEtaTpcNSigmaPr_tofPr"), quantityHolderTrack.ptOverQ, quantityHolderTrack.eta, quantityHolderTrack.tpcNSigmaPr); + if (std::fabs(holderTrack.tofNSigmaPr) < cfgCutMaxAbsNSigmaPid.value) { + hrQaPid.fill(HIST("QaPid/hCentralityPtOverQEtaTpcNSigmaPr_tofPr"), holderEvent.centrality, holderTrack.ptOverQ, holderTrack.eta, holderTrack.tpcNSigmaPr); } if (track.beta() > 0.) { - hrQaPid.fill(HIST("QaPid/hPOverQEtaTofInverseBeta"), quantityHolderTrack.pOverQ, quantityHolderTrack.eta, 1. / track.beta()); - if (std::fabs(quantityHolderTrack.tpcNSigmaPi) < cfgCutMaxAbsNSigmaPid.value) { - hrQaPid.fill(HIST("QaPid/hPtOverQEtaTofNSigmaPi_tpcPi"), quantityHolderTrack.ptOverQ, quantityHolderTrack.eta, quantityHolderTrack.tofNSigmaPi); + hrQaPid.fill(HIST("QaPid/hCentralityPOverQEtaTofInverseBeta"), holderEvent.centrality, holderTrack.pOverQ, holderTrack.eta, 1. / track.beta()); + if (std::fabs(holderTrack.tpcNSigmaPi) < cfgCutMaxAbsNSigmaPid.value) { + hrQaPid.fill(HIST("QaPid/hCentralityPtOverQEtaTofNSigmaPi_tpcPi"), holderEvent.centrality, holderTrack.ptOverQ, holderTrack.eta, holderTrack.tofNSigmaPi); } - if (std::fabs(quantityHolderTrack.tpcNSigmaKa) < cfgCutMaxAbsNSigmaPid.value) { - hrQaPid.fill(HIST("QaPid/hPtOverQEtaTofNSigmaKa_tpcKa"), quantityHolderTrack.ptOverQ, quantityHolderTrack.eta, quantityHolderTrack.tofNSigmaKa); + if (std::fabs(holderTrack.tpcNSigmaKa) < cfgCutMaxAbsNSigmaPid.value) { + hrQaPid.fill(HIST("QaPid/hCentralityPtOverQEtaTofNSigmaKa_tpcKa"), holderEvent.centrality, holderTrack.ptOverQ, holderTrack.eta, holderTrack.tofNSigmaKa); } - if (std::fabs(quantityHolderTrack.tpcNSigmaPr) < cfgCutMaxAbsNSigmaPid.value) { - hrQaPid.fill(HIST("QaPid/hPtOverQEtaTofNSigmaPr_tpcPr"), quantityHolderTrack.ptOverQ, quantityHolderTrack.eta, quantityHolderTrack.tofNSigmaPr); + if (std::fabs(holderTrack.tpcNSigmaPr) < cfgCutMaxAbsNSigmaPid.value) { + hrQaPid.fill(HIST("QaPid/hCentralityPtOverQEtaTofNSigmaPr_tpcPr"), holderEvent.centrality, holderTrack.ptOverQ, holderTrack.eta, holderTrack.tofNSigmaPr); } - hrQaPid.fill(HIST("QaPid/hPtOverQEtaTpcTofNSigmaPi"), quantityHolderTrack.ptOverQ, quantityHolderTrack.eta, quantityHolderTrack.tpcTofNSigmaPi); - hrQaPid.fill(HIST("QaPid/hPtOverQEtaTpcTofNSigmaKa"), quantityHolderTrack.ptOverQ, quantityHolderTrack.eta, quantityHolderTrack.tpcTofNSigmaKa); - hrQaPid.fill(HIST("QaPid/hPtOverQEtaTpcTofNSigmaPr"), quantityHolderTrack.ptOverQ, quantityHolderTrack.eta, quantityHolderTrack.tpcTofNSigmaPr); } } } @@ -1371,7 +1501,23 @@ struct PartNumFluc { template bool initEvent(const C& collision, const Ts& tracks) { - quantityHolderEvent.clear(); + holderEvent.clear(); + holderEvent.vz = collision.posZ(); + holderEvent.vzBinIndex = std::llrint(std::floor(holderEvent.vz - std::floor(-cfgCutMaxAbsVertexZ.value))); + switch (cfgIndexDefinitionCentrality) { + default: + holderEvent.centrality = collision.centFV0A(); + break; + case static_cast(CentralityDefinitionIndices::kFT0M): + holderEvent.centrality = collision.centFT0M(); + break; + case static_cast(CentralityDefinitionIndices::kFT0A): + holderEvent.centrality = collision.centFT0A(); + break; + case static_cast(CentralityDefinitionIndices::kFT0C): + holderEvent.centrality = collision.centFT0C(); + break; + } hrCounter.fill(HIST("hNEvents"), 0.); @@ -1381,15 +1527,15 @@ struct PartNumFluc { } const auto& bc = collision.template bc_as(); - quantityHolderEvent.runNumber = bc.runNumber(); - quantityHolderEvent.runIndex = std::distance(runNumbers.begin(), std::ranges::find(runNumbers, quantityHolderEvent.runNumber)); + holderEvent.runNumber = bc.runNumber(); + holderEvent.runIndex = std::distance(holderCcdb.runNumbers.begin(), std::ranges::find(holderCcdb.runNumbers, holderEvent.runNumber)); - if (std::ranges::find(runNumbers, quantityHolderEvent.runNumber) == runNumbers.end() || std::ranges::find(runNumbersBad, quantityHolderEvent.runNumber) != runNumbersBad.end()) { + if (std::ranges::find(holderCcdb.runNumbers, holderEvent.runNumber) == holderCcdb.runNumbers.end() || std::ranges::find(holderCcdb.runNumbersBad, holderEvent.runNumber) != holderCcdb.runNumbersBad.end()) { hrCounter.fill(HIST("hNEvents"), 2.); return false; } - for (std::int32_t const& iEvSel : std::views::iota(0, aod::evsel::kNsel)) { + for (std::int32_t const& iEvSel : std::views::iota(0, aod::evsel::EventSelectionFlags::kNsel)) { if (((cfgFlagSelectionEvent.value >> iEvSel) & 1) && !collision.selection_bit(iEvSel)) { hrCounter.fill(HIST("hNEvents"), 3); hrCounter.fill(HIST("hNEvents"), 10 + iEvSel); @@ -1397,67 +1543,69 @@ struct PartNumFluc { } } - quantityHolderEvent.vz = collision.posZ(); - if constexpr (!doProcessingMc) { if (cfgFlagQaEvent.value) { - hrQaEvent.fill(HIST("QaEvent/hRunIndexVxVy"), quantityHolderEvent.runIndex, collision.posX(), collision.posY()); - hrQaEvent.fill(HIST("QaEvent/hRunIndexVz"), quantityHolderEvent.runIndex, quantityHolderEvent.vz); + hrQaEvent.fill(HIST("QaEvent/hRunIndexVxVy"), holderEvent.runIndex, collision.posX(), collision.posY()); + hrQaEvent.fill(HIST("QaEvent/hRunIndexVz"), holderEvent.runIndex, holderEvent.vz); } } - if (!(std::fabs(quantityHolderEvent.vz) < cfgCutMaxAbsVertexZ.value)) { + if (!(std::fabs(holderEvent.vz) < cfgCutMaxAbsVertexZ.value)) { hrCounter.fill(HIST("hNEvents"), 4); return false; } if constexpr (!doProcessingMc) { if (cfgFlagQaRun.value) { - hrQaRun.fill(HIST("QaRun/pRunIndexVx"), quantityHolderEvent.runIndex, collision.posX()); - hrQaRun.fill(HIST("QaRun/pRunIndexVy"), quantityHolderEvent.runIndex, collision.posY()); - hrQaRun.fill(HIST("QaRun/pRunIndexVz"), quantityHolderEvent.runIndex, quantityHolderEvent.vz); - hrQaRun.fill(HIST("QaRun/pRunIndexMultFv0a"), quantityHolderEvent.runIndex, collision.multZeqFV0A()); - hrQaRun.fill(HIST("QaRun/pRunIndexMultFt0a"), quantityHolderEvent.runIndex, collision.multZeqFT0A()); - hrQaRun.fill(HIST("QaRun/pRunIndexMultFt0c"), quantityHolderEvent.runIndex, collision.multZeqFT0C()); + hrQaRun.fill(HIST("QaRun/pRunIndexVx"), holderEvent.runIndex, collision.posX()); + hrQaRun.fill(HIST("QaRun/pRunIndexVy"), holderEvent.runIndex, collision.posY()); + hrQaRun.fill(HIST("QaRun/pRunIndexVz"), holderEvent.runIndex, holderEvent.vz); + hrQaRun.fill(HIST("QaRun/pRunIndexMultFv0a"), holderEvent.runIndex, collision.multZeqFV0A()); + hrQaRun.fill(HIST("QaRun/pRunIndexMultFt0a"), holderEvent.runIndex, collision.multZeqFT0A()); + hrQaRun.fill(HIST("QaRun/pRunIndexMultFt0c"), holderEvent.runIndex, collision.multZeqFT0C()); } } for (const auto& track : tracks) { + if (!track.has_collision()) { + continue; + } + initTrack(track); } - if (quantityHolderEvent.nGlobalTracks > 0.) { - quantityHolderEvent.meanDcaXy /= quantityHolderEvent.nGlobalTracks; - quantityHolderEvent.meanSquareDcaXy /= quantityHolderEvent.nGlobalTracks; - quantityHolderEvent.meanDcaZ /= quantityHolderEvent.nGlobalTracks; - quantityHolderEvent.meanSquareDcaZ /= quantityHolderEvent.nGlobalTracks; + if (holderEvent.nGlobalTracks > 0.) { + holderEvent.meanDcaXy /= holderEvent.nGlobalTracks; + holderEvent.meanSquareDcaXy /= holderEvent.nGlobalTracks; + holderEvent.meanDcaZ /= holderEvent.nGlobalTracks; + holderEvent.meanSquareDcaZ /= holderEvent.nGlobalTracks; } if constexpr (!doProcessingMc) { if (cfgFlagQaRun.value) { - hrQaRun.fill(HIST("QaRun/pRunIndexNGlobalTracks"), quantityHolderEvent.runIndex, quantityHolderEvent.nGlobalTracks); - hrQaRun.fill(HIST("QaRun/pRunIndexNPvContributors"), quantityHolderEvent.runIndex, quantityHolderEvent.nPvContributors); - hrQaRun.fill(HIST("QaRun/pRunIndexNTofBeta"), quantityHolderEvent.runIndex, quantityHolderEvent.nTofBeta); - if (quantityHolderEvent.nGlobalTracks > 0) { - hrQaRun.fill(HIST("QaRun/pRunIndexMeanDcaXy"), quantityHolderEvent.runIndex, quantityHolderEvent.meanDcaXy); - hrQaRun.fill(HIST("QaRun/pRunIndexSigmaDcaXy"), quantityHolderEvent.runIndex, std::sqrt(quantityHolderEvent.meanSquareDcaXy - std::pow(quantityHolderEvent.meanDcaXy, 2.))); - hrQaRun.fill(HIST("QaRun/pRunIndexMeanDcaZ"), quantityHolderEvent.runIndex, quantityHolderEvent.meanDcaZ); - hrQaRun.fill(HIST("QaRun/pRunIndexSigmaDcaZ"), quantityHolderEvent.runIndex, std::sqrt(quantityHolderEvent.meanSquareDcaZ - std::pow(quantityHolderEvent.meanDcaZ, 2.))); + hrQaRun.fill(HIST("QaRun/pRunIndexNGlobalTracks"), holderEvent.runIndex, holderEvent.nGlobalTracks); + hrQaRun.fill(HIST("QaRun/pRunIndexNPvContributors"), holderEvent.runIndex, holderEvent.nPvContributors); + if (holderEvent.nGlobalTracks > 0) { + hrQaRun.fill(HIST("QaRun/pRunIndexMeanDcaXy"), holderEvent.runIndex, holderEvent.meanDcaXy); + hrQaRun.fill(HIST("QaRun/pRunIndexSigmaDcaXy"), holderEvent.runIndex, std::sqrt(holderEvent.meanSquareDcaXy - std::pow(holderEvent.meanDcaXy, 2.))); + hrQaRun.fill(HIST("QaRun/pRunIndexMeanDcaZ"), holderEvent.runIndex, holderEvent.meanDcaZ); + hrQaRun.fill(HIST("QaRun/pRunIndexSigmaDcaZ"), holderEvent.runIndex, std::sqrt(holderEvent.meanSquareDcaZ - std::pow(holderEvent.meanDcaZ, 2.))); } + hrQaRun.fill(HIST("QaRun/pRunIndexNTofBeta"), holderEvent.runIndex, holderEvent.nTofBeta); } } if constexpr (!doProcessingMc) { if (cfgFlagQaEvent.value) { - hrQaEvent.fill(HIST("QaEvent/hRunIndexNTofBetaNGlobalTracks"), quantityHolderEvent.runIndex, quantityHolderEvent.nTofBeta, quantityHolderEvent.nGlobalTracks); - hrQaEvent.fill(HIST("QaEvent/hRunIndexNPvContributorsNGlobalTracks"), quantityHolderEvent.runIndex, quantityHolderEvent.nPvContributors, quantityHolderEvent.nGlobalTracks); - if (quantityHolderEvent.nGlobalTracks > 0) { - hrQaEvent.fill(HIST("QaEvent/hRunIndexNGlobalTracksMeanDcaXy"), quantityHolderEvent.runIndex, quantityHolderEvent.nGlobalTracks, quantityHolderEvent.meanDcaXy); - hrQaEvent.fill(HIST("QaEvent/hRunIndexNGlobalTracksMeanDcaZ"), quantityHolderEvent.runIndex, quantityHolderEvent.nGlobalTracks, quantityHolderEvent.meanDcaZ); + hrQaEvent.fill(HIST("QaEvent/hRunIndexNPvContributorsNGlobalTracks"), holderEvent.runIndex, holderEvent.nPvContributors, holderEvent.nGlobalTracks); + if (holderEvent.nGlobalTracks > 0) { + hrQaEvent.fill(HIST("QaEvent/hRunIndexNGlobalTracksMeanDcaXy"), holderEvent.runIndex, holderEvent.nGlobalTracks, holderEvent.meanDcaXy); + hrQaEvent.fill(HIST("QaEvent/hRunIndexNGlobalTracksMeanDcaZ"), holderEvent.runIndex, holderEvent.nGlobalTracks, holderEvent.meanDcaZ); } + hrQaEvent.fill(HIST("QaEvent/hRunIndexNTofBetaNGlobalTracks"), holderEvent.runIndex, holderEvent.nTofBeta, holderEvent.nGlobalTracks); } } - if (!(quantityHolderEvent.nPvContributors - quantityHolderEvent.nGlobalTracks > cfgCutMinNPvContributorsDeviation.value)) { + if (!(holderEvent.nPvContributors - holderEvent.nGlobalTracks > cfgCutMinDeviationNPvContributors.value)) { hrCounter.fill(HIST("hNEvents"), 5); return false; } @@ -1466,335 +1614,322 @@ struct PartNumFluc { if constexpr (!doProcessingMc) { if (cfgFlagQaEvent.value) { - if (quantityHolderEvent.nGlobalTracks > 0) { - hrQaEvent.fill(HIST("QaEvent/hRunIndexNGlobalTracksMeanDcaXy_nPvContributorsCut"), quantityHolderEvent.runIndex, quantityHolderEvent.nGlobalTracks, quantityHolderEvent.meanDcaXy); - hrQaEvent.fill(HIST("QaEvent/hRunIndexNGlobalTracksMeanDcaZ_nPvContributorsCut"), quantityHolderEvent.runIndex, quantityHolderEvent.nGlobalTracks, quantityHolderEvent.meanDcaZ); + if (holderEvent.nGlobalTracks > 0) { + hrQaEvent.fill(HIST("QaEvent/hRunIndexNGlobalTracksMeanDcaXy_nPvContributorsCut"), holderEvent.runIndex, holderEvent.nGlobalTracks, holderEvent.meanDcaXy); + hrQaEvent.fill(HIST("QaEvent/hRunIndexNGlobalTracksMeanDcaZ_nPvContributorsCut"), holderEvent.runIndex, holderEvent.nGlobalTracks, holderEvent.meanDcaZ); } + hrQaEvent.fill(HIST("QaEvent/hRunIndexNTofBetaNGlobalTracks_nPvContributorsCut"), holderEvent.runIndex, holderEvent.nTofBeta, holderEvent.nGlobalTracks); } } - quantityHolderEvent.centrality = collision.centFT0M(); - if constexpr (!doProcessingMc) { if (cfgFlagQaCentrality.value) { hrQaCentrality.fill(HIST("QaCentrality/hCentralityFv0a"), collision.centFV0A(), collision.multZeqFV0A()); hrQaCentrality.fill(HIST("QaCentrality/hCentralityFt0a"), collision.centFT0A(), collision.multZeqFT0A()); hrQaCentrality.fill(HIST("QaCentrality/hCentralityFt0c"), collision.centFT0C(), collision.multZeqFT0C()); - hrQaCentrality.fill(HIST("QaCentrality/hCentralityFt0m"), quantityHolderEvent.centrality, collision.multZeqFT0A() + collision.multZeqFT0C()); + hrQaCentrality.fill(HIST("QaCentrality/hCentralityFt0m"), collision.centFT0M(), collision.multZeqFT0A() + collision.multZeqFT0C()); } } return true; } - void processRaw(const soa::Filtered::iterator& collision, const soa::Filtered& tracks, const aod::BCsWithTimestamps&) + void calculateFluctuation() { - if (!initEvent(collision, tracks)) { - return; - } - - if (!cfgFlagQaTrack.value && !cfgFlagQaAcceptance.value && !cfgFlagQaPid.value && !cfgFlagAnalysisFluctuationCh.value && !cfgFlagAnalysisFluctuationKa.value && !cfgFlagAnalysisFluctuationPr.value) { - return; - } - - if (cfgFlagAnalysisFluctuationCh.value || cfgFlagAnalysisFluctuationKa.value || cfgFlagAnalysisFluctuationPr.value) { - quantityHolderEvent.subgroupIndex = gRandom->Integer(cfgNSubgroups.value); - if (cfgFlagAnalysisFluctuationCh.value) { - fluctuationCalculatorTrackChP->init(); - fluctuationCalculatorTrackChM->init(); - fluctuationCalculatorTrackChT->init(); - fluctuationCalculatorTrackChN->init(); - } - if (cfgFlagAnalysisFluctuationKa.value) { - fluctuationCalculatorTrackKaP->init(); - fluctuationCalculatorTrackKaM->init(); - fluctuationCalculatorTrackKaT->init(); - fluctuationCalculatorTrackKaN->init(); - } - if (cfgFlagAnalysisFluctuationPr.value) { - fluctuationCalculatorTrackPrP->init(); - fluctuationCalculatorTrackPrM->init(); - fluctuationCalculatorTrackPrT->init(); - fluctuationCalculatorTrackPrN->init(); - } - } - for (const auto& track : tracks) { - if (!initTrack(track)) { - continue; - } - - if ((cfgFlagAnalysisFluctuationCh.value || cfgFlagAnalysisFluctuationKa.value || cfgFlagAnalysisFluctuationPr.value) && isGoodMomentum() && quantityHolderTrack.hasTpcPid) { - if (cfgFlagAnalysisFluctuationCh.value) { - if (quantityHolderTrack.pt < cfgThresholdPtTofPi.value) { - switch (isPi()) { - case 1: { - quantityHolderEvent.nChP++; - - const double efficiency = pVzPtEtaEfficiencyTpcPiP->GetBinContent(pVzPtEtaEfficiencyTpcPiP->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcPiP->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcPiP->GetZaxis()->FindBin(quantityHolderTrack.eta)); - - fluctuationCalculatorTrackChP->fill(1., efficiency); - fluctuationCalculatorTrackChT->fill(1., efficiency); - fluctuationCalculatorTrackChN->fill(1., efficiency); - } break; - case -1: { - quantityHolderEvent.nChM++; - - const double efficiency = pVzPtEtaEfficiencyTpcPiM->GetBinContent(pVzPtEtaEfficiencyTpcPiM->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcPiM->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcPiM->GetZaxis()->FindBin(quantityHolderTrack.eta)); - - fluctuationCalculatorTrackChM->fill(1., efficiency); - fluctuationCalculatorTrackChT->fill(1., efficiency); - fluctuationCalculatorTrackChN->fill(-1., efficiency); - } break; - default: - break; - } - } else if (quantityHolderTrack.hasTofPid) { - switch (isPi()) { - case 1: { - quantityHolderEvent.nChP++; + if (isGoodMomentum() && holderTrack.hasTpcPid) { + if (cfgFlagCalculationFluctuationCh.value) { + if (holderTrack.pt < cfgThresholdPtTofPi.value) { + switch (isPi()) { + case 1: { + holderEvent.nChP++; - const double efficiency = pVzPtEtaEfficiencyTpcTofPiP->GetBinContent(pVzPtEtaEfficiencyTpcTofPiP->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcTofPiP->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcTofPiP->GetZaxis()->FindBin(quantityHolderTrack.eta)); + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcPiP[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcPiP[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcPiP[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcPiP[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); - fluctuationCalculatorTrackChP->fill(1., efficiency); - fluctuationCalculatorTrackChT->fill(1., efficiency); - fluctuationCalculatorTrackChN->fill(1., efficiency); - } break; - case -1: { - quantityHolderEvent.nChM++; + fluctuationCalculatorTrackChP->fill(1., efficiency); + fluctuationCalculatorTrackChT->fill(1., efficiency); + fluctuationCalculatorTrackChN->fill(1., efficiency); + } break; + case -1: { + holderEvent.nChM++; - const double efficiency = pVzPtEtaEfficiencyTpcTofPiM->GetBinContent(pVzPtEtaEfficiencyTpcTofPiM->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcTofPiM->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcTofPiM->GetZaxis()->FindBin(quantityHolderTrack.eta)); + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcPiM[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcPiM[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcPiM[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcPiM[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); - fluctuationCalculatorTrackChM->fill(1., efficiency); - fluctuationCalculatorTrackChT->fill(1., efficiency); - fluctuationCalculatorTrackChN->fill(-1., efficiency); - } break; - default: - break; - } + fluctuationCalculatorTrackChM->fill(1., efficiency); + fluctuationCalculatorTrackChT->fill(1., efficiency); + fluctuationCalculatorTrackChN->fill(-1., efficiency); + } break; } - if (quantityHolderTrack.pt < cfgThresholdPtTofKa.value) { - switch (isKa()) { - case 1: { - quantityHolderEvent.nChP++; - - const double efficiency = pVzPtEtaEfficiencyTpcKaP->GetBinContent(pVzPtEtaEfficiencyTpcKaP->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcKaP->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcKaP->GetZaxis()->FindBin(quantityHolderTrack.eta)); - - fluctuationCalculatorTrackChP->fill(1., efficiency); - fluctuationCalculatorTrackChT->fill(1., efficiency); - fluctuationCalculatorTrackChN->fill(1., efficiency); - } break; - case -1: { - quantityHolderEvent.nChM++; - - const double efficiency = pVzPtEtaEfficiencyTpcKaM->GetBinContent(pVzPtEtaEfficiencyTpcKaM->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcKaM->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcKaM->GetZaxis()->FindBin(quantityHolderTrack.eta)); - - fluctuationCalculatorTrackChM->fill(1., efficiency); - fluctuationCalculatorTrackChT->fill(1., efficiency); - fluctuationCalculatorTrackChN->fill(-1., efficiency); - } break; - default: - break; - } - } else if (quantityHolderTrack.hasTofPid) { - switch (isKa()) { - case 1: { - quantityHolderEvent.nChP++; - - const double efficiency = pVzPtEtaEfficiencyTpcTofKaP->GetBinContent(pVzPtEtaEfficiencyTpcTofKaP->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcTofKaP->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcTofKaP->GetZaxis()->FindBin(quantityHolderTrack.eta)); - - fluctuationCalculatorTrackChP->fill(1., efficiency); - fluctuationCalculatorTrackChT->fill(1., efficiency); - fluctuationCalculatorTrackChN->fill(1., efficiency); - } break; - case -1: { - quantityHolderEvent.nChM++; - - const double efficiency = pVzPtEtaEfficiencyTpcTofKaM->GetBinContent(pVzPtEtaEfficiencyTpcTofKaM->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcTofKaM->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcTofKaM->GetZaxis()->FindBin(quantityHolderTrack.eta)); - - fluctuationCalculatorTrackChM->fill(1., efficiency); - fluctuationCalculatorTrackChT->fill(1., efficiency); - fluctuationCalculatorTrackChN->fill(-1., efficiency); - } break; - default: - break; - } + } else if (holderTrack.hasTofPid) { + switch (isPi()) { + case 1: { + holderEvent.nChP++; + + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcTofPiP[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcTofPiP[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcTofPiP[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcTofPiP[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); + + fluctuationCalculatorTrackChP->fill(1., efficiency); + fluctuationCalculatorTrackChT->fill(1., efficiency); + fluctuationCalculatorTrackChN->fill(1., efficiency); + } break; + case -1: { + holderEvent.nChM++; + + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcTofPiM[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcTofPiM[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcTofPiM[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcTofPiM[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); + + fluctuationCalculatorTrackChM->fill(1., efficiency); + fluctuationCalculatorTrackChT->fill(1., efficiency); + fluctuationCalculatorTrackChN->fill(-1., efficiency); + } break; } - if (quantityHolderTrack.pt < cfgThresholdPtTofPr.value) { - switch (isPr()) { - case 1: { - quantityHolderEvent.nChP++; - - const double efficiency = pVzPtEtaEfficiencyTpcPrP->GetBinContent(pVzPtEtaEfficiencyTpcPrP->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcPrP->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcPrP->GetZaxis()->FindBin(quantityHolderTrack.eta)); - - fluctuationCalculatorTrackChP->fill(1., efficiency); - fluctuationCalculatorTrackChT->fill(1., efficiency); - fluctuationCalculatorTrackChN->fill(1., efficiency); - } break; - case -1: { - quantityHolderEvent.nChM++; - - const double efficiency = pVzPtEtaEfficiencyTpcPrM->GetBinContent(pVzPtEtaEfficiencyTpcPrM->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcPrM->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcPrM->GetZaxis()->FindBin(quantityHolderTrack.eta)); - - fluctuationCalculatorTrackChM->fill(1., efficiency); - fluctuationCalculatorTrackChT->fill(1., efficiency); - fluctuationCalculatorTrackChN->fill(-1., efficiency); - } break; - default: - break; - } - } else if (quantityHolderTrack.hasTofPid) { - switch (isPr()) { - case 1: { - quantityHolderEvent.nChP++; + } + if (holderTrack.pt < cfgThresholdPtTofKa.value) { + switch (isKa()) { + case 1: { + holderEvent.nChP++; - const double efficiency = pVzPtEtaEfficiencyTpcTofPrP->GetBinContent(pVzPtEtaEfficiencyTpcTofPrP->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcTofPrP->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcTofPrP->GetZaxis()->FindBin(quantityHolderTrack.eta)); + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcKaP[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcKaP[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcKaP[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcKaP[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); - fluctuationCalculatorTrackChP->fill(1., efficiency); - fluctuationCalculatorTrackChT->fill(1., efficiency); - fluctuationCalculatorTrackChN->fill(1., efficiency); - } break; - case -1: { - quantityHolderEvent.nChM++; + fluctuationCalculatorTrackChP->fill(1., efficiency); + fluctuationCalculatorTrackChT->fill(1., efficiency); + fluctuationCalculatorTrackChN->fill(1., efficiency); + } break; + case -1: { + holderEvent.nChM++; - const double efficiency = pVzPtEtaEfficiencyTpcTofPrM->GetBinContent(pVzPtEtaEfficiencyTpcTofPrM->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcTofPrM->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcTofPrM->GetZaxis()->FindBin(quantityHolderTrack.eta)); + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcKaM[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcKaM[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcKaM[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcKaM[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); - fluctuationCalculatorTrackChM->fill(1., efficiency); - fluctuationCalculatorTrackChT->fill(1., efficiency); - fluctuationCalculatorTrackChN->fill(-1., efficiency); - } break; - default: - break; - } + fluctuationCalculatorTrackChM->fill(1., efficiency); + fluctuationCalculatorTrackChT->fill(1., efficiency); + fluctuationCalculatorTrackChN->fill(-1., efficiency); + } break; + } + } else if (holderTrack.hasTofPid) { + switch (isKa()) { + case 1: { + holderEvent.nChP++; + + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaP[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaP[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaP[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaP[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); + + fluctuationCalculatorTrackChP->fill(1., efficiency); + fluctuationCalculatorTrackChT->fill(1., efficiency); + fluctuationCalculatorTrackChN->fill(1., efficiency); + } break; + case -1: { + holderEvent.nChM++; + + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaM[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaM[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaM[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaM[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); + + fluctuationCalculatorTrackChM->fill(1., efficiency); + fluctuationCalculatorTrackChT->fill(1., efficiency); + fluctuationCalculatorTrackChN->fill(-1., efficiency); + } break; } } + if (holderTrack.pt < cfgThresholdPtTofPr.value) { + switch (isPr()) { + case 1: { + holderEvent.nChP++; - if (cfgFlagAnalysisFluctuationKa.value) { - if (quantityHolderTrack.pt < cfgThresholdPtTofKa.value) { - switch (isKa()) { - case 1: { - quantityHolderEvent.nKaP++; + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcPrP[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcPrP[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcPrP[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcPrP[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); - const double efficiency = pVzPtEtaEfficiencyTpcKaP->GetBinContent(pVzPtEtaEfficiencyTpcKaP->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcKaP->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcKaP->GetZaxis()->FindBin(quantityHolderTrack.eta)); + fluctuationCalculatorTrackChP->fill(1., efficiency); + fluctuationCalculatorTrackChT->fill(1., efficiency); + fluctuationCalculatorTrackChN->fill(1., efficiency); + } break; + case -1: { + holderEvent.nChM++; - fluctuationCalculatorTrackKaP->fill(1., efficiency); - fluctuationCalculatorTrackKaT->fill(1., efficiency); - fluctuationCalculatorTrackKaN->fill(1., efficiency); - } break; - case -1: { - quantityHolderEvent.nKaM++; + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcPrM[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcPrM[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcPrM[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcPrM[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); - const double efficiency = pVzPtEtaEfficiencyTpcKaM->GetBinContent(pVzPtEtaEfficiencyTpcKaM->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcKaM->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcKaM->GetZaxis()->FindBin(quantityHolderTrack.eta)); + fluctuationCalculatorTrackChM->fill(1., efficiency); + fluctuationCalculatorTrackChT->fill(1., efficiency); + fluctuationCalculatorTrackChN->fill(-1., efficiency); + } break; + } + } else if (holderTrack.hasTofPid) { + switch (isPr()) { + case 1: { + holderEvent.nChP++; + + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrP[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrP[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrP[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrP[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); + + fluctuationCalculatorTrackChP->fill(1., efficiency); + fluctuationCalculatorTrackChT->fill(1., efficiency); + fluctuationCalculatorTrackChN->fill(1., efficiency); + } break; + case -1: { + holderEvent.nChM++; + + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrM[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrM[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrM[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrM[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); + + fluctuationCalculatorTrackChM->fill(1., efficiency); + fluctuationCalculatorTrackChT->fill(1., efficiency); + fluctuationCalculatorTrackChN->fill(-1., efficiency); + } break; + } + } + } - fluctuationCalculatorTrackKaM->fill(1., efficiency); - fluctuationCalculatorTrackKaT->fill(1., efficiency); - fluctuationCalculatorTrackKaN->fill(-1., efficiency); - } break; - default: - break; - } - } else if (quantityHolderTrack.hasTofPid) { - switch (isKa()) { - case 1: { - quantityHolderEvent.nKaP++; + if (cfgFlagCalculationFluctuationKa.value) { + if (holderTrack.pt < cfgThresholdPtTofKa.value) { + switch (isKa()) { + case 1: { + holderEvent.nKaP++; - const double efficiency = pVzPtEtaEfficiencyTpcTofKaP->GetBinContent(pVzPtEtaEfficiencyTpcTofKaP->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcTofKaP->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcTofKaP->GetZaxis()->FindBin(quantityHolderTrack.eta)); + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcKaP[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcKaP[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcKaP[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcKaP[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); - fluctuationCalculatorTrackKaP->fill(1., efficiency); - fluctuationCalculatorTrackKaT->fill(1., efficiency); - fluctuationCalculatorTrackKaN->fill(1., efficiency); - } break; - case -1: { - quantityHolderEvent.nKaM++; + fluctuationCalculatorTrackKaP->fill(1., efficiency); + fluctuationCalculatorTrackKaT->fill(1., efficiency); + fluctuationCalculatorTrackKaN->fill(1., efficiency); + } break; + case -1: { + holderEvent.nKaM++; - const double efficiency = pVzPtEtaEfficiencyTpcTofKaM->GetBinContent(pVzPtEtaEfficiencyTpcTofKaM->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcTofKaM->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcTofKaM->GetZaxis()->FindBin(quantityHolderTrack.eta)); + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcKaM[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcKaM[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcKaM[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcKaM[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); - fluctuationCalculatorTrackKaM->fill(1., efficiency); - fluctuationCalculatorTrackKaT->fill(1., efficiency); - fluctuationCalculatorTrackKaN->fill(-1., efficiency); - } break; - default: - break; - } + fluctuationCalculatorTrackKaM->fill(1., efficiency); + fluctuationCalculatorTrackKaT->fill(1., efficiency); + fluctuationCalculatorTrackKaN->fill(-1., efficiency); + } break; + } + } else if (holderTrack.hasTofPid) { + switch (isKa()) { + case 1: { + holderEvent.nKaP++; + + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaP[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaP[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaP[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaP[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); + + fluctuationCalculatorTrackKaP->fill(1., efficiency); + fluctuationCalculatorTrackKaT->fill(1., efficiency); + fluctuationCalculatorTrackKaN->fill(1., efficiency); + } break; + case -1: { + holderEvent.nKaM++; + + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaM[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaM[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaM[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcTofKaM[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); + + fluctuationCalculatorTrackKaM->fill(1., efficiency); + fluctuationCalculatorTrackKaT->fill(1., efficiency); + fluctuationCalculatorTrackKaN->fill(-1., efficiency); + } break; } } + } - if (cfgFlagAnalysisFluctuationPr.value) { - if (quantityHolderTrack.pt < cfgThresholdPtTofPr.value) { - switch (isPr()) { - case 1: { - quantityHolderEvent.nPrP++; + if (cfgFlagCalculationFluctuationPr.value) { + if (holderTrack.pt < cfgThresholdPtTofPr.value) { + switch (isPr()) { + case 1: { + holderEvent.nPrP++; - const double efficiency = pVzPtEtaEfficiencyTpcPrP->GetBinContent(pVzPtEtaEfficiencyTpcPrP->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcPrP->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcPrP->GetZaxis()->FindBin(quantityHolderTrack.eta)); + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcPrP[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcPrP[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcPrP[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcPrP[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); - fluctuationCalculatorTrackPrP->fill(1., efficiency); - fluctuationCalculatorTrackPrT->fill(1., efficiency); - fluctuationCalculatorTrackPrN->fill(1., efficiency); - } break; - case -1: { - quantityHolderEvent.nPrM++; + fluctuationCalculatorTrackPrP->fill(1., efficiency); + fluctuationCalculatorTrackPrT->fill(1., efficiency); + fluctuationCalculatorTrackPrN->fill(1., efficiency); + } break; + case -1: { + holderEvent.nPrM++; - const double efficiency = pVzPtEtaEfficiencyTpcPrM->GetBinContent(pVzPtEtaEfficiencyTpcPrM->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcPrM->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcPrM->GetZaxis()->FindBin(quantityHolderTrack.eta)); + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcPrM[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcPrM[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcPrM[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcPrM[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); - fluctuationCalculatorTrackPrM->fill(1., efficiency); - fluctuationCalculatorTrackPrT->fill(1., efficiency); - fluctuationCalculatorTrackPrN->fill(-1., efficiency); - } break; - default: - break; - } - } else if (quantityHolderTrack.hasTofPid) { - switch (isPr()) { - case 1: { - quantityHolderEvent.nPrP++; + fluctuationCalculatorTrackPrM->fill(1., efficiency); + fluctuationCalculatorTrackPrT->fill(1., efficiency); + fluctuationCalculatorTrackPrN->fill(-1., efficiency); + } break; + } + } else if (holderTrack.hasTofPid) { + switch (isPr()) { + case 1: { + holderEvent.nPrP++; + + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrP[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrP[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrP[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrP[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); + + fluctuationCalculatorTrackPrP->fill(1., efficiency); + fluctuationCalculatorTrackPrT->fill(1., efficiency); + fluctuationCalculatorTrackPrN->fill(1., efficiency); + } break; + case -1: { + holderEvent.nPrM++; + + const double efficiency = holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrM[holderEvent.vzBinIndex]->GetBinContent(holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrM[holderEvent.vzBinIndex]->GetXaxis()->FindBin(holderEvent.centrality), holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrM[holderEvent.vzBinIndex]->GetYaxis()->FindBin(holderTrack.pt), holderCcdb.pCentralityPtEtaEfficiencyTpcTofPrM[holderEvent.vzBinIndex]->GetZaxis()->FindBin(holderTrack.eta)); + + fluctuationCalculatorTrackPrM->fill(1., efficiency); + fluctuationCalculatorTrackPrT->fill(1., efficiency); + fluctuationCalculatorTrackPrN->fill(-1., efficiency); + } break; + } + } + } + } + } - const double efficiency = pVzPtEtaEfficiencyTpcTofPrP->GetBinContent(pVzPtEtaEfficiencyTpcTofPrP->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcTofPrP->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcTofPrP->GetZaxis()->FindBin(quantityHolderTrack.eta)); + void processRaw(const soa::Filtered::iterator& collision, const soa::Filtered& tracks, const aod::BCsWithTimestamps&) + { + if (!initEvent(collision, tracks)) { + return; + } - fluctuationCalculatorTrackPrP->fill(1., efficiency); - fluctuationCalculatorTrackPrT->fill(1., efficiency); - fluctuationCalculatorTrackPrN->fill(1., efficiency); - } break; - case -1: { - quantityHolderEvent.nPrM++; + if (!cfgFlagQaTrack.value && !cfgFlagQaAcceptance.value && !cfgFlagQaPid.value && !cfgFlagCalculationFluctuationCh.value && !cfgFlagCalculationFluctuationKa.value && !cfgFlagCalculationFluctuationPr.value) { + return; + } + + if (cfgFlagCalculationFluctuationCh.value || cfgFlagCalculationFluctuationKa.value || cfgFlagCalculationFluctuationPr.value) { + holderEvent.subgroupIndex = gRandom->Integer(cfgNSubgroups.value); + if (cfgFlagCalculationFluctuationCh.value) { + fluctuationCalculatorTrackChP->init(); + fluctuationCalculatorTrackChM->init(); + fluctuationCalculatorTrackChT->init(); + fluctuationCalculatorTrackChN->init(); + } + if (cfgFlagCalculationFluctuationKa.value) { + fluctuationCalculatorTrackKaP->init(); + fluctuationCalculatorTrackKaM->init(); + fluctuationCalculatorTrackKaT->init(); + fluctuationCalculatorTrackKaN->init(); + } + if (cfgFlagCalculationFluctuationPr.value) { + fluctuationCalculatorTrackPrP->init(); + fluctuationCalculatorTrackPrM->init(); + fluctuationCalculatorTrackPrT->init(); + fluctuationCalculatorTrackPrN->init(); + } + } - const double efficiency = pVzPtEtaEfficiencyTpcTofPrM->GetBinContent(pVzPtEtaEfficiencyTpcTofPrM->GetXaxis()->FindBin(quantityHolderEvent.vz), pVzPtEtaEfficiencyTpcTofPrM->GetYaxis()->FindBin(quantityHolderTrack.pt), pVzPtEtaEfficiencyTpcTofPrM->GetZaxis()->FindBin(quantityHolderTrack.eta)); + for (const auto& track : tracks) { + if (!track.has_collision() || !initTrack(track)) { + continue; + } - fluctuationCalculatorTrackPrM->fill(1., efficiency); - fluctuationCalculatorTrackPrT->fill(1., efficiency); - fluctuationCalculatorTrackPrN->fill(-1., efficiency); - } break; - default: - break; - } - } - } + if (cfgFlagCalculationFluctuationCh.value || cfgFlagCalculationFluctuationKa.value || cfgFlagCalculationFluctuationPr.value) { + calculateFluctuation(); } } - if (cfgFlagAnalysisFluctuationCh.value) { - hrAnalysisFluctuation.fill(HIST("AnalysisFluctuation/hCentralityNChPNChM"), quantityHolderEvent.centrality, quantityHolderEvent.nChP, quantityHolderEvent.nChM); + if (cfgFlagCalculationFluctuationCh.value) { + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hCentralityNChPNChM"), holderEvent.centrality, holderEvent.nChP, holderEvent.nChM); for (std::int32_t const& iOrderVector : std::views::iota(0, static_cast(fluctuation_calculator_base::NOrderVectors))) { - hrAnalysisFluctuation.fill(HIST("AnalysisFluctuation/hFluctuationCalculatorChP"), quantityHolderEvent.centrality, quantityHolderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackChP->getProductFast(iOrderVector)); - hrAnalysisFluctuation.fill(HIST("AnalysisFluctuation/hFluctuationCalculatorChM"), quantityHolderEvent.centrality, quantityHolderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackChM->getProductFast(iOrderVector)); - hrAnalysisFluctuation.fill(HIST("AnalysisFluctuation/hFluctuationCalculatorChT"), quantityHolderEvent.centrality, quantityHolderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackChT->getProductFast(iOrderVector)); - hrAnalysisFluctuation.fill(HIST("AnalysisFluctuation/hFluctuationCalculatorChN"), quantityHolderEvent.centrality, quantityHolderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackChN->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorChP"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackChP->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorChM"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackChM->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorChT"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackChT->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorChN"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackChN->getProductFast(iOrderVector)); } } - if (cfgFlagAnalysisFluctuationKa.value) { - hrAnalysisFluctuation.fill(HIST("AnalysisFluctuation/hCentralityNKaPNKaM"), quantityHolderEvent.centrality, quantityHolderEvent.nKaP, quantityHolderEvent.nKaM); + if (cfgFlagCalculationFluctuationKa.value) { + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hCentralityNKaPNKaM"), holderEvent.centrality, holderEvent.nKaP, holderEvent.nKaM); for (std::int32_t const& iOrderVector : std::views::iota(0, static_cast(fluctuation_calculator_base::NOrderVectors))) { - hrAnalysisFluctuation.fill(HIST("AnalysisFluctuation/hFluctuationCalculatorKaP"), quantityHolderEvent.centrality, quantityHolderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackKaP->getProductFast(iOrderVector)); - hrAnalysisFluctuation.fill(HIST("AnalysisFluctuation/hFluctuationCalculatorKaM"), quantityHolderEvent.centrality, quantityHolderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackKaM->getProductFast(iOrderVector)); - hrAnalysisFluctuation.fill(HIST("AnalysisFluctuation/hFluctuationCalculatorKaT"), quantityHolderEvent.centrality, quantityHolderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackKaT->getProductFast(iOrderVector)); - hrAnalysisFluctuation.fill(HIST("AnalysisFluctuation/hFluctuationCalculatorKaN"), quantityHolderEvent.centrality, quantityHolderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackKaN->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorKaP"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackKaP->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorKaM"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackKaM->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorKaT"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackKaT->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorKaN"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackKaN->getProductFast(iOrderVector)); } } - if (cfgFlagAnalysisFluctuationPr.value) { - hrAnalysisFluctuation.fill(HIST("AnalysisFluctuation/hCentralityNPrPNPrM"), quantityHolderEvent.centrality, quantityHolderEvent.nPrP, quantityHolderEvent.nPrM); + if (cfgFlagCalculationFluctuationPr.value) { + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hCentralityNPrPNPrM"), holderEvent.centrality, holderEvent.nPrP, holderEvent.nPrM); for (std::int32_t const& iOrderVector : std::views::iota(0, static_cast(fluctuation_calculator_base::NOrderVectors))) { - hrAnalysisFluctuation.fill(HIST("AnalysisFluctuation/hFluctuationCalculatorPrP"), quantityHolderEvent.centrality, quantityHolderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackPrP->getProductFast(iOrderVector)); - hrAnalysisFluctuation.fill(HIST("AnalysisFluctuation/hFluctuationCalculatorPrM"), quantityHolderEvent.centrality, quantityHolderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackPrM->getProductFast(iOrderVector)); - hrAnalysisFluctuation.fill(HIST("AnalysisFluctuation/hFluctuationCalculatorPrT"), quantityHolderEvent.centrality, quantityHolderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackPrT->getProductFast(iOrderVector)); - hrAnalysisFluctuation.fill(HIST("AnalysisFluctuation/hFluctuationCalculatorPrN"), quantityHolderEvent.centrality, quantityHolderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackPrN->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorPrP"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackPrP->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorPrM"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackPrM->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorPrT"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackPrT->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorPrN"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackPrN->getProductFast(iOrderVector)); } } } @@ -1813,29 +1948,140 @@ struct PartNumFluc { continue; } - if ((cfgFlagCalculationPurityPi.value || cfgFlagCalculationPurityKa.value || cfgFlagCalculationPurityPr.value)) { + if (cfgFlagCalculationEfficiencyPi.value || cfgFlagCalculationEfficiencyKa.value || cfgFlagCalculationEfficiencyPr.value || cfgFlagCalculationFluctuationCh.value || cfgFlagCalculationFluctuationKa.value || cfgFlagCalculationFluctuationPr.value) { + for (const auto& mcParticle : mcParticles) { + if (!initMcParticle(mcParticle)) { + continue; + } + + switch (holderMcParticle.pdgCode) { + case PDG_t::kPiPlus: + if (cfgFlagCalculationEfficiencyPi.value) { + pCentralityPtEtaEfficiencyTpcPiP[holderEvent.vzBinIndex]->Fill(holderEvent.centrality, holderMcParticle.pt, holderMcParticle.eta, std::ranges::find(holderEvent.mcParticleIndicesMatchedTpcPiP, holderMcParticle.globalIndex) != holderEvent.mcParticleIndicesMatchedTpcPiP.end() ? 1. : 0.); + pCentralityPtEtaEfficiencyTpcTofPiP[holderEvent.vzBinIndex]->Fill(holderEvent.centrality, holderMcParticle.pt, holderMcParticle.eta, std::ranges::find(holderEvent.mcParticleIndicesMatchedTpcTofPiP, holderMcParticle.globalIndex) != holderEvent.mcParticleIndicesMatchedTpcTofPiP.end() ? 1. : 0.); + } + if (cfgFlagCalculationFluctuationCh.value) { + holderEvent.nChPGenerated++; + } + break; + case PDG_t::kPiMinus: + if (cfgFlagCalculationEfficiencyPi.value) { + pCentralityPtEtaEfficiencyTpcPiM[holderEvent.vzBinIndex]->Fill(holderEvent.centrality, holderMcParticle.pt, holderMcParticle.eta, std::ranges::find(holderEvent.mcParticleIndicesMatchedTpcPiM, holderMcParticle.globalIndex) != holderEvent.mcParticleIndicesMatchedTpcPiM.end() ? 1. : 0.); + pCentralityPtEtaEfficiencyTpcTofPiM[holderEvent.vzBinIndex]->Fill(holderEvent.centrality, holderMcParticle.pt, holderMcParticle.eta, std::ranges::find(holderEvent.mcParticleIndicesMatchedTpcTofPiM, holderMcParticle.globalIndex) != holderEvent.mcParticleIndicesMatchedTpcTofPiM.end() ? 1. : 0.); + } + if (cfgFlagCalculationFluctuationCh.value) { + holderEvent.nChMGenerated++; + } + break; + case PDG_t::kKPlus: + if (cfgFlagCalculationEfficiencyKa.value) { + pCentralityPtEtaEfficiencyTpcKaP[holderEvent.vzBinIndex]->Fill(holderEvent.centrality, holderMcParticle.pt, holderMcParticle.eta, std::ranges::find(holderEvent.mcParticleIndicesMatchedTpcKaP, holderMcParticle.globalIndex) != holderEvent.mcParticleIndicesMatchedTpcKaP.end() ? 1. : 0.); + pCentralityPtEtaEfficiencyTpcTofKaP[holderEvent.vzBinIndex]->Fill(holderEvent.centrality, holderMcParticle.pt, holderMcParticle.eta, std::ranges::find(holderEvent.mcParticleIndicesMatchedTpcTofKaP, holderMcParticle.globalIndex) != holderEvent.mcParticleIndicesMatchedTpcTofKaP.end() ? 1. : 0.); + } + if (cfgFlagCalculationFluctuationCh.value) { + holderEvent.nChPGenerated++; + } + if (cfgFlagCalculationFluctuationKa.value) { + holderEvent.nKaPGenerated++; + } + break; + case PDG_t::kKMinus: + if (cfgFlagCalculationEfficiencyKa.value) { + pCentralityPtEtaEfficiencyTpcKaM[holderEvent.vzBinIndex]->Fill(holderEvent.centrality, holderMcParticle.pt, holderMcParticle.eta, std::ranges::find(holderEvent.mcParticleIndicesMatchedTpcKaM, holderMcParticle.globalIndex) != holderEvent.mcParticleIndicesMatchedTpcKaM.end() ? 1. : 0.); + pCentralityPtEtaEfficiencyTpcTofKaM[holderEvent.vzBinIndex]->Fill(holderEvent.centrality, holderMcParticle.pt, holderMcParticle.eta, std::ranges::find(holderEvent.mcParticleIndicesMatchedTpcTofKaM, holderMcParticle.globalIndex) != holderEvent.mcParticleIndicesMatchedTpcTofKaM.end() ? 1. : 0.); + } + if (cfgFlagCalculationFluctuationCh.value) { + holderEvent.nChMGenerated++; + } + if (cfgFlagCalculationFluctuationKa.value) { + holderEvent.nKaMGenerated++; + } + break; + case PDG_t::kProton: + if (cfgFlagCalculationEfficiencyPr.value) { + pCentralityPtEtaEfficiencyTpcPrP[holderEvent.vzBinIndex]->Fill(holderEvent.centrality, holderMcParticle.pt, holderMcParticle.eta, std::ranges::find(holderEvent.mcParticleIndicesMatchedTpcPrP, holderMcParticle.globalIndex) != holderEvent.mcParticleIndicesMatchedTpcPrP.end() ? 1. : 0.); + pCentralityPtEtaEfficiencyTpcTofPrP[holderEvent.vzBinIndex]->Fill(holderEvent.centrality, holderMcParticle.pt, holderMcParticle.eta, std::ranges::find(holderEvent.mcParticleIndicesMatchedTpcTofPrP, holderMcParticle.globalIndex) != holderEvent.mcParticleIndicesMatchedTpcTofPrP.end() ? 1. : 0.); + } + if (cfgFlagCalculationFluctuationCh.value) { + holderEvent.nChPGenerated++; + } + if (cfgFlagCalculationFluctuationPr.value) { + holderEvent.nPrPGenerated++; + } + break; + case PDG_t::kProtonBar: + if (cfgFlagCalculationEfficiencyPr.value) { + pCentralityPtEtaEfficiencyTpcPrM[holderEvent.vzBinIndex]->Fill(holderEvent.centrality, holderMcParticle.pt, holderMcParticle.eta, std::ranges::find(holderEvent.mcParticleIndicesMatchedTpcPrM, holderMcParticle.globalIndex) != holderEvent.mcParticleIndicesMatchedTpcPrM.end() ? 1. : 0.); + pCentralityPtEtaEfficiencyTpcTofPrM[holderEvent.vzBinIndex]->Fill(holderEvent.centrality, holderMcParticle.pt, holderMcParticle.eta, std::ranges::find(holderEvent.mcParticleIndicesMatchedTpcTofPrM, holderMcParticle.globalIndex) != holderEvent.mcParticleIndicesMatchedTpcTofPrM.end() ? 1. : 0.); + } + if (cfgFlagCalculationFluctuationCh.value) { + holderEvent.nChMGenerated++; + } + if (cfgFlagCalculationFluctuationPr.value) { + holderEvent.nPrMGenerated++; + } + break; + } + } + + if (cfgFlagCalculationFluctuationCh.value) { + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hCentralityNChPNChM_generated"), holderEvent.centrality, holderEvent.nChPGenerated, holderEvent.nChMGenerated); + } + if (cfgFlagCalculationFluctuationKa.value) { + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hCentralityNKaPNKaM_generated"), holderEvent.centrality, holderEvent.nKaPGenerated, holderEvent.nKaMGenerated); + } + if (cfgFlagCalculationFluctuationPr.value) { + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hCentralityNPrPNPrM_generated"), holderEvent.centrality, holderEvent.nPrPGenerated, holderEvent.nPrMGenerated); + } + } + + if ((cfgFlagCalculationPurityPi.value || cfgFlagCalculationPurityKa.value || cfgFlagCalculationPurityPr.value || cfgFlagCalculationFluctuationCh.value || cfgFlagCalculationFluctuationKa.value || cfgFlagCalculationFluctuationPr.value)) { + if (cfgFlagCalculationFluctuationCh.value || cfgFlagCalculationFluctuationKa.value || cfgFlagCalculationFluctuationPr.value) { + holderEvent.subgroupIndex = gRandom->Integer(cfgNSubgroups.value); + if (cfgFlagCalculationFluctuationCh.value) { + fluctuationCalculatorTrackChP->init(); + fluctuationCalculatorTrackChM->init(); + fluctuationCalculatorTrackChT->init(); + fluctuationCalculatorTrackChN->init(); + } + if (cfgFlagCalculationFluctuationKa.value) { + fluctuationCalculatorTrackKaP->init(); + fluctuationCalculatorTrackKaM->init(); + fluctuationCalculatorTrackKaT->init(); + fluctuationCalculatorTrackKaN->init(); + } + if (cfgFlagCalculationFluctuationPr.value) { + fluctuationCalculatorTrackPrP->init(); + fluctuationCalculatorTrackPrM->init(); + fluctuationCalculatorTrackPrT->init(); + fluctuationCalculatorTrackPrN->init(); + } + } + for (const auto& track : tracks) { - if (!track.has_mcParticle()) { + if (!track.has_collision() || !track.has_mcParticle()) { continue; } const auto& mcParticle = track.template mcParticle_as(); + if (!mcParticle.has_mcCollision()) { + continue; + } + initMcParticle(mcParticle); if (!initTrack(track)) { continue; } - if (quantityHolderTrack.hasTpcPid) { + if ((cfgFlagCalculationPurityPi.value || cfgFlagCalculationPurityKa.value || cfgFlagCalculationPurityPr.value) && holderTrack.hasTpcPid) { if (cfgFlagCalculationPurityPi.value) { switch (isPi()) { case 1: - hrCalculationPurity.fill(HIST("CalculationPurity/pPtEtaPurityTpcPiP"), quantityHolderTrack.pt, quantityHolderTrack.eta, quantityHolderMcParticle.pdgCode == PDG_t::kPiPlus ? 1. : 0.); + hrCalculationPurity.fill(HIST("CalculationPurity/pCentralityPtEtaPurityTpcPiP"), holderEvent.centrality, holderTrack.pt, holderTrack.eta, holderMcParticle.pdgCode == PDG_t::kPiPlus ? 1. : 0.); break; case -1: - hrCalculationPurity.fill(HIST("CalculationPurity/pPtEtaPurityTpcPiM"), quantityHolderTrack.pt, quantityHolderTrack.eta, quantityHolderMcParticle.pdgCode == PDG_t::kPiMinus ? 1. : 0.); - break; - default: + hrCalculationPurity.fill(HIST("CalculationPurity/pCentralityPtEtaPurityTpcPiM"), holderEvent.centrality, holderTrack.pt, holderTrack.eta, holderMcParticle.pdgCode == PDG_t::kPiMinus ? 1. : 0.); break; } } @@ -1843,12 +2089,10 @@ struct PartNumFluc { if (cfgFlagCalculationPurityKa.value) { switch (isKa()) { case 1: - hrCalculationPurity.fill(HIST("CalculationPurity/pPtEtaPurityTpcKaP"), quantityHolderTrack.pt, quantityHolderTrack.eta, quantityHolderMcParticle.pdgCode == PDG_t::kKPlus ? 1. : 0.); + hrCalculationPurity.fill(HIST("CalculationPurity/pCentralityPtEtaPurityTpcKaP"), holderEvent.centrality, holderTrack.pt, holderTrack.eta, holderMcParticle.pdgCode == PDG_t::kKPlus ? 1. : 0.); break; case -1: - hrCalculationPurity.fill(HIST("CalculationPurity/pPtEtaPurityTpcKaM"), quantityHolderTrack.pt, quantityHolderTrack.eta, quantityHolderMcParticle.pdgCode == PDG_t::kKMinus ? 1. : 0.); - break; - default: + hrCalculationPurity.fill(HIST("CalculationPurity/pCentralityPtEtaPurityTpcKaM"), holderEvent.centrality, holderTrack.pt, holderTrack.eta, holderMcParticle.pdgCode == PDG_t::kKMinus ? 1. : 0.); break; } } @@ -1856,26 +2100,22 @@ struct PartNumFluc { if (cfgFlagCalculationPurityPr.value) { switch (isPr()) { case 1: - hrCalculationPurity.fill(HIST("CalculationPurity/pPtEtaPurityTpcPrP"), quantityHolderTrack.pt, quantityHolderTrack.eta, quantityHolderMcParticle.pdgCode == PDG_t::kProton ? 1. : 0.); + hrCalculationPurity.fill(HIST("CalculationPurity/pCentralityPtEtaPurityTpcPrP"), holderEvent.centrality, holderTrack.pt, holderTrack.eta, holderMcParticle.pdgCode == PDG_t::kProton ? 1. : 0.); break; case -1: - hrCalculationPurity.fill(HIST("CalculationPurity/pPtEtaPurityTpcPrM"), quantityHolderTrack.pt, quantityHolderTrack.eta, quantityHolderMcParticle.pdgCode == PDG_t::kProtonBar ? 1. : 0.); - break; - default: + hrCalculationPurity.fill(HIST("CalculationPurity/pCentralityPtEtaPurityTpcPrM"), holderEvent.centrality, holderTrack.pt, holderTrack.eta, holderMcParticle.pdgCode == PDG_t::kProtonBar ? 1. : 0.); break; } } - if (quantityHolderTrack.hasTofPid) { + if (holderTrack.hasTofPid) { if (cfgFlagCalculationPurityPi.value) { switch (isPi()) { case 1: - hrCalculationPurity.fill(HIST("CalculationPurity/pPtEtaPurityTpcTofPiP"), quantityHolderTrack.pt, quantityHolderTrack.eta, quantityHolderMcParticle.pdgCode == PDG_t::kPiPlus ? 1. : 0.); + hrCalculationPurity.fill(HIST("CalculationPurity/pCentralityPtEtaPurityTpcTofPiP"), holderEvent.centrality, holderTrack.pt, holderTrack.eta, holderMcParticle.pdgCode == PDG_t::kPiPlus ? 1. : 0.); break; case -1: - hrCalculationPurity.fill(HIST("CalculationPurity/pPtEtaPurityTpcTofPiM"), quantityHolderTrack.pt, quantityHolderTrack.eta, quantityHolderMcParticle.pdgCode == PDG_t::kPiMinus ? 1. : 0.); - break; - default: + hrCalculationPurity.fill(HIST("CalculationPurity/pCentralityPtEtaPurityTpcTofPiM"), holderEvent.centrality, holderTrack.pt, holderTrack.eta, holderMcParticle.pdgCode == PDG_t::kPiMinus ? 1. : 0.); break; } } @@ -1883,12 +2123,10 @@ struct PartNumFluc { if (cfgFlagCalculationPurityKa.value) { switch (isKa()) { case 1: - hrCalculationPurity.fill(HIST("CalculationPurity/pPtEtaPurityTpcTofKaP"), quantityHolderTrack.pt, quantityHolderTrack.eta, quantityHolderMcParticle.pdgCode == PDG_t::kKPlus ? 1. : 0.); + hrCalculationPurity.fill(HIST("CalculationPurity/pCentralityPtEtaPurityTpcTofKaP"), holderEvent.centrality, holderTrack.pt, holderTrack.eta, holderMcParticle.pdgCode == PDG_t::kKPlus ? 1. : 0.); break; case -1: - hrCalculationPurity.fill(HIST("CalculationPurity/pPtEtaPurityTpcTofKaM"), quantityHolderTrack.pt, quantityHolderTrack.eta, quantityHolderMcParticle.pdgCode == PDG_t::kKMinus ? 1. : 0.); - break; - default: + hrCalculationPurity.fill(HIST("CalculationPurity/pCentralityPtEtaPurityTpcTofKaM"), holderEvent.centrality, holderTrack.pt, holderTrack.eta, holderMcParticle.pdgCode == PDG_t::kKMinus ? 1. : 0.); break; } } @@ -1896,69 +2134,46 @@ struct PartNumFluc { if (cfgFlagCalculationPurityPr.value) { switch (isPr()) { case 1: - hrCalculationPurity.fill(HIST("CalculationPurity/pPtEtaPurityTpcTofPrP"), quantityHolderTrack.pt, quantityHolderTrack.eta, quantityHolderMcParticle.pdgCode == PDG_t::kProton ? 1. : 0.); + hrCalculationPurity.fill(HIST("CalculationPurity/pCentralityPtEtaPurityTpcTofPrP"), holderEvent.centrality, holderTrack.pt, holderTrack.eta, holderMcParticle.pdgCode == PDG_t::kProton ? 1. : 0.); break; case -1: - hrCalculationPurity.fill(HIST("CalculationPurity/pPtEtaPurityTpcTofPrM"), quantityHolderTrack.pt, quantityHolderTrack.eta, quantityHolderMcParticle.pdgCode == PDG_t::kProtonBar ? 1. : 0.); - break; - default: + hrCalculationPurity.fill(HIST("CalculationPurity/pCentralityPtEtaPurityTpcTofPrM"), holderEvent.centrality, holderTrack.pt, holderTrack.eta, holderMcParticle.pdgCode == PDG_t::kProtonBar ? 1. : 0.); break; } } } } - } - } - if (cfgFlagCalculationEfficiencyPi.value || cfgFlagCalculationEfficiencyKa.value || cfgFlagCalculationEfficiencyPr.value) { - for (const auto& mcParticle : mcParticles) { - if (!initMcParticle(mcParticle)) { - continue; + if ((cfgFlagCalculationFluctuationCh.value || cfgFlagCalculationFluctuationKa.value || cfgFlagCalculationFluctuationPr.value) && isGoodMcParticle(mcParticle)) { + calculateFluctuation(); } + } - if (cfgFlagCalculationEfficiencyPi.value) { - switch (quantityHolderMcParticle.pdgCode) { - case PDG_t::kPiPlus: - hrCalculationEfficiency.fill(HIST("CalculationEfficiency/pVzPtEtaEfficiencyTpcPiP"), quantityHolderEvent.vz, quantityHolderMcParticle.pt, quantityHolderMcParticle.eta, std::ranges::find(quantityHolderEvent.mcParticleIndicesMatchedTpcPiP, quantityHolderMcParticle.globalIndex) != quantityHolderEvent.mcParticleIndicesMatchedTpcPiP.end() ? 1. : 0.); - hrCalculationEfficiency.fill(HIST("CalculationEfficiency/pVzPtEtaEfficiencyTpcTofPiP"), quantityHolderEvent.vz, quantityHolderMcParticle.pt, quantityHolderMcParticle.eta, std::ranges::find(quantityHolderEvent.mcParticleIndicesMatchedTpcTofPiP, quantityHolderMcParticle.globalIndex) != quantityHolderEvent.mcParticleIndicesMatchedTpcTofPiP.end() ? 1. : 0.); - break; - case PDG_t::kPiMinus: - hrCalculationEfficiency.fill(HIST("CalculationEfficiency/pVzPtEtaEfficiencyTpcPiM"), quantityHolderEvent.vz, quantityHolderMcParticle.pt, quantityHolderMcParticle.eta, std::ranges::find(quantityHolderEvent.mcParticleIndicesMatchedTpcPiM, quantityHolderMcParticle.globalIndex) != quantityHolderEvent.mcParticleIndicesMatchedTpcPiM.end() ? 1. : 0.); - hrCalculationEfficiency.fill(HIST("CalculationEfficiency/pVzPtEtaEfficiencyTpcTofPiM"), quantityHolderEvent.vz, quantityHolderMcParticle.pt, quantityHolderMcParticle.eta, std::ranges::find(quantityHolderEvent.mcParticleIndicesMatchedTpcTofPiM, quantityHolderMcParticle.globalIndex) != quantityHolderEvent.mcParticleIndicesMatchedTpcTofPiM.end() ? 1. : 0.); - break; - default: - break; - } + if (cfgFlagCalculationFluctuationCh.value) { + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hCentralityNChPNChM"), holderEvent.centrality, holderEvent.nChP, holderEvent.nChM); + for (std::int32_t const& iOrderVector : std::views::iota(0, static_cast(fluctuation_calculator_base::NOrderVectors))) { + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorChP"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackChP->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorChM"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackChM->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorChT"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackChT->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorChN"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackChN->getProductFast(iOrderVector)); } - - if (cfgFlagCalculationEfficiencyKa.value) { - switch (quantityHolderMcParticle.pdgCode) { - case PDG_t::kKPlus: - hrCalculationEfficiency.fill(HIST("CalculationEfficiency/pVzPtEtaEfficiencyTpcKaP"), quantityHolderEvent.vz, quantityHolderMcParticle.pt, quantityHolderMcParticle.eta, std::ranges::find(quantityHolderEvent.mcParticleIndicesMatchedTpcKaP, quantityHolderMcParticle.globalIndex) != quantityHolderEvent.mcParticleIndicesMatchedTpcKaP.end() ? 1. : 0.); - hrCalculationEfficiency.fill(HIST("CalculationEfficiency/pVzPtEtaEfficiencyTpcTofKaP"), quantityHolderEvent.vz, quantityHolderMcParticle.pt, quantityHolderMcParticle.eta, std::ranges::find(quantityHolderEvent.mcParticleIndicesMatchedTpcTofKaP, quantityHolderMcParticle.globalIndex) != quantityHolderEvent.mcParticleIndicesMatchedTpcTofKaP.end() ? 1. : 0.); - break; - case PDG_t::kKMinus: - hrCalculationEfficiency.fill(HIST("CalculationEfficiency/pVzPtEtaEfficiencyTpcKaM"), quantityHolderEvent.vz, quantityHolderMcParticle.pt, quantityHolderMcParticle.eta, std::ranges::find(quantityHolderEvent.mcParticleIndicesMatchedTpcKaM, quantityHolderMcParticle.globalIndex) != quantityHolderEvent.mcParticleIndicesMatchedTpcKaM.end() ? 1. : 0.); - hrCalculationEfficiency.fill(HIST("CalculationEfficiency/pVzPtEtaEfficiencyTpcTofKaM"), quantityHolderEvent.vz, quantityHolderMcParticle.pt, quantityHolderMcParticle.eta, std::ranges::find(quantityHolderEvent.mcParticleIndicesMatchedTpcTofKaM, quantityHolderMcParticle.globalIndex) != quantityHolderEvent.mcParticleIndicesMatchedTpcTofKaM.end() ? 1. : 0.); - break; - default: - break; - } + } + if (cfgFlagCalculationFluctuationKa.value) { + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hCentralityNKaPNKaM"), holderEvent.centrality, holderEvent.nKaP, holderEvent.nKaM); + for (std::int32_t const& iOrderVector : std::views::iota(0, static_cast(fluctuation_calculator_base::NOrderVectors))) { + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorKaP"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackKaP->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorKaM"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackKaM->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorKaT"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackKaT->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorKaN"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackKaN->getProductFast(iOrderVector)); } - - if (cfgFlagCalculationEfficiencyPr.value) { - switch (quantityHolderMcParticle.pdgCode) { - case PDG_t::kProton: - hrCalculationEfficiency.fill(HIST("CalculationEfficiency/pVzPtEtaEfficiencyTpcPrP"), quantityHolderEvent.vz, quantityHolderMcParticle.pt, quantityHolderMcParticle.eta, std::ranges::find(quantityHolderEvent.mcParticleIndicesMatchedTpcPrP, quantityHolderMcParticle.globalIndex) != quantityHolderEvent.mcParticleIndicesMatchedTpcPrP.end() ? 1. : 0.); - hrCalculationEfficiency.fill(HIST("CalculationEfficiency/pVzPtEtaEfficiencyTpcTofPrP"), quantityHolderEvent.vz, quantityHolderMcParticle.pt, quantityHolderMcParticle.eta, std::ranges::find(quantityHolderEvent.mcParticleIndicesMatchedTpcTofPrP, quantityHolderMcParticle.globalIndex) != quantityHolderEvent.mcParticleIndicesMatchedTpcTofPrP.end() ? 1. : 0.); - break; - case PDG_t::kProtonBar: - hrCalculationEfficiency.fill(HIST("CalculationEfficiency/pVzPtEtaEfficiencyTpcPrM"), quantityHolderEvent.vz, quantityHolderMcParticle.pt, quantityHolderMcParticle.eta, std::ranges::find(quantityHolderEvent.mcParticleIndicesMatchedTpcPrM, quantityHolderMcParticle.globalIndex) != quantityHolderEvent.mcParticleIndicesMatchedTpcPrM.end() ? 1. : 0.); - hrCalculationEfficiency.fill(HIST("CalculationEfficiency/pVzPtEtaEfficiencyTpcTofPrM"), quantityHolderEvent.vz, quantityHolderMcParticle.pt, quantityHolderMcParticle.eta, std::ranges::find(quantityHolderEvent.mcParticleIndicesMatchedTpcTofPrM, quantityHolderMcParticle.globalIndex) != quantityHolderEvent.mcParticleIndicesMatchedTpcTofPrM.end() ? 1. : 0.); - break; - default: - break; - } + } + if (cfgFlagCalculationFluctuationPr.value) { + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hCentralityNPrPNPrM"), holderEvent.centrality, holderEvent.nPrP, holderEvent.nPrM); + for (std::int32_t const& iOrderVector : std::views::iota(0, static_cast(fluctuation_calculator_base::NOrderVectors))) { + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorPrP"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackPrP->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorPrM"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackPrM->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorPrT"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackPrT->getProductFast(iOrderVector)); + hrCalculationFluctuation.fill(HIST("CalculationFluctuation/hFluctuationCalculatorPrN"), holderEvent.centrality, holderEvent.subgroupIndex, iOrderVector, fluctuationCalculatorTrackPrN->getProductFast(iOrderVector)); } } }