ATLAS Offline Software
RadiationMapsMakerTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
3 */
4 #include "TH2D.h"
5 #include "TH3D.h"
6 #include "TFile.h"
7 #include "RadiationMapsMakerTool.h"
8 
9 namespace G4UA{
10 
11  RadiationMapsMakerTool::RadiationMapsMakerTool(const std::string& type,
12  const std::string& name,
13  const IInterface* parent)
14  : UserActionToolBase<RadiationMapsMaker>(type, name, parent),
15  m_radMapsFileName("RadMaps.root")
16  {
18  declareProperty("RadMapsFileName" , m_radMapsFileName);
20  declareProperty("Materials" , m_config.materials);
22  declareProperty("ActivationFileName", m_config.activationFileName);
24  declareProperty("PositiveYOnly" , m_config.posYOnly);
27  declareProperty("NBinsR" , m_config.nBinsr);
28  declareProperty("NBinsZ" , m_config.nBinsz);
30  declareProperty("NBinsLogEn" , m_config.nBinslogEn);
32  declareProperty("NBinsLogEo" , m_config.nBinslogEo);
34  declareProperty("NBinsDPhi" , m_config.nBinsdphi);
36  declareProperty("NBinsTheta" , m_config.nBinstheta);
38  declareProperty("NBinsR3D" , m_config.nBinsr3d);
39  declareProperty("NBinsZ3D" , m_config.nBinsz3d);
40  declareProperty("NBinsPhi3D" , m_config.nBinsphi3d);
42  declareProperty("NBinsLogTimeCut" , m_config.nBinslogT);
45  declareProperty("RMinZoom" , m_config.rMinZoom);
46  declareProperty("RMaxZoom" , m_config.rMaxZoom);
47  declareProperty("ZMinZoom" , m_config.zMinZoom);
48  declareProperty("ZMaxZoom" , m_config.zMaxZoom);
50  declareProperty("RMinFull" , m_config.rMinFull);
51  declareProperty("RMaxFull" , m_config.rMaxFull);
52  declareProperty("ZMinFull" , m_config.zMinFull);
53  declareProperty("ZMaxFull" , m_config.zMaxFull);
55  declareProperty("PhiMinZoom" , m_config.phiMinZoom);
56  declareProperty("PhiMaxZoom" , m_config.phiMaxZoom);
58  declareProperty("LogEMinn" , m_config.logEMinn);
59  declareProperty("LogEMaxn" , m_config.logEMaxn);
61  declareProperty("LogEMino" , m_config.logEMino);
62  declareProperty("LogEMaxo" , m_config.logEMaxo);
64  declareProperty("ThetaMin" , m_config.thetaMin);
65  declareProperty("ThetaMax" , m_config.thetaMax);
67  declareProperty("LogTMin" , m_config.logTMin);
68  declareProperty("LogTMax" , m_config.logTMax);
70  declareProperty("ElemZMin" , m_config.elemZMin);
71  declareProperty("ElemZMax" , m_config.elemZMax);
72  }
73 
74  //---------------------------------------------------------------------------
75  // Initialize Configurable Properties
76  //---------------------------------------------------------------------------
77  StatusCode RadiationMapsMakerTool::initialize()
78  {
79  msg(MSG::INFO)
80  << "Initializing " << name() << "\n"
81  << "OutputFile: " << m_radMapsFileName << "\n"
82  << "ActivationFile: " << m_config.activationFileName << "\n"
83  << "Materials: ";
84  char c=' ';
85  for(const std::string& matName : m_config.materials) {
86  msg() << c << matName;
87  c=',';
88  }
89  msg()
90  << "\n"
91  << "PositiveYOnly: " << m_config.posYOnly << "\n"
92  << "2D Maps: " << m_config.nBinsz << (m_config.zMinFull<0?" z-bins, ":" |z|-bins, ")
93  << m_config.nBinsr << " r-bins" << "\n"
94  << "Zoom: " << m_config.zMinZoom << (m_config.zMinFull<0?" < z/cm < ":" < |z|/cm < ")
95  << m_config.zMaxZoom << ", "
96  << m_config.rMinZoom << " < r/cm < "
97  << m_config.rMaxZoom << "\n"
98  << "Full: " << m_config.zMinFull << (m_config.zMinFull<0?" < z/cm < ":" < |z|/cm < ")
99  << m_config.zMaxFull << ", "
100  << m_config.rMinFull << " < r/cm < "
101  << m_config.rMaxFull << "\n"
102  << "Neutron Spectra: " << m_config.nBinslogEn << " log10E-bins, "
103  << m_config.logEMinn << " < log10(E/MeV) < " << m_config.logEMaxn << "\n"
104  << "Other Spectra: " << m_config.nBinslogEo << " log10E-bins, "
105  << m_config.logEMino << " < log10(E/MeV) < " << m_config.logEMaxo << "\n"
106  << "DPhi-Bins: " << m_config.nBinsdphi << " dphi-bins, 0 < dphi < 360 \n"
107  << "Theta-Bins: " << m_config.nBinstheta << " theta-bins, "
108  << m_config.thetaMin << " < theta < " << m_config.thetaMax << "\n"
109  << "3D Maps: " << m_config.nBinsz3d << (m_config.zMinFull<0?" z-bins, ":" |z|-bins, ")
110  << m_config.nBinsr3d << " r-bins, " << m_config.nBinsphi3d << " phi-bins" << "\n"
111  << "Zoom: " << m_config.zMinZoom << (m_config.zMinFull<0?" < z/cm < ":" < |z|/cm < ")
112  << m_config.zMaxZoom << ", "
113  << m_config.rMinZoom << " < r/cm < " << m_config.rMaxZoom << ", "
114  << m_config.phiMinZoom << " < phi/degrees < " << m_config.phiMaxZoom << "\n"
115  << "Time TID/H Maps: " << m_config.nBinslogT << " Time-cut bins, "
116  << m_config.logTMin << " < log10(t_cut/s) < "<< m_config.logTMax << "\n"
117  << "Mass frac. Maps: " << m_config.elemZMax-m_config.elemZMin+1 << " Element bins, "
118  << m_config.elemZMin << " <= Z <= < " << m_config.elemZMax
119  << endmsg;
120 
121  // clear the activation file if requested
122  if ( !m_config.activationFileName.empty() ) {
123  std::ofstream actf;
124  actf.open(m_config.activationFileName);
125  actf.close();
126  }
127 
128  return StatusCode::SUCCESS;
129  }
130 
131  //---------------------------------------------------------------------------
132  // Merge results from all threads
133  //---------------------------------------------------------------------------
134  StatusCode RadiationMapsMakerTool::finalize()
135  {
136  ATH_MSG_DEBUG( "Finalizing " << name() );
137 
138  RadiationMapsMaker::Report maps;
139 
140  // vector of pointers to vectors of double to save space
141  std::vector<std::vector<double> *> pVal = {
142  &(maps.m_rz_tid),&(maps.m_rz_eion),&(maps.m_rz_niel),&(maps.m_rz_h20),&(maps.m_rz_neut),&(maps.m_rz_chad),
143  &(maps.m_full_rz_tid),&(maps.m_full_rz_eion),&(maps.m_full_rz_niel),&(maps.m_full_rz_h20),&(maps.m_full_rz_neut),&(maps.m_full_rz_chad)
144  };
145 
146  std::vector<std::vector<double> *> pVal3d = {
147  &(maps.m_3d_tid),&(maps.m_3d_eion),&(maps.m_3d_niel),&(maps.m_3d_h20),&(maps.m_3d_neut),&(maps.m_3d_chad)
148  };
149 
150  std::vector<std::vector<double> *> pValSpec = {
151  &(maps.m_rz_neut_spec),&(maps.m_rz_gamm_spec),&(maps.m_rz_elec_spec),&(maps.m_rz_muon_spec),&(maps.m_rz_pion_spec),&(maps.m_rz_prot_spec),&(maps.m_rz_rest_spec),
152  &(maps.m_full_rz_neut_spec),&(maps.m_full_rz_gamm_spec),&(maps.m_full_rz_elec_spec),&(maps.m_full_rz_muon_spec),&(maps.m_full_rz_pion_spec),&(maps.m_full_rz_prot_spec),&(maps.m_full_rz_rest_spec)
153  };
154 
155  std::vector<int> nBinslogE = {
156  m_config.nBinslogEn,m_config.nBinslogEo,m_config.nBinslogEo,m_config.nBinslogEo,m_config.nBinslogEo,m_config.nBinslogEo,m_config.nBinslogEo,
157  m_config.nBinslogEn,m_config.nBinslogEo,m_config.nBinslogEo,m_config.nBinslogEo,m_config.nBinslogEo,m_config.nBinslogEo,m_config.nBinslogEo
158  };
159 
160  std::vector<std::vector<double> *> pValThetaSpec = {
161  &(maps.m_theta_full_rz_neut_spec),&(maps.m_theta_full_rz_gamm_spec),&(maps.m_theta_full_rz_elec_spec),&(maps.m_theta_full_rz_muon_spec),&(maps.m_theta_full_rz_pion_spec),&(maps.m_theta_full_rz_prot_spec),&(maps.m_theta_full_rz_rchgd_spec),&(maps.m_theta_full_rz_rneut_spec)
162  };
163 
164  std::vector<int> nBinsThetalogE = {
165  m_config.nBinslogEn,m_config.nBinslogEo,m_config.nBinslogEo,m_config.nBinslogEo,m_config.nBinslogEo,m_config.nBinslogEo,m_config.nBinslogEo,m_config.nBinslogEo
166  };
167 
168  for(unsigned int hi=0;hi<pVal.size();hi++) {
169 
170  // first make sure the vectors are empty
171 
172  (pVal[hi])->resize(0);
173 
174  // then resize to proper size and initialize with 0's
175  // all maps are needed for the merge - so have to do resize
176  // for all before merging any ...
177 
178  (pVal[hi])->resize(m_config.nBinsz*m_config.nBinsr,0.0);
179  }
180 
181  // same for 3d
182 
183  for(unsigned int hi=0;hi<pVal3d.size();hi++) {
184  (pVal3d[hi])->resize(0);
185  (pVal3d[hi])->resize(m_config.nBinsz3d*m_config.nBinsr3d*m_config.nBinsphi3d,0.0);
186  }
187 
188  // same for spectra
189 
190  for(unsigned int hi=0;hi<pValSpec.size();hi++) {
191  (pValSpec[hi])->resize(0);
192  (pValSpec[hi])->resize(m_config.nBinsz*m_config.nBinsr*nBinslogE[hi],0.0);
193  }
194 
195  // same for theta x dphi spectra
196 
197  for(unsigned int hi=0;hi<pValThetaSpec.size();hi++) {
198  (pValThetaSpec[hi])->resize(0);
199  (pValThetaSpec[hi])->resize(m_config.nBinsdphi*m_config.nBinstheta*m_config.nBinsz*m_config.nBinsr*nBinsThetalogE[hi],0.0);
200  }
201 
202  // same for misc individual maps
203 
204  maps.m_rz_tid_time .resize(0);
205  maps.m_rz_ht_time .resize(0);
206  maps.m_full_rz_tid_time .resize(0);
207  maps.m_full_rz_ht_time .resize(0);
208 
209  maps.m_rz_element .resize(0);
210  maps.m_full_rz_element .resize(0);
211 
212  if (!m_config.materials.empty()) {
213  // need volume fraction only if particular materials are selected
214  // 2d zoom
215  maps.m_rz_vol .resize(0);
216  maps.m_rz_norm.resize(0);
217  // 2d full
218  maps.m_full_rz_vol.resize(0);
219  maps.m_full_rz_norm.resize(0);
220  // 3d
221  maps.m_3d_vol .resize(0);
222  maps.m_3d_norm.resize(0);
223  }
224 
225  // then resize to proper size and initialize with 0's
226  // all maps are needed for the merge - so have to do resize
227  // for all first ...
228 
229  maps.m_rz_tid_time .resize(m_config.nBinsz*m_config.nBinsr*m_config.nBinslogT,0.0);
230  maps.m_rz_ht_time .resize(m_config.nBinsz*m_config.nBinsr*m_config.nBinslogT,0.0);
231  maps.m_full_rz_tid_time .resize(m_config.nBinsz*m_config.nBinsr*m_config.nBinslogT,0.0);
232  maps.m_full_rz_ht_time .resize(m_config.nBinsz*m_config.nBinsr*m_config.nBinslogT,0.0);
233 
234  maps.m_rz_element .resize(m_config.nBinsz*m_config.nBinsr*(m_config.elemZMax-m_config.elemZMin+1),0.0);
235  maps.m_full_rz_element .resize(m_config.nBinsz*m_config.nBinsr*(m_config.elemZMax-m_config.elemZMin+1),0.0);
236 
237  if (!m_config.materials.empty()) {
238  // need volume fraction only if particular materials are selected
239  // 2d zoom
240  maps.m_rz_vol .resize(m_config.nBinsz*m_config.nBinsr,0.0);
241  maps.m_rz_norm.resize(m_config.nBinsz*m_config.nBinsr,0.0);
242  // 2d full
243  maps.m_full_rz_vol .resize(m_config.nBinsz*m_config.nBinsr,0.0);
244  maps.m_full_rz_norm.resize(m_config.nBinsz*m_config.nBinsr,0.0);
245  // 3d
246  maps.m_3d_vol .resize(m_config.nBinsz3d*m_config.nBinsr3d*m_config.nBinsphi3d,0.0);
247  maps.m_3d_norm.resize(m_config.nBinsz3d*m_config.nBinsr3d*m_config.nBinsphi3d,0.0);
248  }
249 
250  // merge radiation map vectors from threads
251  // Accumulate the results across threads
252  m_actions.accumulate(maps, &RadiationMapsMaker::getReport,
253  &RadiationMapsMaker::Report::merge);
254 
255  TFile * f = new TFile(m_radMapsFileName.c_str(),"RECREATE");
256 
257  // histograms can be booked, filled, written and deleted in a loop
258  // in order to save memory. Need vectors to loop over them ...
259 
260  std::vector<const char *> h2dNames = {
261  "rz_tid","rz_eion","rz_niel","rz_h20","rz_neut","rz_chad",
262  "full_rz_tid","full_rz_eion","full_rz_niel","full_rz_h20","full_rz_neut","full_rz_chad"
263  };
264 
265  std::vector<const char *> h2dZTitles = {
266  "TID [Gy]","E_{ion}/V [MeV/cm^{3}]","NIEL [n_{eq}/cm^{2}]","SEE [h_{>20 MeV}/cm^{2}]","FLUX [n_{>100 keV}/cm^{2}]","FLUX [h_{charged}/cm^{2}]",
267  "TID [Gy]","E_{ion}/V [MeV/cm^{3}]","NIEL [n_{eq}/cm^{2}]","SEE [h_{>20 MeV}/cm^{2}]","FLUX [n_{>100 keV}/cm^{2}]","FLUX [h_{charged}/cm^{2}]"
268  };
269 
270  std::vector<double> zMin = {
271  m_config.zMinZoom,m_config.zMinZoom,m_config.zMinZoom,m_config.zMinZoom,m_config.zMinZoom,m_config.zMinZoom,
272  m_config.zMinFull,m_config.zMinFull,m_config.zMinFull,m_config.zMinFull,m_config.zMinFull,m_config.zMinFull
273  };
274 
275  std::vector<double> zMax = {
276  m_config.zMaxZoom,m_config.zMaxZoom,m_config.zMaxZoom,m_config.zMaxZoom,m_config.zMaxZoom,m_config.zMaxZoom,
277  m_config.zMaxFull,m_config.zMaxFull,m_config.zMaxFull,m_config.zMaxFull,m_config.zMaxFull,m_config.zMaxFull
278  };
279 
280  std::vector<double> rMin = {
281  m_config.rMinZoom,m_config.rMinZoom,m_config.rMinZoom,m_config.rMinZoom,m_config.rMinZoom,m_config.rMinZoom,
282  m_config.rMinFull,m_config.rMinFull,m_config.rMinFull,m_config.rMinFull,m_config.rMinFull,m_config.rMinFull
283  };
284 
285  std::vector<double> rMax = {
286  m_config.rMaxZoom,m_config.rMaxZoom,m_config.rMaxZoom,m_config.rMaxZoom,m_config.rMaxZoom,m_config.rMaxZoom,
287  m_config.rMaxFull,m_config.rMaxFull,m_config.rMaxFull,m_config.rMaxFull,m_config.rMaxFull,m_config.rMaxFull
288  };
289 
290  const char * xtitle = (m_config.zMinFull<0?"z [cm]":"|z| [cm]");
291 
292  TH2D * h_rz_vol = 0;
293  TH2D * h_rz_norm = 0;
294  TH2D * h_full_rz_vol = 0;
295  TH2D * h_full_rz_norm = 0;
296 
297  for(unsigned int hi=0;hi<h2dNames.size();hi++) {
298  TH2D *h2d = new TH2D(h2dNames[hi],h2dNames[hi],m_config.nBinsz,zMin[hi],zMax[hi],m_config.nBinsr,rMin[hi],rMax[hi]);
299  h2d->SetXTitle(xtitle);
300  h2d->SetYTitle("r [cm]");
301  h2d->SetZTitle(h2dZTitles[hi]);
302  if (hi==0 && !m_config.materials.empty()) {
303  // need volume fraction only if particular materials are selected
304  //
305  // the maps for TID, NIEL and SEE need to be divided by the ratio of (vol/norm) in order to get
306  // the proper estimate per volume bin for the selected material.
307  // This is *not* done in the tool directly and left to the user after having summed the histograms
308  // from many individual jobs.
309  //
310  h_rz_vol = new TH2D("rz_vol" ,"rz_vol" ,m_config.nBinsz,m_config.zMinZoom,m_config.zMaxZoom,m_config.nBinsr,m_config.rMinZoom,m_config.rMaxZoom);
311  h_rz_norm = new TH2D("rz_norm","rz_norm",m_config.nBinsz,m_config.zMinZoom,m_config.zMaxZoom,m_config.nBinsr,m_config.rMinZoom,m_config.rMaxZoom);
312  h_full_rz_vol = new TH2D("full_rz_vol" ,"full_rz_vol" ,m_config.nBinsz,m_config.zMinFull,m_config.zMaxFull,m_config.nBinsr,m_config.rMinFull,m_config.rMaxFull);
313  h_full_rz_norm = new TH2D("full_rz_norm","full_rz_norm",m_config.nBinsz,m_config.zMinFull,m_config.zMaxFull,m_config.nBinsr,m_config.rMinFull,m_config.rMaxFull);
314 
315  h_rz_vol ->SetXTitle(xtitle);
316  h_rz_norm ->SetXTitle(xtitle);
317  h_rz_vol ->SetYTitle("r [cm]");
318  h_rz_norm ->SetYTitle("r [cm]");
319  std::string hname("Volume fraction of");
320  char c = ' ';
321  for(const std::string& matName : m_config.materials) {
322  hname += c;
323  hname += matName;
324  c = ',';
325  }
326  h_rz_vol ->SetZTitle(hname.data());
327  h_rz_norm ->SetZTitle("Volume norm");
328 
329  h_full_rz_vol ->SetXTitle(xtitle);
330  h_full_rz_norm ->SetXTitle(xtitle);
331  h_full_rz_vol ->SetYTitle("r [cm]");
332  h_full_rz_norm ->SetYTitle("r [cm]");
333  h_full_rz_vol ->SetZTitle(hname.data());
334  h_full_rz_norm ->SetZTitle("Volume norm");
335  }
336 
337  // normalize to volume element per bin
338  for(int i=0;i<h2d->GetNbinsX();i++) {
339  for(int j=0;j<h2d->GetNbinsY();j++) {
340  int iBin = h2d->GetBin(i+1,j+1);
341  int vBin = m_config.nBinsr*i+j;
342  double r0=h2d->GetYaxis()->GetBinLowEdge(j+1);
343  double r1=h2d->GetYaxis()->GetBinUpEdge(j+1);
344  double z0=h2d->GetXaxis()->GetBinLowEdge(i+1);
345  double z1=h2d->GetXaxis()->GetBinUpEdge(i+1);
346  double vol=(z1-z0)*M_PI*(r1*r1-r0*r0);
347  // if |z| instead of z double the volume
348  if ( m_config.zMinFull >= 0 ) vol *= 2;
349  // if positive y hemisphere is used only -- half the volume
350  if ( m_config.posYOnly ) vol *= 0.5;
351  double val = (*(pVal[hi]))[vBin];
352  h2d->SetBinContent(iBin,val/vol);
353  if (hi ==0 && !m_config.materials.empty()) {
354  // need volume fraction only if particular materials are selected
355  // VOL
356  val =maps.m_rz_vol[vBin];
357  h_rz_vol->SetBinContent(iBin,val/vol);
358  // NORM
359  val =maps.m_rz_norm[vBin];
360  h_rz_norm->SetBinContent(iBin,val/vol);
361  }
362  if (hi ==h2dNames.size()/2 && !m_config.materials.empty()) {
363  // need volume fraction only if particular materials are selected
364  // VOL
365  val =maps.m_full_rz_vol[vBin];
366  h_full_rz_vol->SetBinContent(iBin,val/vol);
367  // NORM
368  val =maps.m_full_rz_norm[vBin];
369  h_full_rz_norm->SetBinContent(iBin,val/vol);
370  }
371  }
372  }
373  h2d->Write();
374  h2d->Delete();
375  if (hi ==h2dNames.size()/2 && !m_config.materials.empty()) {
376  h_rz_vol->Write();
377  h_rz_vol->Delete();
378  h_rz_norm->Write();
379  h_rz_norm->Delete();
380  h_full_rz_vol->Write();
381  h_full_rz_vol->Delete();
382  h_full_rz_norm->Write();
383  h_full_rz_norm->Delete();
384  }
385  }
386 
387  std::vector<const char *> h3dNames = {
388  "h3d_tid","h3d_eion","h3d_niel","h3d_h20","h3d_neut","h3d_chad"
389  };
390 
391  std::vector<const char *> h3dTitles = {
392  "TID [Gy]","E_{ion}/V [MeV/cm^{3}]","NIEL [n_{eq}/cm^{2}]","SEE [h_{>20 MeV}/cm^{2}]","FLUX [n_{>100 keV}/cm^{2}]","FLUX [h_{charged}/cm^{2}]"
393  };
394 
395  TH3D * h_3d_vol = 0;
396  TH3D * h_3d_norm = 0;
397 
398  for(unsigned int hi=0;hi<h3dNames.size();hi++) {
399  TH3D *h3d = new TH3D(h3dNames[hi],h3dNames[hi],m_config.nBinsz3d,m_config.zMinZoom,m_config.zMaxZoom,m_config.nBinsr3d,m_config.rMinZoom,m_config.rMaxZoom,m_config.nBinsphi3d,m_config.phiMinZoom,m_config.phiMaxZoom);
400  h3d->SetXTitle(xtitle);
401  h3d->SetYTitle("r [cm]");
402  h3d->SetZTitle("#phi [#circ]");
403  h3d->SetTitle(h3dTitles[hi]);
404  if (hi == 0 && !m_config.materials.empty()) {
405  h_3d_vol = new TH3D("h3d_vol" ,"h3d_vol" ,m_config.nBinsz3d,m_config.zMinZoom,m_config.zMaxZoom,m_config.nBinsr3d,m_config.rMinZoom,m_config.rMaxZoom,m_config.nBinsphi3d,m_config.phiMinZoom,m_config.phiMaxZoom);
406  h_3d_norm = new TH3D("h3d_norm","h3d_norm",m_config.nBinsz3d,m_config.zMinZoom,m_config.zMaxZoom,m_config.nBinsr3d,m_config.rMinZoom,m_config.rMaxZoom,m_config.nBinsphi3d,m_config.phiMinZoom,m_config.phiMaxZoom);
407  h_3d_vol ->SetXTitle(xtitle);
408  h_3d_norm ->SetXTitle(xtitle);
409  h_3d_vol ->SetYTitle("r [cm]");
410  h_3d_norm ->SetYTitle("r [cm]");
411  h_3d_vol ->SetZTitle("#phi [#circ]");
412  h_3d_norm ->SetZTitle("#phi [#circ]");
413  std::string hname("Volume fraction of");
414  char c = ' ';
415  for(const std::string& matName : m_config.materials) {
416  hname += c;
417  hname += matName;
418  c = ',';
419  }
420  h_3d_vol ->SetTitle(hname.data());
421  h_3d_norm ->SetTitle("Volume norm");
422  }
423  // normalize to volume element per bin
424  for(int i=0;i<h3d->GetNbinsX();i++) {
425  for(int j=0;j<h3d->GetNbinsY();j++) {
426  for(int k=0;k<h3d->GetNbinsZ();k++) {
427  int vBin = m_config.nBinsr3d*m_config.nBinsphi3d*i+m_config.nBinsphi3d*j+k;
428  int iBin = h3d->GetBin(i+1,j+1,k+1);
429  double phi0=h3d->GetZaxis()->GetBinLowEdge(k+1);
430  double phi1=h3d->GetZaxis()->GetBinUpEdge(k+1);
431  double r0=h3d->GetYaxis()->GetBinLowEdge(j+1);
432  double r1=h3d->GetYaxis()->GetBinUpEdge(j+1);
433  double z0=h3d->GetXaxis()->GetBinLowEdge(i+1);
434  double z1=h3d->GetXaxis()->GetBinUpEdge(i+1);
435  double vol=(z1-z0)*M_PI*(r1*r1-r0*r0)*(phi1-phi0)/360.;
436  // if |z| instead of z double the volume
437  if ( m_config.zMinFull >= 0 ) vol *= 2;
438  // assume that phi-range corresponds to full 360 degrees in case
439  // lower phi boundary is 0 - i.e. all phi-segments mapped to first
440  if ( m_config.phiMinZoom == 0 ) {
441  vol *= 360./m_config.phiMaxZoom;
442  // if positive y hemisphere is used only -- half the volume
443  if ( m_config.posYOnly )
444  vol *= 0.5;
445  }
446  double val = (*(pVal3d[hi]))[vBin];
447  h3d->SetBinContent(iBin,val/vol);
448  if (hi == 0 && !m_config.materials.empty()) {
449  // VOL
450  val =maps.m_3d_vol[vBin];
451  h_3d_vol->SetBinContent(iBin,val/vol);
452  // NORM
453  val =maps.m_3d_norm[vBin];
454  h_3d_norm->SetBinContent(iBin,val/vol);
455  }
456  }
457  }
458  }
459  h3d->Write();
460  h3d->Delete();
461  if (hi == 0 && !m_config.materials.empty()) {
462  h_3d_vol->Write();
463  h_3d_vol->Delete();
464  h_3d_norm->Write();
465  h_3d_norm->Delete();
466  }
467  }
468 
469  // spectra
470 
471  std::vector<const char *> hSpecNames = {
472  "rz_neut_spec","rz_gamm_spec","rz_elec_spec","rz_muon_spec","rz_pion_spec","rz_prot_spec","rz_rest_spec",
473  "full_rz_neut_spec","full_rz_gamm_spec","full_rz_elec_spec","full_rz_muon_spec","full_rz_pion_spec","full_rz_prot_spec","full_rz_rest_spec"
474  };
475 
476  std::vector<const char *> hSpecTitles = {
477  "FLUX [n(log_{10}(E/MeV))/cm^{2}]","FLUX [#gamma(log_{10}(E/MeV))/cm^{2}]","FLUX [e^{#pm}(log_{10}(E/MeV))/cm^{2}]","FLUX [#mu^{#pm}(log_{10}(E/MeV))/cm^{2}]","FLUX [#pi^{#pm}(log_{10}(E/MeV))/cm^{2}]","FLUX [p(log_{10}(E/MeV))/cm^{2}]","FLUX [rest(log_{10}(E/MeV))/cm^{2}]",
478  "FLUX [n(log_{10}(E/MeV))/cm^{2}]","FLUX [#gamma(log_{10}(E/MeV))/cm^{2}]","FLUX [e^{#pm}(log_{10}(E/MeV))/cm^{2}]","FLUX [#mu^{#pm}(log_{10}(E/MeV))/cm^{2}]","FLUX [#pi^{#pm}(log_{10}(E/MeV))/cm^{2}]","FLUX [p(log_{10}(E/MeV))/cm^{2}]","FLUX [rest(log_{10}(E/MeV))/cm^{2}]"
479  };
480 
481  std::vector<double> zMinSpec = {
482  m_config.zMinZoom,m_config.zMinZoom,m_config.zMinZoom,m_config.zMinZoom,m_config.zMinZoom,m_config.zMinZoom,m_config.zMinZoom,
483  m_config.zMinFull,m_config.zMinFull,m_config.zMinFull,m_config.zMinFull,m_config.zMinFull,m_config.zMinFull,m_config.zMinFull
484  };
485 
486  std::vector<double> zMaxSpec = {
487  m_config.zMaxZoom,m_config.zMaxZoom,m_config.zMaxZoom,m_config.zMaxZoom,m_config.zMaxZoom,m_config.zMaxZoom,m_config.zMaxZoom,
488  m_config.zMaxFull,m_config.zMaxFull,m_config.zMaxFull,m_config.zMaxFull,m_config.zMaxFull,m_config.zMaxFull,m_config.zMaxFull
489  };
490 
491  std::vector<double> rMinSpec = {
492  m_config.rMinZoom,m_config.rMinZoom,m_config.rMinZoom,m_config.rMinZoom,m_config.rMinZoom,m_config.rMinZoom,m_config.rMinZoom,
493  m_config.rMinFull,m_config.rMinFull,m_config.rMinFull,m_config.rMinFull,m_config.rMinFull,m_config.rMinFull,m_config.rMinFull
494  };
495 
496  std::vector<double> rMaxSpec = {
497  m_config.rMaxZoom,m_config.rMaxZoom,m_config.rMaxZoom,m_config.rMaxZoom,m_config.rMaxZoom,m_config.rMaxZoom,m_config.rMaxZoom,
498  m_config.rMaxFull,m_config.rMaxFull,m_config.rMaxFull,m_config.rMaxFull,m_config.rMaxFull,m_config.rMaxFull,m_config.rMaxFull
499  };
500 
501  std::vector<double> logEMin = {
502  m_config.logEMinn,m_config.logEMino,m_config.logEMino,m_config.logEMino,m_config.logEMino,m_config.logEMino,m_config.logEMino,
503  m_config.logEMinn,m_config.logEMino,m_config.logEMino,m_config.logEMino,m_config.logEMino,m_config.logEMino,m_config.logEMino
504  };
505 
506  std::vector<double> logEMax = {
507  m_config.logEMaxn,m_config.logEMaxo,m_config.logEMaxo,m_config.logEMaxo,m_config.logEMaxo,m_config.logEMaxo,m_config.logEMaxo,
508  m_config.logEMaxn,m_config.logEMaxo,m_config.logEMaxo,m_config.logEMaxo,m_config.logEMaxo,m_config.logEMaxo,m_config.logEMaxo
509  };
510 
511  for(unsigned int hi=0;hi<hSpecNames.size();hi++) {
512  TH3D *hSpec = new TH3D(hSpecNames[hi],hSpecNames[hi],m_config.nBinsz,zMinSpec[hi],zMaxSpec[hi],m_config.nBinsr,rMinSpec[hi],rMaxSpec[hi],nBinslogE[hi],logEMin[hi],logEMax[hi]);
513  hSpec->SetXTitle(xtitle);
514  hSpec->SetYTitle("r [cm]");
515  hSpec->SetZTitle("log_{10}(E/MeV)");
516  hSpec->SetTitle(hSpecTitles[hi]);
517  // normalize to volume element per bin
518  for(int i=0;i<hSpec->GetNbinsX();i++) {
519  for(int j=0;j<hSpec->GetNbinsY();j++) {
520  double r0=hSpec->GetYaxis()->GetBinLowEdge(j+1);
521  double r1=hSpec->GetYaxis()->GetBinUpEdge(j+1);
522  double z0=hSpec->GetXaxis()->GetBinLowEdge(i+1);
523  double z1=hSpec->GetXaxis()->GetBinUpEdge(i+1);
524  double vol=(z1-z0)*M_PI*(r1*r1-r0*r0);
525  // if |z| instead of z double the volume
526  if ( m_config.zMinFull >= 0 ) vol *= 2;
527  // if positive y hemisphere is used only -- half the volume
528  if ( m_config.posYOnly ) vol *= 0.5;
529  double val;
530  // Energy Spectra
531  for(int k=0;k<hSpec->GetNbinsZ();k++) {
532  int kBin = hSpec->GetBin(i+1,j+1,k+1);
533  int vBinE = m_config.nBinsr*nBinslogE[hi]*i+j*nBinslogE[hi]+k;
534  val = (*(pValSpec[hi]))[vBinE];
535  hSpec->SetBinContent(kBin,val/vol);
536  }
537  }
538  }
539  hSpec->Write();
540  hSpec->Delete();
541  }
542 
543  std::vector<const char *> hThetaSpecNames = {
544  "theta_dphi_full_rz_neut_spec","theta_dphi_full_rz_gamm_spec","theta_dphi_full_rz_elec_spec","theta_dphi_full_rz_muon_spec","theta_dphi_full_rz_pion_spec","theta_dphi_full_rz_prot_spec","theta_dphi_full_rz_rchgd_spec","theta_dphi_full_rz_rneut_spec"
545  };
546 
547  std::vector<const char *> hThetaSpecTitles = {
548  "FLUX [n(log_{10}(E/MeV))/cm^{2}]","FLUX [#gamma(log_{10}(E/MeV))/cm^{2}]","FLUX [e^{#pm}(log_{10}(E/MeV))/cm^{2}]","FLUX [#mu^{#pm}(log_{10}(E/MeV))/cm^{2}]","FLUX [#pi^{#pm}(log_{10}(E/MeV))/cm^{2}]","FLUX [p(log_{10}(E/MeV))/cm^{2}]","FLUX [rest^{chgd}(log_{10}(E/MeV))/cm^{2}]","FLUX [rest^{neut}(log_{10}(E/MeV))/cm^{2}]"
549  };
550 
551  std::vector<double> thetalogEMin = {
552  m_config.logEMinn,m_config.logEMino,m_config.logEMino,m_config.logEMino,m_config.logEMino,m_config.logEMino,m_config.logEMino,m_config.logEMino
553  };
554 
555  std::vector<double> thetalogEMax = {
556  m_config.logEMaxn,m_config.logEMaxo,m_config.logEMaxo,m_config.logEMaxo,m_config.logEMaxo,m_config.logEMaxo,m_config.logEMaxo,m_config.logEMaxo
557  };
558 
559  for(unsigned int hi=0;hi<hThetaSpecNames.size();hi++) {
560  for(int i=0;i<m_config.nBinstheta;i++) {
561  for(int j=0;j<m_config.nBinsdphi;j++) {
562  TString hname(hThetaSpecNames[hi]);
563  hname += "_";
564  hname += (int)(m_config.thetaMin + i *(m_config.thetaMax-m_config.thetaMin)/m_config.nBinstheta);
565  hname += "_";
566  hname += (int)(m_config.thetaMin + (i+1)*(m_config.thetaMax-m_config.thetaMin)/m_config.nBinstheta);
567  hname += "_";
568  hname += (int)(j*360./m_config.nBinsdphi);
569  hname += "_";
570  hname += (int)((j+1)*360./m_config.nBinsdphi);
571  TH3D * hThetaSpec = new TH3D(hname.Data(),hname.Data(),m_config.nBinsz,m_config.zMinFull,m_config.zMaxFull,m_config.nBinsr,m_config.rMinFull,m_config.rMaxFull,nBinsThetalogE[hi],thetalogEMin[hi],thetalogEMax[hi]);
572 
573  hThetaSpec->SetXTitle(xtitle);
574  hThetaSpec->SetYTitle("r [cm]");
575  hThetaSpec->SetZTitle("log_{10}(E/MeV)");
576  hname = TString(hThetaSpecTitles[hi]);
577  hname += " Theta: ";
578  hname += (int)(m_config.thetaMin + i *(m_config.thetaMax-m_config.thetaMin)/m_config.nBinstheta);
579  hname += " - ";
580  hname += (int)(m_config.thetaMin + (i+1)*(m_config.thetaMax-m_config.thetaMin)/m_config.nBinstheta);
581  hname += " DPhi: ";
582  hname += (int)(j*360./m_config.nBinsdphi);
583  hname += " - ";
584  hname += (int)((j+1)*360./m_config.nBinsdphi);
585  hThetaSpec->SetTitle(hname.Data());
586  // normalize to volume element per bin
587  for(int k=0;k<hThetaSpec->GetNbinsX();k++) {
588  for(int l=0;l<hThetaSpec->GetNbinsY();l++) {
589  double r0=hThetaSpec->GetYaxis()->GetBinLowEdge(l+1);
590  double r1=hThetaSpec->GetYaxis()->GetBinUpEdge(l+1);
591  double z0=hThetaSpec->GetXaxis()->GetBinLowEdge(k+1);
592  double z1=hThetaSpec->GetXaxis()->GetBinUpEdge(k+1);
593  double vol=(z1-z0)*M_PI*(r1*r1-r0*r0);
594  // if |z| instead of z double the volume
595  if ( m_config.zMinFull >= 0 ) vol *= 2;
596  // if positive y hemisphere is used only -- half the volume
597  if ( m_config.posYOnly ) vol *= 0.5;
598  double val;
599  // Energy Spectra
600  for(int m=0;m<hThetaSpec->GetNbinsZ();m++) {
601  int mBin = hThetaSpec->GetBin(k+1,l+1,m+1);
602  int vBinETh = m_config.nBinsr*nBinsThetalogE[hi]*m_config.nBinsdphi*m_config.nBinstheta*k+l*nBinsThetalogE[hi]*m_config.nBinsdphi*m_config.nBinstheta+m*m_config.nBinsdphi*m_config.nBinstheta+i*m_config.nBinsdphi+j;
603  val = (*(pValThetaSpec[hi]))[vBinETh];
604  hThetaSpec->SetBinContent(mBin,val/vol);
605  }
606  }
607  }
608  hThetaSpec->Write();
609  hThetaSpec->Delete();
610  }
611  }
612  }
613 
614  // time dependent TID and H_T maps zoom
615  TH3D * h_rz_tid_time = new TH3D("rz_tid_time" ,"rz_tid_time" ,m_config.nBinsz,m_config.zMinZoom,m_config.zMaxZoom,m_config.nBinsr,m_config.rMinZoom,m_config.rMaxZoom,m_config.nBinslogT,m_config.logTMin,m_config.logTMax);
616  h_rz_tid_time ->SetXTitle(xtitle);
617  h_rz_tid_time ->SetYTitle("r [cm]");
618  h_rz_tid_time ->SetZTitle("log_{10}(t_{cut}/s)");
619 
620  TH3D * h_rz_ht_time = new TH3D("rz_ht_time" ,"rz_ht_time" ,m_config.nBinsz,m_config.zMinZoom,m_config.zMaxZoom,m_config.nBinsr,m_config.rMinZoom,m_config.rMaxZoom,m_config.nBinslogT,m_config.logTMin,m_config.logTMax);
621  h_rz_ht_time ->SetXTitle(xtitle);
622  h_rz_ht_time ->SetYTitle("r [cm]");
623  h_rz_ht_time ->SetZTitle("log_{10}(t_{cut}/s)");
624 
625  // element mass fraction maps zoom
626  TH3D * h_rz_element = new TH3D("rz_element" ,"rz_element" ,m_config.nBinsz,m_config.zMinZoom,m_config.zMaxZoom,m_config.nBinsr,m_config.rMinZoom,m_config.rMaxZoom,m_config.elemZMax-m_config.elemZMin+1,m_config.elemZMin-0.5,m_config.elemZMax+0.5);
627  h_rz_element ->SetXTitle(xtitle);
628  h_rz_element ->SetYTitle("r [cm]");
629  h_rz_element ->SetZTitle("Z");
630 
631  // normalize to volume element per bin
632  for(int i=0;i<h_rz_tid_time->GetNbinsX();i++) {
633  for(int j=0;j<h_rz_tid_time->GetNbinsY();j++) {
634  double r0=h_rz_tid_time->GetYaxis()->GetBinLowEdge(j+1);
635  double r1=h_rz_tid_time->GetYaxis()->GetBinUpEdge(j+1);
636  double z0=h_rz_tid_time->GetXaxis()->GetBinLowEdge(i+1);
637  double z1=h_rz_tid_time->GetXaxis()->GetBinUpEdge(i+1);
638  double vol=(z1-z0)*M_PI*(r1*r1-r0*r0);
639  // if |z| instead of z double the volume
640  if ( m_config.zMinFull >= 0 ) vol *= 2;
641  // if positive y hemisphere is used only -- half the volume
642  if ( m_config.posYOnly ) vol *= 0.5;
643  double val;
644  // Time dependent TID and H_T maps
645  for(int k=0;k<h_rz_tid_time->GetNbinsZ();k++) {
646  int kBin = h_rz_tid_time->GetBin(i+1,j+1,k+1);
647  int vBinT = m_config.nBinsr*m_config.nBinslogT*i+j*m_config.nBinslogT+k;
648  // TID
649  val =maps.m_rz_tid_time[vBinT];
650  h_rz_tid_time->SetBinContent(kBin,val/vol);
651  // H_T
652  val =maps.m_rz_ht_time[vBinT];
653  h_rz_ht_time->SetBinContent(kBin,val/vol);
654  }
655  // Element mass fraction maps
656  for(int k=0;k<h_rz_element->GetNbinsZ();k++) {
657  int kBin = h_rz_element->GetBin(i+1,j+1,k+1);
658  int vBinElem = m_config.nBinsr*(m_config.elemZMax-m_config.elemZMin+1)*i+j*(m_config.elemZMax-m_config.elemZMin+1)+k;
659  val =maps.m_rz_element[vBinElem];
660  h_rz_element->SetBinContent(kBin,val/vol);
661  }
662  }
663  }
664 
665  h_rz_tid_time->Write();
666  h_rz_tid_time->Delete();
667  h_rz_ht_time->Write();
668  h_rz_ht_time->Delete();
669  h_rz_element->Write();
670  h_rz_element->Delete();
671 
672  // time dependent TID and H_T maps full
673  TH3D * h_full_rz_tid_time = new TH3D("full_rz_tid_time" ,"full_rz_tid_time" ,m_config.nBinsz,m_config.zMinFull,m_config.zMaxFull,m_config.nBinsr,m_config.rMinFull,m_config.rMaxFull,m_config.nBinslogT,m_config.logTMin,m_config.logTMax);
674  h_full_rz_tid_time->SetXTitle(xtitle);
675  h_full_rz_tid_time->SetYTitle("r [cm]");
676  h_full_rz_tid_time->SetZTitle("log_{10}(t_{cut}/s)");
677 
678  TH3D * h_full_rz_ht_time = new TH3D("full_rz_ht_time" ,"full_rz_ht_time" ,m_config.nBinsz,m_config.zMinFull,m_config.zMaxFull,m_config.nBinsr,m_config.rMinFull,m_config.rMaxFull,m_config.nBinslogT,m_config.logTMin,m_config.logTMax);
679  h_full_rz_ht_time->SetXTitle(xtitle);
680  h_full_rz_ht_time->SetYTitle("r [cm]");
681  h_full_rz_ht_time->SetZTitle("log_{10}(t_{cut}/s)");
682 
683  // element mass fraction maps full
684  TH3D * h_full_rz_element = new TH3D("full_rz_element" ,"full_rz_element" ,m_config.nBinsz,m_config.zMinFull,m_config.zMaxFull,m_config.nBinsr,m_config.rMinFull,m_config.rMaxFull,m_config.elemZMax-m_config.elemZMin+1,m_config.elemZMin-0.5,m_config.elemZMax+0.5);
685  h_full_rz_element->SetXTitle(xtitle);
686  h_full_rz_element->SetYTitle("r [cm]");
687  h_full_rz_element->SetZTitle("Z");
688 
689  // normalize to volume element per bin
690  for(int i=0;i<h_full_rz_tid_time->GetNbinsX();i++) {
691  for(int j=0;j<h_full_rz_tid_time->GetNbinsY();j++) {
692  double r0=h_full_rz_tid_time->GetYaxis()->GetBinLowEdge(j+1);
693  double r1=h_full_rz_tid_time->GetYaxis()->GetBinUpEdge(j+1);
694  double z0=h_full_rz_tid_time->GetXaxis()->GetBinLowEdge(i+1);
695  double z1=h_full_rz_tid_time->GetXaxis()->GetBinUpEdge(i+1);
696  double vol=(z1-z0)*M_PI*(r1*r1-r0*r0);
697  // if |z| instead of z double the volume
698  if ( m_config.zMinFull >= 0 ) vol *= 2;
699  // if positive y hemisphere is used only -- half the volume
700  if ( m_config.posYOnly ) vol *= 0.5;
701  double val;
702  // Time dependent TID and H_T maps
703  for(int k=0;k<h_full_rz_tid_time->GetNbinsZ();k++) {
704  int kBin = h_full_rz_tid_time->GetBin(i+1,j+1,k+1);
705  int vBinT = m_config.nBinsr*m_config.nBinslogT*i+j*m_config.nBinslogT+k;
706  // TID
707  val =maps.m_full_rz_tid_time[vBinT];
708  h_full_rz_tid_time->SetBinContent(kBin,val/vol);
709  // H_T
710  val =maps.m_full_rz_ht_time[vBinT];
711  h_full_rz_ht_time->SetBinContent(kBin,val/vol);
712  }
713  // Element mass fraction maps
714  for(int k=0;k<h_full_rz_element->GetNbinsZ();k++) {
715  int kBin = h_full_rz_element->GetBin(i+1,j+1,k+1);
716  int vBinElem = m_config.nBinsr*(m_config.elemZMax-m_config.elemZMin+1)*i+j*(m_config.elemZMax-m_config.elemZMin+1)+k;
717  val =maps.m_full_rz_element[vBinElem];
718  h_full_rz_element->SetBinContent(kBin,val/vol);
719  }
720  }
721  }
722  h_full_rz_tid_time->Write();
723  h_full_rz_tid_time->Delete();
724  h_full_rz_ht_time->Write();
725  h_full_rz_ht_time->Delete();
726  h_full_rz_element->Write();
727  h_full_rz_element->Delete();
728 
729  f->Close();
730 
731  return StatusCode::SUCCESS;
732  }
733 
734  std::unique_ptr<RadiationMapsMaker> RadiationMapsMakerTool::makeAndFillAction(G4AtlasUserActions& actionList){
735  ATH_MSG_INFO("Making a RadiationMapsMaker action");
736  auto action = std::make_unique<RadiationMapsMaker>(m_config);
737  actionList.runActions.push_back( action.get() );
738  actionList.steppingActions.push_back( action.get() );
739  return action;
740  }
741 
742 } // namespace G4UA
G4UA::RadiationMapsMaker::Report::m_full_rz_vol
std::vector< double > m_full_rz_vol
next two vectors are used only in case maps are needed for particular materials instead of all
Definition: RadiationMapsMaker.h:128
G4UA::RadiationMapsMaker::Report::m_3d_h20
std::vector< double > m_3d_h20
vector of >20 MeV hadron flux seen by thread in 3d
Definition: RadiationMapsMaker.h:139
G4UA::RadiationMapsMaker::Report::m_theta_full_rz_rneut_spec
std::vector< double > m_theta_full_rz_rneut_spec
vector of rest neutral spectra in log10(E/MeV) bins and the full 2d grid x theta bins
Definition: RadiationMapsMaker.h:217
G4UA::RadiationMapsMaker::Config::nBinslogT
int nBinslogT
Definition: RadiationMapsMaker.h:79
G4UA::RadiationMapsMaker::Report::m_3d_tid
std::vector< double > m_3d_tid
vector of tid seen by thread in 3d
Definition: RadiationMapsMaker.h:133
G4UA::RadiationMapsMakerTool::initialize
virtual StatusCode initialize() override final
Initialize configurable properties.
Definition: RadiationMapsMakerTool.cxx:77
G4UA::RadiationMapsMaker::Report::m_rz_element
std::vector< double > m_rz_element
vector of element fractions in zoom 2d grid
Definition: RadiationMapsMaker.h:234
G4UA::RadiationMapsMaker::Report::m_full_rz_neut
std::vector< double > m_full_rz_neut
vector of >100 keV hadron flux seen by thread in full area
Definition: RadiationMapsMaker.h:121
G4UA::G4AtlasUserActions
Struct for passing around user actions.
Definition: IUserActionTool.h:32
G4UA::RadiationMapsMaker::Report::m_full_rz_chad
std::vector< double > m_full_rz_chad
vector of charged hadron flux seen by thread in full area
Definition: RadiationMapsMaker.h:123
python.CaloRecoConfig.f
f
Definition: CaloRecoConfig.py:127
G4UA::RadiationMapsMaker::Report::m_full_rz_h20
std::vector< double > m_full_rz_h20
vector of >20 MeV hadron flux seen by thread in full area
Definition: RadiationMapsMaker.h:119
G4UA::RadiationMapsMaker
Definition: RadiationMapsMaker.h:22
G4UA::RadiationMapsMaker::Report::m_theta_full_rz_elec_spec
std::vector< double > m_theta_full_rz_elec_spec
vector of e^+/- spectra in log10(E/MeV) bins and the full 2d grid x theta bins
Definition: RadiationMapsMaker.h:179
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
G4UA::RadiationMapsMaker::Config::logEMino
double logEMino
Definition: RadiationMapsMaker.h:75
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TH3D
Definition: rootspy.cxx:505
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
G4UA::RadiationMapsMaker::Config::nBinslogEn
int nBinslogEn
Definition: RadiationMapsMaker.h:69
G4UA
for nSW
Definition: CalibrationDefaultProcessing.h:19
G4UA::RadiationMapsMaker::Report::m_rz_neut_spec
std::vector< double > m_rz_neut_spec
vector of neutron spectra in log10(E/MeV) bins and the zoom 2d grid
Definition: RadiationMapsMaker.h:157
dqt_zlumi_pandas.hname
string hname
Definition: dqt_zlumi_pandas.py:272
G4UA::RadiationMapsMaker::Report::m_theta_full_rz_gamm_spec
std::vector< double > m_theta_full_rz_gamm_spec
vector of gamma spectra in log10(E/MeV) bins and the full 2d grid x theta bins
Definition: RadiationMapsMaker.h:170
G4UA::RadiationMapsMaker::Config::logEMinn
double logEMinn
Definition: RadiationMapsMaker.h:70
G4UA::RadiationMapsMaker::Report::m_rz_elec_spec
std::vector< double > m_rz_elec_spec
vector of e^+/- spectra in log10(E/MeV) bins and the zoom 2d grid
Definition: RadiationMapsMaker.h:175
G4UA::RadiationMapsMaker::Config::activationFileName
std::string activationFileName
Definition: RadiationMapsMaker.h:34
InDetAccessor::phi0
@ phi0
Definition: InDetAccessor.h:33
G4UA::RadiationMapsMaker::Config::rMinZoom
double rMinZoom
Definition: RadiationMapsMaker.h:41
TH2D::SetBinContent
void SetBinContent(int, double)
Definition: rootspy.cxx:436
G4UA::RadiationMapsMaker::Report::m_3d_eion
std::vector< double > m_3d_eion
vector of ionizing energy density seen by thread in 3d
Definition: RadiationMapsMaker.h:135
TH3D::SetBinContent
void SetBinContent(int, double)
Definition: rootspy.cxx:511
G4UA::RadiationMapsMaker::Config::logTMax
double logTMax
Definition: RadiationMapsMaker.h:81
G4UA::RadiationMapsMaker::Report::m_full_rz_gamm_spec
std::vector< double > m_full_rz_gamm_spec
vector of gamma spectra in log10(E/MeV) bins and the full 2d grid
Definition: RadiationMapsMaker.h:168
M_PI
#define M_PI
Definition: ActiveFraction.h:11
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
G4UA::ThreadSpecificUserAction::accumulate
void accumulate(ResultType &result, Mapper mapOp, Reducer reduceOp)
Accumulate results across user actions with specified operations.
Definition: ThreadSpecificUserAction.h:88
G4UA::RadiationMapsMaker::Report::m_rz_ht_time
std::vector< double > m_rz_ht_time
vector of time dependent H_T in zoom 2d grid
Definition: RadiationMapsMaker.h:227
G4UA::RadiationMapsMaker::Report::m_3d_chad
std::vector< double > m_3d_chad
vector of charged hadron flux seen by thread in 3d
Definition: RadiationMapsMaker.h:143
G4UA::RadiationMapsMaker::Report::m_3d_niel
std::vector< double > m_3d_niel
vector of 1 MeV neutron equivalent flux seen by thread in 3d
Definition: RadiationMapsMaker.h:137
G4UA::RadiationMapsMaker::Config::nBinstheta
int nBinstheta
Definition: RadiationMapsMaker.h:63
G4UA::RadiationMapsMaker::Report::m_rz_norm
std::vector< double > m_rz_norm
vector to normalize the volume fraction in zoomed area
Definition: RadiationMapsMaker.h:110
G4UA::RadiationMapsMaker::Report::m_rz_eion
std::vector< double > m_rz_eion
vector of ionizing energy density seen by thread in zoomed area
Definition: RadiationMapsMaker.h:95
G4UA::RadiationMapsMaker::Config::nBinsz3d
int nBinsz3d
Definition: RadiationMapsMaker.h:54
G4UA::RadiationMapsMaker::Config::zMinZoom
double zMinZoom
Definition: RadiationMapsMaker.h:47
G4UA::RadiationMapsMaker::Report::m_3d_norm
std::vector< double > m_3d_norm
vector to normalize the volume fraction in 3d
Definition: RadiationMapsMaker.h:150
G4UA::RadiationMapsMakerTool::RadiationMapsMakerTool
RadiationMapsMakerTool(const std::string &type, const std::string &name, const IInterface *parent)
standard tool ctor
Definition: RadiationMapsMakerTool.cxx:11
G4UA::RadiationMapsMaker::Report::m_full_rz_element
std::vector< double > m_full_rz_element
vector of element fractions in full 2d grid
Definition: RadiationMapsMaker.h:236
G4UA::RadiationMapsMaker::Config::materials
std::vector< std::string > materials
bin sizes and ranges match the requirements for the Radiation Estimate Web tool for the default value...
Definition: RadiationMapsMaker.h:32
G4UA::RadiationMapsMaker::Config::thetaMin
double thetaMin
Definition: RadiationMapsMaker.h:65
G4UA::RadiationMapsMaker::Config::rMaxFull
double rMaxFull
Definition: RadiationMapsMaker.h:45
G4UA::RadiationMapsMaker::Report::m_rz_tid_time
std::vector< double > m_rz_tid_time
vector of time dependent TID in zoom 2d grid
Definition: RadiationMapsMaker.h:222
G4UA::RadiationMapsMaker::Report::m_rz_h20
std::vector< double > m_rz_h20
vector of >20 MeV hadron flux seen by thread in zoomed area
Definition: RadiationMapsMaker.h:99
G4UA::RadiationMapsMaker::Config::zMaxFull
double zMaxFull
Definition: RadiationMapsMaker.h:51
lumiFormat.i
int i
Definition: lumiFormat.py:92
G4UA::RadiationMapsMakerTool::m_config
RadiationMapsMaker::Config m_config
Radiation Map ranges and granularities.
Definition: RadiationMapsMakerTool.h:51
G4UA::RadiationMapsMaker::Report::m_full_rz_niel
std::vector< double > m_full_rz_niel
vector of 1 MeV neutron equivalent flux seen by thread in full area
Definition: RadiationMapsMaker.h:117
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
G4UA::UserActionToolBase< RadiationMapsMaker >::m_actions
ThreadSpecificUserAction< RadiationMapsMaker > m_actions
Thread-specific storage of the user action.
Definition: UserActionToolBase.h:63
G4UA::RadiationMapsMaker::Config::nBinsz
int nBinsz
Definition: RadiationMapsMaker.h:39
G4UA::RadiationMapsMaker::Config::zMinFull
double zMinFull
Definition: RadiationMapsMaker.h:48
G4UA::RadiationMapsMaker::Config::phiMaxZoom
double phiMaxZoom
Definition: RadiationMapsMaker.h:58
G4UA::RadiationMapsMaker::Report::m_full_rz_ht_time
std::vector< double > m_full_rz_ht_time
vector of time dependent H_T in full 2d grid
Definition: RadiationMapsMaker.h:229
G4UA::RadiationMapsMaker::Config::nBinsr
int nBinsr
Definition: RadiationMapsMaker.h:38
test_pyathena.parent
parent
Definition: test_pyathena.py:15
G4UA::RadiationMapsMaker::Report::m_rz_prot_spec
std::vector< double > m_rz_prot_spec
vector of proton spectra in log10(E/MeV) bins and the zoom 2d grid
Definition: RadiationMapsMaker.h:202
G4UA::RadiationMapsMakerTool::makeAndFillAction
virtual std::unique_ptr< RadiationMapsMaker > makeAndFillAction(G4AtlasUserActions &) override final
create action for this thread
Definition: RadiationMapsMakerTool.cxx:734
G4UA::RadiationMapsMaker::Report::merge
void merge(const Report &maps)
Definition: RadiationMapsMaker.cxx:155
G4UA::RadiationMapsMaker::Report::m_rz_niel
std::vector< double > m_rz_niel
vector of 1 MeV neutron equivalent flux seen by thread in zoomed area
Definition: RadiationMapsMaker.h:97
TH2D
Definition: rootspy.cxx:430
TRT::Track::z0
@ z0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:63
G4UA::RadiationMapsMaker::Report::m_theta_full_rz_neut_spec
std::vector< double > m_theta_full_rz_neut_spec
vector of neutron spectra in log10(E/MeV) bins and the full 2d grid x theta bins
Definition: RadiationMapsMaker.h:161
G4UA::RadiationMapsMaker::Config::elemZMax
int elemZMax
Definition: RadiationMapsMaker.h:85
G4UA::RadiationMapsMaker::Report
Simple struct for holding the radiation maps.
Definition: RadiationMapsMaker.h:91
G4UA::RadiationMapsMaker::Report::m_3d_vol
std::vector< double > m_3d_vol
next two vectors are used only in case maps are needed for particular materials instead of all
Definition: RadiationMapsMaker.h:148
G4UA::RadiationMapsMaker::Report::m_full_rz_eion
std::vector< double > m_full_rz_eion
vector of ionizing energy density seen by thread in full area
Definition: RadiationMapsMaker.h:115
G4UA::RadiationMapsMaker::Report::m_full_rz_pion_spec
std::vector< double > m_full_rz_pion_spec
vector of pi^+/- spectra in log10(E/MeV) bins and the full 2d grid
Definition: RadiationMapsMaker.h:195
G4UA::RadiationMapsMaker::Report::m_rz_vol
std::vector< double > m_rz_vol
next two vectors are used only in case maps are needed for particular materials instead of all
Definition: RadiationMapsMaker.h:108
G4UA::RadiationMapsMakerTool::m_radMapsFileName
std::string m_radMapsFileName
Output Filename for the Radiation Maps.
Definition: RadiationMapsMakerTool.h:49
G4UA::RadiationMapsMaker::Report::m_full_rz_prot_spec
std::vector< double > m_full_rz_prot_spec
vector of proton spectra in log10(E/MeV) bins and the full 2d grid
Definition: RadiationMapsMaker.h:204
G4UA::RadiationMapsMaker::Config::rMinFull
double rMinFull
Definition: RadiationMapsMaker.h:42
G4UA::RadiationMapsMaker::Config::logEMaxo
double logEMaxo
Definition: RadiationMapsMaker.h:76
G4UA::RadiationMapsMaker::Config::rMaxZoom
double rMaxZoom
Definition: RadiationMapsMaker.h:44
G4UA::RadiationMapsMaker::Config::logEMaxn
double logEMaxn
Definition: RadiationMapsMaker.h:71
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
G4UA::RadiationMapsMaker::Config::thetaMax
double thetaMax
Definition: RadiationMapsMaker.h:66
G4UA::RadiationMapsMaker::Report::m_rz_gamm_spec
std::vector< double > m_rz_gamm_spec
vector of gamma spectra in log10(E/MeV) bins and the zoom 2d grid
Definition: RadiationMapsMaker.h:166
G4UA::RadiationMapsMaker::Report::m_theta_full_rz_prot_spec
std::vector< double > m_theta_full_rz_prot_spec
vector of proton spectra in log10(E/MeV) bins and the full 2d grid x theta bins
Definition: RadiationMapsMaker.h:206
G4UA::G4AtlasUserActions::runActions
std::vector< G4UserRunAction * > runActions
Definition: IUserActionTool.h:33
G4UA::UserActionToolBase
abstract template utility base-class for G4 user-action tools.
Definition: UserActionToolBase.h:33
G4UA::RadiationMapsMaker::Report::m_full_rz_neut_spec
std::vector< double > m_full_rz_neut_spec
vector of neutron spectra in log10(E/MeV) bins and the full 2d grid
Definition: RadiationMapsMaker.h:159
G4UA::RadiationMapsMaker::Report::m_3d_neut
std::vector< double > m_3d_neut
vector of >100 keV hadron flux seen by thread in 3d
Definition: RadiationMapsMaker.h:141
RadiationMapsMakerTool.h
G4UA::RadiationMapsMakerTool::finalize
virtual StatusCode finalize() override final
Finalize and merge results from all threads.
Definition: RadiationMapsMakerTool.cxx:134
G4UA::RadiationMapsMaker::Config::logTMin
double logTMin
Definition: RadiationMapsMaker.h:80
G4UA::RadiationMapsMaker::Config::nBinslogEo
int nBinslogEo
Definition: RadiationMapsMaker.h:74
G4UA::RadiationMapsMaker::getReport
const Report & getReport() const
Retrieve my maps.
Definition: RadiationMapsMaker.h:252
G4UA::RadiationMapsMaker::Report::m_theta_full_rz_rchgd_spec
std::vector< double > m_theta_full_rz_rchgd_spec
vector of rest charged spectra in log10(E/MeV) bins and the full 2d grid x theta bins
Definition: RadiationMapsMaker.h:215
G4UA::RadiationMapsMaker::Report::m_rz_pion_spec
std::vector< double > m_rz_pion_spec
vector of pi^+/- spectra in log10(E/MeV) bins and the zoom 2d grid
Definition: RadiationMapsMaker.h:193
G4UA::RadiationMapsMaker::Report::m_full_rz_tid
std::vector< double > m_full_rz_tid
vector of tid seen by thread in full area
Definition: RadiationMapsMaker.h:113
G4UA::RadiationMapsMaker::Report::m_full_rz_rest_spec
std::vector< double > m_full_rz_rest_spec
vector of e^+/- spectra in log10(E/MeV) bins and the full 2d grid
Definition: RadiationMapsMaker.h:213
python.CaloScaleNoiseConfig.action
action
Definition: CaloScaleNoiseConfig.py:77
G4UA::RadiationMapsMaker::Report::m_theta_full_rz_pion_spec
std::vector< double > m_theta_full_rz_pion_spec
vector of pi^+/- spectra in log10(E/MeV) bins and the full 2d grid x theta bins
Definition: RadiationMapsMaker.h:197
G4UA::RadiationMapsMaker::Report::m_rz_neut
std::vector< double > m_rz_neut
vector of >100 keV hadron flux seen by thread in zoomed area
Definition: RadiationMapsMaker.h:101
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
plotting.yearwise_efficiency.xtitle
string xtitle
Definition: yearwise_efficiency.py:38
G4UA::RadiationMapsMaker::Config::posYOnly
bool posYOnly
Definition: RadiationMapsMaker.h:36
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:569
G4UA::RadiationMapsMaker::Report::m_full_rz_muon_spec
std::vector< double > m_full_rz_muon_spec
vector of mu^+/- spectra in log10(E/MeV) bins and the full 2d grid
Definition: RadiationMapsMaker.h:186
G4UA::RadiationMapsMaker::Config::nBinsr3d
int nBinsr3d
Definition: RadiationMapsMaker.h:53
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
G4UA::RadiationMapsMaker::Config::phiMinZoom
double phiMinZoom
Definition: RadiationMapsMaker.h:57
G4UA::RadiationMapsMaker::Report::m_theta_full_rz_muon_spec
std::vector< double > m_theta_full_rz_muon_spec
vector of mu^+/- spectra in log10(E/MeV) bins and the full 2d grid x theta bins
Definition: RadiationMapsMaker.h:188
G4UA::RadiationMapsMaker::Config::nBinsphi3d
int nBinsphi3d
Definition: RadiationMapsMaker.h:55
G4UA::G4AtlasUserActions::steppingActions
std::vector< G4UserSteppingAction * > steppingActions
Definition: IUserActionTool.h:36
G4UA::RadiationMapsMaker::Config::zMaxZoom
double zMaxZoom
Definition: RadiationMapsMaker.h:50
G4UA::RadiationMapsMaker::Report::m_rz_rest_spec
std::vector< double > m_rz_rest_spec
vector of other particle spectra in log10(E/MeV) bins and the zoom 2d grid
Definition: RadiationMapsMaker.h:211
python.compressB64.c
def c
Definition: compressB64.py:93
G4UA::RadiationMapsMaker::Config::nBinsdphi
int nBinsdphi
Definition: RadiationMapsMaker.h:62
G4UA::RadiationMapsMaker::Config::elemZMin
int elemZMin
Definition: RadiationMapsMaker.h:84
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
G4UA::RadiationMapsMaker::Report::m_full_rz_elec_spec
std::vector< double > m_full_rz_elec_spec
vector of e^+/- spectra in log10(E/MeV) bins and the full 2d grid
Definition: RadiationMapsMaker.h:177
G4UA::RadiationMapsMaker::Report::m_rz_chad
std::vector< double > m_rz_chad
vector of charged hadron flux seen by thread in zoomed area
Definition: RadiationMapsMaker.h:103
G4UA::RadiationMapsMaker::Report::m_rz_muon_spec
std::vector< double > m_rz_muon_spec
vector of mu^+/- spectra in log10(E/MeV) bins and the zoom 2d grid
Definition: RadiationMapsMaker.h:184
G4UA::RadiationMapsMaker::Report::m_full_rz_norm
std::vector< double > m_full_rz_norm
vector to normalize the volume fraction in full area
Definition: RadiationMapsMaker.h:130
G4UA::RadiationMapsMaker::Report::m_full_rz_tid_time
std::vector< double > m_full_rz_tid_time
vector of time dependent TID in full 2d grid
Definition: RadiationMapsMaker.h:224
fitman.k
k
Definition: fitman.py:528
G4UA::RadiationMapsMaker::Report::m_rz_tid
std::vector< double > m_rz_tid
vector of tid seen by thread in zoomed area
Definition: RadiationMapsMaker.h:93
Generated on Thu Jul 4 2024 21:25:08 for ATLAS Offline Software by   doxygen 1.8.18