diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index 979c580aa3a..467410d7151 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -202,6 +202,7 @@ struct HfTaskFlow { struct : ConfigurableGroup { std::string prefix = "ConfigTask_group"; Configurable centralityBinsForMc{"centralityBinsForMc", false, "falsce = OFF, true = ON for data like multiplicity/centrality bins for MC steps"}; + Configurable chooseCorrelationCase{"chooseCorrelationCase", 0, "0: Tpc-Tpc, 1: Tpc-Mft, 2: Tpc-Fv0a, 3: Mft-Fv0a, 4: Tpc-Ft0a, 5: Mft-Ft0a, 6: Tpc-Ft0c, 7: Ft0a-Ft0c"}; Configurable doEtaDependentFlow{"doEtaDependentFlow", false, "Flag to know if eta dependent flow should be done"}; Configurable doHeavyFlavor{"doHeavyFlavor", false, "Flag to know we in the heavy flavor case or not"}; Configurable doMonteCarlo{"doMonteCarlo", false, "Flag to know if Monte Carlo should be done"}; @@ -211,6 +212,10 @@ struct HfTaskFlow { Configurable etaMcParticlesTriggerMin{"etaMcParticlesTriggerMin", -0.8f, "Minimum value for the eta of MC particles when used in cut function"}; 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 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"}; Configurable ptMcParticlesTriggerMax{"ptMcParticlesTriggerMax", 3.0f, "Maximum value for the pT of MC particles when used in cut function"}; Configurable ptMcParticlesTriggerMin{"ptMcParticlesTriggerMin", 0.2f, "Minimum value for the pT of MC particles when used in cut function"}; Configurable ptMcParticlesAssocMax{"ptMcParticlesAssocMax", 100.0f, "Maximum value for the pT of MC particles when used in cut function"}; @@ -219,6 +224,7 @@ struct HfTaskFlow { Configurable nMixedEvents{"nMixedEvents", 5, "Number of mixed events per event"}; Configurable nSamples{"nSamples", 10, "number of different samples for correlations"}; Configurable nameCorrelationContainer{"nameCorrelationContainer", "", "Add the possibility to the rename the correlation container as configurable"}; + Configurable useEfficiencyCorrection{"useEfficiencyCorrection", false, "Choose to use or not use efficiency correction, if not used, weight is set to 1"}; } configTask; // configurables for collisions @@ -235,6 +241,8 @@ struct HfTaskFlow { 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 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"}; Configurable requireCorrelationAnalysisRCTFlagChecker{"requireCorrelationAnalysisRCTFlagChecker", false, "Check event quality in run condition table for correlation analysis"}; Configurable setRCTFlagCheckerLabel{"setRCTFlagCheckerLabel", "CBT_muon_global", "Evt sel: RCT flag checker label"}; @@ -318,6 +326,13 @@ struct HfTaskFlow { RCTFlagsChecker rctChecker; RCTFlagsChecker correlationAnalysisRctChecker{kFT0Bad, kITSBad, kTPCBadTracking, kTPCBadPID, kMFTBad}; + TH3D* mEfficiencyTpc = nullptr; + TH3D* mEfficiencyMft = nullptr; + TH1D* mEfficiencyNch = nullptr; + bool areCorrectionsLoaded = false; + + // o2::aod::rctsel::RCTFlagsChecker rctChecker{"CBT_muon_glo", false, false, true}; + // ========================= // using declarations : DATA // ========================= @@ -521,7 +536,7 @@ struct HfTaskFlow { // ========================= rctChecker.init(configCollision.setRCTFlagCheckerLabel, configCollision.requireZDCCheck, configCollision.requireRCTFlagCheckerLimitAcceptanceAsBad, true); - correlationAnalysisRctChecker.init({kFT0Bad, kITSBad, kTPCBadTracking, kTPCBadPID, kMFTBad}, configCollision.requireZDCCheck, configCollision.requireRCTFlagCheckerLimitAcceptanceAsBad, true); + correlationAnalysisRctChecker.init({kFT0Bad, kITSBad, kTPCBadTracking, kTPCBadPID, kMFTBad, kITSLimAccMCRepr, kMFTLimAccMCRepr, kTPCLimAccMCRepr}); registry.add("Data/hVtxZ", "v_{z} (cm)", {HistType::kTH1D, {configAxis.axisVertex}}); registry.add("Data/hNTracks", "", {HistType::kTH1F, {configAxis.axisMultiplicity}}); @@ -577,8 +592,8 @@ struct HfTaskFlow { {configAxis.axisVertex, "z-vtx (cm)"}}; std::vector const corrAxisEta = {{configAxis.axisSamples, "sampling"}, {configAxis.axisVertex, "z-vtx (cm)"}, - {configAxis.axisEtaTrigger, "#eta_{trigger}"}, {configAxis.axisEtaAssociated, "#eta_{associated}"}, + {configAxis.axisEtaTrigger, "#eta_{trigger}"}, {configAxis.axisDeltaPhi, "#Delta#varphi (rad)"}, {configAxis.axisDeltaEta, "#Delta#eta"}}; std::vector const corrAxisVariations = {{configAxis.axisSamples, "sampling"}, @@ -632,6 +647,8 @@ struct HfTaskFlow { if (doprocessSameTpcMftChCh || doprocessSameTpcMftChChReassociated || doprocessSameTpcMftChChReassociated3d || doprocessSameTpcMftChChNonAmbiguous) { addHistograms(); addMftHistograms(); + registry.add("Data/hEfficiencyTrigger", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); + registry.add("Data/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { registry.add("Trig_hist_TPC_MFT", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); @@ -849,6 +866,46 @@ struct HfTaskFlow { // Initialization of histograms and CorrelationContainers for McGen cases // ========================= + if (doprocessSameMcGen) { + + registry.add("MC/hEfficiencyTrigger", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); + registry.add("MC/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}}); + + if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFv0a)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFv0a)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0a)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0c)) { + addHistograms(); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::Ft0aFt0c)) { + addHistograms(); + } + + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + registry.add("Trig_hist", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + } else if (configTask.doEtaDependentFlow) { + registry.add("Trig_hist", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisEtaTrigger}}}); + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + } else { + registry.add("Trig_hist", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisVariations, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisVariations, effAxis, {})); + } + } + + // ========================= + // Initialization of histograms and CorrelationContainers for McGen cases + // ========================= + // if (doprocessSameMcGen) { // if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { @@ -894,22 +951,22 @@ struct HfTaskFlow { // Helper functions // ========================= - HfProngSpecies getSpecies(int pdgCode) - { - switch (std::abs(pdgCode)) { - case PDG_t::kPiPlus: // positive or negative pion - return HfProngSpecies::Pion; - case PDG_t::kKPlus: // positive or negative kaon - return HfProngSpecies::Kaon; - case PDG_t::kProton: // proton or proton bar - return HfProngSpecies::Proton; - default: // NOTE. The efficiency histogram is hardcoded to contain 4 species. Anything special will have the last slot. - return HfProngSpecies::NHfProngSpecies; - } - } + // HfProngSpecies getSpecies(int pdgCode) + // { + // switch (std::abs(pdgCode)) { + // case PDG_t::kPiPlus: // positive or negative pion + // return HfProngSpecies::Pion; + // case PDG_t::kKPlus: // positive or negative kaon + // return HfProngSpecies::Kaon; + // case PDG_t::kProton: // proton or proton bar + // return HfProngSpecies::Proton; + // default: // NOTE. The efficiency histogram is hardcoded to contain 4 species. Anything special will have the last slot. + // return HfProngSpecies::NHfProngSpecies; + // } + // } template - float getMultiplicityEstimator(TCollision collision, bool isSameEvent) + int64_t getMultiplicityEstimator(TCollision collision, bool isSameEvent) { switch (configCollision.multiplicityEstimator) { case MultiplicityEstimators::MultNTracksPV: @@ -1100,6 +1157,129 @@ struct HfTaskFlow { } } + void loadEfficiencyCorrection(uint64_t timestamp) + { + if (areCorrectionsLoaded) { + return; + } + if (configTask.loadEfficienciesForTpc.value.empty() == false) { + mEfficiencyTpc = ccdb->getForTimeStamp(configTask.loadEfficienciesForTpc, timestamp); + if (mEfficiencyTpc == nullptr) { + LOGF(fatal, "Could not load efficiency histogram for TPC tracks from %s", configTask.loadEfficienciesForTpc.value.c_str()); + } + LOGF(info, "Loaded efficiency histogram from %s (%p)", configTask.loadEfficienciesForTpc.value.c_str(), (void*)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); + } + 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); + } + areCorrectionsLoaded = true; + } + + bool getEfficiencyCorrectionTpc(float& weightTpc, float pt, float eta, float vertex) + { + float efficiencyTpc = 1.; + + if (mEfficiencyTpc) { + int etaBin = mEfficiencyTpc->GetXaxis()->FindBin(eta); + int ptBin = mEfficiencyTpc->FindBin(pt); + int vertexBin = mEfficiencyTpc->GetZaxis()->FindBin(vertex); + efficiencyTpc = mEfficiencyTpc->GetBinContent(etaBin, ptBin, vertexBin); + } + + if (efficiencyTpc == 0) { + return false; + } + + weightTpc = 1. / efficiencyTpc; + + return true; + } + + bool getEfficiencyCorrectionMft(float& weightMft, float pt, float eta, float vertex) + { + float efficiencyMft = 1.; + + if (mEfficiencyMft) { + int etaBin = mEfficiencyMft->GetXaxis()->FindBin(eta); + int ptBin = mEfficiencyMft->FindBin(pt); + int vertexBin = mEfficiencyMft->GetZaxis()->FindBin(vertex); + efficiencyMft = mEfficiencyMft->GetBinContent(etaBin, ptBin, vertexBin); + } + + if (efficiencyMft == 0) { + return false; + } + + weightMft = 1. / efficiencyMft; + + return true; + } + + template + double getCorrectedMultiplicity(TTracks tracks) // function to count the number of tracks in the event and fill the histogram + { + auto trackCounter = 0; + auto weightMultiplicity = 1.0f; + for (auto const& track : tracks) { + + if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { + trackCounter += 1; + } + + // if (!getEfficiencyCorrection_Nch(weight_Nch, track.pt())) { + // continue; + // } + auto efficiencyNch = 1.0f; + if (configTask.useEfficiencyCorrection) { + + if (mEfficiencyNch) { + int ptBin = mEfficiencyNch->FindBin(track.pt()); + efficiencyNch = mEfficiencyNch->GetBinContent(ptBin); + } + + if (efficiencyNch == 0) { + return false; + } + + weightMultiplicity = 1. / efficiencyNch; + } else { + weightMultiplicity = 0; + } + + trackCounter += weightMultiplicity; + } + return trackCounter; + } + + // bool getEfficiencyCorrectionNch(float& weightNch, float pt) + // { + // float efficiencyNch = 1.; + + // if (mEfficiencyNch) { + // int ptBin = mEfficiencyNch->FindBin(pt); + // efficiencyNch = mEfficiencyNch->GetBinContent(ptBin); + // } + + // if (efficiencyNch == 0 ) { + // return false; + // } + + // weightNch = 1. / efficiencyNch; + + // return true; + // } + // ========================= // Cuts with functions // ========================= @@ -1337,8 +1517,8 @@ struct HfTaskFlow { TTracksTrig const& tracks1, TTracksAssoc const& tracks2, float multiplicity, float posZ, bool sameEvent, int magneticField) { - auto triggerWeight = 1; - auto associatedWeight = 1; + auto triggerWeight = 1.0f; + auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision int sampleIndex = gRandom->Uniform(0, configTask.nSamples); @@ -1356,6 +1536,10 @@ struct HfTaskFlow { float const pt1 = track1.pt(); float const phi1 = track1.phi(); + if (configTask.useEfficiencyCorrection && !getEfficiencyCorrectionTpc(triggerWeight, pt1, eta1, posZ)) { + continue; + } + // TODO: add getter for NUE trigger efficiency here // calculating inv. mass to be filled into the container below @@ -1503,6 +1687,17 @@ struct HfTaskFlow { float phi2 = track2.phi(); o2::math_utils::bringTo02Pi(phi2); + if constexpr (std::is_same_v) { + if (configTask.useEfficiencyCorrection && !getEfficiencyCorrectionTpc(associatedWeight, pt2, eta2, posZ)) { + continue; + } + } + if constexpr (std::is_same_v) { + if (configTask.useEfficiencyCorrection && !getEfficiencyCorrectionMft(associatedWeight, pt2, eta2, posZ)) { + continue; + } + } + // TODO: add getter for NUE associated efficiency here float deltaPhi = phi1 - phi2; @@ -1559,8 +1754,8 @@ struct HfTaskFlow { TTracksTrig const& tracks1, TTracksAssoc const& tracks2, float multiplicity, float posZ, bool sameEvent, bool cutAmbiguousTracks) { - auto triggerWeight = 1; - auto associatedWeight = 1; + auto triggerWeight = 1.0f; + auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision int sampleIndex = gRandom->Uniform(0, configTask.nSamples); @@ -1578,6 +1773,10 @@ struct HfTaskFlow { float const pt1 = track1.pt(); float const phi1 = track1.phi(); + if (configTask.useEfficiencyCorrection && !getEfficiencyCorrectionTpc(triggerWeight, pt1, eta1, posZ)) { + continue; + } + bool fillingHFcontainer = false; double invmass = 0; if constexpr (std::is_same_v || std::is_same_v) { @@ -1615,6 +1814,7 @@ struct HfTaskFlow { fillTriggerQa(multiplicity, eta1, phi1, pt1); } else { fillTriggerQa(multiplicity, eta1, phi1, pt1); + registry.fill(HIST("Data/hEfficiencyTrigger"), pt1, eta1, posZ); } } @@ -1706,7 +1906,9 @@ struct HfTaskFlow { float phi2 = reassociatedMftTrack.phi(); o2::math_utils::bringTo02Pi(phi2); - // TODO: add getter for NUE associated efficiency here + if (configTask.useEfficiencyCorrection && !getEfficiencyCorrectionMft(associatedWeight, pt2, eta2, posZ)) { + continue; + } float deltaPhi = phi1 - phi2; // set range of delta phi in (-pi/2 , 3/2*pi) @@ -1739,6 +1941,7 @@ struct HfTaskFlow { } else { fillAssociatedQa(multiplicity, eta2, phi2); registry.fill(HIST("Data/Mft/hPtMft"), pt2); + registry.fill(HIST("Data/hEfficiencyAssociated"), pt2, eta2, posZ); } } // end of fill QA } // end of loop over tracks2 @@ -1750,8 +1953,8 @@ struct HfTaskFlow { TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TFits const&, float multiplicity, float posZ, bool sameEvent, int fitType) { - auto triggerWeight = 1; - auto associatedWeight = 1; + auto triggerWeight = 1.0f; + auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision int sampleIndex = gRandom->Uniform(0, configTask.nSamples); @@ -1782,6 +1985,13 @@ struct HfTaskFlow { float phi1 = track1.phi(); if constexpr (std::is_same_v) { o2::math_utils::bringTo02Pi(phi1); + if (configTask.useEfficiencyCorrection && !getEfficiencyCorrectionMft(triggerWeight, pt1, eta1, posZ)) { + continue; + } + } else { + if (configTask.useEfficiencyCorrection && !getEfficiencyCorrectionTpc(triggerWeight, pt1, eta1, posZ)) { + continue; + } } bool fillingHFcontainer = false; @@ -1987,8 +2197,8 @@ struct HfTaskFlow { TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TFits const&, float multiplicity, float posZ, bool sameEvent, bool cutAmbiguousTracks, int fitType) { - auto triggerWeight = 1; - auto associatedWeight = 1; + auto triggerWeight = 1.0f; + auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision int sampleIndex = gRandom->Uniform(0, configTask.nSamples); @@ -2031,12 +2241,12 @@ struct HfTaskFlow { float phi1 = reassociatedMftTrack.phi(); o2::math_utils::bringTo02Pi(phi1); - if (!configTask.doEtaDependentFlow) { - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); - } else { - target->getTriggerHist()->Fill(step, eta1, multiplicity, posZ, triggerWeight); + if (configTask.useEfficiencyCorrection && !getEfficiencyCorrectionMft(triggerWeight, pt1, eta1, posZ)) { + continue; } + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + if (configTask.doEtaDependentFlow) { registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, eta1, triggerWeight); // think about event weight in near future } @@ -2131,8 +2341,8 @@ struct HfTaskFlow { TFT0As const& ft0as, TFT0Cs const& ft0cs, float multiplicity, float posZ, bool sameEvent) { - auto triggerWeight = 1; - auto associatedWeight = 1; + auto triggerWeight = 1.0f; + auto associatedWeight = 1.0f; auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision int sampleIndex = gRandom->Uniform(0, configTask.nSamples); @@ -2186,67 +2396,120 @@ struct HfTaskFlow { } // end of trigger loop } // end of fillCorrelationsFt0aFt0c - // template - // void fillCorrelationsMonteCarlo(TTarget target, CorrelationContainer::CFStep step, - // TTracksTrig const& tracks1, TTracksAssoc const& tracks2, - // float multiplicity, float posZ, bool sameEvent) - // { - // auto triggerWeight = 1; - // auto associatedWeight = 1; - // auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision - // int sampleIndex = gRandom->Uniform(0, configTask.nSamples); + template + void fillCorrelationsMonteCarlo(TTarget target, CorrelationContainer::CFStep step, + TTracksTrig const& tracks1, TTracksAssoc const& tracks2, + float multiplicity, float posZ, bool sameEvent) + { + auto triggerWeight = 1; + auto associatedWeight = 1; + auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision + int sampleIndex = gRandom->Uniform(0, configTask.nSamples); + bool fillQaPlots = false; - // for (auto const& track1 : tracks1) { + if (configTask.fillOnlyStepAll) { + if (step == CorrelationContainer::kCFStepAll) { + fillQaPlots = true; + } + } else { + if (step == CorrelationContainer::kCFStepTrackedOnlyPrim) { + fillQaPlots = true; + } + } - // if (track1.eta() < configTask.etaMcParticlesTriggerMin || track1.eta() > configTask.etaMcParticlesTriggerMax) { - // continue; - // } - // if (track1.pt() < configTask.ptMcParticlesTriggerMin || track1.pt() > configTask.ptMcParticlesTriggerMax) { - // continue; - // } - // if (step >= CorrelationContainer::kCFStepTrackedOnlyPrim && !track1.isPhysicalPrimary()) { - // continue; - // } + for (auto const& track1 : tracks1) { + loopCounter++; - // target->getTriggerHist()->Fill(step, track1.pt(), multiplicity, posZ, triggerWeight); - // if (configTask.doEtaDependentFlow) { - // registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.eta(), triggerWeight); - // } else { - // registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.pt(), triggerWeight); - // } + if (track1.eta() < configTask.etaMcParticlesTriggerMin || track1.eta() > configTask.etaMcParticlesTriggerMax) { + continue; + } + if (track1.pt() < configTask.ptMcParticlesTriggerMin || track1.pt() > configTask.ptMcParticlesTriggerMax) { + continue; + } + if (step >= CorrelationContainer::kCFStepTrackedOnlyPrim && !track1.isPhysicalPrimary()) { + continue; + } - // for (auto const& track2 : tracks2) { - - // if (track1.globalIndex() == track2.globalIndex()) { - // continue; - // } - // if (track2.eta() < configTask.etaMcParticlesAssocMin || track2.eta() > configTask.etaMcParticlesAssocMax) { - // continue; - // } - // if (track2.pt() < configTask.ptMcParticlesAssocMin || track2.pt() > configTask.ptMcParticlesAssocMax) { - // continue; - // } - // if (step >= CorrelationContainer::kCFStepTrackedOnlyPrim && !track2.isPhysicalPrimary()) { - // continue; - // } - - // float deltaPhi = RecoDecay::constrainAngle(track2.phi() - track1.phi(), -PIHalf); - // float deltaEta = track2.eta() - track1.eta(); - - // if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - // target->getPairHist()->Fill(step, deltaEta, track2.pt(), track1.pt(), multiplicity, deltaPhi, posZ, - // triggerWeight * associatedWeight); - // } else if (configTask.doEtaDependentFlow) { - // target->getPairHist()->Fill(step, sampleIndex, posZ, track2.eta(), track1.eta(), deltaPhi, deltaEta, - // triggerWeight * associatedWeight); - // } else { - // target->getPairHist()->Fill(step, sampleIndex, posZ, track1.pt(), multiplicity, deltaPhi, deltaEta, - // triggerWeight * associatedWeight); - // } - // } // end of loop over track2 - - // } // end of loop over track1 - // } + 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 + } + if (configTask.doVariationContainers) { + registry.fill(HIST("Trig_hist"), sampleIndex, posZ, track1.pt(), triggerWeight); + } + + // FILL QA FOR TRIGGER PARTICLE + if (sameEvent && 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()); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { + fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFv0a)) { + fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFv0a)) { + fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0a)) { + fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0c)) { + fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::Ft0aFt0c)) { + fillTriggerQa(multiplicity, track1.eta(), track1.phi(), track1.pt()); + } + } + + for (auto const& track2 : tracks2) { + + if (track1.globalIndex() == track2.globalIndex()) { + continue; + } + if (track2.eta() < configTask.etaMcParticlesAssocMin || track2.eta() > configTask.etaMcParticlesAssocMax) { + continue; + } + if (track2.pt() < configTask.ptMcParticlesAssocMin || track2.pt() > configTask.ptMcParticlesAssocMax) { + continue; + } + if (step >= CorrelationContainer::kCFStepTrackedOnlyPrim && !track2.isPhysicalPrimary()) { + continue; + } + + float deltaPhi = RecoDecay::constrainAngle(track2.phi() - track1.phi(), -PIHalf); + float deltaEta = track2.eta() - track1.eta(); + + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + target->getPairHist()->Fill(step, deltaEta, track2.pt(), track1.pt(), multiplicity, deltaPhi, posZ, + triggerWeight * associatedWeight); + } else if (configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, sampleIndex, posZ, track2.eta(), track1.eta(), deltaPhi, deltaEta, + triggerWeight * associatedWeight); + } else { + target->getPairHist()->Fill(step, sampleIndex, posZ, track1.pt(), multiplicity, deltaPhi, deltaEta, + triggerWeight * associatedWeight); + } + + // FILL QA PLOTS for associated particle + if (sameEvent && fillQaPlots && (loopCounter == 1)) { + registry.fill(HIST("MC/hEfficiencyAssociated"), track2.pt(), track2.eta(), posZ); + if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcTpc)) { + fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcMft)) { + fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFv0a)) { + fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::MftFv0a)) { + fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0a)) { + fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::TpcFt0c)) { + fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); + } else if (configTask.chooseCorrelationCase.value == static_cast(CorrelationCase::Ft0aFt0c)) { + fillAssociatedQa(track2.eta(), track2.phi(), track2.pt()); + } + } // end of fill QA + } // end of loop over track2 + } // end of loop over track1 + } // =============================================================================================================================================================================== // mixCollisions for RECONSTRUCTED events @@ -2257,9 +2520,19 @@ struct HfTaskFlow { TTracksTrig const& tracks1, TTracksAssoc const& tracks2, OutputObj& corrContainer, aod::BCsWithTimestamps const&) { - auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { - auto multiplicity = getMultiplicityEstimator(collision, false); - return multiplicity; + // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { + // auto multiplicity = getMultiplicityEstimator(collision, false); + // return multiplicity; + // }; + + auto getMultiplicity = [&tracks1, this](FilteredCollisionsWSelMult::iterator const& collision) { + auto associatedTracks = tracks1.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); + // auto mult = 0.f; + if (configCollision.useMultiplicityFromTracks) { + return associatedTracks.size(); + } else { + return getMultiplicityEstimator(collision, false); + } }; // The first one that I call "Data" should work for data and mc rec @@ -2279,9 +2552,15 @@ struct HfTaskFlow { } auto bc = collision1.template bc_as(); - const auto multiplicity = getMultiplicityEstimator(collision1, false); + loadEfficiencyCorrection(bc.timestamp()); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks1.size(); + } else { + multiplicity = getMultiplicityEstimator(collision1, false); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2295,9 +2574,19 @@ struct HfTaskFlow { TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TPresliceTrigger const& presliceTrigger, TPresliceAssociated const& presliceAssociated, OutputObj& corrContainer, aod::BCsWithTimestamps const&) { - auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { - auto multiplicity = getMultiplicityEstimator(collision, false); - return multiplicity; + // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { + // auto multiplicity = getMultiplicityEstimator(collision, false); + // return multiplicity; + // }; + + auto getMultiplicity = [&tracks1, this](FilteredCollisionsWSelMult::iterator const& collision) { + auto associatedTracks = tracks1.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); + auto mult = associatedTracks.size(); + if (configCollision.useMultiplicityFromTracks) { + return mult; + } else { + return getMultiplicityEstimator(collision, false); + } }; using MixedBinning = FlexibleBinningPolicy, aod::collision::PosZ, decltype(getMultiplicity)>; @@ -2314,12 +2603,19 @@ struct HfTaskFlow { if (collision1.globalIndex() == collision2.globalIndex()) { continue; } - const auto multiplicity = getMultiplicityEstimator(collision1, false); - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + + auto bc = collision1.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks1.size(); + } else { + multiplicity = getMultiplicityEstimator(collision1, false); + } + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } - auto bc = collision1.template bc_as(); auto slicedTriggerTracks = tracks1.sliceBy(presliceTrigger, collision1.globalIndex()); auto slicedAssociatedTracks = tracks2.sliceBy(presliceAssociated, collision2.globalIndex()); @@ -2328,14 +2624,24 @@ struct HfTaskFlow { } } - template - void mixCollisionsReassociatedMftTracks(TCollisions const& collisions, CorrelationContainer::CFStep step, + template + void mixCollisionsReassociatedMftTracks(TCollisions const& collisions, CorrelationContainer::CFStep step, TTracksTpc const& tracksTpc, TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TPresliceTrigger const& presliceTrigger, TPresliceAssociated const& presliceAssociated, - OutputObj& corrContainer, bool cutAmbiguousTracks) + OutputObj& corrContainer, bool cutAmbiguousTracks, aod::BCsWithTimestamps const&) { - auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { - auto multiplicity = getMultiplicityEstimator(collision, false); - return multiplicity; + // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { + // auto multiplicity = getMultiplicityEstimator(collision, false); + // return multiplicity; + // }; + + auto getMultiplicity = [&tracksTpc, this](FilteredCollisionsWSelMult::iterator const& collision) { + auto associatedTracks = tracksTpc.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); + auto mult = associatedTracks.size(); + if (configCollision.useMultiplicityFromTracks) { + return mult; + } else { + return getMultiplicityEstimator(collision, false); + } }; using MixedBinning = FlexibleBinningPolicy, aod::collision::PosZ, decltype(getMultiplicity)>; @@ -2349,8 +2655,16 @@ struct HfTaskFlow { if (collision1.globalIndex() == collision2.globalIndex()) { continue; } - const auto multiplicity = getMultiplicityEstimator(collision1, false); - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + + auto bc = collision1.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracksTpc.size(); + } else { + multiplicity = getMultiplicityEstimator(collision1, false); + } + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2374,11 +2688,21 @@ struct HfTaskFlow { template void mixCollisionsFIT(TCollisions const& collisions, CorrelationContainer::CFStep step, TTracksTrig const& tracks1, TTracksAssoc const& tracks2, TPreslice const& preslice, - OutputObj& corrContainer, int fitType) + OutputObj& corrContainer, int fitType, aod::BCsWithTimestamps const&) { - auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { - auto multiplicity = getMultiplicityEstimator(collision, false); - return multiplicity; + // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { + // auto multiplicity = getMultiplicityEstimator(collision, false); + // return multiplicity; + // }; + + auto getMultiplicity = [&tracks1, this](FilteredCollisionsWSelMult::iterator const& collision) { + auto associatedTracks = tracks1.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); + auto mult = associatedTracks.size(); + if (configCollision.useMultiplicityFromTracks) { + return mult; + } else { + return getMultiplicityEstimator(collision, false); + } }; using MixedBinning = FlexibleBinningPolicy, aod::collision::PosZ, decltype(getMultiplicity)>; @@ -2394,14 +2718,23 @@ struct HfTaskFlow { continue; } + auto bc = collision1.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); + if constexpr (std::is_same_v) { // IF ASSOCIATED PARTICLE FROM FV0A if (collision1.has_foundFV0() && collision2.has_foundFV0()) { - const auto multiplicity = getMultiplicityEstimator(collision1, false); auto slicedTriggerTracks = tracks1.sliceBy(preslice, collision1.globalIndex()); const auto& fv0 = collision2.foundFV0(); - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks1.size(); + } else { + multiplicity = getMultiplicityEstimator(collision1, false); + } + + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2413,9 +2746,18 @@ struct HfTaskFlow { if constexpr (std::is_same_v) { if (collision1.has_foundFT0() && collision2.has_foundFT0()) { - const auto multiplicity = getMultiplicityEstimator(collision1, false); auto slicedTriggerTracks = tracks1.sliceBy(preslice, collision1.globalIndex()); const auto& ft0 = collision2.foundFT0(); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks1.size(); + } else { + multiplicity = getMultiplicityEstimator(collision1, false); + } + + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { + return; + } corrContainer->fillEvent(multiplicity, step); fillCorrelationsFIT(corrContainer, step, slicedTriggerTracks, ft0, tracks2, multiplicity, collision1.posZ(), false, fitType); @@ -2424,14 +2766,24 @@ struct HfTaskFlow { } // end of for loop } - template + template void mixCollisionsFt0aFt0c(TCollisions const& collisions, CorrelationContainer::CFStep step, - TFT0as const&, TFT0cs const&, - OutputObj& corrContainer) + TTracksTpc const& tracksTpc, TFT0as const&, TFT0cs const&, + OutputObj& corrContainer, aod::BCsWithTimestamps const&) { - auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { - auto multiplicity = getMultiplicityEstimator(collision, false); - return multiplicity; + // auto getMultiplicity = [this](FilteredCollisionsWSelMult::iterator const& collision) { + // auto multiplicity = getMultiplicityEstimator(collision, false); + // return multiplicity; + // }; + + auto getMultiplicity = [&tracksTpc, this](FilteredCollisionsWSelMult::iterator const& collision) { + auto associatedTracks = tracksTpc.sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), this->cache); + auto mult = associatedTracks.size(); + if (configCollision.useMultiplicityFromTracks) { + return mult; + } else { + return getMultiplicityEstimator(collision, false); + } }; using MixedBinning = FlexibleBinningPolicy, aod::collision::PosZ, decltype(getMultiplicity)>; @@ -2449,11 +2801,19 @@ struct HfTaskFlow { if (collision1.has_foundFT0() && collision2.has_foundFT0()) { - const auto multiplicity = getMultiplicityEstimator(collision1, false); const auto& ft0as = collision1.foundFT0(); const auto& ft0cs = collision2.foundFT0(); - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + auto bc = collision1.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracksTpc.size(); + } else { + multiplicity = getMultiplicityEstimator(collision1, false); + } + + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2487,9 +2847,15 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); auto bc = collision.template bc_as(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + loadEfficiencyCorrection(bc.timestamp()); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2520,9 +2886,15 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); auto bc = collision.template bc_as(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + loadEfficiencyCorrection(bc.timestamp()); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2553,9 +2925,15 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); auto bc = collision.template bc_as(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + loadEfficiencyCorrection(bc.timestamp()); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2579,9 +2957,15 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); auto bc = collision.template bc_as(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + loadEfficiencyCorrection(bc.timestamp()); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2598,7 +2982,8 @@ struct HfTaskFlow { void processSameTpcMftChChReassociated(FilteredCollisionsWSelMult::iterator const& collision, soa::SmallGroups const& reassociatedMftTracks, FilteredTracksWDcaSel const& tracks, - FilteredMftTracks const& mftTracks) + FilteredMftTracks const& mftTracks, + aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; @@ -2607,9 +2992,16 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2626,7 +3018,8 @@ struct HfTaskFlow { void processSameTpcMftChChReassociated3d(FilteredCollisionsWSelMult::iterator const& collision, soa::SmallGroups const& reassociatedMftTracks, FilteredTracksWDcaSel const& tracks, - FilteredMftTracks const& mftTracks) + FilteredMftTracks const& mftTracks, + aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; @@ -2635,11 +3028,16 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - // const auto multiplicity = collision.multNTracksPV(); - const auto multiplicity = getMultiplicityEstimator(collision, true); - - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2656,7 +3054,8 @@ struct HfTaskFlow { void processSameTpcMftChChNonAmbiguous(FilteredCollisionsWSelMult::iterator const& collision, soa::SmallGroups const& reassociatedMftTracks, FilteredTracksWDcaSel const& tracks, - FilteredMftTracks const& mftTracks) + FilteredMftTracks const& mftTracks, + aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; // when process function has iterator @@ -2665,9 +3064,16 @@ struct HfTaskFlow { registry.fill(HIST("Data/hNTracks"), tracks.size()); registry.fill(HIST("Data/Mft/hNMftTracks"), mftTracks.size()); registry.fill(HIST("Data/Mft/hNBestCollisionFwd"), reassociatedMftTracks.size()); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2687,7 +3093,7 @@ struct HfTaskFlow { void processSameTpcMftD0Ch(FilteredCollisionsWSelMult::iterator const& collision, HfCandidatesSelD0 const& candidates, - FilteredTracksWDcaSel const& /*tracks*/, + FilteredTracksWDcaSel const& tracks, FilteredMftTracks const& mftTracks, aod::BCsWithTimestamps const&) { @@ -2703,9 +3109,15 @@ struct HfTaskFlow { } auto bc = collision.template bc_as(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + loadEfficiencyCorrection(bc.timestamp()); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2717,15 +3129,24 @@ struct HfTaskFlow { void processSameTpcMftD0ChReassociated(FilteredCollisionsWSelMult::iterator const& collision, HfCandidatesSelD0 const& candidates, soa::SmallGroups const& reassociatedMftTracks, - FilteredMftTracks const&) + FilteredTracksWDcaSel const& tracks, + FilteredMftTracks const&, + aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; // when process function has iterator } - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2740,7 +3161,7 @@ struct HfTaskFlow { void processSameTpcMftLcCh(FilteredCollisionsWSelMult::iterator const& collision, HfCandidatesSelLc const& candidates, - FilteredTracksWDcaSel const& /*tracks*/, + FilteredTracksWDcaSel const& tracks, FilteredMftTracks const& mftTracks, aod::BCsWithTimestamps const&) { @@ -2756,9 +3177,15 @@ struct HfTaskFlow { } auto bc = collision.template bc_as(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + loadEfficiencyCorrection(bc.timestamp()); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2770,15 +3197,24 @@ struct HfTaskFlow { void processSameTpcMftLcChReassociated(FilteredCollisionsWSelMult::iterator const& collision, HfCandidatesSelLc const& candidates, soa::SmallGroups const& reassociatedMftTracks, - FilteredMftTracks const&) + FilteredTracksWDcaSel const& tracks, + FilteredMftTracks const&, + aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; // when process function has iterator } - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2803,9 +3239,9 @@ struct HfTaskFlow { // const auto& fv0 = collision.foundFV0(); // registry.fill(HIST("Data/hNTracks"), tracks.size()); - // const auto multiplicity = getMultiplicityEstimator(collision, true); + // auto multiplicity = getMultiplicityEstimator(collision, true); - // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { // return; // } @@ -2829,9 +3265,9 @@ struct HfTaskFlow { // if (collision.has_foundFV0()) { // const auto& fv0 = collision.foundFV0(); - // const auto multiplicity = getMultiplicityEstimator(collision, true); + // auto multiplicity = getMultiplicityEstimator(collision, true); - // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { // return; // } @@ -2855,9 +3291,9 @@ struct HfTaskFlow { // if (collision.has_foundFV0()) { // const auto& fv0 = collision.foundFV0(); - // const auto multiplicity = getMultiplicityEstimator(collision, true); + // auto multiplicity = getMultiplicityEstimator(collision, true); - // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { // return; // } @@ -2881,9 +3317,9 @@ struct HfTaskFlow { // if (collision.has_foundFV0()) { // const auto& fv0 = collision.foundFV0(); - // const auto multiplicity = getMultiplicityEstimator(collision, true); + // auto multiplicity = getMultiplicityEstimator(collision, true); - // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { // return; // } @@ -2904,9 +3340,9 @@ struct HfTaskFlow { // if (collision.has_foundFV0()) { // const auto& fv0 = collision.foundFV0(); - // const auto multiplicity = getMultiplicityEstimator(collision, true); + // auto multiplicity = getMultiplicityEstimator(collision, true); - // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { // return; // } @@ -2928,9 +3364,9 @@ struct HfTaskFlow { if (collision.has_foundFV0()) { const auto& fv0 = collision.foundFV0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = getMultiplicityEstimator(collision, true); - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -2952,9 +3388,9 @@ struct HfTaskFlow { // if (collision.has_foundFV0()) { // const auto& fv0 = collision.foundFV0(); - // const auto multiplicity = getMultiplicityEstimator(collision, true); + // auto multiplicity = getMultiplicityEstimator(collision, true); - // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { // return; // } @@ -2977,15 +3413,21 @@ struct HfTaskFlow { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); registry.fill(HIST("Data/hNTracks"), tracks.size()); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3007,20 +3449,27 @@ struct HfTaskFlow { void processSameTpcFt0aD0Ch(FilteredCollisionsWSelMult::iterator const& collision, HfCandidatesSelD0 const& candidates, aod::FT0s const& ft0as, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3037,20 +3486,27 @@ struct HfTaskFlow { void processSameTpcFt0aLcCh(FilteredCollisionsWSelMult::iterator const& collision, HfCandidatesSelLc const& candidates, aod::FT0s const& ft0as, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3067,20 +3523,27 @@ struct HfTaskFlow { void processSameMftFt0aChCh(FilteredCollisionsWSelMult::iterator const& collision, FilteredMftTracks const& mftTracks, aod::FT0s const& ft0as, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3099,20 +3562,27 @@ struct HfTaskFlow { soa::SmallGroups const& reassociatedMftTracks, FilteredMftTracks const&, aod::FT0s const& ft0as, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3131,20 +3601,27 @@ struct HfTaskFlow { soa::SmallGroups const& reassociatedMftTracks, FilteredMftTracks const&, aod::FT0s const& ft0as, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3163,20 +3640,27 @@ struct HfTaskFlow { soa::SmallGroups const& reassociatedMftTracks, FilteredMftTracks const&, aod::FT0s const& ft0as, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3204,15 +3688,21 @@ struct HfTaskFlow { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); registry.fill(HIST("Data/hNTracks"), tracks.size()); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3229,20 +3719,27 @@ struct HfTaskFlow { void processSameTpcFt0cD0Ch(FilteredCollisionsWSelMult::iterator const& collision, HfCandidatesSelD0 const& candidates, aod::FT0s const& ft0cs, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3259,20 +3756,27 @@ struct HfTaskFlow { void processSameTpcFt0cLcCh(FilteredCollisionsWSelMult::iterator const& collision, HfCandidatesSelLc const& candidates, aod::FT0s const& ft0cs, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3288,20 +3792,27 @@ struct HfTaskFlow { void processSameFt0aFt0cChCh(FilteredCollisionsWSelMult::iterator const& collision, aod::FT0s const&, + FilteredTracksWDcaSel const& tracks, aod::BCsWithTimestamps const&) { if (!(isAcceptedCollision(collision, true))) { return; } - auto bc = collision.bc_as(); + auto bc = collision.template bc_as(); + loadEfficiencyCorrection(bc.timestamp()); if (collision.has_foundFT0()) { loadGain(bc); const auto& ft0 = collision.foundFT0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + multiplicity = tracks.size(); + } else { + multiplicity = getMultiplicityEstimator(collision, true); + } - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) { return; } @@ -3315,28 +3826,40 @@ struct HfTaskFlow { // MONTE-CARLO // =================================================================================================================================================================================================================================================================== - // void processSameMcGen(aod::McCollisions::iterator const& mcCollision, - // aod::McParticles const& mcParticles, - // SmallGroupMcCollisions const& collisions) - // { - // if (!(abs(mcCollision.posZ()) <= configCollision.zVertexMax)) { - // return; - // } - // if ( (mcParticles.size() < configCollision.minMultiplicity) || (mcParticles.size() > configCollision.maxMultiplicity) ) { - // return; - // } + void processSameMcGen(soa::Join::iterator const& mcCollision, + aod::McParticles const& mcParticles, + SmallGroupMcCollisions const& collisions) + { + if (!(std::abs(mcCollision.posZ()) <= configCollision.zVertexMax)) { + return; + } - // sameEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepAll); - // fillCorrelationsMonteCarlo(sameEvent, CorrelationContainer::CFStep::kCFStepAll, mcParticles, mcParticles, mcParticles.size(), mcCollision.posZ(), true); + auto multiplicity = 0; + if (configCollision.useMultiplicityFromTracks) { + for (const auto& track : mcParticles) { + if (std::abs(track.eta()) < configCentral.etaCentralTrackMax && track.pt() >= configCentral.ptCentralTrackMin && track.pt() <= configCentral.ptCentralTrackMax) { + multiplicity += 1; + } + } + } else { + multiplicity = mcCollision.multMCPVz(); + } - // if (collisions.size() == 0) { - // return; - // } + if ((multiplicity < configCollision.minMultiplicity) || (multiplicity >= configCollision.maxMultiplicity)) { + return; + } - // sameEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepTrackedOnlyPrim); - // fillCorrelationsMonteCarlo(sameEvent, CorrelationContainer::CFStep::kCFStepTrackedOnlyPrim, mcParticles, mcParticles, mcParticles.size(), mcCollision.posZ(), true); - // } - // PROCESS_SWITCH(HfTaskFlow, processSameMcGen, "MC Gen : Process same-event correlations", false); + sameEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepAll); + fillCorrelationsMonteCarlo(sameEvent, CorrelationContainer::CFStep::kCFStepAll, mcParticles, mcParticles, multiplicity, mcCollision.posZ(), true); + + if (collisions.size() == 0) { + return; + } + + sameEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepTrackedOnlyPrim); + fillCorrelationsMonteCarlo(sameEvent, CorrelationContainer::CFStep::kCFStepTrackedOnlyPrim, mcParticles, mcParticles, multiplicity, mcCollision.posZ(), true); + } + PROCESS_SWITCH(HfTaskFlow, processSameMcGen, "MC Gen : Process same-event correlations", false); // =================================================================================================================================================================================================================================================================== // =================================================================================================================================================================================================================================================================== @@ -3419,12 +3942,13 @@ struct HfTaskFlow { void processMixedTpcMftChChReassociated2d(FilteredCollisionsWSelMult const& collisions, FilteredTracksWDcaSel const& tracks, FilteredMftTracks const& /*mftTracks*/, - soa::SmallGroups const& reassociated2dMftTracks) + soa::SmallGroups const& reassociated2dMftTracks, + aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, false, bcs); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, false); + 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); @@ -3432,12 +3956,13 @@ struct HfTaskFlow { void processMixedTpcMftChChReassociated3d(FilteredCollisionsWSelMult const& collisions, FilteredTracksWDcaSel const& tracks, FilteredMftTracks const& /*mftTracks*/, - soa::SmallGroups const& reassociated3dMftTracks) + soa::SmallGroups const& reassociated3dMftTracks, + aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEvent, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEvent, false, bcs); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEventTpcMft, false); + 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); @@ -3445,12 +3970,13 @@ struct HfTaskFlow { void processMixedTpcMftChChNonAmbiguous(FilteredCollisionsWSelMult const& collisions, FilteredTracksWDcaSel const& tracks, FilteredMftTracks const& /*mftTracks*/, - soa::SmallGroups const& reassociated2dMftTracks) + soa::SmallGroups const& reassociated2dMftTracks, + aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, true); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, true, bcs); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, true); + 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); @@ -3536,12 +4062,13 @@ struct HfTaskFlow { void processMixedTpcFt0aChCh(FilteredCollisionsWSelMult const& collisions, FilteredTracksWDcaSel const& tracks, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEvent, isFT0A); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEvent, isFT0A, bcs); } else { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEventTpcFt0a, isFT0A); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEventTpcFt0a, isFT0A, bcs); } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcFt0aChCh, "DATA : Process mixed-event correlations for TPC-FT0-A h-h case", false); @@ -3552,9 +4079,10 @@ struct HfTaskFlow { void processMixedTpcFt0aD0Ch(FilteredCollisionsWSelMult const& collisions, HfCandidatesSelD0 const& candidates, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, ft0s, perColD0s, mixedEventHf, isFT0A); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, ft0s, perColD0s, mixedEventHf, isFT0A, bcs); } PROCESS_SWITCH(HfTaskFlow, processMixedTpcFt0aD0Ch, "DATA : Process mixed-event correlations for TPC-FT0-A D0-h case", false); @@ -3564,9 +4092,10 @@ struct HfTaskFlow { void processMixedTpcFt0aLcCh(FilteredCollisionsWSelMult const& collisions, HfCandidatesSelLc const& candidates, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, ft0s, perColLcs, mixedEventHf, isFT0A); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, ft0s, perColLcs, mixedEventHf, isFT0A, bcs); } PROCESS_SWITCH(HfTaskFlow, processMixedTpcFt0aLcCh, "DATA : Process mixed-event correlations for TPC-FT0-A Lc-h case", false); @@ -3576,51 +4105,58 @@ struct HfTaskFlow { void processMixedMftFt0aChCh(FilteredCollisionsWSelMult const& collisions, FilteredMftTracks const& mftTracks, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, ft0s, perColMftTracks, mixedEvent, isFT0A); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, ft0s, perColMftTracks, mixedEvent, isFT0A, bcs); } else { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, ft0s, perColMftTracks, mixedEventMftFt0a, isFT0A); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, ft0s, perColMftTracks, mixedEventMftFt0a, isFT0A, bcs); } } 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::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, false, bcs); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, false); + 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*/, + FilteredTracksWDcaSel const& tracksTpc, soa::SmallGroups const& reassociated3dMftTracks, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEvent, false); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEvent, false, bcs); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEventMftFt0a, false); + 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); void processMixedMftFt0aChChNonAmbiguous(FilteredCollisionsWSelMult const& collisions, FilteredMftTracks const& /*mftTracks*/, + FilteredTracksWDcaSel const& tracksTpc, soa::SmallGroups const& reassociated2dMftTracks, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, true); + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, true, bcs); } else { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, true); + 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); @@ -3631,9 +4167,10 @@ struct HfTaskFlow { void processMixedTpcFt0cChCh(FilteredCollisionsWSelMult const& collisions, FilteredTracksWDcaSel const& tracks, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEvent, isFT0C); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEvent, isFT0C, bcs); } PROCESS_SWITCH(HfTaskFlow, processMixedTpcFt0cChCh, "DATA : Process mixed-event correlations for TPC-FT0C h-h case", false); @@ -3643,9 +4180,10 @@ struct HfTaskFlow { void processMixedTpcFt0cD0Ch(FilteredCollisionsWSelMult const& collisions, HfCandidatesSelD0 const& candidates, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, ft0s, perColD0s, mixedEventHf, isFT0C); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, ft0s, perColD0s, mixedEventHf, isFT0C, bcs); } PROCESS_SWITCH(HfTaskFlow, processMixedTpcFt0cD0Ch, "DATA : Process mixed-event correlations for TPC-FT0C D0-h case", false); @@ -3655,9 +4193,10 @@ struct HfTaskFlow { void processMixedTpcFt0cLcCh(FilteredCollisionsWSelMult const& collisions, HfCandidatesSelLc const& candidates, - aod::FT0s const& ft0s) + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, ft0s, perColLcs, mixedEventHf, isFT0C); + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, ft0s, perColLcs, mixedEventHf, isFT0C, bcs); } PROCESS_SWITCH(HfTaskFlow, processMixedTpcFt0cLcCh, "DATA : Process mixed-event correlations for TPC-FT0C Lc-h case", false); @@ -3666,9 +4205,11 @@ struct HfTaskFlow { // ===================================== void processMixedFt0aFt0cChCh(FilteredCollisionsWSelMult const& collisions, - aod::FT0s const& ft0s) + FilteredTracksWDcaSel const& tracksTpc, + aod::FT0s const& ft0s, + aod::BCsWithTimestamps const& bcs) { - mixCollisionsFt0aFt0c(collisions, CorrelationContainer::kCFStepReconstructed, ft0s, ft0s, mixedEvent); + mixCollisionsFt0aFt0c(collisions, CorrelationContainer::kCFStepReconstructed, tracksTpc, ft0s, ft0s, mixedEvent, bcs); } PROCESS_SWITCH(HfTaskFlow, processMixedFt0aFt0cChCh, "DATA : Process mixed-event correlations for FT0A-FT0C h-h case", false); @@ -3676,46 +4217,79 @@ struct HfTaskFlow { // MONTE-CARLO // =================================================================================================================================================================================================================================================================== - // void processMixedMcGen(aod::McCollisions const& mcCollisions, - // aod::McParticles const& mcParticles, - // SmallGroupMcCollisions const& collisions) - // { - // auto getTracksSize = [&mcParticles, this](aod::McCollisions::iterator const& mcCollision) { - // auto associatedTracks = mcParticles.sliceByCached(o2::aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), this->cache); - // auto multiplicity = associatedTracks.size(); - // return multiplicity; - // }; + void processMixedMcGen(soa::Join const& mcCollisions, + aod::McParticles const& mcParticles, + SmallGroupMcCollisions const& collisions) + { + // auto getTracksSize = [&mcParticles, this](aod::McCollisions::iterator const& mcCollision) { + // auto associatedTracks = mcParticles.sliceByCached(o2::aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), this->cache); + // auto multiplicity = associatedTracks.size(); + // return multiplicity; + // }; + + auto getTracksSize = [&mcParticles, this](soa::Join::iterator const& mcCollision) { + auto associatedTracks = mcParticles.sliceByCached(o2::aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), this->cache); + 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) { + multiplicity += 1; + } + } + } else { + multiplicity = mcCollision.multMCPVz(); + } + return multiplicity; + }; - // using MixedBinning = FlexibleBinningPolicy, aod::mccollision::PosZ, decltype(getTracksSize)>; - // MixedBinning const binningOnVtxAndMult{{getTracksSize}, {configAxis.binsMixingVertex, configAxis.binsMixingMultiplicity}, true}; + using MixedBinning = FlexibleBinningPolicy, aod::mccollision::PosZ, decltype(getTracksSize)>; + MixedBinning const binningOnVtxAndMult{{getTracksSize}, {configAxis.binsMixingVertex, configAxis.binsMixingMultiplicity}, true}; - // for (auto const& [collision1, collision2] : soa::selfCombinations(binningOnVtxAndMult, configTask.nMixedEvents, -1, mcCollisions, mcCollisions)) { + for (auto const& [collision1, collision2] : soa::selfCombinations(binningOnVtxAndMult, configTask.nMixedEvents, -1, mcCollisions, mcCollisions)) { - // auto tracks1 = mcParticles.sliceBy(perMcColMcParticles, collision1.globalIndex()); - // auto tracks2 = mcParticles.sliceBy(perMcColMcParticles, collision2.globalIndex()); + auto tracks1 = mcParticles.sliceBy(perMcColMcParticles, collision1.globalIndex()); + auto tracks2 = mcParticles.sliceBy(perMcColMcParticles, collision2.globalIndex()); - // if ((tracks1.size() < configCollision.minMultiplicity || tracks1.size() >= configCollision.maxMultiplicity)) { - // continue; - // } - // if ((tracks2.size() < configCollision.minMultiplicity || tracks2.size() >= configCollision.maxMultiplicity)) { - // continue; - // } + auto multiplicityCollision1 = 0; + auto multiplicityCollision2 = 0; - // auto groupedCollisions = collisions.sliceBy(collisionPerMcCollision, collision1.globalIndex()); + 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; + } + } + } else { + multiplicityCollision1 = collision1.multMCPVz(); + multiplicityCollision2 = collision2.multMCPVz(); + } - // mixedEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepAll); - // fillCorrelationsMonteCarlo(mixedEvent, CorrelationContainer::CFStep::kCFStepAll, mcParticles, mcParticles, mcParticles.size(), collision1.posZ(), false); + if ((multiplicityCollision1 < configCollision.minMultiplicity || multiplicityCollision1 >= configCollision.maxMultiplicity)) { + continue; + } + if ((multiplicityCollision2 < configCollision.minMultiplicity || multiplicityCollision2 >= configCollision.maxMultiplicity)) { + continue; + } - // if (groupedCollisions.size() == 0) { - // return; - // } + auto groupedCollisions = collisions.sliceBy(collisionPerMcCollision, collision1.globalIndex()); - // mixedEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepTrackedOnlyPrim); - // fillCorrelationsMonteCarlo(mixedEvent, CorrelationContainer::CFStep::kCFStepTrackedOnlyPrim, mcParticles, mcParticles, mcParticles.size(), collision1.posZ(), false); - // } + mixedEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepAll); + fillCorrelationsMonteCarlo(mixedEvent, CorrelationContainer::CFStep::kCFStepAll, mcParticles, mcParticles, multiplicityCollision1, collision1.posZ(), false); - // } - // PROCESS_SWITCH(HfTaskFlow, processMixedMcGen, "MC Gen : Process mixed-event correlations", false); + if (groupedCollisions.size() == 0) { + return; + } + + mixedEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepTrackedOnlyPrim); + fillCorrelationsMonteCarlo(mixedEvent, CorrelationContainer::CFStep::kCFStepTrackedOnlyPrim, mcParticles, mcParticles, multiplicityCollision1, collision1.posZ(), false); + } + } + PROCESS_SWITCH(HfTaskFlow, processMixedMcGen, "MC Gen : Process mixed-event correlations", false); }; // End of struct