RecoSetup.h

Go to the documentation of this file.

/* Copyright (C) 2025 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */

 
 
#ifndef CBM_ALGO_RecoSetup_h
#define CBM_ALGO_RecoSetup_h 1
 
#include "CbmDefs.h"
#include "CbmStructLooper.h"
#include "CbmTypeTraits.h"
#include "algo/detectors/much/RecoSetupUnit.h"
#include "algo/detectors/mvd/RecoSetupUnit.h"
#include "algo/detectors/sts/RecoSetupUnit.h"
#include "algo/detectors/tof/RecoSetupUnit.h"
#include "algo/detectors/trd/RecoSetupUnit.h"
 
#include <boost/serialization/access.hpp>
#include <boost/serialization/split_free.hpp>
 
#include <functional>
#include <optional>
#include <tuple>
#include <type_traits>
#include <variant>
 
namespace cbm::algo
{
  // clang-format off
  namespace detail 
  {
    template<ECbmModuleId> struct RecoSetupUnitMapper;
 
    template<> struct RecoSetupUnitMapper<ECbmModuleId::kMvd> { using type = mvd::RecoSetupUnit; };
    template<> struct RecoSetupUnitMapper<ECbmModuleId::kSts> { using type = sts::RecoSetupUnit; };
    template<> struct RecoSetupUnitMapper<ECbmModuleId::kMuch> { using type = much::RecoSetupUnit; };
    template<> struct RecoSetupUnitMapper<ECbmModuleId::kTrd> { using type = trd::RecoSetupUnit; };
    template<> struct RecoSetupUnitMapper<ECbmModuleId::kTof> { using type = tof::RecoSetupUnit; };
  }
  // clang-format on
 
  template<ECbmModuleId ModuleId>
  using RecoSetupUnit_t = typename detail::RecoSetupUnitMapper<ModuleId>::type;
 
  // clang-format off
  using RecoSetupUnitPtrVariant_t = std::variant<const mvd::RecoSetupUnit*, 
                                                 const sts::RecoSetupUnit*, 
                                                 const much::RecoSetupUnit*, 
                                                 const trd::RecoSetupUnit*, 
                                                 const tof::RecoSetupUnit*>;
  // clang-format on

  class RecoSetup {
   public:
    //* Member methods

    RecoSetup() = default;

    RecoSetup(const std::string& filename);

    template<class Visitor>
    void ForEachOptUnit(Visitor&& visitor) const
    {
      kUnits.ForEachVariable(this, std::forward<Visitor>(visitor));
    }

    template<class Visitor>
    void ForEachOptUnit(Visitor&& visitor)
    {
      kUnits.ForEachVariable(this, std::forward<Visitor>(visitor));
    }

    template<class Visitor>
    void ForEachUnit(Visitor&& visitor) const
    {
      kUnits.ForEachValue(this, std::forward<Visitor>(visitor));
    }

    template<class Visitor>
    void ForEachUnit(Visitor&& visitor)
    {
      kUnits.ForEachValue(this, std::forward<Visitor>(visitor));
    }
 

    template<ECbmModuleId ModuleId>
    const RecoSetupUnit_t<ModuleId>* Get() const
    {
      static_assert(cbm::util::is_in_sequence_v<ModuleId, ECbmModuleId::kMvd, ECbmModuleId::kSts, ECbmModuleId::kMuch,
                                                ECbmModuleId::kTrd, ECbmModuleId::kTof>,
                    "Unsupported ECbmModuleId (SFINAE)");
 
      if constexpr (ModuleId == ECbmModuleId::kMuch)
        return GetMuch();
      else if constexpr (ModuleId == ECbmModuleId::kMvd)
        return GetMvd();
      else if constexpr (ModuleId == ECbmModuleId::kSts)
        return GetSts();
      else if constexpr (ModuleId == ECbmModuleId::kTrd)
        return GetTrd();
      else if constexpr (ModuleId == ECbmModuleId::kTof)
        return GetTof();
    }

    const much::RecoSetupUnit* GetMuch() const { return HasMuch() ? &fMuch.value() : nullptr; }

    const mvd::RecoSetupUnit* GetMvd() const { return HasMvd() ? &fMvd.value() : nullptr; }

    const sts::RecoSetupUnit* GetSts() const { return HasSts() ? &fSts.value() : nullptr; }

    const tof::RecoSetupUnit* GetTof() const { return HasTof() ? &fTof.value() : nullptr; }

    const trd::RecoSetupUnit* GetTrd() const { return HasTrd() ? &fTrd.value() : nullptr; }

    template<ECbmModuleId ModuleId>
    bool Has() const
    {
      if constexpr (ModuleId == ECbmModuleId::kMuch)
        return HasMuch();
      else if constexpr (ModuleId == ECbmModuleId::kMvd)
        return HasMvd();
      else if constexpr (ModuleId == ECbmModuleId::kSts)
        return HasSts();
      else if constexpr (ModuleId == ECbmModuleId::kTrd)
        return HasTrd();
      else if constexpr (ModuleId == ECbmModuleId::kTof)
        return HasTof();
      return false;
    }

    bool Has(ECbmModuleId moduleId) const;

    bool HasMuch() const { return fMuch.has_value(); }

    bool HasMvd() const { return fMvd.has_value(); }

    bool HasSts() const { return fSts.has_value(); }

    bool HasTof() const { return fTof.has_value(); }

    bool HasTrd() const { return fTrd.has_value(); }

    void SetMuch(much::RecoSetupUnit much) { fMuch = std::make_optional(std::move(much)); }

    void SetMvd(mvd::RecoSetupUnit mvd) { fMvd = std::make_optional(std::move(mvd)); }

    void SetSts(sts::RecoSetupUnit sts) { fSts = std::make_optional(std::move(sts)); }

    void SetTof(tof::RecoSetupUnit tof) { fTof = std::make_optional(std::move(tof)); }

    void SetTrd(trd::RecoSetupUnit trd) { fTrd = std::make_optional(std::move(trd)); }

    std::string ToString() const;
 
 
    //* Static methods

    static RecoSetup Load(const std::string& filename);

    static void Store(const RecoSetup& setup, const std::string& filename);
 
   private:
    std::optional<mvd::RecoSetupUnit> fMvd{std::nullopt};    
    std::optional<sts::RecoSetupUnit> fSts{std::nullopt};    
    std::optional<much::RecoSetupUnit> fMuch{std::nullopt};  
    std::optional<trd::RecoSetupUnit> fTrd{std::nullopt};    
    std::optional<tof::RecoSetupUnit> fTof{std::nullopt};    

    // clang-format off
    static constexpr auto kUnits = cbm::util::StructLooper(
      &RecoSetup::fMvd, 
      &RecoSetup::fSts, 
      &RecoSetup::fMuch, 
      &RecoSetup::fTrd, 
      &RecoSetup::fTof
    );
    // clang-format on
 
    friend class boost::serialization::access;
    template<class Archive>
    void load(Archive& ar, const unsigned int /*version*/)
    {
      ForEachOptUnit([&ar](auto& unit) {
        bool isNotNullopt;
        ar >> isNotNullopt;
        if (isNotNullopt) {
          using Unit_t = typename std::remove_reference_t<decltype(unit)>::value_type;
          Unit_t res{};
          ar >> res;
          unit = std::make_optional(std::move(res));
        }
        else {
          unit = std::nullopt;
        }
      });
    }

    template<class Archive>
    void save(Archive& ar, const unsigned int /*version*/) const
    {
      ForEachOptUnit([&ar](const auto& unit) {
        if (unit.has_value()) {
          ar << true;
          ar << unit.value();
        }
        else {
          ar << false;
        }
      });
    }

    template<class Archive>
    void serialize(Archive& ar, const unsigned int version)
    {
      boost::serialization::split_member(ar, *this, version);
    }
  };
 
}  // namespace cbm::algo
 
#endif  // CBM_ALGO_RecoSetup_h