diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 6756a4e2334..6ac799fff5d 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -27,8 +27,10 @@ #include "Common/CCDB/EventSelectionParams.h" #include "Common/CCDB/RCTSelectionFlags.h" #include "Common/Core/RecoDecay.h" +#include "Common/Core/fwdtrackUtilities.h" #include "Common/DataModel/Centrality.h" #include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/McCollisionExtra.h" #include "Common/DataModel/Multiplicity.h" #include "Common/DataModel/TrackSelectionTables.h" @@ -61,6 +63,7 @@ #include +#include #include #include #include @@ -134,11 +137,19 @@ enum MftTrackSelectionStep { Pt, DCAxy, DCAz, + Chi2OverNdf, + Phi, IsLTF, IsCA, NMftTrackSelectionSteps }; +enum CentralityEstimators { + CentFT0C = 0, + CentFT0CVariant1, + CentFT0M +}; + enum MultiplicityEstimators { MultNTracksPV = 0, MultNumContrib, @@ -170,6 +181,7 @@ enum TrackSelection { 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"}; auto static constexpr MinFt0cCell = 96; @@ -211,6 +223,7 @@ struct HfTaskFlow { Configurable etaMcParticlesAssocMax{"etaMcParticlesAssocMax", -2.4f, "Maximum value for the eta of MC particles when used in cut function"}; Configurable etaMcParticlesAssocMin{"etaMcParticlesAssocMin", -3.6f, "Minimum value for the eta of MC particles when used in cut function"}; Configurable fillOnlyStepAll{"fillOnlyStepAll", true, "Fill Mc Gen QA plots only for StepAll, or only for Primaries"}; + Configurable loadCentralityWeight{"loadCentralityWeight", "", "Ccdb path to centrality weight correction"}; Configurable loadEfficienciesForTpc{"loadEfficienciesForTpc", "", "Ccdb path to Tpc tracks efficiency correction"}; Configurable loadEfficienciesForMft{"loadEfficienciesForMft", "", "Ccdb path to Mft tracks efficiency correction"}; Configurable loadEfficienciesForNch{"loadEfficienciesForNch", "", "Ccdb path to Nch estimation efficiency correction"}; @@ -229,6 +242,7 @@ struct HfTaskFlow { // configurables for collisions struct : ConfigurableGroup { std::string prefix = "ConfigCollision_group"; + Configurable centralityEstimator{"centralityEstimator", 0, "0: centFT0C, 1: CentFT0CVariant1, 2: centFT0M"}; Configurable isApplyGoodItsLayersAll{"isApplyGoodItsLayersAll", false, "Enable GoodITSLayersAll"}; Configurable isApplyGoodZvtxFT0vsPV{"isApplyGoodZvtxFT0vsPV", false, "Enable GoodZvtxFT0vsPV cut"}; Configurable isApplyNoCollInRofStandard{"isApplyNoCollInRofStandard", false, ""}; @@ -237,9 +251,12 @@ struct HfTaskFlow { Configurable isApplyNoCollInTimeRangeStrict{"isApplyNoCollInTimeRangeStrict", false, ""}; Configurable isApplyNoHighMultCollInPrevRof{"isApplyNoHighMultCollInPrevRof", false, ""}; Configurable isApplySameBunchPileup{"isApplySameBunchPileup", false, "Enable SameBunchPileup cut"}; + Configurable maxCentrality{"maxCentrality", 20, "maximum centrality"}; + Configurable minCentrality{"minCentrality", 0, "minimum centrality"}; Configurable maxMultiplicity{"maxMultiplicity", 300, "maximum multiplicity selection for collision"}; Configurable minMultiplicity{"minMultiplicity", 0, "minimum multiplicity selection for collision"}; - Configurable multiplicityEstimator{"multiplicityEstimator", 0, "0: multNTracksPV, 1: numContrib, 2: multFT0C, 3: multFT0M, 4: centFT0C, 5: centFT0CVariants1s, 6: centFT0M, 7: centFV0A, 8: centNTracksPV, 9: centNGlobal, 10: centMFT"}; + Configurable multiplicityEstimator{"multiplicityEstimator", 0, "0: multNTracksPV, 1: numContrib, 2: multFT0C, 3: multFT0M"}; + 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 requireRCTFlagChecker{"requireRCTFlagChecker", false, "Check event quality in run condition table"}; @@ -296,11 +313,18 @@ struct HfTaskFlow { Configurable etaMftTrackMin{"etaMftTrackMin", -3.36f, "Minimum value for the eta of MFT tracks when used in cut function"}; Configurable etaMftTrackMaxFilter{"etaMftTrackMaxFilter", -2.0f, "Maximum value for the eta of MFT tracks when used in filter"}; Configurable etaMftTrackMinFilter{"etaMftTrackMinFilter", -3.9f, "Minimum value for the eta of MFT tracks when used in filter"}; + Configurable maxChi2OverNdf{"maxChi2OverNdf", 1000.f, "maximum chi2/ndf for MFT tracks"}; Configurable mftMaxDCAxy{"mftMaxDCAxy", 2.0f, "Cut on dcaXY for MFT tracks"}; Configurable mftMaxDCAz{"mftMaxDCAz", 2.0f, "Cut on dcaZ for MFT tracks"}; Configurable nClustersMftTrack{"nClustersMftTrack", 5, "Minimum number of clusters for the reconstruction of MFT tracks"}; + Configurable phiMftTrackMin{"phiMftTrackMin", 0.1, "Minimum value for the phi of MFT tracks when used in cut function"}; + Configurable phiMftTrackMiddleMin{"phiMftTrackMiddleMin", PI - 0.1, "cut to remove before phi = pi for MFT tracks when used in cut function"}; + Configurable phiMftTrackMiddleMax{"phiMftTrackMiddleMax", PI + 0.1, "cut to remove after phi = pi for MFT tracks when used in cut function"}; + Configurable phiMftTrackMax{"phiMftTrackMax", TwoPI - 0.1, "Maximum value for the phi of MFT tracks when used in cut function"}; Configurable ptMftTrackMax{"ptMftTrackMax", 10.0f, "max value of MFT tracks pT when used in cut function"}; Configurable ptMftTrackMin{"ptMftTrackMin", 0.f, "min value of MFT tracks pT when used in cut function"}; + Configurable useMftChi2OverNdfCut{"useMftChi2OverNdfCut", false, "use mft track chi2/ndf cut"}; + Configurable useMftPhiCut{"useMftPhiCut", false, "if true, use the Mft phi function cut"}; Configurable useMftPtCut{"useMftPtCut", false, "if true, use the Mft pt function cut"}; Configurable useOnlyCATracks{"useOnlyCATracks", false, "if true, use strictly MFT tracks reconstructed with CA algo."}; Configurable useOnlyLTFTracks{"useOnlyLTFTracks", false, "if true, use strictly MFT tracks reconstructed with LTF algo."}; @@ -328,6 +352,7 @@ struct HfTaskFlow { TH3D* mEfficiencyTpc = nullptr; TH3D* mEfficiencyMft = nullptr; TH1D* mEfficiencyNch = nullptr; + TH1D* mCentralityWeight = nullptr; bool areCorrectionsLoaded = false; // o2::aod::rctsel::RCTFlagsChecker rctChecker{"CBT_muon_glo", false, false, true}; @@ -336,12 +361,14 @@ struct HfTaskFlow { // using declarations : DATA // ========================= - using FilteredCollisionsWSelMult = soa::Filtered>; + using FilteredCollisionsWSelMult = soa::Filtered>; using HfCandidatesSelD0 = soa::Filtered>; using HfCandidatesSelLc = soa::Filtered>; using FilteredTracksWDcaSel = soa::Filtered>; + using FilteredTracksWDcaSelWLabels = soa::Filtered>; using FilteredMftTracks = soa::Filtered; + using FilteredMftTracksWCollsMcLabels = soa::Filtered>; // ========================= // using declarations : MC @@ -349,6 +376,7 @@ struct HfTaskFlow { using SmallGroupMcCollisions = soa::SmallGroups>; using FilteredMcCollisionsWMult = soa::Filtered>; + using FilteredMcCollisionsWMultWCollsExtra = soa::Filtered>; using FilteredMcParticles = soa::Filtered; // ========================= @@ -426,10 +454,13 @@ struct HfTaskFlow { ConfigurableAxis axisMass{"axisMass", {1, 1.5848, 2.1848}, "axis of invariant mass of candidates"}; 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 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"}; ConfigurableAxis axisEtaTrigger{"axisEtaTrigger", {48, -1, 1}, "eta axis for TPC histograms"}; + ConfigurableAxis axisDcaXY{"axisDcaXY", {100, 0, 2}, "dcaXY axis for MFT histograms"}; + ConfigurableAxis axisDcaZ{"axisDcaZ", {100, -2, 2}, "dcaZ axis for MFT histograms"}; ConfigurableAxis axisDeltaPhi{"axisDeltaPhi", {72, -PIHalf, PIHalf * 3}, "delta phi axis for histograms"}; ConfigurableAxis axisDeltaEta{"axisDeltaEta", {48, -2.4, 2.4}, "delta eta axis for histograms"}; ConfigurableAxis axisMultiplicity{"axisMultiplicity", {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 100.1}, "multiplicity axis for histograms"}; @@ -496,6 +527,8 @@ struct HfTaskFlow { labelsMftTracksSelection[MftTrackSelectionStep::Pt] = "MFT tracks after pT selection"; labelsMftTracksSelection[MftTrackSelectionStep::DCAxy] = "MFT tracks after DCAxy selection"; labelsMftTracksSelection[MftTrackSelectionStep::DCAz] = "MFT tracks after DCAz selection"; + labelsMftTracksSelection[MftTrackSelectionStep::Chi2OverNdf] = "MFT tracks after Chi2OverNdf selection"; + labelsMftTracksSelection[MftTrackSelectionStep::Phi] = "MFT tracks after phi selection"; labelsMftTracksSelection[MftTrackSelectionStep::IsLTF] = "Linear Track Finder MFT tracks"; labelsMftTracksSelection[MftTrackSelectionStep::IsCA] = "Cellular Automaton MFT tracks"; registry.get(HIST("Data/Mft/hMftTracksSelection"))->SetMinimum(0); @@ -517,6 +550,8 @@ struct HfTaskFlow { 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}}); + registry.add("Data/Mft/hDcaXYMft", "", {HistType::kTH1D, {configAxis.axisDcaXY}}); + registry.add("Data/Mft/hDcaZMft", "", {HistType::kTH1D, {configAxis.axisDcaZ}}); registry.add("Data/Mft/hNMftTracks", "", {HistType::kTH1F, {configAxis.axisMultiplicity}}); registry.add("Data/Mft/hNBestCollisionFwd", "", {HistType::kTH1F, {configAxis.axisMultiplicity}}); } @@ -550,6 +585,7 @@ struct HfTaskFlow { 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]; @@ -659,8 +695,7 @@ struct HfTaskFlow { 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", "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); - registry.add("Data/hMultiplicity_corrected", "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); + 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}}}); @@ -881,7 +916,7 @@ struct HfTaskFlow { if (doprocessSameMcGen) { 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("MC/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtAssoc}, {configAxis.axisEtaAssociated}, {configAxis.axisVertex}}}); if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { addHistograms(); @@ -916,6 +951,13 @@ 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}}}); + } + } // End of init() function // ========================= @@ -987,6 +1029,30 @@ struct HfTaskFlow { } } + template + float getCentralityEstimator(TCollision const& collision, bool isSameEvent) + { + switch (configCollision.centralityEstimator) { + case CentralityEstimators::CentFT0C: + if (isSameEvent) { + registry.fill(HIST("Data/hCentrality_centFT0C"), collision.centFT0C()); + } + return collision.centFT0C(); + case CentralityEstimators::CentFT0CVariant1: + if (isSameEvent) { + registry.fill(HIST("Data/hCentrality_centFT0CVariant1"), collision.centFT0CVariant1()); + } + return collision.centFT0CVariant1(); + case CentralityEstimators::CentFT0M: + if (isSameEvent) { + registry.fill(HIST("Data/hCentrality_centFT0M"), collision.centFT0M()); + } + return collision.centFT0M(); + default: + return collision.centFT0C(); + } + } + template float getDPhiStar(TTrack const& track1, TTrackAssoc const& track2, float radius, int magField) { @@ -1160,21 +1226,28 @@ struct HfTaskFlow { 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(), (void*)mEfficiencyTpc); + LOGF(info, "Loaded efficiency histogram from %s (%p)", configTask.loadEfficienciesForTpc.value.c_str(), static_cast(mEfficiencyTpc)); } if (configTask.loadEfficienciesForMft.value.empty() == false) { mEfficiencyMft = ccdb->getForTimeStamp(configTask.loadEfficienciesForTpc, 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(), (void*)mEfficiencyMft); + LOGF(info, "Loaded efficiency histogram from %s (%p)", configTask.loadEfficienciesForMft.value.c_str(), static_cast(mEfficiencyMft)); } if (configTask.loadEfficienciesForNch.value.empty() == false) { 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(), (void*)mEfficiencyNch); + LOGF(info, "Loaded efficiency histogram from %s (%p)", configTask.loadEfficienciesForNch.value.c_str(), static_cast(mEfficiencyNch)); + } + if (configTask.loadCentralityWeight.value.empty() == false) { + mCentralityWeight = ccdb->getForTimeStamp(configTask.loadCentralityWeight, timestamp); + if (mCentralityWeight == nullptr) { + LOGF(fatal, "Could not load centrality weight correction from %s", configTask.loadCentralityWeight.value.c_str()); + } + LOGF(info, "Loaded centrality weight from %s (%p)", configTask.loadCentralityWeight.value.c_str(), static_cast(mCentralityWeight)); } areCorrectionsLoaded = true; } @@ -1252,6 +1325,21 @@ struct HfTaskFlow { return trackCounter; } + bool getCentralityWeight(float& weightCent, const float centrality) + { + float weight = 1.; + if (mCentralityWeight) { + weight = mCentralityWeight->GetBinContent(mCentralityWeight->FindBin(centrality)); + } else { + weight = 1.0; + } + if (weight == 0) { + return false; + } + weightCent = weight; + return true; + } + // ========================= // Cuts with functions // ========================= @@ -1327,9 +1415,6 @@ struct HfTaskFlow { } if (fillHistograms) { registry.fill(HIST("Data/hPreciseEventCounter"), SpecificEventSelectionStep::IsRctFlagChecked); - } - - if (fillHistograms) { registry.fill(HIST("Data/hEventCounter"), EventSelectionStep::AfterEventSelection); } @@ -1429,9 +1514,34 @@ struct HfTaskFlow { } if (fillHistograms) { + registry.fill(HIST("Data/Mft/hDcaXYMft"), dcaXY); + registry.fill(HIST("Data/Mft/hDcaZMft"), dcaZ); registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::DCAz); } + if (configMft.useMftChi2OverNdfCut) { + float ndfMftTrack = std::max(2.0f * mftTrack.nClusters() - 5.0f, 1.0f); + float mftChi2OverNdf = mftTrack.chi2() / ndfMftTrack; + if (mftChi2OverNdf > configMft.maxChi2OverNdf) { + return false; + } + } + if (fillHistograms) { + registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::Chi2OverNdf); + } + + if (configMft.useMftPhiCut) { + auto phiMftTrack = mftTrack.phi(); + o2::math_utils::bringTo02Pi(phiMftTrack); + if (phiMftTrack > configMft.phiMftTrackMax || phiMftTrack < configMft.phiMftTrackMin || + (phiMftTrack > configMft.phiMftTrackMiddleMin && phiMftTrack < configMft.phiMftTrackMiddleMax)) { + return false; + } + } + if (fillHistograms) { + registry.fill(HIST("Data/Mft/hMftTracksSelection"), MftTrackSelectionStep::Phi); + } + // cut on the track algorithm of MFT tracks if (mftTrack.isCA()) { if (fillHistograms) { @@ -1486,8 +1596,8 @@ struct HfTaskFlow { template void fillCorrelations(TTarget target, CorrelationContainer::CFStep step, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, - float multiplicity, float posZ, bool sameEvent, int magneticField) + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, + float multiplicity, float posZ, bool isSameEvent, int magneticField, float centralityWeight) { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; @@ -1495,7 +1605,7 @@ struct HfTaskFlow { int sampleIndex = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE - for (const auto& track1 : tracks1) { + for (const auto& track1 : tracksTrigger) { loopCounter++; if constexpr (std::is_same_v) { @@ -1532,21 +1642,21 @@ struct HfTaskFlow { // fill single-track distributions if (!fillingHFcontainer) { // if not HF-h case - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, centralityWeight * triggerWeight); if (configTask.doEtaDependentFlow) { - registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.eta(), centralityWeight * triggerWeight); } if (configTask.doVariationContainers) { - registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.pt(), triggerWeight); + registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.pt(), centralityWeight * triggerWeight); } } else { - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, centralityWeight * triggerWeight); } // FILL QA PLOTS for trigger particle - if (sameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { 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); @@ -1567,7 +1677,7 @@ struct HfTaskFlow { } // ASSOCIATED PARTICLE - for (const auto& track2 : tracks2) { + for (const auto& track2 : tracksAssoc) { if constexpr (std::is_same_v) { if (!isAcceptedCentralTrack(track2)) { @@ -1578,7 +1688,7 @@ struct HfTaskFlow { // apply cuts for MFT tracks if constexpr (std::is_same_v) { - if (sameEvent && loopCounter == 1) { // To avoid double counting, we fill the plots only the first time + 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 (!isAcceptedMftTrack(track2, 0.f, 0.f, true)) { @@ -1595,10 +1705,10 @@ struct HfTaskFlow { continue; } - if (configCentral.isApplyPtOrderingSameEvent && sameEvent && (track1.pt() <= track2.pt())) { + if (configCentral.isApplyPtOrderingSameEvent && isSameEvent && (track1.pt() <= track2.pt())) { continue; } - if (configCentral.isApplyPtOrderingMixedEvent && !sameEvent && (track1.pt() <= track2.pt())) { + if (configCentral.isApplyPtOrderingMixedEvent && !isSameEvent && (track1.pt() <= track2.pt())) { continue; } @@ -1680,21 +1790,21 @@ struct HfTaskFlow { // fill pair correlations if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, - triggerWeight * associatedWeight); + centralityWeight * triggerWeight * associatedWeight); } else if (configTask.doEtaDependentFlow) { target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, - triggerWeight * associatedWeight); + centralityWeight * triggerWeight * associatedWeight); } else { target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, - triggerWeight * associatedWeight); + centralityWeight * triggerWeight * associatedWeight); } } else { target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, invmass, - triggerWeight * associatedWeight); + centralityWeight * triggerWeight * associatedWeight); } // FILL QA PLOTS for associated particle - if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { 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); @@ -1723,8 +1833,8 @@ struct HfTaskFlow { template void fillCorrelationsReassociatedMftTracks(TTarget target, CorrelationContainer::CFStep step, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, - float multiplicity, float posZ, bool sameEvent, bool cutAmbiguousTracks) + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, + float multiplicity, float posZ, bool isSameEvent, bool cutAmbiguousTracks, float centralityWeight) { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; @@ -1732,7 +1842,7 @@ struct HfTaskFlow { int sampleIndex = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE - for (const auto& track1 : tracks1) { + for (const auto& track1 : tracksTrigger) { loopCounter++; if constexpr (std::is_same_v) { @@ -1765,21 +1875,21 @@ struct HfTaskFlow { // fill single-track distributions if (!fillingHFcontainer) { // if not HF-h case - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, centralityWeight * triggerWeight); if (configTask.doEtaDependentFlow) { - registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.eta(), centralityWeight * triggerWeight); } if (configTask.doVariationContainers) { - registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.pt(), triggerWeight); + registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.pt(), centralityWeight * triggerWeight); } } else { - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, centralityWeight * triggerWeight); } // FILL QA PLOTS for trigger particle - if (sameEvent) { + if (isSameEvent) { if constexpr (std::is_same_v) { fillTriggerQa(multiplicity, eta1, phi1, pt1); } else if constexpr (std::is_same_v) { @@ -1791,10 +1901,10 @@ struct HfTaskFlow { } // ASSOCIATED PARTICLE - for (const auto& track2 : tracks2) { + for (const auto& track2 : tracksAssoc) { // Fill QA plot for all MFT tracks () (only if cutAmbiguousTracks is false to avoid double counting) - if (!cutAmbiguousTracks && sameEvent && (loopCounter == 1)) { + if (!cutAmbiguousTracks && isSameEvent && (loopCounter == 1)) { registry.fill(HIST("Data/Mft/hAmbiguityOfMftTracks"), MftTrackAmbiguityStep::AllMftTracks); } @@ -1810,7 +1920,7 @@ struct HfTaskFlow { reassociatedMftTrackDcaZ = track2.bestDCAZ(); } - if (sameEvent && loopCounter == 1) { // To avoid double counting, we fill the plots only the first time + 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 (!isAcceptedMftTrack(reassociatedMftTrack, reassociatedMftTrackDcaXY, reassociatedMftTrackDcaZ, true)) { @@ -1823,15 +1933,15 @@ struct HfTaskFlow { } // Fill QA plot for MFT tracks after physical selection (eta + clusters) - if (!cutAmbiguousTracks && sameEvent && (loopCounter == 1)) { + if (!cutAmbiguousTracks && isSameEvent && (loopCounter == 1)) { registry.fill(HIST("Data/Mft/hAmbiguityOfMftTracks"), MftTrackAmbiguityStep::AfterTrackSelection); } // We check if the track is ambiguous or non-ambiguous (QA plots are filled in isAmbiguousMftTrack) // Fill plots only if cutAmbiguousTracks is false (to avoid double counting) - if (isAmbiguousMftTrack(track2, (!cutAmbiguousTracks && sameEvent && (loopCounter == 1)))) { + if (isAmbiguousMftTrack(track2, (!cutAmbiguousTracks && isSameEvent && (loopCounter == 1)))) { // If the MFT track is ambiguous we may cut or not on the ambiguous track - if (sameEvent && (loopCounter == 1)) { + if (isSameEvent && (loopCounter == 1)) { registry.fill(HIST("Data/Mft/hReassociationMftTracks"), ReassociationMftTracks::NotReassociatedMftTracks); } if (cutAmbiguousTracks) { @@ -1840,7 +1950,7 @@ struct HfTaskFlow { } if (reassociatedMftTrack.collisionId() != track2.bestCollisionId()) { - if (sameEvent && (loopCounter == 1)) { + if (isSameEvent && (loopCounter == 1)) { registry.fill(HIST("Data/Mft/hReassociationMftTracks"), ReassociationMftTracks::ReassociatedMftTracks); } } @@ -1862,10 +1972,10 @@ struct HfTaskFlow { continue; } - if (configCentral.isApplyPtOrderingSameEvent && sameEvent && (track1.pt() <= reassociatedMftTrack.pt())) { + if (configCentral.isApplyPtOrderingSameEvent && isSameEvent && (track1.pt() <= reassociatedMftTrack.pt())) { continue; } - if (configCentral.isApplyPtOrderingMixedEvent && !sameEvent && (track1.pt() <= reassociatedMftTrack.pt())) { + if (configCentral.isApplyPtOrderingMixedEvent && !isSameEvent && (track1.pt() <= reassociatedMftTrack.pt())) { continue; } @@ -1889,21 +1999,21 @@ struct HfTaskFlow { if (!fillingHFcontainer) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, - triggerWeight * associatedWeight); + centralityWeight * triggerWeight * associatedWeight); } else if (configTask.doEtaDependentFlow) { target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, - triggerWeight * associatedWeight); + centralityWeight * triggerWeight * associatedWeight); } else { target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, - triggerWeight * associatedWeight); + centralityWeight * triggerWeight * associatedWeight); } } else { target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, invmass, - triggerWeight * associatedWeight); + centralityWeight * triggerWeight * associatedWeight); } // FILL QA PLOTS for associated particle - if (sameEvent && (loopCounter == 1)) { + if (isSameEvent && (loopCounter == 1)) { if constexpr (std::is_same_v) { fillAssociatedQa(multiplicity, eta2, phi2); registry.fill(HIST("Data/Mft/hPtMft"), pt2); @@ -1922,8 +2032,8 @@ struct HfTaskFlow { template void fillCorrelationsFIT(TTarget target, CorrelationContainer::CFStep step, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TFits const&, - float multiplicity, float posZ, bool sameEvent, int fitType) + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, TFits const&, + float multiplicity, float posZ, bool isSameEvent, int fitType, float centralityWeight) { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; @@ -1931,7 +2041,7 @@ struct HfTaskFlow { int sampleIndex = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE - for (auto const& track1 : tracks1) { + for (auto const& track1 : tracksTrigger) { loopCounter++; if constexpr (std::is_same_v) { @@ -1939,7 +2049,7 @@ struct HfTaskFlow { continue; } } else if constexpr (std::is_same_v) { - if (sameEvent && loopCounter == 1) { // To avoid double counting, we fill the plots only the first time + 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 (!isAcceptedMftTrack(track1, 0.f, 0.f, true)) { @@ -1982,29 +2092,46 @@ struct HfTaskFlow { // fill single-track distributions if (!fillingHFcontainer) { // if not HF-h case - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, centralityWeight * triggerWeight); if (configTask.doEtaDependentFlow) { if (fitType == isFT0A) { - registry.fill(HIST("Trig_hist_TPC_FT0A"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + if constexpr (std::is_same_v) { + registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, track1.eta(), centralityWeight * triggerWeight); + } else { + registry.fill(HIST("Trig_hist_TPC_FT0A"), sampleIndex, posZ, track1.eta(), centralityWeight * triggerWeight); + } } else { - registry.fill(HIST("Trig_hist_TPC_FT0C"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + if constexpr (std::is_same_v) { + registry.fill(HIST("Trig_hist_MFT_FT0C"), sampleIndex, posZ, track1.eta(), centralityWeight * triggerWeight); + } else { + registry.fill(HIST("Trig_hist_TPC_FT0C"), sampleIndex, posZ, track1.eta(), centralityWeight * triggerWeight); + } } } if (configTask.doVariationContainers) { if (fitType == isFT0A) { - registry.fill(HIST("Trig_hist_TPC_FT0A"), sampleIndex, posZ, track1.pt(), triggerWeight); // think about event weight in near future + + if constexpr (std::is_same_v) { + registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, track1.pt(), centralityWeight * triggerWeight); + } else { + registry.fill(HIST("Trig_hist_TPC_FT0A"), sampleIndex, posZ, track1.pt(), centralityWeight * triggerWeight); + } } else { - registry.fill(HIST("Trig_hist_TPC_FT0C"), sampleIndex, posZ, track1.pt(), triggerWeight); // think about event weight in near future + if constexpr (std::is_same_v) { + registry.fill(HIST("Trig_hist_MFT_FT0C"), sampleIndex, posZ, track1.pt(), centralityWeight * triggerWeight); + } else { + registry.fill(HIST("Trig_hist_TPC_FT0C"), sampleIndex, posZ, track1.pt(), centralityWeight * triggerWeight); + } } } } else { - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, centralityWeight * triggerWeight); } // FILL QA PLOTS for trigger particle - if (sameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { 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 -> @@ -2062,18 +2189,18 @@ struct HfTaskFlow { // if (!fillingHFcontainer) { // if (!configTask.doEtaDependentFlow) { // target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, - // triggerWeight * associatedWeight); + // centralityWeight * triggerWeight * associatedWeight); // } else { // target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, - // triggerWeight * associatedWeight); + // centralityWeight * triggerWeight * associatedWeight); // } // } else { // target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, invmass, - // triggerWeight * associatedWeight); + // centralityWeight * triggerWeight * associatedWeight); // } // // FILL QA PLOTS for associated particle - // if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + // if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { // 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 // fillAssociatedQa(multiplicity, eta2, phi2); @@ -2095,9 +2222,9 @@ struct HfTaskFlow { // select the right channel size if it is FT0a or FT0c std::size_t channelSize = 0; if (fitType == isFT0C) { - channelSize = tracks2.channelC().size(); + channelSize = tracksAssoc.channelC().size(); } else if (fitType == isFT0A) { - channelSize = tracks2.channelA().size(); + channelSize = tracksAssoc.channelA().size(); } else { LOGF(fatal, "Cor Index %d out of range", fitType); } @@ -2106,7 +2233,7 @@ struct HfTaskFlow { int channelId = 0; float amplitude = 0.; - getChannel(tracks2, indexChannel, channelId, fitType, amplitude); + getChannel(tracksAssoc, indexChannel, channelId, fitType, amplitude); auto phi2 = getPhiFT0(channelId, fitType); auto eta2 = getEtaFT0(channelId, fitType); float deltaPhi = phi1 - phi2; @@ -2115,21 +2242,21 @@ struct HfTaskFlow { if (!fillingHFcontainer) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { target->getPairHist()->Fill(step, eta1 - eta2, 0.5, pt1, multiplicity, deltaPhi, posZ, - amplitude * triggerWeight * associatedWeight); + amplitude * centralityWeight * triggerWeight * associatedWeight); } else if (configTask.doEtaDependentFlow) { target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, - amplitude * triggerWeight * associatedWeight); + amplitude * centralityWeight * triggerWeight * associatedWeight); } else { target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, - amplitude * triggerWeight * associatedWeight); + amplitude * centralityWeight * triggerWeight * associatedWeight); } } else { target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, invmass, - amplitude * triggerWeight * associatedWeight); + amplitude * centralityWeight * triggerWeight * associatedWeight); } // FILL QA PLOTS for associated particle - if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { 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) { @@ -2166,8 +2293,8 @@ struct HfTaskFlow { template void fillCorrelationsFITReassociatedMftTracks(TTarget target, CorrelationContainer::CFStep step, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TFits const&, - float multiplicity, float posZ, bool sameEvent, bool cutAmbiguousTracks, int fitType) + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, TFits const&, + float multiplicity, float posZ, bool isSameEvent, bool cutAmbiguousTracks, int fitType, float centralityWeight) { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; @@ -2175,7 +2302,7 @@ struct HfTaskFlow { int sampleIndex = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE - for (auto const& track1 : tracks1) { + for (auto const& track1 : tracksTrigger) { loopCounter++; auto reassociatedMftTrack = track1.template mfttrack_as(); @@ -2190,7 +2317,7 @@ struct HfTaskFlow { reassociatedMftTrackDcaZ = track1.bestDCAZ(); } - if (sameEvent && loopCounter == 1) { // To avoid double counting, we fill the plots only the first time + 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 (!isAcceptedMftTrack(reassociatedMftTrack, reassociatedMftTrackDcaXY, reassociatedMftTrackDcaZ, true)) { @@ -2217,17 +2344,17 @@ struct HfTaskFlow { continue; } - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, centralityWeight * triggerWeight); if (configTask.doEtaDependentFlow) { - registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, eta1, triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, eta1, centralityWeight * triggerWeight); } if (configTask.doVariationContainers) { - registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, pt1, triggerWeight); + registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, pt1, centralityWeight * triggerWeight); } // FILL QA PLOTS for trigger particle - if (sameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { if constexpr (std::is_same_v) { fillTriggerQa(multiplicity, eta1, phi1, pt1); } else if constexpr (std::is_same_v) { @@ -2250,14 +2377,14 @@ struct HfTaskFlow { // if (!configTask.doEtaDependentFlow) { // target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, - // triggerWeight * associatedWeight); + // centralityWeight * triggerWeight * associatedWeight); // } else { // target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, - // triggerWeight * associatedWeight); + // centralityWeight * triggerWeight * associatedWeight); // } // // FILL QA PLOTS for associated particle - // if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + // if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { // fillAssociatedQa(multiplicity, eta2, phi2); // } // end of if condition to fill QA plots for associated particle // } // end of loop over FV0 channel indices @@ -2269,9 +2396,9 @@ struct HfTaskFlow { // select the right channel size if it is FT0a or FT0c std::size_t channelSize = 0; if (fitType == isFT0C) { - channelSize = tracks2.channelC().size(); + channelSize = tracksAssoc.channelC().size(); } else if (fitType == isFT0A) { - channelSize = tracks2.channelA().size(); + channelSize = tracksAssoc.channelA().size(); } else { LOGF(fatal, "Cor Index %d out of range", fitType); } @@ -2280,7 +2407,7 @@ struct HfTaskFlow { int channelId = 0; float amplitude = 0.; - getChannel(tracks2, indexChannel, channelId, fitType, amplitude); + getChannel(tracksAssoc, indexChannel, channelId, fitType, amplitude); auto phi2 = getPhiFT0(channelId, fitType); auto eta2 = getEtaFT0(channelId, fitType); float deltaPhi = phi1 - phi2; @@ -2288,17 +2415,17 @@ struct HfTaskFlow { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { target->getPairHist()->Fill(step, eta1 - eta2, 0.5, pt1, multiplicity, deltaPhi, posZ, - amplitude * triggerWeight * associatedWeight); + amplitude * centralityWeight * triggerWeight * associatedWeight); } else if (configTask.doEtaDependentFlow) { target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, - amplitude * triggerWeight * associatedWeight); + amplitude * centralityWeight * triggerWeight * associatedWeight); } else { target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, - amplitude * triggerWeight * associatedWeight); + amplitude * centralityWeight * triggerWeight * associatedWeight); } // FILL QA PLOTS for associated particle - if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { if (fitType == isFT0A) { fillAssociatedQa(multiplicity, eta2, phi2); } @@ -2311,7 +2438,7 @@ struct HfTaskFlow { template void fillCorrelationsFt0aFt0c(TTarget target, CorrelationContainer::CFStep step, TFT0As const& ft0as, TFT0Cs const& ft0cs, - float multiplicity, float posZ, bool sameEvent) + float multiplicity, float posZ, bool isSameEvent, float centralityWeight) { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; @@ -2322,21 +2449,21 @@ struct HfTaskFlow { for (std::size_t indexChannelA = 0; indexChannelA < ft0as.channelA().size(); indexChannelA++) { loopCounter++; int channelIdA = 0; - float amplitude = 0.; - getChannel(ft0as, indexChannelA, channelIdA, isFT0A, amplitude); + float amplitudeA = 0.; + getChannel(ft0as, indexChannelA, channelIdA, isFT0A, amplitudeA); auto phiA = getPhiFT0(channelIdA, isFT0A); auto etaA = getEtaFT0(channelIdA, isFT0A); - target->getTriggerHist()->Fill(step, 0.5, multiplicity, posZ, amplitude * triggerWeight); + target->getTriggerHist()->Fill(step, 0.5, multiplicity, posZ, amplitudeA * centralityWeight * triggerWeight); if (configTask.doEtaDependentFlow) { - registry.fill(HIST("Trig_hist_FT0A_FT0C"), sampleIndex, posZ, etaA, triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist_FT0A_FT0C"), sampleIndex, posZ, etaA, amplitudeA * centralityWeight * triggerWeight); } if (configTask.doVariationContainers) { - registry.fill(HIST("Trig_hist_FT0A_FT0C"), sampleIndex, posZ, 0.5, triggerWeight); + registry.fill(HIST("Trig_hist_FT0A_FT0C"), sampleIndex, posZ, 0.5, amplitudeA * centralityWeight * triggerWeight); } - if (sameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { fillTriggerQa(multiplicity, etaA, phiA, 0.5); } // end of fill trigger QA @@ -2344,24 +2471,24 @@ struct HfTaskFlow { for (std::size_t indexChannelC = 0; indexChannelC < ft0cs.channelC().size(); indexChannelC++) { int channelIdC = 0; - float amplitude = 0.; - getChannel(ft0cs, indexChannelC, channelIdC, isFT0C, amplitude); + float amplitudeC = 0.; + getChannel(ft0cs, indexChannelC, channelIdC, isFT0C, amplitudeC); auto phiC = getPhiFT0(channelIdC, isFT0C); auto etaC = getEtaFT0(channelIdC, isFT0C); float deltaPhi = RecoDecay::constrainAngle(phiA - phiC, -PIHalf); if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { target->getPairHist()->Fill(step, etaA - etaC, 0.5, 0.5, multiplicity, deltaPhi, posZ, - amplitude * triggerWeight * associatedWeight); + amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); } else if (configTask.doEtaDependentFlow) { target->getPairHist()->Fill(step, sampleIndex, posZ, etaC, etaA, deltaPhi, etaA - etaC, - amplitude * triggerWeight * associatedWeight); + amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); } else { target->getPairHist()->Fill(step, sampleIndex, posZ, 0.5, multiplicity, deltaPhi, etaA - etaC, - amplitude * triggerWeight * associatedWeight); + amplitudeA * amplitudeC * centralityWeight * triggerWeight * associatedWeight); } - if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + if (isSameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { fillAssociatedQa(multiplicity, etaC, phiC); } // end of fill associated QA } // end of associated loop @@ -2370,8 +2497,8 @@ struct HfTaskFlow { template void fillCorrelationsMonteCarlo(TTarget target, CorrelationContainer::CFStep step, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, - float multiplicity, float posZ, bool sameEvent) + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, + float multiplicity, float posZ, bool isSameEvent) { auto triggerWeight = 1.0f; auto associatedWeight = 1.0f; @@ -2389,7 +2516,7 @@ struct HfTaskFlow { } } - for (auto const& track1 : tracks1) { + for (auto const& track1 : tracksTrigger) { loopCounter++; if (track1.eta() < configTask.etaMcParticlesTriggerMin || track1.eta() > configTask.etaMcParticlesTriggerMax) { @@ -2405,14 +2532,14 @@ struct HfTaskFlow { target->getTriggerHist()->Fill(step, track1.pt(), multiplicity, posZ, triggerWeight); if (configTask.doEtaDependentFlow) { - registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.eta(), triggerWeight); } if (configTask.doVariationContainers) { registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.pt(), triggerWeight); } // FILL QA FOR TRIGGER PARTICLE - if (sameEvent && fillQaPlots) { + if (isSameEvent && fillQaPlots) { registry.fill(HIST("MC/hEfficiencyTrigger"), track1.pt(), track1.eta(), posZ); if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); @@ -2433,7 +2560,7 @@ struct HfTaskFlow { } } - for (auto const& track2 : tracks2) { + for (auto const& track2 : tracksAssoc) { if (track1.globalIndex() == track2.globalIndex()) { continue; @@ -2463,7 +2590,7 @@ struct HfTaskFlow { } // FILL QA PLOTS for associated particle - if (sameEvent && fillQaPlots && (loopCounter == 1)) { + if (isSameEvent && fillQaPlots && (loopCounter == 1)) { registry.fill(HIST("MC/hEfficiencyAssociated"), track2.pt(), track2.eta(), posZ); if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { fillAssociatedQa(multiplicity, track2.eta(), track2.phi()); @@ -2493,7 +2620,7 @@ struct HfTaskFlow { template void mixCollisions(TCollisions const& collisions, CorrelationContainer::CFStep step, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, OutputObj& corrContainer, aod::BCsWithTimestamps const&) { // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { @@ -2501,8 +2628,8 @@ struct HfTaskFlow { // return multiplicity; // }; - auto getMultiplicity = [&tracks1, this](FilteredCollisionsWSelMult::iterator const& collision) { - auto associatedTracks = tracks1.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); + auto getMultiplicity = [&tracksTrigger, this](FilteredCollisionsWSelMult::iterator const& collision) { + auto associatedTracks = tracksTrigger.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); // auto mult = 0.f; if (configCollision.useMultiplicityFromTracks) { return associatedTracks.size(); @@ -2515,7 +2642,7 @@ struct HfTaskFlow { using BinningTypeData = FlexibleBinningPolicy, aod::collision::PosZ, decltype(getMultiplicity)>; BinningTypeData binningWithTracksSize{{getMultiplicity}, {configAxis.binsMixingVertex, configAxis.binsMixingMultiplicity}, true}; - auto tracksTuple = std::make_tuple(tracks1, tracks2); + auto tracksTuple = std::make_tuple(tracksTrigger, tracksAssoc); Pair pair{binningWithTracksSize, configTask.nMixedEvents, -1, collisions, tracksTuple, &cache}; for (const auto& [collision1, tracks1, collision2, tracks2] : pair) { @@ -2536,18 +2663,26 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision1, false); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + 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; + } } corrContainer->fillEvent(multiplicity, step); - fillCorrelations(corrContainer, step, tracks1, tracks2, multiplicity, collision1.posZ(), false, getMagneticField(bc.timestamp())); + fillCorrelations(corrContainer, step, tracks1, tracks2, multiplicity, collision1.posZ(), false, getMagneticField(bc.timestamp()), centralityWeight); } } template void mixCollisionsBis(TCollisions const& collisions, CorrelationContainer::CFStep step, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TPresliceTrigger const& presliceTrigger, TPresliceAssociated const& presliceAssociated, + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, TPresliceTrigger const& presliceTrigger, TPresliceAssociated const& presliceAssociated, OutputObj& corrContainer, aod::BCsWithTimestamps const&) { // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { @@ -2555,8 +2690,8 @@ struct HfTaskFlow { // return multiplicity; // }; - auto getMultiplicity = [&tracks1, this](FilteredCollisionsWSelMult::iterator const& collision) { - auto associatedTracks = tracks1.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); + auto getMultiplicity = [&tracksTrigger, this](FilteredCollisionsWSelMult::iterator const& collision) { + auto associatedTracks = tracksTrigger.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); auto mult = associatedTracks.size(); if (configCollision.useMultiplicityFromTracks) { return mult; @@ -2584,25 +2719,34 @@ struct HfTaskFlow { loadEfficiencyCorrection(bc.timestamp()); auto multiplicity = 0; if (configCollision.useMultiplicityFromTracks) { - multiplicity = tracks1.size(); + multiplicity = tracksTrigger.size(); } else { multiplicity = getMultiplicityEstimator(collision1, false); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + + float centralityWeight = 1.0f; + 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; + } } - auto slicedTriggerTracks = tracks1.sliceBy(presliceTrigger, collision1.globalIndex()); - auto slicedAssociatedTracks = tracks2.sliceBy(presliceAssociated, collision2.globalIndex()); + auto slicedTriggerTracks = tracksTrigger.sliceBy(presliceTrigger, collision1.globalIndex()); + auto slicedAssociatedTracks = tracksAssoc.sliceBy(presliceAssociated, collision2.globalIndex()); corrContainer->fillEvent(multiplicity, step); - fillCorrelations(corrContainer, step, slicedTriggerTracks, slicedAssociatedTracks, multiplicity, collision1.posZ(), false, getMagneticField(bc.timestamp())); + fillCorrelations(corrContainer, step, slicedTriggerTracks, slicedAssociatedTracks, multiplicity, collision1.posZ(), false, getMagneticField(bc.timestamp()), centralityWeight); } } template void mixCollisionsReassociatedMftTracks(TCollisions const& collisions, CorrelationContainer::CFStep step, TTracksTpc const& tracksTpc, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TPresliceTrigger const& presliceTrigger, TPresliceAssociated const& presliceAssociated, + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, TPresliceTrigger const& presliceTrigger, TPresliceAssociated const& presliceAssociated, OutputObj& corrContainer, bool cutAmbiguousTracks, aod::BCsWithTimestamps const&) { // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { @@ -2641,30 +2785,39 @@ struct HfTaskFlow { } else { multiplicity = getMultiplicityEstimator(collision1, false); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + + float centralityWeight = 1.0f; + 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; + } } // if TPC-MFT cases if constexpr (std::is_same_v) { - auto slicedTriggerTracks = tracks1.sliceBy(presliceTrigger, collision1.globalIndex()); - auto slicedAssociatedTracks = tracks2.sliceBy(presliceAssociated, collision2.globalIndex()); + auto slicedTriggerTracks = tracksTrigger.sliceBy(presliceTrigger, collision1.globalIndex()); + auto slicedAssociatedTracks = tracksAssoc.sliceBy(presliceAssociated, collision2.globalIndex()); corrContainer->fillEvent(multiplicity, step); - fillCorrelationsReassociatedMftTracks(corrContainer, step, slicedTriggerTracks, slicedAssociatedTracks, multiplicity, collision1.posZ(), false, cutAmbiguousTracks); + fillCorrelationsReassociatedMftTracks(corrContainer, step, slicedTriggerTracks, slicedAssociatedTracks, multiplicity, collision1.posZ(), false, cutAmbiguousTracks, centralityWeight); } else if ((collision1.has_foundFT0() && collision2.has_foundFT0())) { // if MFT-FT0A cases - auto slicedTriggerTracks = tracks1.sliceBy(presliceTrigger, collision1.globalIndex()); + auto slicedTriggerTracks = tracksTrigger.sliceBy(presliceTrigger, collision1.globalIndex()); const auto& ft0 = collision2.foundFT0(); corrContainer->fillEvent(multiplicity, step); - fillCorrelationsFITReassociatedMftTracks(corrContainer, step, slicedTriggerTracks, ft0, tracks2, multiplicity, collision1.posZ(), false, cutAmbiguousTracks, isFT0A); + fillCorrelationsFITReassociatedMftTracks(corrContainer, step, slicedTriggerTracks, ft0, tracksAssoc, multiplicity, collision1.posZ(), false, cutAmbiguousTracks, isFT0A, centralityWeight); } } // end of for loop } template void mixCollisionsFIT(TCollisions const& collisions, CorrelationContainer::CFStep step, TTracksTpc const& tracksTpc, - TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TPreslice const& preslice, + TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, TPreslice const& preslice, OutputObj& corrContainer, int fitType, aod::BCsWithTimestamps const&) { // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { @@ -2672,8 +2825,8 @@ struct HfTaskFlow { // return multiplicity; // }; - auto getMultiplicity = [&tracks1, this](FilteredCollisionsWSelMult::iterator const& collision) { - auto associatedTracks = tracks1.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); + auto getMultiplicity = [&tracksTrigger, this](FilteredCollisionsWSelMult::iterator const& collision) { + auto associatedTracks = tracksTrigger.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); auto mult = associatedTracks.size(); if (configCollision.useMultiplicityFromTracks) { return mult; @@ -2701,7 +2854,7 @@ struct HfTaskFlow { // if constexpr (std::is_same_v) { // IF ASSOCIATED PARTICLE FROM FV0A // if (collision1.has_foundFV0() && collision2.has_foundFV0()) { - // auto slicedTriggerTracks = tracks1.sliceBy(preslice, collision1.globalIndex()); + // auto slicedTriggerTracks = tracksTrigger.sliceBy(preslice, collision1.globalIndex()); // auto tracksForMultiplicity = tracksTpc.sliceByCached(o2::aod::track::collisionId, collision1.globalIndex(), cache); // const auto& fv0 = collision2.foundFV0(); @@ -2724,7 +2877,7 @@ struct HfTaskFlow { if constexpr (std::is_same_v) { if (collision1.has_foundFT0() && collision2.has_foundFT0()) { - auto slicedTriggerTracks = tracks1.sliceBy(preslice, collision1.globalIndex()); + auto slicedTriggerTracks = tracksTrigger.sliceBy(preslice, collision1.globalIndex()); auto tracksForMultiplicity = tracksTpc.sliceByCached(o2::aod::track::collisionId, collision1.globalIndex(), cache); const auto& ft0 = collision2.foundFT0(); @@ -2735,12 +2888,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision1, false); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + float centralityWeight = 1.0f; + 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; + } } corrContainer->fillEvent(multiplicity, step); - fillCorrelationsFIT(corrContainer, step, slicedTriggerTracks, ft0, tracks2, multiplicity, collision1.posZ(), false, fitType); + fillCorrelationsFIT(corrContainer, step, slicedTriggerTracks, ft0, tracksAssoc, multiplicity, collision1.posZ(), false, fitType, centralityWeight); } } // end of if condition for TPC-FT0 or MFT-FT0s } // end of for loop @@ -2793,12 +2954,21 @@ struct HfTaskFlow { } else { multiplicity = getMultiplicityEstimator(collision1, false); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + + float centralityWeight = 1.0f; + 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; + } } corrContainer->fillEvent(multiplicity, step); - fillCorrelationsFt0aFt0c(corrContainer, step, ft0as, ft0cs, multiplicity, collision1.posZ(), true); + fillCorrelationsFt0aFt0c(corrContainer, step, ft0as, ft0cs, multiplicity, collision1.posZ(), true, centralityWeight); } } // end of for loop } @@ -2835,12 +3005,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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; + } } sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelations(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, tracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + fillCorrelations(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, tracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp()), centralityWeight); } PROCESS_SWITCH(HfTaskFlow, processSameTpcTpcChCh, "DATA : Process same-event correlations for TPC-TPC h-h case", false); @@ -2874,12 +3052,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, tracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, tracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp()), centralityWeight); } PROCESS_SWITCH(HfTaskFlow, processSameTpcTpcD0Ch, "DATA : Process same-event correlations for TPC-TPC D0-h case", false); @@ -2913,12 +3099,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, tracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, tracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp()), centralityWeight); } PROCESS_SWITCH(HfTaskFlow, processSameTpcTpcLcCh, "DATA : Process same-event correlations for TPC-TPC Lc-h case", false); @@ -2945,16 +3139,24 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelations(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + fillCorrelations(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp()), centralityWeight); } else { sameEventTpcMft->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelations(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + fillCorrelations(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp()), centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChCh, "DATA : Process same-event correlations for TPC-MFT h-h case", false); @@ -2981,16 +3183,24 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false, centralityWeight); } else { sameEventTpcMft->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChChReassociated, "DATA : Process same-event correlations for TPC-MFT h-h case reassociated", false); @@ -3017,22 +3227,30 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - registry.fill(HIST("Data/hMultiplicity_uncorrected"), multiplicity); + auto uncorrectedMultiplicity = multiplicity; + registry.fill(HIST("Data/hMultiplicity_uncorrected_vs_corrected"), uncorrectedMultiplicity, multiplicity); if (configCollision.useMultiplicityFromTracksCorrected) { multiplicity = getCorrectedMultiplicity(tracks); - registry.fill(HIST("Data/hMultiplicity_corrected"), multiplicity); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false, centralityWeight); } else { sameEventTpcMft->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChChReassociated3d, "DATA : Process same-event correlations for TPC-MFT h-h case 3d reassociated", false); @@ -3059,16 +3277,24 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, true); + fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, true, centralityWeight); } else { sameEventTpcMft->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, true); + fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, true, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChChNonAmbiguous, "DATA : Process same-event correlations for TPC-MFT h-h case with non-ambiguous tracks", false); @@ -3103,12 +3329,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp()), centralityWeight); } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftD0Ch, "DATA : Process same-event correlations for TPC-MFT D0-h case", false); @@ -3132,12 +3366,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + fillCorrelationsReassociatedMftTracks(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, reassociatedMftTracks, multiplicity, collision.posZ(), true, false, centralityWeight); } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftD0ChReassociated, "DATA : Process same-event correlations for TPC-MFT D0-h case reassociated", false); @@ -3171,12 +3413,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + fillCorrelations(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp()), centralityWeight); } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftLcCh, "DATA : Process same-event correlations for TPC-MFT Lc-h case", false); @@ -3200,12 +3450,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + fillCorrelationsReassociatedMftTracks(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, reassociatedMftTracks, multiplicity, collision.posZ(), true, false, centralityWeight); } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftLcChReassociated, "DATA : Process same-event correlations for TPC-MFT Lc-h case reassociated", false); @@ -3413,16 +3671,24 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A, centralityWeight); } else { sameEventTpcFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEventTpcFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + fillCorrelationsFIT(sameEventTpcFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A, centralityWeight); } } } @@ -3455,12 +3721,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcFt0aD0Ch, "DATA : Process same-event correlations for TPC-FT0-A D0-h case", false); @@ -3492,12 +3766,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcFt0aLcCh, "DATA : Process same-event correlations for TPC-FT0-A Lc-h case", false); @@ -3529,16 +3811,24 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A, centralityWeight); } else { sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + fillCorrelationsFIT(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A, centralityWeight); } } } @@ -3568,16 +3858,24 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A, centralityWeight); } else { sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A, centralityWeight); } } } @@ -3607,16 +3905,24 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A, centralityWeight); } else { sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A, centralityWeight); } } } @@ -3646,16 +3952,24 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, true, isFT0A); + fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, true, isFT0A, centralityWeight); } else { sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, true, isFT0A); + fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, true, isFT0A, centralityWeight); } } } @@ -3688,12 +4002,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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; + } } sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0cs, multiplicity, collision.posZ(), true, isFT0C); + fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0cs, multiplicity, collision.posZ(), true, isFT0C, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcFt0cChCh, "DATA : Process same-event correlations for TPC-FT0C h-h case", false); @@ -3725,12 +4047,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, ft0, ft0cs, multiplicity, collision.posZ(), true, isFT0C); + fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, ft0, ft0cs, multiplicity, collision.posZ(), true, isFT0C, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcFt0cD0Ch, "DATA : Process same-event correlations for TPC-FT0C D0-h case", false); @@ -3762,12 +4092,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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; + } } sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, ft0, ft0cs, multiplicity, collision.posZ(), true, isFT0C); + fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, ft0, ft0cs, multiplicity, collision.posZ(), true, isFT0C, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameTpcFt0cLcCh, "DATA : Process same-event correlations for TPC-FT0C Lc-h case", false); @@ -3798,12 +4136,20 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { - return; + 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; + } } sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFt0aFt0c(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, ft0, ft0, multiplicity, collision.posZ(), true); + fillCorrelationsFt0aFt0c(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, ft0, ft0, multiplicity, collision.posZ(), true, centralityWeight); } } PROCESS_SWITCH(HfTaskFlow, processSameFt0aFt0cChCh, "DATA : Process same-event correlations for FT0A-FT0C h-h case", false); @@ -4272,6 +4618,115 @@ struct HfTaskFlow { } PROCESS_SWITCH(HfTaskFlow, processMixedMcGen, "MC Gen : Process mixed-event correlations", false); + void processTrackEfficiencies(FilteredMcCollisionsWMultWCollsExtra::iterator const& mcCollision, + SmallGroupMcCollisions const& reconstructedCollisions, + FilteredTracksWDcaSelWLabels const& tpcTracks, FilteredMftTracksWCollsMcLabels const& /*mftTracks*/, + soa::Filtered> const& reassociated3dMftTracks, + FilteredMcParticles const& mcParticles) + { + if (std::abs(mcCollision.posZ()) >= configCollision.zVertexMax) { + return; + } + + // check whether we have a selected reconstructed collision corresponding to the MC collision + bool hasReconstructedCollision = false; + for (const auto& reconstructedCollision : reconstructedCollisions) { + if (!isAcceptedCollision(reconstructedCollision)) { + continue; + } + if (reconstructedCollision.globalIndex() != mcCollision.bestCollisionIndex()) { + continue; + } + hasReconstructedCollision = true; + } + + // fill histogram for MC Gen TPC particles + for (const auto& particle : mcParticles) { + auto pdgParticle = pdg->GetParticle(particle.pdgCode()); + // check MC related properties of the particle + if (!particle.isPhysicalPrimary() || !particle.producedByGenerator()) { + continue; + } + // check charge of the particle + if (pdgParticle == nullptr || std::abs(pdgParticle->Charge()) == 0) { + continue; + } + // check kinematics of the particle for TPC + if (std::abs(particle.eta()) <= configTask.etaMcParticlesTriggerMax && + particle.pt() >= configTask.ptMcParticlesTriggerMin && + particle.pt() <= configTask.ptMcParticlesTriggerMax) { + if (hasReconstructedCollision) { + registry.fill(HIST("MC/hEfficiencyTrigger"), particle.pt(), particle.eta(), mcCollision.posZ()); + } + } + // check kinematics of the particle for MFT + if (particle.eta() <= configTask.etaMcParticlesAssocMax && + particle.eta() >= configTask.etaMcParticlesAssocMin && + particle.pt() >= configTask.ptMcParticlesAssocMin && + particle.pt() <= configTask.ptMcParticlesAssocMax) { + + if (configMft.useMftPhiCut) { + if (particle.phi() < configMft.phiMftTrackMax && particle.phi() > configMft.phiMftTrackMin && + !(particle.phi() > configMft.phiMftTrackMiddleMin && particle.phi() < configMft.phiMftTrackMiddleMax)) { + if (hasReconstructedCollision) { + registry.fill(HIST("MC/hEfficiencyAssociated"), particle.pt(), particle.eta(), mcCollision.posZ()); + } + } + } else { + if (hasReconstructedCollision) { + registry.fill(HIST("MC/hEfficiencyAssociated"), particle.pt(), particle.eta(), mcCollision.posZ()); + } + } + } + } + + // fill histogram for reconstructed TPC tracks + for (const auto& reconstructedCollision : reconstructedCollisions) { + if (!isAcceptedCollision(reconstructedCollision)) { + continue; + } + if (reconstructedCollision.globalIndex() != mcCollision.bestCollisionIndex()) { + continue; + } + + auto groupedTpcTracks = tpcTracks.sliceBy(perColTracks, reconstructedCollision.globalIndex()); + for (const auto& tpcTrack : groupedTpcTracks) { + if (!isAcceptedCentralTrack(tpcTrack)) { + continue; + } + if (!tpcTrack.has_mcParticle()) { + continue; + } + auto tpcParticle = tpcTrack.template mcParticle_as(); + if (reconstructedCollision.mcCollisionId() != tpcParticle.mcCollisionId()) { + continue; + } + if (tpcParticle.isPhysicalPrimary()) { + registry.fill(HIST("Data/hEfficiencyTrigger"), tpcParticle.pt(), tpcParticle.eta(), mcCollision.posZ()); + } + } + + auto groupedreassociated3dMftTracks = reassociated3dMftTracks.sliceBy(perColReassociated3dTracks, reconstructedCollision.globalIndex()); + for (const auto& reassociated3dMftTrack : reassociated3dMftTracks) { + if (!reassociated3dMftTrack.has_mcParticle()) { + continue; + } + auto templatedMftTrack = reassociated3dMftTrack.template mfttrack_as(); + if (!isAcceptedMftTrack(templatedMftTrack, reassociated3dMftTrack.bestDCAXY(), reassociated3dMftTrack.bestDCAZ(), false)) { + continue; + } + auto mftParticle = templatedMftTrack.template mcParticle_as(); + if (reconstructedCollision.mcCollisionId() != mftParticle.mcCollisionId()) { + continue; + } + if (mftParticle.isPhysicalPrimary()) { + registry.fill(HIST("Data/hEfficiencyAssociated"), mftParticle.pt(), mftParticle.eta(), mcCollision.posZ()); + } + } + } + } + PROCESS_SWITCH(HfTaskFlow, processTrackEfficiencies, "process track efficiencies for TPC and MFT", false); + }; // End of struct WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)