ATLAS Offline Software
Classes | Public Types | Public Member Functions | Private Member Functions | Private Attributes | List of all members
G4UA::StepHistogram Class Reference

#include <StepHistogram.h>

Inheritance diagram for G4UA::StepHistogram:
Collaboration diagram for G4UA::StepHistogram:

Classes

struct  Config
 
struct  Report
 this holds all the data from individual threads that needs to be merged at EoR More...
 

Public Types

typedef std::map< G4String, TH1 * > HistoMap_t
 
typedef std::map< G4String, HistoMap_t > HistoMapMap_t
 

Public Member Functions

virtual void UserSteppingAction (const G4Step *) override
 the hooks for G4 UA handling More...
 
 StepHistogram (const Config &)
 ctor More...
 
const Report & getReport () const
 
bool msgLvl (const MSG::Level lvl) const
 Test the output level. More...
 
MsgStream & msg () const
 The standard message stream. More...
 
MsgStream & msg (const MSG::Level lvl) const
 The standard message stream. More...
 
void setLevel (MSG::Level lvl)
 Change the current logging level. More...
 

Private Member Functions

void InitializeFillHistogram2D (HistoMapMap_t &hMapMap, const char *suffix, const G4String &pdgId, const G4String &vol, int nbinsx, double xmin, double xmax, int nbinsy, double ymin, double ymax, double valuex, double valuey, double weight)
 
void InitializeFillHistogram (HistoMapMap_t &hMapMap, const char *suffix, const G4String &pdgId, const G4String &vol, int nbins, double xmin, double xmax, double value, double weight)
 
void InitializeFillHistogram (HistoMapMap_t &hMapMap, const char *suffix, const G4String &pdgId, const G4String &vol, int nbins, double *edges, double value, double weight)
 
void initMessaging () const
 Initialize our message level and MessageSvc. More...
 

Private Attributes

Report m_report
 
Config m_config
 configuration data More...
 
float m_initialKineticEnergyOfStep
 
G4String m_initialVolume
 
G4String m_initialMaterial
 
G4String m_initialProcess
 
int m_trackID = 0
 
std::string m_nm
 Message source name. More...
 
boost::thread_specific_ptr< MsgStream > m_msg_tls
 MsgStream instance (a std::cout like with print-out levels) More...
 
std::atomic< IMessageSvc * > m_imsg { nullptr }
 MessageSvc pointer. More...
 
std::atomic< MSG::Level > m_lvl { MSG::NIL }
 Current logging level. More...
 
std::atomic_flag m_initialized ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
 Messaging initialized (initMessaging) More...
 

Detailed Description

Definition at line 28 of file StepHistogram.h.

Member Typedef Documentation

◆ HistoMap_t

typedef std::map<G4String, TH1*> G4UA::StepHistogram::HistoMap_t

Definition at line 38 of file StepHistogram.h.

◆ HistoMapMap_t

typedef std::map<G4String, HistoMap_t> G4UA::StepHistogram::HistoMapMap_t

Definition at line 39 of file StepHistogram.h.

Constructor & Destructor Documentation

◆ StepHistogram()

G4UA::StepHistogram::StepHistogram ( const Config &  config)

ctor

Definition at line 26 of file StepHistogram.cxx.

26  :
27  AthMessaging(Gaudi::svcLocator()->service<IMessageSvc>("MessageSvc"),"StepHistogram"),
28  m_config(config),
29  m_initialKineticEnergyOfStep(),
30  m_initialVolume(),
31  m_initialMaterial(),
32  m_initialProcess()
33  {}

Member Function Documentation

◆ getReport()

const Report& G4UA::StepHistogram::getReport ( ) const
inline

Definition at line 115 of file StepHistogram.h.

115 { return m_report; }

◆ InitializeFillHistogram() [1/2]

void G4UA::StepHistogram::InitializeFillHistogram ( HistoMapMap_t &  hMapMap,
const char *  suffix,
const G4String &  pdgId,
const G4String &  vol,
int  nbins,
double *  edges,
double  value,
double  weight 
)
private

Definition at line 252 of file StepHistogram.cxx.

255  {
256  const auto& [pStringMapPair, inserted] = hMapMap.try_emplace(vol,HistoMap_t());
257  HistoMap_t &hMap = pStringMapPair->second;
258  if ( hMap.find(particleName) == hMap.end() ) {
259  // initialize histogram if not yet exist
260  std::ostringstream stringStream;
261  stringStream << vol << "_" << particleName << "_" << suffix;
262  hMap[particleName] = new TH1F(stringStream.str().c_str(), stringStream.str().c_str(), nbins, edges);
263  }
264  hMap[particleName]->Fill(value, weight);
265  }

◆ InitializeFillHistogram() [2/2]

void G4UA::StepHistogram::InitializeFillHistogram ( HistoMapMap_t &  hMapMap,
const char *  suffix,
const G4String &  pdgId,
const G4String &  vol,
int  nbins,
double  xmin,
double  xmax,
double  value,
double  weight 
)
private

Definition at line 237 of file StepHistogram.cxx.

240  {
241  const auto& [pStringMapPair, inserted] = hMapMap.try_emplace(vol,HistoMap_t());
242  HistoMap_t &hMap = pStringMapPair->second;
243  if ( hMap.find(particleName) == hMap.end() ) {
244  // initialize histogram if not yet exist
245  std::ostringstream stringStream;
246  stringStream << vol << "_" << particleName << "_" << suffix;
247  hMap[particleName] = new TH1F(stringStream.str().c_str(), stringStream.str().c_str(), nbins, xmin, xmax);
248  }
249  hMap[particleName]->Fill(value, weight);
250  }

◆ InitializeFillHistogram2D()

void G4UA::StepHistogram::InitializeFillHistogram2D ( HistoMapMap_t &  hMapMap,
const char *  suffix,
const G4String &  pdgId,
const G4String &  vol,
int  nbinsx,
double  xmin,
double  xmax,
int  nbinsy,
double  ymin,
double  ymax,
double  valuex,
double  valuey,
double  weight 
)
private

Definition at line 220 of file StepHistogram.cxx.

225  {
226  const auto& [pStringMapPair, inserted] = hMapMap.try_emplace(vol,HistoMap_t());
227  HistoMap_t &hMap = pStringMapPair->second;
228  if ( hMap.find(particleName) == hMap.end() ) {
229  // initialize histogram if not yet exist
230  std::ostringstream stringStream;
231  stringStream << vol << "_" << particleName << "_" << suffix;
232  hMap[particleName] = new TH2F(stringStream.str().c_str(), stringStream.str().c_str(), nbinsx, xmin, xmax, nbinsy, ymin, ymax);
233  }
234  ((TH2*)hMap[particleName])->Fill(valuex, valuey, weight);
235  }

◆ initMessaging()

void AthMessaging::initMessaging ( ) const
privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

40 {
41  m_imsg = Athena::getMessageSvc();
42  m_lvl = m_imsg ?
43  static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
44  MSG::INFO;
45 }

◆ msg() [1/2]

MsgStream & AthMessaging::msg ( ) const
inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 164 of file AthMessaging.h.

165 {
166  MsgStream* ms = m_msg_tls.get();
167  if (!ms) {
168  if (!m_initialized.test_and_set()) initMessaging();
169  ms = new MsgStream(m_imsg,m_nm);
170  m_msg_tls.reset( ms );
171  }
172 
173  ms->setLevel (m_lvl);
174  return *ms;
175 }

◆ msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level  lvl) const
inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 179 of file AthMessaging.h.

180 { return msg() << lvl; }

◆ msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Test the output level.

Parameters
lvlThe message level to test against
Returns
boolean Indicating if messages at given level will be printed
Return values
trueMessages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

152 {
153  if (!m_initialized.test_and_set()) initMessaging();
154  if (m_lvl <= lvl) {
155  msg() << lvl;
156  return true;
157  } else {
158  return false;
159  }
160 }

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level  lvl)
inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

29 {
30  m_lvl = lvl;
31 }

◆ UserSteppingAction()

void G4UA::StepHistogram::UserSteppingAction ( const G4Step *  aStep)
overridevirtual

the hooks for G4 UA handling

Definition at line 35 of file StepHistogram.cxx.

35  {
36 
37  // track
38  G4Track *tr = aStep->GetTrack();
39 
40  // pre-step point
41  G4StepPoint *PreStepPoint = aStep->GetPreStepPoint();
42 
43  // post-step point
44  G4StepPoint *PostStepPoint = aStep->GetPostStepPoint();
45 
46  // pre-step kinetic energy
47  double stepKinetic = PreStepPoint->GetKineticEnergy();
48 
49  // post-step kinetic energy
50  double postStepKinetic = PostStepPoint->GetKineticEnergy();
51 
52  // pre-step position
53  const G4ThreeVector& myPos = PreStepPoint->GetPosition();
54 
55  // particle name
56  G4String particleName = "nucleus";
57  if (!(tr->GetDefinition()->GetParticleType() == "nucleus"))
58  particleName = G4DebuggingHelpers::ClassifyParticle(tr->GetParticleDefinition());
59 
60  // pre-step volume
61  G4String volumeName = PreStepPoint->GetPhysicalVolume()->GetName();
62  volumeName = G4DebuggingHelpers::ClassifyVolume(volumeName);
63 
64  // pre-step material
65  G4String materialName = PreStepPoint->GetMaterial()->GetName();
66  materialName = G4DebuggingHelpers::ClassifyMaterial(materialName);
67 
68  // process name (uses post-step point)
69  G4String processName = PostStepPoint->GetProcessDefinedStep() ?
70  PostStepPoint->GetProcessDefinedStep()->GetProcessName() : "Unknown";
71 
72  // secondaries
73  const std::vector<const G4Track*>* secondaries = aStep->GetSecondaryInCurrentStep();
74 
75  // 2D map
76  if (m_config.do2DHistograms) {
77  float DepositedE = aStep->GetTotalEnergyDeposit();
78  InitializeFillHistogram2D(m_report.histoMapMap2D_vol_RZ, "vol_RZ", particleName, volumeName,
79  2000, -20000, 20000, 1000, 0, 5000, myPos.getZ(), myPos.perp(), 1.);
80  InitializeFillHistogram2D(m_report.histoMapMap2D_mat_RZ, "mat_RZ", particleName, materialName,
81  2000, -20000, 20000, 1000, 0, 5000, myPos.getZ(), myPos.perp(), 1.);
82  InitializeFillHistogram2D(m_report.histoMapMap2D_prc_RZ, "prc_RZ", particleName, processName,
83  2000, -20000, 20000, 1000, 0, 5000, myPos.getZ(), myPos.perp(), 1.);
84  InitializeFillHistogram2D(m_report.histoMapMap2D_vol_RZ_E, "vol_RZ_E", particleName, volumeName,
85  2000, -20000, 20000, 1000, 0, 5000, myPos.getZ(), myPos.perp(), DepositedE);
86  InitializeFillHistogram2D(m_report.histoMapMap2D_mat_RZ_E, "mat_RZ_E", particleName, materialName,
87  2000, -20000, 20000, 1000, 0, 5000, myPos.getZ(), myPos.perp(), DepositedE);
88  }
89 
90  // step length
91  InitializeFillHistogram(m_report.histoMapMap_vol_stepSize, "vol_stepLength", particleName, volumeName,
92  1000, -12, 4, log10(aStep->GetStepLength()), 1.);
93  InitializeFillHistogram(m_report.histoMapMap_mat_stepSize, "mat_stepLength", particleName, materialName,
94  1000, -12, 4, log10(aStep->GetStepLength()), 1.);
95  InitializeFillHistogram(m_report.histoMapMap_prc_stepSize, "prc_stepLength", particleName, processName,
96  1000, -12, 4, log10(aStep->GetStepLength()), 1.);
97 
98  // step pseudorapidity
99  InitializeFillHistogram(m_report.histoMapMap_vol_stepPseudorapidity, "vol_stepPseudorapidity", particleName, volumeName,
100  200, -10, 10, myPos.eta(), 1.);
101  InitializeFillHistogram(m_report.histoMapMap_mat_stepPseudorapidity, "mat_stepPseudorapidity", particleName, materialName,
102  200, -10, 10, myPos.eta(), 1.);
103  InitializeFillHistogram(m_report.histoMapMap_prc_stepPseudorapidity, "prc_stepPseudorapidity", particleName, processName,
104  200, -10, 10, myPos.eta(), 1.);
105 
106  // step kinetic energy
107  InitializeFillHistogram(m_report.histoMapMap_vol_stepKineticEnergy, "vol_stepKineticEnergy", particleName, volumeName,
108  1000, -9, 7, log10(stepKinetic), 1.);
109  InitializeFillHistogram(m_report.histoMapMap_mat_stepKineticEnergy, "mat_stepKineticEnergy", particleName, materialName,
110  1000, -9, 7, log10(stepKinetic), 1.);
111  InitializeFillHistogram(m_report.histoMapMap_prc_stepKineticEnergy, "prc_stepKineticEnergy", particleName, processName,
112  1000, -9, 7, log10(stepKinetic), 1.);
113  InitializeFillHistogram(m_report.histoMapMap_stepKinetic, "stepKineticEnergy", particleName, "AllATLAS",
114  1000, -9, 7, log10(stepKinetic), 1.);
115 
116  // post step kinetic energy
117  InitializeFillHistogram(m_report.histoMapMap_vol_postStepKineticEnergy, "vol_postStepKineticEnergy", particleName, volumeName,
118  1000, -9, 7, log10(postStepKinetic), 1.);
119  InitializeFillHistogram(m_report.histoMapMap_mat_postStepKineticEnergy, "mat_postStepKineticEnergy", particleName, materialName,
120  1000, -9, 7, log10(postStepKinetic), 1.);
121  InitializeFillHistogram(m_report.histoMapMap_prc_postStepKineticEnergy, "prc_postStepKineticEnergy", particleName, processName,
122  1000, -9, 7, log10(postStepKinetic), 1.);
123  InitializeFillHistogram(m_report.histoMapMap_postStepKinetic, "postStepKineticEnergy", particleName, "AllATLAS",
124  1000, -9, 7, log10(postStepKinetic), 1.);
125 
126  // step energy deposit
127  InitializeFillHistogram(m_report.histoMapMap_vol_stepEnergyDeposit, "vol_stepEnergyDeposit", particleName, volumeName,
128  1000, -11, 3, log10(aStep->GetTotalEnergyDeposit()), 1.);
129  InitializeFillHistogram(m_report.histoMapMap_mat_stepEnergyDeposit, "mat_stepEnergyDeposit", particleName, materialName,
130  1000, -11, 3, log10(aStep->GetTotalEnergyDeposit()), 1.);
131  InitializeFillHistogram(m_report.histoMapMap_prc_stepEnergyDeposit, "prc_stepEnergyDeposit", particleName, processName,
132  1000, -11, 3, log10(aStep->GetTotalEnergyDeposit()), 1.);
133 
134  // step non-ionizing energy deposit
135  InitializeFillHistogram(m_report.histoMapMap_vol_stepEnergyNonIonDeposit, "vol_stepEnergyNonIonDeposit", particleName, volumeName,
136  1000, -11, 1, log10(aStep->GetNonIonizingEnergyDeposit()), 1.);
137  InitializeFillHistogram(m_report.histoMapMap_mat_stepEnergyNonIonDeposit, "mat_stepEnergyNonIonDeposit", particleName, materialName,
138  1000, -11, 1, log10(aStep->GetNonIonizingEnergyDeposit()), 1.);
139  InitializeFillHistogram(m_report.histoMapMap_prc_stepEnergyNonIonDeposit, "prc_stepEnergyNonIonDeposit", particleName, processName,
140  1000, -11, 1, log10(aStep->GetNonIonizingEnergyDeposit()), 1.);
141 
142  // secondary kinetic energy
143  for (const auto &track : *secondaries) {
144  G4String secondary_particleName = G4DebuggingHelpers::ClassifyParticle(track->GetParticleDefinition());
145  InitializeFillHistogram(m_report.histoMapMap_vol_stepSecondaryKinetic, "vol_stepSecondaryKinetic", secondary_particleName, volumeName,
146  1000, -7, 5, log10(track->GetKineticEnergy()), 1.);
147  InitializeFillHistogram(m_report.histoMapMap_mat_stepSecondaryKinetic, "mat_stepSecondaryKinetic", secondary_particleName, materialName,
148  1000, -7, 5, log10(track->GetKineticEnergy()), 1.);
149  InitializeFillHistogram(m_report.histoMapMap_prc_stepSecondaryKinetic, "prc_stepSecondaryKinetic", secondary_particleName, processName,
150  1000, -7, 5, log10(track->GetKineticEnergy()), 1.);
151  }
152 
153  // stop here if 'general' histograms not activated
154  // _______________________________________________
155  if (!m_config.doGeneralHistograms)
156  return;
157 
158  // first step (after initial step)
159  if (tr->GetCurrentStepNumber()==1) {
160  // initial kinetic energy
161  m_initialKineticEnergyOfStep = stepKinetic;
162 
163  // initial volume/material/processes
164  m_initialVolume = volumeName;
165  m_initialMaterial = materialName;
166  m_initialProcess = processName;
167 
168  // save track ID for checking if we later have the same track
169  m_trackID = tr->GetTrackID();
170 
171  // initial energy
172  InitializeFillHistogram(m_report.histoMapMap_InitialE, "InitialE", particleName, "AllATLAS",
173  1000, -9, 7, std::log10(m_initialKineticEnergyOfStep), 1.0);
174  InitializeFillHistogram(m_report.histoMapMap_vol_InitialE, "vol_InitialE", particleName, m_initialVolume,
175  1000, -9, 7, std::log10(m_initialKineticEnergyOfStep), 1.0);
176  InitializeFillHistogram(m_report.histoMapMap_mat_InitialE, "mat_InitialE", particleName, m_initialMaterial,
177  1000, -9, 7, std::log10(m_initialKineticEnergyOfStep), 1.0);
178  InitializeFillHistogram(m_report.histoMapMap_prc_InitialE, "prc_InitialE", particleName, m_initialProcess,
179  1000, -9, 7, std::log10(m_initialKineticEnergyOfStep), 1.0);
180  }
181 
182  // last step
183  if ( tr->GetTrackStatus() == 2 ) {
184  // assert to check if we have the correct track
185  if (not (tr->GetTrackID() == m_trackID)) {
186  ATH_MSG_ERROR("Track ID changed between the assumed first step and the last.");
187  throw std::exception();
188  }
189  // number of steps
190  int nSteps = tr->GetCurrentStepNumber() + 1;
191  InitializeFillHistogram(m_report.histoMapMap_numberOfSteps, "numberOfSteps", particleName, "AllATLAS",
192  10000, 0.5, 10000.5, nSteps, 1.);
193  InitializeFillHistogram(m_report.histoMapMap_vol_numberOfSteps, "vol_numberOfSteps", particleName, m_initialVolume,
194  10000, 0.5, 10000.5, nSteps, 1.);
195  InitializeFillHistogram(m_report.histoMapMap_mat_numberOfSteps, "mat_numberOfSteps", particleName, m_initialMaterial,
196  10000, 0.5, 10000.5, nSteps, 1.);
197  InitializeFillHistogram(m_report.histoMapMap_prc_numberOfSteps, "prc_numberOfSteps", particleName, m_initialProcess,
198  10000, 0.5, 10000.5, nSteps, 1.);
199  // number of steps vs initial energy
200  InitializeFillHistogram(m_report.histoMapMap_numberOfStepsPerInitialE, "numberOfStepsPerInitialE", particleName, "AllATLAS",
201  1000, -9, 7, std::log10(m_initialKineticEnergyOfStep), nSteps);
202  InitializeFillHistogram(m_report.histoMapMap_vol_numberOfStepsPerInitialE, "vol_numberOfStepsPerInitialE", particleName, m_initialVolume,
203  1000, -9, 7, std::log10(m_initialKineticEnergyOfStep), nSteps);
204  InitializeFillHistogram(m_report.histoMapMap_mat_numberOfStepsPerInitialE, "mat_numberOfStepsPerInitialE", particleName, m_initialMaterial,
205  1000, -9, 7, std::log10(m_initialKineticEnergyOfStep), nSteps);
206  InitializeFillHistogram(m_report.histoMapMap_prc_numberOfStepsPerInitialE, "prc_numberOfStepsPerInitialE", particleName, m_initialProcess,
207  1000, -9, 7, std::log10(m_initialKineticEnergyOfStep), nSteps);
208  // track length vs initial energy
209  InitializeFillHistogram(m_report.histoMapMap_trackLengthPerInitialE, "trackLengthPerInitialE", particleName, "AllATLAS",
210  1000, -9, 7, log10(tr->GetTrackLength()), 1.);
211  InitializeFillHistogram(m_report.histoMapMap_vol_trackLengthPerInitialE, "vol_trackLengthPerInitialE", particleName, m_initialVolume,
212  1000, -9, 7, log10(tr->GetTrackLength()), 1.);
213  InitializeFillHistogram(m_report.histoMapMap_mat_trackLengthPerInitialE, "mat_trackLengthPerInitialE", particleName, m_initialMaterial,
214  1000, -9, 7, log10(tr->GetTrackLength()), 1.);
215  InitializeFillHistogram(m_report.histoMapMap_prc_trackLengthPerInitialE, "prc_trackLengthPerInitialE", particleName, m_initialProcess,
216  1000, -9, 7, log10(tr->GetTrackLength()), 1.);
217  }
218  }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_config

Config G4UA::StepHistogram::m_config
private

configuration data

Definition at line 122 of file StepHistogram.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }
mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_initialKineticEnergyOfStep

float G4UA::StepHistogram::m_initialKineticEnergyOfStep
private

Definition at line 139 of file StepHistogram.h.

◆ m_initialMaterial

G4String G4UA::StepHistogram::m_initialMaterial
private

Definition at line 141 of file StepHistogram.h.

◆ m_initialProcess

G4String G4UA::StepHistogram::m_initialProcess
private

Definition at line 142 of file StepHistogram.h.

◆ m_initialVolume

G4String G4UA::StepHistogram::m_initialVolume
private

Definition at line 140 of file StepHistogram.h.

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }
mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls
mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm
privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_report

Report G4UA::StepHistogram::m_report
private

Definition at line 119 of file StepHistogram.h.

◆ m_trackID

int G4UA::StepHistogram::m_trackID = 0
private

Definition at line 143 of file StepHistogram.h.

The documentation for this class was generated from the following files:
G4UA::StepHistogram::Report::histoMapMap_mat_stepSize
HistoMapMap_t histoMapMap_mat_stepSize
Definition: StepHistogram.h:58
G4UA::StepHistogram::Report::histoMapMap_mat_stepKineticEnergy
HistoMapMap_t histoMapMap_mat_stepKineticEnergy
Definition: StepHistogram.h:59
AthMessaging::m_lvl
std::atomic< MSG::Level > m_lvl
Current logging level.
Definition: AthMessaging.h:138
G4UA::StepHistogram::HistoMap_t
std::map< G4String, TH1 * > HistoMap_t
Definition: StepHistogram.h:38
G4UA::StepHistogram::Report::histoMapMap_prc_numberOfStepsPerInitialE
HistoMapMap_t histoMapMap_prc_numberOfStepsPerInitialE
Definition: StepHistogram.h:79
ymin
double ymin
Definition: listroot.cxx:63
G4UA::StepHistogram::Report::histoMapMap_trackLengthPerInitialE
HistoMapMap_t histoMapMap_trackLengthPerInitialE
Definition: StepHistogram.h:86
G4UA::StepHistogram::Report::histoMapMap_prc_numberOfSteps
HistoMapMap_t histoMapMap_prc_numberOfSteps
Definition: StepHistogram.h:78
hotSpotInTAG.suffix
string suffix
Definition: hotSpotInTAG.py:186
G4DebuggingHelpers::ClassifyParticle
const G4String ClassifyParticle(const G4ParticleDefinition *def)
Definition: G4DebuggingHelper.cxx:24
G4UA::StepHistogram::m_initialMaterial
G4String m_initialMaterial
Definition: StepHistogram.h:141
G4DebuggingHelpers::ClassifyVolume
const G4String ClassifyVolume(const G4String &nom)
Definition: G4DebuggingHelper.cxx:74
G4UA::StepHistogram::m_config
Config m_config
configuration data
Definition: StepHistogram.h:122
G4UA::StepHistogram::Report::histoMapMap_mat_numberOfSteps
HistoMapMap_t histoMapMap_mat_numberOfSteps
Definition: StepHistogram.h:65
G4UA::StepHistogram::Report::histoMapMap_mat_stepEnergyDeposit
HistoMapMap_t histoMapMap_mat_stepEnergyDeposit
Definition: StepHistogram.h:62
G4UA::StepHistogram::Report::histoMapMap_stepKinetic
HistoMapMap_t histoMapMap_stepKinetic
Definition: StepHistogram.h:88
G4UA::StepHistogram::Config::do2DHistograms
bool do2DHistograms
Definition: StepHistogram.h:108
athena.value
value
Definition: athena.py:122
G4UA::StepHistogram::Report::histoMapMap_mat_numberOfStepsPerInitialE
HistoMapMap_t histoMapMap_mat_numberOfStepsPerInitialE
Definition: StepHistogram.h:66
G4UA::StepHistogram::Report::histoMapMap_vol_InitialE
HistoMapMap_t histoMapMap_vol_InitialE
Definition: StepHistogram.h:55
G4UA::StepHistogram::m_trackID
int m_trackID
Definition: StepHistogram.h:143
python.TrigEgammaMonitorHelper.TH2F
def TH2F(name, title, nxbins, bins_par2, bins_par3, bins_par4, bins_par5=None, bins_par6=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:45
AthMessaging::m_imsg
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
Definition: AthMessaging.h:135
python.SystemOfUnits.ms
int ms
Definition: SystemOfUnits.py:132
G4UA::StepHistogram::Report::histoMapMap_vol_postStepKineticEnergy
HistoMapMap_t histoMapMap_vol_postStepKineticEnergy
Definition: StepHistogram.h:47
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
G4UA::StepHistogram::Report::histoMapMap_prc_trackLengthPerInitialE
HistoMapMap_t histoMapMap_prc_trackLengthPerInitialE
Definition: StepHistogram.h:80
G4UA::StepHistogram::Report::histoMapMap_vol_stepKineticEnergy
HistoMapMap_t histoMapMap_vol_stepKineticEnergy
Definition: StepHistogram.h:46
config
Definition: PhysicsAnalysis/AnalysisCommon/AssociationUtils/python/config.py:1
G4UA::StepHistogram::Report::histoMapMap_prc_stepEnergyDeposit
HistoMapMap_t histoMapMap_prc_stepEnergyDeposit
Definition: StepHistogram.h:75
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:200
G4UA::StepHistogram::Report::histoMapMap_vol_numberOfStepsPerInitialE
HistoMapMap_t histoMapMap_vol_numberOfStepsPerInitialE
Definition: StepHistogram.h:53
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
G4UA::StepHistogram::Report::histoMapMap_prc_postStepKineticEnergy
HistoMapMap_t histoMapMap_prc_postStepKineticEnergy
Definition: StepHistogram.h:73
AthMessaging::AthMessaging
AthMessaging()
Default constructor:
G4UA::StepHistogram::Report::histoMapMap_vol_stepSecondaryKinetic
HistoMapMap_t histoMapMap_vol_stepSecondaryKinetic
Definition: StepHistogram.h:51
G4UA::StepHistogram::Report::histoMapMap_vol_stepEnergyDeposit
HistoMapMap_t histoMapMap_vol_stepEnergyDeposit
Definition: StepHistogram.h:49
G4StepHelper::particleName
std::string particleName(const G4Step *theStep)
TODO.
Definition: StepHelper.cxx:24
TrigConf::MSGTC::Level
Level
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:21
G4UA::StepHistogram::Report::histoMapMap_vol_stepPseudorapidity
HistoMapMap_t histoMapMap_vol_stepPseudorapidity
Definition: StepHistogram.h:48
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
G4UA::StepHistogram::Report::histoMapMap_mat_InitialE
HistoMapMap_t histoMapMap_mat_InitialE
Definition: StepHistogram.h:68
xmin
double xmin
Definition: listroot.cxx:60
calibdata.exception
exception
Definition: calibdata.py:496
G4UA::StepHistogram::Report::histoMapMap_mat_trackLengthPerInitialE
HistoMapMap_t histoMapMap_mat_trackLengthPerInitialE
Definition: StepHistogram.h:67
G4UA::StepHistogram::Report::histoMapMap_postStepKinetic
HistoMapMap_t histoMapMap_postStepKinetic
Definition: StepHistogram.h:89
checkCorrelInHIST.nSteps
int nSteps
Definition: checkCorrelInHIST.py:458
TH2
Definition: rootspy.cxx:373
G4UA::StepHistogram::Report::histoMapMap2D_mat_RZ
HistoMapMap_t histoMapMap2D_mat_RZ
Definition: StepHistogram.h:93
AthMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition: AthMessaging.h:164
G4UA::StepHistogram::Report::histoMapMap_vol_trackLengthPerInitialE
HistoMapMap_t histoMapMap_vol_trackLengthPerInitialE
Definition: StepHistogram.h:54
G4UA::StepHistogram::Report::histoMapMap2D_mat_RZ_E
HistoMapMap_t histoMapMap2D_mat_RZ_E
Definition: StepHistogram.h:96
G4UA::StepHistogram::Report::histoMapMap_prc_stepSecondaryKinetic
HistoMapMap_t histoMapMap_prc_stepSecondaryKinetic
Definition: StepHistogram.h:77
G4UA::StepHistogram::Report::histoMapMap_vol_stepEnergyNonIonDeposit
HistoMapMap_t histoMapMap_vol_stepEnergyNonIonDeposit
Definition: StepHistogram.h:50
G4UA::StepHistogram::Report::histoMapMap_mat_stepPseudorapidity
HistoMapMap_t histoMapMap_mat_stepPseudorapidity
Definition: StepHistogram.h:61
G4UA::StepHistogram::Report::histoMapMap_prc_stepSize
HistoMapMap_t histoMapMap_prc_stepSize
Definition: StepHistogram.h:71
G4UA::StepHistogram::Report::histoMapMap_numberOfStepsPerInitialE
HistoMapMap_t histoMapMap_numberOfStepsPerInitialE
Definition: StepHistogram.h:85
G4UA::StepHistogram::Report::histoMapMap_prc_InitialE
HistoMapMap_t histoMapMap_prc_InitialE
Definition: StepHistogram.h:81
G4UA::StepHistogram::Report::histoMapMap_prc_stepKineticEnergy
HistoMapMap_t histoMapMap_prc_stepKineticEnergy
Definition: StepHistogram.h:72
G4UA::StepHistogram::Report::histoMapMap_vol_numberOfSteps
HistoMapMap_t histoMapMap_vol_numberOfSteps
Definition: StepHistogram.h:52
G4UA::StepHistogram::InitializeFillHistogram2D
void InitializeFillHistogram2D(HistoMapMap_t &hMapMap, const char *suffix, const G4String &pdgId, const G4String &vol, int nbinsx, double xmin, double xmax, int nbinsy, double ymin, double ymax, double valuex, double valuey, double weight)
Definition: StepHistogram.cxx:220
G4DebuggingHelpers::ClassifyMaterial
const G4String ClassifyMaterial(const G4String &nom)
Definition: G4DebuggingHelper.cxx:40
G4UA::StepHistogram::Config::doGeneralHistograms
bool doGeneralHistograms
Definition: StepHistogram.h:109
AthMessaging::m_nm
std::string m_nm
Message source name.
Definition: AthMessaging.h:129
xmax
double xmax
Definition: listroot.cxx:61
G4UA::StepHistogram::m_initialVolume
G4String m_initialVolume
Definition: StepHistogram.h:140
G4UA::StepHistogram::Report::histoMapMap_numberOfSteps
HistoMapMap_t histoMapMap_numberOfSteps
Definition: StepHistogram.h:84
G4UA::StepHistogram::Report::histoMapMap2D_vol_RZ_E
HistoMapMap_t histoMapMap2D_vol_RZ_E
Definition: StepHistogram.h:95
G4UA::StepHistogram::m_report
Report m_report
Definition: StepHistogram.h:119
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
G4UA::StepHistogram::Report::histoMapMap2D_prc_RZ
HistoMapMap_t histoMapMap2D_prc_RZ
Definition: StepHistogram.h:94
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
G4UA::StepHistogram::Report::histoMapMap_vol_stepSize
HistoMapMap_t histoMapMap_vol_stepSize
Definition: StepHistogram.h:45
AthMessaging::initMessaging
void initMessaging() const
Initialize our message level and MessageSvc.
Definition: AthMessaging.cxx:39
G4UA::StepHistogram::InitializeFillHistogram
void InitializeFillHistogram(HistoMapMap_t &hMapMap, const char *suffix, const G4String &pdgId, const G4String &vol, int nbins, double xmin, double xmax, double value, double weight)
Definition: StepHistogram.cxx:237
AthMessaging::m_msg_tls
boost::thread_specific_ptr< MsgStream > m_msg_tls
MsgStream instance (a std::cout like with print-out levels)
Definition: AthMessaging.h:132
G4UA::StepHistogram::Report::histoMapMap_InitialE
HistoMapMap_t histoMapMap_InitialE
Definition: StepHistogram.h:87
G4UA::StepHistogram::Report::histoMapMap2D_vol_RZ
HistoMapMap_t histoMapMap2D_vol_RZ
Definition: StepHistogram.h:92
G4UA::StepHistogram::m_initialKineticEnergyOfStep
float m_initialKineticEnergyOfStep
Definition: StepHistogram.h:139
G4UA::StepHistogram::Report::histoMapMap_mat_stepEnergyNonIonDeposit
HistoMapMap_t histoMapMap_mat_stepEnergyNonIonDeposit
Definition: StepHistogram.h:63
G4UA::StepHistogram::Report::histoMapMap_prc_stepEnergyNonIonDeposit
HistoMapMap_t histoMapMap_prc_stepEnergyNonIonDeposit
Definition: StepHistogram.h:76
ymax
double ymax
Definition: listroot.cxx:64
G4UA::StepHistogram::m_initialProcess
G4String m_initialProcess
Definition: StepHistogram.h:142
G4UA::StepHistogram::Report::histoMapMap_prc_stepPseudorapidity
HistoMapMap_t histoMapMap_prc_stepPseudorapidity
Definition: StepHistogram.h:74
G4UA::StepHistogram::Report::histoMapMap_mat_stepSecondaryKinetic
HistoMapMap_t histoMapMap_mat_stepSecondaryKinetic
Definition: StepHistogram.h:64
G4UA::StepHistogram::Report::histoMapMap_mat_postStepKineticEnergy
HistoMapMap_t histoMapMap_mat_postStepKineticEnergy
Definition: StepHistogram.h:60
Generated on Tue Jul 2 2024 22:16:40 for ATLAS Offline Software by   doxygen 1.8.18