TrackingSetupIfs.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_TrackingSetupIfs_h
#define ALGO_TrackingSetupIfs_h 1
 
#include "AlgoFairloggerCompat.h"
#include "algo/setup/GeoVolume.h"
 
#include <boost/serialization/access.hpp>
#include <boost/serialization/array.hpp>
#include <boost/serialization/vector.hpp>
 
#include <limits>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
#include <fmt/format.h>
 
namespace cbm::algo
{
  struct HitRange {
    double x{0.};  
    double y{0.};  
    double t{0.};  

    constexpr HitRange() = default;

    constexpr HitRange(double x_, double y_, double t_) : x(x_), y(y_), t(t_) {}
 
   private:
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int /*version*/)
    {
      ar& x;
      ar& y;
      ar& t;
    }
  };
 

  template<class ConcreteDetector>
  class TrackingSetupIfs {
   public:
    virtual ~TrackingSetupIfs() = default;

    bool IsValid() const;

    const GeoVolume& GetActiveVolume(int stationId) const { return fvStationActiveVolumes[stationId]; }

    template<class HitType>
    HitRange GetHitRange(const HitType& hit) const
    {
      return static_cast<const ConcreteDetector*>(this)->ImplGetHitRange(hit);
    };

    int GetNofTrackingStations() const { return fvStationFullVolumes.size(); }

    int GetTrackingStationId(uint32_t address) const
    {
      return static_cast<const ConcreteDetector*>(this)->ImplGetTrackingStationId(address);
    }

    const GeoVolume& GetFullVolume(int stationId) const { return fvStationFullVolumes[stationId]; }

    bool IsTimeInfoProvided(int stationId) const
    {
      return static_cast<const ConcreteDetector*>(this)->ImplIsTimeInfoProvided(stationId);
    }

    std::string TableOfTrackingStations() const;
 
   protected:
    TrackingSetupIfs()                        = default;
    TrackingSetupIfs(const TrackingSetupIfs&) = default;
    TrackingSetupIfs(TrackingSetupIfs&&)      = default;
    TrackingSetupIfs& operator=(const TrackingSetupIfs&) = default;
    TrackingSetupIfs& operator=(TrackingSetupIfs&&) = default;

    TrackingSetupIfs(std::pair<std::vector<GeoVolume>, std::vector<GeoVolume>>&& volumes)
      : fvStationFullVolumes(std::move(volumes.first))
      , fvStationActiveVolumes(std::move(volumes.second))
    {
    }
 
   protected:
    template<class HitType>
    HitRange ImplGetHitRange(const HitType& hit) const
    {
      return HitRange{3.5 * hit.GetDx(), 3.5 * hit.GetDy(), 3.5 * hit.GetTimeError()};
    }
 
   private:
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int /*version*/)
    {
      ar& fvStationFullVolumes;
      ar& fvStationActiveVolumes;
    }
 
    std::vector<GeoVolume> fvStationFullVolumes{};    
    std::vector<GeoVolume> fvStationActiveVolumes{};  
  };
 
 
  //* Method implementation
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  template<class ConcreteDetector>
  bool TrackingSetupIfs<ConcreteDetector>::IsValid() const
  {
    std::stringstream msg;
    msg << "Errors in the detector interface initialization for " << ConcreteDetector::GetDetectorName() << ':';
 
    // 1. Number of stations
    if (fvStationActiveVolumes.size() != fvStationFullVolumes.size() || fvStationActiveVolumes.size() == 0) {
      msg << "\n\t number of active ( " << fvStationActiveVolumes.size() << " ) and passive ("
          << fvStationFullVolumes.size() << ") volumes is different and(or) no active volumes provided";
      LOG(error) << msg.str();
      return false;
    }
 
    bool res = true;
    // 2. Volume checks
    for (int iSt{0}; iSt < GetNofTrackingStations(); ++iSt) {
      const auto& activeVolume{fvStationActiveVolumes[iSt]};
      const auto& fullVolume{fvStationFullVolumes[iSt]};
 
      if (!activeVolume.IsValid()) {
        msg << "\n\t - invalid active volume for station " << iSt << ": " << activeVolume.ToString();
        res = false;
      }
 
      if (!fullVolume.IsValid()) {
        msg << "\n\t - invalid active volume for station " << iSt << ": " << fullVolume.ToString();
        res = false;
      }
    }
 
    if (!res) {
      LOG(error) << msg.str();
      return false;
    }
 
    // 3. Active volume intersection check
    // Check, if stations ordered in z-direction and check overlaps
    for (int iSt{1}; iSt < GetNofTrackingStations(); ++iSt) {
      const auto& prevVol = fvStationActiveVolumes[iSt - 1];
      const auto& thisVol = fvStationActiveVolumes[iSt];
      if (prevVol.GetCenterZ() > thisVol.GetCenterZ()) {
        msg << "\n\t - stations " << iSt - 1 << " and " << iSt << " are not properly ordered in z-direction:";
        msg << "\n\t\t previous station: " << prevVol.ToString();
        msg << "\n\t\t this station:     " << thisVol.ToString();
        res = false;
      }
 
      if (thisVol.HasOverlapWith(prevVol)) {
        msg << "\n\t - stations " << iSt - 1 << " and " << iSt << " have intersections:";
        msg << "\n\t\t previous station: " << prevVol.ToString();
        msg << "\n\t\t this station:     " << thisVol.ToString();
        res = false;
      }
    }
 
    if (!res) {
      LOG(error) << msg.str();
    }
 
    // 4. Check, if the derived class is valid
    res = static_cast<const ConcreteDetector*>(this)->IsInitialized();
 
    return res;
  }
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  template<class ConcreteDetector>
  std::string TrackingSetupIfs<ConcreteDetector>::TableOfTrackingStations() const
  {
    // TODO: Add verbosity level, probably distribute properties into several tables
    using fmt::format;
    std::stringstream table;
    table << "* Tracking stations for " << ConcreteDetector::GetDetectorName() << " *";
    table << format(
      "\n|{:>5}|{:>8}|{:>14}|{:>14}|{:>14}|{:>14}|{:>14}|{:>14}|{:>8}|{:>8}|{:>8}|{:>8}|{:>8}|{:>8}|{:>9}|\n", "st.No",
      "zRef[cm]", "xMin(act.)[cm]", "xMax(act.)[cm]", "yMin(act.)[cm]", "yMax(act.)[cm]", "zMin(act.)[cm]",
      "zMax(act.)[cm]", "xMin[cm]", "xMax[cm]", "yMin[cm]", "yMax[cm]", "zMin[cm]", "zMax[cm]", "time info");
    table << format("|{0:->5}|{0:->8}|{0:->14}|{0:->14}|{0:->14}|{0:->14}|{0:->14}|{0:->14}|{0:->8}|{0:->8}"
                    "|{0:->8}|{0:->8}|{0:->8}|{0:->8}|{0:->9}|\n",
                    "");
    for (int iSt = 0; iSt < GetNofTrackingStations(); ++iSt) {
      const auto& volA = GetActiveVolume(iSt);
      const auto& volF = GetFullVolume(iSt);
      table << format(
        "|{:>5d}|{:>8.2f}|{:>14.2f}|{:>14.2f}|{:>14.2f}|{:>14.2f}|{:>14.2f}|{:>14.2f}|{:>8.2f}|{:>8.2f}|{:>"
        "8.2f}|{:>8.2f}|{:>8.2f}|"
        "{:>8.2f}|{:>9}|\n",
        iSt, volA.GetCenterZ(), volA.GetMinX(), volA.GetMaxX(), volA.GetMinY(), volA.GetMaxY(), volA.GetMinZ(),
        volA.GetMaxZ(), volF.GetMinX(), volF.GetMaxX(), volF.GetMinY(), volF.GetMaxY(), volF.GetMinZ(), volF.GetMaxZ(),
        IsTimeInfoProvided(iSt));
    }
    return table.str();
  }
}  // namespace cbm::algo
 
#endif  // ALGO_RecoTrackingSetupIfs_h