make file reading make sense

Author: aalkin

ALICE3/Core/FlatLutEntry.cxx

@@ -142,6 +142,14 @@ void FlatLutData::cacheDimensions()
   mPtBins = header.ptmap.nbins;
 }
 
+void FlatLutData::resetDimensions()
+{
+  mNchBins = 0;
+  mRadBins = 0;
+  mEtaBins = 0;
+  mPtBins = 0;
+}
+
 void FlatLutData::adopt(const uint8_t* buffer, size_t size)
 {
   mData.resize(size);
@@ -198,4 +206,54 @@ FlatLutData FlatLutData::ViewFromBuffer(const uint8_t* buffer, size_t size)
   return data;
 }
 
+bool FlatLutData::isLoaded() const
+{
+  return ((!mData.empty()) || (!mDataRef.empty()));
+}
+
+FlatLutData FlatLutData::loadFromFile(const char* filename)
+{
+  std::ifstream lutFile(filename, std::ifstream::binary);
+  if (!lutFile.is_open()) {
+    throw framework::runtime_error_f("Cannot open LUT file: %s", filename);
+  }
+
+  // Read header first
+  lutHeader_t tempHeader;
+  lutFile.read(reinterpret_cast<char*>(&tempHeader), sizeof(lutHeader_t));
+  if (lutFile.gcount() != static_cast<std::streamsize>(sizeof(lutHeader_t))) {
+    throw framework::runtime_error_f("Failed to read LUT header from %s", filename);
+  }
+
+  if (!tempHeader.check_version()) {
+    throw framework::runtime_error_f("LUT header version mismatch: expected %d, got %d", LUTCOVM_VERSION, tempHeader.version);
+  }
+
+  FlatLutData data;
+
+  // Initialize flat data structure
+  data.initialize(tempHeader);
+
+  // Read all entries sequentially into flat buffer
+  size_t headerSize = sizeof(lutHeader_t);
+  size_t numEntries = static_cast<size_t>(data.mNchBins) * data.mRadBins * data.mEtaBins * data.mPtBins;
+  size_t entriesSize = numEntries * sizeof(lutEntry_t);
+
+  lutFile.read(reinterpret_cast<char*>(data.data() + headerSize), entriesSize);
+  if (lutFile.gcount() != static_cast<std::streamsize>(entriesSize)) {
+    throw framework::runtime_error_f("Failed to read LUT entries from %s: expected %zu bytes, got %zu", filename, entriesSize, static_cast<size_t>(lutFile.gcount()));
+  }
+
+  lutFile.close();
+  LOGF(info, "Successfully loaded LUT from %s: %zu entries", filename, numEntries);
+  return data;
+}
+
+void FlatLutData::reset()
+{
+  mData.clear();
+  updateRef();
+  resetDimensions();
+}
+
 } // namespace o2::delphes

ALICE3/Core/FlatLutEntry.h

@@ -93,6 +93,8 @@ class FlatLutData
 {
  public:
   FlatLutData() = default;
+  FlatLutData(FlatLutData&&) = default;
+  FlatLutData& operator=(FlatLutData&&) = default;
 
   /**
    * @brief Initialize from binning information
@@ -141,6 +143,21 @@ class FlatLutData
    */
   static FlatLutData ViewFromBuffer(const uint8_t* buffer, size_t size);
 
+  /**
+   * @brief Construct a new FlatLutData from a file
+   */
+  static FlatLutData loadFromFile(const char* filename);
+
+  /**
+   * @brief Check if the LUT is loaded
+   */
+  bool isLoaded() const;
+
+  /**
+   * @brief Reset LUT to empty
+   */
+  void reset();
+
  private:
   /**
    * @brief Linear index calculation for entry access
@@ -151,6 +168,10 @@ class FlatLutData
    * @brief Update dimensions from the current header
    */
   void cacheDimensions();
+  /**
+   * @brief Reset dimensions to 0
+   */
+  void resetDimensions();
 
   /**
    * @brief Adopt a buffer by copying

ALICE3/Core/FlatTrackSmearer.cxx

@@ -11,6 +11,10 @@
 
 #include "FlatTrackSmearer.h"
 
+#include "ALICE3/Core/GeometryContainer.h"
+
+#include <Framework/RuntimeError.h>
+
 namespace o2::delphes
 {
 int TrackSmearer::getIndexPDG(int pdg) const
@@ -64,4 +68,63 @@ const char* TrackSmearer::getParticleName(int pdg) const
       return "pion"; // Default: pion
   }
 }
+
+bool TrackSmearer::loadTable(int pdg, const char* filename, bool forceReload)
+{
+  if (!filename || filename[0] == '\0') {
+    LOGF(info, "No LUT file provided for PDG %d. Skipping load.", pdg);
+    return false;
+  }
+
+  const auto ipdg = getIndexPDG(pdg);
+  LOGF(info, "Loading %s LUT file: '%s'", getParticleName(pdg), filename);
+
+  if (mLUTData[ipdg].isLoaded() && !forceReload) {
+    LOGF(info, "LUT table for PDG %d already loaded (index %d)", pdg, ipdg);
+    return false;
+  }
+
+  const std::string localFilename = o2::fastsim::GeometryEntry::accessFile(filename, "./.ALICE3/LUTs/", mCcdbManager, 10);
+
+  try {
+    mLUTData[ipdg] = FlatLutData::loadFromFile(localFilename.c_str());
+  } catch (framework::RuntimeErrorRef ref) {
+    LOGF(error, "%s", framework::error_from_ref(ref).what);
+    return false;
+  }
+
+  // Validate header
+  const auto& header = mLUTData[ipdg].getHeaderRef();
+
+  bool specialPdgCase = false;
+  switch (pdg) {
+    case o2::constants::physics::kAlpha:
+      // Special case: Allow Alpha particles to use He3 LUT
+      specialPdgCase = (header.pdg == o2::constants::physics::kHelium3);
+      if (specialPdgCase) {
+        LOGF(info, "Alpha particles (PDG %d) will use He3 LUT data (PDG %d)", pdg, header.pdg);
+      }
+      break;
+    default:
+      break;
+  }
+
+  if (header.pdg != pdg && !specialPdgCase) {
+    LOGF(error, "LUT header PDG mismatch: expected %d, got %d", pdg, header.pdg);
+    mLUTData[ipdg].reset();
+    return false;
+  }
+
+  LOGF(info, "Successfully read LUT for PDG %d: %s", pdg, localFilename.c_str());
+  header.print();
+
+  return true;
+}
+
+bool TrackSmearer::hasTable(int pdg) const
+{
+  const int ipdg = getIndexPDG(pdg);
+  return mLUTData[ipdg].isLoaded();
+}
+
 } // namespace o2::delphes

ALICE3/Core/FlatTrackSmearer.h

@@ -27,7 +27,6 @@ class TrackSmearer
 {
  public:
   TrackSmearer() = default;
-  ~TrackSmearer() = default;
 
   /** LUT methods **/
   bool loadTable(int pdg, const char* filename, bool forceReload = false);
@@ -60,7 +59,7 @@ class TrackSmearer
  protected:
   static constexpr unsigned int nLUTs = 9; // Number of LUT available
   lutHeader_t const* mHeaders[nLUTs];      // header references for quick access
-  FlatLutData mLUTData[nLUTs];             // NEW: Flat data storage
+  FlatLutData mLUTData[nLUTs];             // Flat data storage
 
   bool mUseEfficiency = true;
   bool mInterpolateEfficiency = false;