Implemented cbm::algo::tof::Calibrate.

algo/CMakeLists.txt

@@ -89,6 +89,7 @@ set(SRCS
   detectors/much/ReadoutConfig.cxx
   detectors/much/Unpack.cxx
   detectors/tof/HitFinder.cxx
+  detectors/tof/Calibrate.cxx
   detectors/tof/Clusterizer.cxx
   detectors/tof/ReadoutConfig.cxx
   detectors/tof/Unpack.cxx

algo/detectors/tof/Calibrate.cxx

+/* Copyright (C) 2023 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Dominik Smith [committer] */
+
+#include "Calibrate.h"
+
+#include <chrono>
+
+#include "log.hpp"
+
+using namespace std;
+using fles::Subsystem;
+
+namespace cbm::algo::tof
+{
+  // -----   Execution   -------------------------------------------------------
+  Calibrate::resultType Calibrate::operator()(gsl::span<CbmTofDigi> digiIn)
+  {
+    xpu::push_timer("TofCalibrate");
+    xpu::t_add_bytes(digiIn.size_bytes());
+
+    // --- Output data
+    resultType result = {};
+
+    auto& calDigiOut = result.first;
+    auto& monitor    = result.second;
+
+    // channel deadtime map
+    std::map<int32_t, double> mChannelDeadTime;
+
+    for (size_t iDigi = 0; iDigi < digiIn.size(); iDigi++) {
+
+      CbmTofDigi pDigi    = digiIn[iDigi];
+      const double SmType = pDigi.GetType();
+      const double Sm     = pDigi.GetSm();
+      const double Rpc    = pDigi.GetRpc();
+      const double Chan   = pDigi.GetChannel();
+      const double Side   = pDigi.GetSide();
+      const int NbRpc     = fTofConfig.NbRpc[SmType];
+
+      auto& rpcs = fTofConfig.rpcs;
+      if (SmType >= rpcs.size() || Sm * NbRpc + Rpc >= rpcs.at(SmType).size()) {
+        monitor.fDigiCalibUnknownRPC++;
+        continue;
+      }
+
+      HitfindSetup::Rpc& rpcPar      = fTofConfig.rpcs.at(SmType).at(Sm * NbRpc + Rpc);
+      HitfindSetup::Channel& chanPar = rpcPar.chanPar[Chan];
+
+      if (rpcPar.swapChannelSides && 5 != SmType && 8 != SmType) {
+        pDigi.SetAddress(Sm, Rpc, Chan, (0 == Side) ? 1 : 0, SmType);
+      }
+
+      // Check dead time
+      const int32_t iAddr = pDigi.GetAddress();
+      auto it             = mChannelDeadTime.find(iAddr);
+      if (it != mChannelDeadTime.end() && pDigi.GetTime() <= it->second) {
+        it->second = pDigi.GetTime() + rpcPar.channelDeadtime;
+        continue;
+      }
+      mChannelDeadTime[iAddr] = pDigi.GetTime() + rpcPar.channelDeadtime;
+
+      // Create calibrated digi
+      CbmTofDigi pCalDigi(pDigi);
+
+      // calibrate Digi Time
+      pCalDigi.SetTime(pCalDigi.GetTime() - chanPar.vCPTOff[Side]);
+
+      // subtract Offset
+      double dTot = pCalDigi.GetTot() - chanPar.vCPTotOff[Side];
+      if (dTot < 0.001) dTot = 0.001;
+      // calibrate Digi ToT
+      pCalDigi.SetTot(dTot * chanPar.vCPTotGain[Side]);
+
+      // walk correction
+      std::vector<double>& walk = chanPar.vCPWalk[Side];
+      const double dTotBinSize  = (rpcPar.TOTMax - rpcPar.TOTMin) / rpcPar.numClWalkBinX;
+      int32_t iWx               = (int32_t)((pCalDigi.GetTot() - rpcPar.TOTMin) / dTotBinSize);
+
+      if (0 > iWx) { iWx = 0; }
+      if (iWx >= rpcPar.numClWalkBinX) { iWx = rpcPar.numClWalkBinX - 1; }
+
+      const double dDTot = (pCalDigi.GetTot() - rpcPar.TOTMin) / dTotBinSize - (double) iWx - 0.5;
+      double dWT         = walk[iWx];
+
+      // linear interpolation to next bin
+      if (dDTot > 0) {
+        if (iWx < rpcPar.numClWalkBinX - 1) { dWT += dDTot * (walk[iWx + 1] - walk[iWx]); }
+      }
+      else {
+        if (0 < iWx) { dWT -= dDTot * (walk[iWx - 1] - walk[iWx]); }
+      }
+      pCalDigi.SetTime(pCalDigi.GetTime() - dWT);  // calibrate Digi Time
+      calDigiOut.push_back(pCalDigi);
+    }
+
+    /// Sort the buffers of hits due to the time offsets applied
+    std::sort(calDigiOut.begin(), calDigiOut.end(),
+              [](const CbmTofDigi& a, const CbmTofDigi& b) -> bool { return a.GetTime() < b.GetTime(); });
+
+    monitor.fTime = xpu::pop_timer();
+
+    return result;
+  }
+
+}  // namespace cbm::algo::tof

algo/detectors/tof/Calibrate.h

+/* Copyright (C) 2023 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Dominik Smith [committer] */
+
+#ifndef TOFCALIBRATE_H
+#define TOFCALIBRATE_H 1
+
+#include "CbmTofDigi.h"
+
+#include "tof/Clusterizer.h"
+#include "tof/HitfindSetup.h"
+
+#include <gsl/span>
+#include <optional>
+#include <sstream>
+#include <vector>
+
+#include <xpu/host.h>
+
+#include "PartitionedVector.h"
+
+namespace cbm::algo::tof
+{
+
+  /** @struct CalibrateMonitorData
+   ** @author Dominik Smith <d.smith@gsi.de>
+   ** @since 16 Oct 2023
+   ** @brief Monitoring data for calibration
+   **/
+  struct CalibrateMonitorData {
+    xpu::timings fTime;
+    size_t fDigiCalibUnknownRPC = 0;
+
+    std::string print() const
+    {
+      std::stringstream ss;
+      ss << "Calibrate stats: num unknown RPC " << fDigiCalibUnknownRPC << ", time " << fTime.wall() << std::endl;
+      return ss.str();
+    }
+  };
+
+  /** @class Calibrate
+ ** @brief Algo class for calibration
+ ** @author Dominik Smith <d.smith@gsi.de>
+ ** @since 16.10.2023
+ **
+ **/
+  class Calibrate {
+
+  public:
+    typedef std::pair<std::vector<CbmTofDigi>, CalibrateMonitorData> resultType;
+
+    /** @brief Algorithm execution
+     ** @param digis to calibrate
+     ** @return pair: digi timeslice, monitoring data
+     **
+     ** @note Modifies input digis for time calibration
+     **/
+    resultType operator()(gsl::span<CbmTofDigi> digiIn);
+
+    /** @brief Default constructor **/
+    Calibrate() {};
+
+    /** @brief Destructor **/
+    ~Calibrate() {};
+
+    /** @brief Parameters for TOF hitfinders **/
+    tof::HitfindSetup fTofConfig {};
+
+  private:  // members
+    /** @brief Applies calibration to input digis **/
+    std::vector<CbmTofDigi> CalibRawDigis(gsl::span<CbmTofDigi> digiVec, CalibrateMonitorData& monitor);
+  };
+}  // namespace cbm::algo::tof
+
+#endif /* TOFCALIBRATE_H */

algo/detectors/tof/Hitfind.cxx

@@ -24,10 +24,12 @@ namespace cbm::algo::tof
 
     auto& clusterTs = std::get<0>(result);
     auto& monitor   = std::get<1>(result);
-    auto& calDigi   = std::get<2>(result);
+    //auto& calDigi   = std::get<2>(result);
 
     // Do calibration globally (optional, should not be used together with RPC-wise calibration)
-    calDigi = CalibRawDigis(digiIn, monitor);
+    //calDigi = CalibRawDigis(digiIn, monitor);
+
+    auto& calDigi = digiIn;
 
     // Loop over the digis array and store the Digis in separate vectors for
     // each RPC modules

reco/tasks/CbmTaskTofClusterizer.cxx

@@ -313,6 +313,7 @@ bool CbmTaskTofClusterizer::InitAlgos()
   cbm::algo::fs::path paramsPath = "TofHitfinderPar.yaml";
   YAML::Node yaml                = YAML::LoadFile(paramsPath.string());
   fAlgo.fTofConfig               = cbm::algo::config::Read<cbm::algo::tof::HitfindSetup>(yaml);
+  fCalibrate.fTofConfig          = cbm::algo::config::Read<cbm::algo::tof::HitfindSetup>(yaml);
   fAlgo.Init();
   return true;
 }
@@ -347,13 +348,17 @@ bool CbmTaskTofClusterizer::BuildClusters()
     }
   }
 
+  // Calibrated digis (calibration done in algo)
+  // Can be left out if calibrated digis not stored separately!
+  *fTofCalDigiVec = fCalibrate(fTofDigiVec).first;
+
   //call cluster finder
-  auto clusterOut = fAlgo(fTofDigiVec);
+  auto clusterOut = fAlgo(*fTofCalDigiVec);
   auto clusters   = std::get<0>(clusterOut);
 
   // Calibrated digis (calibration done in algo)
   // Can be left out if calibrated digis not stored separately!
-  *fTofCalDigiVec = std::get<2>(clusterOut);
+  //*fTofCalDigiVec = std::get<2>(clusterOut);
 
   //Store hits and match
   for (auto const& cluster : clusters.Data()) {

reco/tasks/CbmTaskTofClusterizer.h

@@ -14,6 +14,7 @@ class CbmTsEventHeader;
 #include "CbmMatch.h"
 #include "CbmTofDigi.h"
 
+#include "tof/Calibrate.h"
 #include "tof/Clusterizer.h"
 #include "tof/Hitfind.h"
 
@@ -97,7 +98,6 @@ private:
 
   std::vector<CbmTofDigi>* fT0DigiVec = nullptr;  //! T0 Digis
 
-
   /**
        ** @brief Copy constructor.
        **/
@@ -130,6 +130,9 @@ private:
   // Hit finder algo
   cbm::algo::tof::Hitfind fAlgo;
 
+  // Calibrator algo
+  cbm::algo::tof::Calibrate fCalibrate;
+
   const CbmTsEventHeader* fTsHeader;
 
   // Input variables