CaInitManager.h

Go to the documentation of this file.

/* Copyright (C) 2021-2023 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 "CaObjectInitController.h"
#include "CaParameters.h"
#include "CaSimd.h"
#include "CaStationInitializer.h"
#include "KfFieldRegion.h"
 
#include <array>
#include <bitset>
#include <memory>  //unique_ptr
#include <numeric>
#include <set>
#include <string>
#include <type_traits>
#include <unordered_map>
 
namespace cbm::algo::ca
{
  enum class EDetectorID;
}  // namespace cbm::algo::ca
 
template<>
struct std::hash<cbm::algo::ca::EDetectorID> {
  int operator()(cbm::algo::ca::EDetectorID t) const { return static_cast<int>(t); }
};
 
namespace cbm::algo::ca
{
  using DetectorID_t = std::underlying_type_t<EDetectorID>;
 
  class InitManager {
   private:
    enum class EInitKey
    {
      // NOTE: Please, keep the numbers of the enumeration items in the existing order: it helps to debug the
      //       initialization with this->GetObjectInitController().ToString() method call (S.Zharko)
      kFieldFunction,                 
      kTargetPos,                     
      kPrimaryVertexField,            
      kStationsInfo,                  
      kCAIterationsNumberCrosscheck,  
      kCAIterations,                  
      kSearchWindows,                 
      kGhostSuppression,              
      kRandomSeed,                    
      kStationLayoutInitialized,      
      kSetupInitialized,              
      kEnd                            
    };
 
    using DetectorIDIntMap_t = std::unordered_map<EDetectorID, int>;
    using DetectorIDSet_t    = std::set<EDetectorID>;
    using FieldFunction_t    = std::function<void(const double (&xyz)[3], double (&B)[3])>;
    using InitController_t   = ObjectInitController<static_cast<int>(EInitKey::kEnd), EInitKey>;
    template<typename T>
    using DetectorIDArr_t = std::array<T, constants::size::MaxNdetectors>;
 
   public:
    InitManager() = default;
 
    ~InitManager() = default;
 
    InitManager(const InitManager& /*other*/) = delete;
 
    InitManager(InitManager&& /*other*/) = delete;
 
    InitManager& operator=(const InitManager& /*other*/) = delete;
 
    InitManager& operator=(InitManager&& /*other*/) = delete;
 
    void AddStation(const StationInitializer& station);
 
    void CheckInit();
 
    void ClearCAIterations();
 
    void ClearSetupInfo();
 
    bool FormParametersContainer();
 
    const std::string& GetDetectorName(EDetectorID detId) const { return fvDetectorNames[static_cast<int>(detId)]; }
 
    int GetGhostSuppression() const { return fParameters.fGhostSuppression; }
 
    const std::string& GetInputConfigMain() const { return fsConfigInputMain; }
 
    const std::string& GetInputConfigUser() const { return fsConfigInputMain; }
 
    const InitController_t& GetInitController() const { return fInitController; }
 
    int GetNstationsActive() const;
 
    int GetNstationsActive(EDetectorID detectorID) const;
 
    int GetNstationsGeometry() const;
 
    int GetNstationsGeometry(EDetectorID detectorID) const;
 
    const std::string& GetOutputConfigName() const { return fConfigOutputName; }
 
    std::vector<StationInitializer>& GetStationInfo();
 
    void InitStationLayout();
 
    void InitTargetField(double zStep);
 
    bool IsActive(EDetectorID detectorID) const { return GetNstationsActive(detectorID) != 0; }
 
    bool IsPresent(EDetectorID detectorID) const { return GetNstationsGeometry(detectorID) != 0; }
 
    void PushBackCAIteration(const Iteration& iteration);
 
    void PushBackCAIteration(const Iteration* pIteration) { PushBackCAIteration(*pIteration); }
 
    void PushBackCAIteration(const std::unique_ptr<Iteration>& puIteration) { PushBackCAIteration(*puIteration); }
 
    void ReadInputConfigs();
 
    void ReadGeometrySetup(const std::string& fileName);
 
    void ReadParametersObject(const std::string& fileName);
 
    void ReadSearchWindows(const std::string& fileName);
 
    // TODO: remove this method
    void SetCAIterationsNumberCrosscheck(int nIterations);
 
    void SetConfigMain(const std::string& mainConfig) { fsConfigInputMain = mainConfig; }
 
    void SetConfigUser(const std::string& userConfig) { fsConfigInputUser = userConfig; }
 
    template<size_t Size>
    void SetDetectorNames(const std::array<const char*, Size>& container)
    {
      static_assert(Size <= constants::size::MaxNdetectors,
                    "Please, be ensured that the constants::size::MaxNdetectors is not lower then the "
                    "EDetectorID::kEND value, provided by your setup");
      std::copy(container.begin(), container.end(), fvDetectorNames.begin());
    }
 
    void SetFieldFunction(const FieldFunction_t& fieldFcn);
 
    void SetGhostSuppression(int ghostSuppression);
 
    void SetOutputConfigName(const std::string& filename) { fConfigOutputName = filename; }
 
    void SetRandomSeed(unsigned int seed);
 
    // TODO: Use kf::Setup instead
    void SetTargetPosition(double x, double y, double z);
 
    void SetMaxDoubletsPerSinglet(unsigned int value) { fParameters.fMaxDoubletsPerSinglet = value; }
 
    void SetMaxTripletPerDoublets(unsigned int value) { fParameters.fMaxTripletPerDoublets = value; }
 
    template<typename DataT>
    void SetGeometrySetup(const cbm::algo::kf::Setup<DataT>& setup)
    {
      if (!fInitController.GetFlag(EInitKey::kStationLayoutInitialized)) {
        std::stringstream msg;
        msg << "ca::InitManager: setup cannot be set until the station layout is initialized";
        throw std::runtime_error(msg.str());
      }
      fParameters.fGeometrySetup = kf::Setup<fvec>(setup);
      fParameters.fActiveSetup   = fParameters.fGeometrySetup;
      // A sequence of the last inactive materials will be anyway thrown away, so it is more effective to
      // loop over stations downstream
      for (int iStGeo = setup.GetNofLayers() - 1; iStGeo >= 0; --iStGeo) {
        auto [detID, locID] = fParameters.GetStationIndexLocal(iStGeo);
        int iStActive       = fParameters.GetStationIndexActive(locID, detID);
        if (iStActive < 0) {
          fParameters.fActiveSetup.DisableLayer(detID, locID);
        }
      }
      LOG(info) << "Geometry setup:" << fParameters.fGeometrySetup.ToString(1);
      LOG(info) << "Active setup:" << fParameters.fActiveSetup.ToString(1);
      fInitController.SetFlag(EInitKey::kSetupInitialized, true);
    }
 
    void SetMisalignmentTolerance(EDetectorID detectorId, double x, double y, double t)
    {
      fParameters.fMisalignmentX[static_cast<int>(detectorId)] = x;
      fParameters.fMisalignmentY[static_cast<int>(detectorId)] = y;
      fParameters.fMisalignmentT[static_cast<int>(detectorId)] = t;
    }
 
    void SetDefaultMass(double mass) { fParameters.fDefaultMass = mass; }
 
    Parameters<fvec>&& TakeParameters();
 
    void WriteParametersObject(const std::string& fileName) const;
 
    // ***************************
    // ** Flags for development **
    // ***************************
 
    void DevSetIgnoreHitSearchAreas(bool value = true) { fParameters.fDevIsIgnoreHitSearchAreas = value; }
 
    void DevSetUseOfOriginalField(bool value = true) { fParameters.fDevIsUseOfOriginalField = value; }
 
    void DevSetIsMatchDoubletsViaMc(bool value = true) { fParameters.fDevIsMatchDoubletsViaMc = value; }
 
    void DevSetIsMatchTripletsViaMc(bool value = true) { fParameters.fDevIsMatchTripletsViaMc = value; }
 
    void DevSetIsExtendTracksViaMc(bool value = true) { fParameters.fDevIsExtendTracksViaMc = value; }
 
    void DevSetIsSuppressOverlapHitsViaMc(bool value = true) { fParameters.fDevIsSuppressOverlapHitsViaMc = value; }
 
    void DevSetIsParSearchWUsed(bool value = true) { fParameters.fDevIsParSearchWUsed = value; }
 
   private:
    void CheckCAIterationsInit();
 
    void CheckStationsInfoInit();
 
    void ClearStationLayout();
 
    InitController_t fInitController{};              
    DetectorIDArr_t<std::string> fvDetectorNames{};  
 
    double fTargetZ{0.};  
 
    std::vector<StationInitializer> fvStationInfo{};  
 
    FieldFunction_t fFieldFunction{[](const double (&)[3], double (&)[3]) {}};
    // NOTE: Stations of the detectors which are not assigned as active, are not included in the tracking!
 
    // TODO: remove
    int fCAIterationsNumberCrosscheck{-1};  
 
    Parameters<fvec> fParameters{};  
    // TODO: With a separate KF-framework instance we need to figure it out, how to store and read the corresponding
    //       parameters (essential for the online reconstruction!!!)
 
    std::string fsConfigInputMain = "";  
    std::string fsConfigInputUser = "";  
    std::string fConfigOutputName = "";  
 
    bool fbConfigIsRead       = false;  
    bool fbGeometryConfigLock = false;  
  };
 
 
}  // namespace cbm::algo::ca