Geant4 11.2.2
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4SteppingVerbose.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26// G4SteppingVerbose class implementation
27//
28// Contact:
29// Questions and comments to this code should be sent to
30// Katsuya Amako (e-mail: [email protected])
31// Takashi Sasaki (e-mail: [email protected])
32// --------------------------------------------------------------------
33
34#include "G4SteppingVerbose.hh"
35
36#include "G4StepStatus.hh" // Include from 'tracking'
37#include "G4SteppingManager.hh"
38#include "G4SystemOfUnits.hh"
39#include "G4VSensitiveDetector.hh" // Include from 'hits/digi'
40
41// #define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
42
43#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
44# include "G4UnitsTable.hh"
45#else
46# define G4BestUnit(a, b) a
47#endif
48
49G4int G4SteppingVerbose::useBestUnitPrecision = -1;
50
51//////////////////////////////////////////////////
52void G4SteppingVerbose::NewStep()
53//////////////////////////////////////////////////
54{}
55
56//////////////////////////////////////////////////
57void G4SteppingVerbose::AtRestDoItInvoked()
58//////////////////////////////////////////////////
59{
60 if (Silent == 1) {
61 return;
62 }
63
64 G4VProcess* ptProcManager;
65 CopyState();
66
67 if (verboseLevel >= 3) {
68 G4int npt = 0;
69 G4cout << " **List of AtRestDoIt invoked:" << G4endl;
70 for (std::size_t np = 0; np < MAXofAtRestLoops; ++np) {
71 std::size_t npGPIL = MAXofAtRestLoops - np - 1;
72 if ((*fSelectedAtRestDoItVector)[npGPIL] == G4ForceCondition::Forced) {
73 ++npt;
74 ptProcManager = (*fAtRestDoItVector)[(G4int)np];
75 G4cout << " # " << npt << " : " << ptProcManager->GetProcessName() << " (Forced)"
76 << G4endl;
77 }
78 else if ((*fSelectedAtRestDoItVector)[npGPIL] == G4ForceCondition::NotForced) {
79 ++npt;
80 ptProcManager = (*fAtRestDoItVector)[(G4int)np];
81 G4cout << " # " << npt << " : " << ptProcManager->GetProcessName() << G4endl;
82 }
83 }
84
85 G4cout << " Generated secondries # : " << fN2ndariesAtRestDoIt << G4endl;
86
87 if (fN2ndariesAtRestDoIt > 0) {
88 G4cout << " -- List of secondaries generated : "
89 << "(x,y,z,kE,t,PID) --" << G4endl;
90 for (std::size_t lp1 = (*fSecondary).size() - fN2ndariesAtRestDoIt;
91 lp1 < (*fSecondary).size(); ++lp1)
92 {
93 G4cout << " " << std::setw(9)
94 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length") << " " << std::setw(9)
95 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length") << " " << std::setw(9)
96 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length") << " " << std::setw(9)
97 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy") << " "
98 << std::setw(9) << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time") << " "
99 << std::setw(18) << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
100 }
101 }
102 }
103
104 if (verboseLevel >= 4) {
105 ShowStep();
106 G4cout << G4endl;
107 }
108}
109
110/////////////////////////////////////////////////////
111void G4SteppingVerbose::AlongStepDoItAllDone()
112/////////////////////////////////////////////////////
113{
114 if (Silent == 1) {
115 return;
116 }
117
118 G4VProcess* ptProcManager;
119
120 CopyState();
121
122 if (verboseLevel >= 3) {
123 G4cout << G4endl;
124 G4cout << " >>AlongStepDoIt (after all invocations):" << G4endl;
125 G4cout << " ++List of invoked processes " << G4endl;
126
127 for (std::size_t ci = 0; ci < MAXofAlongStepLoops; ++ci) {
128 ptProcManager = (*fAlongStepDoItVector)((G4int)ci);
129 G4cout << " " << ci + 1 << ") ";
130 if (ptProcManager != nullptr) {
131 G4cout << ptProcManager->GetProcessName() << G4endl;
132 }
133 }
134
135 ShowStep();
136 G4cout << G4endl;
137 G4cout << " ++List of secondaries generated "
138 << "(x,y,z,kE,t,PID):"
139 << " No. of secondaries = " << (*fSecondary).size() << G4endl;
140
141 if (! (*fSecondary).empty()) {
142 for (auto& lp1 : *fSecondary) {
143 G4cout << " " << std::setw(9) << G4BestUnit(lp1->GetPosition().x(), "Length") << " "
144 << std::setw(9) << G4BestUnit(lp1->GetPosition().y(), "Length") << " "
145 << std::setw(9) << G4BestUnit(lp1->GetPosition().z(), "Length") << " "
146 << std::setw(9) << G4BestUnit(lp1->GetKineticEnergy(), "Energy") << " "
147 << std::setw(9) << G4BestUnit(lp1->GetGlobalTime(), "Time") << " " << std::setw(18)
148 << lp1->GetDefinition()->GetParticleName() << G4endl;
149 }
150 }
151 }
152}
153
154////////////////////////////////////////////////////
155void G4SteppingVerbose::PostStepDoItAllDone()
156////////////////////////////////////////////////////
157{
158 if (Silent == 1) {
159 return;
160 }
161
162 G4VProcess* ptProcManager;
163
164 CopyState();
165
166 if ((fStepStatus == fPostStepDoItProc) || (fCondition == Forced) ||
167 (fCondition == Conditionally) || (fCondition == ExclusivelyForced) ||
168 (fCondition == StronglyForced))
169 {
170 if (verboseLevel >= 3) {
171 G4int npt = 0;
172 G4cout << G4endl;
173 G4cout << " **PostStepDoIt (after all invocations):" << G4endl;
174 G4cout << " ++List of invoked processes " << G4endl;
175
176 for (std::size_t np = 0; np < MAXofPostStepLoops; ++np) {
177 std::size_t npGPIL = MAXofPostStepLoops - np - 1;
178 if ((*fSelectedPostStepDoItVector)[npGPIL] == G4ForceCondition::Forced) {
179 ++npt;
180 ptProcManager = (*fPostStepDoItVector)[(G4int)np];
181 G4cout << " " << npt << ") " << ptProcManager->GetProcessName() << " (Forced)"
182 << G4endl;
183 }
184 else if ((*fSelectedPostStepDoItVector)[npGPIL] == G4ForceCondition::NotForced) {
185 ++npt;
186 ptProcManager = (*fPostStepDoItVector)[(G4int)np];
187 G4cout << " " << npt << ") " << ptProcManager->GetProcessName() << G4endl;
188 }
189 }
190
191 ShowStep();
192 G4cout << G4endl;
193 G4cout << " ++List of secondaries generated "
194 << "(x,y,z,kE,t,PID):"
195 << " No. of secodaries = " << (*fSecondary).size() << G4endl;
196 G4cout << " [Note]Secondaries from AlongStepDoIt included." << G4endl;
197
198 if (! (*fSecondary).empty()) {
199 for (auto& lp1 : *fSecondary) {
200 G4cout << " " << std::setw(9) << G4BestUnit(lp1->GetPosition().x(), "Length") << " "
201 << std::setw(9) << G4BestUnit(lp1->GetPosition().y(), "Length") << " "
202 << std::setw(9) << G4BestUnit(lp1->GetPosition().z(), "Length") << " "
203 << std::setw(9) << G4BestUnit(lp1->GetKineticEnergy(), "Energy") << " "
204 << std::setw(9) << G4BestUnit(lp1->GetGlobalTime(), "Time") << " " << std::setw(18)
205 << lp1->GetDefinition()->GetParticleName() << G4endl;
206 }
207 }
208 }
209 }
210}
211
212/////////////////////////////////////////
213void G4SteppingVerbose::StepInfo()
214/////////////////////////////////////////
215{
216 if (Silent == 1) {
217 return;
218 }
219 if (SilentStepInfo == 1) {
220 return;
221 }
222
223 CopyState();
224 G4cout.precision(16);
225 G4long prec = G4cout.precision(3);
226
227 if (verboseLevel >= 1) {
228 if (verboseLevel >= 4) VerboseTrack();
229 if (verboseLevel >= 3) {
230 G4cout << G4endl;
231#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
232 G4cout << std::setw(5) << "#Step#"
233 << " " << std::setw(8) << "X"
234 << " " << std::setw(8) << "Y"
235 << " " << std::setw(8) << "Z"
236 << " " << std::setw(9) << "KineE"
237 << " " << std::setw(8) << "dE"
238 << " " << std::setw(12) << "StepLeng"
239 << " " << std::setw(12) << "TrackLeng"
240 << " " << std::setw(12) << "NextVolume"
241 << " " << std::setw(8) << "ProcName" << G4endl;
242#else
243 G4cout << std::setw(5) << "#Step#"
244 << " " << std::setw(8) << "X(mm)"
245 << " " << std::setw(8) << "Y(mm)"
246 << " " << std::setw(8) << "Z(mm)"
247 << " " << std::setw(9) << "KinE(MeV)"
248 << " " << std::setw(8) << "dE(MeV)"
249 << " " << std::setw(8) << "StepLeng"
250 << " " << std::setw(9) << "TrackLeng"
251 << " " << std::setw(11) << "NextVolume"
252 << " " << std::setw(8) << "ProcName" << G4endl;
253#endif
254 }
255 G4cout << std::setw(5) << fTrack->GetCurrentStepNumber() << " " << std::setw(8)
256 << G4BestUnit(fTrack->GetPosition().x(), "Length") << " " << std::setw(8)
257 << G4BestUnit(fTrack->GetPosition().y(), "Length") << " " << std::setw(8)
258 << G4BestUnit(fTrack->GetPosition().z(), "Length") << " " << std::setw(9)
259 << G4BestUnit(fTrack->GetKineticEnergy(), "Energy") << " " << std::setw(8)
260 << G4BestUnit(fStep->GetTotalEnergyDeposit(), "Energy") << " " << std::setw(8)
261 << G4BestUnit(fStep->GetStepLength(), "Length") << " " << std::setw(9)
262 << G4BestUnit(fTrack->GetTrackLength(), "Length") << " ";
263
264 if (fTrack->GetNextVolume() != nullptr) {
265 G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
266 }
267 else {
268 G4cout << std::setw(11) << "OutOfWorld"
269 << " ";
270 }
271 if (fStep->GetPostStepPoint()->GetProcessDefinedStep() != nullptr) {
272 G4cout << fStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName();
273 }
274 else {
275 G4cout << "User Limit";
276 }
277 G4cout << G4endl;
278 if (verboseLevel == 2) {
279 G4int tN2ndariesTot = fN2ndariesAtRestDoIt + fN2ndariesAlongStepDoIt + fN2ndariesPostStepDoIt;
280 if (tN2ndariesTot > 0) {
281 G4cout << " :----- List of 2ndaries - "
282 << "#SpawnInStep=" << std::setw(3) << tN2ndariesTot << "(Rest=" << std::setw(2)
283 << fN2ndariesAtRestDoIt << ",Along=" << std::setw(2) << fN2ndariesAlongStepDoIt
284 << ",Post=" << std::setw(2) << fN2ndariesPostStepDoIt << "), "
285 << "#SpawnTotal=" << std::setw(3) << (*fSecondary).size() << " ---------------"
286 << G4endl;
287
288 for (std::size_t lp1 = (*fSecondary).size() - tN2ndariesTot; lp1 < (*fSecondary).size();
289 ++lp1)
290 {
291 G4cout << " : " << std::setw(9)
292 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length") << " "
293 << std::setw(9) << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length")
294 << " " << std::setw(9)
295 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length") << " "
296 << std::setw(9) << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy")
297 << " " << std::setw(18) << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
298 << G4endl;
299 }
300 G4cout << " :-----------------------------"
301 << "----------------------------------"
302 << "-- EndOf2ndaries Info ---------------" << G4endl;
303 }
304 }
305 }
306 G4cout.precision(prec);
307}
308
309////////////////////////////////////////////
310void G4SteppingVerbose::DPSLStarted()
311////////////////////////////////////////////
312{
313 if (Silent == 1) {
314 return;
315 }
316 CopyState();
317
318 if (verboseLevel > 5) {
319 G4cout << G4endl << " >>DefinePhysicalStepLength (List of proposed StepLengths): " << G4endl;
320 }
321}
322
323//////////////////////////////////////////////
324void G4SteppingVerbose::DPSLUserLimit()
325//////////////////////////////////////////////
326{
327 if (Silent == 1) {
328 return;
329 }
330 CopyState();
331
332 if (verboseLevel > 5) {
333 G4cout << G4endl << G4endl;
334 G4cout << "=== Defined Physical Step Length (DPSL)" << G4endl;
335 G4cout << " ++ProposedStep(UserLimit) = " << std::setw(9) << physIntLength
336 << " : ProcName = User defined maximum allowed Step" << G4endl;
337 }
338}
339
340/////////////////////////////////////////////
341void G4SteppingVerbose::DPSLPostStep()
342/////////////////////////////////////////////
343{
344 if (Silent == 1) {
345 return;
346 }
347 CopyState();
348
349 if (verboseLevel > 5) {
350 G4cout << " ++ProposedStep(PostStep ) = " << std::setw(9) << physIntLength
351 << " : ProcName = " << fCurrentProcess->GetProcessName() << " (";
352 if (fCondition == ExclusivelyForced) {
353 G4cout << "ExclusivelyForced)" << G4endl;
354 }
355 else if (fCondition == StronglyForced) {
356 G4cout << "StronglyForced)" << G4endl;
357 }
358 else if (fCondition == Conditionally) {
359 G4cout << "Conditionally)" << G4endl;
360 }
361 else if (fCondition == Forced) {
362 G4cout << "Forced)" << G4endl;
363 }
364 else {
365 G4cout << "No ForceCondition)" << G4endl;
366 }
367 }
368}
369
370/////////////////////////////////////////////
371void G4SteppingVerbose::DPSLAlongStep()
372/////////////////////////////////////////////
373{
374 if (Silent == 1) {
375 return;
376 }
377 CopyState();
378
379 if (verboseLevel > 5) {
380 G4cout << " ++ProposedStep(AlongStep) = " << std::setw(9)
381 << G4BestUnit(physIntLength, "Length")
382 << " : ProcName = " << fCurrentProcess->GetProcessName() << " (";
383 if (fGPILSelection == CandidateForSelection) {
384 G4cout << "CandidateForSelection)" << G4endl;
385 }
386 else if (fGPILSelection == NotCandidateForSelection) {
387 G4cout << "NotCandidateForSelection)" << G4endl;
388 }
389 else {
390 G4cout << "?!?)" << G4endl;
391 }
392 }
393}
394
395////////////////////////////////////////////////
396void G4SteppingVerbose::TrackingStarted()
397////////////////////////////////////////////////
398{
399 if (Silent == 1) {
400 return;
401 }
402
403 CopyState();
404
405 G4long prec = G4cout.precision(3);
406 if (verboseLevel > 0) {
407#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
408 G4cout << std::setw(5) << "Step#"
409 << " " << std::setw(8) << "X"
410 << " " << std::setw(8) << "Y"
411 << " " << std::setw(8) << "Z"
412 << " " << std::setw(9) << "KineE"
413 << " " << std::setw(8) << "dE"
414 << " " << std::setw(12) << "StepLeng"
415 << " " << std::setw(12) << "TrackLeng"
416 << " " << std::setw(12) << "NextVolume"
417 << " " << std::setw(8) << "ProcName" << G4endl;
418#else
419 G4cout << std::setw(5) << "Step#"
420 << " " << std::setw(8) << "X(mm)"
421 << " " << std::setw(8) << "Y(mm)"
422 << " " << std::setw(8) << "Z(mm)"
423 << " " << std::setw(9) << "KinE(MeV)"
424 << " " << std::setw(8) << "dE(MeV)"
425 << " " << std::setw(8) << "StepLeng"
426 << " " << std::setw(9) << "TrackLeng"
427 << " " << std::setw(11) << "NextVolume"
428 << " " << std::setw(8) << "ProcName" << G4endl;
429#endif
430
431 G4cout << std::setw(5) << fTrack->GetCurrentStepNumber() << " " << std::setw(8)
432 << G4BestUnit(fTrack->GetPosition().x(), "Length") << " " << std::setw(8)
433 << G4BestUnit(fTrack->GetPosition().y(), "Length") << " " << std::setw(8)
434 << G4BestUnit(fTrack->GetPosition().z(), "Length") << " " << std::setw(9)
435 << G4BestUnit(fTrack->GetKineticEnergy(), "Energy") << " " << std::setw(8)
436 << G4BestUnit(fStep->GetTotalEnergyDeposit(), "Energy") << " " << std::setw(8)
437 << G4BestUnit(fStep->GetStepLength(), "Length") << " " << std::setw(9)
438 << G4BestUnit(fTrack->GetTrackLength(), "Length") << " ";
439
440 if (fTrack->GetNextVolume() != nullptr) {
441 G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
442 }
443 else {
444 G4cout << std::setw(11) << "OutOfWorld"
445 << " ";
446 }
447 G4cout << "initStep" << G4endl;
448 }
449 G4cout.precision(prec);
450}
451
452//////////////////////////////////////////////////////
453void G4SteppingVerbose::AlongStepDoItOneByOne()
454//////////////////////////////////////////////////////
455{
456 if (Silent == 1) {
457 return;
458 }
459
460 CopyState();
461
462 if (verboseLevel >= 4) {
463 G4cout << G4endl;
464 G4cout << " >>AlongStepDoIt (process by process): "
465 << " Process Name = " << fCurrentProcess->GetProcessName() << G4endl;
466
467 ShowStep();
468 G4cout << " "
469 << "!Note! Safety of PostStep is only valid "
470 << "after all DoIt invocations." << G4endl;
471
472 VerboseParticleChange();
473 G4cout << G4endl;
474
475 G4cout << " ++List of secondaries generated "
476 << "(x,y,z,kE,t,PID):"
477 << " No. of secodaries = " << fN2ndariesAlongStepDoIt << G4endl;
478
479 if (fN2ndariesAlongStepDoIt > 0) {
480 for (std::size_t lp1 = (*fSecondary).size() - fN2ndariesAlongStepDoIt;
481 lp1 < (*fSecondary).size(); ++lp1)
482 {
483 G4cout << " " << std::setw(9)
484 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length") << " " << std::setw(9)
485 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length") << " " << std::setw(9)
486 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length") << " " << std::setw(9)
487 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy") << " "
488 << std::setw(9) << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time") << " "
489 << std::setw(18) << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
490 }
491 }
492 }
493}
494
495//////////////////////////////////////////////////////
496void G4SteppingVerbose::PostStepDoItOneByOne()
497//////////////////////////////////////////////////////
498{
499 if (Silent == 1) {
500 return;
501 }
502
503 CopyState();
504
505 if (verboseLevel >= 4) {
506 G4cout << G4endl;
507 G4cout << " >>PostStepDoIt (process by process): "
508 << " Process Name = " << fCurrentProcess->GetProcessName() << G4endl;
509
510 ShowStep();
511 G4cout << G4endl;
512 VerboseParticleChange();
513 G4cout << G4endl;
514
515 G4cout << " ++List of secondaries generated "
516 << "(x,y,z,kE,t,PID):"
517 << " No. of secodaries = " << fN2ndariesPostStepDoIt << G4endl;
518
519 if (fN2ndariesPostStepDoIt > 0) {
520 for (std::size_t lp1 = (*fSecondary).size() - fN2ndariesPostStepDoIt;
521 lp1 < (*fSecondary).size(); ++lp1)
522 {
523 G4cout << " " << std::setw(9)
524 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length") << " " << std::setw(9)
525 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length") << " " << std::setw(9)
526 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length") << " " << std::setw(9)
527 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy") << " "
528 << std::setw(9) << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time") << " "
529 << std::setw(18) << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
530 }
531 }
532 }
533}
534
535//////////////////////////////////////
536void G4SteppingVerbose::VerboseTrack()
537//////////////////////////////////////
538{
539 if (Silent == 1) {
540 return;
541 }
542
543 CopyState();
544
545 G4cout << G4endl;
546 G4cout << " ++G4Track Information " << G4endl;
547 G4long prec = G4cout.precision(3);
548
549 G4cout << " -----------------------------------------------" << G4endl;
550 G4cout << " G4Track Information " << std::setw(20) << G4endl;
551 G4cout << " -----------------------------------------------" << G4endl;
552
553 G4cout << " Step number : " << std::setw(20) << fTrack->GetCurrentStepNumber()
554 << G4endl;
555#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
556 G4cout << " Position - x : " << std::setw(20)
557 << G4BestUnit(fTrack->GetPosition().x(), "Length") << G4endl;
558 G4cout << " Position - y : " << std::setw(20)
559 << G4BestUnit(fTrack->GetPosition().y(), "Length") << G4endl;
560 G4cout << " Position - z : " << std::setw(20)
561 << G4BestUnit(fTrack->GetPosition().z(), "Length") << G4endl;
562 G4cout << " Global Time : " << std::setw(20)
563 << G4BestUnit(fTrack->GetGlobalTime(), "Time") << G4endl;
564 G4cout << " Local Time : " << std::setw(20)
565 << G4BestUnit(fTrack->GetLocalTime(), "Time") << G4endl;
566#else
567 G4cout << " Position - x (mm) : " << std::setw(20) << fTrack->GetPosition().x() / mm
568 << G4endl;
569 G4cout << " Position - y (mm) : " << std::setw(20) << fTrack->GetPosition().y() / mm
570 << G4endl;
571 G4cout << " Position - z (mm) : " << std::setw(20) << fTrack->GetPosition().z() / mm
572 << G4endl;
573 G4cout << " Global Time (ns) : " << std::setw(20) << fTrack->GetGlobalTime() / ns
574 << G4endl;
575 G4cout << " Local Time (ns) : " << std::setw(20) << fTrack->GetLocalTime() / ns
576 << G4endl;
577#endif
578 G4cout << " Momentum Direct - x : " << std::setw(20) << fTrack->GetMomentumDirection().x()
579 << G4endl;
580 G4cout << " Momentum Direct - y : " << std::setw(20) << fTrack->GetMomentumDirection().y()
581 << G4endl;
582 G4cout << " Momentum Direct - z : " << std::setw(20) << fTrack->GetMomentumDirection().z()
583 << G4endl;
584#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
585 G4cout << " Kinetic Energy : "
586#else
587 G4cout << " Kinetic Energy (MeV): "
588#endif
589 << std::setw(20) << G4BestUnit(fTrack->GetKineticEnergy(), "Energy") << G4endl;
590 G4cout << " Polarization - x : " << std::setw(20) << fTrack->GetPolarization().x()
591 << G4endl;
592 G4cout << " Polarization - y : " << std::setw(20) << fTrack->GetPolarization().y()
593 << G4endl;
594 G4cout << " Polarization - z : " << std::setw(20) << fTrack->GetPolarization().z()
595 << G4endl;
596 G4cout << " Track Length : " << std::setw(20)
597 << G4BestUnit(fTrack->GetTrackLength(), "Length") << G4endl;
598 G4cout << " Track ID # : " << std::setw(20) << fTrack->GetTrackID() << G4endl;
599 G4cout << " Parent Track ID # : " << std::setw(20) << fTrack->GetParentID() << G4endl;
600 G4cout << " Next Volume : " << std::setw(20);
601 if (fTrack->GetNextVolume() != nullptr) {
602 G4cout << fTrack->GetNextVolume()->GetName() << " ";
603 }
604 else {
605 G4cout << "OutOfWorld"
606 << " ";
607 }
608 G4cout << G4endl;
609 G4cout << " Track Status : " << std::setw(20);
610 if (fTrack->GetTrackStatus() == fAlive) {
611 G4cout << " Alive";
612 }
613 else if (fTrack->GetTrackStatus() == fStopButAlive) {
614 G4cout << " StopButAlive";
615 }
616 else if (fTrack->GetTrackStatus() == fStopAndKill) {
617 G4cout << " StopAndKill";
618 }
619 else if (fTrack->GetTrackStatus() == fKillTrackAndSecondaries) {
620 G4cout << " KillTrackAndSecondaries";
621 }
622 else if (fTrack->GetTrackStatus() == fSuspend) {
623 G4cout << " Suspend";
624 }
625 else if (fTrack->GetTrackStatus() == fPostponeToNextEvent) {
626 G4cout << " PostponeToNextEvent";
627 }
628 G4cout << G4endl;
629#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
630 G4cout << " Vertex - x : " << std::setw(20)
631 << G4BestUnit(fTrack->GetVertexPosition().x(), "Length") << G4endl;
632 G4cout << " Vertex - y : " << std::setw(20)
633 << G4BestUnit(fTrack->GetVertexPosition().y(), "Length") << G4endl;
634 G4cout << " Vertex - z : " << std::setw(20)
635 << G4BestUnit(fTrack->GetVertexPosition().z(), "Length") << G4endl;
636#else
637 G4cout << " Vertex - x (mm) : " << std::setw(20)
638 << fTrack->GetVertexPosition().x() / mm << G4endl;
639 G4cout << " Vertex - y (mm) : " << std::setw(20)
640 << fTrack->GetVertexPosition().y() / mm << G4endl;
641 G4cout << " Vertex - z (mm) : " << std::setw(20)
642 << fTrack->GetVertexPosition().z() / mm << G4endl;
643#endif
644 G4cout << " Vertex - Px (MomDir): " << std::setw(20)
645 << fTrack->GetVertexMomentumDirection().x() << G4endl;
646 G4cout << " Vertex - Py (MomDir): " << std::setw(20)
647 << fTrack->GetVertexMomentumDirection().y() << G4endl;
648 G4cout << " Vertex - Pz (MomDir): " << std::setw(20)
649 << fTrack->GetVertexMomentumDirection().z() << G4endl;
650#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
651 G4cout << " Vertex - KineE : "
652#else
653 G4cout << " Vertex - KineE (MeV): "
654#endif
655 << std::setw(20) << G4BestUnit(fTrack->GetVertexKineticEnergy(), "Energy") << G4endl;
656
657 G4cout << " Creator Process : " << std::setw(20);
658 if (fTrack->GetCreatorProcess() == nullptr) {
659 G4cout << " Event Generator" << G4endl;
660 }
661 else {
662 G4cout << fTrack->GetCreatorProcess()->GetProcessName() << G4endl;
663 }
664
665 G4cout << " -----------------------------------------------" << G4endl;
666 G4cout.precision(prec);
667}
668
669///////////////////////////////////////////////
670void G4SteppingVerbose::VerboseParticleChange()
671///////////////////////////////////////////////
672{
673 if (Silent == 1) {
674 return;
675 }
676
677 G4cout << G4endl;
678 G4cout << " ++G4ParticleChange Information " << G4endl;
679 fParticleChange->DumpInfo();
680}
681
682/////////////////////////////////////////
683void G4SteppingVerbose::ShowStep() const
684////////////////////////////////////////
685{
686 if (Silent == 1) {
687 return;
688 }
689 G4String volName;
690 G4long oldprc;
691
692 // Show header
693 G4cout << G4endl;
694 G4cout << " ++G4Step Information " << G4endl;
695 oldprc = G4cout.precision(16);
696
697 // Show G4Step specific information
698 G4cout << " Address of G4Track : " << fStep->GetTrack() << G4endl;
699 G4cout << " Step Length (mm) : " << fStep->GetTrack()->GetStepLength() << G4endl;
700 G4cout << " Energy Deposit (MeV) : " << fStep->GetTotalEnergyDeposit() << G4endl;
701
702 // Show G4StepPoint specific information
703 G4cout << " -------------------------------------------------------"
704 << "----------------" << G4endl;
705 G4cout << " StepPoint Information " << std::setw(20) << "PreStep" << std::setw(20)
706 << "PostStep" << G4endl;
707 G4cout << " -------------------------------------------------------"
708 << "----------------" << G4endl;
709 G4cout << " Position - x (mm) : " << std::setw(20)
710 << fStep->GetPreStepPoint()->GetPosition().x() << std::setw(20)
711 << fStep->GetPostStepPoint()->GetPosition().x() << G4endl;
712 G4cout << " Position - y (mm) : " << std::setw(20)
713 << fStep->GetPreStepPoint()->GetPosition().y() << std::setw(20)
714 << fStep->GetPostStepPoint()->GetPosition().y() << G4endl;
715 G4cout << " Position - z (mm) : " << std::setw(20)
716 << fStep->GetPreStepPoint()->GetPosition().z() << std::setw(20)
717 << fStep->GetPostStepPoint()->GetPosition().z() << G4endl;
718 G4cout << " Global Time (ns) : " << std::setw(20)
719 << fStep->GetPreStepPoint()->GetGlobalTime() << std::setw(20)
720 << fStep->GetPostStepPoint()->GetGlobalTime() << G4endl;
721 G4cout << " Local Time (ns) : " << std::setw(20)
722 << fStep->GetPreStepPoint()->GetLocalTime() << std::setw(20)
723 << fStep->GetPostStepPoint()->GetLocalTime() << G4endl;
724 G4cout << " Proper Time (ns) : " << std::setw(20)
725 << fStep->GetPreStepPoint()->GetProperTime() << std::setw(20)
726 << fStep->GetPostStepPoint()->GetProperTime() << G4endl;
727 G4cout << " Momentum Direct - x : " << std::setw(20)
728 << fStep->GetPreStepPoint()->GetMomentumDirection().x() << std::setw(20)
729 << fStep->GetPostStepPoint()->GetMomentumDirection().x() << G4endl;
730 G4cout << " Momentum Direct - y : " << std::setw(20)
731 << fStep->GetPreStepPoint()->GetMomentumDirection().y() << std::setw(20)
732 << fStep->GetPostStepPoint()->GetMomentumDirection().y() << G4endl;
733 G4cout << " Momentum Direct - z : " << std::setw(20)
734 << fStep->GetPreStepPoint()->GetMomentumDirection().z() << std::setw(20)
735 << fStep->GetPostStepPoint()->GetMomentumDirection().z() << G4endl;
736 G4cout << " Momentum - x (MeV/c): " << std::setw(20)
737 << fStep->GetPreStepPoint()->GetMomentum().x() << std::setw(20)
738 << fStep->GetPostStepPoint()->GetMomentum().x() << G4endl;
739 G4cout << " Momentum - y (MeV/c): " << std::setw(20)
740 << fStep->GetPreStepPoint()->GetMomentum().y() << std::setw(20)
741 << fStep->GetPostStepPoint()->GetMomentum().y() << G4endl;
742 G4cout << " Momentum - z (MeV/c): " << std::setw(20)
743 << fStep->GetPreStepPoint()->GetMomentum().z() << std::setw(20)
744 << fStep->GetPostStepPoint()->GetMomentum().z() << G4endl;
745 G4cout << " Total Energy (MeV) : " << std::setw(20)
746 << fStep->GetPreStepPoint()->GetTotalEnergy() << std::setw(20)
747 << fStep->GetPostStepPoint()->GetTotalEnergy() << G4endl;
748 G4cout << " Kinetic Energy (MeV): " << std::setw(20)
749 << fStep->GetPreStepPoint()->GetKineticEnergy() << std::setw(20)
750 << fStep->GetPostStepPoint()->GetKineticEnergy() << G4endl;
751 G4cout << " Velocity (mm/ns) : " << std::setw(20)
752 << fStep->GetPreStepPoint()->GetVelocity() << std::setw(20)
753 << fStep->GetPostStepPoint()->GetVelocity() << G4endl;
754 G4cout << " Volume Name : " << std::setw(20)
755 << fStep->GetPreStepPoint()->GetPhysicalVolume()->GetName();
756 if (fStep->GetPostStepPoint()->GetPhysicalVolume() != nullptr) {
757 volName = fStep->GetPostStepPoint()->GetPhysicalVolume()->GetName();
758 }
759 else {
760 volName = "OutOfWorld";
761 }
762 G4cout << std::setw(20) << volName << G4endl;
763 G4cout << " Safety (mm) : " << std::setw(20)
764 << fStep->GetPreStepPoint()->GetSafety() << std::setw(20)
765 << fStep->GetPostStepPoint()->GetSafety() << G4endl;
766 G4cout << " Polarization - x : " << std::setw(20)
767 << fStep->GetPreStepPoint()->GetPolarization().x() << std::setw(20)
768 << fStep->GetPostStepPoint()->GetPolarization().x() << G4endl;
769 G4cout << " Polarization - y : " << std::setw(20)
770 << fStep->GetPreStepPoint()->GetPolarization().y() << std::setw(20)
771 << fStep->GetPostStepPoint()->GetPolarization().y() << G4endl;
772 G4cout << " Polarization - Z : " << std::setw(20)
773 << fStep->GetPreStepPoint()->GetPolarization().z() << std::setw(20)
774 << fStep->GetPostStepPoint()->GetPolarization().z() << G4endl;
775 G4cout << " Weight : " << std::setw(20)
776 << fStep->GetPreStepPoint()->GetWeight() << std::setw(20)
777 << fStep->GetPostStepPoint()->GetWeight() << G4endl;
778 G4cout << " Step Status : ";
779 G4StepStatus tStepStatus = fStep->GetPreStepPoint()->GetStepStatus();
780 if (tStepStatus == fGeomBoundary) {
781 G4cout << std::setw(20) << "Geom Limit";
782 }
783 else if (tStepStatus == fAlongStepDoItProc) {
784 G4cout << std::setw(20) << "AlongStep Proc.";
785 }
786 else if (tStepStatus == fPostStepDoItProc) {
787 G4cout << std::setw(20) << "PostStep Proc";
788 }
789 else if (tStepStatus == fAtRestDoItProc) {
790 G4cout << std::setw(20) << "AtRest Proc";
791 }
792 else if (tStepStatus == fUndefined) {
793 G4cout << std::setw(20) << "Undefined";
794 }
795
796 tStepStatus = fStep->GetPostStepPoint()->GetStepStatus();
797 if (tStepStatus == fGeomBoundary) {
798 G4cout << std::setw(20) << "Geom Limit";
799 }
800 else if (tStepStatus == fAlongStepDoItProc) {
801 G4cout << std::setw(20) << "AlongStep Proc.";
802 }
803 else if (tStepStatus == fPostStepDoItProc) {
804 G4cout << std::setw(20) << "PostStep Proc";
805 }
806 else if (tStepStatus == fAtRestDoItProc) {
807 G4cout << std::setw(20) << "AtRest Proc";
808 }
809 else if (tStepStatus == fUndefined) {
810 G4cout << std::setw(20) << "Undefined";
811 }
812
813 G4cout << G4endl;
814 G4cout << " Process defined Step: ";
815 if (fStep->GetPreStepPoint()->GetProcessDefinedStep() == nullptr) {
816 G4cout << std::setw(20) << "Undefined";
817 }
818 else {
819 G4cout << std::setw(20) << fStep->GetPreStepPoint()->GetProcessDefinedStep()->GetProcessName();
820 }
821 if (fStep->GetPostStepPoint()->GetProcessDefinedStep() == nullptr) {
822 G4cout << std::setw(20) << "Undefined";
823 }
824 else {
825 G4cout << std::setw(20) << fStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName();
826 }
827 G4cout.precision(oldprc);
828
829 G4cout << G4endl;
830 G4cout << " -------------------------------------------------------"
831 << "----------------" << G4endl;
832}
833
834//////////////////////////////////////////////////
835void G4SteppingVerbose::UseBestUnit(G4int prec)
836//////////////////////////////////////////////////
837{
838 useBestUnitPrecision = prec;
839}
840
841//////////////////////////////////////////////////
842G4int G4SteppingVerbose::BestUnitPrecision()
843//////////////////////////////////////////////////
844{
845 return useBestUnitPrecision;
846}
StronglyForced
@ StronglyForced
Definition G4ForceCondition.hh:55
NotForced
@ NotForced
Definition G4ForceCondition.hh:47
Conditionally
@ Conditionally
Definition G4ForceCondition.hh:49
ExclusivelyForced
@ ExclusivelyForced
Definition G4ForceCondition.hh:52
Forced
@ Forced
Definition G4ForceCondition.hh:44
CandidateForSelection
@ CandidateForSelection
Definition G4GPILSelection.hh:42
NotCandidateForSelection
@ NotCandidateForSelection
Definition G4GPILSelection.hh:47
G4StepStatus
G4StepStatus
Definition G4StepStatus.hh:40
fGeomBoundary
@ fGeomBoundary
Definition G4StepStatus.hh:43
fUndefined
@ fUndefined
Definition G4StepStatus.hh:55
fPostStepDoItProc
@ fPostStepDoItProc
Definition G4StepStatus.hh:49
fAtRestDoItProc
@ fAtRestDoItProc
Definition G4StepStatus.hh:45
fAlongStepDoItProc
@ fAlongStepDoItProc
Definition G4StepStatus.hh:47
G4BestUnit
#define G4BestUnit(a, b)
Definition G4SteppingVerbose.cc:46
fKillTrackAndSecondaries
@ fKillTrackAndSecondaries
Definition G4TrackStatus.hh:48
fSuspend
@ fSuspend
Definition G4TrackStatus.hh:50
fAlive
@ fAlive
Definition G4TrackStatus.hh:42
fStopAndKill
@ fStopAndKill
Definition G4TrackStatus.hh:46
fStopButAlive
@ fStopButAlive
Definition G4TrackStatus.hh:44
fPostponeToNextEvent
@ fPostponeToNextEvent
Definition G4TrackStatus.hh:56
G4long
long G4long
Definition G4Types.hh:87
G4int
int G4int
Definition G4Types.hh:85
G4endl
#define G4endl
Definition G4ios.hh:67
G4cout
G4GLOB_DLL std::ostream G4cout
CLHEP::Hep3Vector::z
double z() const
CLHEP::Hep3Vector::x
double x() const
CLHEP::Hep3Vector::y
double y() const
G4StepPoint::GetTotalEnergy
G4double GetTotalEnergy() const
G4StepPoint::GetStepStatus
G4StepStatus GetStepStatus() const
G4StepPoint::GetVelocity
G4double GetVelocity() const
G4StepPoint::GetProperTime
G4double GetProperTime() const
G4StepPoint::GetGlobalTime
G4double GetGlobalTime() const
G4StepPoint::GetSafety
G4double GetSafety() const
G4StepPoint::GetProcessDefinedStep
const G4VProcess * GetProcessDefinedStep() const
G4StepPoint::GetMomentum
G4ThreeVector GetMomentum() const
G4StepPoint::GetPosition
const G4ThreeVector & GetPosition() const
G4StepPoint::GetMomentumDirection
const G4ThreeVector & GetMomentumDirection() const
G4StepPoint::GetLocalTime
G4double GetLocalTime() const
G4StepPoint::GetPhysicalVolume
G4VPhysicalVolume * GetPhysicalVolume() const
G4StepPoint::GetPolarization
const G4ThreeVector & GetPolarization() const
G4StepPoint::GetKineticEnergy
G4double GetKineticEnergy() const
G4StepPoint::GetWeight
G4double GetWeight() const
G4Step::GetTrack
G4Track * GetTrack() const
G4Step::GetPreStepPoint
G4StepPoint * GetPreStepPoint() const
G4Step::GetStepLength
G4double GetStepLength() const
G4Step::GetTotalEnergyDeposit
G4double GetTotalEnergyDeposit() const
G4Step::GetPostStepPoint
G4StepPoint * GetPostStepPoint() const
G4SteppingVerbose::NewStep
void NewStep() override
Definition G4SteppingVerbose.cc:52
G4SteppingVerbose::AlongStepDoItAllDone
void AlongStepDoItAllDone() override
Definition G4SteppingVerbose.cc:111
G4SteppingVerbose::VerboseParticleChange
void VerboseParticleChange() override
Definition G4SteppingVerbose.cc:670
G4SteppingVerbose::ShowStep
virtual void ShowStep() const
Definition G4SteppingVerbose.cc:683
G4SteppingVerbose::DPSLAlongStep
void DPSLAlongStep() override
Definition G4SteppingVerbose.cc:371
G4SteppingVerbose::TrackingStarted
void TrackingStarted() override
Definition G4SteppingVerbose.cc:396
G4SteppingVerbose::UseBestUnit
static void UseBestUnit(G4int prec=4)
Definition G4SteppingVerbose.cc:835
G4SteppingVerbose::PostStepDoItOneByOne
void PostStepDoItOneByOne() override
Definition G4SteppingVerbose.cc:496
G4SteppingVerbose::StepInfo
void StepInfo() override
Definition G4SteppingVerbose.cc:213
G4SteppingVerbose::DPSLUserLimit
void DPSLUserLimit() override
Definition G4SteppingVerbose.cc:324
G4SteppingVerbose::AtRestDoItInvoked
void AtRestDoItInvoked() override
Definition G4SteppingVerbose.cc:57
G4SteppingVerbose::DPSLStarted
void DPSLStarted() override
Definition G4SteppingVerbose.cc:310
G4SteppingVerbose::BestUnitPrecision
static G4int BestUnitPrecision()
Definition G4SteppingVerbose.cc:842
G4SteppingVerbose::VerboseTrack
void VerboseTrack() override
Definition G4SteppingVerbose.cc:536
G4SteppingVerbose::DPSLPostStep
void DPSLPostStep() override
Definition G4SteppingVerbose.cc:341
G4SteppingVerbose::AlongStepDoItOneByOne
void AlongStepDoItOneByOne() override
Definition G4SteppingVerbose.cc:453
G4SteppingVerbose::PostStepDoItAllDone
void PostStepDoItAllDone() override
Definition G4SteppingVerbose.cc:155
G4Track::GetTrackStatus
G4TrackStatus GetTrackStatus() const
G4Track::GetVertexKineticEnergy
G4double GetVertexKineticEnergy() const
G4Track::GetTrackID
G4int GetTrackID() const
G4Track::GetCreatorProcess
const G4VProcess * GetCreatorProcess() const
G4Track::GetNextVolume
G4VPhysicalVolume * GetNextVolume() const
G4Track::GetPosition
const G4ThreeVector & GetPosition() const
G4Track::GetTrackLength
G4double GetTrackLength() const
G4Track::GetVertexMomentumDirection
const G4ThreeVector & GetVertexMomentumDirection() const
G4Track::GetGlobalTime
G4double GetGlobalTime() const
G4Track::GetCurrentStepNumber
G4int GetCurrentStepNumber() const
G4Track::GetVertexPosition
const G4ThreeVector & GetVertexPosition() const
G4Track::GetLocalTime
G4double GetLocalTime() const
G4Track::GetMomentumDirection
const G4ThreeVector & GetMomentumDirection() const
G4Track::GetKineticEnergy
G4double GetKineticEnergy() const
G4Track::GetPolarization
const G4ThreeVector & GetPolarization() const
G4Track::GetStepLength
G4double GetStepLength() const
G4Track::GetParentID
G4int GetParentID() const
G4VParticleChange::DumpInfo
virtual void DumpInfo() const
Definition G4VParticleChange.cc:133
G4VPhysicalVolume::GetName
const G4String & GetName() const
G4VProcess::GetProcessName
const G4String & GetProcessName() const
Definition G4VProcess.hh:386
G4VSteppingVerbose::fCondition
G4ForceCondition fCondition
Definition G4VSteppingVerbose.hh:181
G4VSteppingVerbose::fGPILSelection
G4GPILSelection fGPILSelection
Definition G4VSteppingVerbose.hh:182
G4VSteppingVerbose::fParticleChange
G4VParticleChange * fParticleChange
Definition G4VSteppingVerbose.hh:125
G4VSteppingVerbose::fSelectedPostStepDoItVector
G4SelectedPostStepDoItVector * fSelectedPostStepDoItVector
Definition G4VSteppingVerbose.hh:172
G4VSteppingVerbose::fSelectedAtRestDoItVector
G4SelectedAtRestDoItVector * fSelectedAtRestDoItVector
Definition G4VSteppingVerbose.hh:170
G4VSteppingVerbose::SilentStepInfo
static G4TRACKING_DLL G4ThreadLocal G4int SilentStepInfo
Definition G4VSteppingVerbose.hh:107
G4VSteppingVerbose::Silent
static G4TRACKING_DLL G4ThreadLocal G4int Silent
Definition G4VSteppingVerbose.hh:106
G4VSteppingVerbose::fSecondary
G4TrackVector * fSecondary
Definition G4VSteppingVerbose.hh:127