KfSetupBuilder.h

Go to the documentation of this file.

/* Copyright (C) 2024-2025 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */

 
#pragma once  // include this header only once per compilation unit
 
#include "KfIMaterialMapFactory.h"
#include "KfSetup.h"
 
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
 
#include <fstream>
#include <memory>
#include <optional>
#include <sstream>
#include <string>
#include <vector>
 
#include <fmt/format.h>
 
namespace cbm::algo::kf
{
 

  class SetupBuilder {
   public:
    struct LayerProperty {
      int detId;             
      int locId;             
      double zRef;           
      double zMin;           
      double zMax;           
      double xMinFull;       
      double xMaxFull;       
      double yMinFull;       
      double yMaxFull;       
      double xMinAct;        
      double xMaxAct;        
      double yMinAct;        
      double yMaxAct;        
      EFieldType fieldType;  
      bool timeInfo;         

      bool operator<(const LayerProperty& rhs) const { return zRef < rhs.zRef; }

      template<typename F>
      ActiveLayer<F> CreateActiveLayer() const
      {
        return ActiveLayer<F>(zRef, xMinAct, xMaxAct, yMinAct, yMaxAct, fieldType, timeInfo);
      }

      std::string ToString() const;
    };

    SetupBuilder() = default;

    SetupBuilder(const SetupBuilder&) = delete;

    SetupBuilder(SetupBuilder&&) = delete;

    virtual ~SetupBuilder() = default;

    SetupBuilder& operator=(const SetupBuilder&) = delete;

    SetupBuilder& operator=(SetupBuilder&&) = delete;

    void AddLayer(LayerProperty geoLayer);

    const FieldFn_t& GetFieldFunction() const { return fFieldBuilder.GetFieldFunction(); }

    void Init();

    template<typename F>
    Setup<F> MakeSetup(EFieldMode fldMode) const;

    void Reset();

    void SetFieldFunction(const FieldFn_t& fieldFn, EFieldType fieldType)
    {
      fbReady = false;
      fFieldBuilder.SetFieldFunction(fieldFn, fieldType);
      fFieldBuilder.SetStep(kTargetFieldInitStep);
      fbIfFieldFunctionSet = true;
    }

    template<typename F>
    void SetFromSetup(const Setup<F>& inSetup);

    void SetMaterialMapFactory(const std::shared_ptr<IMaterialMapFactory>& pMaterialFactory)
    {
      fbReady              = false;
      fpMaterialMapFactory = pMaterialFactory;
    }

    void SetMaterialCacheFile(const std::string& filename, size_t refHash)
    {
      fsMaterialCacheFile = filename;
      fGeoHash            = refHash;
    }

    void SetTargetProperty(double x, double y, double z, double dz, double r);
 
 
    // ********************
    // ** Static methods **
    // ********************

    static void Store(const Setup<double>& setup, const std::string& fileName);

    template<typename F>
    static Setup<F> Load(const std::string& fileName);
 
   private:

    std::string InitStatusMsg() const;

    bool LoadMaterial();

    void StoreMaterial() const;
 
    // TODO: Define target material more precisely
    static constexpr double kTargetCenterOffset{0.05};                 
    static constexpr double kTargetMaterialOffset{2.};                 
    static constexpr double kTargetMaterialTransverseSizeMargin{1.3};  
    static constexpr double kTargetFieldInitStep{
      2.5};  
    static constexpr int kTargetMaterialMapNofBins{20};  
 
    std::set<LayerProperty> fGeoLayers{};                                
    std::string fsMaterialCacheFile{""};                                 
    std::vector<MaterialMap> fvMaterial{};                               
    std::shared_ptr<IMaterialMapFactory> fpMaterialMapFactory{nullptr};  
    ModuleIndexMapFactory fModuleIndexFactory;                           
    FieldBuilder fFieldBuilder;                                          
    Target<double> fTarget;                                              
    size_t fGeoHash{0};                                                  
    int fMatMapNofBins{100};                                             
 
    bool fbIfTargetSet{false};         
    bool fbIfGeoLayersInit{false};     
    bool fbIfFieldFunctionSet{false};  
    bool fbIfSetFromSetup{false};
    bool fbReady{false};  
  };
 
 
  // ********************************
  // ** Template method definition **
  // ********************************
 
 
  // ---------------------------------------------------------------------------------------------------------------------
  //
  template<typename F>
  void SetupBuilder::SetFromSetup(const Setup<F>& inSetup)
  {
    LOG(debug) << "kf::SetupBuilder: setting properties from input setup: " << inSetup.ToString(2);
    fbReady = false;
    // Reset geo layer information
    fGeoLayers.clear();
    fvMaterial.clear();
    fvMaterial.reserve(inSetup.GetNofLayers());
    fModuleIndexFactory.Reset();
    fFieldBuilder.ResetSliceReferences();
 
    // Init target properties
    fTarget = Target<double>(inSetup.fTarget);
 
    // Init geometry layers
    for (int iLayer{0}; iLayer < inSetup.GetNofLayers(); ++iLayer) {
      const auto& material{inSetup.GetMaterial(iLayer)};
      fvMaterial.push_back(material);
      const auto& actLayer{inSetup.GetActiveLayer(iLayer)};
      fFieldBuilder.AddSliceReference(material.GetXYmax(), material.GetXYmax(), material.GetZref());
      const auto& [iDetExt, iLoc] = inSetup.GetIndexMap().template GlobalToLocal<int>(iLayer);
      fModuleIndexFactory.AddComponent(iDetExt, iLoc, material.GetZref());
 
      AddLayer(std::move(
        {.detId     = iDetExt,                                           //
         .locId     = iLoc,                                              //
         .zRef      = utils::simd::Cast<F, double>(actLayer.GetZref()),  //
         .zMin      = utils::simd::Cast<F, double>(actLayer.GetZmin()),  //
         .zMax      = utils::simd::Cast<F, double>(actLayer.GetZmax()),  //
         .xMinFull  = -material.GetXYMax(),  // NOTE: the original info. on full vol. X min is lost in kf::Setup
         .xMaxFull  = +material.GetXYMax(),  // NOTE: the original info. on full vol. X max is lost in kf::Setup
         .yMinFull  = -material.GetXYMax(),  // NOTE: the original info. on full vol. Y min is lost in kf::Setup
         .yMaxFull  = +material.GetXYMax(),  // NOTE: the original info. on full vol. Y max is lost in kf::Setup
         .xMinAct   = utils::simd::Cast<F, double>(actLayer.GetXmin()),  //
         .xMaxAct   = utils::simd::Cast<F, double>(actLayer.GetXmax()),  //
         .yMinAct   = utils::simd::Cast<F, double>(actLayer.GetYmin()),  //
         .yMaxAct   = utils::simd::Cast<F, double>(actLayer.GetYmax()),  //
         .fieldType = actLayer.GetFieldType(),
         .timeInfo  = actLayer.IsTimeMeasured()}));
    }
 
    fbIfGeoLayersInit = true;
    fbIfTargetSet     = true;
    fbIfSetFromSetup  = true;
    fbReady           = true;
  }
 
  // ---------------------------------------------------------------------------------------------------------------------
  //
  template<typename F>
  Setup<F> SetupBuilder::MakeSetup(EFieldMode fldMode) const
  {
    if (!fbReady) {
      throw std::runtime_error(
        "kf::SetupBuilder is not ready to build a setup. Please, provide all setters and call the "
        "Init method");
    }
 
    // Form a vector of active layers
    std::vector<ActiveLayer<F>> vActiveLayers;
    vActiveLayers.reserve(fGeoLayers.size());
    std::transform(fGeoLayers.begin(), fGeoLayers.end(), std::back_inserter(vActiveLayers),
                   [](const auto& in) -> ActiveLayer<F> { return in.template CreateActiveLayer<F>(); });
 
    return Setup<F>(fModuleIndexFactory.MakeIndexMap(), fvMaterial, vActiveLayers, fFieldBuilder.MakeField<F>(fldMode),
                    fTarget);
  }
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  template<typename F>
  Setup<F> SetupBuilder::Load(const std::string& fileName)
  {
    Setup<double> setup;
    std::ifstream ifs(fileName, std::ios::binary);
    if (!ifs) {
      throw std::runtime_error(fmt::format("kf::SetupBuilder::Load: intput setup file \"{}\" was not found", fileName));
    }
    try {
      boost::archive::binary_iarchive ia(ifs);
      ia >> setup;
    }
    catch (const std::exception& err) {
      throw std::runtime_error(fmt::format("kf::SetupBuilder::Load: input setup file \"{}\" has inconsistent format or "
                                           "was corrupted. The exception message: ",
                                           fileName, err.what()));
    }
    if constexpr (std::is_same_v<F, double>) {
      return setup;
    }
    else {
      return Setup<F>(setup);
    }
  }
}  // namespace cbm::algo::kf