From ec14c9ef39073f180e02b76e82de3da79783b5d0 Mon Sep 17 00:00:00 2001 From: Anton Riedel Date: Sun, 26 Jul 2026 11:19:00 +0200 Subject: [PATCH 1/7] Feat: add lite tables for all particles --- PWGCF/Femto/Core/femtoUtils.h | 39 ++++ PWGCF/Femto/DataModel/FemtoTables.h | 266 +++++++++++++++++++++++++--- 2 files changed, 281 insertions(+), 24 deletions(-) diff --git a/PWGCF/Femto/Core/femtoUtils.h b/PWGCF/Femto/Core/femtoUtils.h index de8b24d3da9..bab26c453e5 100644 --- a/PWGCF/Femto/Core/femtoUtils.h +++ b/PWGCF/Femto/Core/femtoUtils.h @@ -24,6 +24,8 @@ #include +#include + #include #include #include @@ -279,6 +281,43 @@ inline float unBinLogSigned(T binned, float magMin, float magMax) return sign * mag; } +template +inline int unBinSign(T binned) +{ + static_assert(std::is_unsigned_v, "unBinSign requires an unsigned storage type"); + constexpr uint64_t TotalBits = sizeof(T) * 8; + constexpr T SignMask = static_cast(uint64_t{1} << (TotalBits - 1)); + return (binned & SignMask) ? -1 : 1; +} + +template +inline T binLogUnsigned(float value, float magMin, float magMax) +{ + static_assert(std::is_unsigned_v, "binLogUnsigned requires an unsigned storage type"); + constexpr uint64_t TotalBits = sizeof(T) * 8; + constexpr uint64_t Levels = uint64_t{1} << TotalBits; // number of representable values, e.g. 65536 for uint16_t + float mag = std::clamp(value, magMin, magMax); + float logLo = std::log(magMin); + float logHi = std::log(magMax); + float step = (logHi - logLo) / static_cast(Levels - 1); + auto idx = static_cast(std::round((std::log(mag) - logLo) / step)); + idx = std::clamp(idx, uint64_t{0}, Levels - 1); + return static_cast(idx); +} + +template +inline float unBinLogUnsigned(T binned, float magMin, float magMax) +{ + constexpr uint64_t TotalBits = sizeof(T) * 8; + constexpr uint64_t Levels = uint64_t{1} << TotalBits; + uint64_t idx = binned; + float logLo = std::log(magMin); + float logHi = std::log(magMax); + float step = (logHi - logLo) / static_cast(Levels - 1); + float mag = std::exp(logLo + static_cast(idx) * step); + return mag; +} + }; // namespace utils }; // namespace o2::analysis::femto // diff --git a/PWGCF/Femto/DataModel/FemtoTables.h b/PWGCF/Femto/DataModel/FemtoTables.h index ef5b66c6cb0..f64d3704a53 100644 --- a/PWGCF/Femto/DataModel/FemtoTables.h +++ b/PWGCF/Femto/DataModel/FemtoTables.h @@ -51,11 +51,11 @@ namespace lite { constexpr float PosZMin = -20.f; constexpr float PosZMax = 20.f; -constexpr float PosZStep = 0.5f; // cm +constexpr float PosZStep = 0.5f; // bin vtz in 0.5cm steps constexpr float CentMin = 0.f; constexpr float CentMax = 100.f; -constexpr float CentStep = 0.5f; // percent -constexpr float MultStep = 1.f; // rounded to nearest integer +constexpr float CentStep = 0.5f; // bin centrality in 0.5% steps +constexpr float MultStep = 1.f; // round multiplicity to nearest integer inline uint8_t binPosZ(float posZ) { return o2::analysis::femto::utils::binLinear(posZ, PosZMin, PosZMax, PosZStep); } inline float unBinPosZ(uint8_t binned) { return o2::analysis::femto::utils::unBinLinear(binned, PosZMin, PosZStep); } @@ -63,7 +63,7 @@ inline float unBinPosZ(uint8_t binned) { return o2::analysis::femto::utils::unBi inline uint8_t binCent(float cent) { return o2::analysis::femto::utils::binLinear(cent, CentMin, CentMax, CentStep); } inline float unBinCent(uint8_t binned) { return o2::analysis::femto::utils::unBinLinear(binned, CentMin, CentStep); } -inline uint16_t binMult(float mult) { return o2::analysis::femto::utils::binLinear(mult, 0.f, 65535.f, MultStep); } // use full range of uint16_6 +inline uint16_t binMult(float mult) { return o2::analysis::femto::utils::binLinear(mult, 0.f, 65535.f, MultStep); } // use full range of uint16_t inline float unBinMult(uint16_t binned) { return o2::analysis::femto::utils::unBinLinear(binned, 0.f, MultStep); } DECLARE_SOA_COLUMN(BinnedPosZ, binnedPosZ, uint8_t); @@ -154,6 +154,7 @@ namespace stored { // static columns DECLARE_SOA_INDEX_COLUMN(FCol, fCol); //! collision index of femto collision table +DECLARE_SOA_INDEX_COLUMN(FLiteCol, fLiteCol); //! collision index of femto collision table DECLARE_SOA_COLUMN(SignedPt, signedPt, float); //! signed pt DECLARE_SOA_COLUMN(Pt, pt, float); //! pt DECLARE_SOA_COLUMN(Eta, eta, float); //! eta @@ -197,16 +198,16 @@ DECLARE_SOA_DYNAMIC_COLUMN(Theta, theta, //! theta namespace lite { -constexpr float EtaMin = -1.f; -constexpr float EtaMax = 1.f; +constexpr float EtaMin = -1.2f; // Eta coverage of ITS +constexpr float EtaMax = 1.2f; constexpr float EtaStep = (EtaMax - EtaMin) / 65536.f; constexpr float PhiMin = 0.f; -constexpr float PhiMax = constants::math::TwoPI; +constexpr float PhiMax = constants::math::TwoPI; // phi is bound on [0,2pi) constexpr float PhiStep = (PhiMax - PhiMin) / 65536.f; -constexpr float PtMagMin = 0.1f; -constexpr float PtMagMax = 6.f; +constexpr float PtMagMin = 0.1f; // lowest pt cut for pions is usually 0.12-0.14 GeV/c +constexpr float PtMagMax = 6.f; // sensible upper limit for pt inline uint16_t binEta(float eta) { return o2::analysis::femto::utils::binLinear(eta, EtaMin, EtaMax, EtaStep); } inline float unBinEta(uint16_t binned) { return o2::analysis::femto::utils::unBinLinear(binned, EtaMin, EtaStep); } @@ -214,24 +215,28 @@ inline float unBinEta(uint16_t binned) { return o2::analysis::femto::utils::unBi inline uint16_t binPhi(float phi) { return o2::analysis::femto::utils::binLinear(phi, PhiMin, PhiMax, PhiStep); } inline float unBinPhi(uint16_t binned) { return o2::analysis::femto::utils::unBinLinear(binned, PhiMin, PhiStep); } -inline uint16_t binPt(float signedPt) { return o2::analysis::femto::utils::binLogSigned(signedPt, PtMagMin, PtMagMax); } -inline float unBinPt(uint16_t binned) { return o2::analysis::femto::utils::unBinLogSigned(binned, PtMagMin, PtMagMax); } +inline uint16_t binSignedPt(float signedPt) { return o2::analysis::femto::utils::binLogSigned(signedPt, PtMagMin, PtMagMax); } +inline float unBinSignedPt(uint16_t binned) { return o2::analysis::femto::utils::unBinLogSigned(binned, PtMagMin, PtMagMax); } + +inline uint16_t binUnsignedPt(float unsignedPt) { return o2::analysis::femto::utils::binLogUnsigned(unsignedPt, PtMagMin, PtMagMax); } +inline float unBinUnsignedPt(uint16_t binned) { return o2::analysis::femto::utils::unBinLogUnsigned(binned, PtMagMin, PtMagMax); } DECLARE_SOA_COLUMN(SignedBinnedPt, signedBinnedPt, uint16_t); +DECLARE_SOA_COLUMN(UnsignedBinnedPt, unsignedBinnedPt, uint16_t); DECLARE_SOA_COLUMN(BinnedEta, binnedEta, uint16_t); DECLARE_SOA_COLUMN(BinnedPhi, binnedPhi, uint16_t); DECLARE_SOA_DYNAMIC_COLUMN(Sign, sign, [](uint16_t signedBinnedPt) -> int { - return (signedBinnedPt & 0x8000u) ? -1 : 1; // top bit, matches binLogSigned + return o2::analysis::femto::utils::unBinSign(signedBinnedPt); }); DECLARE_SOA_DYNAMIC_COLUMN(SignedPt, signedPt, [](uint16_t signedBinnedPt) -> float { - return unBinPt(signedBinnedPt); + return unBinSignedPt(signedBinnedPt); }); -DECLARE_SOA_DYNAMIC_COLUMN(Pt, pt, - [](uint16_t signedBinnedPt) -> float { - return std::fabs(unBinPt(signedBinnedPt)); +DECLARE_SOA_DYNAMIC_COLUMN(UnsignedPt, unsignedPt, + [](uint16_t unsignedBinnedPt) -> float { + return unBinUnsignedPt(unsignedBinnedPt); }); DECLARE_SOA_DYNAMIC_COLUMN(Eta, eta, [](uint16_t binnedEta) -> float { @@ -344,12 +349,11 @@ using StoredFTracks = StoredFTracks_001; // table for basic track information, compressed/binned kinematics DECLARE_SOA_TABLE_STAGED_VERSIONED(FLiteTracks_001, "FLITETRACKS", 1, //! femto tracks, binned kinematics o2::soa::Index<>, - femtobase::stored::FColId, + femtobase::stored::FLiteColId, femtobase::lite::SignedBinnedPt, femtobase::lite::BinnedEta, femtobase::lite::BinnedPhi, femtobase::lite::Sign, - femtobase::lite::Pt, femtobase::lite::SignedPt, femtobase::lite::Eta, femtobase::lite::Phi); @@ -554,6 +558,42 @@ DECLARE_SOA_DYNAMIC_COLUMN(DecayVtx, decayVtx, //! distance of decay DECLARE_SOA_INDEX_COLUMN_FULL(PosDau, posDau, int32_t, FTracks, "_PosDau"); //! index column for positive daughter track DECLARE_SOA_INDEX_COLUMN_FULL(NegDau, negDau, int32_t, FTracks, "_NegDau"); //! index column for negative daughter track +namespace lite +{ + +constexpr float LambdaMassMin = 1.05f; // Kinematic lower limit +constexpr float LambdaMassMax = 1.30f; +constexpr float LambdaMassStep = (LambdaMassMax - LambdaMassMin) / 65536.f; + +// K0short: PDG mass 0.497611 GeV, ±100 MeV window +constexpr float K0shortMassMin = 0.497611f - 0.1f; // = 0.397611 +constexpr float K0shortMassMax = 0.497611f + 0.1f; // = 0.597611 +constexpr float K0shortMassStep = (K0shortMassMax - K0shortMassMin) / 65536.f; + +inline uint16_t binLambdaMass(float lambdaMass) { return o2::analysis::femto::utils::binLinear(lambdaMass, LambdaMassMin, LambdaMassMax, LambdaMassStep); } +inline float unBinLambdaMass(uint16_t binned) { return o2::analysis::femto::utils::unBinLinear(binned, LambdaMassMin, LambdaMassStep); } + +inline uint16_t binK0shortMass(float lambdaMass) { return o2::analysis::femto::utils::binLinear(lambdaMass, K0shortMassMin, K0shortMassMax, K0shortMassStep); } +inline float unBinK0shortMass(uint16_t binned) { return o2::analysis::femto::utils::unBinLinear(binned, K0shortMassMin, K0shortMassStep); } + +DECLARE_SOA_COLUMN(BinnedLambdaMass, binnedLambdaMass, uint16_t); +DECLARE_SOA_COLUMN(BinnedK0shortMass, binnedK0shortMass, uint16_t); + +DECLARE_SOA_DYNAMIC_COLUMN(LambdaMass, lambdaMass, + [](uint16_t binnedLambdaMass) -> float { + return unBinLambdaMass(binnedLambdaMass); + }); + +DECLARE_SOA_DYNAMIC_COLUMN(K0shortMass, k0shortMass, + [](uint16_t binnedK0shortMass) -> float { + return unBinK0shortMass(binnedK0shortMass); + }); + +// index for lite track table +DECLARE_SOA_INDEX_COLUMN_FULL(PosDau, posDau, int32_t, FLiteTracks, "_PosDau"); //! index column for positive daughter track +DECLARE_SOA_INDEX_COLUMN_FULL(NegDau, negDau, int32_t, FLiteTracks, "_NegDau"); //! index column for negative daughter track + +} // namespace lite } // namespace femtov0s // table for basic lambda information @@ -576,6 +616,25 @@ DECLARE_SOA_TABLE_STAGED_VERSIONED(FLambdas_001, "FLAMBDA", 1, //! femto lambdas using FLambdas = FLambdas_001; using StoredFLambdas = StoredFLambdas_001; +// table for basic lambda information with compressed/binned kinematics +DECLARE_SOA_TABLE_STAGED_VERSIONED(FLiteLambdas_001, "FLITELAMBDAS", 1, + o2::soa::Index<>, + femtobase::stored::FLiteColId, + femtobase::lite::SignedBinnedPt, + femtobase::lite::BinnedEta, + femtobase::lite::BinnedPhi, + femtov0s::lite::BinnedLambdaMass, + femtov0s::lite::PosDauId, + femtov0s::lite::NegDauId, + femtobase::lite::Sign, + femtobase::lite::SignedPt, + femtobase::lite::Eta, + femtobase::lite::Phi, + femtov0s::lite::LambdaMass); +using FLiteLambdas = FLiteLambdas_001; +using FLiteLambda = FLiteLambdas::iterator; +using StoredFLiteLambdas = StoredFLiteLambdas_001; + DECLARE_SOA_TABLE_STAGED_VERSIONED(FLambdaMasks_001, "FLAMBDAMASK", 1, //! lambda masks femtov0s::Mask); using FLambdaMasks = FLambdaMasks_001; @@ -612,6 +671,24 @@ DECLARE_SOA_TABLE_STAGED_VERSIONED(FK0shorts_001, "FK0SHORT", 1, //! femto k0sho using FK0shorts = FK0shorts_001; using StoredFK0shorts = StoredFK0shorts_001; +// table for basic lambda information with compressed/binned kinematics +DECLARE_SOA_TABLE_STAGED_VERSIONED(FLiteK0shorts_001, "FLITEK0SHORT", 1, + o2::soa::Index<>, + femtobase::stored::FLiteColId, + femtobase::lite::UnsignedBinnedPt, + femtobase::lite::BinnedEta, + femtobase::lite::BinnedPhi, + femtov0s::lite::BinnedK0shortMass, + femtov0s::lite::PosDauId, + femtov0s::lite::NegDauId, + femtobase::lite::UnsignedPt, + femtobase::lite::Eta, + femtobase::lite::Phi, + femtov0s::lite::K0shortMass); +using FLiteK0shorts = FLiteK0shorts_001; +using FLiteK0short = FLiteK0shorts::iterator; +using StoredFLiteK0shorts = StoredFLiteK0shorts_001; + DECLARE_SOA_TABLE_STAGED_VERSIONED(FK0shortMasks_001, "FK0SHORTMASK", 1, //! k0short masks femtov0s::Mask); using FK0shortMasks = FK0shortMasks_001; @@ -646,13 +723,36 @@ DECLARE_SOA_COLUMN(TransRadius, transRadius, float); //! Transverse decay radius // id column for charged daughter track DECLARE_SOA_INDEX_COLUMN_FULL(ChaDau, chaDau, int32_t, FTracks, "_ChaDau"); //! + +namespace lite +{ +// Sigma (using a shared window covering both Sigma- 1.19745 and Sigma+ 1.18937): +// centered on the midpoint ~1.19341, +-100 MeV comfortably covers both species + margin +constexpr float SigmaMassMin = 1.19341f - 0.1f; // = 1.09341 +constexpr float SigmaMassMax = 1.19341f + 0.1f; // = 1.29341 +constexpr float SigmaMassStep = (SigmaMassMax - SigmaMassMin) / 65536.f; + +inline uint16_t binSigmaMass(float mass) { return o2::analysis::femto::utils::binLinear(mass, SigmaMassMin, SigmaMassMax, SigmaMassStep); } +inline float unBinSigmaMass(uint16_t binned) { return o2::analysis::femto::utils::unBinLinear(binned, SigmaMassMin, SigmaMassStep); } + +DECLARE_SOA_COLUMN(BinnedSigmaMass, binnedSigmaMass, uint16_t); + +DECLARE_SOA_DYNAMIC_COLUMN(SigmaMass, sigmaMass, + [](uint16_t binnedSigmaMass) -> float { + return unBinSigmaMass(binnedSigmaMass); + }); + +// index for lite track table +DECLARE_SOA_INDEX_COLUMN_FULL(ChaDau, chaDau, int32_t, FLiteTracks, "_ChaDau"); //! charged daughter index, into FLiteTracks +} // namespace lite + } // namespace femtokinks // table for basic sigma information DECLARE_SOA_TABLE_STAGED_VERSIONED(FSigmas_001, "FSIGMA", 1, o2::soa::Index<>, - femtobase::stored::FColId, // use sign to differentiate between sigma minus (-1) and anti sigma minus (+1) - femtobase::stored::SignedPt, + femtobase::stored::FColId, + femtobase::stored::SignedPt, // use sign to differentiate between sigma minus (-1) and anti sigma minus (+1) femtobase::stored::Eta, femtobase::stored::Phi, femtobase::stored::Mass, @@ -668,8 +768,8 @@ DECLARE_SOA_TABLE_STAGED_VERSIONED(FSigmas_001, "FSIGMA", 1, // table for basic sigma information DECLARE_SOA_TABLE_STAGED_VERSIONED(FSigmas_002, "FSIGMA", 2, o2::soa::Index<>, - femtobase::stored::FColId, // use sign to differentiate between sigma minus (-1) and anti sigma minus (+1) - femtobase::stored::SignedPt, + femtobase::stored::FColId, + femtobase::stored::SignedPt, // use sign to differentiate between sigma minus (-1) and anti sigma minus (+1) femtobase::stored::Eta, femtobase::stored::Phi, femtobase::stored::Mass, @@ -682,10 +782,32 @@ DECLARE_SOA_TABLE_STAGED_VERSIONED(FSigmas_002, "FSIGMA", 2, femtobase::dynamic::Pz, femtobase::dynamic::Theta); using FSigmas = FSigmas_002; +using FSigma = FSigmas::iterator; +using StoredFSigmas = StoredFSigmas_002; + +// table for basic sigma information, compressed/binned kinematics +DECLARE_SOA_TABLE_STAGED_VERSIONED(FLiteSigmas_001, "FLITESIGMA", 1, + o2::soa::Index<>, + femtobase::stored::FLiteColId, + femtobase::lite::SignedBinnedPt, + femtobase::lite::BinnedEta, + femtobase::lite::BinnedPhi, + femtokinks::lite::BinnedSigmaMass, + femtokinks::lite::ChaDauId, + femtobase::lite::Sign, + femtobase::lite::SignedPt, + femtobase::lite::Eta, + femtobase::lite::Phi, + femtokinks::lite::SigmaMass); +using FLiteSigmas = FLiteSigmas_001; +using FLiteSigma = FLiteSigmas::iterator; +using StoredFLiteSigmas = StoredFLiteSigmas_001; DECLARE_SOA_TABLE_STAGED_VERSIONED(FSigmaMasks_001, "FSIGMAMASKS", 1, femtokinks::Mask); using FSigmaMasks = FSigmaMasks_001; +using FSigmamask = FSigmaMasks::iterator; +using StoredFSigmaMasks = StoredFSigmaMasks_001; DECLARE_SOA_TABLE_STAGED_VERSIONED(FSigmaExtras_001, "FSIGMAEXTRAS", 1, femtokinks::KinkAngle, @@ -701,8 +823,8 @@ using FSigmaExtras = FSigmaExtras_001; // table for basic sigma plus information DECLARE_SOA_TABLE_STAGED_VERSIONED(FSigmaPlus_001, "FSIGMAPLUS", 1, o2::soa::Index<>, - femtobase::stored::FColId, // use sign to differentiate between sigma minus (-1) and anti sigma minus (+1) - femtobase::stored::SignedPt, + femtobase::stored::FColId, + femtobase::stored::SignedPt, // use sign to differentiate between sigma minus (-1) and anti sigma minus (+1) femtobase::stored::Eta, femtobase::stored::Phi, femtobase::stored::Mass, @@ -715,6 +837,26 @@ DECLARE_SOA_TABLE_STAGED_VERSIONED(FSigmaPlus_001, "FSIGMAPLUS", 1, femtobase::dynamic::Pz, femtobase::dynamic::Theta); using FSigmaPlus = FSigmaPlus_001; +using FSigmaPlusRow = FSigmaPlus::iterator; +using StoredFSigmaPlus = StoredFSigmaPlus_001; + +// table for basic sigma plus information, compressed/binned kinematics +DECLARE_SOA_TABLE_STAGED_VERSIONED(FLiteSigmaPlus_001, "FLITESIGMAPLUS", 1, + o2::soa::Index<>, + femtobase::stored::FLiteColId, + femtobase::lite::SignedBinnedPt, + femtobase::lite::BinnedEta, + femtobase::lite::BinnedPhi, + femtokinks::lite::BinnedSigmaMass, + femtokinks::lite::ChaDauId, + femtobase::lite::Sign, + femtobase::lite::SignedPt, + femtobase::lite::Eta, + femtobase::lite::Phi, + femtokinks::lite::SigmaMass); +using FLiteSigmaPlus = FLiteSigmaPlus_001; +using FLiteSigmaPlusRow = FLiteSigmaPlus::iterator; +using StoredFLiteSigmaPlus = StoredFLiteSigmaPlus_001; DECLARE_SOA_TABLE_STAGED_VERSIONED(FSigmaPlusMasks_001, "FSIGMAPLUSMASKS", 1, femtokinks::Mask); @@ -752,6 +894,40 @@ DECLARE_SOA_COLUMN(LambdaDcaToPv, lambdaDcaToPv, float); //! Lambda tr // following same style as strangeness tables were we do not store the id of the lambda, but its daughters DECLARE_SOA_INDEX_COLUMN_FULL(Bachelor, bachelor, int32_t, FTracks, "_Bachelor"); //! bachelor id +namespace lite +{ + +// Xi-: PDG mass 1.32171 GeV, ±100 MeV window +constexpr float XiMassMin = 1.32171f - 0.1f; // = 1.22171 +constexpr float XiMassMax = 1.32171f + 0.1f; // = 1.42171 +constexpr float XiMassStep = (XiMassMax - XiMassMin) / 65536.f; + +// Omega-: PDG mass 1.67245 GeV, ±100 MeV window +constexpr float OmegaMassMin = 1.67245f - 0.1f; // = 1.57245 +constexpr float OmegaMassMax = 1.67245f + 0.1f; // = 1.77245 +constexpr float OmegaMassStep = (OmegaMassMax - OmegaMassMin) / 65536.f; + +inline uint16_t binXiMass(float mass) { return o2::analysis::femto::utils::binLinear(mass, XiMassMin, XiMassMax, XiMassStep); } +inline float unBinXiMass(uint16_t binned) { return o2::analysis::femto::utils::unBinLinear(binned, XiMassMin, XiMassStep); } + +inline uint16_t binOmegaMass(float mass) { return o2::analysis::femto::utils::binLinear(mass, OmegaMassMin, OmegaMassMax, OmegaMassStep); } +inline float unBinOmegaMass(uint16_t binned) { return o2::analysis::femto::utils::unBinLinear(binned, OmegaMassMin, OmegaMassStep); } + +DECLARE_SOA_COLUMN(BinnedXiMass, binnedXiMass, uint16_t); +DECLARE_SOA_COLUMN(BinnedOmegaMass, binnedOmegaMass, uint16_t); + +DECLARE_SOA_DYNAMIC_COLUMN(XiMass, xiMass, + [](uint16_t binnedXiMass) -> float { + return unBinXiMass(binnedXiMass); + }); +DECLARE_SOA_DYNAMIC_COLUMN(OmegaMass, omegaMass, + [](uint16_t binnedOmegaMass) -> float { + return unBinOmegaMass(binnedOmegaMass); + }); + +// index for lite track table +DECLARE_SOA_INDEX_COLUMN_FULL(Bachelor, bachelor, int32_t, FLiteTracks, "_Bachelor"); //! bachelor index, into FLiteTracks +} // namespace lite } // namespace femtocascades DECLARE_SOA_TABLE_STAGED_VERSIONED(FXis_001, "FXI", 1, //! femto xis @@ -772,8 +948,29 @@ DECLARE_SOA_TABLE_STAGED_VERSIONED(FXis_001, "FXI", 1, //! femto xis femtobase::dynamic::Pz, femtobase::dynamic::Theta); using FXis = FXis_001; +using FXi = FXis::iterator; using StoredFXis = StoredFXis_001; +// table for basic xi information, compressed/binned kinematics +DECLARE_SOA_TABLE_STAGED_VERSIONED(FLiteXis_001, "FLITEXI", 1, + o2::soa::Index<>, + femtobase::stored::FLiteColId, + femtobase::lite::SignedBinnedPt, + femtobase::lite::BinnedEta, + femtobase::lite::BinnedPhi, + femtocascades::lite::BinnedXiMass, + femtocascades::lite::BachelorId, + femtov0s::lite::PosDauId, + femtov0s::lite::NegDauId, + femtobase::lite::Sign, + femtobase::lite::SignedPt, + femtobase::lite::Eta, + femtobase::lite::Phi, + femtocascades::lite::XiMass); +using FLiteXis = FLiteXis_001; +using FLiteXi = FLiteXis::iterator; +using StoredFLiteXis = StoredFLiteXis_001; + DECLARE_SOA_TABLE_STAGED_VERSIONED(FXiMasks_001, "FXIMASK", 1, //! xi masks femtocascades::Mask); using FXiMasks = FXiMasks_001; @@ -809,8 +1006,29 @@ DECLARE_SOA_TABLE_STAGED_VERSIONED(FOmegas_001, "FOMEGA", 1, //! femto omegas femtobase::dynamic::Pz, femtobase::dynamic::Theta); using FOmegas = FOmegas_001; +using FOmega = FOmegas::iterator; using StoredFOmegas = StoredFOmegas_001; +// table for basic omega information, compressed/binned kinematics +DECLARE_SOA_TABLE_STAGED_VERSIONED(FLiteOmegas_001, "FLITEOMEGA", 1, + o2::soa::Index<>, + femtobase::stored::FLiteColId, + femtobase::lite::SignedBinnedPt, + femtobase::lite::BinnedEta, + femtobase::lite::BinnedPhi, + femtocascades::lite::BinnedOmegaMass, + femtocascades::lite::BachelorId, + femtov0s::lite::PosDauId, + femtov0s::lite::NegDauId, + femtobase::lite::Sign, + femtobase::lite::SignedPt, + femtobase::lite::Eta, + femtobase::lite::Phi, + femtocascades::lite::OmegaMass); +using FLiteOmegas = FLiteOmegas_001; +using FLiteOmega = FLiteOmegas::iterator; +using StoredFLiteOmegas = StoredFLiteOmegas_001; + DECLARE_SOA_TABLE_STAGED_VERSIONED(FOmegaMasks_001, "FOMEGAMASK", 1, //! omega masks femtocascades::Mask); using FOmegaMasks = FOmegaMasks_001; From ab335bf81373a179a6744a0f1de68f7b53a72eb7 Mon Sep 17 00:00:00 2001 From: Anton Riedel Date: Sun, 26 Jul 2026 12:16:45 +0200 Subject: [PATCH 2/7] Feat: finish adding lite tables --- PWGCF/Femto/Core/cascadeBuilder.h | 77 ++++++++++++++-- PWGCF/Femto/Core/collisionBuilder.h | 9 ++ PWGCF/Femto/Core/kinkBuilder.h | 83 ++++++++++++++--- PWGCF/Femto/Core/trackBuilder.h | 20 +++- PWGCF/Femto/Core/v0Builder.h | 85 ++++++++++++++--- PWGCF/Femto/TableProducer/femtoProducer.cxx | 24 +++-- .../femtoProducerLiteConverter.cxx | 92 +++++++++++++++++-- 7 files changed, 336 insertions(+), 54 deletions(-) diff --git a/PWGCF/Femto/Core/cascadeBuilder.h b/PWGCF/Femto/Core/cascadeBuilder.h index dd1d2d4b15b..ea63069aacc 100644 --- a/PWGCF/Femto/Core/cascadeBuilder.h +++ b/PWGCF/Femto/Core/cascadeBuilder.h @@ -443,9 +443,11 @@ class CascadeSelection : public baseselection::BaseSelection producedXis; + o2::framework::Produces producedLiteXis; o2::framework::Produces producedXiMasks; o2::framework::Produces producedXiExtras; o2::framework::Produces producedOmegas; + o2::framework::Produces producedLiteOmegas; o2::framework::Produces producedOmegaMasks; o2::framework::Produces producedOmegaExtras; }; @@ -453,9 +455,11 @@ struct CascadeBuilderProducts : o2::framework::ProducesGroup { struct ConfCascadeTables : o2::framework::ConfigurableGroup { std::string prefix = std::string("CascadeTables"); o2::framework::Configurable produceXis{"produceXis", -1, "Produce Xis (-1: auto; 0 off; 1 on)"}; + o2::framework::Configurable produceLiteXis{"produceLiteXis", -1, "Produce LiteXis (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable produceXiMasks{"produceXiMasks", -1, "Produce XiMasks (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable produceXiExtras{"produceXiExtras", -1, "Produce XiExtras (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable produceOmegas{"produceOmegas", -1, "Produce Omegas (-1: auto; 0 off; 1 on)"}; + o2::framework::Configurable produceLiteOmegas{"produceLiteOmegas", -1, "Produce LiteOmegas (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable produceOmegaMasks{"produceOmegaMasks", -1, "Produce OmegaMasks (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable produceOmegaExtras{"produceOmegaExtras", -1, "Produce OmegaExtras (-1: auto; 0 off; 1 on)"}; }; @@ -467,23 +471,58 @@ class CascadeBuilder CascadeBuilder() = default; ~CascadeBuilder() = default; - template - void init(o2::framework::HistogramRegistry* registry, T1& config, T2& filter, T3& table, T4& initContext) + template + void init(o2::framework::HistogramRegistry* registry, T1& config, T2& filter, T3& table, T4& initContext, T5& trackBuilder) { if constexpr (modes::isEqual(cascadeType, modes::Cascade::kXi)) { LOG(info) << "Initialize femto Xi builder..."; + mProduceLiteXis = utils::enableTable("FLiteXis_001", table.produceLiteXis.value, initContext); mProduceXis = utils::enableTable("FXis_001", table.produceXis.value, initContext); mProduceXiMasks = utils::enableTable("FXiMasks_001", table.produceXiMasks.value, initContext); mProduceXiExtras = utils::enableTable("FXiExtras_001", table.produceXiExtras.value, initContext); + + if (mProduceXis && mProduceLiteXis) { + LOG(fatal) << "FXis and FLiteXis are mutually exclusive -- enable only one. " + << "FLiteXis is meant to replace FXis at the producer stage (for better compression in derived data); " + << "use the dedicated converter task to reconstruct FXis from FLiteXis downstream."; + } + if (mProduceXis && !trackBuilder.producingTracks()) { + LOG(fatal) << "FXis is enabled, but the track builder is not producing FTracks (full precision). " + << "FXis stores daughter indices into FTracks -- enable TrackTables.produceTracks, " + << "or switch to FLiteXis if TrackTables.produceLiteTracks is enabled instead."; + } + if (mProduceLiteXis && !trackBuilder.producingLiteTracks()) { + LOG(fatal) << "FLiteXis is enabled, but the track builder is not producing FLiteTracks. " + << "FLiteXis stores daughter indices into FLiteTracks -- enable TrackTables.produceLiteTracks, " + << "or switch to FXis if TrackTables.produceTracks is enabled instead."; + } } if constexpr (modes::isEqual(cascadeType, modes::Cascade::kOmega)) { LOG(info) << "Initialize femto Omega builder..."; mProduceOmegas = utils::enableTable("FOmegas_001", table.produceOmegas.value, initContext); + mProduceLiteOmegas = utils::enableTable("FLiteOmegas_001", table.produceLiteOmegas.value, initContext); mProduceOmegaMasks = utils::enableTable("FOmegaMasks_001", table.produceOmegaMasks.value, initContext); mProduceOmegaExtras = utils::enableTable("FOmegaExtras_001", table.produceOmegaExtras.value, initContext); + + if (mProduceOmegas && mProduceLiteOmegas) { + LOG(fatal) << "FOmegas and FLiteOmegas are mutually exclusive -- enable only one. " + << "FLiteOmegas is meant to replace FOmegas at the producer stage (for better compression in derived data); " + << "use the dedicated converter task to reconstruct FOmegas from FLiteOmegas downstream."; + } + if (mProduceOmegas && !trackBuilder.producingTracks()) { + LOG(fatal) << "FOmegas is enabled, but the track builder is not producing FTracks (full precision). " + << "FOmegas stores daughter indices into FTracks -- enable TrackTables.produceTracks, " + << "or switch to FLiteOmegas if TrackTables.produceLiteTracks is enabled instead."; + } + if (mProduceLiteOmegas && !trackBuilder.producingLiteTracks()) { + LOG(fatal) << "FLiteOmegas is enabled, but the track builder is not producing FLiteTracks. " + << "FLiteOmegas stores daughter indices into FLiteTracks -- enable TrackTables.produceLiteTracks, " + << "or switch to FOmegas if TrackTables.produceTracks is enabled instead."; + } } - if (mProduceXis || mProduceXiExtras || mProduceXiMasks || mProduceOmegas || mProduceOmegaMasks || mProduceOmegaExtras) { + if (mProduceXis || mProduceLiteXis || mProduceXiExtras || mProduceXiMasks || + mProduceOmegas || mProduceLiteOmegas || mProduceOmegaMasks || mProduceOmegaExtras) { mFillAnyTable = true; } else { LOG(info) << "No tables configured, Selection object will not be configured..."; @@ -525,7 +564,7 @@ class CascadeBuilder auto negDaughter = cascade.template negTrack_as(); negDaughterIndex = trackBuilder.template getDaughterIndex(negDaughter, trackProducts, collisionBuilder); - fillCascade(collisionProducts, cascadeProducts, cascade, col, bachelorIndex, posDaughterIndex, negDaughterIndex); + fillCascade(collisionBuilder, cascadeProducts, cascade, col, bachelorIndex, posDaughterIndex, negDaughterIndex); } } @@ -559,7 +598,7 @@ class CascadeBuilder auto negDaughter = cascade.template negTrack_as(); negDaughterIndex = trackBuilder.template getDaughterIndex(col, collisionBuilder, mcCols, negDaughter, trackProducts, mcParticles, mcBuilder, mcProducts); - fillCascade(collisionProducts, cascadeProducts, cascade, col, bachelorIndex, posDaughterIndex, negDaughterIndex); + fillCascade(collisionBuilder, cascadeProducts, cascade, col, bachelorIndex, posDaughterIndex, negDaughterIndex); if constexpr (modes::isEqual(cascadeType, modes::Cascade::kXi)) { mcBuilder.template fillMcXiWithLabel(col, mcCols, cascade, mcParticles, mcProducts); } @@ -570,11 +609,11 @@ class CascadeBuilder } template - void fillCascade(T1& collisionProducts, T2& cascadeProducts, T3 const& cascade, T4 const& col, int bachelorIndex, int posDaughterIndex, int negDaughterIndex) + void fillCascade(T1& collisionBuilder, T2& cascadeProducts, T3 const& cascade, T4 const& col, int bachelorIndex, int posDaughterIndex, int negDaughterIndex) { if constexpr (modes::isEqual(cascadeType, modes::Cascade::kXi)) { if (mProduceXis) { - cascadeProducts.producedXis(collisionProducts.producedCollision.lastIndex(), + cascadeProducts.producedXis(collisionBuilder.collisionIndex(), cascade.sign() * cascade.pt(), cascade.eta(), cascade.phi(), @@ -583,6 +622,16 @@ class CascadeBuilder posDaughterIndex, negDaughterIndex); } + if (mProduceLiteXis) { + cascadeProducts.producedLiteXis(collisionBuilder.collisionIndex(), + o2::aod::femtobase::lite::binSignedPt(cascade.sign() * cascade.pt()), + o2::aod::femtobase::lite::binEta(cascade.eta()), + o2::aod::femtobase::lite::binPhi(cascade.phi()), + o2::aod::femtocascades::lite::binXiMass(cascade.mXi()), + bachelorIndex, + posDaughterIndex, + negDaughterIndex); + } if (mProduceXiMasks) { cascadeProducts.producedXiMasks(mCascadeSelection.getBitmask()); } @@ -601,7 +650,7 @@ class CascadeBuilder } if constexpr (modes::isEqual(cascadeType, modes::Cascade::kOmega)) { if (mProduceOmegas) { - cascadeProducts.producedOmegas(collisionProducts.producedCollision.lastIndex(), + cascadeProducts.producedOmegas(collisionBuilder.collisionIndex(), cascade.sign() * cascade.pt(), cascade.eta(), cascade.phi(), @@ -610,6 +659,16 @@ class CascadeBuilder posDaughterIndex, negDaughterIndex); } + if (mProduceLiteOmegas) { + cascadeProducts.producedLiteOmegas(collisionBuilder.collisionIndex(), + o2::aod::femtobase::lite::binSignedPt(cascade.sign() * cascade.pt()), + o2::aod::femtobase::lite::binEta(cascade.eta()), + o2::aod::femtobase::lite::binPhi(cascade.phi()), + o2::aod::femtocascades::lite::binOmegaMass(cascade.mOmega()), + bachelorIndex, + posDaughterIndex, + negDaughterIndex); + } if (mProduceOmegaMasks) { cascadeProducts.producedOmegaMasks(mCascadeSelection.getBitmask()); } @@ -634,9 +693,11 @@ class CascadeBuilder CascadeSelection mCascadeSelection; bool mFillAnyTable = false; bool mProduceXis = false; + bool mProduceLiteXis = false; bool mProduceXiMasks = false; bool mProduceXiExtras = false; bool mProduceOmegas = false; + bool mProduceLiteOmegas = false; bool mProduceOmegaMasks = false; bool mProduceOmegaExtras = false; }; diff --git a/PWGCF/Femto/Core/collisionBuilder.h b/PWGCF/Femto/Core/collisionBuilder.h index 4fd4d499d60..7a4bce87173 100644 --- a/PWGCF/Femto/Core/collisionBuilder.h +++ b/PWGCF/Femto/Core/collisionBuilder.h @@ -599,6 +599,9 @@ class CollisionBuilder template bool checkCollision(T1 const& col) { + if (!mFillAnyTable) { + return false; // selection object was never configured, nothing to check or fill + } return mCollisionSelection.checkFilters(col) && mCollisionSelection.passesAllRequiredSelections(); } @@ -606,6 +609,9 @@ class CollisionBuilder template bool checkCollision(T1 const& col, T2 const& /*mcCols*/) { + if (!mFillAnyTable) { + return false; // selection object was never configured, nothing to check or fill + } // check sub generator id of associated generated collision if (mSubGeneratorId >= 0) { if (col.has_mcCollision()) { @@ -698,6 +704,9 @@ class CollisionBuilder mCurrentCollisionIndex = -1; } + [[nodiscard]] bool producingCollisions() const { return mProducedCollisions; } + [[nodiscard]] bool producingLiteCollisions() const { return mProducedLiteCollisions; } + private: CollisionSelection mCollisionSelection; bool mCollisionAlreadyFilled = false; diff --git a/PWGCF/Femto/Core/kinkBuilder.h b/PWGCF/Femto/Core/kinkBuilder.h index 58664220674..ded1d92eba2 100644 --- a/PWGCF/Femto/Core/kinkBuilder.h +++ b/PWGCF/Femto/Core/kinkBuilder.h @@ -470,9 +470,11 @@ class KinkSelection : public baseselection::BaseSelection producedSigmas; + o2::framework::Produces producedLiteSigmas; o2::framework::Produces producedSigmaMasks; o2::framework::Produces producedSigmaExtras; o2::framework::Produces producedSigmaPlus; + o2::framework::Produces producedLiteSigmaPlus; o2::framework::Produces producedSigmaPlusMasks; o2::framework::Produces producedSigmaPlusExtras; }; @@ -480,9 +482,11 @@ struct KinkBuilderProducts : o2::framework::ProducesGroup { struct ConfKinkTables : o2::framework::ConfigurableGroup { std::string prefix = std::string("KinkTables"); o2::framework::Configurable produceSigmas{"produceSigmas", -1, "Produce Sigmas (-1: auto; 0 off; 1 on)"}; + o2::framework::Configurable produceLiteSigmas{"produceLiteSigmas", -1, "Produce LiteSigmas (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable produceSigmaMasks{"produceSigmaMasks", -1, "Produce SigmaMasks (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable produceSigmaExtras{"produceSigmaExtras", -1, "Produce SigmaExtras (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable produceSigmaPlus{"produceSigmaPlus", -1, "Produce SigmaPlus (-1: auto; 0 off; 1 on)"}; + o2::framework::Configurable produceLiteSigmaPlus{"produceLiteSigmaPlus", -1, "Produce LiteSigmaPlus (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable produceSigmaPlusMasks{"produceSigmaPlusMasks", -1, "Produce SigmaPlusMasks (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable produceSigmaPlusExtras{"produceSigmaPlusExtras", -1, "Produce SigmaPlusExtras (-1: auto; 0 off; 1 on)"}; }; @@ -494,21 +498,55 @@ class KinkBuilder KinkBuilder() = default; ~KinkBuilder() = default; - template - void init(o2::framework::HistogramRegistry* registry, T1& config, T2& filter, T3& table, T4& initContext) + template + void init(o2::framework::HistogramRegistry* registry, T1& config, T2& filter, T3& table, T4& initContext, T5& trackBuilder) { if constexpr (modes::isEqual(kinkType, modes::Kink::kSigma)) { LOG(info) << "Initialize femto Sigma builder..."; mProduceSigmas = utils::enableTable("FSigmas_002", table.produceSigmas.value, initContext); + mProduceLiteSigmas = utils::enableTable("FLiteSigmas_001", table.produceLiteSigmas.value, initContext); mProduceSigmaMasks = utils::enableTable("FSigmaMasks_001", table.produceSigmaMasks.value, initContext); mProduceSigmaExtras = utils::enableTable("FSigmaExtras_001", table.produceSigmaExtras.value, initContext); + + if (mProduceSigmas && mProduceLiteSigmas) { + LOG(fatal) << "FSigmas and FLiteSigmas are mutually exclusive -- enable only one. " + << "FLiteSigmas is meant to replace FSigmas at the producer stage (for better compression in derived data); " + << "use the dedicated converter task to reconstruct FSigmas from FLiteSigmas downstream."; + } + if (mProduceSigmas && !trackBuilder.producingTracks()) { + LOG(fatal) << "FSigmas is enabled, but the track builder is not producing FTracks (full precision). " + << "FSigmas stores the daughter index into FTracks -- enable TrackTables.produceTracks, " + << "or switch to FLiteSigmas if TrackTables.produceLiteTracks is enabled instead."; + } + if (mProduceLiteSigmas && !trackBuilder.producingLiteTracks()) { + LOG(fatal) << "FLiteSigmas is enabled, but the track builder is not producing FLiteTracks. " + << "FLiteSigmas stores the daughter index into FLiteTracks -- enable TrackTables.produceLiteTracks, " + << "or switch to FSigmas if TrackTables.produceTracks is enabled instead."; + } } if constexpr (modes::isEqual(kinkType, modes::Kink::kSigmaPlus)) { LOG(info) << "Initialize femto SigmaPlus builder..."; mProduceSigmaPlus = utils::enableTable("FSigmaPlus_001", table.produceSigmaPlus.value, initContext); + mProduceLiteSigmaPlus = utils::enableTable("FLiteSigmaPlus_001", table.produceLiteSigmaPlus.value, initContext); mProduceSigmaPlusMasks = utils::enableTable("FSigmaPlusMasks_001", table.produceSigmaPlusMasks.value, initContext); mProduceSigmaPlusExtras = utils::enableTable("FSigmaPlusExtras_001", table.produceSigmaPlusExtras.value, initContext); + + if (mProduceSigmaPlus && mProduceLiteSigmaPlus) { + LOG(fatal) << "FSigmaPlus and FLiteSigmaPlus are mutually exclusive -- enable only one. " + << "FLiteSigmaPlus is meant to replace FSigmaPlus at the producer stage (for better compression in derived data); " + << "use the dedicated converter task to reconstruct FSigmaPlus from FLiteSigmaPlus downstream."; + } + if (mProduceSigmaPlus && !trackBuilder.producingTracks()) { + LOG(fatal) << "FSigmaPlus is enabled, but the track builder is not producing FTracks (full precision). " + << "FSigmaPlus stores the daughter index into FTracks -- enable TrackTables.produceTracks, " + << "or switch to FLiteSigmaPlus if TrackTables.produceLiteTracks is enabled instead."; + } + if (mProduceLiteSigmaPlus && !trackBuilder.producingLiteTracks()) { + LOG(fatal) << "FLiteSigmaPlus is enabled, but the track builder is not producing FLiteTracks. " + << "FLiteSigmaPlus stores the daughter index into FLiteTracks -- enable TrackTables.produceLiteTracks, " + << "or switch to FSigmaPlus if TrackTables.produceTracks is enabled instead."; + } } if (mProduceSigmas || mProduceSigmaMasks || mProduceSigmaExtras || mProduceSigmaPlus || mProduceSigmaPlusMasks || mProduceSigmaPlusExtras) { @@ -549,10 +587,10 @@ class KinkBuilder auto daughter = kink.template trackDaug_as(); daughterIndex = trackBuilder.template getDaughterIndex(daughter, trackProducts, collisionBuilder); if constexpr (modes::isEqual(kinkType, modes::Kink::kSigma)) { - fillSigma(collisionProducts, kinkProducts, kink, daughterIndex); + fillSigma(collisionBuilder, kinkProducts, kink, daughterIndex); } if constexpr (modes::isEqual(kinkType, modes::Kink::kSigmaPlus)) { - fillSigmaPlus(collisionProducts, kinkProducts, kink, daughterIndex); + fillSigmaPlus(collisionBuilder, kinkProducts, kink, daughterIndex); } } } @@ -584,30 +622,39 @@ class KinkBuilder daughterIndex = trackBuilder.template getDaughterIndex(col, collisionBuilder, mcCols, daughter, trackProducts, mcParticles, mcBuilder, mcProducts); if constexpr (modes::isEqual(kinkType, modes::Kink::kSigma)) { - fillSigma(collisionProducts, kinkProducts, kink, daughterIndex); + fillSigma(collisionBuilder, kinkProducts, kink, daughterIndex); mcBuilder.template fillMcSigmaWithLabel(col, mcCols, daughter, mcParticles, mcProducts); } if constexpr (modes::isEqual(kinkType, modes::Kink::kSigmaPlus)) { - fillSigmaPlus(collisionProducts, kinkProducts, kink, daughterIndex); + fillSigmaPlus(collisionBuilder, kinkProducts, kink, daughterIndex); mcBuilder.template fillMcSigmaPlusWithLabel(col, mcCols, daughter, mcParticles, mcProducts); } } } template - void fillSigma(T1& collisionProducts, T2& kinkProducts, T3 const& kink, int64_t daughterIndex) + void fillSigma(T1& collisionBuilder, T2& kinkProducts, T3 const& kink, int64_t daughterIndex) { // Mass is calculated from original momentum components stored in kink table float mass = kink.mSigmaMinus(); + float signedPt = kink.mothSign() * mKinkSelection.getKinkMotherPt(); // Recalculated pT if (mProduceSigmas) { - kinkProducts.producedSigmas(collisionProducts.producedCollision.lastIndex(), - kink.mothSign() * mKinkSelection.getKinkMotherPt(), // Recalculated pT + kinkProducts.producedSigmas(collisionBuilder.collisionIndex(), + signedPt, mKinkSelection.getKinkMotherEta(), mKinkSelection.getKinkMotherPhi(), mass, daughterIndex); } + if (mProduceLiteSigmas) { + kinkProducts.producedLiteSigmas(collisionBuilder.collisionIndex(), + o2::aod::femtobase::lite::binSignedPt(signedPt), + o2::aod::femtobase::lite::binEta(mKinkSelection.getKinkMotherEta()), + o2::aod::femtobase::lite::binPhi(mKinkSelection.getKinkMotherPhi()), + o2::aod::femtokinks::lite::binSigmaMass(mass), + daughterIndex); + } if (mProduceSigmaMasks) { kinkProducts.producedSigmaMasks(mKinkSelection.getBitmask()); } @@ -624,19 +671,27 @@ class KinkBuilder } template - void fillSigmaPlus(T1& collisionProducts, T2& kinkProducts, T3 const& kink, int64_t daughterIndex) + void fillSigmaPlus(T1& collisionBuilder, T2& kinkProducts, T3 const& kink, int64_t daughterIndex) { // Mass is calculated from original momentum components stored in kink table float mass = kink.mSigmaPlus(); - + float signedPt = kink.mothSign() * mKinkSelection.getKinkMotherPt(); // Recalculated pT if (mProduceSigmaPlus) { - kinkProducts.producedSigmaPlus(collisionProducts.producedCollision.lastIndex(), - kink.mothSign() * mKinkSelection.getKinkMotherPt(), // Recalculated pT + kinkProducts.producedSigmaPlus(collisionBuilder.collisionIndex(), + signedPt, mKinkSelection.getKinkMotherEta(), mKinkSelection.getKinkMotherPhi(), mass, daughterIndex); } + if (mProduceLiteSigmaPlus) { + kinkProducts.producedLiteSigmaPlus(collisionBuilder.collisionIndex(), + o2::aod::femtobase::lite::binSignedPt(signedPt), + o2::aod::femtobase::lite::binEta(mKinkSelection.getKinkMotherEta()), + o2::aod::femtobase::lite::binPhi(mKinkSelection.getKinkMotherPhi()), + o2::aod::femtokinks::lite::binSigmaMass(mass), + daughterIndex); + } if (mProduceSigmaPlusMasks) { kinkProducts.producedSigmaPlusMasks(mKinkSelection.getBitmask()); } @@ -658,9 +713,11 @@ class KinkBuilder KinkSelection mKinkSelection; bool mFillAnyTable = false; bool mProduceSigmas = false; + bool mProduceLiteSigmas = false; bool mProduceSigmaMasks = false; bool mProduceSigmaExtras = false; bool mProduceSigmaPlus = false; + bool mProduceLiteSigmaPlus = false; bool mProduceSigmaPlusMasks = false; bool mProduceSigmaPlusExtras = false; }; diff --git a/PWGCF/Femto/Core/trackBuilder.h b/PWGCF/Femto/Core/trackBuilder.h index fcb8bc763c4..d7ce7da180a 100644 --- a/PWGCF/Femto/Core/trackBuilder.h +++ b/PWGCF/Femto/Core/trackBuilder.h @@ -568,8 +568,8 @@ class TrackBuilder TrackBuilder() = default; ~TrackBuilder() = default; - template - void init(o2::framework::HistogramRegistry* registry, T1& config, T2& filter, T3& table, T4& initContext) + template + void init(o2::framework::HistogramRegistry* registry, T1& config, T2& filter, T3& table, T4& initContext, T5& collisionBuilder) { LOG(info) << "Initialize femto track builder..."; @@ -593,6 +593,17 @@ class TrackBuilder << "use the dedicated converter task to reconstruct FTracks from FLiteTracks downstream."; } + if (mProduceTracks && !collisionBuilder.producingCollisions()) { + LOG(fatal) << "FTracks is enabled, but the collision builder is not producing FCols (full precision). " + << "FTracks stores the collision index into FCols -- enable CollisionTables.produceCollisions, " + << "or switch to FLiteTracks if CollisionTables.produceLiteCollisions is enabled instead."; + } + if (mProduceLiteTracks && !collisionBuilder.producingLiteCollisions()) { + LOG(fatal) << "FLiteTracks is enabled, but the collision builder is not producing FLiteCols. " + << "FLiteTracks stores the collision index into FLiteCols -- enable CollisionTables.produceLiteCollisions, " + << "or switch to FTracks if CollisionTables.produceCollisions is enabled instead."; + } + if (mProduceTracks || mProduceLiteTracks || mProduceTrackMasks || mProduceTrackMass || mProduceTrackDcas || mProduceTrackExtras || mProduceElectronPids || mProducePionPids || mProduceKaonPids || mProduceProtonPids || mProduceDeuteronPids || mProduceTritonPids || mProduceHeliumPids) { mFillAnyTable = true; } else { @@ -642,7 +653,7 @@ class TrackBuilder if (mProduceLiteTracks) { trackProducts.producedLiteTracks(collisionBuilder.collisionIndex(), - o2::aod::femtobase::lite::binPt(track.pt() * track.sign()), + o2::aod::femtobase::lite::binSignedPt(track.pt() * track.sign()), o2::aod::femtobase::lite::binEta(track.eta()), o2::aod::femtobase::lite::binPhi(track.phi())); lastIndex = trackProducts.producedLiteTracks.lastIndex(); @@ -790,6 +801,9 @@ class TrackBuilder return indexMap.at(daughter.globalIndex()); } + [[nodiscard]] bool producingTracks() const { return mProduceTracks; } + [[nodiscard]] bool producingLiteTracks() const { return mProduceLiteTracks; } + template void reset(T const& tracks) { diff --git a/PWGCF/Femto/Core/v0Builder.h b/PWGCF/Femto/Core/v0Builder.h index 1e2cb7453c4..777553740bb 100644 --- a/PWGCF/Femto/Core/v0Builder.h +++ b/PWGCF/Femto/Core/v0Builder.h @@ -427,9 +427,11 @@ class V0Selection : public baseselection::BaseSelection producedLambdas; + o2::framework::Produces producedLiteLambdas; o2::framework::Produces producedLambdaMasks; o2::framework::Produces producedLambdaExtras; o2::framework::Produces producedK0shorts; + o2::framework::Produces producedLiteK0shorts; o2::framework::Produces producedK0shortMasks; o2::framework::Produces producedK0shortExtras; }; @@ -437,9 +439,11 @@ struct V0BuilderProducts : o2::framework::ProducesGroup { struct ConfV0Tables : o2::framework::ConfigurableGroup { std::string prefix = std::string("V0Tables"); o2::framework::Configurable produceLambdas{"produceLambdas", -1, "Produce Lambdas (-1: auto; 0 off; 1 on)"}; + o2::framework::Configurable produceLiteLambdas{"produceLiteLambdas", -1, "Produce LiteLambdas (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable produceLambdaMasks{"produceLambdaMasks", -1, "Produce LambdaMasks (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable produceLambdaExtras{"produceLambdaExtras", -1, "Produce LambdaExtras (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable produceK0shorts{"produceK0shorts", -1, "Produce K0shorts (-1: auto; 0 off; 1 on)"}; + o2::framework::Configurable produceLiteK0shorts{"produceLiteK0shorts", -1, "Produce LiteK0shorts (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable produceK0shortMasks{"produceK0shortMasks", -1, "Produce K0shortMasks (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable produceK0shortExtras{"produceK0shortExtras", -1, "Produce K0shortExtras (-1: auto; 0 off; 1 on)"}; }; @@ -451,8 +455,8 @@ class V0Builder V0Builder() = default; ~V0Builder() = default; - template - void init(o2::framework::HistogramRegistry* registry, T1& config, T2& filter, T3& table, T4& initContext) + template + void init(o2::framework::HistogramRegistry* registry, T1& config, T2& filter, T3& table, T4& initContext, T5& trackBuilder) { if constexpr (modes::isEqual(v0Type, modes::V0::kLambda) || modes::isEqual(v0Type, modes::V0::kAntiLambda)) { if constexpr (modes::isEqual(v0Type, modes::V0::kLambda)) { @@ -462,16 +466,51 @@ class V0Builder LOG(info) << "Initialize femto AntiLambda builder..."; } mProduceLambdas = utils::enableTable("FLambdas_001", table.produceLambdas.value, initContext); + mProduceLiteLambdas = utils::enableTable("FLiteLambdas_001", table.produceLiteLambdas.value, initContext); mProduceLambdaMasks = utils::enableTable("FLambdaMasks_001", table.produceLambdaMasks.value, initContext); mProduceLambdaExtras = utils::enableTable("FLambdaExtras_001", table.produceLambdaExtras.value, initContext); + + if (mProduceLambdas && mProduceLiteLambdas) { + LOG(fatal) << "FLambdas and FLiteLambdas are mutually exclusive -- enable only one. " + << "FLiteLambdas is meant to replace FLambdas at the producer stage (for better compression in derived data); " + << "use the dedicated converter task to reconstruct FLambdas from FLiteLambdas downstream."; + } + if (mProduceLambdas && !trackBuilder.producingTracks()) { + LOG(fatal) << "FLambdas is enabled, but the track builder is not producing FTracks (full precision). " + << "FLambdas stores daughter indices into FTracks -- enable TrackTables.produceTracks, " + << "or switch to FLiteLambdas if TrackTables.produceLiteTracks is enabled instead."; + } + if (mProduceLiteLambdas && !trackBuilder.producingLiteTracks()) { + LOG(fatal) << "FLiteLambdas is enabled, but the track builder is not producing FLiteTracks. " + << "FLiteLambdas stores daughter indices into FLiteTracks -- enable TrackTables.produceLiteTracks, " + << "or switch to FLambdas if TrackTables.produceTracks is enabled instead."; + } } if constexpr (modes::isEqual(v0Type, modes::V0::kK0short)) { LOG(info) << "Initialize femto K0short builder..."; mProduceK0shorts = utils::enableTable("FK0shorts_001", table.produceK0shorts.value, initContext); + mProduceLiteK0shorts = utils::enableTable("FLiteK0shorts_001", table.produceLiteK0shorts.value, initContext); mProduceK0shortMasks = utils::enableTable("FK0shortMasks_001", table.produceK0shortMasks.value, initContext); mProduceK0shortExtras = utils::enableTable("FK0shortExtras_001", table.produceK0shortExtras.value, initContext); + + if (mProduceK0shorts && mProduceLiteK0shorts) { + LOG(fatal) << "FK0shorts and FLiteK0shorts are mutually exclusive -- enable only one. " + << "FLiteK0shorts is meant to replace FK0shorts at the producer stage (for better compression in derived data); " + << "use the dedicated converter task to reconstruct FK0shorts from FLiteK0shorts downstream."; + } + if (mProduceK0shorts && !trackBuilder.producingTracks()) { + LOG(fatal) << "FK0shorts is enabled, but the track builder is not producing FTracks (full precision). " + << "FK0shorts stores daughter indices into FTracks -- enable TrackTables.produceTracks, " + << "or switch to FLiteK0shorts if TrackTables.produceLiteTracks is enabled instead."; + } + if (mProduceLiteK0shorts && !trackBuilder.producingLiteTracks()) { + LOG(fatal) << "FLiteK0shorts is enabled, but the track builder is not producing FLiteTracks. " + << "FLiteK0shorts stores daughter indices into FLiteTracks -- enable TrackTables.produceLiteTracks, " + << "or switch to FK0shorts if TrackTables.produceTracks is enabled instead."; + } } - if (mProduceLambdas || mProduceLambdaMasks || mProduceLambdaExtras || mProduceK0shorts || mProduceK0shortMasks || mProduceK0shortExtras) { + if (mProduceLambdas || mProduceLiteLambdas || mProduceLambdaMasks || mProduceLambdaExtras || + mProduceK0shorts || mProduceLiteK0shorts || mProduceK0shortMasks || mProduceK0shortExtras) { mFillAnyTable = true; } else { LOG(info) << "No tables configured, Selection object will not be configured..."; @@ -509,13 +548,13 @@ class V0Builder negDaughterIndex = trackBuilder.template getDaughterIndex(negDaughter, trackProducts, collisionBuilder); if constexpr (modes::isEqual(v0Type, modes::V0::kLambda)) { - fillLambda(collisionProducts, v0Products, v0, 1.f, posDaughterIndex, negDaughterIndex); + fillLambda(collisionBuilder, v0Products, v0, 1.f, posDaughterIndex, negDaughterIndex); } if constexpr (modes::isEqual(v0Type, modes::V0::kAntiLambda)) { - fillLambda(collisionProducts, v0Products, v0, -1.f, posDaughterIndex, negDaughterIndex); + fillLambda(collisionBuilder, v0Products, v0, -1.f, posDaughterIndex, negDaughterIndex); } if constexpr (modes::isEqual(v0Type, modes::V0::kK0short)) { - fillK0short(collisionProducts, v0Products, v0, posDaughterIndex, negDaughterIndex); + fillK0short(collisionBuilder, v0Products, v0, posDaughterIndex, negDaughterIndex); } } } @@ -547,22 +586,22 @@ class V0Builder negDaughterIndex = trackBuilder.template getDaughterIndex(col, collisionBuilder, mcCols, negDaughter, trackProducts, mcParticles, mcBuilder, mcProducts); if constexpr (modes::isEqual(v0Type, modes::V0::kLambda)) { - fillLambda(collisionProducts, v0Products, v0, 1.f, posDaughterIndex, negDaughterIndex); + fillLambda(collisionBuilder, v0Products, v0, 1.f, posDaughterIndex, negDaughterIndex); mcBuilder.template fillMcLambdaWithLabel(col, mcCols, v0, mcParticles, mcProducts); } if constexpr (modes::isEqual(v0Type, modes::V0::kAntiLambda)) { - fillLambda(collisionProducts, v0Products, v0, -1.f, posDaughterIndex, negDaughterIndex); + fillLambda(collisionBuilder, v0Products, v0, -1.f, posDaughterIndex, negDaughterIndex); mcBuilder.template fillMcLambdaWithLabel(col, mcCols, v0, mcParticles, mcProducts); } if constexpr (modes::isEqual(v0Type, modes::V0::kK0short)) { - fillK0short(collisionProducts, v0Products, v0, posDaughterIndex, negDaughterIndex); + fillK0short(collisionBuilder, v0Products, v0, posDaughterIndex, negDaughterIndex); mcBuilder.template fillMcK0shortWithLabel(col, mcCols, v0, mcParticles, mcProducts); } } } template - void fillLambda(T1& collisionProducts, T2& v0Products, T3 const& v0, float sign, int64_t posDaughterIndex, int64_t negDaughterIndex) + void fillLambda(T1& collisionBuilder, T2& v0Products, T3 const& v0, float sign, int64_t posDaughterIndex, int64_t negDaughterIndex) { float mass = 0; float massAnti = 0; @@ -574,7 +613,7 @@ class V0Builder massAnti = v0.mLambda(); } if (mProduceLambdas) { - v0Products.producedLambdas(collisionProducts.producedCollision.lastIndex(), + v0Products.producedLambdas(collisionBuilder.collisionIndex(), sign * v0.pt(), v0.eta(), v0.phi(), @@ -582,6 +621,15 @@ class V0Builder posDaughterIndex, negDaughterIndex); } + if (mProduceLiteLambdas) { + v0Products.producedLiteLambdas(collisionBuilder.collisionIndex(), + o2::aod::femtobase::lite::binSignedPt(sign * v0.pt()), + o2::aod::femtobase::lite::binEta(v0.eta()), + o2::aod::femtobase::lite::binPhi(v0.phi()), + o2::aod::femtov0s::lite::binLambdaMass(mass), + posDaughterIndex, + negDaughterIndex); + } if (mProduceLambdaMasks) { v0Products.producedLambdaMasks(mV0Selection.getBitmask()); } @@ -599,10 +647,10 @@ class V0Builder } template - void fillK0short(T1& collisionProducts, T2& v0Products, T3 const& v0, int64_t posDaughterIndex, int64_t negDaughterIndex) + void fillK0short(T1& collisionBuilder, T2& v0Products, T3 const& v0, int64_t posDaughterIndex, int64_t negDaughterIndex) { if (mProduceK0shorts) { - v0Products.producedK0shorts(collisionProducts.producedCollision.lastIndex(), + v0Products.producedK0shorts(collisionBuilder.collisionIndex(), v0.pt(), v0.eta(), v0.phi(), @@ -610,6 +658,15 @@ class V0Builder posDaughterIndex, negDaughterIndex); } + if (mProduceLiteK0shorts) { + v0Products.producedLiteK0shorts(collisionBuilder.collisionIndex(), + o2::aod::femtobase::lite::binUnsignedPt(v0.pt()), + o2::aod::femtobase::lite::binEta(v0.eta()), + o2::aod::femtobase::lite::binPhi(v0.phi()), + o2::aod::femtov0s::lite::binK0shortMass(v0.mK0Short()), + posDaughterIndex, + negDaughterIndex); + } if (mProduceK0shortMasks) { v0Products.producedK0shortMasks(mV0Selection.getBitmask()); } @@ -632,9 +689,11 @@ class V0Builder V0Selection mV0Selection; bool mFillAnyTable = false; bool mProduceLambdas = false; + bool mProduceLiteLambdas = false; bool mProduceLambdaMasks = false; bool mProduceLambdaExtras = false; bool mProduceK0shorts = false; + bool mProduceLiteK0shorts = false; bool mProduceK0shortMasks = false; bool mProduceK0shortExtras = false; }; diff --git a/PWGCF/Femto/TableProducer/femtoProducer.cxx b/PWGCF/Femto/TableProducer/femtoProducer.cxx index 72fa5d15a8c..359f6175abc 100644 --- a/PWGCF/Femto/TableProducer/femtoProducer.cxx +++ b/PWGCF/Femto/TableProducer/femtoProducer.cxx @@ -176,30 +176,34 @@ struct FemtoProducer { int64_t now = std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count(); ccdb->setCreatedNotAfter(now); - // collision selection + // Order matters here: CollisionBuilder must init before TrackBuilder (which checks + // collisionBuilder.producingCollisions()/producingLiteCollisions()), and TrackBuilder + // must init before the V0/Cascade/Kink builders (which check + // trackBuilder.producingTracks()/producingLiteTracks()). + + // configure collision builder collisionBuilder.init(&hRegistry, confCollisionFilters, confCollisionBits, confCollisionRctFlags, confCcdb, confCollisionTables, context); // configure track builder - trackBuilder.init(&hRegistry, confTrackBits, confTrackFilters, confTrackTables, context); + trackBuilder.init(&hRegistry, confTrackBits, confTrackFilters, confTrackTables, context, collisionBuilder); // configure v0 builder - k0shortBuilder.init(&hRegistry, confK0shortBits, confV0Filters, confV0Tables, context); - lambdaBuilder.init(&hRegistry, confLambdaBits, confV0Filters, confV0Tables, context); - antilambdaBuilder.init(&hRegistry, confLambdaBits, confV0Filters, confV0Tables, context); + k0shortBuilder.init(&hRegistry, confK0shortBits, confV0Filters, confV0Tables, context, trackBuilder); + lambdaBuilder.init(&hRegistry, confLambdaBits, confV0Filters, confV0Tables, context, trackBuilder); + antilambdaBuilder.init(&hRegistry, confLambdaBits, confV0Filters, confV0Tables, context, trackBuilder); // configure kink builder - sigmaBuilder.init(&hRegistry, confSigmaBits, confKinkFilters, confKinkTables, context); - sigmaPlusBuilder.init(&hRegistry, confSigmaPlusBits, confKinkFilters, confKinkTables, context); + sigmaBuilder.init(&hRegistry, confSigmaBits, confKinkFilters, confKinkTables, context, trackBuilder); + sigmaPlusBuilder.init(&hRegistry, confSigmaPlusBits, confKinkFilters, confKinkTables, context, trackBuilder); // cascade selections - xiBuilder.init(&hRegistry, confXiBits, confCascadeFilters, confCascadeTables, context); - omegaBuilder.init(&hRegistry, confOmegaBits, confCascadeFilters, confCascadeTables, context); + xiBuilder.init(&hRegistry, confXiBits, confCascadeFilters, confCascadeTables, context, trackBuilder); + omegaBuilder.init(&hRegistry, confOmegaBits, confCascadeFilters, confCascadeTables, context, trackBuilder); // configure mcBuilder mcBuilder.init(confMc, confMcTables, context); hRegistry.print(); - LOG(warn) << __LINE__; } // processing collisions diff --git a/PWGCF/Femto/TableProducer/femtoProducerLiteConverter.cxx b/PWGCF/Femto/TableProducer/femtoProducerLiteConverter.cxx index 0a43ae21e98..5f4ca499cb1 100644 --- a/PWGCF/Femto/TableProducer/femtoProducerLiteConverter.cxx +++ b/PWGCF/Femto/TableProducer/femtoProducerLiteConverter.cxx @@ -10,7 +10,7 @@ // or submit itself to any jurisdiction. /// \file femtoProducerLiteConverter.cxx -/// \brief Task that converts FLiteTracks (binned kinematics) back to FTracks (float kinematics) +/// \brief Task that converts FLite* tables (binned kinematics) back to their full-precision counterparts /// \author Anton Riedel, TU München, anton.riedel@cern.ch #include "PWGCF/Femto/DataModel/FemtoTables.h" @@ -26,28 +26,106 @@ using namespace o2::analysis::femto; struct FemtoProducerLiteConverter { o2::framework::Produces producedCols; o2::framework::Produces producedTracks; + o2::framework::Produces producedLambdas; + o2::framework::Produces producedK0shorts; + o2::framework::Produces producedXis; + o2::framework::Produces producedOmegas; + o2::framework::Produces producedSigmas; + o2::framework::Produces producedSigmaPlus; void init(o2::framework::InitContext&) { } - void processLiteCols(o2::aod::FLiteCols::iterator const& liteCols) + void processLiteCols(o2::aod::FLiteCols::iterator const& liteCol) { - producedCols(liteCols.posZ(), - liteCols.mult(), - liteCols.cent(), - liteCols.magField()); + producedCols(liteCol.posZ(), + liteCol.mult(), + liteCol.cent(), + liteCol.magField()); } PROCESS_SWITCH(FemtoProducerLiteConverter, processLiteCols, "Convert FLiteCols to FCols", true); void processLiteTracks(o2::aod::FLiteTracks::iterator const& liteTrack) { - producedTracks(liteTrack.fColId(), + producedTracks(liteTrack.fLiteColId(), liteTrack.signedPt(), liteTrack.eta(), liteTrack.phi()); } PROCESS_SWITCH(FemtoProducerLiteConverter, processLiteTracks, "Convert FLiteTracks to FTracks", true); + + void processLiteLambdas(o2::aod::FLiteLambdas::iterator const& liteLambda) + { + producedLambdas(liteLambda.fLiteColId(), + liteLambda.signedPt(), + liteLambda.eta(), + liteLambda.phi(), + liteLambda.lambdaMass(), + liteLambda.posDauId(), + liteLambda.negDauId()); + } + PROCESS_SWITCH(FemtoProducerLiteConverter, processLiteLambdas, "Convert FLiteLambdas to FLambdas", false); + + void processLiteK0shorts(o2::aod::FLiteK0shorts::iterator const& liteK0short) + { + producedK0shorts(liteK0short.fLiteColId(), + liteK0short.unsignedPt(), + liteK0short.eta(), + liteK0short.phi(), + liteK0short.k0shortMass(), + liteK0short.posDauId(), + liteK0short.negDauId()); + } + PROCESS_SWITCH(FemtoProducerLiteConverter, processLiteK0shorts, "Convert FLiteK0shorts to FK0shorts", false); + + void processLiteXis(o2::aod::FLiteXis::iterator const& liteXi) + { + producedXis(liteXi.fLiteColId(), + liteXi.signedPt(), + liteXi.eta(), + liteXi.phi(), + liteXi.xiMass(), + liteXi.bachelorId(), + liteXi.posDauId(), + liteXi.negDauId()); + } + PROCESS_SWITCH(FemtoProducerLiteConverter, processLiteXis, "Convert FLiteXis to FXis", false); + + void processLiteOmegas(o2::aod::FLiteOmegas::iterator const& liteOmega) + { + producedOmegas(liteOmega.fLiteColId(), + liteOmega.signedPt(), + liteOmega.eta(), + liteOmega.phi(), + liteOmega.omegaMass(), + liteOmega.bachelorId(), + liteOmega.posDauId(), + liteOmega.negDauId()); + } + PROCESS_SWITCH(FemtoProducerLiteConverter, processLiteOmegas, "Convert FLiteOmegas to FOmegas", false); + + void processLiteSigmas(o2::aod::FLiteSigmas::iterator const& liteSigma) + { + producedSigmas(liteSigma.fLiteColId(), + liteSigma.signedPt(), + liteSigma.eta(), + liteSigma.phi(), + liteSigma.sigmaMass(), + liteSigma.chaDauId()); + } + PROCESS_SWITCH(FemtoProducerLiteConverter, processLiteSigmas, "Convert FLiteSigmas to FSigmas", false); + + void processLiteSigmaPlus(o2::aod::FLiteSigmaPlus::iterator const& liteSigmaPlus) + { + producedSigmaPlus(liteSigmaPlus.fLiteColId(), + liteSigmaPlus.signedPt(), + liteSigmaPlus.eta(), + liteSigmaPlus.phi(), + liteSigmaPlus.sigmaMass(), + liteSigmaPlus.chaDauId()); + } + PROCESS_SWITCH(FemtoProducerLiteConverter, processLiteSigmaPlus, "Convert FLiteSigmaPlus to FSigmaPlus", false); }; o2::framework::WorkflowSpec defineDataProcessing(o2::framework::ConfigContext const& context) From c63301f0e0e402b7e1e3b562b13da360d05f9d86 Mon Sep 17 00:00:00 2001 From: Anton Riedel Date: Sun, 26 Jul 2026 12:24:44 +0200 Subject: [PATCH 3/7] Feat: fix linter issues --- PWGCF/Femto/DataModel/FemtoTables.h | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/PWGCF/Femto/DataModel/FemtoTables.h b/PWGCF/Femto/DataModel/FemtoTables.h index f64d3704a53..ae61f907539 100644 --- a/PWGCF/Femto/DataModel/FemtoTables.h +++ b/PWGCF/Femto/DataModel/FemtoTables.h @@ -565,9 +565,9 @@ constexpr float LambdaMassMin = 1.05f; // Kinematic lower limit constexpr float LambdaMassMax = 1.30f; constexpr float LambdaMassStep = (LambdaMassMax - LambdaMassMin) / 65536.f; -// K0short: PDG mass 0.497611 GeV, ±100 MeV window -constexpr float K0shortMassMin = 0.497611f - 0.1f; // = 0.397611 -constexpr float K0shortMassMax = 0.497611f + 0.1f; // = 0.597611 +// K0short: PDG mass 0.497611 GeV roughly ±100 MeV window +constexpr float K0shortMassMin = 0.4f; +constexpr float K0shortMassMax = 0.6f; constexpr float K0shortMassStep = (K0shortMassMax - K0shortMassMin) / 65536.f; inline uint16_t binLambdaMass(float lambdaMass) { return o2::analysis::femto::utils::binLinear(lambdaMass, LambdaMassMin, LambdaMassMax, LambdaMassStep); } @@ -726,10 +726,9 @@ DECLARE_SOA_INDEX_COLUMN_FULL(ChaDau, chaDau, int32_t, FTracks, "_ChaDau"); //! namespace lite { -// Sigma (using a shared window covering both Sigma- 1.19745 and Sigma+ 1.18937): -// centered on the midpoint ~1.19341, +-100 MeV comfortably covers both species + margin -constexpr float SigmaMassMin = 1.19341f - 0.1f; // = 1.09341 -constexpr float SigmaMassMax = 1.19341f + 0.1f; // = 1.29341 +// Sigma (using a shared window covering both Sigma- 1.19745 and Sigma+ 1.18937) with roughly +-100 MeV +constexpr float SigmaMassMin = 1.1f; +constexpr float SigmaMassMax = 1.3f; constexpr float SigmaMassStep = (SigmaMassMax - SigmaMassMin) / 65536.f; inline uint16_t binSigmaMass(float mass) { return o2::analysis::femto::utils::binLinear(mass, SigmaMassMin, SigmaMassMax, SigmaMassStep); } @@ -897,14 +896,14 @@ DECLARE_SOA_INDEX_COLUMN_FULL(Bachelor, bachelor, int32_t, FTracks, "_Bachelor") namespace lite { -// Xi-: PDG mass 1.32171 GeV, ±100 MeV window -constexpr float XiMassMin = 1.32171f - 0.1f; // = 1.22171 -constexpr float XiMassMax = 1.32171f + 0.1f; // = 1.42171 +// Xi-: PDG mass 1.32171 GeV, roughly ±100 MeV window +constexpr float XiMassMin = 1.22; +constexpr float XiMassMax = 1.42; constexpr float XiMassStep = (XiMassMax - XiMassMin) / 65536.f; -// Omega-: PDG mass 1.67245 GeV, ±100 MeV window -constexpr float OmegaMassMin = 1.67245f - 0.1f; // = 1.57245 -constexpr float OmegaMassMax = 1.67245f + 0.1f; // = 1.77245 +// Omega-: PDG mass 1.67245 GeV, roughly ±100 MeV window +constexpr float OmegaMassMin = 1.57; +constexpr float OmegaMassMax = 1.77; constexpr float OmegaMassStep = (OmegaMassMax - OmegaMassMin) / 65536.f; inline uint16_t binXiMass(float mass) { return o2::analysis::femto::utils::binLinear(mass, XiMassMin, XiMassMax, XiMassStep); } From be3982aa7e2c3e6476c767398ef0d20ee5e333d6 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Sun, 26 Jul 2026 10:25:49 +0000 Subject: [PATCH 4/7] Please consider the following formatting changes --- PWGCF/Femto/DataModel/FemtoTables.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGCF/Femto/DataModel/FemtoTables.h b/PWGCF/Femto/DataModel/FemtoTables.h index ae61f907539..010d0ba506c 100644 --- a/PWGCF/Femto/DataModel/FemtoTables.h +++ b/PWGCF/Femto/DataModel/FemtoTables.h @@ -898,7 +898,7 @@ namespace lite // Xi-: PDG mass 1.32171 GeV, roughly ±100 MeV window constexpr float XiMassMin = 1.22; -constexpr float XiMassMax = 1.42; +constexpr float XiMassMax = 1.42; constexpr float XiMassStep = (XiMassMax - XiMassMin) / 65536.f; // Omega-: PDG mass 1.67245 GeV, roughly ±100 MeV window From 7f75e45c429c0a0f5102bb10bc0ea419efed14f8 Mon Sep 17 00:00:00 2001 From: Anton Riedel Date: Sun, 26 Jul 2026 12:28:28 +0200 Subject: [PATCH 5/7] Fix: fix literal value --- PWGCF/Femto/DataModel/FemtoTables.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGCF/Femto/DataModel/FemtoTables.h b/PWGCF/Femto/DataModel/FemtoTables.h index 010d0ba506c..06783480ab9 100644 --- a/PWGCF/Femto/DataModel/FemtoTables.h +++ b/PWGCF/Femto/DataModel/FemtoTables.h @@ -897,13 +897,13 @@ namespace lite { // Xi-: PDG mass 1.32171 GeV, roughly ±100 MeV window -constexpr float XiMassMin = 1.22; -constexpr float XiMassMax = 1.42; +constexpr float XiMassMin = 1.22f; +constexpr float XiMassMax = 1.42f; constexpr float XiMassStep = (XiMassMax - XiMassMin) / 65536.f; // Omega-: PDG mass 1.67245 GeV, roughly ±100 MeV window -constexpr float OmegaMassMin = 1.57; -constexpr float OmegaMassMax = 1.77; +constexpr float OmegaMassMin = 1.57f; +constexpr float OmegaMassMax = 1.77f; constexpr float OmegaMassStep = (OmegaMassMax - OmegaMassMin) / 65536.f; inline uint16_t binXiMass(float mass) { return o2::analysis::femto::utils::binLinear(mass, XiMassMin, XiMassMax, XiMassStep); } From 6c393863e132365edb2d736d8b50814c618e2cfd Mon Sep 17 00:00:00 2001 From: Anton Riedel Date: Sun, 26 Jul 2026 12:33:18 +0200 Subject: [PATCH 6/7] Feat: fix table names --- PWGCF/Femto/DataModel/FemtoTables.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/PWGCF/Femto/DataModel/FemtoTables.h b/PWGCF/Femto/DataModel/FemtoTables.h index 06783480ab9..72a751a0868 100644 --- a/PWGCF/Femto/DataModel/FemtoTables.h +++ b/PWGCF/Femto/DataModel/FemtoTables.h @@ -97,7 +97,7 @@ using FCol = FCols::iterator; using StoredFCols = StoredFCols_001; // table for basic collision information, compressed/binned information -DECLARE_SOA_TABLE_STAGED_VERSIONED(FLiteCols_001, "FLITECOLS", 1, //! femto collisions, binned information +DECLARE_SOA_TABLE_STAGED_VERSIONED(FLiteCols_001, "FLITECOL", 1, //! femto collisions, binned information o2::soa::Index<>, femtocollisions::lite::BinnedPosZ, femtocollisions::lite::BinnedMult, @@ -347,7 +347,7 @@ using FTrack = FTracks::iterator; using StoredFTracks = StoredFTracks_001; // table for basic track information, compressed/binned kinematics -DECLARE_SOA_TABLE_STAGED_VERSIONED(FLiteTracks_001, "FLITETRACKS", 1, //! femto tracks, binned kinematics +DECLARE_SOA_TABLE_STAGED_VERSIONED(FLiteTracks_001, "FLITETRACK", 1, //! femto tracks, binned kinematics o2::soa::Index<>, femtobase::stored::FLiteColId, femtobase::lite::SignedBinnedPt, @@ -617,7 +617,7 @@ using FLambdas = FLambdas_001; using StoredFLambdas = StoredFLambdas_001; // table for basic lambda information with compressed/binned kinematics -DECLARE_SOA_TABLE_STAGED_VERSIONED(FLiteLambdas_001, "FLITELAMBDAS", 1, +DECLARE_SOA_TABLE_STAGED_VERSIONED(FLiteLambdas_001, "FLITELAMBDA", 1, o2::soa::Index<>, femtobase::stored::FLiteColId, femtobase::lite::SignedBinnedPt, From d493dd47bddba2a09b5b75739c1762ac3f16f3d2 Mon Sep 17 00:00:00 2001 From: Anton Riedel Date: Sun, 26 Jul 2026 13:17:20 +0200 Subject: [PATCH 7/7] Fix: adjust range in eta for lite tables --- PWGCF/Femto/DataModel/FemtoTables.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGCF/Femto/DataModel/FemtoTables.h b/PWGCF/Femto/DataModel/FemtoTables.h index 72a751a0868..3e0ed2911ad 100644 --- a/PWGCF/Femto/DataModel/FemtoTables.h +++ b/PWGCF/Femto/DataModel/FemtoTables.h @@ -198,8 +198,8 @@ DECLARE_SOA_DYNAMIC_COLUMN(Theta, theta, //! theta namespace lite { -constexpr float EtaMin = -1.2f; // Eta coverage of ITS -constexpr float EtaMax = 1.2f; +constexpr float EtaMin = -1.5f; +constexpr float EtaMax = 1.5f; constexpr float EtaStep = (EtaMax - EtaMin) / 65536.f; constexpr float PhiMin = 0.f;