KfSetupBuilder.h

Go to the documentation of this file.

/* Copyright (C) 2024 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>
 
namespace cbm::algo::kf
{
  template<class EDetID>
  struct GeoLayer {
    GeoLayer(EDetID detID, int iLoc, double zRef, double zMin, double zMax, double xMax, double yMax)
      : fZref(zRef)
      , fZmin(zMin)
      , fZmax(zMax)
      , fXmax(xMax)
      , fYmax(yMax)
      , fDetID(detID)
      , fLocID(iLoc)
    {
    }
 
    double fZref;   
    double fZmin;   
    double fZmax;   
    double fXmax;   
    double fYmax;   
    EDetID fDetID;  
    int fLocID;     
    bool operator<(const GeoLayer& rhs) const { return fZref < rhs.fZref; }
  };
 
  class SetupBuilder {
   public:
    SetupBuilder() = default;
 
    SetupBuilder(const SetupBuilder&) = delete;
 
    SetupBuilder(SetupBuilder&&) = delete;
 
    virtual ~SetupBuilder() = default;
 
    SetupBuilder& operator=(const SetupBuilder&) = delete;
 
    SetupBuilder& operator=(SetupBuilder&&) = delete;
 
    template<class EDetID>
    void AddLayer(const GeoLayer<EDetID>& geoLayer);
 
    template<typename T>
    Setup<T> MakeSetup(EFieldMode fldMode);
 
    void Reset();
 
    void SetFieldFunction(const FieldFn_t& fieldFn, EFieldType fieldType)
    {
      fbReady = false;
      fFieldFactory.SetFieldFunction(fieldFn, fieldType);
      fFieldFactory.SetStep(kTargetFieldInitStep);
      fbIfFieldFunctionSet = true;
    }
 
    template<typename T>
    void SetFromSetup(const Setup<T>& 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 T>
    static Setup<T> Load(const std::string& fileName);
 
   private:
    void Init();
 
    std::string InitStatusMsg() const;
 
    bool LoadMaterial();
 
    void StoreMaterial() const;
 
    // TODO: Define target material more precisely
    static constexpr double kTargetCenterOffset{0.05};                 // Offset from target center [cm]
    static constexpr double kTargetMaterialOffset{2.};                 // Offset of the target material [in dz]
    static constexpr double kTargetMaterialTransverseSizeMargin{1.3};  // Margin of target transverse size
    static constexpr double kTargetFieldInitStep{2.5};  // Step between nodal points to determine field near target [cm]
    static constexpr int kTargetMaterialMapNofBins{20};
 
    std::set<GeoLayer<int>> fGeoLayers{};                                
    std::string fsMaterialCacheFile{""};                                 
    std::vector<MaterialMap> fvMaterial{};                               
    std::shared_ptr<IMaterialMapFactory> fpMaterialMapFactory{nullptr};  
    ModuleIndexMapFactory fModuleIndexFactory;                           
    FieldFactory fFieldFactory;                                          
    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<class EDetID>
  void SetupBuilder::AddLayer(const GeoLayer<EDetID>& geoLayer)
  {
    fbReady    = false;
    auto layer = fGeoLayers.emplace(static_cast<int>(geoLayer.fDetID), geoLayer.fLocID, geoLayer.fZref, geoLayer.fZmin,
                                    geoLayer.fZmax, geoLayer.fXmax, geoLayer.fYmax);
    if (!layer.second) {
      std::stringstream msg;
      msg << "SetupBuilder::AddLayer: attempt of adding a duplicating geometry layer: ";
      msg << "DetID = " << static_cast<int>(geoLayer.fDetID) << ", localID = " << geoLayer.fLocID
          << "fZref = " << geoLayer.fZref << ", fZmin = " << geoLayer.fZmin << ", fZmax = " << geoLayer.fZmax
          << ", fXmax = " << geoLayer.fXmax << ", fYmax = " << geoLayer.fYmax
          << ".\nThe next layers were already added:";
      for (const auto& el : fGeoLayers) {
        msg << "\n\t- DetID = " << static_cast<int>(el.fDetID) << ", localID = " << el.fLocID << "fZref = " << el.fZref
            << ", fZmin = " << el.fZmin << ", fZmax = " << el.fZmax << ", fXmax = " << el.fXmax
            << ", fYmax = " << el.fYmax;
      }
      throw std::logic_error(msg.str());
    }
  }
 
  // ---------------------------------------------------------------------------------------------------------------------
  //
  template<typename T>
  void SetupBuilder::SetFromSetup(const Setup<T>& inSetup)
  {
    LOG(info) << inSetup.ToString(2);
    fbReady = false;
    // Reset geo layer information
    fGeoLayers.clear();
    fvMaterial.clear();
    fModuleIndexFactory.Reset();
    fFieldFactory.ResetSliceReferences();
 
    // Init target properties
    fTarget = Target<double>(inSetup.fTarget);
 
    // Init geometry layers
    for (int iLayer{0}; iLayer < inSetup.GetNofMaterialLayers(); ++iLayer) {
      const auto& material{inSetup.GetMaterial(iLayer)};
      fvMaterial.push_back(material);
      fFieldFactory.AddSliceReference(material.GetXYmax(), material.GetXYmax(), material.GetZref());
      const auto& [iDetExt, iLoc] = inSetup.GetIndexMap().template GlobalToLocal<int>(iLayer);
      fModuleIndexFactory.AddComponent(iDetExt, iLoc, material.GetZref());
    }
 
    fbIfGeoLayersInit = true;
    fbIfTargetSet     = true;
    fbIfSetFromSetup  = true;
  }
 
  // ---------------------------------------------------------------------------------------------------------------------
  //
  template<typename T>
  Setup<T> SetupBuilder::MakeSetup(EFieldMode fldMode)
  {
    Setup<T> setup(fldMode);
    if (!fbReady) {
      this->Init();
    }
    setup.fTarget = this->fTarget;
    for (const auto& material : this->fvMaterial) {
      setup.fvMaterialLayers.push_back(material);
    }
    setup.fField          = fFieldFactory.MakeField<T>();
    setup.fModuleIndexMap = fModuleIndexFactory.MakeIndexMap();
    return setup;
  }
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  template<typename T>
  Setup<T> SetupBuilder::Load(const std::string& fileName)
  {
    Setup<double> setup(EFieldMode::Intrpl);
    std::ifstream ifs(fileName, std::ios::binary);
    if (!ifs) {
      std::stringstream msg;
      msg << "kf::SetupBuilder::Load: intput setup file \"" << fileName << "\" was not found";
      throw std::runtime_error(msg.str());
    }
    try {
      boost::archive::binary_iarchive ia(ifs);
      ia >> setup;
    }
    catch (const std::exception& err) {
      std::stringstream msg;
      msg << "kf::SetupBuilder::Load: input setup file \"" << fileName
          << "\" has inconsistent format or was "
             "corrupted. The exception message: "
          << err.what();
      throw std::runtime_error(msg.str());
    }
    return Setup<T>(setup);
  }
}  // namespace cbm::algo::kf