Geant4 10.7.0
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#include "G4SteppingManager.hh"
36#include "G4SystemOfUnits.hh"
37#include "G4VSensitiveDetector.hh" // Include from 'hits/digi'
38#include "G4StepStatus.hh" // Include from 'tracking'
39
40// #define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
41
42#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
43#include "G4UnitsTable.hh"
44#else
45#define G4BestUnit(a,b) a
46#endif
47
48//////////////////////////////////////////////////
49G4SteppingVerbose::G4SteppingVerbose()
50//////////////////////////////////////////////////
51{
52#ifdef G4_TRACKING_DEBUG
53 G4cout << "G4SteppingVerbose has instantiated" << G4endl;
54#endif
55}
56
57//////////////////////////////////////////////////
58G4SteppingVerbose::~G4SteppingVerbose()
59//////////////////////////////////////////////////
60{
61}
62
63//////////////////////////////////////////////////
64void G4SteppingVerbose::NewStep()
65//////////////////////////////////////////////////
66{
67}
68
69//////////////////////////////////////////////////
70void G4SteppingVerbose::AtRestDoItInvoked()
71//////////////////////////////////////////////////
72{
73 if(Silent==1) { return; }
74
75 G4VProcess* ptProcManager;
76 CopyState();
77
78 if(verboseLevel >= 3)
79 {
80 G4int npt=0;
81 G4cout << " **List of AtRestDoIt invoked:" << G4endl;
82 for(std::size_t np=0; np<MAXofAtRestLoops; ++np)
83 {
84 std::size_t npGPIL = MAXofAtRestLoops-np-1;
85 if( (*fSelectedAtRestDoItVector)[npGPIL] == 2 )
86 {
87 ++npt;
88 ptProcManager = (*fAtRestDoItVector)[np];
89 G4cout << " # " << npt << " : "
90 << ptProcManager->GetProcessName()
91 << " (Forced)" << G4endl;
92 }
93 else if ( (*fSelectedAtRestDoItVector)[npGPIL] == 1 )
94 {
95 ++npt;
96 ptProcManager = (*fAtRestDoItVector)[np];
97 G4cout << " # " << npt << " : " << ptProcManager->GetProcessName()
98 << G4endl;
99 }
100 }
101
102 G4cout << " Generated secondries # : " << fN2ndariesAtRestDoIt << G4endl;
103
104 if( fN2ndariesAtRestDoIt > 0 )
105 {
106 G4cout << " -- List of secondaries generated : "
107 << "(x,y,z,kE,t,PID) --" << G4endl;
108 for( std::size_t lp1=(*fSecondary).size()-fN2ndariesAtRestDoIt;
109 lp1<(*fSecondary).size(); ++lp1)
110 {
111 G4cout << " "
112 << std::setw( 9)
113 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(),"Length")
114 << " " << std::setw( 9)
115 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(),"Length")
116 << " " << std::setw( 9)
117 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(),"Length")
118 << " " << std::setw( 9)
119 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(),"Energy")
120 << " " << std::setw( 9)
121 << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(),"Time")
122 << " " << std::setw(18)
123 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
124 << G4endl;
125 }
126 }
127 }
128
129 if( verboseLevel >= 4 )
130 {
131 ShowStep();
132 G4cout << G4endl;
133 }
134}
135
136/////////////////////////////////////////////////////
137void G4SteppingVerbose::AlongStepDoItAllDone()
138/////////////////////////////////////////////////////
139{
140 if(Silent==1){ return; }
141
142 G4VProcess* ptProcManager;
143
144 CopyState();
145
146 if(verboseLevel >= 3)
147 {
148 G4cout << G4endl;
149 G4cout << " >>AlongStepDoIt (after all invocations):" << G4endl;
150 G4cout << " ++List of invoked processes " << G4endl;
151
152 for(std::size_t ci=0; ci<MAXofAlongStepLoops; ++ci)
153 {
154 ptProcManager = (*fAlongStepDoItVector)(ci);
155 G4cout << " " << ci+1 << ") ";
156 if(ptProcManager != nullptr)
157 {
158 G4cout << ptProcManager->GetProcessName() << G4endl;
159 }
160 }
161
162 ShowStep();
163 G4cout << G4endl;
164 G4cout << " ++List of secondaries generated "
165 << "(x,y,z,kE,t,PID):"
166 << " No. of secondaries = "
167 << (*fSecondary).size() << G4endl;
168
169 if((*fSecondary).size()>0)
170 {
171 for(std::size_t lp1=0; lp1<(*fSecondary).size(); ++lp1)
172 {
173 G4cout << " "
174 << std::setw( 9)
175 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(),"Length")
176 << " " << std::setw( 9)
177 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(),"Length")
178 << " " << std::setw( 9)
179 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(),"Length")
180 << " " << std::setw( 9)
181 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(),"Energy")
182 << " " << std::setw( 9)
183 << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(),"Time")
184 << " " << std::setw(18)
185 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
186 << G4endl;
187 }
188 }
189 }
190}
191
192////////////////////////////////////////////////////
193void G4SteppingVerbose::PostStepDoItAllDone()
194////////////////////////////////////////////////////
195{
196 if(Silent==1) { return; }
197
198 G4VProcess* ptProcManager;
199
200 CopyState();
201
202 if( (fStepStatus == fPostStepDoItProc) |
203 (fCondition == Forced) |
204 (fCondition == Conditionally) |
205 (fCondition == ExclusivelyForced) |
206 (fCondition == StronglyForced) )
207 {
208 if(verboseLevel >= 3)
209 {
210 G4int npt=0;
211 G4cout << G4endl;
212 G4cout << " **PostStepDoIt (after all invocations):" << G4endl;
213 G4cout << " ++List of invoked processes " << G4endl;
214
215 for(std::size_t np=0; np<MAXofPostStepLoops; ++np)
216 {
217 std::size_t npGPIL = MAXofPostStepLoops-np-1;
218 if( (*fSelectedPostStepDoItVector)[npGPIL] == 2)
219 {
220 ++npt;
221 ptProcManager = (*fPostStepDoItVector)[np];
222 G4cout << " " << npt << ") "
223 << ptProcManager->GetProcessName()
224 << " (Forced)" << G4endl;
225 }
226 else if ( (*fSelectedPostStepDoItVector)[npGPIL] == 1)
227 {
228 ++npt;
229 ptProcManager = (*fPostStepDoItVector)[np];
230 G4cout << " " << npt << ") " << ptProcManager->GetProcessName()
231 << G4endl;
232 }
233 }
234
235 ShowStep();
236 G4cout << G4endl;
237 G4cout << " ++List of secondaries generated "
238 << "(x,y,z,kE,t,PID):"
239 << " No. of secodaries = "
240 << (*fSecondary).size() << G4endl;
241 G4cout << " [Note]Secondaries from AlongStepDoIt included."
242 << G4endl;
243
244 if((*fSecondary).size()>0)
245 {
246 for(std::size_t lp1=0; lp1<(*fSecondary).size(); ++lp1)
247 {
248 G4cout << " "
249 << std::setw( 9)
250 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length")
251 << " " << std::setw( 9)
252 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length")
253 << " " << std::setw( 9)
254 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length")
255 << " " << std::setw( 9)
256 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy")
257 << " " << std::setw( 9)
258 << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time")
259 << " " << std::setw(18)
260 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
261 << G4endl;
262 }
263 }
264 }
265 }
266}
267
268/////////////////////////////////////////
269void G4SteppingVerbose::StepInfo()
270/////////////////////////////////////////
271{
272 if(Silent==1) { return; }
273 if(SilentStepInfo==1) { return; }
274
275 CopyState();
276 G4cout.precision(16);
277 G4int prec = G4cout.precision(3);
278
279 if( verboseLevel >= 1 )
280 {
281 if( verboseLevel >= 4 ) VerboseTrack();
282 if( verboseLevel >= 3 )
283 {
284 G4cout << G4endl;
285#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
286 G4cout << std::setw( 5) << "#Step#" << " "
287 << std::setw( 8) << "X" << " "
288 << std::setw( 8) << "Y" << " "
289 << std::setw( 8) << "Z" << " "
290 << std::setw( 9) << "KineE" << " "
291 << std::setw( 8) << "dE" << " "
292 << std::setw(12) << "StepLeng" << " "
293 << std::setw(12) << "TrackLeng" << " "
294 << std::setw(12) << "NextVolume" << " "
295 << std::setw( 8) << "ProcName" << G4endl;
296#else
297 G4cout << std::setw( 5) << "#Step#" << " "
298 << std::setw( 8) << "X(mm)" << " "
299 << std::setw( 8) << "Y(mm)" << " "
300 << std::setw( 8) << "Z(mm)" << " "
301 << std::setw( 9) << "KinE(MeV)" << " "
302 << std::setw( 8) << "dE(MeV)" << " "
303 << std::setw( 8) << "StepLeng" << " "
304 << std::setw( 9) << "TrackLeng" << " "
305 << std::setw(11) << "NextVolume" << " "
306 << std::setw( 8) << "ProcName" << G4endl;
307#endif
308 }
309 G4cout << std::setw( 5) << fTrack->GetCurrentStepNumber() << " "
310 << std::setw( 8)
311 << G4BestUnit(fTrack->GetPosition().x(), "Length") << " "
312 << std::setw( 8)
313 << G4BestUnit(fTrack->GetPosition().y(), "Length") << " "
314 << std::setw( 8)
315 << G4BestUnit(fTrack->GetPosition().z(), "Length") << " "
316 << std::setw( 9)
317 << G4BestUnit(fTrack->GetKineticEnergy(), "Energy") << " "
318 << std::setw( 8)
319 << G4BestUnit(fStep->GetTotalEnergyDeposit(), "Energy") << " "
320 << std::setw( 8)
321 << G4BestUnit(fStep->GetStepLength(), "Length") << " "
322 << std::setw( 9)
323 << G4BestUnit(fTrack->GetTrackLength(), "Length") << " ";
324
325 if( fTrack->GetNextVolume() != 0 )
326 {
327 G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
328 }
329 else
330 {
331 G4cout << std::setw(11) << "OutOfWorld" << " ";
332 }
333 if(fStep->GetPostStepPoint()->GetProcessDefinedStep() != 0)
334 {
335 G4cout << fStep->GetPostStepPoint()
336 ->GetProcessDefinedStep()->GetProcessName();
337 }
338 else
339 {
340 G4cout << "User Limit";
341 }
342 G4cout << G4endl;
343 if( verboseLevel == 2 )
344 {
345 G4int tN2ndariesTot = fN2ndariesAtRestDoIt + fN2ndariesAlongStepDoIt
346 + fN2ndariesPostStepDoIt;
347 if(tN2ndariesTot>0)
348 {
349 G4cout << " :----- List of 2ndaries - "
350 << "#SpawnInStep=" << std::setw(3) << tN2ndariesTot
351 << "(Rest=" << std::setw(2) << fN2ndariesAtRestDoIt
352 << ",Along=" << std::setw(2) << fN2ndariesAlongStepDoIt
353 << ",Post=" << std::setw(2) << fN2ndariesPostStepDoIt
354 << "), "
355 << "#SpawnTotal=" << std::setw(3) << (*fSecondary).size()
356 << " ---------------"
357 << G4endl;
358
359 for(std::size_t lp1=(*fSecondary).size()-tN2ndariesTot;
360 lp1<(*fSecondary).size(); ++lp1)
361 {
362 G4cout << " : "
363 << std::setw( 9)
364 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length")
365 << " " << std::setw( 9)
366 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length")
367 << " " << std::setw( 9)
368 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length")
369 << " " << std::setw( 9)
370 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy")
371 << " " << std::setw(18)
372 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
373 << G4endl;
374 }
375 G4cout << " :-----------------------------"
376 << "----------------------------------"
377 << "-- EndOf2ndaries Info ---------------" << G4endl;
378 }
379 }
380 }
381 G4cout.precision(prec);
382}
383
384////////////////////////////////////////////
385void G4SteppingVerbose::DPSLStarted()
386////////////////////////////////////////////
387{
388 if(Silent==1){ return; }
389 CopyState();
390
391 if( verboseLevel > 5 )
392 {
393 G4cout << G4endl
394 << " >>DefinePhysicalStepLength (List of proposed StepLengths): "
395 << G4endl;
396 }
397}
398
399//////////////////////////////////////////////
400void G4SteppingVerbose::DPSLUserLimit()
401//////////////////////////////////////////////
402{
403 if(Silent==1){ return; }
404 CopyState();
405
406 if( verboseLevel > 5 )
407 {
408 G4cout << G4endl << G4endl;
409 G4cout << "=== Defined Physical Step Length (DPSL)" << G4endl;
410 G4cout << " ++ProposedStep(UserLimit) = "
411 << std::setw( 9) << physIntLength
412 << " : ProcName = User defined maximum allowed Step" << G4endl;
413 }
414}
415
416/////////////////////////////////////////////
417void G4SteppingVerbose::DPSLPostStep()
418/////////////////////////////////////////////
419{
420 if(Silent==1){ return; }
421 CopyState();
422
423 if( verboseLevel > 5 )
424 {
425 G4cout << " ++ProposedStep(PostStep ) = "
426 << std::setw( 9) << physIntLength
427 << " : ProcName = " << fCurrentProcess->GetProcessName() << " (";
428 if(fCondition==ExclusivelyForced)
429 {
430 G4cout << "ExclusivelyForced)" << G4endl;
431 }
432 else if(fCondition==StronglyForced)
433 {
434 G4cout << "StronglyForced)" << G4endl;
435 }
436 else if(fCondition==Conditionally)
437 {
438 G4cout << "Conditionally)" << G4endl;
439 }
440 else if(fCondition==Forced)
441 {
442 G4cout << "Forced)" << G4endl;
443 }
444 else
445 {
446 G4cout << "No ForceCondition)" << G4endl;
447 }
448 }
449}
450
451/////////////////////////////////////////////
452void G4SteppingVerbose::DPSLAlongStep()
453/////////////////////////////////////////////
454{
455 if(Silent==1){ return; }
456 CopyState();
457
458 if( verboseLevel > 5 )
459 {
460 G4cout << " ++ProposedStep(AlongStep) = "
461 << std::setw( 9) << G4BestUnit(physIntLength , "Length")
462 << " : ProcName = "
463 << fCurrentProcess->GetProcessName()
464 << " (";
465 if(fGPILSelection==CandidateForSelection)
466 {
467 G4cout << "CandidateForSelection)" << G4endl;
468 }
469 else if(fGPILSelection==NotCandidateForSelection)
470 {
471 G4cout << "NotCandidateForSelection)" << G4endl;
472 }
473 else
474 {
475 G4cout << "?!?)" << G4endl;
476 }
477 }
478}
479
480////////////////////////////////////////////////
481void G4SteppingVerbose::TrackingStarted()
482////////////////////////////////////////////////
483{
484 if(Silent==1){ return; }
485
486 CopyState();
487
488 G4int prec = G4cout.precision(3);
489 if( verboseLevel > 0 )
490 {
491#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
492 G4cout << std::setw( 5) << "Step#" << " "
493 << std::setw( 8) << "X" << " "
494 << std::setw( 8) << "Y" << " "
495 << std::setw( 8) << "Z" << " "
496 << std::setw( 9) << "KineE" << " "
497 << std::setw( 8) << "dE" << " "
498 << std::setw(12) << "StepLeng" << " "
499 << std::setw(12) << "TrackLeng" << " "
500 << std::setw(12) << "NextVolume" << " "
501 << std::setw( 8) << "ProcName" << G4endl;
502#else
503 G4cout << std::setw( 5) << "Step#" << " "
504 << std::setw( 8) << "X(mm)" << " "
505 << std::setw( 8) << "Y(mm)" << " "
506 << std::setw( 8) << "Z(mm)" << " "
507 << std::setw( 9) << "KinE(MeV)" << " "
508 << std::setw( 8) << "dE(MeV)" << " "
509 << std::setw( 8) << "StepLeng" << " "
510 << std::setw( 9) << "TrackLeng" << " "
511 << std::setw(11) << "NextVolume" << " "
512 << std::setw( 8) << "ProcName" << G4endl;
513#endif
514
515 G4cout << std::setw( 5) << fTrack->GetCurrentStepNumber() << " "
516 << std::setw( 8)
517 << G4BestUnit(fTrack->GetPosition().x(),"Length") << " "
518 << std::setw( 8)
519 << G4BestUnit(fTrack->GetPosition().y(),"Length") << " "
520 << std::setw( 8)
521 << G4BestUnit(fTrack->GetPosition().z(),"Length") << " "
522 << std::setw( 9)
523 << G4BestUnit(fTrack->GetKineticEnergy(),"Energy") << " "
524 << std::setw( 8)
525 << G4BestUnit(fStep->GetTotalEnergyDeposit(),"Energy") << " "
526 << std::setw( 8)
527 << G4BestUnit(fStep->GetStepLength(),"Length") << " "
528 << std::setw( 9)
529 << G4BestUnit(fTrack->GetTrackLength(),"Length") << " ";
530
531 if(fTrack->GetNextVolume())
532 {
533 G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
534 }
535 else
536 {
537 G4cout << std::setw(11) << "OutOfWorld" << " ";
538 }
539 G4cout << "initStep" << G4endl;
540 }
541 G4cout.precision(prec);
542}
543
544//////////////////////////////////////////////////////
545void G4SteppingVerbose::AlongStepDoItOneByOne()
546//////////////////////////////////////////////////////
547{
548 if(Silent==1){ return; }
549
550 CopyState();
551
552 if(verboseLevel >= 4)
553 {
554 G4cout << G4endl;
555 G4cout << " >>AlongStepDoIt (process by process): "
556 << " Process Name = "
557 << fCurrentProcess->GetProcessName() << G4endl;
558
559 ShowStep();
560 G4cout << " "
561 << "!Note! Safety of PostStep is only valid "
562 << "after all DoIt invocations."
563 << G4endl;
564
565 VerboseParticleChange();
566 G4cout << G4endl;
567
568 G4cout << " ++List of secondaries generated "
569 << "(x,y,z,kE,t,PID):"
570 << " No. of secodaries = "
571 << fN2ndariesAlongStepDoIt << G4endl;
572
573 if(fN2ndariesAlongStepDoIt>0)
574 {
575 for(std::size_t lp1=(*fSecondary).size()-fN2ndariesAlongStepDoIt;
576 lp1<(*fSecondary).size(); ++lp1)
577 {
578 G4cout << " "
579 << std::setw( 9)
580 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length")
581 << " " << std::setw( 9)
582 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length")
583 << " " << std::setw( 9)
584 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length")
585 << " " << std::setw( 9)
586 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy")
587 << " " << std::setw( 9)
588 << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time")
589 << " " << std::setw(18)
590 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
591 << G4endl;
592 }
593 }
594 }
595}
596
597//////////////////////////////////////////////////////
598void G4SteppingVerbose::PostStepDoItOneByOne()
599//////////////////////////////////////////////////////
600{
601 if(Silent==1) { return; }
602
603 CopyState();
604
605 if(verboseLevel >= 4)
606 {
607 G4cout << G4endl;
608 G4cout << " >>PostStepDoIt (process by process): "
609 << " Process Name = "
610 << fCurrentProcess->GetProcessName() << G4endl;
611
612 ShowStep();
613 G4cout << G4endl;
614 VerboseParticleChange();
615 G4cout << G4endl;
616
617 G4cout << " ++List of secondaries generated "
618 << "(x,y,z,kE,t,PID):"
619 << " No. of secodaries = "
620 << fN2ndariesPostStepDoIt << G4endl;
621
622 if(fN2ndariesPostStepDoIt>0)
623 {
624 for(std::size_t lp1=(*fSecondary).size()-fN2ndariesPostStepDoIt;
625 lp1<(*fSecondary).size(); ++lp1)
626 {
627 G4cout << " "
628 << std::setw( 9)
629 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length")
630 << " " << std::setw( 9)
631 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length")
632 << " " << std::setw( 9)
633 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length")
634 << " " << std::setw( 9)
635 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy")
636 << " " << std::setw( 9)
637 << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time")
638 << " " << std::setw(18)
639 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
640 << G4endl;
641 }
642 }
643 }
644}
645
646//////////////////////////////////////
647void G4SteppingVerbose::VerboseTrack()
648//////////////////////////////////////
649{
650 if(Silent==1){ return; }
651
652 CopyState();
653
654 G4cout << G4endl;
655 G4cout << " ++G4Track Information " << G4endl;
656 G4int prec = G4cout.precision(3);
657
658
659 G4cout << " -----------------------------------------------"
660 << G4endl;
661 G4cout << " G4Track Information " << std::setw(20) << G4endl;
662 G4cout << " -----------------------------------------------"
663 << G4endl;
664
665 G4cout << " Step number : "
666 << std::setw(20) << fTrack->GetCurrentStepNumber()
667 << G4endl;
668#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
669 G4cout << " Position - x : "
670 << std::setw(20) << G4BestUnit(fTrack->GetPosition().x(), "Length")
671 << G4endl;
672 G4cout << " Position - y : "
673 << std::setw(20) << G4BestUnit(fTrack->GetPosition().y(), "Length")
674 << G4endl;
675 G4cout << " Position - z : "
676 << std::setw(20) << G4BestUnit(fTrack->GetPosition().z(), "Length")
677 << G4endl;
678 G4cout << " Global Time : "
679 << std::setw(20) << G4BestUnit(fTrack->GetGlobalTime(), "Time")
680 << G4endl;
681 G4cout << " Local Time : "
682 << std::setw(20) << G4BestUnit(fTrack->GetLocalTime(), "Time")
683 << G4endl;
684#else
685 G4cout << " Position - x (mm) : "
686 << std::setw(20) << fTrack->GetPosition().x() /mm
687 << G4endl;
688 G4cout << " Position - y (mm) : "
689 << std::setw(20) << fTrack->GetPosition().y() /mm
690 << G4endl;
691 G4cout << " Position - z (mm) : "
692 << std::setw(20) << fTrack->GetPosition().z() /mm
693 << G4endl;
694 G4cout << " Global Time (ns) : "
695 << std::setw(20) << fTrack->GetGlobalTime() /ns
696 << G4endl;
697 G4cout << " Local Time (ns) : "
698 << std::setw(20) << fTrack->GetLocalTime() /ns
699 << G4endl;
700#endif
701 G4cout << " Momentum Direct - x : "
702 << std::setw(20) << fTrack->GetMomentumDirection().x()
703 << G4endl;
704 G4cout << " Momentum Direct - y : "
705 << std::setw(20) << fTrack->GetMomentumDirection().y()
706 << G4endl;
707 G4cout << " Momentum Direct - z : "
708 << std::setw(20) << fTrack->GetMomentumDirection().z()
709 << G4endl;
710#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
711 G4cout << " Kinetic Energy : "
712#else
713 G4cout << " Kinetic Energy (MeV): "
714#endif
715 << std::setw(20) << G4BestUnit(fTrack->GetKineticEnergy(), "Energy")
716 << G4endl;
717 G4cout << " Polarization - x : "
718 << std::setw(20) << fTrack->GetPolarization().x()
719 << G4endl;
720 G4cout << " Polarization - y : "
721 << std::setw(20) << fTrack->GetPolarization().y()
722 << G4endl;
723 G4cout << " Polarization - z : "
724 << std::setw(20) << fTrack->GetPolarization().z()
725 << G4endl;
726 G4cout << " Track Length : "
727 << std::setw(20) << G4BestUnit(fTrack->GetTrackLength(), "Length")
728 << G4endl;
729 G4cout << " Track ID # : "
730 << std::setw(20) << fTrack->GetTrackID()
731 << G4endl;
732 G4cout << " Parent Track ID # : "
733 << std::setw(20) << fTrack->GetParentID()
734 << G4endl;
735 G4cout << " Next Volume : "
736 << std::setw(20);
737 if( fTrack->GetNextVolume() != 0 )
738 {
739 G4cout << fTrack->GetNextVolume()->GetName() << " ";
740 }
741 else
742 {
743 G4cout << "OutOfWorld" << " ";
744 }
745 G4cout << G4endl;
746 G4cout << " Track Status : "
747 << std::setw(20);
748 if( fTrack->GetTrackStatus() == fAlive )
749 {
750 G4cout << " Alive";
751 }
752 else if( fTrack->GetTrackStatus() == fStopButAlive )
753 {
754 G4cout << " StopButAlive";
755 }
756 else if( fTrack->GetTrackStatus() == fStopAndKill )
757 {
758 G4cout << " StopAndKill";
759 }
760 else if( fTrack->GetTrackStatus() == fKillTrackAndSecondaries )
761 {
762 G4cout << " KillTrackAndSecondaries";
763 }
764 else if( fTrack->GetTrackStatus() == fSuspend )
765 {
766 G4cout << " Suspend";
767 }
768 else if( fTrack->GetTrackStatus() == fPostponeToNextEvent )
769 {
770 G4cout << " PostponeToNextEvent";
771 }
772 G4cout << G4endl;
773#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
774 G4cout << " Vertex - x : "
775 << std::setw(20)
776 << G4BestUnit(fTrack->GetVertexPosition().x(),"Length")
777 << G4endl;
778 G4cout << " Vertex - y : "
779 << std::setw(20)
780 << G4BestUnit(fTrack->GetVertexPosition().y(),"Length")
781 << G4endl;
782 G4cout << " Vertex - z : "
783 << std::setw(20)
784 << G4BestUnit(fTrack->GetVertexPosition().z(),"Length")
785 << G4endl;
786#else
787 G4cout << " Vertex - x (mm) : "
788 << std::setw(20) << fTrack->GetVertexPosition().x()/mm
789 << G4endl;
790 G4cout << " Vertex - y (mm) : "
791 << std::setw(20) << fTrack->GetVertexPosition().y()/mm
792 << G4endl;
793 G4cout << " Vertex - z (mm) : "
794 << std::setw(20) << fTrack->GetVertexPosition().z()/mm
795 << G4endl;
796#endif
797 G4cout << " Vertex - Px (MomDir): "
798 << std::setw(20) << fTrack->GetVertexMomentumDirection().x()
799 << G4endl;
800 G4cout << " Vertex - Py (MomDir): "
801 << std::setw(20) << fTrack->GetVertexMomentumDirection().y()
802 << G4endl;
803 G4cout << " Vertex - Pz (MomDir): "
804 << std::setw(20) << fTrack->GetVertexMomentumDirection().z()
805 << G4endl;
806#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
807 G4cout << " Vertex - KineE : "
808#else
809 G4cout << " Vertex - KineE (MeV): "
810#endif
811 << std::setw(20)
812 << G4BestUnit(fTrack->GetVertexKineticEnergy(),"Energy")
813 << G4endl;
814
815 G4cout << " Creator Process : "
816 << std::setw(20);
817 if( fTrack->GetCreatorProcess() == 0)
818 {
819 G4cout << " Event Generator" << G4endl;
820 }
821 else
822 {
823 G4cout << fTrack->GetCreatorProcess()->GetProcessName() << G4endl;
824 }
825
826 G4cout << " -----------------------------------------------"
827 << G4endl;
828 G4cout.precision(prec);
829}
830
831///////////////////////////////////////////////
832void G4SteppingVerbose::VerboseParticleChange()
833///////////////////////////////////////////////
834{
835 if(Silent==1) { return; }
836
837 G4cout << G4endl;
838 G4cout << " ++G4ParticleChange Information " << G4endl;
839 fParticleChange->DumpInfo();
840}
841
842/////////////////////////////////////////
843void G4SteppingVerbose::ShowStep() const
844////////////////////////////////////////
845{
846 if(Silent==1){ return; }
847 G4String volName;
848 G4int oldprc;
849
850 // Show header
851 G4cout << G4endl;
852 G4cout << " ++G4Step Information " << G4endl;
853 oldprc = G4cout.precision(16);
854
855 // Show G4Step specific information
856 G4cout << " Address of G4Track : "
857 << fStep->GetTrack() << G4endl;
858 G4cout << " Step Length (mm) : "
859 << fStep->GetTrack()->GetStepLength() << G4endl;
860 G4cout << " Energy Deposit (MeV) : "
861 << fStep->GetTotalEnergyDeposit() << G4endl;
862
863 // Show G4StepPoint specific information
864 G4cout << " -------------------------------------------------------"
865 << "----------------" << G4endl;
866 G4cout << " StepPoint Information "
867 << std::setw(20) << "PreStep"
868 << std::setw(20) << "PostStep" << G4endl;
869 G4cout << " -------------------------------------------------------"
870 << "----------------" << G4endl;
871 G4cout << " Position - x (mm) : "
872 << std::setw(20) << fStep->GetPreStepPoint()->GetPosition().x()
873 << std::setw(20) << fStep->GetPostStepPoint()->GetPosition().x()
874 << G4endl;
875 G4cout << " Position - y (mm) : "
876 << std::setw(20) << fStep->GetPreStepPoint()->GetPosition().y()
877 << std::setw(20) << fStep->GetPostStepPoint()->GetPosition().y()
878 << G4endl;
879 G4cout << " Position - z (mm) : "
880 << std::setw(20) << fStep->GetPreStepPoint()->GetPosition().z()
881 << std::setw(20) << fStep->GetPostStepPoint()->GetPosition().z()
882 << G4endl;
883 G4cout << " Global Time (ns) : "
884 << std::setw(20) << fStep->GetPreStepPoint()->GetGlobalTime()
885 << std::setw(20) << fStep->GetPostStepPoint()->GetGlobalTime()
886 << G4endl;
887 G4cout << " Local Time (ns) : "
888 << std::setw(20) << fStep->GetPreStepPoint()->GetLocalTime()
889 << std::setw(20) << fStep->GetPostStepPoint()->GetLocalTime()
890 << G4endl;
891 G4cout << " Proper Time (ns) : "
892 << std::setw(20) << fStep->GetPreStepPoint()->GetProperTime()
893 << std::setw(20) << fStep->GetPostStepPoint()->GetProperTime()
894 << G4endl;
895 G4cout << " Momentum Direct - x : "
896 << std::setw(20) << fStep->GetPreStepPoint()->GetMomentumDirection().x()
897 << std::setw(20) << fStep->GetPostStepPoint()->GetMomentumDirection().x()
898 << G4endl;
899 G4cout << " Momentum Direct - y : "
900 << std::setw(20) << fStep->GetPreStepPoint()->GetMomentumDirection().y()
901 << std::setw(20) << fStep->GetPostStepPoint()->GetMomentumDirection().y()
902 << G4endl;
903 G4cout << " Momentum Direct - z : "
904 << std::setw(20) << fStep->GetPreStepPoint()->GetMomentumDirection().z()
905 << std::setw(20) << fStep->GetPostStepPoint()->GetMomentumDirection().z()
906 << G4endl;
907 G4cout << " Momentum - x (MeV/c): "
908 << std::setw(20) << fStep->GetPreStepPoint()->GetMomentum().x()
909 << std::setw(20) << fStep->GetPostStepPoint()->GetMomentum().x()
910 << G4endl;
911 G4cout << " Momentum - y (MeV/c): "
912 << std::setw(20) << fStep->GetPreStepPoint()->GetMomentum().y()
913 << std::setw(20) << fStep->GetPostStepPoint()->GetMomentum().y()
914 << G4endl;
915 G4cout << " Momentum - z (MeV/c): "
916 << std::setw(20) << fStep->GetPreStepPoint()->GetMomentum().z()
917 << std::setw(20) << fStep->GetPostStepPoint()->GetMomentum().z()
918 << G4endl;
919 G4cout << " Total Energy (MeV) : "
920 << std::setw(20) << fStep->GetPreStepPoint()->GetTotalEnergy()
921 << std::setw(20) << fStep->GetPostStepPoint()->GetTotalEnergy()
922 << G4endl;
923 G4cout << " Kinetic Energy (MeV): "
924 << std::setw(20) << fStep->GetPreStepPoint()->GetKineticEnergy()
925 << std::setw(20) << fStep->GetPostStepPoint()->GetKineticEnergy()
926 << G4endl;
927 G4cout << " Velocity (mm/ns) : "
928 << std::setw(20) << fStep->GetPreStepPoint()->GetVelocity()
929 << std::setw(20) << fStep->GetPostStepPoint()->GetVelocity()
930 << G4endl;
931 G4cout << " Volume Name : "
932 << std::setw(20)
933 << fStep->GetPreStepPoint()->GetPhysicalVolume()->GetName();
934 if (fStep->GetPostStepPoint()->GetPhysicalVolume())
935 {
936 volName = fStep->GetPostStepPoint()->GetPhysicalVolume()->GetName();
937 }
938 else
939 {
940 volName = "OutOfWorld";
941 }
942 G4cout << std::setw(20) << volName << G4endl;
943 G4cout << " Safety (mm) : "
944 << std::setw(20) << fStep->GetPreStepPoint()->GetSafety()
945 << std::setw(20) << fStep->GetPostStepPoint()->GetSafety()
946 << G4endl;
947 G4cout << " Polarization - x : "
948 << std::setw(20) << fStep->GetPreStepPoint()->GetPolarization().x()
949 << std::setw(20) << fStep->GetPostStepPoint()->GetPolarization().x()
950 << G4endl;
951 G4cout << " Polarization - y : "
952 << std::setw(20) << fStep->GetPreStepPoint()->GetPolarization().y()
953 << std::setw(20) << fStep->GetPostStepPoint()->GetPolarization().y()
954 << G4endl;
955 G4cout << " Polarization - Z : "
956 << std::setw(20) << fStep->GetPreStepPoint()->GetPolarization().z()
957 << std::setw(20) << fStep->GetPostStepPoint()->GetPolarization().z()
958 << G4endl;
959 G4cout << " Weight : "
960 << std::setw(20) << fStep->GetPreStepPoint()->GetWeight()
961 << std::setw(20) << fStep->GetPostStepPoint()->GetWeight()
962 << G4endl;
963 G4cout << " Step Status : " ;
964 G4StepStatus tStepStatus = fStep->GetPreStepPoint()->GetStepStatus();
965 if( tStepStatus == fGeomBoundary )
966 {
967 G4cout << std::setw(20) << "Geom Limit";
968 }
969 else if ( tStepStatus == fAlongStepDoItProc )
970 {
971 G4cout << std::setw(20) << "AlongStep Proc.";
972 }
973 else if ( tStepStatus == fPostStepDoItProc )
974 {
975 G4cout << std::setw(20) << "PostStep Proc";
976 }
977 else if ( tStepStatus == fAtRestDoItProc )
978 {
979 G4cout << std::setw(20) << "AtRest Proc";
980 }
981 else if ( tStepStatus == fUndefined )
982 {
983 G4cout << std::setw(20) << "Undefined";
984 }
985
986 tStepStatus = fStep->GetPostStepPoint()->GetStepStatus();
987 if( tStepStatus == fGeomBoundary )
988 {
989 G4cout << std::setw(20) << "Geom Limit";
990 }
991 else if ( tStepStatus == fAlongStepDoItProc )
992 {
993 G4cout << std::setw(20) << "AlongStep Proc.";
994 }
995 else if ( tStepStatus == fPostStepDoItProc )
996 {
997 G4cout << std::setw(20) << "PostStep Proc";
998 }
999 else if ( tStepStatus == fAtRestDoItProc )
1000 {
1001 G4cout << std::setw(20) << "AtRest Proc";
1002 }
1003 else if ( tStepStatus == fUndefined )
1004 {
1005 G4cout << std::setw(20) << "Undefined";
1006 }
1007
1008 G4cout << G4endl;
1009 G4cout << " Process defined Step: " ;
1010 if( fStep->GetPreStepPoint()->GetProcessDefinedStep() == 0 )
1011 {
1012 G4cout << std::setw(20) << "Undefined";
1013 }
1014 else
1015 {
1016 G4cout << std::setw(20)
1017 << fStep->GetPreStepPoint()
1018 ->GetProcessDefinedStep()->GetProcessName();
1019 }
1020 if( fStep->GetPostStepPoint()->GetProcessDefinedStep() == 0)
1021 {
1022 G4cout << std::setw(20) << "Undefined";
1023 }
1024 else
1025 {
1026 G4cout << std::setw(20)
1027 << fStep->GetPostStepPoint()
1028 ->GetProcessDefinedStep()->GetProcessName();
1029 }
1030 G4cout.precision(oldprc);
1031
1032 G4cout << G4endl;
1033 G4cout << " -------------------------------------------------------"
1034 << "----------------" << G4endl;
1035}
StronglyForced
@ StronglyForced
Definition: G4ForceCondition.hh:55
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:45
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:52
G4int
int G4int
Definition: G4Types.hh:85
G4endl
#define G4endl
Definition: G4ios.hh:57
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
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:232
G4VPhysicalVolume::GetName
const G4String & GetName() const
G4VProcess::GetProcessName
const G4String & GetProcessName() const
Definition: G4VProcess.hh:382
G4VSteppingVerbose::MAXofAlongStepLoops
std::size_t MAXofAlongStepLoops
Definition: G4VSteppingVerbose.hh:145
G4VSteppingVerbose::fCondition
G4ForceCondition fCondition
Definition: G4VSteppingVerbose.hh:180
G4VSteppingVerbose::fGPILSelection
G4GPILSelection fGPILSelection
Definition: G4VSteppingVerbose.hh:181
G4VSteppingVerbose::fParticleChange
G4VParticleChange * fParticleChange
Definition: G4VSteppingVerbose.hh:123
G4VSteppingVerbose::fSelectedPostStepDoItVector
G4SelectedPostStepDoItVector * fSelectedPostStepDoItVector
Definition: G4VSteppingVerbose.hh:171
G4VSteppingVerbose::fSelectedAtRestDoItVector
G4SelectedAtRestDoItVector * fSelectedAtRestDoItVector
Definition: G4VSteppingVerbose.hh:169
G4VSteppingVerbose::fCurrentProcess
G4VProcess * fCurrentProcess
Definition: G4VSteppingVerbose.hh:132
G4VSteppingVerbose::SilentStepInfo
static G4ThreadLocal G4int SilentStepInfo
Definition: G4VSteppingVerbose.hh:104
G4VSteppingVerbose::Silent
static G4ThreadLocal G4int Silent
Definition: G4VSteppingVerbose.hh:102
G4VSteppingVerbose::MAXofPostStepLoops
std::size_t MAXofPostStepLoops
Definition: G4VSteppingVerbose.hh:146
G4VSteppingVerbose::fSecondary
G4TrackVector * fSecondary
Definition: G4VSteppingVerbose.hh:125
ns
#define ns
Definition: xmlparse.cc:614