CaParameters.h

Go to the documentation of this file.

/* Copyright (C) 2021-2022 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergey Gorbunov, Sergei Zharko [committer] */
 
 
#pragma once  // include this header only once per compilation unit
 
#include "CaDefs.h"
#include "CaIteration.h"
#include "CaSearchWindow.h"
#include "CaStation.h"
#include "CaVector.h"
#include "KfFieldRegion.h"
#include "KfSetup.h"
 
#include <boost/serialization/array.hpp>
#include <boost/serialization/utility.hpp>
 
#include <array>
#include <numeric>
#include <type_traits>
#include <utility>
 
namespace cbm::algo::ca
{
  class InitManager;
  enum class EDetectorID;
 
  using constants::Undef;
 
  using IterationsContainer_t = Vector<Iteration>;
  template<typename DataT>
  using StationsContainer_t = std::array<ca::Station<DataT>, constants::size::MaxNstations>;
 
  enum TrackingMode
  {
    kSts,
    kGlobal,
    kMcbm
  };
 
  template<typename DataT>
  class alignas(constants::misc::Alignment) Parameters {
    friend class InitManager;
 
    using DetectorID_t = std::underlying_type_t<EDetectorID>;
    template<typename T>
    using StationArray_t = std::array<T, constants::size::MaxNstations>;
 
   public:
    Parameters();
 
    ~Parameters() noexcept = default;
 
    Parameters(const Parameters& other) = default;
 
    template<typename DataIn>
    Parameters(const Parameters<DataIn>& other)
      : fGeometrySetup(other.GetGeometrySetup())
      , fActiveSetup(other.GetActiveSetup())
      , fMaxDoubletsPerSinglet(other.GetMaxDoubletsPerSinglet())
      , fMaxTripletPerDoublets(other.GetMaxTripletPerDoublets())
      , fCAIterations(other.GetCAIterations())
      , fVertexFieldValue(other.GetVertexFieldValue())
      , fVertexFieldRegion(other.GetVertexFieldRegion())
      , fvFirstGeoId(other.GetFirstGeoId())
      , fvLocalToGeoIdMap(other.GetLocalToGeoIdMap())
      , fvGeoToLocalIdMap(other.GetGeoToLocalIdMap())
      , fvGeoToActiveMap(other.GetGeoToActiveMap())
      , fvActiveToGeoMap(other.GetActiveToGeoMap())
      , fNstationsActiveTotal(other.GetNstationsActive())
      , fSearchWindows(other.GetSearchWindows())
      , fGhostSuppression(other.GetGhostSuppression())
      , fRandomSeed(other.GetRandomSeed())
      , fDefaultMass(other.GetDefaultMass())
      , fMisalignmentX(other.GetMisalignmentX())
      , fMisalignmentY(other.GetMisalignmentY())
      , fMisalignmentT(other.GetMisalignmentT())
      , fDevIsIgnoreHitSearchAreas(other.DevIsIgnoreHitSearchAreas())
      , fDevIsUseOfOriginalField(other.DevIsUseOfOriginalField())
      , fDevIsMatchDoubletsViaMc(other.DevIsMatchDoubletsViaMc())
      , fDevIsMatchTripletsViaMc(other.DevIsMatchTripletsViaMc())
      , fDevIsExtendTracksViaMc(other.DevIsExtendTracksViaMc())
      , fDevIsSuppressOverlapHitsViaMc(other.DevIsSuppressOverlapHitsViaMc())
      , fDevIsParSearchWUsed(other.DevIsParSearchWUsed())
    {
      fTargetPos[0] = kfutils::simd::Cast<DataIn, DataT>(other.GetTargetPositionX());
      fTargetPos[1] = kfutils::simd::Cast<DataIn, DataT>(other.GetTargetPositionY());
      fTargetPos[2] = kfutils::simd::Cast<DataIn, DataT>(other.GetTargetPositionZ());
      for (size_t i = 0; i < constants::size::MaxNstations; i++) {
        fStations[i] = other.GetStation(i);
      }
    }
 
    Parameters& operator=(const Parameters& other) = default;
 
    Parameters(Parameters&& other) = default;
 
    Parameters& operator=(Parameters&& other) = default;
 
    void Print(int verbosityLevel = 0) const;
 
    std::string ToString(int verbosity = 0, int indentLevel = 0) const;
 
    unsigned int GetMaxDoubletsPerSinglet() const { return fMaxDoubletsPerSinglet; }
 
    unsigned int GetMaxTripletPerDoublets() const { return fMaxTripletPerDoublets; }
 
    int GetNstationsActive() const { return fNstationsActiveTotal; }
 
    int GetNstationsActive(EDetectorID detectorID) const;
 
    int GetNstationsGeometry() const { return fvFirstGeoId.back(); }
 
    int GetNstationsGeometry(EDetectorID detectorID) const
    {
      return fvFirstGeoId[static_cast<int>(detectorID) + 1] - fvFirstGeoId[static_cast<int>(detectorID)];
    }
 
    const std::array<int, constants::size::MaxNdetectors + 1>& GetFirstGeoId() const { return fvFirstGeoId; }
 
    [[gnu::always_inline]] std::pair<EDetectorID, int> GetStationIndexLocal(int geoIndex) const
    {
      return fvGeoToLocalIdMap[geoIndex];
    }
 
    const StationArray_t<std::pair<EDetectorID, int>>& GetGeoToLocalIdMap() const { return fvGeoToLocalIdMap; }
 
    [[gnu::always_inline]] int GetStationIndexGeometry(int localIndex, EDetectorID detectorID) const
    {
      if (localIndex >= GetNstationsGeometry(detectorID)) {
        return -1;
      }
      return fvLocalToGeoIdMap[fvFirstGeoId[static_cast<int>(detectorID)] + localIndex];
    }
 
    const StationArray_t<int>& GetLocalToGeoIdMap() const { return fvLocalToGeoIdMap; }
 
    [[gnu::always_inline]] int GetStationIndexActive(int localIndex, EDetectorID detectorID) const
    {
      int geoIndex = GetStationIndexGeometry(localIndex, detectorID);
      return (geoIndex < 0) ? -1 : fvGeoToActiveMap[geoIndex];
    }
 
    const StationArray_t<int>& GetGeoToActiveMap() const { return fvGeoToActiveMap; }
 
    const StationArray_t<int>& GetActiveToGeoMap() const { return fvActiveToGeoMap; }
 
    const IterationsContainer_t& GetCAIterations() const { return fCAIterations; }
 
    int GetNcaIterations() const { return fCAIterations.size(); }
 
    const StationsContainer_t<DataT>& GetStations() const { return fStations; }
 
    const Station<DataT>& GetStation(int iStation) const { return fStations[iStation]; }
 
    const SearchWindow& GetSearchWindow(int iStation, int iTrackGr) const
    {
      assert(iStation < fNstationsActiveTotal && iStation > 0);
      assert(iTrackGr < int(fCAIterations.size()));
      return fSearchWindows[iTrackGr * constants::size::MaxNstations + iStation];
    }
 
    const std::array<SearchWindow, constants::size::MaxNstations * constants::size::MaxNtrackGroups>&
    GetSearchWindows() const
    {
      return fSearchWindows;
    }
 
    DataT GetTargetPositionX() const { return fTargetPos[0]; }
 
    DataT GetTargetPositionY() const { return fTargetPos[1]; }
 
    DataT GetTargetPositionZ() const { return fTargetPos[2]; }
 
    const kf::FieldRegion<DataT>& GetVertexFieldRegion() const { return fVertexFieldRegion; }
 
    const kf::FieldValue<DataT>& GetVertexFieldValue() const { return fVertexFieldValue; }
 
    int GetRandomSeed() const { return fRandomSeed; }
 
    const auto& GetActiveSetup() const { return fActiveSetup; }
 
    const auto& GetGeometrySetup() const { return fGeometrySetup; }
 
    int GetGhostSuppression() const { return fGhostSuppression; }
 
    float GetDefaultMass() const { return fDefaultMass; }
 
    float GetMisalignmentXsq(EDetectorID detId) const
    {
      auto iDet = static_cast<DetectorID_t>(detId);
      return fMisalignmentX[iDet] * fMisalignmentX[iDet];
    }
 
    float GetMisalignmentYsq(EDetectorID detId) const
    {
      auto iDet = static_cast<DetectorID_t>(detId);
      return fMisalignmentY[iDet] * fMisalignmentY[iDet];
    }
 
    float GetMisalignmentTsq(EDetectorID detId) const
    {
      auto iDet = static_cast<DetectorID_t>(detId);
      return fMisalignmentT[iDet] * fMisalignmentT[iDet];
    }
 
    const std::array<float, constants::size::MaxNdetectors> GetMisalignmentX() const { return fMisalignmentX; }
 
    const std::array<float, constants::size::MaxNdetectors> GetMisalignmentY() const { return fMisalignmentY; }
 
    const std::array<float, constants::size::MaxNdetectors> GetMisalignmentT() const { return fMisalignmentT; }
 
    bool IsActive(EDetectorID detId) const { return GetNstationsActive(detId) != 0; }
 
    void CheckConsistency() const;
 
    // ***************************
    // ** Flags for development **
    // ***************************
 
    bool DevIsIgnoreHitSearchAreas() const { return fDevIsIgnoreHitSearchAreas; }
 
    bool DevIsUseOfOriginalField() const { return fDevIsUseOfOriginalField; }
 
    bool DevIsMatchDoubletsViaMc() const { return fDevIsMatchDoubletsViaMc; }
 
    bool DevIsMatchTripletsViaMc() const { return fDevIsMatchTripletsViaMc; }
 
    bool DevIsExtendTracksViaMc() const { return fDevIsExtendTracksViaMc; }
 
    bool DevIsSuppressOverlapHitsViaMc() const { return fDevIsSuppressOverlapHitsViaMc; }
 
    bool DevIsParSearchWUsed() const { return fDevIsParSearchWUsed; }
 
   private:
    kf::Setup<DataT> fGeometrySetup{kf::EFieldMode::Intrpl};
 
    kf::Setup<DataT> fActiveSetup{kf::EFieldMode::Intrpl};
 
    unsigned int fMaxDoubletsPerSinglet{150};  
    unsigned int fMaxTripletPerDoublets{15};   
 
    alignas(constants::misc::Alignment) IterationsContainer_t fCAIterations{
      "ca::Parameters::fCAIterations"};  
 
    /*************************
     ** Geometry parameters **
     *************************/
    alignas(constants::misc::Alignment) std::array<DataT, 3> fTargetPos{Undef<float>, Undef<float>, Undef<float>};
 
    kf::FieldValue<DataT> fVertexFieldValue{};
 
    kf::FieldRegion<DataT> fVertexFieldRegion{};
 
    alignas(constants::misc::Alignment) StationsContainer_t<DataT> fStations{};
 
    // ** Station layout arrays **
    alignas(constants::misc::Alignment) std::array<int, constants::size::MaxNdetectors + 1> fvFirstGeoId{};
 
    alignas(constants::misc::Alignment) StationArray_t<int> fvLocalToGeoIdMap{};
 
    alignas(constants::misc::Alignment) StationArray_t<std::pair<EDetectorID, int>> fvGeoToLocalIdMap{};
 
    alignas(constants::misc::Alignment) StationArray_t<int> fvGeoToActiveMap{};
 
    alignas(constants::misc::Alignment) StationArray_t<int> fvActiveToGeoMap{};
 
 
    alignas(constants::misc::Alignment) int fNstationsActiveTotal = -1;  
 
 
    alignas(constants::misc::Alignment)
      std::array<SearchWindow, constants::size::MaxNstations* constants::size::MaxNtrackGroups> fSearchWindows = {};
 
    int fGhostSuppression = 0;  
    int fRandomSeed       = 1;  
    float fDefaultMass    = constants::phys::MuonMass;
 
    std::array<float, constants::size::MaxNdetectors> fMisalignmentX{0.};
 
    std::array<float, constants::size::MaxNdetectors> fMisalignmentY{0.};
 
    std::array<float, constants::size::MaxNdetectors> fMisalignmentT{0.};
 
    // ***************************
    // ** Flags for development **
    // ***************************
 
    bool fDevIsIgnoreHitSearchAreas{false};      
    bool fDevIsUseOfOriginalField{false};        
    bool fDevIsMatchDoubletsViaMc{false};        
    bool fDevIsMatchTripletsViaMc{false};        
    bool fDevIsExtendTracksViaMc{false};         
    bool fDevIsSuppressOverlapHitsViaMc{false};  
 
    bool fDevIsParSearchWUsed = false;  
 
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int)
    {
      ar& fMaxDoubletsPerSinglet;
      ar& fMaxTripletPerDoublets;
 
      ar& fCAIterations;
      ar& fTargetPos;
 
      ar& fVertexFieldValue;
      ar& fVertexFieldRegion;
 
      ar& fStations;
 
      ar& fvFirstGeoId;
      ar& fvLocalToGeoIdMap;
      ar& fvGeoToLocalIdMap;
      ar& fvGeoToActiveMap;
      ar& fvActiveToGeoMap;
      ar& fNstationsActiveTotal;
 
      ar& fSearchWindows;
 
      ar& fGhostSuppression;
      ar& fRandomSeed;
      ar& fDefaultMass;
 
      ar& fMisalignmentX;
      ar& fMisalignmentY;
      ar& fMisalignmentT;
 
      ar& fDevIsIgnoreHitSearchAreas;
      ar& fDevIsUseOfOriginalField;
      ar& fDevIsMatchDoubletsViaMc;
      ar& fDevIsMatchTripletsViaMc;
      ar& fDevIsExtendTracksViaMc;
      ar& fDevIsSuppressOverlapHitsViaMc;
    }
  };
}  // namespace cbm::algo::ca