tof/RecoSetupUnit.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 ALGO_TOF_RecoSetupUnit_h
#define ALGO_TOF_RecoSetupUnit_h 1
 
#include "CbmDefs.h"
#include "CbmTofAddress.h"
#include "algo/setup/TrackingSetupIfs.h"
 
#include <boost/serialization/access.hpp>
#include <boost/serialization/export.hpp>
 
#include <utility>
#include <vector>
 
namespace cbm::algo::tof
{
  // TODO: probably can be re-used for defining the tof-related info TOF hit-finder (then, int -> tof::Module)
  class TrkStationIdMap {
   public:
    struct SmTypeInfo {
      uint32_t offset{0};  
      uint16_t nSm{0};     
      uint16_t nRpc{0};    
 
     private:
      friend boost::serialization::access;
      template<class Archive>
      void serialize(Archive& ar, const unsigned int /*version*/)
      {
        ar& offset;
        ar& nSm;
        ar& nRpc;
      }
    };

    TrkStationIdMap() = default;

    TrkStationIdMap(std::vector<SmTypeInfo>&& smTypeRpcMap, std::vector<int>&& trkStationIdMap);

    void Clear()
    {
      fSmTypeRpcMap.clear();
      fTrkStationIdMap.clear();
    }

    bool IsEmpty() const { return fSmTypeRpcMap.empty() && fTrkStationIdMap.empty(); }

    uint16_t GetNofSmTypes() const { return fSmTypeRpcMap.size(); }

    uint16_t GetNofRpc(uint16_t iSmType) const { return fSmTypeRpcMap[iSmType].nRpc; }

    uint16_t GetNofSm(uint16_t iSmType) const { return fSmTypeRpcMap[iSmType].nSm; }

    const auto& GetSmTypeRpcMap() const { return fSmTypeRpcMap; }

    const auto& GetTrkStationIdMap() const { return fTrkStationIdMap; }

    int GetTrackingStationIndex(uint16_t iSmType, uint16_t iSm, uint16_t iRpc) const
    {
      if (iSmType < GetNofSmTypes() && iSm < GetNofSm(iSmType) && iRpc < GetNofRpc(iSmType)) {
        const auto& smt = fSmTypeRpcMap[iSmType];
        return fTrkStationIdMap[smt.offset + iSm * smt.nRpc + iRpc];
      }
      return -1;
    }
 
   private:
    std::vector<SmTypeInfo> fSmTypeRpcMap{};  
    std::vector<int> fTrkStationIdMap{};      
 
    friend boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int /*version*/)
    {
      ar& fSmTypeRpcMap;
      ar& fTrkStationIdMap;
    }
  };

  class RecoSetupUnit : public TrackingSetupIfs<RecoSetupUnit> {
    friend class TrackingSetupIfs<RecoSetupUnit>;
 
   public:
    RecoSetupUnit() = default;

    RecoSetupUnit(std::pair<std::vector<GeoVolume>, std::vector<GeoVolume>>&& stationVolumes,
                  TrkStationIdMap&& trkStationIdMap);

    static constexpr std::string_view GetDetectorName() { return "TOF"; }

    static constexpr ECbmModuleId GetModuleId() { return ECbmModuleId::kTof; }

    const TrkStationIdMap& GetTrkStationIdMap() const { return fTrkStationIdMap; }
 
   private:
    int ImplGetTrackingStationId(uint32_t address) const;

    bool ImplIsTimeInfoProvided(int /*stationId*/) const { return true; }

    bool IsInitialized() const;

    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int /*version*/)
    {
      ar& boost::serialization::base_object<TrackingSetupIfs<RecoSetupUnit>>(*this);
      ar& fTrkStationIdMap;
    }
 
    TrkStationIdMap fTrkStationIdMap;  
  };
 
  //* Inline methods
  inline int RecoSetupUnit::ImplGetTrackingStationId(uint32_t address) const
  {
    int iSmType = CbmTofAddress::GetSmType(address);
    int iSm     = CbmTofAddress::GetSmId(address);
    int iRpc    = CbmTofAddress::GetRpcId(address);
    return fTrkStationIdMap.GetTrackingStationIndex(iSmType, iSm, iRpc);
  }
 
 
}  // namespace cbm::algo::tof
 
 
#endif  // ALGO_STS_RecoSetupUnit_h