CaParametersBuilder.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 CaParametersBuilder_h
#define CaParametersBuilder_h 1
 
#include "CaConfigReader.h"
#include "CaDefs.h"
#include "CaParameters.h"
#include "CaSearchWindowMapContainerFactory.h"
#include "KfISetupFactory.h"
#include "KfSetup.h"
 
#include <algorithm>
#include <array>
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
namespace cbm::algo::ca
{
  class ParametersBuilder {
 
   public:
    using DetNamesArray_t = std::array<std::string, constants::size::MaxNdetectors>;
    using GeoFactoryPtr_t = std::unique_ptr<const kf::ISetupFactory>;

    template<typename Float>
    Parameters<Float> Build(kf::FloatTag<Float> floatTag, kf::EFieldMode fldMode);

    void DisableStation(EDetectorID detId, int locId) { fvInactiveIds.push_back(std::pair{detId, locId}); }

    void SetGeoSetupFactoryConstructor(std::function<GeoFactoryPtr_t()> lazyConstructor)
    {
      fpGeoSetupFactoryConstructor = lazyConstructor;
    }

    void SetMainConfig(const std::string& mainConfig) { fsMainConfig = mainConfig; }

    void SetUserConfig(const std::string& userConfig) { fsUserConfig = userConfig; }

    void SetDetNames(const DetNamesArray_t& detNames) { fDetNames = detNames; }
 
 
   private:
    void Init();
 
    std::string fsMainConfig{};                              
    std::string fsUserConfig{};                              
    std::vector<std::pair<EDetectorID, int>> fvInactiveIds;  
    GeoFactoryPtr_t fpGeoSetupFactory;                       
    DetNamesArray_t fDetNames;                               
 
    std::function<GeoFactoryPtr_t()> fpGeoSetupFactoryConstructor;  
    // NOTE: Set of the lazy constructor ensures, that the geo-setup factory will be constructed in the
    //       initialization of the parameters builder. This method is to be called in a constructor of
    //       a concrete parameter builder class.
  };
 
  //* Template method implementation
  template<typename Float>
  Parameters<Float> ParametersBuilder::Build(kf::FloatTag<Float>, kf::EFieldMode fldMode)
  {
    if (fsMainConfig.empty()) {
      throw std::runtime_error("ca::ParametersBuilder: attempt to build a parameters object with an "
                               "uninitialized main config.");
    }
 
    if (fpGeoSetupFactory == nullptr) {
      Init();
    }
 
    auto configReader = ConfigReader{};
    configReader.SetDetectorNames(fDetNames);
    configReader.SetMainConfigPath(fsMainConfig);
    configReader.SetUserConfigPath(fsUserConfig);
    auto config = configReader.CreateConfig();
 
    // Append inactive indices from the config
    auto inactiveIdsFromCfg = configReader.ReadInactiveStationMap();
    std::vector<std::pair<ca::EDetectorID, int>> inactiveIdsFull;
    inactiveIdsFull.reserve(inactiveIdsFromCfg.size() + fvInactiveIds.size());
    std::copy(fvInactiveIds.begin(), fvInactiveIds.end(), std::back_inserter(inactiveIdsFull));
    std::copy(inactiveIdsFromCfg.begin(), inactiveIdsFromCfg.end(), std::back_inserter(inactiveIdsFull));
 
    auto geoSetup = fpGeoSetupFactory->Create(kf::FloatTag<Float>{}, fldMode);
    auto caSetup  = ca::Setup{std::move(geoSetup), inactiveIdsFull};
    auto swMaps =
      SearchWindowMapContainerFactory{}.Create(caSetup.GetActiveSetup(), fpGeoSetupFactory->GetFieldFunction(), config);
 
    return Parameters<Float>{std::move(caSetup), std::move(config), std::move(swMaps)};
  }
 
}  // namespace cbm::algo::ca
 
#endif  // CaParametersBuilder_h