Added CMVContainer.cxx, fixed missing links and includes

Author: tubagundem

Detectors/TPC/calibration/CMakeLists.txt

@@ -58,6 +58,7 @@ o2_add_library(TPCCalibration
                        src/DigitAdd.cxx
                        src/CorrectdEdxDistortions.cxx
                        src/PressureTemperatureHelper.cxx
+                       src/CMVContainer.cxx
                PUBLIC_LINK_LIBRARIES O2::DataFormatsTPC O2::TPCBaseRecSim
                                      O2::TPCReconstruction ROOT::Minuit
                                      Microsoft.GSL::GSL
@@ -115,7 +116,8 @@ o2_target_root_dictionary(TPCCalibration
                                   include/TPCCalibration/TPCMShapeCorrection.h
                                   include/TPCCalibration/DigitAdd.h
                                   include/TPCCalibration/CorrectdEdxDistortions.h
-                                  include/TPCCalibration/PressureTemperatureHelper.h)
+                                  include/TPCCalibration/PressureTemperatureHelper.h
+                                  include/TPCCalibration/CMVContainer.h)
 
 o2_add_test_root_macro(macro/comparePedestalsAndNoise.C
                        PUBLIC_LINK_LIBRARIES O2::TPCBaseRecSim

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

@@ -19,14 +19,8 @@
 #include <vector>
 #include <string>
 #include <memory>
-#include <stdexcept>
-
-#include <fmt/format.h>
 
 #include "TTree.h"
-#include "TFile.h"
-
-#include "DataFormatsTPC/CMV.h"
 
 namespace o2::tpc
 {
@@ -44,127 +38,35 @@ struct CMVContainer {
   std::vector<uint32_t> tf{};      ///< TF counters
 
   /// Pre-allocate storage for the expected number of entries: expectedTFs × expectedCRUs × NTimeBinsPerTF
-  void reserve(uint32_t expectedTFs, uint32_t expectedCRUs)
-  {
-    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 reserve(uint32_t expectedTFs, uint32_t expectedCRUs);
 
   /// Append one (cmv, cru, timebin, tf) tuple
-  void 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 addEntry(float cmvVal, uint32_t cruID, uint32_t tb, uint32_t tfCounter);
 
   /// 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)
-  {
-    for (uint32_t tb = 0; tb < o2::tpc::cmv::NTimeBinsPerPacket; ++tb) {
-      addEntry(packet[tb], cruID, tbOffset + tb, tfCounter);
-    }
-  }
+  void addPacket(const float* packet, uint32_t cruID, uint32_t tbOffset, uint32_t tfCounter);
 
-  std::size_t size() const { return cmvValues.size(); }
-  bool empty() const { return cmvValues.empty(); }
+  std::size_t size() const;
+  bool empty() const;
 
   /// Clear all data and reset counters
-  void clear()
-  {
-    cmvValues.clear();
-    cru.clear();
-    timebin.clear();
-    tf.clear();
-    nTFs = 0;
-    nCRUs = 0;
-    firstTF = 0;
-  }
-
-  std::string summary() const
-  {
-    return fmt::format("CMVContainer: {} entries, {} TFs, {} CRUs, firstTF={}",
-                       size(), nTFs, nCRUs, firstTF);
-  }
+  void clear();
+
+  std::string summary() const;
 
   /// Build an in-memory TTree with one branch per field and one entry per tuple
-  std::unique_ptr<TTree> toTTree() const
-  {
-    const std::size_t n = size();
-    if (n == 0) {
-      throw std::runtime_error("CMVContainer::toTTree() called on empty container");
-    }
-
-    auto tree = std::make_unique<TTree>("CMVTree", "TPC common mode values");
-    tree->SetAutoSave(0);
-
-    // Point branches directly at the vector data — single Fill() call writes all rows
-    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());
-
-    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->Fill();
-    return tree;
-  }
+  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
-  void writeToFile(const std::string& filename) const
-  {
-    TFile f(filename.c_str(), "RECREATE");
-    if (f.IsZombie()) {
-      throw std::runtime_error(fmt::format("CMVContainer::writeToFile: cannot open '{}'", filename));
-    }
-    auto tree = toTTree();
-    tree->Write();
-    f.Close();
-  }
+  void writeToFile(const std::string& filename) const;
 
   /// Restore a CMVContainer from a TTree previously written by toTTree()
-  static CMVContainer fromTTree(TTree* tree)
-  {
-    if (!tree) {
-      throw std::runtime_error("CMVContainer::fromTTree: null TTree pointer");
-    }
-
-    CMVContainer c;
-    const Long64_t nEntries = tree->GetEntries();
-    if (nEntries <= 0) {
-      return c;
-    }
-
-    // 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());
-
-    tree->GetEntry(0);
-
-    c.cmvValues = std::move(bCmv);
-    c.cru = std::move(bCru);
-    c.timebin = std::move(bTimebin);
-    c.tf = std::move(bTf);
-
-    return c;
-  }
+  static CMVContainer fromTTree(TTree* tree, int entry = 0);
 
   ClassDefNV(CMVContainer, 1)
 };

Detectors/TPC/calibration/src/CMVContainer.cxx

@@ -0,0 +1,138 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   CMVContainer.cxx
+/// @author Tuba Gündem, tuba.gundem@cern.ch
+
+#include <stdexcept>
+#include <fmt/format.h>
+
+#include "TFile.h"
+
+#include "TPCCalibration/CMVContainer.h"
+#include "DataFormatsTPC/CMV.h"
+
+namespace o2::tpc
+{
+
+void CMVContainer::reserve(uint32_t expectedTFs, uint32_t expectedCRUs)
+{
+  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);
+  }
+}
+
+std::size_t CMVContainer::size() const { return cmvValues.size(); }
+
+bool CMVContainer::empty() const { return cmvValues.empty(); }
+
+void CMVContainer::clear()
+{
+  cmvValues.clear();
+  cru.clear();
+  timebin.clear();
+  tf.clear();
+  nTFs = 0;
+  nCRUs = 0;
+  firstTF = 0;
+}
+
+std::string CMVContainer::summary() const
+{
+  return fmt::format("CMVContainer: {} entries, {} TFs, {} CRUs, firstTF={}",
+                     size(), nTFs, nCRUs, firstTF);
+}
+
+std::unique_ptr<TTree> CMVContainer::toTTree() const
+{
+  const std::size_t n = size();
+  if (n == 0) {
+    throw std::runtime_error("CMVContainer::toTTree() called on empty container");
+  }
+
+  auto tree = std::make_unique<TTree>("CMVTree", "TPC common mode values");
+  tree->SetAutoSave(0);
+
+  // Point branches directly at the vector data — single Fill() call writes all rows
+  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());
+
+  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->Fill();
+  return tree;
+}
+
+void CMVContainer::writeToFile(const std::string& filename) const
+{
+  TFile f(filename.c_str(), "RECREATE");
+  if (f.IsZombie()) {
+    throw std::runtime_error(fmt::format("CMVContainer::writeToFile: cannot open '{}'", filename));
+  }
+  auto tree = toTTree();
+  tree->Write();
+  f.Close();
+}
+
+CMVContainer CMVContainer::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;
+  }
+
+  // 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());
+
+  tree->GetEntry(entry);
+  
+  c.cmvValues = std::move(bCmv);
+  c.cru = std::move(bCru);
+  c.timebin = std::move(bTimebin);
+  c.tf = std::move(bTf);
+
+  return c;
+}
+
+} // namespace o2::tpc

Detectors/TPC/calibration/src/TPCCalibrationLinkDef.h

@@ -123,4 +123,6 @@
 #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 + ;
+
 #endif

Detectors/TPC/workflow/include/TPCWorkflow/TPCFactorizeCMVSpec.h

@@ -155,7 +155,7 @@ class TPCFactorizeCMVDevice : public o2::framework::Task
 
   void endOfStream(o2::framework::EndOfStreamContext& ec) final
   {
-    LOGP(info, "End of stream – flushing CMV container ({} entries, lane {})", mContainer.size(), mLaneId);
+    LOGP(info, "End of stream, flushing CMV container ({} entries, lane {})", mContainer.size(), mLaneId);
     mContainer.nTFs = static_cast<uint32_t>(mTimeFrames);
     mContainer.nCRUs = static_cast<uint32_t>(mCRUs.size());
     sendOutput(ec.outputs());