Merge branch 'AliceO2Group:master' into update-varNamesMap-in-A2

Author: ypwangg

ALICE3/TableProducer/OTF/onTheFlyDecayer.cxx

@@ -20,6 +20,7 @@
 #include "ALICE3/Core/TrackUtilities.h"
 #include "ALICE3/DataModel/tracksAlice3.h"
 
+#include <CommonConstants/PhysicsConstants.h>
 #include <Framework/AnalysisDataModel.h>
 #include <Framework/AnalysisHelpers.h>
 #include <Framework/AnalysisTask.h>
@@ -47,13 +48,19 @@
 using namespace o2;
 using namespace o2::framework;
 
-static constexpr int NumDecays = 7;
+static constexpr int NumDecays = 13;
 static constexpr int NumParameters = 1;
-static constexpr int DefaultParameters[NumDecays][NumParameters]{{1}, {1}, {1}, {1}, {1}, {1}, {1}};
+static constexpr std::array<std::array<int, NumParameters>, NumDecays> DefaultParameters{{{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}}};
 static const std::vector<std::string> parameterNames{"enable"};
 static const std::vector<std::string> particleNames{"K0s",
                                                     "Lambda",
                                                     "Anti-Lambda",
+                                                    "SigmaPlus",
+                                                    "Anti-SigmaPlus",
+                                                    "SigmaMinus",
+                                                    "Anti-SigmaMinus",
+                                                    "Xi0",
+                                                    "Anti-Xi0",
                                                     "Xi",
                                                     "Anti-Xi",
                                                     "Omega",
@@ -62,6 +69,12 @@ static const std::vector<std::string> particleNames{"K0s",
 static const std::vector<int> pdgCodes{PDG_t::kK0Short,
                                        PDG_t::kLambda0,
                                        PDG_t::kLambda0Bar,
+                                       PDG_t::kSigmaPlus,
+                                       PDG_t::kSigmaBarMinus,
+                                       PDG_t::kSigmaMinus,
+                                       PDG_t::kSigmaBarPlus,
+                                       o2::constants::physics::kXi0,
+                                       -o2::constants::physics::kXi0,
                                        PDG_t::kXiMinus,
                                        PDG_t::kXiPlusBar,
                                        PDG_t::kOmegaMinus,
@@ -78,13 +91,13 @@ struct OnTheFlyDecayer {
   Produces<aod::OTFDecayerBits> tableOTFDecayerBits;
 
   o2::upgrade::Decayer decayer;
-  Service<o2::framework::O2DatabasePDG> pdgDB;
+  Service<o2::framework::O2DatabasePDG> pdgDB{};
   HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject};
 
   Configurable<int> seed{"seed", 0, "Set seed for particle decayer"};
   Configurable<float> magneticField{"magneticField", 20., "Magnetic field (kG)"};
   Configurable<LabeledArray<int>> enabledDecays{"enabledDecays",
-                                                {DefaultParameters[0], NumDecays, NumParameters, particleNames, parameterNames},
+                                                {DefaultParameters[0].data(), NumDecays, NumParameters, particleNames, parameterNames},
                                                 "Enable option for particle to be decayed: 0 - no, 1 - yes"};
 
   std::size_t indexOffset = 0;
@@ -99,7 +112,7 @@ struct OnTheFlyDecayer {
     decayer.setSeed(seed);
     decayer.setBField(magneticField);
     for (int i = 0; i < NumDecays; ++i) {
-      if (enabledDecays->get(particleNames[i].c_str(), "enable")) {
+      if (enabledDecays->get(particleNames[i].c_str(), "enable") != 0) {
         LOG(info) << " --- Decay enabled: " << pdgCodes[i];
         mEnabledDecays.push_back(pdgCodes[i]);
       }
@@ -146,9 +159,9 @@ struct OnTheFlyDecayer {
 
       const float decayRadius = decayer.getDecayRadius();
       const float trackVelocity = o2::upgrade::computeParticleVelocity(particle.p(), pdgDB->GetParticle(particle.pdgCode())->Mass());
-      const int charge = pdgDB->GetParticle(particle.pdgCode())->Charge() / 3;
+      const int charge = static_cast<int>(pdgDB->GetParticle(particle.pdgCode())->Charge() / 3);
       float trackLength{-1.f};
-      if (!charge) {
+      if (charge == 0) {
         const float dx = particle.vx() - decayer.getSecondaryVertexX();
         const float dy = particle.vy() - decayer.getSecondaryVertexY();
         const float dz = particle.vz() - decayer.getSecondaryVertexZ();

ALICE3/TableProducer/alice3MulticharmFinder.cxx

@@ -517,13 +517,13 @@ class CascadeBuilder
       collisionBuilder.template fillCollision<system>(collisionProducts, col);
 
       auto bachelor = cascade.template bachelor_as<T7>();
-      bachelorIndex = trackBuilder.template getDaughterIndex<modes::Track::kCascadeBachelor>(bachelor, trackProducts, collisionProducts);
+      bachelorIndex = trackBuilder.template getDaughterIndex<modes::Track::kCascadeBachelor>(bachelor, trackProducts, collisionBuilder);
 
       auto posDaughter = cascade.template posTrack_as<T7>();
-      posDaughterIndex = trackBuilder.template getDaughterIndex<modes::Track::kV0Daughter>(posDaughter, trackProducts, collisionProducts);
+      posDaughterIndex = trackBuilder.template getDaughterIndex<modes::Track::kV0Daughter>(posDaughter, trackProducts, collisionBuilder);
 
       auto negDaughter = cascade.template negTrack_as<T7>();
-      negDaughterIndex = trackBuilder.template getDaughterIndex<modes::Track::kV0Daughter>(negDaughter, trackProducts, collisionProducts);
+      negDaughterIndex = trackBuilder.template getDaughterIndex<modes::Track::kV0Daughter>(negDaughter, trackProducts, collisionBuilder);
 
       fillCascade(collisionProducts, cascadeProducts, cascade, col, bachelorIndex, posDaughterIndex, negDaughterIndex);
     }
@@ -551,13 +551,13 @@ class CascadeBuilder
       collisionBuilder.template fillMcCollision<system>(collisionProducts, col, mcCols, mcProducts, mcBuilder);
 
       auto bachelor = cascade.template bachelor_as<T8>();
-      bachelorIndex = trackBuilder.template getDaughterIndex<system, modes::Track::kCascadeBachelor>(col, collisionProducts, mcCols, bachelor, trackProducts, mcParticles, mcBuilder, mcProducts);
+      bachelorIndex = trackBuilder.template getDaughterIndex<system, modes::Track::kCascadeBachelor>(col, collisionBuilder, mcCols, bachelor, trackProducts, mcParticles, mcBuilder, mcProducts);
 
       auto posDaughter = cascade.template posTrack_as<T8>();
-      posDaughterIndex = trackBuilder.template getDaughterIndex<system, modes::Track::kV0Daughter>(col, collisionProducts, mcCols, posDaughter, trackProducts, mcParticles, mcBuilder, mcProducts);
+      posDaughterIndex = trackBuilder.template getDaughterIndex<system, modes::Track::kV0Daughter>(col, collisionBuilder, mcCols, posDaughter, trackProducts, mcParticles, mcBuilder, mcProducts);
 
       auto negDaughter = cascade.template negTrack_as<T8>();
-      negDaughterIndex = trackBuilder.template getDaughterIndex<system, modes::Track::kV0Daughter>(col, collisionProducts, mcCols, negDaughter, trackProducts, mcParticles, mcBuilder, mcProducts);
+      negDaughterIndex = trackBuilder.template getDaughterIndex<system, modes::Track::kV0Daughter>(col, collisionBuilder, mcCols, negDaughter, trackProducts, mcParticles, mcBuilder, mcProducts);
 
       fillCascade(collisionProducts, cascadeProducts, cascade, col, bachelorIndex, posDaughterIndex, negDaughterIndex);
       if constexpr (modes::isEqual(cascadeType, modes::Cascade::kXi)) {

PWGCF/EbyEFluctuations/Tasks/meanPtFlucId.cxx

@@ -500,6 +500,7 @@ class CollisionSelection : public baseselection::BaseSelection<float, o2::analys
 
 struct CollisionBuilderProducts : o2::framework::ProducesGroup {
   o2::framework::Produces<o2::aod::FCols> producedCollision;
+  o2::framework::Produces<o2::aod::FLiteCols> producedLiteCollision;
   o2::framework::Produces<o2::aod::FColMasks> producedCollisionMask;
   o2::framework::Produces<o2::aod::FColPos> producedPositions;
   o2::framework::Produces<o2::aod::FColSphericities> producedSphericities;
@@ -511,6 +512,7 @@ struct CollisionBuilderProducts : o2::framework::ProducesGroup {
 struct ConfCollisionTables : o2::framework::ConfigurableGroup {
   std::string prefix = std::string("CollisionTables");
   o2::framework::Configurable<int> produceCollisions{"produceCollisions", -1, "Produce Collisions (-1: auto; 0 off; 1 on)"};
+  o2::framework::Configurable<int> produceLiteCollisions{"produceLiteCollisions", -1, "Produce Lite Collisions (-1: auto; 0 off; 1 on)"};
   o2::framework::Configurable<int> produceCollisionMasks{"produceCollisionMasks", -1, "Produce Collision Masks (-1: auto; 0 off; 1 on)"};
   o2::framework::Configurable<int> producePositions{"producePositions", -1, "Produce Positions (-1: auto; 0 off; 1 on)"};
   o2::framework::Configurable<int> produceSphericities{"produceSphericities", -1, "Produce Sphericity (-1: auto; 0 off; 1 on)"};
@@ -536,13 +538,21 @@ class CollisionBuilder
     mSubGeneratorId = confFilter.subGeneratorId.value;
 
     mProducedCollisions = utils::enableTable("FCols_001", confTable.produceCollisions.value, initContext);
+    mProducedLiteCollisions = utils::enableTable("FLiteCols_001", confTable.produceLiteCollisions.value, initContext);
     mProducedCollisionMasks = utils::enableTable("FColMasks_001", confTable.produceCollisionMasks.value, initContext);
     mProducedPositions = utils::enableTable("FColPos_001", confTable.producePositions.value, initContext);
     mProducedSphericities = utils::enableTable("FColSphericities_001", confTable.produceSphericities.value, initContext);
     mProducedMultiplicities = utils::enableTable("FColMults_001", confTable.produceMults.value, initContext);
     mProducedCentralities = utils::enableTable("FColCents_001", confTable.produceCents.value, initContext);
     mProduceQns = utils::enableTable("FColQnBins_001", confTable.produceQns.value, initContext);
-    if (mProducedCollisions || mProducedCollisionMasks || mProducedPositions || mProducedSphericities || mProducedMultiplicities || mProducedCentralities) {
+
+    if (mProducedCollisions && mProducedLiteCollisions) {
+      LOG(fatal) << "FCols and FLiteCols are mutually exclusive -- enable only one. "
+                 << "FLiteCols is meant to only replace FCols at the producer stage (for better compression in derived data); "
+                 << "use the dedicated converter task to reconstruct FCols from FLiteCols downstream.";
+    }
+
+    if (mProducedCollisions || mProducedLiteCollisions || mProducedCollisionMasks || mProducedPositions || mProducedSphericities || mProducedMultiplicities || mProducedCentralities) {
       mFillAnyTable = true;
     } else {
       LOG(info) << "No tables configured, Selection object will not be configured...";
@@ -616,17 +626,25 @@ class CollisionBuilder
     if (!mFillAnyTable) {
       return;
     }
-
     if (mCollisionAlreadyFilled) {
       return;
     }
-
     if (mProducedCollisions) {
       collisionProducts.producedCollision(col.posZ(),
                                           col.multNTracksPV(),
                                           mCollisionSelection.getCentrality(),
                                           static_cast<int8_t>(mCollisionSelection.getMagneticField()));
+
+      mCurrentCollisionIndex = collisionProducts.producedCollision.lastIndex();
+    }
+    if (mProducedLiteCollisions) {
+      collisionProducts.producedLiteCollision(o2::aod::femtocollisions::lite::binPosZ(col.posZ()),
+                                              o2::aod::femtocollisions::lite::binMult(col.multNTracksPV()),
+                                              o2::aod::femtocollisions::lite::binCent(mCollisionSelection.getCentrality()),
+                                              static_cast<int8_t>(mCollisionSelection.getMagneticField()));
+      mCurrentCollisionIndex = collisionProducts.producedLiteCollision.lastIndex();
     }
+
     if (mProducedCollisionMasks) {
       collisionProducts.producedCollisionMask(mCollisionSelection.getBitmask());
     }
@@ -673,18 +691,25 @@ class CollisionBuilder
     mcBuilder.template fillMcCollisionWithLabel<system>(mcProducts, col, mcCols);
   }
 
-  void reset() { mCollisionAlreadyFilled = false; }
+  [[nodiscard]] int64_t collisionIndex() const { return mCurrentCollisionIndex; }
+  void reset()
+  {
+    mCollisionAlreadyFilled = false;
+    mCurrentCollisionIndex = -1;
+  }
 
  private:
   CollisionSelection<SelectionHistName, FilterHistName> mCollisionSelection;
   bool mCollisionAlreadyFilled = false;
+  int64_t mCurrentCollisionIndex = -1;
   int mRunNumber = -1;
   std::string mGrpPath = std::string("");
   int mMagFieldForced = 0;
   int mMagField = 0;
   int mSubGeneratorId = -1;
   bool mFillAnyTable = false;
   bool mProducedCollisions = false;
+  bool mProducedLiteCollisions = false;
   bool mProducedCollisionMasks = false;
   bool mProducedPositions = false;
   bool mProducedSphericities = false;

PWGCF/Femto/Core/cascadeBuilder.h

@@ -24,9 +24,11 @@
 
 #include <TPDGCode.h>
 
+#include <algorithm>
 #include <cmath>
 #include <concepts>
 #include <cstdint>
+#include <limits>
 #include <optional>
 #include <unordered_map>
 
@@ -228,6 +230,56 @@ inline int signum(T x)
   return (T(0) < x) - (x < T(0));
 }
 
+template <typename T>
+inline T binLinear(float value, float lo, float hi, float step)
+{
+  float v = std::clamp(value, lo, hi);
+  auto idx = static_cast<int64_t>(std::round((v - lo) / step));
+  auto maxIdx = static_cast<int64_t>(std::numeric_limits<T>::max()) - static_cast<int64_t>(std::numeric_limits<T>::min());
+  idx = std::clamp(idx, static_cast<int64_t>(0), maxIdx);
+  return static_cast<T>(idx + std::numeric_limits<T>::min());
+}
+
+template <typename T>
+inline float unBinLinear(T binned, float lo, float step)
+{
+  auto idx = static_cast<int64_t>(binned) - static_cast<int64_t>(std::numeric_limits<T>::min());
+  return lo + static_cast<float>(idx) * step;
+}
+
+template <typename T>
+inline T binLogSigned(float signedValue, float magMin, float magMax)
+{
+  static_assert(std::is_unsigned_v<T>, "binLogSigned requires an unsigned storage type");
+  constexpr uint32_t TotalBits = sizeof(T) * 8;
+  constexpr uint32_t HalfLevels = 1u << (TotalBits - 1);
+  uint32_t sign = (signedValue < 0.f) ? 1u : 0u;
+  float mag = std::clamp(std::fabs(signedValue), magMin, magMax);
+  float logLo = std::log(magMin);
+  float logHi = std::log(magMax);
+  float step = (logHi - logLo) / static_cast<float>(HalfLevels - 1);
+  auto idx = static_cast<uint32_t>(std::round((std::log(mag) - logLo) / step));
+  idx = std::clamp(idx, 0u, HalfLevels - 1);
+  return static_cast<T>((sign << (TotalBits - 1)) | idx);
+}
+
+template <typename T>
+inline float unBinLogSigned(T binned, float magMin, float magMax)
+{
+  constexpr uint32_t TotalBits = sizeof(T) * 8;
+  constexpr uint32_t HalfLevels = 1u << (TotalBits - 1);
+  constexpr T SignMask = static_cast<T>(1u << (TotalBits - 1));
+  constexpr T MagMask = static_cast<T>(SignMask - 1);
+  float sign = (binned & SignMask) ? -1.f : 1.f;
+  uint32_t idx = binned & MagMask;
+  float logLo = std::log(magMin);
+  float logHi = std::log(magMax);
+  float step = (logHi - logLo) / static_cast<float>(HalfLevels - 1);
+  float mag = std::exp(logLo + static_cast<float>(idx) * step);
+  return sign * mag;
+}
+
 }; // namespace utils
 }; // namespace o2::analysis::femto
+//
 #endif // PWGCF_FEMTO_CORE_FEMTOUTILS_H_

PWGCF/Femto/Core/collisionBuilder.h

@@ -547,7 +547,7 @@ class KinkBuilder
       collisionBuilder.template fillCollision<system>(collisionProducts, col);
 
       auto daughter = kink.template trackDaug_as<T7>();
-      daughterIndex = trackBuilder.template getDaughterIndex<modes::Track::kKinkDaughter>(daughter, trackProducts, collisionProducts);
+      daughterIndex = trackBuilder.template getDaughterIndex<modes::Track::kKinkDaughter>(daughter, trackProducts, collisionBuilder);
       if constexpr (modes::isEqual(kinkType, modes::Kink::kSigma)) {
         fillSigma(collisionProducts, kinkProducts, kink, daughterIndex);
       }
@@ -581,7 +581,7 @@ class KinkBuilder
       collisionBuilder.template fillMcCollision<system>(collisionProducts, col, mcCols, mcProducts, mcBuilder);
 
       auto daughter = kink.template trackDaug_as<T8>();
-      daughterIndex = trackBuilder.template getDaughterIndex<system, modes::Track::kKinkDaughter>(col, collisionProducts, mcCols, daughter, trackProducts, mcParticles, mcBuilder, mcProducts);
+      daughterIndex = trackBuilder.template getDaughterIndex<system, modes::Track::kKinkDaughter>(col, collisionBuilder, mcCols, daughter, trackProducts, mcParticles, mcBuilder, mcProducts);
 
       if constexpr (modes::isEqual(kinkType, modes::Kink::kSigma)) {
         fillSigma(collisionProducts, kinkProducts, kink, daughterIndex);

PWGCF/Femto/Core/femtoUtils.h

@@ -162,6 +162,7 @@ class McBuilder
   void fillMcCollisionWithLabel(T1& mcProducts, T2 const& col, T3 const& /*mcCols*/)
   {
     if (!mProduceCollisionLabels) {
+      mcProducts.producedCollisionLabels(-1);
       return;
     }
     // Case: This reconstructed collision has an MC collision
@@ -265,6 +266,7 @@ class McBuilder
   void fillMcSigmaWithLabel(T1 const& col, T2 const& mcCols, T3 const& sigmaDaughter, T4 const& mcParticles, T5& mcProducts)
   {
     if (!mProduceSigmaLabels) {
+      mcProducts.producedSigmaLabels(-1);
       return;
     }
     fillMcLabelGeneric<system>(col, mcCols, sigmaDaughter, mcParticles, mcProducts, [](auto& prod, int64_t p) { prod.producedSigmaLabels(p); }, true);
@@ -274,6 +276,7 @@ class McBuilder
   void fillMcSigmaPlusWithLabel(T1 const& col, T2 const& mcCols, T3 const& sigmaPlusDaughter, T4 const& mcParticles, T5& mcProducts)
   {
     if (!mProduceSigmaPlusLabels) {
+      mcProducts.producedSigmaPlusLabels(-1);
       return;
     }
     fillMcLabelGeneric<system>(col, mcCols, sigmaPlusDaughter, mcParticles, mcProducts, [](auto& prod, int64_t p) { prod.producedSigmaPlusLabels(p); }, true);