diff --git a/PWGHF/HFC/Tasks/taskFlow.cxx b/PWGHF/HFC/Tasks/taskFlow.cxx index f41fd055852..979c580aa3a 100644 --- a/PWGHF/HFC/Tasks/taskFlow.cxx +++ b/PWGHF/HFC/Tasks/taskFlow.cxx @@ -204,10 +204,21 @@ struct HfTaskFlow { Configurable centralityBinsForMc{"centralityBinsForMc", false, "falsce = OFF, true = ON for data like multiplicity/centrality bins for MC steps"}; 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"}; Configurable doReferenceFlow{"doReferenceFlow", false, "Flag to know if reference flow should be done"}; + Configurable doVariationContainers{"doVariationContainers", false, "Flag to know if variation containers should be filled"}; + Configurable etaMcParticlesTriggerMax{"etaMcParticlesTriggerMax", 0.8f, "Maximum value for the eta of MC particles when used in cut function"}; + 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 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"}; + Configurable ptMcParticlesAssocMin{"ptMcParticlesAssocMin", 0.f, "Minimum value for the pT of MC particles when used in cut function"}; Configurable isReadoutCenter{"isReadoutCenter", false, "Enable Readout Center"}; 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"}; } configTask; // configurables for collisions @@ -295,8 +306,6 @@ struct HfTaskFlow { Configurable cfgCorrLevel{"cfgCorrLevel", 1, "calibration step: 0 = no corr, 1 = gain corr"}; } configFit; - TF1* fPtDepDCAxy = nullptr; - SliceCache cache; Service pdg{}; Service ccdb{}; @@ -320,6 +329,12 @@ struct HfTaskFlow { using FilteredMftTracks = soa::Filtered; + // ========================= + // using declarations : MC + // ========================= + + using SmallGroupMcCollisions = soa::SmallGroups>; + // ========================= // Filters & partitions : DATA // ========================= @@ -366,10 +381,17 @@ struct HfTaskFlow { Preslice perColLcs = aod::track::collisionId; Preslice perColMftTracks = o2::aod::fwdtrack::collisionId; Preslice perColTracks = aod::track::collisionId; + Preslice perMcColMcParticles = aod::mcparticle::mcCollisionId; PresliceUnsorted> perColReassociated2dTracks = o2::aod::fwdtrack::collisionId; PresliceUnsorted> perColReassociated3dTracks = o2::aod::fwdtrack::collisionId; + // ========================= + // Preslice : MC + // ========================= + + PresliceUnsorted collisionPerMcCollision = aod::mccollisionlabel::mcCollisionId; + // configurables for containers // TODO: flow of HF will need to be done vs. invariant mass, in the signal and side-band regions // either 1) add invariant mass axis or 2) define several containers for different inv. mass regions @@ -406,13 +428,15 @@ struct HfTaskFlow { // Correlation containers used for data OutputObj sameEvent{"sameEvent"}; OutputObj mixedEvent{"mixedEvent"}; + OutputObj sameEventTpcMft{"sameEvent_TPC_MFT"}; + OutputObj mixedEventTpcMft{"mixedEvent_TPC_MFT"}; + OutputObj sameEventTpcFt0a{"sameEvent_TPC_FT0A"}; + OutputObj mixedEventTpcFt0a{"mixedEvent_TPC_FT0A"}; + OutputObj sameEventMftFt0a{"sameEvent_MFT_FT0A"}; + OutputObj mixedEventMftFt0a{"mixedEvent_MFT_FT0A"}; OutputObj sameEventHf{"sameEventHf"}; OutputObj mixedEventHf{"mixedEventHf"}; - // Correlation containers used for Monte-Carlo - OutputObj sameEventHfMc{"sameEventHfMc"}; - OutputObj mixedEventHfMc{"mixedEventHfMc"}; - template void addHistograms() { @@ -551,12 +575,18 @@ struct HfTaskFlow { {configAxis.axisMultiplicity, "multiplicity"}, {configAxis.axisDeltaPhi, "#Delta#varphi (rad)"}, {configAxis.axisVertex, "z-vtx (cm)"}}; - std::vector const corrAxisEta = {{configAxis.axisDeltaEta, "#Delta#eta"}, - {configAxis.axisEtaAssociated, "#eta_{associated}"}, + std::vector const corrAxisEta = {{configAxis.axisSamples, "sampling"}, + {configAxis.axisVertex, "z-vtx (cm)"}, {configAxis.axisEtaTrigger, "#eta_{trigger}"}, - {configAxis.axisMultiplicity, "multiplicity"}, + {configAxis.axisEtaAssociated, "#eta_{associated}"}, {configAxis.axisDeltaPhi, "#Delta#varphi (rad)"}, - {configAxis.axisVertex, "z-vtx (cm)"}}; + {configAxis.axisDeltaEta, "#Delta#eta"}}; + std::vector const corrAxisVariations = {{configAxis.axisSamples, "sampling"}, + {configAxis.axisVertex, "z-vtx (cm)"}, + {configAxis.axisPtTrigger, "p_{T} (GeV/c)"}, + {configAxis.axisMultiplicity, "multiplicity"}, + {configAxis.axisDeltaPhi, "#Delta#varphi (rad)"}, + {configAxis.axisDeltaEta, "#Delta#eta"}}; std::vector const effAxis = {{configAxis.axisEtaEfficiency, "#eta"}, {configAxis.axisPtEfficiency, "p_{T} (GeV/c)"}, {configAxis.axisVertexEfficiency, "z-vtx (cm)"}}; @@ -603,12 +633,18 @@ struct HfTaskFlow { addHistograms(); addMftHistograms(); - if (!configTask.doEtaDependentFlow) { + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + registry.add("Trig_hist_TPC_MFT", "", {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_TPC_MFT", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisEtaTrigger}}}); + sameEventTpcMft.setObject(new CorrelationContainer("sameEvent_TPC_MFT", "sameEvent_TPC_MFT", corrAxisEta, effAxis, {})); + mixedEventTpcMft.setObject(new CorrelationContainer("mixedEvent_TPC_MFT", "mixedEvent_TPC_MFT", corrAxisEta, effAxis, {})); } else { - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + registry.add("Trig_hist_TPC_MFT", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); + sameEventTpcMft.setObject(new CorrelationContainer("sameEvent_TPC_MFT", "sameEvent_TPC_MFT", corrAxisVariations, effAxis, {})); + mixedEventTpcMft.setObject(new CorrelationContainer("mixedEvent_TPC_MFT", "mixedEvent_TPC_MFT", corrAxisVariations, effAxis, {})); } } @@ -632,49 +668,49 @@ struct HfTaskFlow { // Initialization of histograms and CorrelationContainers for TpcFv0a cases // ========================= - if (doprocessSameTpcFv0aChCh) { - addHistograms(); + // if (doprocessSameTpcFv0aChCh) { + // addHistograms(); - if (!configTask.doEtaDependentFlow) { - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); - } else { - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); - } - } + // if (!configTask.doEtaDependentFlow) { + // sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); + // mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + // } else { + // sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); + // mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + // } + // } - if (doprocessSameTpcFv0aD0Ch) { - addHistograms(); + // if (doprocessSameTpcFv0aD0Ch) { + // addHistograms(); - sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); - mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); - } + // sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); + // mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); + // } - if (doprocessSameTpcFv0aLcCh) { - addHistograms(); + // if (doprocessSameTpcFv0aLcCh) { + // addHistograms(); - sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); - mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); - } + // sameEventHf.setObject(new CorrelationContainer("sameEventHf", "sameEventHf", corrAxis, effAxis, hfUserAxis)); + // mixedEventHf.setObject(new CorrelationContainer("mixedEventHf", "mixedEventHf", corrAxis, effAxis, hfUserAxis)); + // } // ========================= // Initialization of histograms and CorrelationContainers for MftFv0a cases // ========================= - // if (doprocessSameMftFv0aChCh || doprocessSameMftFv0aChChReassociated || doprocessSameMftFv0aReassociated3d || doprocessSameMftFv0aChChNonAmbiguous) { - if (doprocessSameMftFv0aChCh || doprocessSameMftFv0aChChReassociated || doprocessSameMftFv0aChChNonAmbiguous) { - addHistograms(); - addMftHistograms(); + // // if (doprocessSameMftFv0aChCh || doprocessSameMftFv0aChChReassociated || doprocessSameMftFv0aReassociated3d || doprocessSameMftFv0aChChNonAmbiguous) { + // if (doprocessSameMftFv0aChCh || doprocessSameMftFv0aChChReassociated || doprocessSameMftFv0aChChNonAmbiguous) { + // addHistograms(); + // addMftHistograms(); - if (!configTask.doEtaDependentFlow) { - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); - } else { - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); - } - } + // if (!configTask.doEtaDependentFlow) { + // sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {})); + // mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {})); + // } else { + // sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); + // mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + // } + // } // ========================= // Initialization of histograms and CorrelationContainers for TpcFt0a cases @@ -685,12 +721,18 @@ struct HfTaskFlow { registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - if (!configTask.doEtaDependentFlow) { + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + registry.add("Trig_hist_TPC_FT0A", "", {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_TPC_FT0A", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisEtaTrigger}}}); + sameEventTpcFt0a.setObject(new CorrelationContainer("sameEvent_TPC_FT0A", "sameEvent_TPC_FT0A", corrAxisEta, effAxis, {})); + mixedEventTpcFt0a.setObject(new CorrelationContainer("mixedEvent_TPC_FT0A", "mixedEvent_TPC_FT0A", corrAxisEta, effAxis, {})); } else { - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + registry.add("Trig_hist_TPC_FT0A", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); + sameEventTpcFt0a.setObject(new CorrelationContainer("sameEvent_TPC_FT0A", "sameEvent_TPC_FT0A", corrAxisVariations, effAxis, {})); + mixedEventTpcFt0a.setObject(new CorrelationContainer("mixedEvent_TPC_FT0A", "mixedEvent_TPC_FT0A", corrAxisVariations, effAxis, {})); } } @@ -722,12 +764,18 @@ struct HfTaskFlow { registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - if (!configTask.doEtaDependentFlow) { + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + registry.add("Trig_hist_MFT_FT0A", "", {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_MFT_FT0A", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisEtaTrigger}}}); + sameEventMftFt0a.setObject(new CorrelationContainer("sameEvent_MFT_FT0A", "sameEvent_MFT_FT0A", corrAxisEta, effAxis, {})); + mixedEventMftFt0a.setObject(new CorrelationContainer("mixedEvent_MFT_FT0A", "mixedEvent_MFT_FT0A", corrAxisEta, effAxis, {})); } else { - sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {})); - mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {})); + registry.add("Trig_hist_MFT_FT0A", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); + sameEventMftFt0a.setObject(new CorrelationContainer("sameEvent_MFT_FT0A", "sameEvent_MFT_FT0A", corrAxisVariations, effAxis, {})); + mixedEventMftFt0a.setObject(new CorrelationContainer("mixedEvent_MFT_FT0A", "mixedEvent_MFT_FT0A", corrAxisVariations, effAxis, {})); } } @@ -740,12 +788,18 @@ struct HfTaskFlow { registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - if (!configTask.doEtaDependentFlow) { + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + registry.add("Trig_hist_TPC_FT0C", "", {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 { + } else if (configTask.doEtaDependentFlow) { + registry.add("Trig_hist_TPC_FT0C", "", {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_TPC_FT0C", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}}); + sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisVariations, effAxis, {})); + mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisVariations, effAxis, {})); } } @@ -776,15 +830,42 @@ struct HfTaskFlow { registry.add("Data/FT0Amp", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); registry.add("Data/FT0AmpCorr", "", {HistType::kTH2F, {configAxis.axisChID, configAxis.axisAmplitudeFit}}); - if (!configTask.doEtaDependentFlow) { + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + registry.add("Trig_hist_FT0A_FT0C", "", {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 { + } else if (configTask.doEtaDependentFlow) { + registry.add("Trig_hist_FT0A_FT0C ", "", {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_FT0A_FT0C", "", {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) { + // 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, {})); + // } + // } + } // End of init() function // ========================= @@ -904,29 +985,29 @@ struct HfTaskFlow { return RecoDecay::phi(chPos.X() + (*offsetFT0)[i].getX(), chPos.Y() + (*offsetFT0)[i].getY()); } - double getPhiFV0(unsigned int chno) const - { - int const cellsInLeft[] = {0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 40, 33, 41, 34, 42, 35, 43}; - bool const isChnoInLeft = std::find(std::begin(cellsInLeft), std::end(cellsInLeft), chno) != std::end(cellsInLeft); - float offsetX{}, offsetY{}; - if (isChnoInLeft) { - offsetX = (*offsetFV0)[0].getX(); - offsetY = (*offsetFV0)[0].getY(); - } else { - offsetX = (*offsetFV0)[1].getX(); - offsetY = (*offsetFV0)[1].getY(); - } + // double getPhiFV0(unsigned int chno) const + // { + // int const cellsInLeft[] = {0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 40, 33, 41, 34, 42, 35, 43}; + // bool const isChnoInLeft = std::find(std::begin(cellsInLeft), std::end(cellsInLeft), chno) != std::end(cellsInLeft); + // float offsetX{}, offsetY{}; + // if (isChnoInLeft) { + // offsetX = (*offsetFV0)[0].getX(); + // offsetY = (*offsetFV0)[0].getY(); + // } else { + // offsetX = (*offsetFV0)[1].getX(); + // offsetY = (*offsetFV0)[1].getY(); + // } - o2::fv0::Point3Dsimple chPos{}; - chPos = fv0Det->getReadoutCenter(chno); + // o2::fv0::Point3Dsimple chPos{}; + // chPos = fv0Det->getReadoutCenter(chno); - // if (configTask.isReadoutCenter) - // chPos = fv0Det->getReadoutCenter(chno); - // else - // chPos = fv0Det->getCellCenter(chno); + // // if (configTask.isReadoutCenter) + // // chPos = fv0Det->getReadoutCenter(chno); + // // else + // // chPos = fv0Det->getCellCenter(chno); - return RecoDecay::phi(chPos.x + offsetX, chPos.y + offsetY); - } + // return RecoDecay::phi(chPos.x + offsetX, chPos.y + offsetY); + // } double getEtaFT0(uint chno, int i) { @@ -943,35 +1024,35 @@ struct HfTaskFlow { return -std::log(std::tan(0.5 * theta)); } - double getEtaFV0(unsigned int chno) const - { - int const cellsInLeft[] = {0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 40, 33, 41, 34, 42, 35, 43}; - bool const isChnoInLeft = std::find(std::begin(cellsInLeft), std::end(cellsInLeft), chno) != std::end(cellsInLeft); - float offsetX{}, offsetY{}, offsetZ{}; - if (isChnoInLeft) { - offsetX = (*offsetFV0)[0].getX(); - offsetY = (*offsetFV0)[0].getY(); - offsetZ = (*offsetFV0)[0].getZ(); - } else { - offsetX = (*offsetFV0)[1].getX(); - offsetY = (*offsetFV0)[1].getY(); - offsetZ = (*offsetFV0)[1].getZ(); - } - - o2::fv0::Point3Dsimple chPos{}; - chPos = fv0Det->getReadoutCenter(chno); - // if (configTask.isReadoutCenter) - // chPos = fv0Det->getReadoutCenter(chno); - // else - // chPos = fv0Det->getCellCenter(chno); - - auto x = chPos.x + offsetX; - auto y = chPos.y + offsetY; - auto z = chPos.z + offsetZ; - auto r = std::sqrt(x * x + y * y); - auto theta = std::atan2(r, z); - return -std::log(std::tan(0.5 * theta)); - } + // double getEtaFV0(unsigned int chno) const + // { + // int const cellsInLeft[] = {0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 40, 33, 41, 34, 42, 35, 43}; + // bool const isChnoInLeft = std::find(std::begin(cellsInLeft), std::end(cellsInLeft), chno) != std::end(cellsInLeft); + // float offsetX{}, offsetY{}, offsetZ{}; + // if (isChnoInLeft) { + // offsetX = (*offsetFV0)[0].getX(); + // offsetY = (*offsetFV0)[0].getY(); + // offsetZ = (*offsetFV0)[0].getZ(); + // } else { + // offsetX = (*offsetFV0)[1].getX(); + // offsetY = (*offsetFV0)[1].getY(); + // offsetZ = (*offsetFV0)[1].getZ(); + // } + + // o2::fv0::Point3Dsimple chPos{}; + // chPos = fv0Det->getReadoutCenter(chno); + // // if (configTask.isReadoutCenter) + // // chPos = fv0Det->getReadoutCenter(chno); + // // else + // // chPos = fv0Det->getCellCenter(chno); + + // auto x = chPos.x + offsetX; + // auto y = chPos.y + offsetY; + // auto z = chPos.z + offsetZ; + // auto r = std::sqrt(x * x + y * y); + // auto theta = std::atan2(r, z); + // return -std::log(std::tan(0.5 * theta)); + // } template void getChannel(TFT0s const& ft0, std::size_t const& iCh, int& id, int fitType, float& amplitude) @@ -1259,7 +1340,7 @@ struct HfTaskFlow { 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); + int sampleIndex = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE for (const auto& track1 : tracks1) { @@ -1294,12 +1375,16 @@ struct HfTaskFlow { } // fill single-track distributions - if (!fillingHFcontainer) { // if not HF-h case - if (!configTask.doEtaDependentFlow) { // if not eta-differential flow, fill vs pt, otherwise fill vs eta - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); - } else { - target->getTriggerHist()->Fill(step, eta1, multiplicity, posZ, triggerWeight); + if (!fillingHFcontainer) { // if not HF-h case + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + + if (configTask.doEtaDependentFlow) { + registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future } + if (configTask.doVariationContainers) { + registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.pt(), triggerWeight); + } + } else { target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, triggerWeight); } @@ -1426,11 +1511,14 @@ struct HfTaskFlow { if (!fillingHFcontainer) { // fill pair correlations - if (!configTask.doEtaDependentFlow) { + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, triggerWeight * associatedWeight); + } else if (configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, + triggerWeight * associatedWeight); } else { - target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, triggerWeight * associatedWeight); } } else { @@ -1474,7 +1562,7 @@ struct HfTaskFlow { 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); + int sampleIndex = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE for (const auto& track1 : tracks1) { @@ -1506,11 +1594,15 @@ struct HfTaskFlow { // fill single-track distributions if (!fillingHFcontainer) { // if not HF-h case - if (!configTask.doEtaDependentFlow) { - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); - } else { - target->getTriggerHist()->Fill(step, eta1, multiplicity, posZ, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + + if (configTask.doEtaDependentFlow) { + registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + } + if (configTask.doVariationContainers) { + registry.fill(HIST("Trig_hist_TPC_MFT"), sampleIndex, posZ, track1.pt(), triggerWeight); } + } else { target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, triggerWeight); } @@ -1621,11 +1713,14 @@ struct HfTaskFlow { deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); if (!fillingHFcontainer) { - if (!configTask.doEtaDependentFlow) { + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { target->getPairHist()->Fill(step, eta1 - eta2, pt2, pt1, multiplicity, deltaPhi, posZ, triggerWeight * associatedWeight); + } else if (configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, + triggerWeight * associatedWeight); } else { - target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, triggerWeight * associatedWeight); } } else { @@ -1658,7 +1753,7 @@ struct HfTaskFlow { 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); + int sampleIndex = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE for (auto const& track1 : tracks1) { @@ -1705,11 +1800,23 @@ struct HfTaskFlow { // fill single-track distributions if (!fillingHFcontainer) { // if not HF-h case - if (!configTask.doEtaDependentFlow) { - target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); - } else { - target->getTriggerHist()->Fill(step, eta1, multiplicity, posZ, triggerWeight); + target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, triggerWeight); + + if (configTask.doEtaDependentFlow) { + if (fitType == isFT0A) { + registry.fill(HIST("Trig_hist_TPC_FT0A"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + } else { + registry.fill(HIST("Trig_hist_TPC_FT0C"), sampleIndex, posZ, track1.eta(), triggerWeight); // think about event weight in near future + } } + if (configTask.doVariationContainers) { + if (fitType == isFT0A) { + registry.fill(HIST("Trig_hist_TPC_FT0A"), sampleIndex, posZ, track1.pt(), triggerWeight); // think about event weight in near future + } else { + registry.fill(HIST("Trig_hist_TPC_FT0C"), sampleIndex, posZ, track1.pt(), triggerWeight); // think about event weight in near future + } + } + } else { target->getTriggerHist()->Fill(step, pt1, multiplicity, posZ, invmass, triggerWeight); } @@ -1760,45 +1867,45 @@ struct HfTaskFlow { } } // end of if condition to fill QA plots for trigger particle - // ASSOCIATED PARTICLE IF USING FV0 - if constexpr (std::is_same_v) { - for (std::size_t indexChannel = 0; indexChannel < tracks2.channel().size(); indexChannel++) { - - auto channelId = tracks2.channel()[indexChannel]; - auto phi2 = getPhiFV0(channelId); - auto eta2 = getEtaFV0(channelId); - float deltaPhi = phi1 - phi2; - deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); // set range of delta phi in (-pi/2 , 3/2*pi) - - if (!fillingHFcontainer) { - if (!configTask.doEtaDependentFlow) { - target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, - triggerWeight * associatedWeight); - } else { - target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, - triggerWeight * associatedWeight); - } - } else { - target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, invmass, - triggerWeight * associatedWeight); - } - - // FILL QA PLOTS for associated particle - if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { - if constexpr (!std::is_same_v) { // If not FilteredMftTracks as trigger -> TPC-FV0a correlations - if constexpr (std::is_same_v) { // IF D0 CASE -> TPC-FV0a D0-h - fillAssociatedQa(multiplicity, eta2, phi2); - } else if constexpr (std::is_same_v) { // IF LC CASE -> TPC-FV0a Lc-h - fillAssociatedQa(multiplicity, eta2, phi2); - } else if constexpr (std::is_same_v) { // IF NEITHER D0 NOR LC -> ch. part. - ch. part - fillAssociatedQa(multiplicity, eta2, phi2); - } - } else { // If FilteredMftTracks as trigger -> MFT-FV0a (non reassoc/ambiguous) correlations - fillAssociatedQa(multiplicity, eta2, phi2); - } - } // end of if condition to fill QA plots for associated particle - } // end of loop over FV0 channel indices - } // end of if condition for FV0s + // // ASSOCIATED PARTICLE IF USING FV0 + // if constexpr (std::is_same_v) { + // for (std::size_t indexChannel = 0; indexChannel < tracks2.channel().size(); indexChannel++) { + + // auto channelId = tracks2.channel()[indexChannel]; + // auto phi2 = getPhiFV0(channelId); + // auto eta2 = getEtaFV0(channelId); + // float deltaPhi = phi1 - phi2; + // deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); // set range of delta phi in (-pi/2 , 3/2*pi) + + // if (!fillingHFcontainer) { + // if (!configTask.doEtaDependentFlow) { + // target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, + // triggerWeight * associatedWeight); + // } else { + // target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + // triggerWeight * associatedWeight); + // } + // } else { + // target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, invmass, + // triggerWeight * associatedWeight); + // } + + // // FILL QA PLOTS for associated particle + // if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + // if constexpr (!std::is_same_v) { // If not FilteredMftTracks as trigger -> TPC-FV0a correlations + // if constexpr (std::is_same_v) { // IF D0 CASE -> TPC-FV0a D0-h + // fillAssociatedQa(multiplicity, eta2, phi2); + // } else if constexpr (std::is_same_v) { // IF LC CASE -> TPC-FV0a Lc-h + // fillAssociatedQa(multiplicity, eta2, phi2); + // } else if constexpr (std::is_same_v) { // IF NEITHER D0 NOR LC -> ch. part. - ch. part + // fillAssociatedQa(multiplicity, eta2, phi2); + // } + // } else { // If FilteredMftTracks as trigger -> MFT-FV0a (non reassoc/ambiguous) correlations + // fillAssociatedQa(multiplicity, eta2, phi2); + // } + // } // end of if condition to fill QA plots for associated particle + // } // end of loop over FV0 channel indices + // } // end of if condition for FV0s // ASSOCIATED PARTICLE IF USING FT0 if constexpr (std::is_same_v) { @@ -1824,11 +1931,14 @@ struct HfTaskFlow { deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); // set range of delta phi in (-pi/2 , 3/2*pi) if (!fillingHFcontainer) { - if (!configTask.doEtaDependentFlow) { - target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + target->getPairHist()->Fill(step, eta1 - eta2, 0.5, pt1, multiplicity, deltaPhi, posZ, + amplitude * triggerWeight * associatedWeight); + } else if (configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, amplitude * triggerWeight * associatedWeight); } else { - target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, amplitude * triggerWeight * associatedWeight); } } else { @@ -1880,7 +1990,7 @@ struct HfTaskFlow { 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); + int sampleIndex = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE for (auto const& track1 : tracks1) { @@ -1927,6 +2037,13 @@ struct HfTaskFlow { target->getTriggerHist()->Fill(step, eta1, multiplicity, posZ, triggerWeight); } + if (configTask.doEtaDependentFlow) { + registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, eta1, triggerWeight); // think about event weight in near future + } + if (configTask.doVariationContainers) { + registry.fill(HIST("Trig_hist_MFT_FT0A"), sampleIndex, posZ, pt1, triggerWeight); + } + // FILL QA PLOTS for trigger particle if (sameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { if constexpr (std::is_same_v) { @@ -1938,31 +2055,31 @@ struct HfTaskFlow { } } // end of if condition to fill QA plots for trigger particle - // ASSOCIATED PARTICLE FOR FV0s - if constexpr (std::is_same_v) { - for (std::size_t indexChannel = 0; indexChannel < tracks2.channel().size(); indexChannel++) { + // // ASSOCIATED PARTICLE FOR FV0s + // if constexpr (std::is_same_v) { + // for (std::size_t indexChannel = 0; indexChannel < tracks2.channel().size(); indexChannel++) { - auto channelId = tracks2.channel()[indexChannel]; - auto phi2 = getPhiFV0(channelId); - auto eta2 = getEtaFV0(channelId); + // auto channelId = tracks2.channel()[indexChannel]; + // auto phi2 = getPhiFV0(channelId); + // auto eta2 = getEtaFV0(channelId); - float deltaPhi = phi1 - phi2; - deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); // set range of delta phi in (-pi/2 , 3/2*pi) + // float deltaPhi = phi1 - phi2; + // deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); // set range of delta phi in (-pi/2 , 3/2*pi) - if (!configTask.doEtaDependentFlow) { - target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, - triggerWeight * associatedWeight); - } else { - target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, - triggerWeight * associatedWeight); - } + // if (!configTask.doEtaDependentFlow) { + // target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, + // triggerWeight * associatedWeight); + // } else { + // target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + // triggerWeight * associatedWeight); + // } - // FILL QA PLOTS for associated particle - if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { - fillAssociatedQa(multiplicity, eta2, phi2); - } // end of if condition to fill QA plots for associated particle - } // end of loop over FV0 channel indices - } // end of if condition for FV0s + // // FILL QA PLOTS for associated particle + // if (sameEvent && (loopCounter == 1) && (step == CorrelationContainer::kCFStepReconstructed)) { + // fillAssociatedQa(multiplicity, eta2, phi2); + // } // end of if condition to fill QA plots for associated particle + // } // end of loop over FV0 channel indices + // } // end of if condition for FV0s // ASSOCIATED PARTICLE FOR FT0s if constexpr (std::is_same_v) { @@ -1987,11 +2104,14 @@ struct HfTaskFlow { float deltaPhi = phi1 - phi2; deltaPhi = RecoDecay::constrainAngle(deltaPhi, -PIHalf); // set range of delta phi in (-pi/2 , 3/2*pi) - if (!configTask.doEtaDependentFlow) { - target->getPairHist()->Fill(step, eta1 - eta2, pt1, pt1, multiplicity, deltaPhi, posZ, + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + target->getPairHist()->Fill(step, eta1 - eta2, 0.5, pt1, multiplicity, deltaPhi, posZ, + amplitude * triggerWeight * associatedWeight); + } else if (configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, sampleIndex, posZ, eta2, eta1, deltaPhi, eta1 - eta2, amplitude * triggerWeight * associatedWeight); } else { - target->getPairHist()->Fill(step, eta1 - eta2, eta2, eta1, multiplicity, deltaPhi, posZ, + target->getPairHist()->Fill(step, sampleIndex, posZ, pt1, multiplicity, deltaPhi, eta1 - eta2, amplitude * triggerWeight * associatedWeight); } @@ -2014,7 +2134,7 @@ struct HfTaskFlow { 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); + int sampleIndex = gRandom->Uniform(0, configTask.nSamples); // TRIGGER PARTICLE FROM FT0A for (std::size_t indexChannelA = 0; indexChannelA < ft0as.channelA().size(); indexChannelA++) { @@ -2025,14 +2145,17 @@ struct HfTaskFlow { auto phiA = getPhiFT0(channelIdA, isFT0A); auto etaA = getEtaFT0(channelIdA, isFT0A); - if (!configTask.doEtaDependentFlow) { - target->getTriggerHist()->Fill(step, 0.f, multiplicity, posZ, amplitude * triggerWeight); - } else { - target->getTriggerHist()->Fill(step, etaA, multiplicity, posZ, amplitude * triggerWeight); + target->getTriggerHist()->Fill(step, 0.5, multiplicity, posZ, amplitude * triggerWeight); + + if (configTask.doEtaDependentFlow) { + registry.fill(HIST("Trig_hist_FT0A_FT0C"), sampleIndex, posZ, etaA, triggerWeight); // think about event weight in near future + } + if (configTask.doVariationContainers) { + registry.fill(HIST("Trig_hist_FT0A_FT0C"), sampleIndex, posZ, 0.5, triggerWeight); } if (sameEvent && (step == CorrelationContainer::kCFStepReconstructed)) { - fillTriggerQa(multiplicity, etaA, phiA, 0.f); + fillTriggerQa(multiplicity, etaA, phiA, 0.5); } // end of fill trigger QA // ASSOCIATED PARTICLE FROM FT0C @@ -2045,11 +2168,14 @@ struct HfTaskFlow { auto etaC = getEtaFT0(channelIdC, isFT0C); float deltaPhi = RecoDecay::constrainAngle(phiA - phiC, -PIHalf); - if (!configTask.doEtaDependentFlow) { - target->getPairHist()->Fill(step, etaA - etaC, 0.f, 0.f, multiplicity, deltaPhi, posZ, + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + target->getPairHist()->Fill(step, etaA - etaC, 0.5, 0.5, multiplicity, deltaPhi, posZ, + amplitude * triggerWeight * associatedWeight); + } else if (configTask.doEtaDependentFlow) { + target->getPairHist()->Fill(step, sampleIndex, posZ, etaC, etaA, deltaPhi, etaA - etaC, amplitude * triggerWeight * associatedWeight); } else { - target->getPairHist()->Fill(step, etaA - etaC, etaC, etaA, multiplicity, deltaPhi, posZ, + target->getPairHist()->Fill(step, sampleIndex, posZ, 0.5, multiplicity, deltaPhi, etaA - etaC, amplitude * triggerWeight * associatedWeight); } @@ -2060,6 +2186,68 @@ 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); + + // for (auto const& track1 : tracks1) { + + // 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; + // } + + // 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); + // } + + // 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 + // } + // =============================================================================================================================================================================== // mixCollisions for RECONSTRUCTED events // =============================================================================================================================================================================== @@ -2397,8 +2585,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelations(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelations(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + } else { + sameEventTpcMft->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelations(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, mftTracks, multiplicity, collision.posZ(), true, getMagneticField(bc.timestamp())); + } } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChCh, "DATA : Process same-event correlations for TPC-MFT h-h case", false); @@ -2420,8 +2613,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + } else { + sameEventTpcMft->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + } } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChChReassociated, "DATA : Process same-event correlations for TPC-MFT h-h case reassociated", false); @@ -2445,8 +2643,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + } else { + sameEventTpcMft->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, false); + } } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChChReassociated3d, "DATA : Process same-event correlations for TPC-MFT h-h case 3d reassociated", false); @@ -2468,8 +2671,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, true); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, true); + } else { + sameEventTpcMft->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsReassociatedMftTracks(sameEventTpcMft, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, reassociatedMftTracks, multiplicity, collision.posZ(), true, true); + } } PROCESS_SWITCH(HfTaskFlow, processSameTpcMftChChNonAmbiguous, "DATA : Process same-event correlations for TPC-MFT h-h case with non-ambiguous tracks", false); @@ -2583,130 +2791,130 @@ struct HfTaskFlow { // DATA : process same event correlations: TPC-FV0A Ch. Part. - Ch. Part // ===================================== - void processSameTpcFv0aChCh(FilteredCollisionsWSelMult::iterator const& collision, - FilteredTracksWDcaSel const& tracks, - aod::FV0As const& fv0as) - { - if (!(isAcceptedCollision(collision, true))) { - return; - } - - if (collision.has_foundFV0()) { - const auto& fv0 = collision.foundFV0(); - - registry.fill(HIST("Data/hNTracks"), tracks.size()); - const auto multiplicity = getMultiplicityEstimator(collision, true); - - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { - return; - } - - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, fv0, fv0as, multiplicity, collision.posZ(), true, isFV0A); - } - } - PROCESS_SWITCH(HfTaskFlow, processSameTpcFv0aChCh, "DATA : Process same-event correlations for TPC-FV0-A h-h case", false); - - // ===================================== - // DATA : process same event correlations: TPC-FV0A D0 - Ch. Part - // ===================================== - - void processSameTpcFv0aD0Ch(FilteredCollisionsWSelMult::iterator const& collision, - HfCandidatesSelD0 const& candidates, - aod::FV0As const& fv0as) - { - if (!(isAcceptedCollision(collision, true))) { - return; - } - - if (collision.has_foundFV0()) { - const auto& fv0 = collision.foundFV0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); - - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { - return; - } - - sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, fv0, fv0as, multiplicity, collision.posZ(), true, isFV0A); - } - } - PROCESS_SWITCH(HfTaskFlow, processSameTpcFv0aD0Ch, "DATA : Process same-event correlations for TPC-FV0-A D0-h case", false); - - // ===================================== - // DATA : process same event correlations: TPC-FV0A Lc - Ch. Part - // ===================================== - - void processSameTpcFv0aLcCh(FilteredCollisionsWSelMult::iterator const& collision, - HfCandidatesSelLc const& candidates, - aod::FV0As const& fv0as) - { - if (!(isAcceptedCollision(collision, true))) { - return; - } - - if (collision.has_foundFV0()) { - const auto& fv0 = collision.foundFV0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); - - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { - return; - } - - sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, fv0, fv0as, multiplicity, collision.posZ(), true, isFV0A); - } - } - PROCESS_SWITCH(HfTaskFlow, processSameTpcFv0aLcCh, "DATA : Process same-event correlations for TPC-FV0-A Lc-h case", false); - - // ===================================== - // DATA : process same event correlations: MFT-FV0A Ch. Part. - Ch. Part - // ===================================== - - void processSameMftFv0aChCh(FilteredCollisionsWSelMult::iterator const& collision, - FilteredMftTracks const& mftTracks, - aod::FV0As const& fv0as) - { - if (!(isAcceptedCollision(collision, true))) { - return; - } - - if (collision.has_foundFV0()) { - const auto& fv0 = collision.foundFV0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); - - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { - return; - } - - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, fv0, fv0as, multiplicity, collision.posZ(), true, isFV0A); - } - } - PROCESS_SWITCH(HfTaskFlow, processSameMftFv0aChCh, "DATA : Process same-event correlations for MFT-FV0-A h-h case", false); - - void processSameMftFv0aChChReassociated(FilteredCollisionsWSelMult::iterator const& collision, - soa::SmallGroups const& reassociatedMftTracks, - FilteredMftTracks const&, - aod::FV0As const& fv0as) - { - if (!(isAcceptedCollision(collision, true))) { - return; - } - - if (collision.has_foundFV0()) { - const auto& fv0 = collision.foundFV0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); - - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { - return; - } - - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - 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); + // void processSameTpcFv0aChCh(FilteredCollisionsWSelMult::iterator const& collision, + // FilteredTracksWDcaSel const& tracks, + // aod::FV0As const& fv0as) + // { + // if (!(isAcceptedCollision(collision, true))) { + // return; + // } + + // if (collision.has_foundFV0()) { + // const auto& fv0 = collision.foundFV0(); + + // registry.fill(HIST("Data/hNTracks"), tracks.size()); + // const auto multiplicity = getMultiplicityEstimator(collision, true); + + // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // return; + // } + + // sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + // fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, fv0, fv0as, multiplicity, collision.posZ(), true, isFV0A); + // } + // } + // PROCESS_SWITCH(HfTaskFlow, processSameTpcFv0aChCh, "DATA : Process same-event correlations for TPC-FV0-A h-h case", false); + + // // ===================================== + // // DATA : process same event correlations: TPC-FV0A D0 - Ch. Part + // // ===================================== + + // void processSameTpcFv0aD0Ch(FilteredCollisionsWSelMult::iterator const& collision, + // HfCandidatesSelD0 const& candidates, + // aod::FV0As const& fv0as) + // { + // if (!(isAcceptedCollision(collision, true))) { + // return; + // } + + // if (collision.has_foundFV0()) { + // const auto& fv0 = collision.foundFV0(); + // const auto multiplicity = getMultiplicityEstimator(collision, true); + + // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // return; + // } + + // sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + // fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, fv0, fv0as, multiplicity, collision.posZ(), true, isFV0A); + // } + // } + // PROCESS_SWITCH(HfTaskFlow, processSameTpcFv0aD0Ch, "DATA : Process same-event correlations for TPC-FV0-A D0-h case", false); + + // // ===================================== + // // DATA : process same event correlations: TPC-FV0A Lc - Ch. Part + // // ===================================== + + // void processSameTpcFv0aLcCh(FilteredCollisionsWSelMult::iterator const& collision, + // HfCandidatesSelLc const& candidates, + // aod::FV0As const& fv0as) + // { + // if (!(isAcceptedCollision(collision, true))) { + // return; + // } + + // if (collision.has_foundFV0()) { + // const auto& fv0 = collision.foundFV0(); + // const auto multiplicity = getMultiplicityEstimator(collision, true); + + // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // return; + // } + + // sameEventHf->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + // fillCorrelationsFIT(sameEventHf, CorrelationContainer::CFStep::kCFStepReconstructed, candidates, fv0, fv0as, multiplicity, collision.posZ(), true, isFV0A); + // } + // } + // PROCESS_SWITCH(HfTaskFlow, processSameTpcFv0aLcCh, "DATA : Process same-event correlations for TPC-FV0-A Lc-h case", false); + + // // ===================================== + // // DATA : process same event correlations: MFT-FV0A Ch. Part. - Ch. Part + // // ===================================== + + // void processSameMftFv0aChCh(FilteredCollisionsWSelMult::iterator const& collision, + // FilteredMftTracks const& mftTracks, + // aod::FV0As const& fv0as) + // { + // if (!(isAcceptedCollision(collision, true))) { + // return; + // } + + // if (collision.has_foundFV0()) { + // const auto& fv0 = collision.foundFV0(); + // const auto multiplicity = getMultiplicityEstimator(collision, true); + + // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // return; + // } + + // sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + // fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, fv0, fv0as, multiplicity, collision.posZ(), true, isFV0A); + // } + // } + // PROCESS_SWITCH(HfTaskFlow, processSameMftFv0aChCh, "DATA : Process same-event correlations for MFT-FV0-A h-h case", false); + + // void processSameMftFv0aChChReassociated(FilteredCollisionsWSelMult::iterator const& collision, + // soa::SmallGroups const& reassociatedMftTracks, + // FilteredMftTracks const&, + // aod::FV0As const& fv0as) + // { + // if (!(isAcceptedCollision(collision, true))) { + // return; + // } + + // if (collision.has_foundFV0()) { + // const auto& fv0 = collision.foundFV0(); + // const auto multiplicity = getMultiplicityEstimator(collision, true); + + // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // return; + // } + + // sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + // 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); /* void processSameMftFv0aChChReassociated3d(FilteredCollisionsWSelMult::iterator const& collision, @@ -2733,28 +2941,28 @@ struct HfTaskFlow { PROCESS_SWITCH(HfTaskFlow, processSameMftFv0aChChReassociated3d, "DATA : Process same-event correlations for MFT-FV0a h-h case 3d reassociated", false); */ - void processSameMftFv0aChChNonAmbiguous(FilteredCollisionsWSelMult::iterator const& collision, - soa::SmallGroups const& reassociatedMftTracks, - FilteredMftTracks const&, - aod::FV0As const& fv0as) - { - if (!(isAcceptedCollision(collision, true))) { - return; - } + // void processSameMftFv0aChChNonAmbiguous(FilteredCollisionsWSelMult::iterator const& collision, + // soa::SmallGroups const& reassociatedMftTracks, + // FilteredMftTracks const&, + // aod::FV0As const& fv0as) + // { + // if (!(isAcceptedCollision(collision, true))) { + // return; + // } - if (collision.has_foundFV0()) { - const auto& fv0 = collision.foundFV0(); - const auto multiplicity = getMultiplicityEstimator(collision, true); + // if (collision.has_foundFV0()) { + // const auto& fv0 = collision.foundFV0(); + // const auto multiplicity = getMultiplicityEstimator(collision, true); - if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { - return; - } + // if (multiplicity < configCollision.minMultiplicity || multiplicity > configCollision.maxMultiplicity) { + // return; + // } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - 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); + // sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + // 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); // ===================================== // DATA : process same event correlations: TPC-FT0A Ch. Part. - Ch. Part @@ -2781,8 +2989,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + } else { + sameEventTpcFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFIT(sameEventTpcFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, tracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + } } } PROCESS_SWITCH(HfTaskFlow, processSameTpcFt0aChCh, "DATA : Process same-event correlations for TPC-FT0-A h-h case", false); @@ -2871,8 +3084,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFIT(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + } else { + sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFIT(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, mftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, isFT0A); + } } } PROCESS_SWITCH(HfTaskFlow, processSameMftFt0aChCh, "DATA : Process same-event correlations for MFT-FT0-A h-h case", false); @@ -2898,8 +3116,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + } else { + sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + } } } PROCESS_SWITCH(HfTaskFlow, processSameMftFt0aChChReassociated, "DATA : Process same-event correlations for MFT-FT0-A h-h case reassociated", false); @@ -2925,8 +3148,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + } else { + sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, false, isFT0A); + } } } PROCESS_SWITCH(HfTaskFlow, processSameMftFt0aChChReassociated3d, "DATA : Process same-event correlations for MFT-FT0-A h-h case reassociated 3d", false); @@ -2952,8 +3180,13 @@ struct HfTaskFlow { return; } - sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); - fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, true, isFT0A); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFITReassociatedMftTracks(sameEvent, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, true, isFT0A); + } else { + sameEventMftFt0a->fillEvent(multiplicity, CorrelationContainer::kCFStepReconstructed); + fillCorrelationsFITReassociatedMftTracks(sameEventMftFt0a, CorrelationContainer::CFStep::kCFStepReconstructed, reassociatedMftTracks, ft0, ft0as, multiplicity, collision.posZ(), true, true, isFT0A); + } } } PROCESS_SWITCH(HfTaskFlow, processSameMftFt0aChChNonAmbiguous, "DATA : Process same-event correlations for MFT-FT0-A h-h case non ambiguous", false); @@ -3078,6 +3311,33 @@ struct HfTaskFlow { } PROCESS_SWITCH(HfTaskFlow, processSameFt0aFt0cChCh, "DATA : Process same-event correlations for FT0A-FT0C h-h case", false); + // =================================================================================================================================================================================================================================================================== + // 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; + // } + + // sameEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepAll); + // fillCorrelationsMonteCarlo(sameEvent, CorrelationContainer::CFStep::kCFStepAll, mcParticles, mcParticles, mcParticles.size(), mcCollision.posZ(), true); + + // if (collisions.size() == 0) { + // 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); + // =================================================================================================================================================================================================================================================================== // =================================================================================================================================================================================================================================================================== // MIXED EVENT PROCESS FUNCTIONS @@ -3135,7 +3395,11 @@ struct HfTaskFlow { FilteredMftTracks const& mftTracks, aod::BCsWithTimestamps const& bcs) { - mixCollisions(collisions, CorrelationContainer::kCFStepReconstructed, tracks, mftTracks, mixedEvent, bcs); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisions(collisions, CorrelationContainer::kCFStepReconstructed, tracks, mftTracks, mixedEvent, bcs); + } else { + mixCollisions(collisions, CorrelationContainer::kCFStepReconstructed, tracks, mftTracks, mixedEventTpcMft, bcs); + } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChCh, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -3144,7 +3408,11 @@ struct HfTaskFlow { FilteredMftTracks const& mftTracks, aod::BCsWithTimestamps const& bcs) { - mixCollisionsBis(collisions, CorrelationContainer::kCFStepReconstructed, tracks, mftTracks, perColTracks, perColMftTracks, mixedEvent, bcs); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsBis(collisions, CorrelationContainer::kCFStepReconstructed, tracks, mftTracks, perColTracks, perColMftTracks, mixedEvent, bcs); + } else { + mixCollisionsBis(collisions, CorrelationContainer::kCFStepReconstructed, tracks, mftTracks, perColTracks, perColMftTracks, mixedEventTpcMft, bcs); + } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChBis, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -3153,7 +3421,11 @@ struct HfTaskFlow { FilteredMftTracks const& /*mftTracks*/, soa::SmallGroups const& reassociated2dMftTracks) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, false); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, false); + } else { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, false); + } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChReassociated2d, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -3162,7 +3434,11 @@ struct HfTaskFlow { FilteredMftTracks const& /*mftTracks*/, soa::SmallGroups const& reassociated3dMftTracks) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEvent, false); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEvent, false); + } else { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated3dMftTracks, perColTracks, perColReassociated3dTracks, mixedEventTpcMft, false); + } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChReassociated3d, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -3171,7 +3447,11 @@ struct HfTaskFlow { FilteredMftTracks const& /*mftTracks*/, soa::SmallGroups const& reassociated2dMftTracks) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, true); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEvent, true); + } else { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, tracks, reassociated2dMftTracks, perColTracks, perColReassociated2dTracks, mixedEventTpcMft, true); + } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcMftChChNonAmbiguous, "DATA : Process mixed-event correlations for TPC-MFT h-h case", false); @@ -3206,49 +3486,49 @@ struct HfTaskFlow { // DATA : process mixed event correlations: TPC-FV0-A ch part. - ch. part. case // ===================================== - void processMixedTpcFv0aChCh(FilteredCollisionsWSelMult const& collisions, - FilteredTracksWDcaSel const& tracks, - aod::FV0As const& fv0as) - { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, fv0as, perColTracks, mixedEvent, isFV0A); - } - PROCESS_SWITCH(HfTaskFlow, processMixedTpcFv0aChCh, "DATA : Process mixed-event correlations for TPC-FV0-A h-h case", false); + // void processMixedTpcFv0aChCh(FilteredCollisionsWSelMult const& collisions, + // FilteredTracksWDcaSel const& tracks, + // aod::FV0As const& fv0as) + // { + // mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, fv0as, perColTracks, mixedEvent, isFV0A); + // } + // PROCESS_SWITCH(HfTaskFlow, processMixedTpcFv0aChCh, "DATA : Process mixed-event correlations for TPC-FV0-A h-h case", false); // ===================================== // DATA : process mixed event correlations: TPC-FV0-A D0 - ch. part. case // ===================================== - void processMixedTpcFv0aD0Ch(FilteredCollisionsWSelMult const& collisions, - HfCandidatesSelD0 const& candidates, - aod::FV0As const& fv0as) - { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, fv0as, perColD0s, mixedEventHf, isFV0A); - } - PROCESS_SWITCH(HfTaskFlow, processMixedTpcFv0aD0Ch, "DATA : Process mixed-event correlations for TPC-FV0-A D0-h case", false); + // void processMixedTpcFv0aD0Ch(FilteredCollisionsWSelMult const& collisions, + // HfCandidatesSelD0 const& candidates, + // aod::FV0As const& fv0as) + // { + // mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, fv0as, perColD0s, mixedEventHf, isFV0A); + // } + // PROCESS_SWITCH(HfTaskFlow, processMixedTpcFv0aD0Ch, "DATA : Process mixed-event correlations for TPC-FV0-A D0-h case", false); // ===================================== // DATA : process mixed event correlations: TPC-FV0-A Lc - ch. part. case // ===================================== - void processMixedTpcFv0aLcCh(FilteredCollisionsWSelMult const& collisions, - HfCandidatesSelLc const& candidates, - aod::FV0As const& fv0as) - { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, fv0as, perColLcs, mixedEventHf, isFV0A); - } - PROCESS_SWITCH(HfTaskFlow, processMixedTpcFv0aLcCh, "DATA : Process mixed-event correlations for TPC-FV0-A Lc-h case", false); + // void processMixedTpcFv0aLcCh(FilteredCollisionsWSelMult const& collisions, + // HfCandidatesSelLc const& candidates, + // aod::FV0As const& fv0as) + // { + // mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, candidates, fv0as, perColLcs, mixedEventHf, isFV0A); + // } + // PROCESS_SWITCH(HfTaskFlow, processMixedTpcFv0aLcCh, "DATA : Process mixed-event correlations for TPC-FV0-A Lc-h case", false); // ===================================== // DATA : process mixed event correlations: TPC-FV0-A ch part. - ch. part. case // ===================================== - void processMixedMftFv0aChCh(FilteredCollisionsWSelMult const& collisions, - FilteredMftTracks const& mftTracks, - aod::FV0As const& fv0as) - { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, fv0as, perColMftTracks, mixedEvent, isFV0A); - } - PROCESS_SWITCH(HfTaskFlow, processMixedMftFv0aChCh, "DATA : Process mixed-event correlations for Mft-FV0-A h-h case", false); + // void processMixedMftFv0aChCh(FilteredCollisionsWSelMult const& collisions, + // FilteredMftTracks const& mftTracks, + // aod::FV0As const& fv0as) + // { + // mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, fv0as, perColMftTracks, mixedEvent, isFV0A); + // } + // PROCESS_SWITCH(HfTaskFlow, processMixedMftFv0aChCh, "DATA : Process mixed-event correlations for Mft-FV0-A h-h case", false); // ===================================== // DATA : process mixed event correlations: TPC-FT0-A ch part. - ch. part. case @@ -3258,7 +3538,11 @@ struct HfTaskFlow { FilteredTracksWDcaSel const& tracks, aod::FT0s const& ft0s) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEvent, isFT0A); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEvent, isFT0A); + } else { + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, tracks, ft0s, perColTracks, mixedEventTpcFt0a, isFT0A); + } } PROCESS_SWITCH(HfTaskFlow, processMixedTpcFt0aChCh, "DATA : Process mixed-event correlations for TPC-FT0-A h-h case", false); @@ -3294,7 +3578,11 @@ struct HfTaskFlow { FilteredMftTracks const& mftTracks, aod::FT0s const& ft0s) { - mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, ft0s, perColMftTracks, mixedEvent, isFT0A); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, ft0s, perColMftTracks, mixedEvent, isFT0A); + } else { + mixCollisionsFIT(collisions, CorrelationContainer::kCFStepReconstructed, mftTracks, ft0s, perColMftTracks, mixedEventMftFt0a, isFT0A); + } } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChCh, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); @@ -3303,7 +3591,11 @@ struct HfTaskFlow { soa::SmallGroups const& reassociated2dMftTracks, aod::FT0s const& ft0s) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, false); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, false); + } else { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, false); + } } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChChReassociated2d, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); @@ -3312,7 +3604,11 @@ struct HfTaskFlow { soa::SmallGroups const& reassociated3dMftTracks, aod::FT0s const& ft0s) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEvent, false); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEvent, false); + } else { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated3dMftTracks, ft0s, perColReassociated3dTracks, perColReassociated3dTracks, mixedEventMftFt0a, false); + } } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChChReassociated3d, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); @@ -3321,7 +3617,11 @@ struct HfTaskFlow { soa::SmallGroups const& reassociated2dMftTracks, aod::FT0s const& ft0s) { - mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, true); + if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEvent, true); + } else { + mixCollisionsReassociatedMftTracks(collisions, CorrelationContainer::kCFStepReconstructed, reassociated2dMftTracks, ft0s, perColReassociated2dTracks, perColReassociated2dTracks, mixedEventMftFt0a, true); + } } PROCESS_SWITCH(HfTaskFlow, processMixedMftFt0aChChNonAmbiguous, "DATA : Process mixed-event correlations for MFT-FT0-A h-h case", false); @@ -3372,6 +3672,51 @@ struct HfTaskFlow { } PROCESS_SWITCH(HfTaskFlow, processMixedFt0aFt0cChCh, "DATA : Process mixed-event correlations for FT0A-FT0C h-h case", false); + // =================================================================================================================================================================================================================================================================== + // 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; + // }; + + // 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)) { + + // 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 groupedCollisions = collisions.sliceBy(collisionPerMcCollision, collision1.globalIndex()); + + // mixedEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepAll); + // fillCorrelationsMonteCarlo(mixedEvent, CorrelationContainer::CFStep::kCFStepAll, mcParticles, mcParticles, mcParticles.size(), collision1.posZ(), false); + + // if (groupedCollisions.size() == 0) { + // return; + // } + + // mixedEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepTrackedOnlyPrim); + // fillCorrelationsMonteCarlo(mixedEvent, CorrelationContainer::CFStep::kCFStepTrackedOnlyPrim, mcParticles, mcParticles, mcParticles.size(), collision1.posZ(), false); + // } + + // } + // PROCESS_SWITCH(HfTaskFlow, processMixedMcGen, "MC Gen : Process mixed-event correlations", false); + }; // End of struct WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)