diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 1337864b67b..26378bbb90e 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -63,6 +63,7 @@ #include #include +#include #include #include #include @@ -82,7 +83,7 @@ using namespace o2::framework; using namespace o2::framework::expressions; enum CorrelationCase { - TpcTpc, + TpcTpc = 0, TpcMft, TpcFv0a, MftFv0a, @@ -103,6 +104,24 @@ enum DataType { Mc }; +enum FT0DetectorChannels { + FT0AInnerRingMin = 0, + FT0AInnerRingMax = 31, + FT0AOuterRingMin = 32, + FT0AOuterRingMax = 95, + FT0CInnerRingMin = 96, + FT0CInnerRingMax = 143, + FT0COuterRingMin = 144, + FT0COuterRingMax = 207 +}; + +enum FT0InnerOrOuter { + FT0Error, + FT0InnerRing, + FT0OuterRing, + NFT0InnerOrOuterSteps +}; + enum ReassociationMftTracks { NotReassociatedMftTracks = 0, ReassociatedMftTracks, @@ -168,6 +187,7 @@ enum SpecificEventSelectionStep { IsNoCollInTimeRangeStrict, IsNoHighMultCollInPrevRof, IsRctFlagChecked, + IsFoundFT0, NSpecificEventSelectionSteps }; @@ -176,12 +196,11 @@ enum TrackSelection { TrackSelectionGlobalTrack }; -// static constexpr std::string_view whatEventType[] = {"SameEvent/", "MixedEvent/"}; -static constexpr std::string_view WhatDataType[] = {"Data/", "MC/"}; -static constexpr std::string_view WhatCorrelationCase[] = {"TpcTpc/", "TpcMft/", "TpcFv0a/", "MftFv0a/", "TpcFt0a/", "MftFt0a/", "TpcFt0c/", "Ft0aFt0c/"}; -static constexpr std::string_view WhatParticles[] = {"ChPartChPart/", "D0ChPart/", "LcChPart/"}; -static constexpr std::string_view WhatCentralityEstimator[] = {"centFT0C", "CentFT0CVariant1", "centFT0M"}; -static constexpr std::string_view WhatMultiplicityEstimator[] = {"multNTracksPV", "multNumContrib", "multFT0C", "multFT0M"}; +static constexpr std::array WhatDataType = {"Data/", "MC/"}; +static constexpr std::array WhatCorrelationCase = {"TpcTpc/", "TpcMft/", "TpcFv0a/", "MftFv0a/", "TpcFt0a/", "MftFt0a/", "TpcFt0c/", "Ft0aFt0c/"}; +static constexpr std::array WhatParticles = {"ChPartChPart/", "D0ChPart/", "LcChPart/"}; +static constexpr std::array WhatCentralityEstimator = {"centFT0C", "CentFT0CVariant1", "centFT0M"}; +static constexpr std::array WhatMultiplicityEstimator = {"multNTracksPV", "multNumContrib", "multFT0C", "multFT0M"}; auto static constexpr MinFt0cCell = 96; static constexpr TrackSelectionFlags::flagtype TrackSelectionIts = @@ -196,7 +215,7 @@ static constexpr TrackSelectionFlags::flagtype TrackSelectionDca = static constexpr TrackSelectionFlags::flagtype TrackSelectionDcaxyOnly = TrackSelectionFlags::kDCAxy; -static constexpr float PairCutDefaults[1][5] = {{-1, -1, -1, -1, -1}}; +static constexpr std::array, 1> PairCutDefaults{{{{-1, -1, -1, -1, -1}}}}; struct HfTaskFlow { @@ -234,6 +253,8 @@ struct HfTaskFlow { Configurable nMixedEvents{"nMixedEvents", 5, "Number of mixed events per event"}; Configurable nSamples{"nSamples", 10, "number of different samples for correlations"}; Configurable nameCorrelationContainer{"nameCorrelationContainer", "", "Add the possibility to the rename the correlation container as configurable"}; + Configurable removeQAForSystematics{"removeQAForSystematics", false, "Remove QA plots for systematics, deactivate all plots except trigger hist"}; + Configurable useCutNeutralParticles{"useCutNeutralParticles", false, "Choose to use or not use neutral particles in the correlation analysis"}; Configurable useEfficiencyCorrection{"useEfficiencyCorrection", false, "Choose to use or not use efficiency correction, if not used, weight is set to 1"}; Configurable useOnlyPrimaryInMc{"useOnlyPrimaryInMc", false, "Choose to use or not use only primaries for McGen"}; } configTask; @@ -258,6 +279,7 @@ struct HfTaskFlow { Configurable useCentrality{"useCentrality", false, "use centrality instead of multiplicity"}; Configurable useMultiplicityFromTracks{"useMultiplicityFromTracks", false, "Use multiplicity from counting tracks"}; Configurable useMultiplicityFromTracksCorrected{"useMultiplicityFromTracksCorrected", false, "Use multiplicity from counting tracks, corrected but takes a lot of computation time"}; + Configurable useNoFoundFT0Cut{"useNoFoundFT0Cut", false, "Use cut on no FT0 signal"}; Configurable requireRCTFlagChecker{"requireRCTFlagChecker", false, "Check event quality in run condition table"}; Configurable requireCorrelationAnalysisRCTFlagChecker{"requireCorrelationAnalysisRCTFlagChecker", false, "Check event quality in run condition table for correlation analysis"}; Configurable setRCTFlagCheckerLabel{"setRCTFlagCheckerLabel", "CBT_muon_global", "Evt sel: RCT flag checker label"}; @@ -286,7 +308,7 @@ struct HfTaskFlow { Configurable minMergingRadius{"minMergingRadius", 0.8, "max radius for merging cut"}; Configurable minTpcClusters{"minTpcClusters", 50.0f, "cut for minimum TPC clusters"}; Configurable minTpcCrossedRows{"minTpcCrossedRows", 70.0f, "cut for minimum TOC crossed rows"}; - Configurable> pairCut{"pairCut", {PairCutDefaults[0], 5, {"Photon", "K0", "Lambda", "Phi", "Rho"}}, "Pair cuts on various particles"}; + Configurable> pairCut{"pairCut", {PairCutDefaults[0].data(), 5, {"Photon", "K0", "Lambda", "Phi", "Rho"}}, "Pair cuts on various particles"}; Configurable ptCentralTrackMin{"ptCentralTrackMin", 0.2f, "min. pT of central tracks"}; Configurable ptCentralTrackMax{"ptCentralTrackMax", 10.0f, "max. pT of central tracks"}; Configurable trackSelectionType{"trackSelectionType", 1, "Track selection: 0 -> kGlobalTrack or isGlobalTrackSDD , 1 -> kGlobalTrack, 2 -> kGlobalTrackWoPtEta, 3 -> kGlobalTrackWoDCA, 4 -> No globalTrack selection"}; @@ -334,6 +356,7 @@ struct HfTaskFlow { std::string prefix = "ConfigFit_group"; Configurable cfgGainEqPath{"cfgGainEqPath", "Analysis/EventPlane/GainEq", "CCDB path for gain equalization constants"}; Configurable cfgCorrLevel{"cfgCorrLevel", 1, "calibration step: 0 = no corr, 1 = gain corr"}; + Configurable discriminateInnerOrOuter{"discriminateInnerOrOuter", false, "if true, fill correlationContainer with either Inner ou Outer for FIT, if false, fill with real eta information"}; } configFit; SliceCache cache; @@ -344,7 +367,7 @@ struct HfTaskFlow { o2::ccdb::CcdbApi ccdbApi; o2::ft0::Geometry ft0Det; // o2::fv0::Geometry* fv0Det{}; - std::vector cstFT0RelGain{}; + std::vector cstFT0RelGain; RCTFlagsChecker rctChecker; RCTFlagsChecker correlationAnalysisRctChecker{kFT0Bad, kITSBad, kTPCBadTracking, kTPCBadPID, kMFTBad, kITSLimAccMCRepr, kMFTLimAccMCRepr, kTPCLimAccMCRepr}; @@ -374,9 +397,11 @@ struct HfTaskFlow { // ========================= using SmallGroupMcCollisions = soa::SmallGroups>; - using FilteredMcCollisionsWMult = soa::Filtered>; - using FilteredMcCollisionsWMultWCollsExtra = soa::Filtered>; - using FilteredMcParticles = soa::Filtered; + // using FilteredMcCollisionsWMult = soa::Filtered>; + using FilteredMcCollisionsWMult = soa::Join; + using FilteredMcCollisionsWMultWCollsExtra = soa::Join; + // using FilteredMcParticles = soa::Filtered; + using FilteredMcParticles = aod::McParticles; // ========================= // Filters & partitions : DATA @@ -419,10 +444,11 @@ struct HfTaskFlow { // Filters & partitions : MC // ========================= - Filter mcParticleFilter = (((aod::mcparticle::eta > configTask.etaMcParticlesTriggerMin) && (aod::mcparticle::eta < configTask.etaMcParticlesTriggerMax)) || ((aod::mcparticle::eta > configTask.etaMcParticlesAssocMin) && (aod::mcparticle::eta < configTask.etaMcParticlesAssocMax)) || (nabs(aod::mcparticle::eta) < configCentral.etaCentralTrackMax)) && (aod::mcparticle::pt > configTask.ptMcParticlesTriggerMin) && (aod::mcparticle::pt < configTask.ptMcParticlesTriggerMax); + // // Filter for McParticles + // Filter mcParticleFilter = (((aod::mcparticle::eta > configTask.etaMcParticlesTriggerMin) && (aod::mcparticle::eta < configTask.etaMcParticlesTriggerMax)) || ((aod::mcparticle::eta > configTask.etaMcParticlesAssocMin) && (aod::mcparticle::eta < configTask.etaMcParticlesAssocMax)) || (nabs(aod::mcparticle::eta) < configCentral.etaCentralTrackMax)) && (aod::mcparticle::pt < configTask.ptMcParticlesTriggerMax); - // Filter for MCcollisions - Filter mcCollisionFilter = nabs(aod::mccollision::posZ) < configCollision.zVertexMax; + // // Filter for MCcollisions + // Filter mcCollisionFilter = nabs(aod::mccollision::posZ) < configCollision.zVertexMax; // ========================= // Preslice : DATA @@ -454,6 +480,7 @@ struct HfTaskFlow { ConfigurableAxis binsMixingMultiplicity{"binsMixingMultiplicity", {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 100.1}, "multiplicity bins for event mixing"}; ConfigurableAxis binsMixingVertex{"binsMixingVertex", {20, -10, 10}, "vertex bins for event mixing"}; ConfigurableAxis axisCentrality{"axisCentrality", {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100}, "centrality axis for histograms"}; + ConfigurableAxis axisChi2Ndf{"axisChi2Ndf", {100, 0, 100}, "chi2/ndf axis for MFT histograms"}; ConfigurableAxis axisNClusters{"axisNClusters", {9, 1, 10}, "axis for number of clusters of MFT tracks"}; ConfigurableAxis axisEtaEfficiency{"axisEtaEfficiency", {1, -1.0, 1.0}, "eta axis for efficiency histograms"}; ConfigurableAxis axisEtaAssociated{"axisEtaAssociated", {48, -4, -2}, "eta axis for MFT histograms"}; @@ -507,7 +534,7 @@ struct HfTaskFlow { void addMftHistograms() { registry.add("Data/Mft/hAmbiguityOfMftTracks", "hAmbiguityOfMftTracks", {HistType::kTH1D, {{MftTrackAmbiguityStep::NMftAmbiguitySteps, -0.5, +MftTrackAmbiguityStep::NMftAmbiguitySteps - 0.5}}}); - std::string labelsAmbiguityOfMftTracks[MftTrackAmbiguityStep::NMftAmbiguitySteps]; + std::array labelsAmbiguityOfMftTracks{}; labelsAmbiguityOfMftTracks[MftTrackAmbiguityStep::AllMftTracks] = "all MFT tracks"; labelsAmbiguityOfMftTracks[MftTrackAmbiguityStep::AfterTrackSelection] = "MFT tracks after selection"; labelsAmbiguityOfMftTracks[MftTrackAmbiguityStep::NumberOfAmbiguousTracks] = "how much tracks are ambigous"; @@ -519,7 +546,7 @@ struct HfTaskFlow { } registry.add("Data/Mft/hMftTracksSelection", "hMftTracksSelection", {HistType::kTH1D, {{MftTrackSelectionStep::NMftTrackSelectionSteps, -0.5, +MftTrackSelectionStep::NMftTrackSelectionSteps - 0.5}}}); - std::string labelsMftTracksSelection[MftTrackSelectionStep::NMftTrackSelectionSteps]; + std::array labelsMftTracksSelection{}; labelsMftTracksSelection[MftTrackSelectionStep::NoSelection] = "all MFT tracks"; labelsMftTracksSelection[MftTrackSelectionStep::Eta] = "MFT tracks after eta selection"; labelsMftTracksSelection[MftTrackSelectionStep::Cluster] = "MFT tracks after clusters selection"; @@ -537,7 +564,7 @@ struct HfTaskFlow { } registry.add("Data/Mft/hReassociationMftTracks", "hReassociationMftTracks", {HistType::kTH1D, {{ReassociationMftTracks::NReassociationMftTracksSteps, -0.5, +ReassociationMftTracks::NReassociationMftTracksSteps - 0.5}}}); - std::string labelsReassociationMftTracks[ReassociationMftTracks::NReassociationMftTracksSteps]; + std::array labelsReassociationMftTracks{}; labelsReassociationMftTracks[ReassociationMftTracks::NotReassociatedMftTracks] = "Ambiguous MFT tracks after track selection"; labelsReassociationMftTracks[ReassociationMftTracks::ReassociatedMftTracks] = "Reassociated MFT tracks by DCAxy method"; registry.get(HIST("Data/Mft/hReassociationMftTracks"))->SetMinimum(0); @@ -546,6 +573,7 @@ struct HfTaskFlow { registry.get(HIST("Data/Mft/hReassociationMftTracks"))->GetXaxis()->SetBinLabel(iBin + 1, labelsReassociationMftTracks[iBin].data()); } + registry.add("Data/Mft/hChi2OverNdfMft", "", {HistType::kTH1D, {configAxis.axisChi2Ndf}}); registry.add("Data/Mft/hPtMft", "", {HistType::kTH1D, {configAxis.axisPt}}); registry.add("Data/Mft/hPtVsClustersLTF", "", {HistType::kTH2D, {configAxis.axisPt, configAxis.axisNClusters}}); registry.add("Data/Mft/hPtVsClustersCA", "", {HistType::kTH2D, {configAxis.axisPt, configAxis.axisNClusters}}); @@ -555,6 +583,22 @@ struct HfTaskFlow { registry.add("Data/Mft/hNBestCollisionFwd", "", {HistType::kTH1F, {configAxis.axisMultiplicity}}); } + void addFt0Histograms() + { + registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + registry.add("Data/FT0IsInnerOrOuter", "FT0IsInnerOrOuter", {HistType::kTH1D, {{FT0InnerOrOuter::NFT0InnerOrOuterSteps, -0.5, +FT0InnerOrOuter::NFT0InnerOrOuterSteps - 0.5}}}); + std::array labels{}; + labels[FT0InnerOrOuter::FT0InnerRing] = "FT0InnerRing"; + labels[FT0InnerOrOuter::FT0OuterRing] = "FT0OuterRing"; + registry.get(HIST("Data/FT0IsInnerOrOuter"))->SetMinimum(0); + + for (int iBin = 0; iBin < FT0InnerOrOuter::NFT0InnerOrOuterSteps; iBin++) { + registry.get(HIST("Data/FT0IsInnerOrOuter"))->GetXaxis()->SetBinLabel(iBin + 1, labels[iBin].data()); + } + } + // ========================= // init() // ========================= @@ -581,47 +625,54 @@ struct HfTaskFlow { rctChecker.init(configCollision.setRCTFlagCheckerLabel, configCollision.requireZDCCheck, configCollision.requireRCTFlagCheckerLimitAcceptanceAsBad, true); correlationAnalysisRctChecker.init({kFT0Bad, kITSBad, kTPCBadTracking, kTPCBadPID, kMFTBad, kITSLimAccMCRepr, kMFTLimAccMCRepr, kTPCLimAccMCRepr}); - registry.add("Data/hVtxZ", "v_{z} (cm)", {HistType::kTH1D, {configAxis.axisVertex}}); - registry.add("Data/hNTracks", "", {HistType::kTH1F, {configAxis.axisMultiplicity}}); - registry.add(Form("Data/hMultiplicity_%s", WhatMultiplicityEstimator[configCollision.multiplicityEstimator].data()), "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); - registry.add(Form("Data/hCentrality_%s", WhatCentralityEstimator[configCollision.centralityEstimator].data()), "", {HistType::kTH1D, {configAxis.axisCentrality}}); - - registry.add("Data/hEventCounter", "hEventCounter", {HistType::kTH1D, {{EventSelectionStep::NEventSelectionSteps, -0.5, +EventSelectionStep::NEventSelectionSteps - 0.5}}}); - std::string labels[EventSelectionStep::NEventSelectionSteps]; - labels[EventSelectionStep::AllEvents] = "all"; - labels[EventSelectionStep::AfterEventSelection] = "after Physics selection"; - registry.get(HIST("Data/hEventCounter"))->SetMinimum(0); - - for (int iBin = 0; iBin < EventSelectionStep::NEventSelectionSteps; iBin++) { - registry.get(HIST("Data/hEventCounter"))->GetXaxis()->SetBinLabel(iBin + 1, labels[iBin].data()); - } - - registry.add("Data/hPreciseEventCounter", "hPreciseEventCounter", {HistType::kTH1D, {{SpecificEventSelectionStep::NSpecificEventSelectionSteps, -0.5, +SpecificEventSelectionStep::NSpecificEventSelectionSteps - 0.5}}}); - std::string labelsPreciseEventSelection[SpecificEventSelectionStep::NSpecificEventSelectionSteps]; - labelsPreciseEventSelection[SpecificEventSelectionStep::AllEventsPrecise] = "all"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsSel8] = "sel8"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoSameBunchPileup] = "IsNoSameBunchPileup"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsGoodItsLayersAll] = "IsGoodItsLayersAll"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsGoodZvtxFT0vsPV] = "IsGoodZvtxFT0vsPV"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoCollInRofStandard] = "IsNoCollInRofStandard"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoCollInRofStrict] = "IsNoCollInRofStrict"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoCollInTimeRangeStandard] = "IsNoCollInTimeRangeStandard"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoCollInTimeRangeStrict] = "IsNoCollInTimeRangeStrict"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoHighMultCollInPrevRof] = "IsNoHighMultCollInPrevRof"; - labelsPreciseEventSelection[SpecificEventSelectionStep::IsRctFlagChecked] = "IsRctFlagChecked"; - registry.get(HIST("Data/hPreciseEventCounter"))->SetMinimum(0); - - for (int iBin = 0; iBin < SpecificEventSelectionStep::NSpecificEventSelectionSteps; iBin++) { - registry.get(HIST("Data/hPreciseEventCounter"))->GetXaxis()->SetBinLabel(iBin + 1, labelsPreciseEventSelection[iBin].data()); - } - - mPairCuts.SetHistogramRegistry(®istry); - if (configCentral.pairCut->get("Photon") > 0 || configCentral.pairCut->get("K0") > 0 || configCentral.pairCut->get("Lambda") > 0 || configCentral.pairCut->get("Phi") > 0 || configCentral.pairCut->get("Rho") > 0) { - mPairCuts.SetPairCut(PairCuts::Photon, configCentral.pairCut->get("Photon")); - mPairCuts.SetPairCut(PairCuts::K0, configCentral.pairCut->get("K0")); - mPairCuts.SetPairCut(PairCuts::Lambda, configCentral.pairCut->get("Lambda")); - mPairCuts.SetPairCut(PairCuts::Phi, configCentral.pairCut->get("Phi")); - mPairCuts.SetPairCut(PairCuts::Rho, configCentral.pairCut->get("Rho")); + if (!configTask.removeQAForSystematics) { + registry.add("Data/hVtxZ", "v_{z} (cm)", {HistType::kTH1D, {configAxis.axisVertex}}); + registry.add("Data/hNTracks", "", {HistType::kTH1F, {configAxis.axisMultiplicity}}); + registry.add(Form("Data/hMultiplicity_%s", WhatMultiplicityEstimator[configCollision.multiplicityEstimator].data()), "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); + registry.add("Data/hMultiplicityTracksSize", "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); + registry.add("Data/hMultiplicityUsed", "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); + registry.add(Form("Data/hCentrality_%s", WhatCentralityEstimator[configCollision.centralityEstimator].data()), "", {HistType::kTH1D, {configAxis.axisCentrality}}); + registry.add("Data/hCentralityWeighted", "", {HistType::kTH1D, {configAxis.axisCentrality}}); + registry.add("Data/hCentralityUsed", "", {HistType::kTH1D, {configAxis.axisCentrality}}); + + registry.add("Data/hEventCounter", "hEventCounter", {HistType::kTH1D, {{EventSelectionStep::NEventSelectionSteps, -0.5, +EventSelectionStep::NEventSelectionSteps - 0.5}}}); + std::array labels{}; + labels[EventSelectionStep::AllEvents] = "all"; + labels[EventSelectionStep::AfterEventSelection] = "after Physics selection"; + registry.get(HIST("Data/hEventCounter"))->SetMinimum(0); + + for (int iBin = 0; iBin < EventSelectionStep::NEventSelectionSteps; iBin++) { + registry.get(HIST("Data/hEventCounter"))->GetXaxis()->SetBinLabel(iBin + 1, labels[iBin].data()); + } + + registry.add("Data/hPreciseEventCounter", "hPreciseEventCounter", {HistType::kTH1D, {{SpecificEventSelectionStep::NSpecificEventSelectionSteps, -0.5, +SpecificEventSelectionStep::NSpecificEventSelectionSteps - 0.5}}}); + std::array labelsPreciseEventSelection{}; + labelsPreciseEventSelection[SpecificEventSelectionStep::AllEventsPrecise] = "all"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsSel8] = "sel8"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoSameBunchPileup] = "IsNoSameBunchPileup"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsGoodItsLayersAll] = "IsGoodItsLayersAll"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsGoodZvtxFT0vsPV] = "IsGoodZvtxFT0vsPV"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoCollInRofStandard] = "IsNoCollInRofStandard"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoCollInRofStrict] = "IsNoCollInRofStrict"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoCollInTimeRangeStandard] = "IsNoCollInTimeRangeStandard"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoCollInTimeRangeStrict] = "IsNoCollInTimeRangeStrict"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsNoHighMultCollInPrevRof] = "IsNoHighMultCollInPrevRof"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsRctFlagChecked] = "IsRctFlagChecked"; + labelsPreciseEventSelection[SpecificEventSelectionStep::IsFoundFT0] = "IsFoundFT0"; + registry.get(HIST("Data/hPreciseEventCounter"))->SetMinimum(0); + + for (int iBin = 0; iBin < SpecificEventSelectionStep::NSpecificEventSelectionSteps; iBin++) { + registry.get(HIST("Data/hPreciseEventCounter"))->GetXaxis()->SetBinLabel(iBin + 1, labelsPreciseEventSelection[iBin].data()); + } + + mPairCuts.SetHistogramRegistry(®istry); + if (configCentral.pairCut->get("Photon") > 0 || configCentral.pairCut->get("K0") > 0 || configCentral.pairCut->get("Lambda") > 0 || configCentral.pairCut->get("Phi") > 0 || configCentral.pairCut->get("Rho") > 0) { + mPairCuts.SetPairCut(PairCuts::Photon, configCentral.pairCut->get("Photon")); + mPairCuts.SetPairCut(PairCuts::K0, configCentral.pairCut->get("K0")); + mPairCuts.SetPairCut(PairCuts::Lambda, configCentral.pairCut->get("Lambda")); + mPairCuts.SetPairCut(PairCuts::Phi, configCentral.pairCut->get("Phi")); + mPairCuts.SetPairCut(PairCuts::Rho, configCentral.pairCut->get("Rho")); + } } // ========================= @@ -659,7 +710,9 @@ struct HfTaskFlow { // ========================= if (doprocessSameTpcTpcChCh) { - addHistograms(); + if (!configTask.removeQAForSystematics) { + addHistograms(); + } if (!configTask.doEtaDependentFlow) { sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); @@ -671,14 +724,18 @@ struct HfTaskFlow { } if (doprocessSameTpcTpcD0Ch) { - addHistograms(); + if (!configTask.removeQAForSystematics) { + addHistograms(); + } sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); } if (doprocessSameTpcTpcLcCh) { - addHistograms(); + if (!configTask.removeQAForSystematics) { + addHistograms(); + } sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); @@ -689,12 +746,12 @@ struct HfTaskFlow { // ========================= if (doprocessSameTpcMftChCh || doprocessSameTpcMftChChReassociated || doprocessSameTpcMftChChReassociated3d || doprocessSameTpcMftChChNonAmbiguous) { - addHistograms(); - addMftHistograms(); - registry.add("Data/hEfficiencyTrigger", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); - registry.add("Data/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtAssoc}, {configAxis.axisEtaAssociated}, {configAxis.axisVertex}}}); - registry.add("Data/hMultiplicity_uncorrected_vs_corrected", "", {HistType::kTH2D, {{configAxis.axisMultiplicity}, {configAxis.axisMultiplicity}}}); + if (!configTask.removeQAForSystematics) { + addHistograms(); + addMftHistograms(); + registry.add("Data/hMultiplicity_uncorrected_vs_corrected", "", {HistType::kTH2D, {{configAxis.axisMultiplicity}, {configAxis.axisMultiplicity}}}); + } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { registry.add("Trig_hist_TPC_MFT", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); @@ -712,16 +769,21 @@ struct HfTaskFlow { } if (doprocessSameTpcMftD0Ch || doprocessSameTpcMftD0ChReassociated) { - addHistograms(); - addMftHistograms(); + if (!configTask.removeQAForSystematics) { + addHistograms(); + addMftHistograms(); + } sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); } if (doprocessSameTpcMftLcCh || doprocessSameTpcMftLcChReassociated) { - addHistograms(); - addMftHistograms(); + + if (!configTask.removeQAForSystematics) { + addHistograms(); + addMftHistograms(); + } sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); @@ -780,9 +842,10 @@ struct HfTaskFlow { // ========================= if (doprocessSameTpcFt0aChCh) { - addHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + if (!configTask.removeQAForSystematics) { + addHistograms(); + addFt0Histograms(); + } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { registry.add("Trig_hist_TPC_FT0A", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); @@ -800,18 +863,24 @@ struct HfTaskFlow { } if (doprocessSameTpcFt0aD0Ch) { - addHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + if (!configTask.removeQAForSystematics) { + addHistograms(); + registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + } sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); } if (doprocessSameTpcFt0aLcCh) { - addHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + if (!configTask.removeQAForSystematics) { + addHistograms(); + registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + } sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); @@ -822,10 +891,12 @@ struct HfTaskFlow { // ========================= if (doprocessSameMftFt0aChCh || doprocessSameMftFt0aChChReassociated || doprocessSameMftFt0aChChReassociated3d || doprocessSameMftFt0aChChNonAmbiguous) { - addHistograms(); - addMftHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + if (!configTask.removeQAForSystematics) { + addHistograms(); + addMftHistograms(); + addFt0Histograms(); + } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { registry.add("Trig_hist_MFT_FT0A", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); @@ -847,9 +918,11 @@ struct HfTaskFlow { // ========================= if (doprocessSameTpcFt0cChCh) { - addHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + if (!configTask.removeQAForSystematics) { + addHistograms(); + addFt0Histograms(); + } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { registry.add("Trig_hist_TPC_FT0C", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); @@ -867,18 +940,24 @@ struct HfTaskFlow { } if (doprocessSameTpcFt0cD0Ch) { - addHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + if (!configTask.removeQAForSystematics) { + addHistograms(); + registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + } sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); } if (doprocessSameTpcFt0cLcCh) { - addHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + if (!configTask.removeQAForSystematics) { + addHistograms(); + registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + } sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); @@ -889,9 +968,13 @@ struct HfTaskFlow { // ========================= if (doprocessSameFt0aFt0cChCh) { - addHistograms(); - registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + + if (!configTask.removeQAForSystematics) { + addHistograms(); + addFt0Histograms(); + registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); + } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { registry.add("Trig_hist_FT0A_FT0C", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); @@ -914,25 +997,25 @@ struct HfTaskFlow { if (doprocessSameMcGen) { - registry.add("MC/hEfficiencyTrigger", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); - registry.add("MC/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtAssoc}, {configAxis.axisEtaAssociated}, {configAxis.axisVertex}}}); - - if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFv0a)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFv0a)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0a)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFt0a)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0c)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::Ft0aFt0c)) { - addHistograms(); + if (!configTask.removeQAForSystematics) { + + if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFv0a)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFv0a)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0a)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFt0a)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0c)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::Ft0aFt0c)) { + addHistograms(); + } } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -951,12 +1034,15 @@ struct HfTaskFlow { } if (doprocessTrackEfficiencies) { - registry.add("MC/hEfficiencyTrigger", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); - registry.add("MC/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaAssociated}, {configAxis.axisVertex}}}); - registry.add("Data/hEfficiencyTrigger", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); - registry.add("Data/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtAssoc}, {configAxis.axisEtaAssociated}, {configAxis.axisVertex}}}); + if (!configTask.removeQAForSystematics) { + registry.add("MC/hEfficiencyTrigger", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); + registry.add("MC/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaAssociated}, {configAxis.axisVertex}}}); + registry.add("Data/hEfficiencyTrigger", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); + registry.add("Data/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtAssoc}, {configAxis.axisEtaAssociated}, {configAxis.axisVertex}}}); + } } + registry.print(); } // End of init() function // ========================= @@ -1004,22 +1090,22 @@ struct HfTaskFlow { { switch (configCollision.multiplicityEstimator) { case MultiplicityEstimators::MultNTracksPV: - if (isSameEvent) { + if (isSameEvent && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hMultiplicity_multNTracksPV"), collision.multNTracksPV()); } return collision.multNTracksPV(); case MultiplicityEstimators::MultNumContrib: - if (isSameEvent) { + if (isSameEvent && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hMultiplicity_multNumContrib"), collision.numContrib()); } return collision.numContrib(); case MultiplicityEstimators::MultFT0C: - if (isSameEvent) { + if (isSameEvent && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hMultiplicity_multFT0C"), collision.multFT0C()); } return collision.multFT0C(); case MultiplicityEstimators::MultFT0M: - if (isSameEvent) { + if (isSameEvent && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hMultiplicity_multFT0M"), collision.multFT0M()); } return collision.multFT0M(); @@ -1033,17 +1119,17 @@ struct HfTaskFlow { { switch (configCollision.centralityEstimator) { case CentralityEstimators::CentFT0C: - if (isSameEvent) { + if (isSameEvent && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hCentrality_centFT0C"), collision.centFT0C()); } return collision.centFT0C(); case CentralityEstimators::CentFT0CVariant1: - if (isSameEvent) { + if (isSameEvent && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hCentrality_centFT0CVariant1"), collision.centFT0CVariant1()); } return collision.centFT0CVariant1(); case CentralityEstimators::CentFT0M: - if (isSameEvent) { + if (isSameEvent && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hCentrality_centFT0M"), collision.centFT0M()); } return collision.centFT0M(); @@ -1184,15 +1270,19 @@ struct HfTaskFlow { } else { LOGF(fatal, "Cor Index %d out of range", fitType); } - registry.fill(HIST("Data/FT0Amp"), rID, amplitude); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/FT0Amp"), rID, amplitude); + } amplitude = amplitude / cstFT0RelGain[id]; - registry.fill(HIST("Data/FT0AmpCorr"), rID, amplitude); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/FT0AmpCorr"), rID, amplitude); + } } void loadGain(aod::BCsWithTimestamps::iterator const& bc) { cstFT0RelGain.clear(); - cstFT0RelGain = {}; + // cstFT0RelGain = {}; std::string fullPath; auto timestamp = bc.timestamp(); @@ -1215,33 +1305,71 @@ struct HfTaskFlow { } } + int isInnerOrOuter(int channelId, int fitType) + { + if (fitType == isFT0C) { + if (channelId >= FT0DetectorChannels::FT0CInnerRingMin && channelId <= FT0DetectorChannels::FT0CInnerRingMax) { + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/FT0IsInnerOrOuter"), FT0InnerOrOuter::FT0InnerRing); + } + return FT0InnerOrOuter::FT0InnerRing; + } else if (channelId >= FT0DetectorChannels::FT0COuterRingMin && channelId <= FT0DetectorChannels::FT0COuterRingMax) { + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/FT0IsInnerOrOuter"), FT0InnerOrOuter::FT0OuterRing); + } + return FT0InnerOrOuter::FT0OuterRing; + } else { + LOGF(fatal, "Channel ID %d out of range for FT0C", channelId); + return FT0InnerOrOuter::FT0Error; + } + } else if (fitType == isFT0A) { + if (channelId >= FT0DetectorChannels::FT0AInnerRingMin && channelId <= FT0DetectorChannels::FT0AInnerRingMax) { + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/FT0IsInnerOrOuter"), FT0InnerOrOuter::FT0InnerRing); + } + return FT0InnerOrOuter::FT0InnerRing; + } else if (channelId >= FT0DetectorChannels::FT0AOuterRingMin && channelId <= FT0DetectorChannels::FT0AOuterRingMax) { + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/FT0IsInnerOrOuter"), FT0InnerOrOuter::FT0OuterRing); + } + return FT0InnerOrOuter::FT0OuterRing; + } else { + LOGF(fatal, "Channel ID %d out of range for FT0A", channelId); + return FT0InnerOrOuter::FT0Error; + } + } else { + LOGF(fatal, "Fit type %d is not valid for FT0", fitType); + return FT0InnerOrOuter::FT0Error; + } + } + void loadEfficiencyCorrection(uint64_t timestamp) { if (areCorrectionsLoaded) { return; } - if (configTask.loadEfficienciesForTpc.value.empty() == false) { + if (!configTask.loadEfficienciesForTpc.value.empty()) { mEfficiencyTpc = ccdb->getForTimeStamp(configTask.loadEfficienciesForTpc, timestamp); if (mEfficiencyTpc == nullptr) { LOGF(fatal, "Could not load efficiency histogram for TPC tracks from %s", configTask.loadEfficienciesForTpc.value.c_str()); } LOGF(info, "Loaded efficiency histogram from %s (%p)", configTask.loadEfficienciesForTpc.value.c_str(), static_cast(mEfficiencyTpc)); } - if (configTask.loadEfficienciesForMft.value.empty() == false) { + if (!configTask.loadEfficienciesForMft.value.empty()) { mEfficiencyMft = ccdb->getForTimeStamp(configTask.loadEfficienciesForMft, timestamp); if (mEfficiencyMft == nullptr) { LOGF(fatal, "Could not load efficiency histogram for MFT tracks from %s", configTask.loadEfficienciesForMft.value.c_str()); } LOGF(info, "Loaded efficiency histogram from %s (%p)", configTask.loadEfficienciesForMft.value.c_str(), static_cast(mEfficiencyMft)); } - if (configTask.loadEfficienciesForNch.value.empty() == false) { + if (!configTask.loadEfficienciesForNch.value.empty()) { mEfficiencyNch = ccdb->getForTimeStamp(configTask.loadEfficienciesForNch, timestamp); if (!mEfficiencyNch) { LOGF(fatal, "Could not load efficiency histogram for Nch estimator from %s", configTask.loadEfficienciesForNch.value.c_str()); } LOGF(info, "Loaded efficiency histogram from %s (%p)", configTask.loadEfficienciesForNch.value.c_str(), static_cast(mEfficiencyNch)); } - if (configTask.loadCentralityWeight.value.empty() == false) { + if (!configTask.loadCentralityWeight.value.empty()) { mCentralityWeight = ccdb->getForTimeStamp(configTask.loadCentralityWeight, timestamp); if (mCentralityWeight == nullptr) { LOGF(fatal, "Could not load centrality weight correction from %s", configTask.loadCentralityWeight.value.c_str()); @@ -1292,14 +1420,14 @@ struct HfTaskFlow { } template - double getCorrectedMultiplicity(const TTracks& tracks) // function to count the number of tracks in the event and fill the histogram + float getCorrectedMultiplicity(const TTracks& tracks) // function to count the number of tracks in the event and fill the histogram { - auto trackCounter = 0; + float trackCounter = 0.f; auto weightMultiplicity = 1.0f; for (auto const& track : tracks) { - if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { - trackCounter += 1; + if (std::abs(track.eta()) > configCentral.etaCentralTrackMax || track.pt() <= configCentral.ptCentralTrackMin || track.pt() >= configCentral.ptCentralTrackMax) { + continue; } auto efficiencyNch = 1.0f; @@ -1311,12 +1439,13 @@ struct HfTaskFlow { } if (efficiencyNch == 0) { - return false; + // return false; + efficiencyNch = 1.0f; } weightMultiplicity = 1. / efficiencyNch; } else { - weightMultiplicity = 0; + weightMultiplicity = 1.0f; } trackCounter += weightMultiplicity; @@ -1335,6 +1464,11 @@ struct HfTaskFlow { if (weight == 0) { return false; } + + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityWeighted"), centrality, weight); + } + weightCent = weight; return true; } @@ -1343,11 +1477,44 @@ struct HfTaskFlow { // Cuts with functions // ========================= + template + bool isAcceptedEventActivity(TCollision const& collision, TTracks const& tracks, auto& multiplicity, float& centrality, float& centralityWeight) + { + if (configCollision.useMultiplicityFromTracks) { + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hMultiplicityTracksSize"), tracks.size()); + } + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } + + centrality = getCentralityEstimator(collision, true); + if (configCollision.useCentrality) { + getCentralityWeight(centralityWeight, centrality); + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { + return false; + } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hCentralityUsed"), centrality); + } + } else { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return false; + } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hMultiplicityUsed"), multiplicity); + } + } + + return true; + } + // FIXME: Some collisions are rejected here, what causes (part of) differences with the D0 task template bool isAcceptedCollision(TCollision const& collision, bool fillHistograms = false) { - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hEventCounter"), EventSelectionStep::AllEvents); registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::AllEventsPrecise); } @@ -1355,55 +1522,55 @@ struct HfTaskFlow { if (!collision.sel8()) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsSel8); } if (configCollision.isApplySameBunchPileup && !collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsNoSameBunchPileup); } if (configCollision.isApplyGoodItsLayersAll && !collision.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsGoodItsLayersAll); } if (configCollision.isApplyGoodZvtxFT0vsPV && !collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsGoodZvtxFT0vsPV); } if (configCollision.isApplyNoCollInRofStandard && !collision.selection_bit(o2::aod::evsel::kNoCollInRofStandard)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsNoCollInRofStandard); } if (configCollision.isApplyNoCollInRofStrict && !collision.selection_bit(o2::aod::evsel::kNoCollInRofStrict)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsNoCollInRofStrict); } if (configCollision.isApplyNoCollInTimeRangeStandard && !collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsNoCollInTimeRangeStandard); } if (configCollision.isApplyNoCollInTimeRangeStrict && !collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStrict)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsNoCollInTimeRangeStrict); } if (configCollision.isApplyNoHighMultCollInPrevRof && !collision.selection_bit(o2::aod::evsel::kNoHighMultCollInPrevRof)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsNoHighMultCollInPrevRof); } if (configCollision.requireRCTFlagChecker && !rctChecker(collision)) { @@ -1412,12 +1579,20 @@ struct HfTaskFlow { if (configCollision.requireCorrelationAnalysisRCTFlagChecker && !correlationAnalysisRctChecker(collision)) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsRctFlagChecked); - registry.fill(HIST("Data/hEventCounter"), EventSelectionStep::AfterEventSelection); + } + if (configCollision.useNoFoundFT0Cut && !collision.has_foundFT0()) { + return false; + } + if (fillHistograms && !configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsFoundFT0); } - registry.fill(HIST("Data/hVtxZ"), collision.posZ()); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hEventCounter"), EventSelectionStep::AfterEventSelection); + registry.fill(HIST("Data/hVtxZ"), collision.posZ()); + } return true; } @@ -1479,7 +1654,7 @@ struct HfTaskFlow { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::Eta); } @@ -1488,7 +1663,7 @@ struct HfTaskFlow { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::Cluster); } @@ -1497,7 +1672,8 @@ struct HfTaskFlow { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { + registry.fill(HIST("Data/Mft/hPtMft"), mftTrack.pt()); registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::Pt); } @@ -1505,14 +1681,14 @@ struct HfTaskFlow { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::DCAxy); } if (configMft.cutOnDcaZ && std::abs(dcaZ) > configMft.mftMaxDCAz) { return false; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hDcaXYMft"), dcaXY); registry.fill(HIST("Data/Mft/hDcaZMft"), dcaZ); registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::DCAz); @@ -1525,7 +1701,8 @@ struct HfTaskFlow { return false; } } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { + registry.fill(HIST("Data/Mft/hChi2OverNdfMft"), mftTrack.chi2() / std::max(2.0f * mftTrack.nClusters() - 5.0f, 1.0f)); registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::Chi2OverNdf); } @@ -1537,13 +1714,13 @@ struct HfTaskFlow { return false; } } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::Phi); } // cut on the track algorithm of MFT tracks if (mftTrack.isCA()) { - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::IsCA); registry.fill(HIST("Data/Mft/hPtVsClustersCA"), mftTrack.pt(), mftTrack.nClusters()); } @@ -1553,7 +1730,7 @@ struct HfTaskFlow { } } else { - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::IsLTF); registry.fill(HIST("Data/Mft/hPtVsClustersLTF"), mftTrack.pt(), mftTrack.nClusters()); } @@ -1571,13 +1748,13 @@ struct HfTaskFlow { bool isAmbiguousMftTrack(TTrack const& mftTrack, bool fillHistograms) { if (mftTrack.ambDegree() > 1) { - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hAmbiguityOfMftTracks"), MftTrackAmbiguityStep::NumberOfAmbiguousTracks); } return true; } - if (fillHistograms) { + if (fillHistograms && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hAmbiguityOfMftTracks"), MftTrackAmbiguityStep::NumberOfNonAmbiguousTracks); } return false; @@ -1601,7 +1778,7 @@ struct HfTaskFlow { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision - int sampleIndex = gRandom->Uniform(0, configTask.nSamples); + int sampleIndex = static_cast(gRandom->Uniform(0, configTask.nSamples)); // TRIGGER PARTICLE for (const auto& track1 : tracksTrigger) { @@ -1655,7 +1832,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for trigger particle - if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed) && !configTask.removeQAForSystematics) { if constexpr (!std::is_same_v) { // IF TPC-TPC case if constexpr (std::is_same_v) { // IF D0 CASE -> TPC-TPC D0-h fillTriggerQa(multiplicity, eta1, phi1, pt1); @@ -1688,7 +1865,9 @@ struct HfTaskFlow { if constexpr (std::is_same_v) { if (isSameEvent && loopCounter == 1) { // To avoid double counting, we fill the plots only the first time - registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::NoSelection); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::NoSelection); + } if (!isAcceptedMftTrack(track2, 0.f, 0.f, true)) { continue; @@ -1731,19 +1910,19 @@ struct HfTaskFlow { const double kLimit = 3.0 * configCentral.mergingCut; - bool bIsBelow = false; + [[maybe_unused]] bool bIsBelow = false; if (std::abs(dPhiStarLow) < kLimit || std::abs(dPhiStarHigh) < kLimit || dPhiStarLow * dPhiStarHigh < 0) { - for (double rad(configCentral.minMergingRadius); rad < configCentral.maxMergingRadius; rad += 0.01) { // FIXME: Variable 'rad' with floating point type 'double' should not be used as a loop counter. + constexpr double StepRad = 0.01; + const int nSteps = static_cast((configCentral.maxMergingRadius - configCentral.minMergingRadius) / StepRad); + for (int iStep = 1; iStep < nSteps; ++iStep) { + double rad = configCentral.minMergingRadius + iStep * StepRad; double dPhiStar = getDPhiStar(track1, track2, rad, magneticField); if (std::abs(dPhiStar) < kLimit) { bIsBelow = true; break; } } - if (bIsBelow) { - continue; - } } } } @@ -1803,7 +1982,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for associated particle - if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed) && !configTask.removeQAForSystematics) { if constexpr (!std::is_same_v) { // IF TPC-TPC case if constexpr (std::is_same_v) { // IF D0 CASE -> TPC-TPC D0-h fillAssociatedQa(multiplicity, eta2, phi2); @@ -1815,13 +1994,10 @@ struct HfTaskFlow { } else { // IF TPC-MFT case if constexpr (std::is_same_v) { // IF D0 CASE -> TPC-MFT D0-h fillAssociatedQa(multiplicity, eta2, phi2); - registry.fill(HIST("Data/Mft/hPtMft"), pt2); } else if constexpr (std::is_same_v) { // IF LC CASE -> TPC-MFT Lc-h fillAssociatedQa(multiplicity, eta2, phi2); - registry.fill(HIST("Data/Mft/hPtMft"), pt2); } else { // IF NEITHER D0 NOR LC -> TPC-MFT h-h fillAssociatedQa(multiplicity, eta2, phi2); - registry.fill(HIST("Data/Mft/hPtMft"), pt2); } // end of if condition for TPC-TPC or TPC-MFT case } } @@ -1838,7 +2014,7 @@ struct HfTaskFlow { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision - int sampleIndex = gRandom->Uniform(0, configTask.nSamples); + int sampleIndex = static_cast(gRandom->Uniform(0, configTask.nSamples)); // TRIGGER PARTICLE for (const auto& track1 : tracksTrigger) { @@ -1888,14 +2064,13 @@ struct HfTaskFlow { } // FILL QA PLOTS for trigger particle - if (isSameEvent) { + if (isSameEvent && !configTask.removeQAForSystematics) { if constexpr (std::is_same_v) { fillTriggerQa(multiplicity, eta1, phi1, pt1); } else if constexpr (std::is_same_v) { fillTriggerQa(multiplicity, eta1, phi1, pt1); } else { fillTriggerQa(multiplicity, eta1, phi1, pt1); - registry.fill(HIST("Data/hEfficiencyTrigger"), pt1, eta1, posZ); } } @@ -1903,7 +2078,7 @@ struct HfTaskFlow { for (const auto& track2 : tracksAssoc) { // Fill QA plot for all MFT tracks () (only if cutAmbiguousTracks is false to avoid double counting) - if (!cutAmbiguousTracks && isSameEvent && (loopCounter == 1)) { + if (!cutAmbiguousTracks && isSameEvent && (loopCounter == 1) && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hAmbiguityOfMftTracks"), MftTrackAmbiguityStep::AllMftTracks); } @@ -1920,7 +2095,10 @@ struct HfTaskFlow { } if (isSameEvent && loopCounter == 1) { // To avoid double counting, we fill the plots only the first time - registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::NoSelection); + + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::NoSelection); + } if (!isAcceptedMftTrack(reassociatedMftTrack, reassociatedMftTrackDcaXY, reassociatedMftTrackDcaZ, true)) { continue; @@ -1932,7 +2110,7 @@ struct HfTaskFlow { } // Fill QA plot for MFT tracks after physical selection (eta + clusters) - if (!cutAmbiguousTracks && isSameEvent && (loopCounter == 1)) { + if (!cutAmbiguousTracks && isSameEvent && (loopCounter == 1) && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hAmbiguityOfMftTracks"), MftTrackAmbiguityStep::AfterTrackSelection); } @@ -1940,7 +2118,7 @@ struct HfTaskFlow { // Fill plots only if cutAmbiguousTracks is false (to avoid double counting) if (isAmbiguousMftTrack(track2, (!cutAmbiguousTracks && isSameEvent && (loopCounter == 1)))) { // If the MFT track is ambiguous we may cut or not on the ambiguous track - if (isSameEvent && (loopCounter == 1)) { + if (isSameEvent && (loopCounter == 1) && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hReassociationMftTracks"), ReassociationMftTracks::NotReassociatedMftTracks); } if (cutAmbiguousTracks) { @@ -1949,7 +2127,7 @@ struct HfTaskFlow { } if (reassociatedMftTrack.collisionId() != track2.bestCollisionId()) { - if (isSameEvent && (loopCounter == 1)) { + if (isSameEvent && (loopCounter == 1) && !configTask.removeQAForSystematics) { registry.fill(HIST("Data/Mft/hReassociationMftTracks"), ReassociationMftTracks::ReassociatedMftTracks); } } @@ -2012,17 +2190,13 @@ struct HfTaskFlow { } // FILL QA PLOTS for associated particle - if (isSameEvent && (loopCounter == 1)) { + if (isSameEvent && (loopCounter == 1) && !configTask.removeQAForSystematics) { if constexpr (std::is_same_v) { fillAssociatedQa(multiplicity, eta2, phi2); - registry.fill(HIST("Data/Mft/hPtMft"), pt2); } else if constexpr (std::is_same_v) { fillAssociatedQa(multiplicity, eta2, phi2); - registry.fill(HIST("Data/Mft/hPtMft"), pt2); } else { fillAssociatedQa(multiplicity, eta2, phi2); - registry.fill(HIST("Data/Mft/hPtMft"), pt2); - registry.fill(HIST("Data/hEfficiencyAssociated"), pt2, eta2, posZ); } } // end of fill QA } // end of loop over tracks2 @@ -2037,7 +2211,7 @@ struct HfTaskFlow { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision - int sampleIndex = gRandom->Uniform(0, configTask.nSamples); + int sampleIndex = static_cast(gRandom->Uniform(0, configTask.nSamples)); // TRIGGER PARTICLE for (auto const& track1 : tracksTrigger) { @@ -2049,7 +2223,10 @@ struct HfTaskFlow { } } else if constexpr (std::is_same_v) { if (isSameEvent && loopCounter == 1) { // To avoid double counting, we fill the plots only the first time - registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::NoSelection); + + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::NoSelection); + } if (!isAcceptedMftTrack(track1, 0.f, 0.f, true)) { continue; @@ -2130,7 +2307,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for trigger particle - if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed) && !configTask.removeQAForSystematics) { if constexpr (!std::is_same_v) { // If not FilteredMftTracks as trigger -> TPC-FV0a correlations if constexpr (std::is_same_v) { // IF D0 CASE -> TPC-FV0a D0-h if constexpr (std::is_same_v) { // IF NEITHER D0 NOR LC -> @@ -2243,8 +2420,13 @@ struct HfTaskFlow { target->getPairHist()->Fill(step, eta1 - eta2, 0.5, pt1, multiplicity, deltaPhi, posZ, amplitude * centralityWeight * triggerWeight * associatedWeight); } else if (configTask.doEtaDependentFlow) { - target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, - amplitude * centralityWeight * triggerWeight * associatedWeight); + if (!configFit.discriminateInnerOrOuter) { + target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, + amplitude * centralityWeight * triggerWeight * associatedWeight); + } else { + target->getPairHist()->Fill(step, sampleIndex, posZ, isInnerOrOuter(channelId, fitType), eta1, deltaPhi, eta1 - eta2, + amplitude * centralityWeight * triggerWeight * associatedWeight); + } } else { target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, amplitude * centralityWeight * triggerWeight * associatedWeight); @@ -2255,7 +2437,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for associated particle - if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed) && !configTask.removeQAForSystematics) { if constexpr (!std::is_same_v) { // If not FilteredMftTracks as trigger -> TPC-Ft0a correlations if constexpr (std::is_same_v) { // IF D0 CASE -> TPC-FV0a D0-h if (fitType == isFT0A) { @@ -2298,7 +2480,7 @@ struct HfTaskFlow { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision - int sampleIndex = gRandom->Uniform(0, configTask.nSamples); + int sampleIndex = static_cast(gRandom->Uniform(0, configTask.nSamples)); // TRIGGER PARTICLE for (auto const& track1 : tracksTrigger) { @@ -2308,16 +2490,18 @@ struct HfTaskFlow { auto reassociatedMftTrackDcaXY = 0.f; auto reassociatedMftTrackDcaZ = 0.f; - if constexpr (std::is_same_v, TTracksAssoc>) { + if constexpr (std::is_same_v, TTracksTrig>) { reassociatedMftTrackDcaXY = track1.bestDCAXY(); } - if constexpr (std::is_same_v, TTracksAssoc>) { + if constexpr (std::is_same_v, TTracksTrig>) { reassociatedMftTrackDcaXY = track1.bestDCAXY(); reassociatedMftTrackDcaZ = track1.bestDCAZ(); } if (isSameEvent && loopCounter == 1) { // To avoid double counting, we fill the plots only the first time - registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::NoSelection); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::NoSelection); + } if (!isAcceptedMftTrack(reassociatedMftTrack, reassociatedMftTrackDcaXY, reassociatedMftTrackDcaZ, true)) { continue; @@ -2353,7 +2537,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for trigger particle - if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed) && !configTask.removeQAForSystematics) { if constexpr (std::is_same_v) { fillTriggerQa(multiplicity, eta1, phi1, pt1); } else if constexpr (std::is_same_v) { @@ -2416,15 +2600,20 @@ struct HfTaskFlow { target->getPairHist()->Fill(step, eta1 - eta2, 0.5, pt1, multiplicity, deltaPhi, posZ, amplitude * centralityWeight * triggerWeight * associatedWeight); } else if (configTask.doEtaDependentFlow) { - target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, - amplitude * centralityWeight * triggerWeight * associatedWeight); + if (!configFit.discriminateInnerOrOuter) { + target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, + amplitude * centralityWeight * triggerWeight * associatedWeight); + } else { + target->getPairHist()->Fill(step, sampleIndex, posZ, isInnerOrOuter(channelId, fitType), eta1, deltaPhi, eta1 - eta2, + amplitude * centralityWeight * triggerWeight * associatedWeight); + } } else { target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, amplitude * centralityWeight * triggerWeight * associatedWeight); } // FILL QA PLOTS for associated particle - if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed) && !configTask.removeQAForSystematics) { if (fitType == isFT0A) { fillAssociatedQa(multiplicity, eta2, phi2); } @@ -2442,7 +2631,7 @@ struct HfTaskFlow { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision - int sampleIndex = gRandom->Uniform(0, configTask.nSamples); + int sampleIndex = static_cast(gRandom->Uniform(0, configTask.nSamples)); // TRIGGER PARTICLE FROM FT0A for (std::size_t indexChannelA = 0; indexChannelA < ft0as.channelA().size(); indexChannelA++) { @@ -2462,7 +2651,7 @@ struct HfTaskFlow { registry.fill(HIST("Trig_hist_FT0A_FT0C"), sampleIndex, posZ, 0.5, amplitudeA * centralityWeight * triggerWeight); } - if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed) && !configTask.removeQAForSystematics) { fillTriggerQa(multiplicity, etaA, phiA, 0.5); } // end of fill trigger QA @@ -2480,14 +2669,22 @@ struct HfTaskFlow { target->getPairHist()->Fill(step, etaA - etaC, 0.5, 0.5, multiplicity, deltaPhi, posZ, amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); } else if (configTask.doEtaDependentFlow) { - target->getPairHist()->Fill(step, sampleIndex, posZ, etaC, etaA, deltaPhi, etaA - etaC, - amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); + // target->getPairHist()->Fill(step, sampleIndex, posZ, etaC, etaA, deltaPhi, etaA - etaC, + // amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); + + if (!configFit.discriminateInnerOrOuter) { + target->getPairHist()->Fill(step, sampleIndex, posZ, etaC, etaA, deltaPhi, etaA - etaC, + amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); + } else { + target->getPairHist()->Fill(step, sampleIndex, posZ, isInnerOrOuter(channelIdA, isFT0A), isInnerOrOuter(channelIdC, isFT0C), deltaPhi, etaA - etaC, + amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); + } } else { target->getPairHist()->Fill(step, sampleIndex, posZ, 0.5, multiplicity, deltaPhi, etaA - etaC, amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); } - if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed) && !configTask.removeQAForSystematics) { fillAssociatedQa(multiplicity, etaC, phiC); } // end of fill associated QA } // end of associated loop @@ -2502,21 +2699,16 @@ struct HfTaskFlow { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision - int sampleIndex = gRandom->Uniform(0, configTask.nSamples); - bool fillQaPlots = false; - - if (configTask.fillOnlyStepAll) { - if (step == CorrelationContainer::kCFStepAll) { - fillQaPlots = true; - } - } else { - if (step == CorrelationContainer::kCFStepTrackedOnlyPrim) { - fillQaPlots = true; - } - } + int sampleIndex = static_cast(gRandom->Uniform(0, configTask.nSamples)); for (auto const& track1 : tracksTrigger) { - loopCounter++; + + if (configTask.useCutNeutralParticles) { + auto pdgTriggerParticle = pdg->GetParticle(track1.pdgCode()); + if (!pdgTriggerParticle || std::abs(pdgTriggerParticle->Charge()) < o2::constants::math::Almost0) { + continue; + } + } if (track1.eta() < configTask.etaMcParticlesTriggerMin || track1.eta() > configTask.etaMcParticlesTriggerMax) { continue; @@ -2538,8 +2730,7 @@ struct HfTaskFlow { } // FILL QA FOR TRIGGER PARTICLE - if (isSameEvent && fillQaPlots) { - registry.fill(HIST("MC/hEfficiencyTrigger"), track1.pt(), track1.eta(), posZ); + if (isSameEvent && !configTask.removeQAForSystematics) { if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { @@ -2559,8 +2750,17 @@ struct HfTaskFlow { } } + loopCounter++; + for (auto const& track2 : tracksAssoc) { + if (configTask.useCutNeutralParticles) { + auto pdgAssociatedParticle = pdg->GetParticle(track2.pdgCode()); + if (!pdgAssociatedParticle || std::abs(pdgAssociatedParticle->Charge()) < o2::constants::math::Almost0) { + continue; + } + } + if (track1.globalIndex() == track2.globalIndex()) { continue; } @@ -2574,8 +2774,8 @@ struct HfTaskFlow { continue; } - float deltaPhi = RecoDecay::constrainAngle(track2.phi() - track1.phi(), -PIHalf); - float deltaEta = track2.eta() - track1.eta(); + float deltaPhi = RecoDecay::constrainAngle(track1.phi() - track2.phi(), -PIHalf); + float deltaEta = track1.eta() - track2.eta(); if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { target->getPairHist()->Fill(step, deltaEta, track2.pt(), track1.pt(), multiplicity, deltaPhi, posZ, @@ -2589,8 +2789,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for associated particle - if (isSameEvent && fillQaPlots && (loopCounter == 1)) { - registry.fill(HIST("MC/hEfficiencyAssociated"), track2.pt(), track2.eta(), posZ); + if (isSameEvent && (loopCounter == 1) && !configTask.removeQAForSystematics) { if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { fillAssociatedQa(multiplicity, track2.eta(), track2.phi()); } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { @@ -2655,7 +2854,7 @@ struct HfTaskFlow { auto bc = collision1.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; + float multiplicity = 0.f; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracks1.size(); } else { @@ -2666,14 +2865,14 @@ struct HfTaskFlow { if (configCollision.useCentrality) { getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, true)); if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + continue; } } + if (!configCollision.useCentrality && (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity)) { + continue; + } + corrContainer->fillEvent(multiplicity, step); fillCorrelations(corrContainer, step, tracks1, tracks2, multiplicity, collision1.posZ(), false, getMagneticField(bc.timestamp()), centralityWeight); } @@ -2716,7 +2915,7 @@ struct HfTaskFlow { auto bc = collision1.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; + float multiplicity = 0.f; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracksTrigger.size(); } else { @@ -2727,14 +2926,14 @@ struct HfTaskFlow { if (configCollision.useCentrality) { getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, true)); if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + continue; } } + if (!configCollision.useCentrality && (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity)) { + continue; + } + auto slicedTriggerTracks = tracksTrigger.sliceBy(presliceTrigger, collision1.globalIndex()); auto slicedAssociatedTracks = tracksAssoc.sliceBy(presliceAssociated, collision2.globalIndex()); @@ -2778,7 +2977,7 @@ struct HfTaskFlow { auto bc = collision1.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto tracksForMultiplicity = tracksTpc.sliceByCached(o2::aod::track::collisionId, collision1.globalIndex(), cache); - auto multiplicity = 0; + float multiplicity = 0.f; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracksForMultiplicity.size(); } else { @@ -2789,14 +2988,14 @@ struct HfTaskFlow { if (configCollision.useCentrality) { getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, true)); if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + continue; } } + if (!configCollision.useCentrality && (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity)) { + continue; + } + // if TPC-MFT cases if constexpr (std::is_same_v) { auto slicedTriggerTracks = tracksTrigger.sliceBy(presliceTrigger, collision1.globalIndex()); @@ -2824,8 +3023,8 @@ struct HfTaskFlow { // return multiplicity; // }; - auto getMultiplicity = [&tracksTrigger, this](FilteredCollisionsWSelMult::iterator const& collision) { - auto associatedTracks = tracksTrigger.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); + auto getMultiplicity = [&tracksTpc, this](FilteredCollisionsWSelMult::iterator const& collision) { + auto associatedTracks = tracksTpc.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); auto mult = associatedTracks.size(); if (configCollision.useMultiplicityFromTracks) { return mult; @@ -2857,7 +3056,7 @@ struct HfTaskFlow { // auto tracksForMultiplicity = tracksTpc.sliceByCached(o2::aod::track::collisionId, collision1.globalIndex(), cache); // const auto& fv0 = collision2.foundFV0(); - // auto multiplicity = 0; + // float multiplicity = 0.f; // if (configCollision.useMultiplicityFromTracks) { // multiplicity = tracksForMultiplicity.size(); // } else { @@ -2865,7 +3064,7 @@ struct HfTaskFlow { // } // if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - // return; + // continue; // } // corrContainer->fillEvent(multiplicity, step); @@ -2880,7 +3079,7 @@ struct HfTaskFlow { auto tracksForMultiplicity = tracksTpc.sliceByCached(o2::aod::track::collisionId, collision1.globalIndex(), cache); const auto& ft0 = collision2.foundFT0(); - auto multiplicity = 0; + float multiplicity = 0.f; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracksForMultiplicity.size(); } else { @@ -2889,16 +3088,16 @@ struct HfTaskFlow { float centralityWeight = 1.0f; if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, true)); + getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, false)); if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + continue; } } + if (!configCollision.useCentrality && (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity)) { + continue; + } + corrContainer->fillEvent(multiplicity, step); fillCorrelationsFIT(corrContainer, step, slicedTriggerTracks, ft0, tracksAssoc, multiplicity, collision1.posZ(), false, fitType, centralityWeight); } @@ -2947,7 +3146,7 @@ struct HfTaskFlow { auto bc = collision1.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); auto tracksForMultiplicity = tracksTpc.sliceByCached(o2::aod::track::collisionId, collision1.globalIndex(), cache); - auto multiplicity = 0; + float multiplicity = 0.f; if (configCollision.useMultiplicityFromTracks) { multiplicity = tracksForMultiplicity.size(); } else { @@ -2958,14 +3157,14 @@ struct HfTaskFlow { if (configCollision.useCentrality) { getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, true)); if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + continue; } } + if (!configCollision.useCentrality && (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity)) { + continue; + } + corrContainer->fillEvent(multiplicity, step); fillCorrelationsFt0aFt0c(corrContainer, step, ft0as, ft0cs, multiplicity, collision1.posZ(), true, centralityWeight); } @@ -2994,26 +3193,18 @@ struct HfTaskFlow { return; } - registry.fill(HIST("Data/hNTracks"), tracks.size()); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hNTracks"), tracks.size()); + } + auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3041,26 +3232,18 @@ struct HfTaskFlow { return; } - registry.fill(HIST("Data/hNTracks"), tracks.size()); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hNTracks"), tracks.size()); + } + auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3088,26 +3271,18 @@ struct HfTaskFlow { return; } - registry.fill(HIST("Data/hNTracks"), tracks.size()); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hNTracks"), tracks.size()); + } + auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3128,26 +3303,18 @@ struct HfTaskFlow { return; } - registry.fill(HIST("Data/hNTracks"), tracks.size()); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hNTracks"), tracks.size()); + } + auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -3170,28 +3337,20 @@ struct HfTaskFlow { return; } - registry.fill(HIST("Data/hNTracks"), tracks.size()); - registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); - registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hNTracks"), tracks.size()); + registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); + registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); + } + auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -3214,34 +3373,30 @@ struct HfTaskFlow { return; } - registry.fill(HIST("Data/hNTracks"), tracks.size()); - registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); - registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hNTracks"), tracks.size()); + registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); + registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); + } + auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; + + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } auto uncorrectedMultiplicity = multiplicity; - registry.fill(HIST("Data/hMultiplicity_uncorrected_vs_corrected"), uncorrectedMultiplicity, multiplicity); + if (configCollision.useMultiplicityFromTracksCorrected) { multiplicity = getCorrectedMultiplicity(tracks); } - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hMultiplicity_uncorrected_vs_corrected"), uncorrectedMultiplicity, multiplicity); } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -3264,28 +3419,20 @@ struct HfTaskFlow { return; // when process function has iterator } - registry.fill(HIST("Data/hNTracks"), tracks.size()); - registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); - registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hNTracks"), tracks.size()); + registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); + registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); + } + auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -3321,23 +3468,12 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3358,23 +3494,12 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3405,23 +3530,12 @@ struct HfTaskFlow { auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3440,25 +3554,14 @@ struct HfTaskFlow { return; // when process function has iterator } - auto multiplicity = 0; auto bc = collision.template bc_as(); loadEfficiencyCorrection(bc.timestamp()); - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3662,24 +3765,15 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - registry.fill(HIST("Data/hNTracks"), tracks.size()); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hNTracks"), tracks.size()); } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -3713,23 +3807,12 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3758,23 +3841,12 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -3803,23 +3875,12 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -3848,25 +3909,15 @@ struct HfTaskFlow { loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { + loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -3895,25 +3946,15 @@ struct HfTaskFlow { loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { + loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -3944,23 +3985,12 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -3993,24 +4023,15 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - registry.fill(HIST("Data/hNTracks"), tracks.size()); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hNTracks"), tracks.size()); } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -4039,23 +4060,12 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -4084,23 +4094,12 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -4128,23 +4127,12 @@ struct HfTaskFlow { if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - auto multiplicity = 0; - if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks.size(); - } else { - multiplicity = getMultiplicityEstimator(collision, true); - } + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; - float centralityWeight = 1.0f; - if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision, true)); - if (getCentralityEstimator(collision, false) < configCollision.minCentrality || getCentralityEstimator(collision, false) >= configCollision.maxCentrality) { - return; - } - } else { - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; - } + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; } sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); @@ -4157,11 +4145,20 @@ struct HfTaskFlow { // MONTE-CARLO // =================================================================================================================================================================================================================================================================== - void processSameMcGen(FilteredMcCollisionsWMult::iterator const& mcCollision, + void processSameMcGen(FilteredMcCollisionsWMultWCollsExtra::iterator const& mcCollision, FilteredMcParticles const& mcParticles, SmallGroupMcCollisions const& collisions) { - auto multiplicity = 0; + + if (mcParticles.size() == 0) { // guard against empty filtered batch + return; + } + + if (collisions.size() == 0) { + return; + } + + float multiplicity = 0.f; if (configCollision.useMultiplicityFromTracks) { for (const auto& track : mcParticles) { if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { @@ -4172,12 +4169,27 @@ struct HfTaskFlow { multiplicity = mcCollision.multMCPVz(); } - if ((multiplicity < configCollision.minMultiplicity) || (multiplicity >= configCollision.maxMultiplicity)) { - return; + float centrality = -1.f; + for (const auto& collision : collisions) { + // if (!collision.sel8()) { + // continue; + // } + // if (collision.globalIndex() != mcCollision.bestCollisionIndex()) { + // continue; + // } + centrality = getCentralityEstimator(collision, false); + // break; } - if (collisions.size() == 0) { - return; + if (configCollision.useCentrality) { + if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { + return; + } + } + if (!configCollision.useCentrality) { + if ((multiplicity < configCollision.minMultiplicity) || (multiplicity >= configCollision.maxMultiplicity)) { + return; + } } sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepAll); @@ -4546,14 +4558,14 @@ struct HfTaskFlow { // MONTE-CARLO // =================================================================================================================================================================================================================================================================== - void processMixedMcGen(FilteredMcCollisionsWMult const& mcCollisions, + void processMixedMcGen(FilteredMcCollisionsWMultWCollsExtra const& mcCollisions, FilteredMcParticles const& mcParticles, SmallGroupMcCollisions const& collisions) { - auto getTracksSize = [&mcParticles, this](soa::Join::iterator const& mcCollision) { + auto getTracksSize = [&mcParticles, this](soa::Join::iterator const& mcCollision) { auto associatedTracks = mcParticles.sliceByCached(o2::aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), this->cache); - auto multiplicity = 0; + float multiplicity = 0.f; if (configCollision.useMultiplicityFromTracks) { for (const auto& track : associatedTracks) { if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { @@ -4571,13 +4583,26 @@ struct HfTaskFlow { auto tracksTuple = std::make_tuple(mcParticles, mcParticles); - Pair pairs{binningOnVtxAndMult, configTask.nMixedEvents, -1, mcCollisions, tracksTuple, &cache}; // -1 is the number of the bin to skip + Pair pairs{binningOnVtxAndMult, configTask.nMixedEvents, -1, mcCollisions, tracksTuple, &cache}; // -1 is the number of the bin to skip for (auto it = pairs.begin(); it != pairs.end(); it++) { auto& [collision1, tracks1, collision2, tracks2] = *it; - auto multiplicityCollision1 = 0; - auto multiplicityCollision2 = 0; + if (tracks1.size() == 0 || tracks2.size() == 0) { // guard against empty filtered batch + continue; + } + + auto groupedCollisions1 = collisions.sliceBy(collisionPerMcCollision, collision1.globalIndex()); + auto groupedCollisions2 = collisions.sliceBy(collisionPerMcCollision, collision2.globalIndex()); + if (groupedCollisions1.size() == 0) { + continue; + } + if (groupedCollisions2.size() == 0) { + continue; + } + + float multiplicityCollision1 = 0.f; + float multiplicityCollision2 = 0.f; if (configCollision.useMultiplicityFromTracks) { for (const auto& track : tracks1) { @@ -4595,20 +4620,42 @@ struct HfTaskFlow { multiplicityCollision2 = collision2.multMCPVz(); } - if ((multiplicityCollision1 < configCollision.minMultiplicity || multiplicityCollision1 >= configCollision.maxMultiplicity)) { - continue; + float centralityCollision1 = 999.f; + float centralityCollision2 = 999.f; + for (const auto& reconstructedCollision1 : groupedCollisions1) { + // if (!collision1.sel8()) { + // continue; + // } + // if (reconstructedCollision1.globalIndex() != collision1.bestCollisionIndex()) { + // continue; + // } + centralityCollision1 = getCentralityEstimator(reconstructedCollision1, false); + // break; } - if ((multiplicityCollision2 < configCollision.minMultiplicity || multiplicityCollision2 >= configCollision.maxMultiplicity)) { - continue; + for (const auto& reconstructedCollision2 : groupedCollisions2) { + // if (reconstructedCollision2.globalIndex() != collision2.bestCollisionIndex()) { + // continue; + // } + centralityCollision2 = getCentralityEstimator(reconstructedCollision2, false); + // break; } - auto groupedCollisions1 = collisions.sliceBy(collisionPerMcCollision, collision1.globalIndex()); - auto groupedCollisions2 = collisions.sliceBy(collisionPerMcCollision, collision2.globalIndex()); - if (groupedCollisions1.size() == 0) { - return; + if (configCollision.useCentrality) { + if (centralityCollision1 < configCollision.minCentrality || centralityCollision1 >= configCollision.maxCentrality) { + continue; + } + if (centralityCollision2 < configCollision.minCentrality || centralityCollision2 >= configCollision.maxCentrality) { + continue; + } } - if (groupedCollisions2.size() == 0) { - return; + + if (!configCollision.useCentrality) { + if ((multiplicityCollision1 < configCollision.minMultiplicity || multiplicityCollision1 >= configCollision.maxMultiplicity)) { + continue; + } + if ((multiplicityCollision2 < configCollision.minMultiplicity || multiplicityCollision2 >= configCollision.maxMultiplicity)) { + continue; + } } mixedEvent->fillEvent(multiplicityCollision1, CorrelationContainer::kCFStepAll); @@ -4706,7 +4753,7 @@ struct HfTaskFlow { } auto groupedreassociated3dMftTracks = reassociated3dMftTracks.sliceBy(perColReassociated3dTracks, reconstructedCollision.globalIndex()); - for (const auto& reassociated3dMftTrack : reassociated3dMftTracks) { + for (const auto& reassociated3dMftTrack : groupedreassociated3dMftTracks) { if (!reassociated3dMftTrack.has_mcParticle()) { continue; }