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 "CaConfig.h"
#include "CaDefs.h"
#include "CaIteration.h"
#include "CaSearchWindowMapContainer.h"
#include "CaSetup.h"
#include "CaVector.h"
#include "KfFieldRegion.h"
#include "KfSetup.h"
 
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/serialization/array.hpp>
#include <boost/serialization/utility.hpp>
 
#include <array>
#include <numeric>
#include <type_traits>
#include <utility>
 
namespace cbm::algo::ca
{
  enum class EDetectorID;
 
  using constants::Undef;

  using IterationsContainer_t = Vector<Iteration>;
 
  // FIXME: Remove TrackingMode (at least)
  enum TrackingMode
  {
    kSts,
    kGlobal,
    kMcbm
  };

  template<typename DataT>
  class alignas(constants::misc::Alignment) Parameters {
    friend class ParametersIO;
 
    using DetectorID_t = std::underlying_type_t<EDetectorID>;
    template<typename T>
    using StationArray_t = std::array<T, constants::size::MaxNstations>;
 
   public:
    Parameters() = default;

    Parameters(ca::Setup<DataT>&& setup, ca::Config&& config, SearchWindowMapContainer&& searchWindows);

    template<typename DataIn>
    Parameters(const Parameters<DataIn>& other)
      : fSetup(other.GetSetup())
      , fConfig(other.GetConfig())
      , fSwMaps(other.GetSearchWindows())
    {
    }

    Parameters(const Parameters& other) = default;

    ~Parameters() noexcept = default;

    Parameters(Parameters&& other) = default;

    Parameters& operator=(const Parameters& other) = default;

    Parameters& operator=(Parameters&& other) = default;

    void Print(int verbosityLevel = 0) const;

    std::string ToString(int verbosity = 0, int indentLevel = 0) const;

    kf::EFieldMode GetFieldMode() const { return fSetup.GetGeometrySetup().GetField().GetFieldMode(); }

    int GetNstationsActive() const { return fSetup.GetNofActStations(); }

    int GetNstationsActive(EDetectorID detId) const { return fSetup.GetNofActStations(detId); }

    int GetNstationsGeometry() const { return fSetup.GetNofGeoStations(); }

    int GetNstationsGeometry(EDetectorID detId) const { return fSetup.GetNofGeoStations(detId); }

    //const std::array<int, constants::size::MaxNdetectors + 1>& GetFirstGeoId() const { return fvFirstGeoId; }

    [[gnu::always_inline]] std::pair<EDetectorID, int> GetStationIndexLocal(int geoId) const
    {
      return fSetup.GeoToLocStationId(geoId);
    }

    //const StationArray_t<std::pair<EDetectorID, int>>& GetGeoToLocalIdMap() const { return fvGeoToLocalIdMap; }

    // TODO: remove function
    [[gnu::always_inline]] int GetStationIndexGeometry(int locId, EDetectorID detId) const
    {
      if (locId >= GetNstationsGeometry(detId)) {
        return -1;
      }
      return fSetup.LocToGeoStationId(detId, locId);
    }

    //const StationArray_t<int>& GetLocalToGeoIdMap() const { return fvLocalToGeoIdMap; }

    [[gnu::always_inline]] int GetStationIndexActive(int locId, EDetectorID detId) const
    {
      return fSetup.LocToActStationId(detId, locId);
    }

    const auto& GetCAIterations() const { return fConfig.GetIterations(); }

    int GetNcaIterations() const { return fConfig.GetIterations().size(); }

    const auto& GetActiveSetup() const { return fSetup.GetActiveSetup(); }

    const auto& GetGeometrySetup() const { return fSetup.GetGeometrySetup(); }

    bool IsActive(EDetectorID detId) const { return GetNstationsActive(detId) != 0; }

    void CheckConsistency() const;

    const Setup<DataT>& GetSetup() const { return fSetup; }

    const Config& GetConfig() const { return fConfig; }

    const SearchWindowMapContainer& GetSearchWindows() const { return fSwMaps; }
 
   private:
    Setup<DataT> fSetup;               
    Config fConfig;                    
    SearchWindowMapContainer fSwMaps;  

    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int)
    {
      ar& fSetup;
      ar& fConfig;
      ar& fSwMaps;
    }
  };
 

  struct ParametersIO {
    ~ParametersIO() = delete;

    template<typename Float>
    static Parameters<Float> Load(const std::string& fileName);

    static void Store(const Parameters<double>& parameters, const std::string& fileName);
  };
 
  //* Template methods implementation
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  template<typename Float>
  Parameters<Float> ParametersIO::Load(const std::string& fileName)
  {
    Parameters<double> parameters;
    std::ifstream ifs(fileName, std::ios::binary);
    if (!ifs) {
      throw std::runtime_error(fmt::format("ca::ParametersIO::Load: intput setup file \"{}\" was not found", fileName));
    }
    try {
      boost::archive::binary_iarchive ia(ifs);
      ia >> parameters;
    }
    catch (const std::exception& err) {
      throw std::runtime_error(fmt::format("ca::ParametersIO::Load: input setup file \"{}\" has inconsistent format or "
                                           "was corrupted. The exception message: ",
                                           fileName, err.what()));
    }
    if constexpr (std::is_same_v<Float, double>) {
      return parameters;
    }
    else {
      return Parameters<Float>(parameters);
    }
  }
}  // namespace cbm::algo::ca