[PWGHF] Ds-h correlations, ME offline on self-contained derived data (#8997)

scattaru · alibuild · vkucera · web-flow · commit 2e3e1714a7fc · 2024-12-18T11:31:59.000+01:00
Co-authored-by: ALICE Action Bot &lt;alibuild@cern.ch&gt;
Co-authored-by: Vít Kučera &lt;vit.kucera@cern.ch&gt;
diff --git a/PWGHF/HFC/TableProducer/CMakeLists.txt b/PWGHF/HFC/TableProducer/CMakeLists.txt
@@ -44,6 +44,11 @@ o2physics_add_dpl_workflow(correlator-ds-hadrons
                     PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore
                     COMPONENT_NAME Analysis)
 
+o2physics_add_dpl_workflow(correlator-ds-hadrons-reduced
+                    SOURCES correlatorDsHadronsReduced.cxx
+                    PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore
+                    COMPONENT_NAME Analysis)
+
 o2physics_add_dpl_workflow(correlator-dstar-hadrons
                     SOURCES correlatorDstarHadrons.cxx
                     PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore
diff --git a/PWGHF/HFC/TableProducer/correlatorDsHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorDsHadrons.cxx
@@ -61,8 +61,8 @@ struct HfCorrelatorDsHadronsSelCollision {
   Configurable<float> yCandMax{"yCandMax", 0.8, "max. cand. rapidity"};
   Configurable<float> ptCandMin{"ptCandMin", 1., "min. cand. pT"};
 
-  SliceCache cache;
   HfHelper hfHelper;
+  SliceCache cache;
 
   using SelCollisions = soa::Join<aod::Collisions, aod::EvSels>;
   using CandDsData = soa::Filtered<soa::Join<aod::HfCand3Prong, aod::HfSelDsToKKPi>>;
@@ -169,15 +169,8 @@ struct HfCorrelatorDsHadrons {
   Configurable<std::vector<double>> binsPtHadron{"binsPtHadron", std::vector<double>{0.3, 2., 4., 8., 12., 50.}, "pT bin limits for assoc particle"};
   Configurable<std::vector<double>> binsPtEfficiencyD{"binsPtEfficiencyD", std::vector<double>{o2::analysis::hf_cuts_ds_to_k_k_pi::vecBinsPt}, "pT bin limits for efficiency"};
   Configurable<std::vector<double>> efficiencyD{"efficiencyD", {1., 1., 1., 1., 1., 1.}, "efficiency values for Ds meson"};
-  ConfigurableAxis zPoolBins{"zPoolBins", {VARIABLE_WIDTH, -10.0, -2.5, 2.5, 10.0}, "z vertex position pools"};
-  ConfigurableAxis multPoolBins{"multPoolBins", {VARIABLE_WIDTH, 0., 900., 1800., 6000.}, "event multiplicity pools (FT0M)"};
-  ConfigurableAxis binsMassD{"binsMassD", {200, 1.7, 2.25}, "inv. mass (K^{#pm}K^{-}#pi^{+}) (GeV/#it{c}^{2})"};
-  ConfigurableAxis binsEta{"binsEta", {50, -2., 2.}, "#it{#eta}"};
-  ConfigurableAxis binsPhi{"binsPhi", {64, -PIHalf, 3. * PIHalf}, "#it{#varphi}"};
-  ConfigurableAxis binsMultiplicity{"binsMultiplicity", {200, 0., 800.}, "Multiplicity"};
-  ConfigurableAxis binsMultFT0M{"binsMultFT0M", {600, 0., 6000.}, "Multiplicity as FT0M signal amplitude"};
-  ConfigurableAxis binsPosZ{"binsPosZ", {100, -10., 10.}, "primary vertex z coordinate"};
-  ConfigurableAxis binsPoolBin{"binsPoolBin", {9, 0., 9.}, "PoolBin"};
+
+  int hfcReducedCollisionIndex = 0;
 
   HfHelper hfHelper;
   SliceCache cache;
@@ -195,6 +188,22 @@ struct HfCorrelatorDsHadrons {
   Filter flagDsFilter = ((o2::aod::hf_track_index::hfflag & static_cast<uint8_t>(1 << aod::hf_cand_3prong::DecayType::DsToKKPi)) != static_cast<uint8_t>(0)) && (aod::hf_sel_candidate_ds::isSelDsToKKPi >= selectionFlagDs || aod::hf_sel_candidate_ds::isSelDsToPiKK >= selectionFlagDs);
   Filter trackFilter = (nabs(aod::track::eta) < etaTrackMax) && (aod::track::pt > ptTrackMin) && (aod::track::pt < ptTrackMax) && (nabs(aod::track::dcaXY) < dcaXYTrackMax) && (nabs(aod::track::dcaZ) < dcaZTrackMax);
 
+  Preslice<CandDsData> candsDsPerCollision = aod::hf_cand::collisionId;
+  Preslice<MyTracksData> trackIndicesPerCollision = aod::track::collisionId;
+  Preslice<CandDsMcGen> perCollisionCandMc = o2::aod::mcparticle::mcCollisionId;
+  PresliceUnsorted<soa::Join<aod::Collisions, aod::FT0Mults, aod::EvSels, aod::McCollisionLabels>> collPerCollMc = o2::aod::mccollisionlabel::mcCollisionId;
+
+  ConfigurableAxis zPoolBins{"zPoolBins", {VARIABLE_WIDTH, -10.0, -2.5, 2.5, 10.0}, "z vertex position pools"};
+  ConfigurableAxis multPoolBins{"multPoolBins", {VARIABLE_WIDTH, 0., 900., 1800., 6000.}, "event multiplicity pools (FT0M)"};
+  ConfigurableAxis binsMassD{"binsMassD", {200, 1.7, 2.25}, "inv. mass (K^{#pm}K^{-}#pi^{+}) (GeV/#it{c}^{2})"};
+  ConfigurableAxis binsEta{"binsEta", {50, -2., 2.}, "#it{#eta}"};
+
+  ConfigurableAxis binsPhi{"binsPhi", {64, -PIHalf, 3. * PIHalf}, "#it{#varphi}"};
+  ConfigurableAxis binsMultiplicity{"binsMultiplicity", {200, 0., 800.}, "Multiplicity"};
+  ConfigurableAxis binsMultFT0M{"binsMultFT0M", {600, 0., 6000.}, "Multiplicity as FT0M signal amplitude"};
+  ConfigurableAxis binsPosZ{"binsPosZ", {100, -10., 10.}, "primary vertex z coordinate"};
+  ConfigurableAxis binsPoolBin{"binsPoolBin", {9, 0., 9.}, "PoolBin"};
+
   HistogramRegistry registry{"registry", {}, OutputObjHandlingPolicy::AnalysisObject};
 
   void init(InitContext&)
@@ -581,9 +590,6 @@ struct HfCorrelatorDsHadrons {
   }
   PROCESS_SWITCH(HfCorrelatorDsHadrons, processMcRec, "Process MC Reco mode", false);
 
-  Preslice<CandDsMcGen> perCollisionCandMc = o2::aod::mcparticle::mcCollisionId;
-  PresliceUnsorted<soa::Join<aod::Collisions, aod::FT0Mults, aod::EvSels, aod::McCollisionLabels>> collPerCollMc = o2::aod::mccollisionlabel::mcCollisionId;
-
   /// Ds-Hadron correlation pair builder - for MC gen-level analysis (no filter/selection, only true signal)
   void processMcGen(SelCollisionsMc const& mcCollisions,
                     soa::Join<aod::Collisions, aod::FT0Mults, aod::EvSels, aod::McCollisionLabels> const& collisions,
@@ -689,32 +695,75 @@ struct HfCorrelatorDsHadrons {
   }
   PROCESS_SWITCH(HfCorrelatorDsHadrons, processMcGen, "Process MC Gen mode", false);
 
-  void processDerivedDataDs(SelCollisionsWithDs::iterator const& collision,
+  void processDerivedDataDs(SelCollisionsWithDs const& collisions,
                             CandDsData const& candidates,
                             MyTracksData const& tracks)
   {
-    collReduced(collision.multFT0M(), collision.posZ());
 
-    // Ds fill histograms and Ds candidates information stored
-    for (const auto& candidate : candidates) {
-      // candidate selected
-      if (candidate.isSelDsToKKPi() >= selectionFlagDs) {
-        candReduced(collReduced.lastIndex(), candidate.phi(), candidate.eta(), candidate.pt(), hfHelper.invMassDsToKKPi(candidate));
-      } else if (candidate.isSelDsToPiKK() >= selectionFlagDs) {
-        candReduced(collReduced.lastIndex(), candidate.phi(), candidate.eta(), candidate.pt(), hfHelper.invMassDsToPiKK(candidate));
+    for (const auto& collision : collisions) {
+      auto thisCollId = collision.globalIndex();
+      auto candsDsThisColl = candidates.sliceBy(candsDsPerCollision, thisCollId);
+      auto tracksThisColl = tracks.sliceBy(trackIndicesPerCollision, thisCollId);
+
+      // Ds fill histograms and Ds candidates information stored
+      for (const auto& candidate : candidates) {
+        // candidate selected
+        if (candidate.isSelDsToKKPi() >= selectionFlagDs) {
+          candReduced(hfcReducedCollisionIndex, candidate.phi(), candidate.eta(), candidate.pt(), hfHelper.invMassDsToKKPi(candidate));
+        } else if (candidate.isSelDsToPiKK() >= selectionFlagDs) {
+          candReduced(hfcReducedCollisionIndex, candidate.phi(), candidate.eta(), candidate.pt(), hfHelper.invMassDsToPiKK(candidate));
+        }
       }
-    }
 
-    // tracks information
-    for (const auto& track : tracks) {
-      if (!track.isGlobalTrackWoDCA()) {
-        continue;
+      // tracks information
+      for (const auto& track : tracks) {
+        if (!track.isGlobalTrackWoDCA()) {
+          continue;
+        }
+        assocTrackReduced(hfcReducedCollisionIndex, track.phi(), track.eta(), track.pt());
       }
-      assocTrackReduced(collReduced.lastIndex(), track.phi(), track.eta(), track.pt());
+
+      collReduced(collision.multFT0M(), collision.posZ());
+      hfcReducedCollisionIndex++;
     }
   }
   PROCESS_SWITCH(HfCorrelatorDsHadrons, processDerivedDataDs, "Process derived data Ds", false);
 
+  void processDerivedDataDsLastIndex(SelCollisionsWithDs const& collisions,
+                                     CandDsData const& candidates,
+                                     MyTracksData const& tracks)
+  {
+
+    for (const auto& collision : collisions) {
+      auto thisCollId = collision.globalIndex();
+      auto candsDsThisColl = candidates.sliceBy(candsDsPerCollision, thisCollId);
+      auto tracksThisColl = tracks.sliceBy(trackIndicesPerCollision, thisCollId);
+
+      int indexHfcReducedCollision = collReduced.lastIndex() + 1;
+
+      // Ds fill histograms and Ds candidates information stored
+      for (const auto& candidate : candidates) {
+        // candidate selected
+        if (candidate.isSelDsToKKPi() >= selectionFlagDs) {
+          candReduced(indexHfcReducedCollision, candidate.phi(), candidate.eta(), candidate.pt(), hfHelper.invMassDsToKKPi(candidate));
+        } else if (candidate.isSelDsToPiKK() >= selectionFlagDs) {
+          candReduced(indexHfcReducedCollision, candidate.phi(), candidate.eta(), candidate.pt(), hfHelper.invMassDsToPiKK(candidate));
+        }
+      }
+
+      // tracks information
+      for (const auto& track : tracks) {
+        if (!track.isGlobalTrackWoDCA()) {
+          continue;
+        }
+        assocTrackReduced(indexHfcReducedCollision, track.phi(), track.eta(), track.pt());
+      }
+
+      collReduced(collision.multFT0M(), collision.posZ());
+    }
+  }
+  PROCESS_SWITCH(HfCorrelatorDsHadrons, processDerivedDataDsLastIndex, "Process derived data Ds w lastIndex", false);
+
   // Event Mixing
   void processDataME(SelCollisionsWithDs const& collisions,
                      CandDsData const& candidates,
diff --git a/PWGHF/HFC/TableProducer/correlatorDsHadronsReduced.cxx b/PWGHF/HFC/TableProducer/correlatorDsHadronsReduced.cxx
@@ -0,0 +1,122 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file correlatorDsHadronsReduced.cxx
+/// \brief Ds-Hadrons correlator task for ME offline
+/// \author Samuele Cattaruzzi <samuele.cattaruzzi@cern.ch>
+
+#include <vector>
+
+#include "CommonConstants/PhysicsConstants.h"
+#include "Framework/AnalysisTask.h"
+#include "Framework/HistogramRegistry.h"
+#include "Framework/runDataProcessing.h"
+
+#include "PWGHF/HFC/DataModel/CorrelationTables.h"
+#include "PWGHF/HFC/DataModel/DerivedDataCorrelationTables.h"
+
+using namespace o2;
+using namespace o2::analysis;
+using namespace o2::constants::physics;
+using namespace o2::constants::math;
+using namespace o2::framework;
+using namespace o2::framework::expressions;
+
+/// Returns deltaPhi value in range [-pi/2., 3.*pi/2], typically used for correlation studies
+double getDeltaPhi(double phiHadron, double phiD)
+{
+  return RecoDecay::constrainAngle(phiHadron - phiD, -PIHalf);
+}
+
+// binning type
+using BinningTypeDerived = ColumnBinningPolicy<aod::hf_collisions_reduced::PosZ, aod::hf_collisions_reduced::Multiplicity>;
+
+/// Ds-Hadron correlation pair builder - for real data and data-like analysis (i.e. reco-level w/o matching request via MC truth)
+struct HfCorrelatorDsHadronsReduced {
+  Produces<aod::DsHadronPair> entryDsHadronPair;
+  Produces<aod::DsHadronRecoInfo> entryDsHadronRecoInfo;
+  Produces<aod::DsHadronGenInfo> entryDsHadronGenInfo;
+
+  Configurable<bool> fillHistoData{"fillHistoData", true, "Flag for filling histograms in data processes"};
+  Configurable<int> numberEventsMixed{"numberEventsMixed", 5, "Number of events mixed in ME process"};
+
+  SliceCache cache;
+
+  // Preslice<aod::AssocTrackReds> tracksPerCol = aod::hf_assoc_track_reduced::hfcRedCollisionId;
+  Preslice<aod::AssocTrackReds> tracksPerCol = aod::hf_candidate_reduced::hfcRedCollisionId;
+  Preslice<aod::DsCandReduceds> candPerCol = aod::hf_candidate_reduced::hfcRedCollisionId;
+
+  ConfigurableAxis zPoolBins{"zPoolBins", {VARIABLE_WIDTH, -10.0, -2.5, 2.5, 10.0}, "z vertex position pools"};
+  ConfigurableAxis multPoolBins{"multPoolBins", {VARIABLE_WIDTH, 0., 900., 1800., 6000.}, "event multiplicity pools (FT0M)"};
+  ConfigurableAxis binsMultFT0M{"binsMultFT0M", {600, 0., 6000.}, "Multiplicity as FT0M signal amplitude"};
+  ConfigurableAxis binsPosZ{"binsPosZ", {100, -10., 10.}, "primary vertex z coordinate"};
+  ConfigurableAxis binsPoolBin{"binsPoolBin", {9, 0., 9.}, "PoolBin"};
+
+  HistogramRegistry registry{"registry", {}, OutputObjHandlingPolicy::AnalysisObject};
+
+  void init(InitContext&)
+  {
+    AxisSpec axisMultFT0M = {binsMultFT0M, "MultiplicityFT0M"};
+    AxisSpec axisPosZ = {binsPosZ, "PosZ"};
+    AxisSpec axisPoolBin = {binsPoolBin, "PoolBin"};
+
+    // Histograms for data analysis
+    if (fillHistoData) {
+      registry.add("hMultFT0M", "Multiplicity FT0M", {HistType::kTH1F, {axisMultFT0M}});
+      registry.add("hZVtx", "z vertex", {HistType::kTH1F, {axisPosZ}});
+      registry.add("hDsPoolBin", "Ds candidates pool bin", {HistType::kTH1F, {axisPoolBin}});
+      registry.add("hTracksPoolBin", "Particles associated pool bin", {HistType::kTH1F, {axisPoolBin}});
+    }
+  }
+
+  void processDerivedDataME(aod::HfcRedCollisions const& collisions,
+                            aod::DsCandReduceds const& candidates,
+                            aod::AssocTrackReds const& tracks)
+  {
+
+    BinningTypeDerived corrBinning{{zPoolBins, multPoolBins}, true};
+
+    auto tracksTuple = std::make_tuple(candidates, tracks);
+
+    Pair<aod::HfcRedCollisions, aod::DsCandReduceds, aod::AssocTrackReds, BinningTypeDerived> pairData{corrBinning, numberEventsMixed, -1, collisions, tracksTuple, &cache};
+
+    for (const auto& [c1, tracks1, c2, tracks2] : pairData) {
+      if (tracks1.size() == 0) {
+        continue;
+      }
+
+      int poolBin = corrBinning.getBin(std::make_tuple(c2.posZ(), c2.multiplicity()));
+      int poolBinDs = corrBinning.getBin(std::make_tuple(c1.posZ(), c1.multiplicity()));
+      registry.fill(HIST("hMultFT0M"), c1.multiplicity());
+      registry.fill(HIST("hZVtx"), c1.posZ());
+      registry.fill(HIST("hTracksPoolBin"), poolBin);
+      registry.fill(HIST("hDsPoolBin"), poolBinDs);
+
+      for (const auto& [cand, pAssoc] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(tracks1, tracks2))) {
+        LOGF(info, "Mixed event tracks pair: (%d, %d) from events (%d, %d), track event: (%d, %d)", cand.index(), pAssoc.index(), c1.index(), c2.index(), cand.hfcRedCollisionId(), pAssoc.hfcRedCollisionId());
+
+        entryDsHadronPair(getDeltaPhi(pAssoc.phiAssocTrack(), cand.phiCand()),
+                          pAssoc.etaAssocTrack() - cand.etaCand(),
+                          cand.ptCand(),
+                          pAssoc.ptAssocTrack(),
+                          poolBin);
+        entryDsHadronRecoInfo(cand.invMassDs(), false, false);
+        entryDsHadronGenInfo(false, false, 0);
+      }
+    }
+  }
+  PROCESS_SWITCH(HfCorrelatorDsHadronsReduced, processDerivedDataME, "Process Mixed Event Derived Data", true);
+};
+
+WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
+{
+  return WorkflowSpec{adaptAnalysisTask<HfCorrelatorDsHadronsReduced>(cfgc)};
+}
