source: trunk/source/tracking/src/G4SteppingVerbose.cc@ 1345

Last change on this file since 1345 was 1340, checked in by garnier, 15 years ago

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