RadiationMapsMaker.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef G4UserActions_RadiationMapsMaker_H
#define G4UserActions_RadiationMapsMaker_H
 
#include <vector>
#include <string>
#include <fstream>
#include "G4UserRunAction.hh"
#include "G4UserSteppingAction.hh"
 
class TGraph;
 
namespace G4UA
{
  
  class RadiationMapsMaker: 
    public G4UserRunAction,
    public G4UserSteppingAction
    {
    
    public:
 
      struct Config
      {
 
    std::vector<std::string> materials;
 
    std::string activationFileName = std::string("");
    
    bool posYOnly = false; // set to true for upper hemisphere only
    
    int nBinsr = 120;
    int nBinsz = 240;
    
    double rMinZoom =    0.; // cm
    double rMinFull =    0.; // cm
    
    double rMaxZoom =  480.; // cm
    double rMaxFull = 1200.; // cm
    
    double zMinZoom =    0.; // cm
    double zMinFull =    0.; // cm
    
    double zMaxZoom =  960.; // cm
    double zMaxFull = 2400.; // cm
 
    int nBinsr3d   = 30;
    int nBinsz3d   = 60;
    int nBinsphi3d = 32;
    
    double phiMinZoom = -180.; // degrees
    double phiMaxZoom =  180.; // degrees
 
    // theta x dphi bins are used in the theta-spectra
    
    int nBinsdphi =  18; // 0 degrees <= dphi < 360 degrees
    int nBinstheta =  9;
 
    double thetaMin =  0.; // degrees
    double thetaMax = 90.; // degrees
 
    // neutron spectra
    int nBinslogEn  =  90;   
    double logEMinn = -11.; // min log10(E_kin/MeV) 
    double logEMaxn =   7.; // max log10(E_kin/MeV) 
 
    // particle spectra for gamma,e^+/-,mu^+/-,pi^+/-,p,rest
    int nBinslogEo  = 45;   
    double logEMino = -2.; // min log10(E_kin/MeV) 
    double logEMaxo =  7.; // max log10(E_kin/MeV) 
 
    // time dependent TID maps
    int nBinslogT   =  20;   
    double logTMin  = -9.; // log10(t_cut/s); first bin for t < 1 ns 
    double logTMax  = 11.; // log10(t_cut/s); last bin for t < 3169 a
 
    // elements mass fraction maps
    int elemZMin    =   1; // minimum Z to keep mass fraction
    int elemZMax    =  92; // maximum Z to keep mass fraction
      };
 

      struct Report
      {
    std::vector<double> m_rz_tid;
    std::vector<double> m_rz_eion;
    std::vector<double> m_rz_niel;
    std::vector<double> m_rz_h20;
    std::vector<double> m_rz_neut;
    std::vector<double> m_rz_chad;


    std::vector<double> m_rz_vol;
    std::vector<double> m_rz_norm;

    std::vector<double> m_full_rz_tid;
    std::vector<double> m_full_rz_eion;
    std::vector<double> m_full_rz_niel;
    std::vector<double> m_full_rz_h20;
    std::vector<double> m_full_rz_neut;
    std::vector<double> m_full_rz_chad;


    std::vector<double> m_full_rz_vol;
    std::vector<double> m_full_rz_norm;

    std::vector<double> m_3d_tid;
    std::vector<double> m_3d_eion;
    std::vector<double> m_3d_niel;
    std::vector<double> m_3d_h20;
    std::vector<double> m_3d_neut;
    std::vector<double> m_3d_chad;


    std::vector<double> m_3d_vol;
    std::vector<double> m_3d_norm;
 
    // particle spectra
 
    // neutrons
    
    std::vector<double> m_rz_neut_spec;
    std::vector<double> m_full_rz_neut_spec;
    std::vector<double> m_theta_full_rz_neut_spec;
 
    // gamma
    
    std::vector<double> m_rz_gamm_spec;
    std::vector<double> m_full_rz_gamm_spec;
    std::vector<double> m_theta_full_rz_gamm_spec;
 
    // e^+/-
    
    std::vector<double> m_rz_elec_spec;
    std::vector<double> m_full_rz_elec_spec;
    std::vector<double> m_theta_full_rz_elec_spec;
 
    // mu^+/-
    
    std::vector<double> m_rz_muon_spec;
    std::vector<double> m_full_rz_muon_spec;
    std::vector<double> m_theta_full_rz_muon_spec;
 
    // pi^+/-
    
    std::vector<double> m_rz_pion_spec;
    std::vector<double> m_full_rz_pion_spec;
    std::vector<double> m_theta_full_rz_pion_spec;
 
    // proton
    
    std::vector<double> m_rz_prot_spec;
    std::vector<double> m_full_rz_prot_spec;
    std::vector<double> m_theta_full_rz_prot_spec;
 
    // rest
    
    std::vector<double> m_rz_rest_spec;
    std::vector<double> m_full_rz_rest_spec;
    std::vector<double> m_theta_full_rz_rchgd_spec;
    std::vector<double> m_theta_full_rz_rneut_spec;
 
    // time dependent maps

    std::vector<double> m_rz_tid_time;
    std::vector<double> m_full_rz_tid_time;

    std::vector<double> m_rz_ht_time;
    std::vector<double> m_full_rz_ht_time;
 
    // maps of element fractions 

    std::vector<double> m_rz_element;
    std::vector<double> m_full_rz_element;
 
    void merge(const Report& maps);
      };
 
      RadiationMapsMaker(const Config& config);
 
      ~RadiationMapsMaker();
 
      // initialize maps to 0
      virtual void BeginOfRunAction(const G4Run*) override final;
 
      // increment radiation maps
      virtual void UserSteppingAction(const G4Step*) override final;

      const Report& getReport() const
      { return m_maps; }
 
    private:
      
      Config m_config;
 
      Report m_maps;
 
      TGraph * m_tgpSiA = 0;
      TGraph * m_tgpSiB = 0;
      TGraph * m_tgnSiA = 0;
      TGraph * m_tgnSiB = 0;
      TGraph * m_tgnSiC = 0;
      TGraph * m_tgpiSi = 0;
      TGraph * m_tgeSi  = 0;
 
      TGraph * m_tgHn  = 0;
      TGraph * m_tgHg  = 0;
      TGraph * m_tgHp  = 0;
      TGraph * m_tgHem = 0;
      TGraph * m_tgHep = 0;
      TGraph * m_tgHmm = 0;
      TGraph * m_tgHmp = 0;
      TGraph * m_tgHpm = 0;
      TGraph * m_tgHpp = 0;
      TGraph * m_tgHa  = 0;
 
      std::ofstream m_activationFile;
      
    }; // class RadiationMapsMaker
  
  
} // namespace G4UA 
 
#endif