CbmGenerateMaterialMaps.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 "FairTask.h"
#include "KfMaterialMap.h"
#include "KfMaterialMapFactory.h"
#include "yaml/Yaml.h"
 
#include <map>
#include <string>
#include <string_view>
#include <tuple>
#include <vector>
 
class CbmGenerateMaterialMaps : public FairTask {
  using MaterialMap = cbm::algo::kf::MaterialMap;
 
  struct MaterialSlice {
    std::string fName;
    double fRefZ;   
    double fMinZ;   
    double fMaxZ;   
    double fMaxXY;  
 
    bool operator<(const MaterialSlice& r) const { return (fRefZ < r.fRefZ); }
 
    CBM_YAML_PROPERTIES(cbm::algo::yaml::Property(&CbmGenerateMaterialMaps::MaterialSlice::fName, "name", ""),
                   cbm::algo::yaml::Property(&CbmGenerateMaterialMaps::MaterialSlice::fRefZ, "ref_z", ""),
                   cbm::algo::yaml::Property(&CbmGenerateMaterialMaps::MaterialSlice::fMinZ, "min_z", ""),
                   cbm::algo::yaml::Property(&CbmGenerateMaterialMaps::MaterialSlice::fMaxZ, "max_z", ""),
                   cbm::algo::yaml::Property(&CbmGenerateMaterialMaps::MaterialSlice::fMaxXY, "max_xy", ""));
  };
 
  struct Config {
    std::vector<MaterialSlice> fvUserSlices;  
 
    double fPitch           = 0.1;    
    int fMaxNofBins         = 100;    
    int fNofRays            = 3;      
    bool fbParallelRays     = false;  
    bool fbTrackingStations = false;  
    bool fbSafeMaterialInit = true;   
 
    CBM_YAML_PROPERTIES(cbm::algo::yaml::Property(&CbmGenerateMaterialMaps::Config::fvUserSlices, "user_slices", ""),
                   cbm::algo::yaml::Property(&CbmGenerateMaterialMaps::Config::fPitch, "pitch", ""),
                   cbm::algo::yaml::Property(&CbmGenerateMaterialMaps::Config::fMaxNofBins, "max_nof_bins", ""),
                   cbm::algo::yaml::Property(&CbmGenerateMaterialMaps::Config::fNofRays, "nof_rays", ""),
                   cbm::algo::yaml::Property(&CbmGenerateMaterialMaps::Config::fbParallelRays, "parallel_rays", ""),
                   cbm::algo::yaml::Property(&CbmGenerateMaterialMaps::Config::fbTrackingStations,
                                               "tracking_stations", ""),
                   cbm::algo::yaml::Property(&CbmGenerateMaterialMaps::Config::fbSafeMaterialInit,
                                               "safe_material_init", ""));
  };
 
 public:
  CbmGenerateMaterialMaps();
 
  CbmGenerateMaterialMaps(const char* name, int verbose);
 
  virtual ~CbmGenerateMaterialMaps() = default;
 
  CbmGenerateMaterialMaps(const CbmGenerateMaterialMaps&) = delete;
 
  CbmGenerateMaterialMaps(CbmGenerateMaterialMaps&&) = delete;
 
  CbmGenerateMaterialMaps& operator=(const CbmGenerateMaterialMaps&) = delete;
 
  CbmGenerateMaterialMaps& operator=(CbmGenerateMaterialMaps&&) = delete;
 
  InitStatus Init();
 
  InitStatus ReInit();
 
  void Finish();
 
  void SetOutputName(const char* fileName) { fsOutputFile = fileName; }
 
  void SetUserConfig(const char* userConfig) { fsUserConfig = userConfig; }
 
  const std::map<std::string, MaterialMap>& GetMaterial() const { return fmMaterial; }
 
 private:
  void WriteMaterialMaps();
 
  static constexpr double kXYoffset     = 1.3;  
  static constexpr double kTargetOffset = 1.;   
 
  Config fConfig;                                                               
  std::string fsUserConfig = "";                                                
  std::string fsOutputFile = "matBudget.root";                                  
  std::map<std::string, MaterialMap> fmMaterial;                                
  std::unique_ptr<::kf::tools::MaterialMapFactory> fpMaterialFactory{nullptr};  
 
  double fTargetZ;  
 
  ClassDef(CbmGenerateMaterialMaps, 0);
};