algo/base/Definitions.h

+/* Copyright (C) 2023 FIAS Frankfurt Institute for Advanced Studies, Frankfurt / Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Felix Weiglhofer [committer] */
+#ifndef CBM_BASE_TYPES_H
+#define CBM_BASE_TYPES_H
+
+#include "MicrosliceDescriptor.hpp"  // For fles::Subsystem
+#include "util/EnumDict.h"
+
+#include <cstdint>
+
+namespace cbm::algo
+{
+
+  // typealias for Rust-like fixed size integer types
+  using i8  = std::int8_t;
+  using u8  = std::uint8_t;
+  using i16 = std::int16_t;
+  using u16 = std::uint16_t;
+  using i32 = std::int32_t;
+  using u32 = std::uint32_t;
+  using i64 = std::int64_t;
+  using u64 = std::uint64_t;
+  using f32 = float;
+  using f64 = double;
+
+#ifdef CBM_ALGO_REAL64
+  using real = f64;
+#else
+  using real = f32;
+#endif
+
+  enum class Step
+  {
+    Unpack,
+    DigiTrigger,
+    LocalReco,
+    Tracking,
+  };
+
+  enum class RecoData
+  {
+    DigiTimeslice,  //< Raw output from unpackers
+    DigiEvent,      //< Digis after event building
+    Cluster,
+    Hit,
+    Track,
+  };
+
+  // FIXME: Remove the Setup enumeration, replace it with a config.
+  enum class Setup
+  {
+    mCBM2022,
+    mCBM2024_03,
+    mCBM2024_05,
+    mCBM2025_02,
+  };
+
+  enum class QaStep
+  {
+    BeamBmon,
+    UnpackBmon,
+    UnpackSts,
+    UnpackMvd,
+    UnpackRich,
+    UnpackTrd1d,
+    UnpackTrd2d,
+    UnpackMuch,
+    UnpackTof,
+    UnpackFsd,
+    EventBuilding,
+    RecoBmon,
+    RecoSts,
+    RecoMvd,
+    RecoRich,
+    RecoTrd1d,
+    RecoTrd2d,
+    RecoMuch,
+    RecoTof,
+    RecoFsd,
+    Tracking,
+    V0Finder,
+    V0Trigger,
+  };
+
+}  // namespace cbm::algo
+
+CBM_ENUM_DICT(fles::Subsystem,
+  // CBM detectors
+  {"STS", fles::Subsystem::STS},
+  {"MVD", fles::Subsystem::MVD},
+  {"RICH", fles::Subsystem::RICH},
+  {"TRD", fles::Subsystem::TRD},
+  {"TRD2D", fles::Subsystem::TRD2D},
+  {"MUCH", fles::Subsystem::MUCH},
+  {"TOF", fles::Subsystem::TOF},
+
+  // Other detectors (experimental)
+  {"ECAL", fles::Subsystem::ECAL},
+  {"PSD", fles::Subsystem::PSD},
+  {"BMON", fles::Subsystem::BMON},
+  {"TRB3", fles::Subsystem::TRB3},
+  {"Hodoscope", fles::Subsystem::Hodoscope},
+  {"Cherenkov", fles::Subsystem::Cherenkov},
+  {"LeadGlass", fles::Subsystem::LeadGlass},
+
+  // FLES (pattern generators)
+  {"FLES", fles::Subsystem::FLES},
+);
+
+CBM_ENUM_DICT(cbm::algo::Step,
+  {"Unpack", Step::Unpack},
+  {"DigiTrigger", Step::DigiTrigger},
+  {"LocalReco", Step::LocalReco},
+  {"Tracking", Step::Tracking}
+);
+
+CBM_ENUM_DICT(cbm::algo::RecoData,
+  {"DigiTimeslice", RecoData::DigiTimeslice},
+  {"DigiEvent", RecoData::DigiEvent},
+  {"Cluster", RecoData::Cluster},
+  {"Hit", RecoData::Hit},
+  {"Track", RecoData::Track}
+);
+
+CBM_ENUM_DICT(cbm::algo::Setup,
+  {"mCBM2022", cbm::algo::Setup::mCBM2022},
+  {"mCBM2024_03", cbm::algo::Setup::mCBM2024_03},
+  {"mCBM2024_05", cbm::algo::Setup::mCBM2024_05},
+  {"mCBM2025_02", cbm::algo::Setup::mCBM2025_02}
+);
+
+CBM_ENUM_DICT(cbm::algo::QaStep,
+  {"BeamBmon", cbm::algo::QaStep::BeamBmon},
+  {"UnpackBmon", cbm::algo::QaStep::UnpackBmon},
+  {"UnpackSts", cbm::algo::QaStep::UnpackSts},
+  {"UnpackMvd", cbm::algo::QaStep::UnpackMvd},
+  {"UnpackRich", cbm::algo::QaStep::UnpackRich},
+  {"UnpackTrd1d", cbm::algo::QaStep::UnpackTrd1d},
+  {"UnpackTrd2d", cbm::algo::QaStep::UnpackTrd2d},
+  {"UnpackMuch", cbm::algo::QaStep::UnpackMuch},
+  {"UnpackTof", cbm::algo::QaStep::UnpackTof},
+  {"UnpackFsd", cbm::algo::QaStep::UnpackFsd},
+  {"EventBuilding", cbm::algo::QaStep::EventBuilding},
+  {"RecoBmon", cbm::algo::QaStep::RecoBmon},
+  {"RecoSts", cbm::algo::QaStep::RecoSts},
+  {"RecoMvd", cbm::algo::QaStep::RecoMvd},
+  {"RecoRich", cbm::algo::QaStep::RecoRich},
+  {"RecoTrd1d", cbm::algo::QaStep::RecoTrd1d},
+  {"RecoTrd2d", cbm::algo::QaStep::RecoTrd2d},
+  {"RecoMuch", cbm::algo::QaStep::RecoMuch},
+  {"RecoTof", cbm::algo::QaStep::RecoTof},
+  {"RecoFsd", cbm::algo::QaStep::RecoFsd},
+  {"Tracking", cbm::algo::QaStep::Tracking},
+  {"V0Finder", cbm::algo::QaStep::V0Finder},
+  {"V0Trigger", cbm::algo::QaStep::V0Trigger}
+);
+
+#endif

algo/base/DigiData.cxx

+/* Copyright (C) 2023 FIAS Frankfurt Institute for Advanced Studies, Frankfurt / Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Felix Weiglhofer [committer] */
+#include "DigiData.h"
+
+using namespace cbm::algo;
+
+// Ctor / Dtor defined in .cxx file so we can use forward declarations for digi types in the header
+
+DigiData::DigiData() {}
+
+DigiData::~DigiData() {}
+
+DigiData::DigiData(const CbmDigiData& storable)
+  : fSts(ToPODVector(storable.fSts.fDigis))
+  , fMuch(ToPODVector(storable.fMuch.fDigis))
+  , fTof(ToPODVector(storable.fTof.fDigis))
+  , fBmon(ToPODVector(storable.fBmon.fDigis))
+  , fTrd(ToPODVector(storable.fTrd.fDigis))
+  , fTrd2d(ToPODVector(storable.fTrd2d.fDigis))
+  , fRich(ToPODVector(storable.fRich.fDigis))
+  , fPsd(ToPODVector(storable.fPsd.fDigis))
+  , fFsd(ToPODVector(storable.fFsd.fDigis))
+{
+}
+
+size_t DigiData::Size(ECbmModuleId system) const
+{
+  switch (system) {
+    case ECbmModuleId::kSts: return fSts.size();
+    case ECbmModuleId::kMuch: return fMuch.size();
+    case ECbmModuleId::kTof: return fTof.size();
+    case ECbmModuleId::kBmon: return fBmon.size();
+    case ECbmModuleId::kTrd: return fTrd.size();
+    case ECbmModuleId::kTrd2d: return fTrd2d.size();
+    case ECbmModuleId::kRich: return fRich.size();
+    case ECbmModuleId::kPsd: return fPsd.size();
+    case ECbmModuleId::kFsd: return fFsd.size();
+    default: throw std::runtime_error("DigiData: Invalid system Id " + ::ToString(system));
+  }
+}
+
+size_t DigiData::TotalSize() const
+{
+  return fSts.size() + fMuch.size() + fTof.size() + fBmon.size() + fTrd.size() + fTrd2d.size() + fRich.size()
+         + fPsd.size() + fFsd.size();
+}
+
+size_t DigiData::TotalSizeBytes() const
+{
+  return sizeof(CbmStsDigi) * fSts.size() + sizeof(CbmMuchDigi) * fMuch.size() + sizeof(CbmTofDigi) * fTof.size()
+         + sizeof(CbmBmonDigi) * fBmon.size() + sizeof(CbmTrdDigi) * fTrd.size() + sizeof(CbmTrdDigi) * fTrd2d.size()
+         + sizeof(CbmRichDigi) * fRich.size() + sizeof(CbmPsdDigi) * fPsd.size() + sizeof(CbmFsdDigi) * fFsd.size();
+}
+
+CbmDigiData DigiData::ToStorable() const
+{
+  return CbmDigiData{
+    .fBmon =
+      {
+        .fDigis = ToStdVector(fBmon),
+      },
+    .fSts =
+      {
+        .fDigis = ToStdVector(fSts),
+      },
+    .fMuch =
+      {
+        .fDigis = ToStdVector(fMuch),
+      },
+    .fRich =
+      {
+        .fDigis = ToStdVector(fRich),
+      },
+    .fTrd =
+      {
+        .fDigis = ToStdVector(fTrd),
+      },
+    .fTrd2d =
+      {
+        .fDigis = ToStdVector(fTrd2d),
+      },
+    .fTof =
+      {
+        .fDigis = ToStdVector(fTof),
+      },
+    .fPsd =
+      {
+        .fDigis = ToStdVector(fPsd),
+      },
+    .fFsd =
+      {
+        .fDigis = ToStdVector(fFsd),
+      },
+  };
+}
+
+std::vector<DigiEvent> DigiEvent::FromCbmDigiEvents(const std::vector<CbmDigiEvent>& events)
+{
+  std::vector<DigiEvent> result;
+  result.reserve(events.size());
+  for (const auto& event : events) {
+    result.emplace_back(event);
+  }
+  return result;
+}
+
+std::vector<CbmDigiEvent> DigiEvent::ToCbmDigiEvents(const std::vector<DigiEvent>& events)
+{
+  std::vector<CbmDigiEvent> result;
+  result.reserve(events.size());
+  for (const auto& event : events) {
+    result.emplace_back(event.ToStorable());
+  }
+  return result;
+}
+
+DigiEvent::DigiEvent(const CbmDigiEvent& storable)
+  : DigiData(storable.fData)
+  , fNumber(storable.fNumber)
+  , fTime(storable.fTime)
+  , fSelectionTriggers(storable.fSelectionTriggers)
+{
+}
+
+CbmDigiEvent DigiEvent::ToStorable() const
+{
+  return CbmDigiEvent{
+    .fData              = DigiData::ToStorable(),
+    .fNumber            = fNumber,
+    .fTime              = fTime,
+    .fSelectionTriggers = fSelectionTriggers,
+  };
+}

algo/base/DigiData.h

+/* Copyright (C) 2023 FIAS Frankfurt Institute for Advanced Studies, Frankfurt / Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Felix Weiglhofer [committer] */
+#ifndef CBM_ALGO_BASE_DIGI_DATA_H
+#define CBM_ALGO_BASE_DIGI_DATA_H
+
+#include "CbmBmonDigi.h"
+#include "CbmDigiData.h"
+#include "CbmDigiEvent.h"
+#include "CbmEventTriggers.h"
+#include "CbmFsdDigi.h"
+#include "CbmMuchDigi.h"
+#include "CbmPsdDigi.h"
+#include "CbmRichDigi.h"
+#include "CbmStsDigi.h"
+#include "CbmTofDigi.h"
+#include "CbmTrdDigi.h"
+#include "PODVector.h"
+
+namespace cbm::algo
+{
+  /**
+   * @brief Collection of digis from all detector systems
+   *
+   * Very similar to CbmDigiData. CbmDigiData is meant for file storage,
+   * while this is used for the actual processing. Seperate classes
+   * allow for more flexibility and easier optimization.
+   *
+   * @see CbmDigiData
+   * @note Uses PODVector for storage, so memory is not initialized by default.
+   */
+  struct DigiData {
+    PODVector<CbmStsDigi> fSts;    ///< Unpacked STS digis
+    PODVector<CbmMuchDigi> fMuch;  ///< Unpacked MUCH digis
+    PODVector<CbmTofDigi> fTof;    ///< Unpacked TOF digis
+    PODVector<CbmBmonDigi> fBmon;  ///< Unpacked Bmon digis
+    PODVector<CbmTrdDigi> fTrd;    ///< Unpacked TRD digis
+    PODVector<CbmTrdDigi> fTrd2d;  ///< Unpacked TRD2D digis
+    PODVector<CbmRichDigi> fRich;  ///< Unpacked RICH digis
+    PODVector<CbmPsdDigi> fPsd;    ///< Unpacked PSD digis
+    PODVector<CbmFsdDigi> fFsd;    ///< Unpacked FSD digis
+
+    DigiData();
+    ~DigiData();
+
+    explicit DigiData(const CbmDigiData& storable);
+
+    /**
+     * @brief Get the number of digis for a given subsystem
+     *
+     * @param system Subsystem to get the number of digis for
+     * @todo Should use fles::Subsystem instead ECbmModuleId
+     */
+    size_t Size(ECbmModuleId system) const;
+
+    /**
+     * @brief Get the total number of digis across all subsystems.
+     */
+    size_t TotalSize() const;
+
+    /**
+     * @brief Get the total number of bytes used by all digis.
+     */
+    size_t TotalSizeBytes() const;
+
+    /**
+     * @brief Convert to CbmDigiData for file storage
+     *
+     * @note This is a very expensive operation, as it copies all data.
+     */
+    CbmDigiData ToStorable() const;
+  };
+
+  /**
+   * @brief Event data with event number and trigger time
+   *
+   * @see CbmDigitEvent
+   * @note Uses PODVector for storage, so memory is not initialized by default.
+   */
+  struct DigiEvent : public DigiData {
+    // FIXME: Event number not set yet!
+    uint64_t fNumber = -1;  ///< Event identifier
+    double fTime     = 0;   ///< Event trigger time [ns]
+    CbmEventTriggers fSelectionTriggers;
+
+    static std::vector<DigiEvent> FromCbmDigiEvents(const std::vector<CbmDigiEvent>& events);
+    static std::vector<CbmDigiEvent> ToCbmDigiEvents(const std::vector<DigiEvent>& events);
+
+    DigiEvent() = default;
+
+    explicit DigiEvent(const CbmDigiEvent& storable);
+
+    /**
+   * @brief Convert to CbmDigiEvent for file storage
+   *
+   * @note This is a very expensive operation, as it copies all data.
+   */
+    CbmDigiEvent ToStorable() const;
+  };
+
+}  // namespace cbm::algo
+
+#endif  // CBM_ALGO_BASE_DIGI_DATA_H

algo/base/Exceptions.h

+/* Copyright (C) 2023 FIAS Frankfurt Institute for Advanced Studies, Frankfurt / Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Felix Weiglhofer [committer] */
+#ifndef CBM_ALGO_BASE_EXCEPTIONS_H
+#define CBM_ALGO_BASE_EXCEPTIONS_H
+
+#include <exception>
+#include <string_view>
+
+#include <fmt/format.h>
+
+namespace cbm::algo
+{
+
+  namespace detail
+  {
+    /**
+     * @brief Base class for exceptions.
+     *
+     * @note Should not be thrown directly. Use one of the derived classes instead.
+     */
+    struct Exception : std::runtime_error {
+      template<typename... Args>
+      Exception(std::string_view fmt, Args&&... args)
+        : std::runtime_error(fmt::format(fmt, std::forward<Args>(args)...))
+      {
+      }
+    };
+  }  // namespace detail
+
+  /**
+   * @brief Indicates an unrecoverable error. Should tear down the process.
+   */
+  struct FatalError : detail::Exception {
+    using Exception::Exception;
+  };
+
+  /**
+   * Indicates an error during timeslice processing. Timeslice will be discarded.
+   * Processing can continue with new timeslice.
+   */
+  struct ProcessingError : detail::Exception {
+    using Exception::Exception;
+  };
+
+}  // namespace cbm::algo
+
+#endif

algo/base/HistogramSender.h

+/* Copyright (C) 2023 FIAS Frankfurt Institute for Advanced Studies, Frankfurt / Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Felix Weiglhofer [committer] */
+#ifndef CBM_ALGO_BASE_HISTOGRAM_SENDER_H
+#define CBM_ALGO_BASE_HISTOGRAM_SENDER_H
+
+#include <boost/archive/binary_oarchive.hpp>
+#include <boost/iostreams/device/array.hpp>
+#include <boost/iostreams/device/back_inserter.hpp>
+#ifdef BOOST_IOS_HAS_ZSTD
+#include <boost/iostreams/filter/zstd.hpp>
+#include <boost/iostreams/filtering_stream.hpp>
+#endif
+#include <boost/iostreams/stream.hpp>
+#include <boost/serialization/utility.hpp>
+#include <boost/serialization/vector.hpp>
+
+#include <string>
+#include <string_view>
+#include <zmq.hpp>
+
+namespace cbm::algo
+{
+
+  class HistogramSender {
+   public:
+    HistogramSender(std::string_view address, int32_t hwm = 1, bool compression = false)
+      : fHistComChan(address)
+      , fHistHighWaterMark(hwm)
+      , fbCompression(compression)
+      , fZmqContext(1)
+      , fZmqSocket(fZmqContext, zmq::socket_type::push)
+    {
+      fZmqSocket.set(zmq::sockopt::sndhwm, fHistHighWaterMark);  // High-Water Mark, max nb updates kept in out buffer
+      fZmqSocket.connect(fHistComChan);  // This side "connects" to socket => Other side should have "bind"!!!!
+    }
+
+    /** @brief Serialize object and send it to the histogram server
+       ** @param obj: object to be serialized in the message, e.g. config pairs of strings or QaData
+       ** @param flags: or'ed values from zmq::send_flags, typ. zmq::send_flags::sndmore to indicate multi-parts message
+       **/
+    template<typename Object>
+    void PrepareAndSendMsg(const Object& obj, zmq::send_flags flags)
+    {
+      /// Needed ressources (serializd string, boost inserter, boost stream, boost binary output archive)
+      namespace b_io = boost::iostreams;
+      namespace b_ar = boost::archive;
+
+      std::string serial_str;
+      b_io::back_insert_device<std::string> inserter(serial_str);
+      b_io::stream<b_io::back_insert_device<std::string>> bstream(inserter);
+
+      serial_str.clear();
+
+      if (fbCompression) {
+#ifdef BOOST_IOS_HAS_ZSTD
+        std::unique_ptr<b_io::filtering_ostream> out_ = std::make_unique<b_io::filtering_ostream>();
+        out_->push(b_io::zstd_compressor(b_io::zstd::best_speed));
+        out_->push(bstream);
+        std::unique_ptr<b_ar::binary_oarchive> oarchive_ =
+          std::make_unique<b_ar::binary_oarchive>(*out_, b_ar::no_header);
+        *oarchive_ << obj;
+#else
+        throw std::runtime_error("Unsupported ZSTD compression (boost) for histograms emissions channel");
+#endif
+      }
+      else {
+        b_ar::binary_oarchive oa(bstream);
+        oa << obj;
+      }
+      bstream.flush();
+
+      zmq::message_t msg(serial_str.size());
+      std::copy_n(static_cast<const char*>(serial_str.data()), msg.size(), static_cast<char*>(msg.data()));
+      /// FIXME: read return value to catch EAGAIN indicating a failed emission, use it outside to skip histo reset
+      fZmqSocket.send(msg, flags | zmq::send_flags::dontwait);
+    }
+
+   private:
+    std::string fHistComChan   = "tcp://127.0.0.1:56800";
+    int32_t fHistHighWaterMark = 1;
+    bool fbCompression         = false;
+    zmq::context_t fZmqContext;  ///< ZMQ context FIXME: should be only one context per binary!
+    zmq::socket_t fZmqSocket;    ///< ZMQ socket to histogram server
+  };
+
+}  // namespace cbm::algo
+
+#endif

algo/base/MainConfig.cxx

+/* Copyright (C) 2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Volker Friese [committer] */
+
+#include "MainConfig.h"
+
+#include <fstream>
+
+#include <yaml-cpp/yaml.h>
+
+namespace cbm::algo
+{
+
+  // -----   Load configuration from YAML file   --------------------------------
+  void MainConfig::LoadYaml(const std::string& filename)
+  {
+    YAML::Node config = YAML::LoadFile(filename);
+
+    // --- Digi trigger
+    fTriggerDet       = ToCbmModuleIdCaseInsensitive(config["trigger"]["detector"].as<std::string>());
+    fTriggerWin       = config["trigger"]["window"].as<double>();
+    fTriggerThreshold = config["trigger"]["threshold"].as<size_t>();
+    fTriggerDeadTime  = config["trigger"]["deadtime"].as<double>();
+
+    // --- Event builder: (detector -> (tMin, tMax))
+    if (auto eventbuilder = config["eventbuilder"]) {
+      if (auto windows = eventbuilder["windows"]) {
+        for (YAML::const_iterator it = windows.begin(); it != windows.end(); ++it) {
+          auto det              = ToCbmModuleIdCaseInsensitive(it->first.as<std::string>());
+          auto lower            = it->second[0].as<double>();
+          auto upper            = it->second[1].as<double>();
+          fEvtbuildWindows[det] = std::make_pair(lower, upper);
+        }
+      }
+    }
+
+    // --- Event selector parameters
+    fSelectMinStationsSts = config["selector"]["minStationsSts"].as<size_t>();
+    fSelectMinStationsTof = config["selector"]["minStationsTof"].as<size_t>();
+    fSelectMinDigisBmon   = config["selector"]["minDigisBmon"].as<size_t>();
+
+    // --- Branch persistence in output file
+    fStoreTimeslice = config["store"]["timeslice"].as<bool>();
+    fStoreTrigger   = config["store"]["triggers"].as<bool>();
+    fStoreEvents    = config["store"]["events"].as<bool>();
+
+    // --- QA publishing
+    fHttpServerRefreshRate = config["qa"]["refreshrate"].as<int32_t>(fHttpServerRefreshRate);
+  }
+  // ----------------------------------------------------------------------------
+
+
+  // -----   Save configuration to YAML file   ----------------------------------
+  void MainConfig::SaveYaml(const std::string& filename)
+  {
+    YAML::Node config;
+
+    // --- Digi trigger
+    config["trigger"]["detector"]  = ToString(fTriggerDet);
+    config["trigger"]["window"]    = fTriggerWin;
+    config["trigger"]["threshold"] = fTriggerThreshold;
+    config["trigger"]["deadtime"]  = fTriggerDeadTime;
+
+    // --- Event builder: (detector -> (tMin, tMax))
+    for (const auto& [key, value] : fEvtbuildWindows) {
+      auto det = ToString(key);
+      config["eventbuilder"]["windows"][det].push_back(value.first);
+      config["eventbuilder"]["windows"][det].push_back(value.second);
+    };
+
+    // --- Event selector
+    config["selector"]["minStationsSts"] = fSelectMinStationsSts;
+    config["selector"]["minStationsTof"] = fSelectMinStationsTof;
+    config["selector"]["minDigisBmon"]   = fSelectMinDigisBmon;
+
+
+    // --- Branch persistence in output file
+    config["store"]["timeslice"] = fStoreTimeslice;
+    config["store"]["triggers"]  = fStoreTrigger;
+    config["store"]["events"]    = fStoreEvents;
+    // --- QA publishing
+    config["qa"]["refreshrate"] = fHttpServerRefreshRate;
+    // ---
+    std::ofstream fout(filename);
+    fout << config;
+  }
+  // ----------------------------------------------------------------------------
+
+} /* namespace cbm::algo */

algo/base/MainConfig.h

+/* Copyright (C) 2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Volker Friese [committer] */
+
+
+#ifndef ALGO_BASE_MAINCONFIG_H_
+#define ALGO_BASE_MAINCONFIG_H_
+
+#include "CbmDefs.h"
+
+#include <map>
+
+namespace cbm::algo
+{
+
+  /** @class MainConfig
+   ** @brief Configuration of online data processing
+   ** @author Volker Friese <v.friese@gsi.de>
+   ** @since 10 July 2023
+   **/
+  class MainConfig {
+   public:  // methods
+    /** @brief Constructor **/
+    MainConfig() = default;
+
+    /** @brief Constructor **/
+    ~MainConfig() = default;
+
+    /** @brief Load from YAML file **/
+    void LoadYaml(const std::string& filename);
+
+    /** @brief Save to YAML file **/
+    void SaveYaml(const std::string& filename);
+
+   public:  // data members
+    // --- Digi trigger
+    ECbmModuleId fTriggerDet = ECbmModuleId::kNotExist;  // Trigger detector
+    double fTriggerWin       = 0.;                       // Trigger window size [ns]
+    size_t fTriggerThreshold = 0;                        // Minimum number if digis in trigger window
+    double fTriggerDeadTime  = 0.;                       // Minimal time between two trigger [ns]
+
+    // --- Event builder: (detector -> (tMin, tMax))
+    std::map<ECbmModuleId, std::pair<double, double>> fEvtbuildWindows = {};
+
+    // --- Event selector
+    size_t fSelectMinStationsSts = 0;
+    size_t fSelectMinStationsTof = 0;
+    size_t fSelectMinDigisBmon   = 0;
+
+    // --- Branch persistence in output file
+    bool fStoreTimeslice = false;
+    bool fStoreTrigger   = false;
+    bool fStoreEvents    = false;
+
+    // --- QA publishing
+    int32_t fHttpServerRefreshRate = 100;
+  };
+
+} /* namespace cbm::algo */
+
+#endif /* ALGO_BASE_MAINCONFIG_H_ */

algo/base/PODVector.h

+/* Copyright (C) 2022 FIAS Frankfurt Institute for Advanced Studies, Frankfurt / Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Felix Weiglhofer [committer] */
+#ifndef CBM_ALGO_BASE_POD_VECTOR_H
+#define CBM_ALGO_BASE_POD_VECTOR_H
+
+#include "util/PODAllocator.h"
+
+#include <vector>
+
+namespace cbm::algo
+{
+  /**
+  * @brief PODVector is a std::vector that doesn't initialize its elements.
+  */
+  template<class T>
+  using PODVector = std::vector<T, PODAllocator<T>>;
+
+  template<typename T>
+  std::vector<T> ToStdVector(const PODVector<T>& vec)
+  {
+    return std::vector<T>(vec.begin(), vec.end());
+  }
+
+  template<typename T>
+  PODVector<T> ToPODVector(const std::vector<T>& vec)
+  {
+    return PODVector<T>(vec.begin(), vec.end());
+  }
+
+}  // namespace cbm::algo
+
+#endif  // CBM_ALGO_BASE_POD_VECTOR_H

algo/base/RecoParams.cxx

+/* Copyright (C) 2024 FIAS Frankfurt Institute for Advanced Studies, Frankfurt / Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Felix Weiglhofer [committer] */
+#include "RecoParams.h"
+
+CBM_YAML_INSTANTIATE(cbm::algo::RecoParams);

algo/base/SubChain.h

+/* Copyright (C) 2023 FIAS Frankfurt Institute for Advanced Studies, Frankfurt / Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Felix Weiglhofer [committer] */
+#ifndef CBM_ALGO_BASE_SUBCHAIN_H
+#define CBM_ALGO_BASE_SUBCHAIN_H
+
+#include "ChainContext.h"
+
+#include <gsl/pointers>
+
+namespace cbm::algo
+{
+  class SubChain {
+
+   public:
+    const ChainContext* GetContext() { return fContext; }
+
+    void SetContext(const ChainContext* ctx) { fContext = ctx; }
+
+    const Options& Opts() const { return gsl::make_not_null(fContext)->opts; }
+    const RecoParams& Params() const { return gsl::make_not_null(fContext)->recoParams; }
+
+    bool HasMonitor() const { return gsl::make_not_null(fContext)->monitor != nullptr; }
+
+    Monitor& GetMonitor() const
+    {
+      // Need Get-prefix to avoid conflict with Monitor-class name
+      if (!HasMonitor()) throw std::runtime_error("No monitor available");
+      return *gsl::make_not_null(fContext)->monitor;
+    }
+
+
+   private:
+    const ChainContext* fContext = nullptr;
+  };
+}  // namespace cbm::algo
+
+#endif

algo/base/compat/Algorithm.cxx

+/* Copyright (C) 2024 FIAS Frankfurt Institute for Advanced Studies, Frankfurt / Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Felix Weiglhofer [committer] */
+
+#include "Algorithm.h"
+
+
+task_thread_pool::task_thread_pool& cbm::algo::GetGlobalSTLThreadPool()
+{
+  static task_thread_pool::task_thread_pool pool;
+  return pool;
+}