Merge branch 'AliceO2Group:master' into kaonIsospinFluctuation2_EffCorrAdded

Author: rahulverma012

ALICE3/Tasks/alice3TrackingPerformance.cxx

@@ -78,19 +78,20 @@ struct Alice3TrackingPerformance {
       }
       const std::string tag = "_" + prefix;
       prefix += "/";
-      particlePtDistribution[pdg] = histos.add<TH1>(prefix + "particlePtDistribution" + tag, "", kTH1D, {ptAxis});
-      particleEtaDistribution[pdg] = histos.add<TH1>(prefix + "particleEtaDistribution" + tag, "", kTH1D, {etaAxis});
+      auto histoName = [&](const std::string& name) { return Form("%s%s%s", prefix.c_str(), name.c_str(), tag.c_str()); };
+      particlePtDistribution[pdg] = histos.add<TH1>(histoName("particlePtDistribution"), "", kTH1D, {ptAxis});
+      particleEtaDistribution[pdg] = histos.add<TH1>(histoName("particleEtaDistribution"), "", kTH1D, {etaAxis});
 
-      ptDistribution[pdg] = histos.add<TH1>(prefix + "ptDistribution" + tag, "", kTH1D, {ptAxis});
-      ptResolutionVsPt[pdg] = histos.add<TH2>(prefix + "ptResolutionVsPt" + tag, "", kTH2D, {ptAxis, axisPtDelta});
-      ptResolutionVsEta[pdg] = histos.add<TProfile2D>(prefix + "ptResolutionVsEta" + tag, "", kTProfile2D, {ptAxis, etaAxis});
-      invPtResolutionVsPt[pdg] = histos.add<TH2>(prefix + "invPtResolutionVsPt" + tag, "", kTH2D, {ptAxis, invPtDeltaAxis});
-      invPtResolutionVsEta[pdg] = histos.add<TProfile2D>(prefix + "invPtResolutionVsEta" + tag, "", kTProfile2D, {ptAxis, etaAxis});
-      dcaXyResolutionVsPt[pdg] = histos.add<TH2>(prefix + "dcaXyResolutionVsPt" + tag, "", kTH2D, {ptAxis, axisDcaXy});
-      dcaZResolutionVsPt[pdg] = histos.add<TH2>(prefix + "dcaZResolutionVsPt" + tag, "", kTH2D, {ptAxis, axisDcaZ});
-      covariancePtPtVsPt[pdg] = histos.add<TH2>(prefix + "covariancePtPtVsPt" + tag, "", kTH2D, {ptAxis, axisCovariancePtPt});
-      covarianceDcaXyDcaXyVsPt[pdg] = histos.add<TH2>(prefix + "covarianceDcaXyDcaXyVsPt" + tag, "", kTH2D, {ptAxis, axisCovarianceDcaXyDcaXy});
-      covarianceDcaZDcaZVsPt[pdg] = histos.add<TH2>(prefix + "covarianceDcaZDcaZVsPt" + tag, "", kTH2D, {ptAxis, axisCovarianceDcaZDcaZ});
+      ptDistribution[pdg] = histos.add<TH1>(histoName("ptDistribution"), "", kTH1D, {ptAxis});
+      ptResolutionVsPt[pdg] = histos.add<TH2>(histoName("ptResolutionVsPt"), "", kTH2D, {ptAxis, axisPtDelta});
+      ptResolutionVsEta[pdg] = histos.add<TProfile2D>(histoName("ptResolutionVsEta"), "", kTProfile2D, {ptAxis, etaAxis});
+      invPtResolutionVsPt[pdg] = histos.add<TH2>(histoName("invPtResolutionVsPt"), "", kTH2D, {ptAxis, invPtDeltaAxis});
+      invPtResolutionVsEta[pdg] = histos.add<TProfile2D>(histoName("invPtResolutionVsEta"), "", kTProfile2D, {ptAxis, etaAxis});
+      dcaXyResolutionVsPt[pdg] = histos.add<TH2>(histoName("dcaXyResolutionVsPt"), "", kTH2D, {ptAxis, axisDcaXy});
+      dcaZResolutionVsPt[pdg] = histos.add<TH2>(histoName("dcaZResolutionVsPt"), "", kTH2D, {ptAxis, axisDcaZ});
+      covariancePtPtVsPt[pdg] = histos.add<TH2>(histoName("covariancePtPtVsPt"), "", kTH2D, {ptAxis, axisCovariancePtPt});
+      covarianceDcaXyDcaXyVsPt[pdg] = histos.add<TH2>(histoName("covarianceDcaXyDcaXyVsPt"), "", kTH2D, {ptAxis, axisCovarianceDcaXyDcaXy});
+      covarianceDcaZDcaZVsPt[pdg] = histos.add<TH2>(histoName("covarianceDcaZDcaZVsPt"), "", kTH2D, {ptAxis, axisCovarianceDcaZDcaZ});
     }
   }
 
@@ -102,10 +103,7 @@ struct Alice3TrackingPerformance {
         return false;
       }
       const int etaBin = particleEtaDistribution[0]->GetXaxis()->FindBin(p.eta());
-      if (etaBin < 1 || etaBin > particleEtaDistribution[0]->GetXaxis()->GetNbins()) {
-        return false;
-      }
-      return true;
+      return etaBin >= 1 && etaBin <= particleEtaDistribution[0]->GetXaxis()->GetNbins();
     };
 
     for (const auto& mcParticle : mcParticles) {
@@ -115,7 +113,7 @@ struct Alice3TrackingPerformance {
       }
       particlePtDistribution[0]->Fill(mcParticle.pt());
       particleEtaDistribution[0]->Fill(mcParticle.eta());
-      if (particlePtDistribution.find(mcParticle.pdgCode()) == particlePtDistribution.end()) {
+      if (!particlePtDistribution.contains(mcParticle.pdgCode())) {
         continue;
       }
       particlePtDistribution[mcParticle.pdgCode()]->Fill(mcParticle.pt());
@@ -148,7 +146,7 @@ struct Alice3TrackingPerformance {
       if (!isParticleSelected(mcParticle)) {
         continue;
       }
-      if (ptResolutionVsPt.find(mcParticle.pdgCode()) == ptResolutionVsPt.end()) {
+      if (!ptResolutionVsPt.contains(mcParticle.pdgCode())) {
         continue;
       }
       fillResolutionHistograms(mcParticle.pdgCode());

PWGCF/EbyEFluctuations/Tasks/radialFlowDecorr.cxx

@@ -748,6 +748,182 @@ class McBuilder
   std::unordered_map<int64_t, int64_t> mMcMotherMap;
   std::unordered_map<int64_t, int64_t> mMcPartonicMotherMap;
 };
+
+struct McBuilderDerivedToDerivedProducts : o2::framework::ProducesGroup {
+  o2::framework::Produces<o2::aod::StoredFMcCols> producedMcCollisions;
+  o2::framework::Produces<o2::aod::StoredFMcParticles> producedMcParticles;
+  o2::framework::Produces<o2::aod::StoredFMcMothers> producedMothers;
+  o2::framework::Produces<o2::aod::StoredFMcPartMoths> producedPartonicMothers;
+  o2::framework::Produces<o2::aod::StoredFMcMotherLabels> producedMcMotherLabels;
+
+  o2::framework::Produces<o2::aod::StoredFColLabels> producedCollisionLabels;
+  o2::framework::Produces<o2::aod::StoredFTrackLabels> producedTrackLabels;
+};
+
+struct ConfMcTablesDerivedToDerived : o2::framework::ConfigurableGroup {
+  std::string prefix = std::string("McTables");
+  o2::framework::Configurable<bool> requireMcLabel{"requireMcLabel", false, "Reject particles without an associated MC particle instead of writing a -1 label"}; // dummy configuration for now
+};
+
+/// Copies MC information from one femto derived file into another.
+/// The ancestry is already resolved upstream (FMcMothers / FMcPartMoths /
+/// FMcMotherLabels), so this only remaps indices: each source row is copied on
+/// first use and cached for the rest of the dataframe.
+class McBuilderDerivedToDerived
+{
+ public:
+  McBuilderDerivedToDerived() = default;
+  ~McBuilderDerivedToDerived() = default;
+
+  template <typename T>
+  void init(T& config)
+  {
+    LOG(info) << "Initialize derived-to-derived monte carlo builder...";
+    mRequireMcLabel = config.requireMcLabel.value;
+    LOG(info) << "Initialization done...";
+  }
+
+  /// Write one FColLabels row. Call exactly once per produced collision,
+  /// directly after collisionBuilder.processCollision().
+  template <typename T1, typename T2, typename T3>
+  void fillCollisionWithLabel(T1 const& col, T2 const& /*mcCols*/, T3& mcProducts)
+  {
+    if (!col.has_fMcCol()) {
+      mcProducts.producedCollisionLabels(-1);
+      return;
+    }
+    auto mcCol = col.template fMcCol_as<T2>();
+    mcProducts.producedCollisionLabels(this->getOrCreateMcCollisionRow(mcCol, mcProducts));
+  }
+
+  /// True if this track has no MC particle and we are configured to drop such tracks.
+  template <typename T>
+  bool rejectParticle(T const& particle) const
+  {
+    return mRequireMcLabel && !particle.has_fMcParticle();
+  }
+
+  /// Write one FTrackLabels row. Call exactly once per produced track row.
+  /// mcParticles must be joined with FMcMotherLabels so the mother indices resolve.
+  template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+  void fillTrackWithLabel(T1 const& track, T2 const& mcCols, T3 const& /*mcParticles*/, T4 const& mcMothers, T5 const& mcPartonicMothers, T6& mcProducts)
+  {
+    if (!track.has_fMcParticle()) {
+      mcProducts.producedTrackLabels(-1);
+      return;
+    }
+    auto mcParticle = track.template fMcParticle_as<T3>();
+    mcProducts.producedTrackLabels(
+      this->getOrCreateMcParticleRow(mcParticle, mcCols, mcMothers, mcPartonicMothers, mcProducts));
+  }
+
+  template <typename T1, typename T2>
+  void reset(T1 const& mcCols, T2 const& mcParticles)
+  {
+    mCollisionMap.clear();
+    mCollisionMap.reserve(mcCols.size());
+    mMcParticleMap.clear();
+    mMcParticleMap.reserve(mcParticles.size());
+    mMcMotherMap.clear();
+    mMcMotherMap.reserve(mcParticles.size());
+    mMcPartonicMotherMap.clear();
+    mMcPartonicMotherMap.reserve(mcParticles.size());
+  }
+
+ private:
+  template <typename T1, typename T2>
+  int64_t getOrCreateMcCollisionRow(T1 const& mcCol, T2& mcProducts)
+  {
+    const int64_t gid = mcCol.globalIndex();
+    auto it = mCollisionMap.find(gid);
+    if (it != mCollisionMap.end()) {
+      return it->second;
+    }
+    mcProducts.producedMcCollisions(mcCol.posZ(),
+                                    mcCol.mult(),
+                                    mcCol.cent());
+    const int64_t row = mcProducts.producedMcCollisions.lastIndex();
+    mCollisionMap.emplace(gid, row);
+    return row;
+  }
+
+  /// Find-or-create the FMcParticles row. On first creation the mother and
+  /// partonic mother rows are copied and the single matching FMcMotherLabels row
+  /// is written, so the two tables stay in lockstep exactly as in McBuilder.
+  template <typename T1, typename T2, typename T3, typename T4, typename T5>
+  int64_t getOrCreateMcParticleRow(T1 const& mcParticle, T2 const& /*mcCols*/, T3 const& /*mcMothers*/, T4 const& /*mcPartonicMothers*/, T5& mcProducts)
+  {
+    const int64_t gid = mcParticle.globalIndex();
+    auto it = mMcParticleMap.find(gid);
+    if (it != mMcParticleMap.end()) {
+      return it->second;
+    }
+
+    // NOTE: the MC collision of the particle, not of the reconstructed collision.
+    // These differ for wrongly associated particles, which is the point of keeping it.
+    int64_t mcColId = -1;
+    if (mcParticle.has_fMcCol()) {
+      auto mcCol = mcParticle.template fMcCol_as<T2>();
+      mcColId = this->getOrCreateMcCollisionRow(mcCol, mcProducts);
+    }
+
+    mcProducts.producedMcParticles(mcColId,
+                                   mcParticle.origin(),
+                                   mcParticle.pdgCode(),
+                                   mcParticle.signedPt(),
+                                   mcParticle.eta(),
+                                   mcParticle.phi());
+    const int64_t row = mcProducts.producedMcParticles.lastIndex();
+    mMcParticleMap.emplace(gid, row);
+
+    // --- mother ---
+    int64_t mcMotherRow = -1;
+    if (mcParticle.has_fMcMother()) {
+      auto mother = mcParticle.template fMcMother_as<T3>();
+      const int64_t motherGid = mother.globalIndex();
+      auto itM = mMcMotherMap.find(motherGid);
+      if (itM != mMcMotherMap.end()) {
+        mcMotherRow = itM->second;
+      } else {
+        mcProducts.producedMothers(mother.origin(),
+                                   mother.pdgCode(),
+                                   mother.signedPt(),
+                                   mother.eta(),
+                                   mother.phi());
+        mcMotherRow = mcProducts.producedMothers.lastIndex();
+        mMcMotherMap.emplace(motherGid, mcMotherRow);
+      }
+    }
+
+    // --- partonic mother ---
+    int64_t mcPartonicMotherRow = -1;
+    if (mcParticle.has_fMcPartMoth()) {
+      auto partonicMother = mcParticle.template fMcPartMoth_as<T4>();
+      const int64_t partonicGid = partonicMother.globalIndex();
+      auto itPM = mMcPartonicMotherMap.find(partonicGid);
+      if (itPM != mMcPartonicMotherMap.end()) {
+        mcPartonicMotherRow = itPM->second;
+      } else {
+        mcProducts.producedPartonicMothers(partonicMother.pdgCode());
+        mcPartonicMotherRow = mcProducts.producedPartonicMothers.lastIndex();
+        mMcPartonicMotherMap.emplace(partonicGid, mcPartonicMotherRow);
+      }
+    }
+
+    // exactly one FMcMotherLabels row per FMcParticles row, written here and only here
+    mcProducts.producedMcMotherLabels(mcMotherRow, mcPartonicMotherRow);
+
+    return row;
+  }
+
+  bool mRequireMcLabel = false;
+
+  std::unordered_map<int64_t, int64_t> mCollisionMap;
+  std::unordered_map<int64_t, int64_t> mMcParticleMap;
+  std::unordered_map<int64_t, int64_t> mMcMotherMap;
+  std::unordered_map<int64_t, int64_t> mMcPartonicMotherMap;
+};
+
 } // namespace o2::analysis::femto::mcbuilder
 
 #endif // PWGCF_FEMTO_CORE_MCBUILDER_H_

PWGCF/Femto/Core/mcBuilder.h

@@ -134,7 +134,7 @@ struct ConfTrackSelection : public o2::framework::ConfigurableGroup {
   std::string prefix = Prefix; // Unique prefix based on the template argument
   // configuration parameters
   o2::framework::Configurable<int> pdgCodeAbs{"pdgCodeAbs", 2212, "Absolute value of PDG code. Set sign of charge to -1 for antiparticle."};
-  o2::framework::Configurable<int> chargeAbs{"chargeAbs", 1, "Absolute value of charge (e.g. 1 for most tracks, 2 for He3). Set sign of charge to -1 for antiparticle"};
+  o2::framework::Configurable<int> chargeAbs{"chargeAbs", 1, "Absolute value of charge (e.g. 1 for most tracks, 2 for He3)"};
   o2::framework::Configurable<int> chargeSign{"chargeSign", 1, "Track charge sign: +1 for positive, -1 for negative, 0 for both"};
   // filters for kinematics
   o2::framework::Configurable<float> ptMin{"ptMin", 0.0f, "Minimum pT (GeV/c)"};
@@ -920,6 +920,41 @@ class TrackBuilderDerivedToDerived
     return idx;
   }
 
+  template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
+  void processTracksWithMc(T1& col, T2& /*trackTable*/, T3& partitionTrack1, T4& partitionTrack2, T5& cache,
+                           T6& newTrackTable, T7& newCollisionTable,
+                           T8& mcBuilder, T9 const& mcCols, T10 const& mcParticles, T11 const& mcMothers, T12 const& mcPartonicMothers, auto& mcProducts)
+  {
+    if (mLimitTrack1 > 0) {
+      auto trackSlice1 = partitionTrack1->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
+      for (auto const& track : trackSlice1) {
+        this->fillTrackWithMcLabel(track, newTrackTable, newCollisionTable, mcBuilder, mcCols, mcParticles, mcMothers, mcPartonicMothers, mcProducts);
+      }
+    }
+    if (mLimitTrack2 > 0) {
+      auto trackSlice2 = partitionTrack2->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
+      for (auto const& track : trackSlice2) {
+        this->fillTrackWithMcLabel(track, newTrackTable, newCollisionTable, mcBuilder, mcCols, mcParticles, mcMothers, mcPartonicMothers, mcProducts);
+      }
+    }
+  }
+
+  /// Same as fillTrack, but writes the matching FTrackLabels row. The indexMap
+  /// lookup happens first, so a track selected by both partitions produces
+  /// exactly one track row and exactly one label row.
+  template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+  int64_t fillTrackWithMcLabel(T1 const& track, T2& trackProducts, T3& collisionProducts,
+                               T4& mcBuilder, T5 const& mcCols, T6 const& mcParticles, T7 const& mcMothers, T8 const& mcPartonicMothers, T9& mcProducts)
+  {
+    auto index = utils::getIndex(track.globalIndex(), indexMap);
+    if (index) {
+      return index.value();
+    }
+    const int64_t idx = this->fillTrack(track, trackProducts, collisionProducts);
+    mcBuilder.fillTrackWithLabel(track, mcCols, mcParticles, mcMothers, mcPartonicMothers, mcProducts);
+    return idx;
+  }
+
   template <typename T1, typename T2, typename T3>
   int64_t getDaughterIndex(const T1& daughter, T2& trackProducts, T3& collisionProducts)
   {