[PWGCF] Add lite track and collision tables to femto framework

PWGCF/Femto/Core/cascadeBuilder.h

@@ -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/Femto/Core/collisionBuilder.h

@@ -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/femtoUtils.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/kinkBuilder.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/mcBuilder.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);