KfSetup.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 "KfDefs.h"
#include "KfField.h"
#include "KfMaterialMap.h"
#include "KfModuleIndexMap.h"
#include "KfTarget.h"
#include "KfVector.h"
 
#include <boost/serialization/access.hpp>
 
#include <fstream>
#include <optional>
#include <sstream>
#include <string>
#include <vector>
 
namespace cbm::algo::kf
{
  template<typename T>
  class alignas(VcMemAlign) Setup {
    friend class boost::serialization::access;  // Boost serializer methods
    friend class SetupBuilder;
    template<typename>
    friend class Setup;
 
   public:
    Setup(EFieldMode fldMode)
      : fvMaterialLayers({})
      , fField(Field<T>(fldMode, EFieldType::Normal))
      , fTarget(Target<T>())
    {
    }
 
    ~Setup() = default;
 
    template<typename I>
    Setup(const Setup<I>& other)
      : fModuleIndexMap(other.fModuleIndexMap)
      , fvMaterialLayers(other.fvMaterialLayers)
      , fField(other.fField)
      , fTarget(other.fTarget)
    {
    }
 
    //Setup(Setup&&) noexcept;
 
    Setup& operator=(const Setup& other) = default;
 
    //Setup& operator=(Setup&&) noexcept;
 
    template<class EDetID>
    void DisableLayer(EDetID iDet, int iLoc);
 
    const Field<T>& GetField() const { return fField; }
 
    const MaterialMap& GetMaterial(int iLayer) const { return fvMaterialLayers[iLayer]; }
 
    template<class EDetID>
    const MaterialMap& GetMaterial(EDetID iDet, int iLoc) const
    {
      return fvMaterialLayers[fModuleIndexMap.LocalToGlobal(iDet, iLoc)];
    }
 
    const ModuleIndexMap& GetIndexMap() const { return fModuleIndexMap; }
 
    int GetNofLayers() const { return static_cast<int>(fvMaterialLayers.size()); }
 
    const Target<T>& GetTarget() const { return fTarget; }
 
    std::string ToString(int verbosity = 1, int indentLevel = 0) const;
 
   private:
    template<class Archive>
    void serialize(Archive& ar, const unsigned int /*version*/)
    {
      ar& fModuleIndexMap;
      ar& fvMaterialLayers;
      ar& fTarget;
      ar& fField;
    }
 
    ModuleIndexMap fModuleIndexMap{};             
    std::vector<MaterialMap> fvMaterialLayers{};  
    Field<T> fField;                              
    Target<T> fTarget;                            
  };
 
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  template<typename T>
  template<class EDetID>
  void Setup<T>::DisableLayer(EDetID iDet, int iLoc)
  {
    int iLayer{fModuleIndexMap.LocalToGlobal(iDet, iLoc)};
    if (iLayer == -1) {
      return;
    }
 
    // Remove material layer and add it to the next one
    if (iLayer < static_cast<int>(fvMaterialLayers.size() - 1)) {
      fvMaterialLayers[iLayer + 1].Add(fvMaterialLayers[iLayer], utils::simd::Cast<T, float>(fTarget.GetZ()));
    }
    fvMaterialLayers.erase(fvMaterialLayers.begin() + iLayer);
 
    // Remove field slice
    fField.RemoveSlice(iLayer);
 
    // Disable layer in the index map
    fModuleIndexMap.Disable(iDet, iLoc);
    //std::cout << "LAYERS: \n" << fModuleIndexMap.ToString() << '\n';
  }
 
 
}  // namespace cbm::algo::kf