Updated the CMVContainer, corrected the timestamp range for CCDB

Author: tubagundem

Detectors/TPC/calibration/include/TPCCalibration/CMVContainer.h

@@ -11,65 +11,75 @@
 
 /// @file   CMVContainer.h
 /// @author Tuba Gündem, tuba.gundem@cern.ch
-/// @brief  Struct for storing CMVs to the CCDB
+/// @brief  Structs for storing CMVs to the CCDB
 
 #ifndef ALICEO2_TPC_CMVCONTAINER_H_
 #define ALICEO2_TPC_CMVCONTAINER_H_
 
 #include <vector>
 #include <string>
 #include <memory>
+#include <stdexcept>
+#include <fmt/format.h>
 
 #include "TTree.h"
+#include "DataFormatsTPC/CMV.h"
 
 namespace o2::tpc
 {
 
-/// CMVContainer: accumulator for one aggregation interval
-struct CMVContainer {
-
-  uint32_t nTFs{0};  ///< number of TFs accumulated
-  uint32_t nCRUs{0}; ///< number of contributing CRUs
-  long firstTF{0};   ///< first TF counter in this aggregation interval
-
-  std::vector<float> cmvValues{};  ///< CMV float values
-  std::vector<uint32_t> cru{};     ///< CRU indices
-  std::vector<uint32_t> timebin{}; ///< absolute timebins within the TF
-  std::vector<uint32_t> tf{};      ///< TF counters
+/// CMV data for one TF across all CRUs
+struct CMVPerTF {
+  int64_t firstOrbit{0}; ///< First orbit of this TF, from heartbeatOrbit of the first CMV packet
+  int64_t firstBC{0};    ///< First bunch crossing of this TF, from heartbeatBC of the first CMV packet
+
+  /// CMV float values indexed as [CRU ID][time bin]
+  std::vector<std::vector<float>> mDataPerTF;
+
+  /// Return the CMV value for a given CRU and time bin within this TF
+  float getCMV(const int cru, const int timeBin) const
+  {
+    if (cru < 0 || static_cast<std::size_t>(cru) >= mDataPerTF.size()) {
+      throw std::out_of_range(fmt::format("CMVPerTF::getCMV: cru {} out of range [0, {})", cru, mDataPerTF.size()));
+    }
+    if (timeBin < 0 || static_cast<uint32_t>(timeBin) >= cmv::NTimeBinsPerTF) {
+      throw std::out_of_range(fmt::format("CMVPerTF::getCMV: timeBin {} out of range [0, {})", timeBin, cmv::NTimeBinsPerTF));
+    }
+    return mDataPerTF[cru][timeBin];
+  }
+
+  ClassDefNV(CMVPerTF, 1)
+};
 
-  /// Pre-allocate storage for the expected number of entries: expectedTFs × expectedCRUs × NTimeBinsPerTF
-  void reserve(uint32_t expectedTFs, uint32_t expectedCRUs);
+/// Container holding CMVs for one aggregation interval
+struct CMVPerInterval {
+  int64_t firstTF{0}; ///< First TF counter seen in this interval
+  int64_t lastTF{0};  ///< Last TF counter seen in this interval
 
-  /// Append one (cmv, cru, timebin, tf) tuple
-  void addEntry(float cmvVal, uint32_t cruID, uint32_t tb, uint32_t tfCounter);
+  /// CMV data, one CMVPerTF entry per TF, indexed by relative TF [0, nTimeFrames)
+  std::vector<CMVPerTF> mCMVPerTF;
 
-  /// Append one full CRU packet (NTimeBinsPerPacket consecutive timebins)
-  /// \param packet    pointer to NTimeBinsPerPacket floats
-  /// \param cruID     CRU index
-  /// \param tbOffset  absolute timebin of the first sample in this packet
-  /// \param tfCounter TF counter
-  void addPacket(const float* packet, uint32_t cruID, uint32_t tbOffset, uint32_t tfCounter);
+  /// Pre-allocate nTFs TF slots; each slot gets mDataPerTF resized to nCRUs entries
+  void reserve(uint32_t nTFs, uint32_t nCRUs);
 
-  std::size_t size() const;
-  bool empty() const;
+  std::size_t size() const { return mCMVPerTF.size(); }
+  bool empty() const { return mCMVPerTF.empty(); }
 
   /// Clear all data and reset counters
   void clear();
 
   std::string summary() const;
 
-  /// Build an in-memory TTree with one branch per field and one entry per tuple
+  /// Serialise into a TTree with a single branch holding the whole CMVPerInterval object
   std::unique_ptr<TTree> toTTree() const;
 
-  /// Write the container as a TTree inside a TFile on disk
-  /// \param filename  path to the output ROOT file
-  /// \param tree  tree of the container
+  /// Write the TTree to a ROOT file
   void writeToFile(const std::string& filename, const std::unique_ptr<TTree>& tree) const;
 
-  /// Restore a CMVContainer from a TTree previously written by toTTree()
-  static CMVContainer fromTTree(TTree* tree, int entry = 0);
+  /// Restore a CMVPerInterval from a TTree previously written by toTTree()
+  static CMVPerInterval fromTTree(TTree* tree, int entry = 0);
 
-  ClassDefNV(CMVContainer, 1)
+  ClassDefNV(CMVPerInterval, 1)
 };
 
 } // namespace o2::tpc

Detectors/TPC/calibration/src/CMVContainer.cxx

@@ -18,121 +18,78 @@
 #include "TFile.h"
 
 #include "TPCCalibration/CMVContainer.h"
-#include "DataFormatsTPC/CMV.h"
 
 namespace o2::tpc
 {
 
-void CMVContainer::reserve(uint32_t expectedTFs, uint32_t expectedCRUs)
+void CMVPerInterval::reserve(uint32_t nTFs, uint32_t nCRUs)
 {
-  const std::size_t n = static_cast<std::size_t>(expectedTFs) * expectedCRUs * o2::tpc::cmv::NTimeBinsPerTF;
-  cmvValues.reserve(n);
-  cru.reserve(n);
-  timebin.reserve(n);
-  tf.reserve(n);
-}
-
-void CMVContainer::addEntry(float cmvVal, uint32_t cruID, uint32_t tb, uint32_t tfCounter)
-{
-  cmvValues.push_back(cmvVal);
-  cru.push_back(cruID);
-  timebin.push_back(tb);
-  tf.push_back(tfCounter);
-}
-
-void CMVContainer::addPacket(const float* packet, uint32_t cruID, uint32_t tbOffset, uint32_t tfCounter)
-{
-  for (uint32_t tb = 0; tb < o2::tpc::cmv::NTimeBinsPerPacket; ++tb) {
-    addEntry(packet[tb], cruID, tbOffset + tb, tfCounter);
+  mCMVPerTF.resize(nTFs);
+  for (auto& tfData : mCMVPerTF) {
+    tfData.mDataPerTF.resize(nCRUs);
   }
 }
 
-std::size_t CMVContainer::size() const { return cmvValues.size(); }
-
-bool CMVContainer::empty() const { return cmvValues.empty(); }
-
-void CMVContainer::clear()
+void CMVPerInterval::clear()
 {
-  cmvValues.clear();
-  cru.clear();
-  timebin.clear();
-  tf.clear();
-  nTFs = 0;
-  nCRUs = 0;
+  mCMVPerTF.clear();
   firstTF = 0;
+  lastTF = 0;
 }
 
-std::string CMVContainer::summary() const
+std::string CMVPerInterval::summary() const
 {
-  return fmt::format("CMVContainer: {} entries, {} TFs, {} CRUs, firstTF={}",
-                     size(), nTFs, nCRUs, firstTF);
+  const std::size_t nCRUs = empty() ? 0 : mCMVPerTF.front().mDataPerTF.size();
+  return fmt::format("CMVPerInterval: {} TFs, {} CRU slots, firstTF={}, lastTF={}",
+                     size(), nCRUs, firstTF, lastTF);
 }
 
-std::unique_ptr<TTree> CMVContainer::toTTree() const
+std::unique_ptr<TTree> CMVPerInterval::toTTree() const
 {
-  const std::size_t n = size();
-  if (n == 0) {
-    throw std::runtime_error("CMVContainer::toTTree() called on empty container");
+  if (empty()) {
+    throw std::runtime_error("CMVPerInterval::toTTree() called on empty container");
   }
 
   auto tree = std::make_unique<TTree>("ccdb_object", "ccdb_object");
   tree->SetAutoSave(0);
   tree->SetDirectory(nullptr);
 
-  // Point branches directly at the vector data
-  float* pCmv = const_cast<float*>(cmvValues.data());
-  uint32_t* pCru = const_cast<uint32_t*>(cru.data());
-  uint32_t* pTimebin = const_cast<uint32_t*>(timebin.data());
-  uint32_t* pTf = const_cast<uint32_t*>(tf.data());
+  const CMVPerInterval* ptr = this;
+  tree->Branch("CMVPerInterval", &ptr);
+  tree->Fill();
 
-  tree->Branch("cmv", pCmv, fmt::format("cmv[{}]/F", n).c_str());
-  tree->Branch("cru", pCru, fmt::format("cru[{}]/i", n).c_str());
-  tree->Branch("timebin", pTimebin, fmt::format("timebin[{}]/i", n).c_str());
-  tree->Branch("tf", pTf, fmt::format("tf[{}]/i", n).c_str());
+  tree->ResetBranchAddresses();
 
-  tree->Fill();
   return tree;
 }
 
-void CMVContainer::writeToFile(const std::string& filename, const std::unique_ptr<TTree>& tree) const
+void CMVPerInterval::writeToFile(const std::string& filename, const std::unique_ptr<TTree>& tree) const
 {
   TFile f(filename.c_str(), "RECREATE");
   if (f.IsZombie()) {
-    throw std::runtime_error(fmt::format("CMVContainer::writeToFile: cannot open '{}'", filename));
+    throw std::runtime_error(fmt::format("CMVPerInterval::writeToFile: cannot open '{}'", filename));
   }
   tree->Write();
   f.Close();
 }
 
-CMVContainer CMVContainer::fromTTree(TTree* tree, int entry)
+CMVPerInterval CMVPerInterval::fromTTree(TTree* tree, int entry)
 {
   if (!tree) {
-    throw std::runtime_error("CMVContainer::fromTTree: null TTree pointer");
-  }
-
-  CMVContainer c;
-  const Long64_t nEntries = tree->GetEntries();
-  if (nEntries <= 0) {
-    return c;
+    throw std::runtime_error("CMVPerInterval::fromTTree: null TTree pointer");
   }
 
-  // Read the array branches back into vectors in one GetEntry() call
-  std::vector<float> bCmv(nEntries);
-  std::vector<uint32_t> bCru(nEntries), bTimebin(nEntries), bTf(nEntries);
-
-  tree->SetBranchAddress("cmv", bCmv.data());
-  tree->SetBranchAddress("cru", bCru.data());
-  tree->SetBranchAddress("timebin", bTimebin.data());
-  tree->SetBranchAddress("tf", bTf.data());
-
+  CMVPerInterval* ptr = nullptr;
+  tree->SetBranchAddress("CMVPerInterval", &ptr);
   tree->GetEntry(entry);
 
-  c.cmvValues = std::move(bCmv);
-  c.cru = std::move(bCru);
-  c.timebin = std::move(bTimebin);
-  c.tf = std::move(bTf);
+  if (!ptr) {
+    throw std::runtime_error("CMVPerInterval::fromTTree: failed to read object from TTree");
+  }
 
-  return c;
+  CMVPerInterval result = std::move(*ptr);
+  delete ptr;
+  return result;
 }
 
-} // namespace o2::tpc
+} // namespace o2::tpc

Detectors/TPC/calibration/src/TPCCalibrationLinkDef.h

@@ -123,6 +123,10 @@
 #pragma link C++ class o2::tpc::DigitAdd + ;
 #pragma link C++ class std::vector < o2::tpc::DigitAdd> + ;
 #pragma link C++ class o2::tpc::PressureTemperatureHelper + ;
-#pragma link C++ class o2::tpc::CMVContainer + ;
+
+#pragma link C++ class o2::tpc::CMVPerTF + ;
+#pragma link C++ class o2::tpc::CMVPerInterval + ;
+#pragma link C++ class std::vector<o2::tpc::CMVPerTF> + ;
+#pragma link C++ class std::vector<std::vector<float>>+;
 
 #endif