ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | Protected Attributes | Private Attributes | List of all members
G4UA::RadiationMapsMakerTool Class Reference

Tool which manages the RadiationMapsMaker action. More...

#include <RadiationMapsMakerTool.h>

Inheritance diagram for G4UA::RadiationMapsMakerTool:
Collaboration diagram for G4UA::RadiationMapsMakerTool:

Public Member Functions

 RadiationMapsMakerTool (const std::string &type, const std::string &name, const IInterface *parent)
 standard tool ctor
virtual StatusCode initialize () override final
 Initialize configurable properties.
virtual StatusCode finalize () override final
 Finalize and merge results from all threads.
virtual StatusCode fillUserAction (G4AtlasUserActions &actionLists) override final
 Fill the user action lists.
StatusCode BeginOfAthenaEvent (HitCollectionMap &) override
 Calls BeginOfAthenaEvent.
StatusCode EndOfAthenaEvent (HitCollectionMap &) override
 Calls EndOfAthenaEvent.

Protected Member Functions

virtual std::unique_ptr< RadiationMapsMaker > makeAndFillAction (G4AtlasUserActions &) override final
 create action for this thread

Protected Attributes

ThreadSpecificUserAction< RadiationMapsMaker > m_actions
 Thread-specific storage of the user action.

Private Attributes

std::string m_radMapsFileName
 Output Filename for the Radiation Maps.
RadiationMapsMaker::Config m_config
 Radiation Map ranges and granularities.

Detailed Description

Tool which manages the RadiationMapsMaker action.

Create the RadiationMapsMaker for each worker thread

Author
Sven Menke (based on Andrea Di Simone's FluxRecorderTool)

Definition at line 26 of file RadiationMapsMakerTool.h.

Constructor & Destructor Documentation

◆ RadiationMapsMakerTool()

G4UA::RadiationMapsMakerTool::RadiationMapsMakerTool ( const std::string & type,
const std::string & name,
const IInterface * parent )

standard tool ctor

Output Filename for the Radiation Maps

Name of the materials to make radiation maps for (take all if empty)

Name of the file to store activated unstable isotopes (don't save if empty)

If true consider hits with y>0 only – useful for shafts

map granularities number of bins in r and z for all 2D maps

number of bins in logE for energy spectra of neutrons in 2D grids

number of bins in logE for energy spectra of other particles in 2D grids

number of bins in dphi for dphi x theta dependent energy spectra

number of bins in theta for dphi x theta dependent energy spectra

number of bins in r, z and phi for all 3D maps

number of bins in logTimeCut for time dependent TID and H_T 2D maps

map ranges for Zoomed area in 2D and 3D

for Full detector in 2D

for Zoomed area in 3D

for logE of neutrons in 2D spectra

for logE of other particles in 2D spectra

for Theta in 2D spectra

for logT in time-dependent TID and H_T 2D maps

for elements mass fracion 2D maps

Definition at line 11 of file RadiationMapsMakerTool.cxx.

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 }
G4UA::RadiationMapsMakerTool::m_config
RadiationMapsMaker::Config m_config
Radiation Map ranges and granularities.
Definition RadiationMapsMakerTool.h:51
G4UA::RadiationMapsMakerTool::m_radMapsFileName
std::string m_radMapsFileName
Output Filename for the Radiation Maps.
Definition RadiationMapsMakerTool.h:49
G4UA::UserActionToolBase< RadiationMapsMaker >::UserActionToolBase
UserActionToolBase(const std::string &type, const std::string &name, const IInterface *parent)
Definition UserActionToolBase.h:40

Member Function Documentation

◆ BeginOfAthenaEvent()

StatusCode G4UA::UserActionToolBase< RadiationMapsMaker >::BeginOfAthenaEvent ( HitCollectionMap & )
inlineoverrideinherited

Calls BeginOfAthenaEvent.

Definition at line 59 of file UserActionToolBase.h.

59{return StatusCode::SUCCESS;};
G4UA::UserActionToolBase
abstract template utility base-class for G4 user-action tools.
Definition UserActionToolBase.h:35

◆ EndOfAthenaEvent()

StatusCode G4UA::UserActionToolBase< RadiationMapsMaker >::EndOfAthenaEvent ( HitCollectionMap & )
inlineoverrideinherited

Calls EndOfAthenaEvent.

Definition at line 61 of file UserActionToolBase.h.

61{return StatusCode::SUCCESS;};

◆ fillUserAction()

virtual StatusCode G4UA::UserActionToolBase< RadiationMapsMaker >::fillUserAction ( G4AtlasUserActions & actionLists)
inlinefinaloverridevirtualinherited

Fill the user action lists.

Definition at line 47 of file UserActionToolBase.h.

48 {
49 auto myAction = makeAndFillAction(actionLists);
50 if(myAction == nullptr) {
51 ATH_MSG_ERROR( "Failed to construct user action in " << name() );
52 return StatusCode::FAILURE;
53 }
54 m_actions.set( std::move(myAction) );
55 return StatusCode::SUCCESS;
56 }
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
G4UA::UserActionToolBase< RadiationMapsMaker >::makeAndFillAction
virtual std::unique_ptr< RadiationMapsMaker > makeAndFillAction(G4AtlasUserActions &actionLists)=0

◆ finalize()

StatusCode G4UA::RadiationMapsMakerTool::finalize ( )
finaloverridevirtual

Finalize and merge results from all threads.

Definition at line 134 of file RadiationMapsMakerTool.cxx.

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 }
M_PI
#define M_PI
Definition ActiveFraction.h:11
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
G4UA::RadiationMapsMaker::getReport
const Report & getReport() const
Retrieve my maps.
Definition RadiationMapsMaker.h:252
G4UA::UserActionToolBase< RadiationMapsMaker >::m_actions
ThreadSpecificUserAction< RadiationMapsMaker > m_actions
Definition UserActionToolBase.h:70
PrintTrkAnaSummary.l
l
Printing final latex table to .tex output file.
Definition PrintTrkAnaSummary.py:370
Pythia8_RapidityOrderMPI.val
val
Definition Pythia8_RapidityOrderMPI.py:14
TRT_PAI_physicsConstants::r0
const double r0
electron radius{cm}
Definition TRT_PAI_physicsConstants.h:22
dqt_zlumi_pandas.hname
str hname
Definition dqt_zlumi_pandas.py:280
hist_file_dump.f
f
Definition hist_file_dump.py:140
plotting.yearwise_efficiency.xtitle
str xtitle
Definition yearwise_efficiency.py:32

◆ initialize()

StatusCode G4UA::RadiationMapsMakerTool::initialize ( )
finaloverridevirtual

Initialize configurable properties.

Definition at line 77 of file RadiationMapsMakerTool.cxx.

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 }
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
msg
MsgStream & msg
Definition testRead.cxx:32

◆ makeAndFillAction()

std::unique_ptr< RadiationMapsMaker > G4UA::RadiationMapsMakerTool::makeAndFillAction ( G4AtlasUserActions & actionList)
finaloverrideprotectedvirtual

create action for this thread

Implements G4UA::UserActionToolBase< RadiationMapsMaker >.

Definition at line 734 of file RadiationMapsMakerTool.cxx.

734 {
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 }
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31

Member Data Documentation

◆ m_actions

ThreadSpecificUserAction<RadiationMapsMaker> G4UA::UserActionToolBase< RadiationMapsMaker >::m_actions
protectedinherited

Thread-specific storage of the user action.

Definition at line 70 of file UserActionToolBase.h.

◆ m_config

RadiationMapsMaker::Config G4UA::RadiationMapsMakerTool::m_config
private

Radiation Map ranges and granularities.

Definition at line 51 of file RadiationMapsMakerTool.h.

◆ m_radMapsFileName

std::string G4UA::RadiationMapsMakerTool::m_radMapsFileName
private

Output Filename for the Radiation Maps.

Definition at line 49 of file RadiationMapsMakerTool.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0