diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 11251c85f98..24a375c075a 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -22,12 +22,14 @@ #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/DataModel/CandidateSelectionTables.h" #include "PWGHF/DataModel/TrackIndexSkimmingTables.h" +#include "PWGLF/DataModel/mcCentrality.h" #include "PWGMM/Mult/DataModel/bestCollisionTable.h" #include "Common/CCDB/EventSelectionParams.h" #include "Common/CCDB/RCTSelectionFlags.h" #include "Common/Core/RecoDecay.h" #include "Common/DataModel/Centrality.h" +#include "Common/DataModel/CollisionAssociationTables.h" #include "Common/DataModel/EventSelection.h" #include "Common/DataModel/McCollisionExtra.h" #include "Common/DataModel/Multiplicity.h" @@ -46,7 +48,6 @@ #include #include #include -#include #include #include #include @@ -148,6 +149,11 @@ enum MftTrackAmbiguityStep { NMftAmbiguitySteps }; +enum MftTrackTemplate { + FilteredMftTracks = 0, + FilteredMftTracksWCollsMcLabels +}; + enum MftTrackSelectionStep { NoSelection = 0, Eta, @@ -203,18 +209,6 @@ static constexpr std::array WhatCentralityEstimator = {"cen static constexpr std::array WhatMultiplicityEstimator = {"multNTracksPV", "multNumContrib", "multFT0C", "multFT0M"}; auto static constexpr MinFt0cCell = 96; -static constexpr TrackSelectionFlags::flagtype TrackSelectionIts = - TrackSelectionFlags::kITSNCls | TrackSelectionFlags::kITSChi2NDF | - TrackSelectionFlags::kITSHits; -static constexpr TrackSelectionFlags::flagtype TrackSelectionTpc = - TrackSelectionFlags::kTPCNCls | - TrackSelectionFlags::kTPCCrossedRowsOverNCls | - TrackSelectionFlags::kTPCChi2NDF; -static constexpr TrackSelectionFlags::flagtype TrackSelectionDca = - TrackSelectionFlags::kDCAz | TrackSelectionFlags::kDCAxy; -static constexpr TrackSelectionFlags::flagtype TrackSelectionDcaxyOnly = - TrackSelectionFlags::kDCAxy; - static constexpr std::array, 1> PairCutDefaults{{{{-1, -1, -1, -1, -1}}}}; struct HfTaskFlow { @@ -398,11 +392,15 @@ struct HfTaskFlow { using SmallGroupMcCollisions = soa::SmallGroups>; // using FilteredMcCollisionsWMult = soa::Filtered>; - using FilteredMcCollisionsWMult = soa::Join; - using FilteredMcCollisionsWMultWCollsExtra = soa::Join; + using FilteredMcCollisionsWMult = soa::Filtered>; + using FilteredMcCollisionsWMultWCollsExtra = soa::Filtered>; // using FilteredMcParticles = soa::Filtered; using FilteredMcParticles = aod::McParticles; + // MC reconstructed + + // using FilteredMftTracksWCollsMcLabels = soa::Filtered>; + // ========================= // Filters & partitions : DATA // ========================= @@ -424,11 +422,7 @@ struct HfTaskFlow { (aod::track::pt < configCentral.ptCentralTrackMax) && requireGlobalTrackInFilter(); - Filter centralTrackItsTpcMatchingFilter = ifnode(ncheckbit(aod::track::v001::detectorMap, (uint8_t)o2::aod::track::TPC), ncheckbit(aod::track::trackCutFlag, TrackSelectionTpc), true) && - ncheckbit(aod::track::v001::detectorMap, (uint8_t)o2::aod::track::ITS) && - ncheckbit(aod::track::trackCutFlag, TrackSelectionIts); - - Filter centralTrackDcaFilter = (ifnode(configCentral.dcaZCentralTrackMax.node() > 0.f, nabs(aod::track::dcaZ) <= configCentral.dcaZCentralTrackMax && ncheckbit(aod::track::trackCutFlag, TrackSelectionDcaxyOnly), ncheckbit(aod::track::trackCutFlag, TrackSelectionDca))); + Filter centralTrackDcaFilter = (nabs(aod::track::dcaZ) <= configCentral.dcaZCentralTrackMax); Filter centralTrackChi2TpcClusterFilter = (aod::track::tpcChi2NCl < configCentral.maxChi2TpcClusters); @@ -447,8 +441,8 @@ struct HfTaskFlow { // // Filter for McParticles // Filter mcParticleFilter = (((aod::mcparticle::eta > configTask.etaMcParticlesTriggerMin) && (aod::mcparticle::eta < configTask.etaMcParticlesTriggerMax)) || ((aod::mcparticle::eta > configTask.etaMcParticlesAssocMin) && (aod::mcparticle::eta < configTask.etaMcParticlesAssocMax)) || (nabs(aod::mcparticle::eta) < configCentral.etaCentralTrackMax)) && (aod::mcparticle::pt < configTask.ptMcParticlesTriggerMax); - // // Filter for MCcollisions - // Filter mcCollisionFilter = nabs(aod::mccollision::posZ) < configCollision.zVertexMax; + // Filter for MCcollisions + Filter mcCollisionFilter = nabs(aod::mccollision::posZ) < configCollision.zVertexMax; // ========================= // Preslice : DATA @@ -745,7 +739,8 @@ struct HfTaskFlow { // Initialization of histograms and CorrelationContainers for TpcMft cases // ========================= - if (doprocessSameTpcMftChCh || doprocessSameTpcMftChChReassociated || doprocessSameTpcMftChChReassociated3d || doprocessSameTpcMftChChNonAmbiguous) { + // if (doprocessSameTpcMftChCh || doprocessSameTpcMftChChReassociated || doprocessSameTpcMftChChReassociated3d || doprocessSameTpcMftChChNonAmbiguous || doprocessSameTpcMftChChReassociated3dMcReconstructed) { + if (doprocessSameTpcMftChCh || doprocessSameTpcMftChChReassociated3d || doprocessSameTpcMftChChNonAmbiguous || doprocessSameTpcMftChChReassociated3dMcReconstructed) { if (!configTask.removeQAForSystematics) { addHistograms(); @@ -768,7 +763,8 @@ struct HfTaskFlow { } } - if (doprocessSameTpcMftD0Ch || doprocessSameTpcMftD0ChReassociated) { + // if (doprocessSameTpcMftD0Ch || doprocessSameTpcMftD0ChReassociated) { + if (doprocessSameTpcMftD0Ch) { if (!configTask.removeQAForSystematics) { addHistograms(); addMftHistograms(); @@ -778,7 +774,8 @@ struct HfTaskFlow { mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); } - if (doprocessSameTpcMftLcCh || doprocessSameTpcMftLcChReassociated) { + // if (doprocessSameTpcMftLcCh || doprocessSameTpcMftLcChReassociated) { + if (doprocessSameTpcMftLcCh) { if (!configTask.removeQAForSystematics) { addHistograms(); @@ -890,7 +887,8 @@ struct HfTaskFlow { // Initialization of histograms and CorrelationContainers for MftFt0a cases // ========================= - if (doprocessSameMftFt0aChCh || doprocessSameMftFt0aChChReassociated || doprocessSameMftFt0aChChReassociated3d || doprocessSameMftFt0aChChNonAmbiguous) { + // if (doprocessSameMftFt0aChCh || doprocessSameMftFt0aChChReassociated || doprocessSameMftFt0aChChReassociated3d || doprocessSameMftFt0aChChNonAmbiguous) { + if (doprocessSameMftFt0aChCh || doprocessSameMftFt0aChChReassociated3d || doprocessSameMftFt0aChChNonAmbiguous || doprocessSameMftFt0aChChReassociated3dMcReconstructed) { if (!configTask.removeQAForSystematics) { addHistograms(); @@ -997,25 +995,39 @@ struct HfTaskFlow { if (doprocessSameMcGen) { - if (!configTask.removeQAForSystematics) { - - if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFv0a)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFv0a)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0a)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFt0a)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0c)) { - addHistograms(); - } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::Ft0aFt0c)) { - addHistograms(); - } + registry.add(Form("MC/hCentrality_%s", WhatCentralityEstimator[configCollision.centralityEstimator].data()), "", {HistType::kTH1D, {configAxis.axisCentrality}}); + registry.add("MC/hCentralityUsed", "", {HistType::kTH1D, {configAxis.axisCentrality}}); + registry.add("MC/hMultiplicity_multMCFT0C", "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); + registry.add("MC/hMultiplicityTracksSize", "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); + registry.add("MC/hMultiplicityUsed", "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); + + registry.add("MC/hMixedMultiplicity_multMCFT0C_coll1", "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); + registry.add("MC/hMixedMultiplicityTracksSize_coll1", "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); + registry.add("MC/hMixedMultiplicityUsed_coll1", "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); + registry.add("MC/hMixedCentrality_coll1", "", {HistType::kTH1D, {configAxis.axisCentrality}}); + registry.add("MC/hMixedCentralityUsed_coll1", "", {HistType::kTH1D, {configAxis.axisCentrality}}); + registry.add("MC/hMixedMultiplicity_multMCFT0C_coll2", "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); + registry.add("MC/hMixedMultiplicityTracksSize_coll2", "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); + registry.add("MC/hMixedMultiplicityUsed_coll2", "", {HistType::kTH1D, {configAxis.axisMultiplicity}}); + registry.add("MC/hMixedCentrality_coll2", "", {HistType::kTH1D, {configAxis.axisCentrality}}); + registry.add("MC/hMixedCentralityUsed_coll2", "", {HistType::kTH1D, {configAxis.axisCentrality}}); + + if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFv0a)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFv0a)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0a)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFt0a)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0c)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::Ft0aFt0c)) { + addHistograms(); } if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -1114,23 +1126,23 @@ struct HfTaskFlow { } } - template + template float getCentralityEstimator(TCollision const& collision, bool isSameEvent) { switch (configCollision.centralityEstimator) { case CentralityEstimators::CentFT0C: if (isSameEvent && !configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentrality_centFT0C"), collision.centFT0C()); + registry.fill(HIST(WhatDataType[DataType]) + HIST("hCentrality_centFT0C"), collision.centFT0C()); } return collision.centFT0C(); case CentralityEstimators::CentFT0CVariant1: if (isSameEvent && !configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentrality_centFT0CVariant1"), collision.centFT0CVariant1()); + registry.fill(HIST(WhatDataType[DataType]) + HIST("hCentrality_centFT0CVariant1"), collision.centFT0CVariant1()); } return collision.centFT0CVariant1(); case CentralityEstimators::CentFT0M: if (isSameEvent && !configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hCentrality_centFT0M"), collision.centFT0M()); + registry.fill(HIST(WhatDataType[DataType]) + HIST("hCentrality_centFT0M"), collision.centFT0M()); } return collision.centFT0M(); default: @@ -1318,10 +1330,9 @@ struct HfTaskFlow { registry.fill(HIST("Data/FT0IsInnerOrOuter"), FT0InnerOrOuter::FT0OuterRing); } return FT0InnerOrOuter::FT0OuterRing; - } else { - LOGF(fatal, "Channel ID %d out of range for FT0C", channelId); - return FT0InnerOrOuter::FT0Error; } + LOGF(fatal, "Channel ID %d out of range for FT0C", channelId); + return FT0InnerOrOuter::FT0Error; } else if (fitType == isFT0A) { if (channelId >= FT0DetectorChannels::FT0AInnerRingMin && channelId <= FT0DetectorChannels::FT0AInnerRingMax) { if (!configTask.removeQAForSystematics) { @@ -1333,10 +1344,9 @@ struct HfTaskFlow { registry.fill(HIST("Data/FT0IsInnerOrOuter"), FT0InnerOrOuter::FT0OuterRing); } return FT0InnerOrOuter::FT0OuterRing; - } else { - LOGF(fatal, "Channel ID %d out of range for FT0A", channelId); - return FT0InnerOrOuter::FT0Error; } + LOGF(fatal, "Channel ID %d out of range for FT0A", channelId); + return FT0InnerOrOuter::FT0Error; } else { LOGF(fatal, "Fit type %d is not valid for FT0", fitType); return FT0InnerOrOuter::FT0Error; @@ -1489,7 +1499,7 @@ struct HfTaskFlow { multiplicity = getMultiplicityEstimator(collision, true); } - centrality = getCentralityEstimator(collision, true); + centrality = getCentralityEstimator(collision, true); if (configCollision.useCentrality) { getCentralityWeight(centralityWeight, centrality); if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { @@ -2006,7 +2016,7 @@ struct HfTaskFlow { } // end of loop over tracks 1 } - template + template void fillCorrelationsReassociatedMftTracks(TTarget target, CorrelationContainer::CFStep step, TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, float multiplicity, float posZ, bool isSameEvent, bool cutAmbiguousTracks, float centralityWeight) @@ -2082,10 +2092,20 @@ struct HfTaskFlow { registry.fill(HIST("Data/Mft/hAmbiguityOfMftTracks"), MftTrackAmbiguityStep::AllMftTracks); } - auto reassociatedMftTrack = track2.template mfttrack_as(); + auto reassociatedMftTrack = track2.template mfttrack_as(); + auto reassociatedMftTrackDcaXY = 0.f; auto reassociatedMftTrackDcaZ = 0.f; + if constexpr (std::is_same_v>, TTracksAssoc>) { + if (!reassociatedMftTrack.has_mcParticle()) { + continue; + } + if (configTask.useOnlyPrimaryInMc && !reassociatedMftTrack.mcParticle().isPhysicalPrimary()) { + continue; + } + } + if constexpr (std::is_same_v, TTracksAssoc>) { reassociatedMftTrackDcaXY = track2.bestDCAXY(); } @@ -2472,7 +2492,7 @@ struct HfTaskFlow { } // end of loop over tracks 1 } - template + template void fillCorrelationsFITReassociatedMftTracks(TTarget target, CorrelationContainer::CFStep step, TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, TFits const&, float multiplicity, float posZ, bool isSameEvent, bool cutAmbiguousTracks, int fitType, float centralityWeight) @@ -2486,10 +2506,19 @@ struct HfTaskFlow { for (auto const& track1 : tracksTrigger) { loopCounter++; - auto reassociatedMftTrack = track1.template mfttrack_as(); + auto reassociatedMftTrack = track1.template mfttrack_as(); auto reassociatedMftTrackDcaXY = 0.f; auto reassociatedMftTrackDcaZ = 0.f; + if constexpr (std::is_same_v>, TTracksAssoc>) { + if (!reassociatedMftTrack.has_mcParticle()) { + continue; + } + if (configTask.useOnlyPrimaryInMc && !reassociatedMftTrack.mcParticle().isPhysicalPrimary()) { + continue; + } + } + if constexpr (std::is_same_v, TTracksTrig>) { reassociatedMftTrackDcaXY = track1.bestDCAXY(); } @@ -2831,9 +2860,8 @@ struct HfTaskFlow { // auto mult = 0.f; if (configCollision.useMultiplicityFromTracks) { return associatedTracks.size(); - } else { - return getMultiplicityEstimator(collision, false); } + return getMultiplicityEstimator(collision, false); }; // The first one that I call "Data" should work for data and mc rec @@ -2863,8 +2891,8 @@ struct HfTaskFlow { float centralityWeight = 1.0f; if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, true)); - if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, false)); + if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { continue; } } @@ -2893,9 +2921,8 @@ struct HfTaskFlow { auto mult = associatedTracks.size(); if (configCollision.useMultiplicityFromTracks) { return mult; - } else { - return getMultiplicityEstimator(collision, false); } + return getMultiplicityEstimator(collision, false); }; using MixedBinning = FlexibleBinningPolicy, aod::collision::PosZ, decltype(getMultiplicity)>; @@ -2924,8 +2951,8 @@ struct HfTaskFlow { float centralityWeight = 1.0f; if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, true)); - if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, false)); + if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { continue; } } @@ -2942,7 +2969,7 @@ struct HfTaskFlow { } } - template + template void mixCollisionsReassociatedMftTracks(TCollisions const& collisions, CorrelationContainer::CFStep step, TTracksTpc const& tracksTpc, TTracksTrig const& tracksTrigger, TTracksAssoc const& tracksAssoc, TPresliceTrigger const& presliceTrigger, TPresliceAssociated const& presliceAssociated, OutputObj& corrContainer, bool cutAmbiguousTracks, aod::BCsWithTimestamps const&) @@ -2957,9 +2984,8 @@ struct HfTaskFlow { auto mult = associatedTracks.size(); if (configCollision.useMultiplicityFromTracks) { return mult; - } else { - return getMultiplicityEstimator(collision, false); } + return getMultiplicityEstimator(collision, false); }; using MixedBinning = FlexibleBinningPolicy, aod::collision::PosZ, decltype(getMultiplicity)>; @@ -2986,8 +3012,8 @@ struct HfTaskFlow { float centralityWeight = 1.0f; if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, true)); - if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, false)); + if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { continue; } } @@ -3002,13 +3028,13 @@ struct HfTaskFlow { auto slicedAssociatedTracks = tracksAssoc.sliceBy(presliceAssociated, collision2.globalIndex()); corrContainer->fillEvent(multiplicity, step); - fillCorrelationsReassociatedMftTracks(corrContainer, step, slicedTriggerTracks, slicedAssociatedTracks, multiplicity, collision1.posZ(), false, cutAmbiguousTracks, centralityWeight); + 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 = tracksTrigger.sliceBy(presliceTrigger, collision1.globalIndex()); const auto& ft0 = collision2.foundFT0(); corrContainer->fillEvent(multiplicity, step); - fillCorrelationsFITReassociatedMftTracks(corrContainer, step, slicedTriggerTracks, ft0, tracksAssoc, multiplicity, collision1.posZ(), false, cutAmbiguousTracks, isFT0A, centralityWeight); + fillCorrelationsFITReassociatedMftTracks(corrContainer, step, slicedTriggerTracks, ft0, tracksAssoc, multiplicity, collision1.posZ(), false, cutAmbiguousTracks, isFT0A, centralityWeight); } } // end of for loop } @@ -3028,9 +3054,8 @@ struct HfTaskFlow { auto mult = associatedTracks.size(); if (configCollision.useMultiplicityFromTracks) { return mult; - } else { - return getMultiplicityEstimator(collision, false); } + return getMultiplicityEstimator(collision, false); }; using MixedBinning = FlexibleBinningPolicy, aod::collision::PosZ, decltype(getMultiplicity)>; @@ -3088,8 +3113,8 @@ struct HfTaskFlow { float centralityWeight = 1.0f; if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, false)); - if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, false)); + if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { continue; } } @@ -3120,9 +3145,8 @@ struct HfTaskFlow { auto mult = associatedTracks.size(); if (configCollision.useMultiplicityFromTracks) { return mult; - } else { - return getMultiplicityEstimator(collision, false); } + return getMultiplicityEstimator(collision, false); }; using MixedBinning = FlexibleBinningPolicy, aod::collision::PosZ, decltype(getMultiplicity)>; @@ -3155,8 +3179,8 @@ struct HfTaskFlow { float centralityWeight = 1.0f; if (configCollision.useCentrality) { - getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, true)); - if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { + getCentralityWeight(centralityWeight, getCentralityEstimator(collision1, false)); + if (getCentralityEstimator(collision1, false) < configCollision.minCentrality || getCentralityEstimator(collision1, false) >= configCollision.maxCentrality) { continue; } } @@ -3327,41 +3351,41 @@ struct HfTaskFlow { } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChCh, "DATA : Process same-event correlations for TPC-MFT h-h case", false); - void processSameTpcMftChChReassociated(FilteredCollisionsWSelMult::iterator const& collision, - soa::SmallGroups const& reassociatedMftTracks, - FilteredTracksWDcaSel const& tracks, - FilteredMftTracks const& mftTracks, - aod::BCsWithTimestamps const&) - { - if (!(isAcceptedCollision(collision, true))) { - return; - } + // void processSameTpcMftChChReassociated(FilteredCollisionsWSelMult::iterator const& collision, + // soa::SmallGroups const& reassociatedMftTracks, + // FilteredTracksWDcaSel const& tracks, + // FilteredMftTracks const& mftTracks, + // aod::BCsWithTimestamps const&) + // { + // if (!(isAcceptedCollision(collision, true))) { + // return; + // } - if (!configTask.removeQAForSystematics) { - registry.fill(HIST("Data/hNTracks"), tracks.size()); - registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); - registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); - } + // if (!configTask.removeQAForSystematics) { + // registry.fill(HIST("Data/hNTracks"), tracks.size()); + // registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); + // registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); + // } - auto bc = collision.template bc_as(); - loadEfficiencyCorrection(bc.timestamp()); - float multiplicity = 0.f; - float centrality = -1.f; - float centralityWeight = 1.f; + // auto bc = collision.template bc_as(); + // loadEfficiencyCorrection(bc.timestamp()); + // float multiplicity = 0.f; + // float centrality = -1.f; + // float centralityWeight = 1.f; - if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { - return; - } + // if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + // return; + // } - if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - 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, centralityWeight); - } - } - PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChChReassociated, "DATA : Process same-event correlations for TPC-MFT h-h case reassociated", false); + // if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + // sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + // 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, centralityWeight); + // } + // } + // PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChChReassociated, "DATA : Process same-event correlations for TPC-MFT h-h case reassociated", false); void processSameTpcMftChChReassociated3d(FilteredCollisionsWSelMult::iterator const& collision, soa::SmallGroups const& reassociatedMftTracks, @@ -3401,10 +3425,10 @@ struct HfTaskFlow { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false, centralityWeight); + 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, centralityWeight); + 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); @@ -3437,10 +3461,10 @@ struct HfTaskFlow { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, true, centralityWeight); + 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, centralityWeight); + 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); @@ -3481,31 +3505,31 @@ struct HfTaskFlow { } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftD0Ch, "DATA : Process same-event correlations for TPC-MFT D0-h case", false); - void processSameTpcMftD0ChReassociated(FilteredCollisionsWSelMult::iterator const& collision, - HfCandidatesSelD0 const& candidates, - soa::SmallGroups const& reassociatedMftTracks, - FilteredTracksWDcaSel const& tracks, - FilteredMftTracks const&, - aod::BCsWithTimestamps const&) - { - if (!(isAcceptedCollision(collision, true))) { - return; // when process function has iterator - } + // void processSameTpcMftD0ChReassociated(FilteredCollisionsWSelMult::iterator const& collision, + // HfCandidatesSelD0 const& candidates, + // soa::SmallGroups const& reassociatedMftTracks, + // FilteredTracksWDcaSel const& tracks, + // FilteredMftTracks const&, + // aod::BCsWithTimestamps const&) + // { + // if (!(isAcceptedCollision(collision, true))) { + // return; // when process function has iterator + // } - auto bc = collision.template bc_as(); - loadEfficiencyCorrection(bc.timestamp()); - float multiplicity = 0.f; - float centrality = -1.f; - float centralityWeight = 1.f; + // auto bc = collision.template bc_as(); + // loadEfficiencyCorrection(bc.timestamp()); + // float multiplicity = 0.f; + // float centrality = -1.f; + // float centralityWeight = 1.f; - if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { - return; - } + // if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + // return; + // } - sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - 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); + // sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + // 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); // ===================================== // DATA : process same event correlations: TPC-MFT HF-h case for Lc @@ -3543,31 +3567,31 @@ struct HfTaskFlow { } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftLcCh, "DATA : Process same-event correlations for TPC-MFT Lc-h case", false); - void processSameTpcMftLcChReassociated(FilteredCollisionsWSelMult::iterator const& collision, - HfCandidatesSelLc const& candidates, - soa::SmallGroups const& reassociatedMftTracks, - FilteredTracksWDcaSel const& tracks, - FilteredMftTracks const&, - aod::BCsWithTimestamps const&) - { - if (!(isAcceptedCollision(collision, true))) { - return; // when process function has iterator - } + // void processSameTpcMftLcChReassociated(FilteredCollisionsWSelMult::iterator const& collision, + // HfCandidatesSelLc const& candidates, + // soa::SmallGroups const& reassociatedMftTracks, + // FilteredTracksWDcaSel const& tracks, + // FilteredMftTracks const&, + // aod::BCsWithTimestamps const&) + // { + // if (!(isAcceptedCollision(collision, true))) { + // return; // when process function has iterator + // } - auto bc = collision.template bc_as(); - loadEfficiencyCorrection(bc.timestamp()); - float multiplicity = 0.f; - float centrality = -1.f; - float centralityWeight = 1.f; + // auto bc = collision.template bc_as(); + // loadEfficiencyCorrection(bc.timestamp()); + // float multiplicity = 0.f; + // float centrality = -1.f; + // float centralityWeight = 1.f; - if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { - return; - } + // if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + // return; + // } - sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - 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); + // sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + // 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); // ===================================== // DATA : process same event correlations: TPC-FV0A Ch. Part. - Ch. Part @@ -3693,7 +3717,7 @@ struct HfTaskFlow { // } // sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - // fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, fv0, fv0as, multiplicity, collision.posZ(), true, false, isFV0A); + // fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, fv0, fv0as, multiplicity, collision.posZ(), true, false, isFV0A); // } // } // PROCESS_SWITCH(HfTaskFlow, processSameMftFv0aChChReassociated, "DATA : Process same-event correlations for MFT-FV0a h-h case reassociated", false); @@ -3717,7 +3741,7 @@ struct HfTaskFlow { } sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, fv0, fv0as, multiplicity, collision.posZ(), true, false, isFV0A); + fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, fv0, fv0as, multiplicity, collision.posZ(), true, false, isFV0A); } } PROCESS_SWITCH(HfTaskFlow, processSameMftFv0aChChReassociated3d, "DATA : Process same-event correlations for MFT-FV0a h-h case 3d reassociated", false); @@ -3741,7 +3765,7 @@ struct HfTaskFlow { // } // sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - // fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, fv0, fv0as, multiplicity, collision.posZ(), true, true, isFV0A); + // fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, fv0, fv0as, multiplicity, collision.posZ(), true, true, isFV0A); // } // } // PROCESS_SWITCH(HfTaskFlow, processSameMftFv0aChChNonAmbiguous, "DATA : Process same-event correlations for MFT-FV0a h-h non-ambiguous case", false); @@ -3894,42 +3918,42 @@ struct HfTaskFlow { } PROCESS_SWITCH(HfTaskFlow, processSameMftFt0aChCh, "DATA : Process same-event correlations for MFT-FT0-A h-h case", false); - void processSameMftFt0aChChReassociated(FilteredCollisionsWSelMult::iterator const& collision, - soa::SmallGroups const& reassociatedMftTracks, - FilteredMftTracks const&, - aod::FT0s const& ft0as, - FilteredTracksWDcaSel const& tracks, - aod::BCsWithTimestamps const&) - { - if (!(isAcceptedCollision(collision, true))) { - return; - } + // void processSameMftFt0aChChReassociated(FilteredCollisionsWSelMult::iterator const& collision, + // soa::SmallGroups const& reassociatedMftTracks, + // FilteredMftTracks const&, + // aod::FT0s const& ft0as, + // FilteredTracksWDcaSel const& tracks, + // aod::BCsWithTimestamps const&) + // { + // if (!(isAcceptedCollision(collision, true))) { + // return; + // } - auto bc = collision.template bc_as(); - loadEfficiencyCorrection(bc.timestamp()); + // auto bc = collision.template bc_as(); + // loadEfficiencyCorrection(bc.timestamp()); - if (collision.has_foundFT0()) { + // if (collision.has_foundFT0()) { - loadGain(bc); - const auto& ft0 = collision.foundFT0(); - float multiplicity = 0.f; - float centrality = -1.f; - float centralityWeight = 1.f; + // loadGain(bc); + // const auto& ft0 = collision.foundFT0(); + // float multiplicity = 0.f; + // float centrality = -1.f; + // float centralityWeight = 1.f; - if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { - return; - } + // if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + // 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, centralityWeight); - } else { - sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A, centralityWeight); - } - } - } - PROCESS_SWITCH(HfTaskFlow, processSameMftFt0aChChReassociated, "DATA : Process same-event correlations for MFT-FT0-A h-h case reassociated", false); + // if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + // sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + // 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, centralityWeight); + // } + // } + // } + // PROCESS_SWITCH(HfTaskFlow, processSameMftFt0aChChReassociated, "DATA : Process same-event correlations for MFT-FT0-A h-h case reassociated", false); void processSameMftFt0aChChReassociated3d(FilteredCollisionsWSelMult::iterator const& collision, soa::SmallGroups const& reassociatedMftTracks, @@ -3959,10 +3983,10 @@ struct HfTaskFlow { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A, centralityWeight); + 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, centralityWeight); + fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A, centralityWeight); } } } @@ -3995,10 +4019,10 @@ struct HfTaskFlow { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, true, isFT0A, centralityWeight); + 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, centralityWeight); + fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, true, isFT0A, centralityWeight); } } } @@ -4145,6 +4169,93 @@ struct HfTaskFlow { // MONTE-CARLO // =================================================================================================================================================================================================================================================================== + void processSameTpcMftChChReassociated3dMcReconstructed(FilteredCollisionsWSelMult::iterator const& collision, + soa::SmallGroups> const& reassociatedMftTracks, + FilteredTracksWDcaSel const& tracks, + FilteredMftTracksWCollsMcLabels const& mftTracks, + aod::McCollisions const& /*mcCollisions*/, + aod::McParticles const& /*particles*/, + aod::BCsWithTimestamps const&) + { + if (!(isAcceptedCollision(collision, true))) { + return; + } + + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hNTracks"), tracks.size()); + registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); + registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); + } + + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; + + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + return; + } + + auto uncorrectedMultiplicity = multiplicity; + + if (configCollision.useMultiplicityFromTracksCorrected) { + multiplicity = getCorrectedMultiplicity(tracks); + } + + if (!configTask.removeQAForSystematics) { + registry.fill(HIST("Data/hMultiplicity_uncorrected_vs_corrected"), uncorrectedMultiplicity, multiplicity); + } + + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + 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, centralityWeight); + } + } + PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChChReassociated3dMcReconstructed, "Mc Rec : Process same-event correlations for TPC-MFT h-h case 3d reassociated", false); + + void processSameMftFt0aChChReassociated3dMcReconstructed(FilteredCollisionsWSelMult::iterator const& collision, + soa::SmallGroups> const& reassociatedMftTracks, + FilteredTracksWDcaSel const& tracks, + FilteredMftTracksWCollsMcLabels const& /*mftTracks*/, + aod::McCollisions const& /*mcCollisions*/, + aod::McParticles const& /*particles*/, + aod::FT0s const& ft0as, + aod::BCsWithTimestamps const&) + { + if (!(isAcceptedCollision(collision, true))) { + return; + } + + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); + + if (collision.has_foundFT0()) { + + loadGain(bc); + const auto& ft0 = collision.foundFT0(); + float multiplicity = 0.f; + float centrality = -1.f; + float centralityWeight = 1.f; + + if (!isAcceptedEventActivity(collision, tracks, multiplicity, centrality, centralityWeight)) { + 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, centralityWeight); + } else { + sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A, centralityWeight); + } + } + } + PROCESS_SWITCH(HfTaskFlow, processSameMftFt0aChChReassociated3dMcReconstructed, "MC Rec : Process same-event correlations for MFT-FT0-A h-h case reassociated 3d", false); + void processSameMcGen(FilteredMcCollisionsWMultWCollsExtra::iterator const& mcCollision, FilteredMcParticles const& mcParticles, SmallGroupMcCollisions const& collisions) @@ -4153,7 +4264,6 @@ struct HfTaskFlow { if (mcParticles.size() == 0) { // guard against empty filtered batch return; } - if (collisions.size() == 0) { return; } @@ -4165,21 +4275,14 @@ struct HfTaskFlow { multiplicity += 1; } } + registry.fill(HIST("MC/hMultiplicityTracksSize"), multiplicity); } else { - multiplicity = mcCollision.multMCPVz(); + multiplicity = mcCollision.multMCFT0C(); + registry.fill(HIST("MC/hMultiplicity_multMCFT0C"), multiplicity); } - float centrality = -1.f; - for (const auto& collision : collisions) { - // if (!collision.sel8()) { - // continue; - // } - // if (collision.globalIndex() != mcCollision.bestCollisionIndex()) { - // continue; - // } - centrality = getCentralityEstimator(collision, false); - // break; - } + float centrality = 999.f; + centrality = getCentralityEstimator(mcCollision, true); if (configCollision.useCentrality) { if (centrality < configCollision.minCentrality || centrality >= configCollision.maxCentrality) { @@ -4192,6 +4295,9 @@ struct HfTaskFlow { } } + registry.fill(HIST("MC/hCentralityUsed"), centrality); + registry.fill(HIST("MC/hMultiplicityUsed"), multiplicity); + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepAll); fillCorrelationsMonteCarlo(sameEvent, CorrelationContainer::CFStep::kCFStepAll, mcParticles, mcParticles, multiplicity, mcCollision.posZ(), true); } @@ -4275,19 +4381,19 @@ struct HfTaskFlow { } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChBis, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); - void processMixedTpcMftChChReassociated2d(FilteredCollisionsWSelMult const& collisions, - FilteredTracksWDcaSel const& tracks, - FilteredMftTracks const& /*mftTracks*/, - soa::SmallGroups const& reassociated2dMftTracks, - aod::BCsWithTimestamps const& bcs) - { - if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, false, bcs); - } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, false, bcs); - } - } - PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChReassociated2d, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); + // void processMixedTpcMftChChReassociated2d(FilteredCollisionsWSelMult const& collisions, + // FilteredTracksWDcaSel const& tracks, + // FilteredMftTracks const& /*mftTracks*/, + // soa::SmallGroups const& reassociated2dMftTracks, + // aod::BCsWithTimestamps const& bcs) + // { + // if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + // mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, false, bcs); + // } else { + // mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, false, bcs); + // } + // } + // PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChReassociated2d, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); void processMixedTpcMftChChReassociated3d(FilteredCollisionsWSelMult const& collisions, FilteredTracksWDcaSel const& tracks, @@ -4296,9 +4402,9 @@ struct HfTaskFlow { aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEvent, false, bcs); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEvent, false, bcs); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEventTpcMft, false, bcs); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEventTpcMft, false, bcs); } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChReassociated3d, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -4310,9 +4416,9 @@ struct HfTaskFlow { aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, true, bcs); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, true, bcs); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, true, bcs); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, true, bcs); } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChNonAmbiguous, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -4455,20 +4561,20 @@ struct HfTaskFlow { } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChCh, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); - void processMixedMftFt0aChChReassociated2d(FilteredCollisionsWSelMult const& collisions, - FilteredMftTracks const& /*mftTracks*/, - FilteredTracksWDcaSel const& tracksTpc, - soa::SmallGroups const& reassociated2dMftTracks, - aod::FT0s const& ft0s, - aod::BCsWithTimestamps const& bcs) - { - if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, false, bcs); - } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, false, bcs); - } - } - PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChChReassociated2d, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); + // void processMixedMftFt0aChChReassociated2d(FilteredCollisionsWSelMult const& collisions, + // FilteredMftTracks const& /*mftTracks*/, + // FilteredTracksWDcaSel const& tracksTpc, + // soa::SmallGroups const& reassociated2dMftTracks, + // aod::FT0s const& ft0s, + // aod::BCsWithTimestamps const& bcs) + // { + // if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + // mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, false, bcs); + // } else { + // mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, false, bcs); + // } + // } + // PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChChReassociated2d, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); void processMixedMftFt0aChChReassociated3d(FilteredCollisionsWSelMult const& collisions, FilteredMftTracks const& /*mftTracks*/, @@ -4478,9 +4584,9 @@ struct HfTaskFlow { aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEvent, false, bcs); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEvent, false, bcs); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEventMftFt0a, false, bcs); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEventMftFt0a, false, bcs); } } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChChReassociated3d, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); @@ -4493,9 +4599,9 @@ struct HfTaskFlow { aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, true, bcs); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, true, bcs); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, true, bcs); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, true, bcs); } } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChChNonAmbiguous, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); @@ -4558,14 +4664,43 @@ struct HfTaskFlow { // MONTE-CARLO // =================================================================================================================================================================================================================================================================== + void processMixedTpcMftChChReassociated3dMcReconstructed(FilteredCollisionsWSelMult const& collisions, + FilteredTracksWDcaSel const& tracks, + FilteredMftTracksWCollsMcLabels const& /*mftTracks*/, + soa::SmallGroups> const& reassociated3dMftTracks, + aod::BCsWithTimestamps const& bcs) + { + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEvent, false, bcs); + } else { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEventTpcMft, false, bcs); + } + } + PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChReassociated3dMcReconstructed, "MC Rec : Process mixed-event correlations for TPC-MFT h-h case", false); + + void processMixedMftFt0aChChReassociated3dMcReconstructed(FilteredCollisionsWSelMult const& collisions, + FilteredMftTracksWCollsMcLabels const& /*mftTracks*/, + FilteredTracksWDcaSel const& tracksTpc, + soa::SmallGroups> const& reassociated3dMftTracks, + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) + { + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEvent, false, bcs); + } else { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEventMftFt0a, false, bcs); + } + } + PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChChReassociated3dMcReconstructed, "MC Rec : Process mixed-event correlations for MFT-FT0-A h-h case", false); + void processMixedMcGen(FilteredMcCollisionsWMultWCollsExtra const& mcCollisions, FilteredMcParticles const& mcParticles, SmallGroupMcCollisions const& collisions) { - auto getTracksSize = [&mcParticles, this](soa::Join::iterator const& mcCollision) { + auto getTracksSize = [&mcParticles, this](FilteredMcCollisionsWMultWCollsExtra::iterator const& mcCollision) { auto associatedTracks = mcParticles.sliceByCached(o2::aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), this->cache); - float multiplicity = 0.f; + auto multiplicity = 0; if (configCollision.useMultiplicityFromTracks) { for (const auto& track : associatedTracks) { if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { @@ -4573,7 +4708,7 @@ struct HfTaskFlow { } } } else { - multiplicity = mcCollision.multMCPVz(); + multiplicity = mcCollision.multMCFT0C(); } return multiplicity; }; @@ -4588,10 +4723,6 @@ struct HfTaskFlow { for (auto it = pairs.begin(); it != pairs.end(); it++) { auto& [collision1, tracks1, collision2, tracks2] = *it; - if (tracks1.size() == 0 || tracks2.size() == 0) { // guard against empty filtered batch - continue; - } - auto groupedCollisions1 = collisions.sliceBy(collisionPerMcCollision, collision1.globalIndex()); auto groupedCollisions2 = collisions.sliceBy(collisionPerMcCollision, collision2.globalIndex()); if (groupedCollisions1.size() == 0) { @@ -4605,40 +4736,33 @@ struct HfTaskFlow { float multiplicityCollision2 = 0.f; if (configCollision.useMultiplicityFromTracks) { - for (const auto& track : tracks1) { - if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { - multiplicityCollision1 += 1; - } - } - for (const auto& track : tracks2) { - if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { - multiplicityCollision2 += 1; - } - } + // for (const auto& track : tracks1) { + // if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { + // multiplicityCollision1 += 1; + // } + // } + // for (const auto& track : tracks2) { + // if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { + // multiplicityCollision2 += 1; + // } + // } + multiplicityCollision1 = getTracksSize(collision1); + multiplicityCollision2 = getTracksSize(collision2); + registry.fill(HIST("MC/hMixedMultiplicityTracksSize_coll1"), multiplicityCollision1); + registry.fill(HIST("MC/hMixedMultiplicityTracksSize_coll2"), multiplicityCollision2); } else { - multiplicityCollision1 = collision1.multMCPVz(); - multiplicityCollision2 = collision2.multMCPVz(); + multiplicityCollision1 = collision1.multMCFT0C(); + multiplicityCollision2 = collision2.multMCFT0C(); + registry.fill(HIST("MC/hMixedMultiplicity_multMCFT0C_coll1"), multiplicityCollision1); + registry.fill(HIST("MC/hMixedMultiplicity_multMCFT0C_coll2"), multiplicityCollision2); } float centralityCollision1 = 999.f; float centralityCollision2 = 999.f; - for (const auto& reconstructedCollision1 : groupedCollisions1) { - // if (!collision1.sel8()) { - // continue; - // } - // if (reconstructedCollision1.globalIndex() != collision1.bestCollisionIndex()) { - // continue; - // } - centralityCollision1 = getCentralityEstimator(reconstructedCollision1, false); - // break; - } - for (const auto& reconstructedCollision2 : groupedCollisions2) { - // if (reconstructedCollision2.globalIndex() != collision2.bestCollisionIndex()) { - // continue; - // } - centralityCollision2 = getCentralityEstimator(reconstructedCollision2, false); - // break; - } + centralityCollision1 = getCentralityEstimator(collision1, false); + centralityCollision2 = getCentralityEstimator(collision2, false); + registry.fill(HIST("MC/hMixedCentrality_coll1"), centralityCollision1); + registry.fill(HIST("MC/hMixedCentrality_coll2"), centralityCollision2); if (configCollision.useCentrality) { if (centralityCollision1 < configCollision.minCentrality || centralityCollision1 >= configCollision.maxCentrality) { @@ -4649,6 +4773,9 @@ struct HfTaskFlow { } } + registry.fill(HIST("MC/hMixedCentralityUsed_coll1"), centralityCollision1); + registry.fill(HIST("MC/hMixedCentralityUsed_coll2"), centralityCollision2); + if (!configCollision.useCentrality) { if ((multiplicityCollision1 < configCollision.minMultiplicity || multiplicityCollision1 >= configCollision.maxMultiplicity)) { continue; @@ -4658,6 +4785,9 @@ struct HfTaskFlow { } } + registry.fill(HIST("MC/hMixedMultiplicityUsed_coll1"), multiplicityCollision1); + registry.fill(HIST("MC/hMixedMultiplicityUsed_coll2"), multiplicityCollision2); + mixedEvent->fillEvent(multiplicityCollision1, CorrelationContainer::kCFStepAll); fillCorrelationsMonteCarlo(mixedEvent, CorrelationContainer::CFStep::kCFStepAll, tracks1, tracks2, multiplicityCollision1, collision1.posZ(), false); } @@ -4713,7 +4843,7 @@ struct HfTaskFlow { if (configMft.useMftPhiCut) { if (particle.phi() < configMft.phiMftTrackMax && particle.phi() > configMft.phiMftTrackMin && - !(particle.phi() > configMft.phiMftTrackMiddleMin && particle.phi() < configMft.phiMftTrackMiddleMax)) { + (particle.phi() <= configMft.phiMftTrackMiddleMin || particle.phi() >= configMft.phiMftTrackMiddleMax)) { if (hasReconstructedCollision) { registry.fill(HIST("MC/hEfficiencyAssociated"), particle.pt(), particle.eta(), mcCollision.posZ()); }