Geant4  10.03
G4ITSteppingVerbose.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 //
27 // $Id$
28 //
29 //---------------------------------------------------------------
30 //
31 // G4ITSteppingVerbose.cc
32 //
33 // Description:
34 // Implementation of the G4ITSteppingVerbose class
35 //
36 //---------------------------------------------------------------
37 
38 #include "G4ITSteppingVerbose.hh"
39 #include "G4ITStepProcessor.hh"
40 #include "G4SystemOfUnits.hh"
41 //#include "G4VSensitiveDetector.hh" // Include from 'hits/digi'
42 #include "G4StepStatus.hh" // Include from 'tracking'
43 
44 #include "G4IT.hh"
45 #include "G4IosFlagsSaver.hh"
46 
47 #define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
48 
49 #ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
50 #include "G4UnitsTable.hh"
51 #else
52 #define G4BestUnit(a,b) a
53 #endif
54 
55 using namespace std;
56 
58 G4ITSteppingVerbose::G4ITSteppingVerbose()
60 {
61 #ifdef G4_TRACKING_DEBUG
62  G4cout << "G4ITSteppingVerbose has instantiated" << G4endl;
63 #endif
64 }
65 
67 G4ITSteppingVerbose::~G4ITSteppingVerbose()
69 {
70 }
71 
73 void G4ITSteppingVerbose::NewStep()
75 {
76 }
77 
79 void G4ITSteppingVerbose::AtRestDoItInvoked()
81 {
82  if(fVerboseLevel == 0)
83  {
84  return;
85  }
86 
87  G4VProcess* ptProcManager;
88  CopyState();
89 
90  if(fVerboseLevel >= 3)
91  {
92  G4int npt = 0;
93  G4cout << " **List of AtRestDoIt invoked:" << G4endl;
94  for(size_t np = 0; np < MAXofAtRestLoops; np++)
95  {
96  size_t npGPIL = MAXofAtRestLoops - np - 1;
97  if((*fSelectedAtRestDoItVector)[npGPIL] == 2)
98  {
99  npt++;
100  ptProcManager = (*fAtRestDoItVector)[np];
101  G4cout << " # " << npt << " : " << ptProcManager->GetProcessName()
102  << " (Forced)" << G4endl;
103  }
104  else if ( (*fSelectedAtRestDoItVector)[npGPIL] == 1 )
105  {
106  npt++;
107  ptProcManager = (*fAtRestDoItVector)[np];
108  G4cout << " # " << npt << " : " << ptProcManager->GetProcessName()
109  << G4endl;
110  }
111  }
112 
113  G4cout << " Generated secondries # : " << fN2ndariesAtRestDoIt << G4endl;
114 
115  if(fN2ndariesAtRestDoIt > 0)
116  {
117  G4cout << " -- List of secondaries generated : "
118  << "(x,y,z,kE,t,PID) --" << G4endl;
119  for( size_t lp1=(*fSecondary).size()-fN2ndariesAtRestDoIt;
120  lp1<(*fSecondary).size(); lp1++)
121  {
122  G4cout << " "
123  << std::setw( 9)
124  << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(),"Length") << " "
125  << std::setw( 9)
126  << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(),"Length") << " "
127  << std::setw( 9)
128  << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(),"Length") << " "
129  << std::setw( 9)
130  << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(),"Energy") << " "
131  << std::setw( 9)
132  << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(),"Time") << " "
133  << std::setw(18)
134  << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
135  }
136  }
137  }
138 
139  if(fVerboseLevel >= 4)
140  {
141  ShowStep();
142  G4cout << G4endl;
143  }
144 }
146 void G4ITSteppingVerbose::AlongStepDoItAllDone()
148 {
149  if(fVerboseLevel == 0)
150  {
151  return;
152  }
153 
154  G4VProcess* ptProcManager;
155 
156  CopyState();
157 
158  if(fVerboseLevel >= 3)
159  {
160  G4cout << G4endl;
161  G4cout << " >>AlongStepDoIt (after all invocations):" << G4endl;
162  G4cout << " ++List of invoked processes " << G4endl;
163 
164  for(size_t ci=0; ci<MAXofAlongStepLoops; ci++)
165  {
166  ptProcManager = (*fAlongStepDoItVector)(ci);
167  G4cout << " " << ci+1 << ") ";
168  if(ptProcManager != 0)
169  {
170  G4cout << ptProcManager->GetProcessName() << G4endl;
171  }
172  }
173 
174  ShowStep();
175  G4cout << G4endl;
176  G4cout << " ++List of secondaries generated "
177  << "(x,y,z,kE,t,PID):"
178  << " No. of secodaries = "
179  << (*fSecondary).size() << G4endl;
180 
181  if((*fSecondary).size()>0)
182  {
183  for(size_t lp1=0; lp1<(*fSecondary).size(); lp1++)
184  {
185  G4cout << " "
186  << std::setw( 9)
187  << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(),"Length") << " "
188  << std::setw( 9)
189  << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(),"Length") << " "
190  << std::setw( 9)
191  << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(),"Length") << " "
192  << std::setw( 9)
193  << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(),"Energy") << " "
194  << std::setw( 9)
195  << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(),"Time") << " "
196  << std::setw(18)
197  << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
198  }
199  }
200  }
201 }
203 void G4ITSteppingVerbose::PostStepDoItAllDone()
205 {
206  if(fVerboseLevel == 0)
207  {
208  return;
209  }
210 
211  G4VProcess* ptProcManager;
212 
213  CopyState();
214 
215  if(fVerboseLevel >= 3)
216  {
217 
218  if((fStepStatus == fPostStepDoItProc) | (fCondition == Forced)
219  | (fCondition == Conditionally) | (fCondition == ExclusivelyForced)
220  | (fCondition == StronglyForced))
221  {
222 
223  G4int npt = 0;
224  G4cout << G4endl;
225  G4cout << " **PostStepDoIt (after all invocations):" << G4endl;
226  G4cout << " ++List of invoked processes " << G4endl;
227 
228  for(size_t np = 0; np < MAXofPostStepLoops; np++)
229  {
230  size_t npGPIL = MAXofPostStepLoops - np - 1;
231  if((*fSelectedPostStepDoItVector)[npGPIL] == 2)
232  {
233  npt++;
234  ptProcManager = (*fPostStepDoItVector)[np];
235  G4cout << " " << npt << ") " << ptProcManager->GetProcessName()
236  << " (Forced)" << G4endl;
237  }
238  else if ( (*fSelectedPostStepDoItVector)[npGPIL] == 1)
239  {
240  npt++;
241  ptProcManager = (*fPostStepDoItVector)[np];
242  G4cout << " " << npt << ") "
243  << ptProcManager->GetProcessName() << G4endl;
244  }
245  }
246 
247  ShowStep();
248  G4cout << G4endl;
249  G4cout << " ++List of secondaries generated " << "(x,y,z,kE,t,PID):"
250  << " No. of secodaries = " << (*fSecondary).size() << G4endl;
251  G4cout << " [Note]Secondaries from AlongStepDoIt included." << G4endl;
252 
253  if((*fSecondary).size() > 0)
254  {
255  for(size_t lp1 = 0; lp1 < (*fSecondary).size(); lp1++)
256  {
257  G4cout << " " << std::setw(9)
258  << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length")
259  << " " << std::setw(9)
260  << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length")
261  << " " << std::setw(9)
262  << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length")
263  << " " << std::setw(9)
264  << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy")
265  << " " << std::setw(9)
266  << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time")
267  << " " << std::setw(18)
268  << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
269  << G4endl;
270  }
271  }
272  }
273  }
274 }
275 
277 void G4ITSteppingVerbose::StepInfoForLeadingTrack()
279 {
280  if(fVerboseLevel == 0)
281  {
282  return;
283  }
284 
285  if(fVerboseLevel < 2)
286  {
287  CopyState();
288  G4int prec = G4cout.precision(3);
289  // G4cout.precision(16);
290 
291  if(fVerboseLevel >= 4) VerboseTrack();
292  if(fVerboseLevel >= 3)
293  {
294  G4cout << G4endl;
295  G4cout << "StepInfo" << G4endl;
296 #ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
297  G4cout << std::setw( 5) << "#TrackID" << " "
298  << std::setw( 5) << "#Step#" << " "
299  << std::setw( 8) << "X" << " " << std::setw( 8) << "Y" << " "
300  << std::setw( 8) << "Z" << " "
301  << std::setw( 9) << "KineE" << " " << std::setw( 8) << "dE" << " "
302  << std::setw(12) << "StepLeng" << " " << std::setw(12) << "TrackLeng" << " "
303  << std::setw(12) << "NextVolume" << " " << std::setw( 8) << "ProcName" << G4endl;
304 #else
305  G4cout << std::setw( 5) << "#TrackID" << " "
306  << std::setw( 5) << "#Step#" << " "
307  << std::setw( 8) << "X(mm)" << " " << std::setw( 8) << "Y(mm)" << " "
308  << std::setw( 8) << "Z(mm)" << " "
309  << std::setw( 9) << "KinE(MeV)" << " " << std::setw( 8) << "dE(MeV)" << " "
310  << std::setw( 8) << "StepLeng" << " " << std::setw( 9) << "TrackLeng" << " "
311  << std::setw(11) << "NextVolume" << " " << std::setw( 8) << "ProcName" << G4endl;
312 #endif
313  }
314  G4cout << std::setw(5) << fTrack->GetTrackID() << " " << std::setw(5)
315  << fTrack->GetCurrentStepNumber() << " " << std::setw(8)
316  << G4BestUnit(fTrack->GetPosition().x(), "Length") << " "
317  << std::setw(8) << G4BestUnit(fTrack->GetPosition().y(), "Length")
318  << " " << std::setw(8)
319  << G4BestUnit(fTrack->GetPosition().z(), "Length") << " "
320  << std::setw(9) << G4BestUnit(fTrack->GetKineticEnergy(), "Energy")
321  << " " << std::setw(8)
322  << G4BestUnit(fStep->GetTotalEnergyDeposit(), "Energy") << " "
323  << std::setw(8) << G4BestUnit(fStep->GetStepLength(), "Length")
324  << " " << std::setw(9)
325  << G4BestUnit(fTrack->GetTrackLength(), "Length") << " ";
326 
327  // Put cut comment here
328  if(fTrack->GetNextVolume() != 0)
329  {
330  G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
331  }
332  else
333  {
334  G4cout << std::setw(11) << "OutOfWorld" << " ";
335  }
336  if(fStep->GetPostStepPoint()->GetProcessDefinedStep() != 0)
337  {
338  G4cout
339  << fStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName();
340  }
341  else
342  {
343  G4cout << "User Limit";
344  }
345 
346  G4cout << G4endl;
347  if(fVerboseLevel == 2)
348  {
349  G4int tN2ndariesTot = fN2ndariesAtRestDoIt + fN2ndariesAlongStepDoIt
350  + fN2ndariesPostStepDoIt;
351  if(tN2ndariesTot > 0)
352  {
353  G4cout << " :----- List of 2ndaries - " << "#SpawnInStep="
354  << std::setw(3) << tN2ndariesTot << "(Rest=" << std::setw(2)
355  << fN2ndariesAtRestDoIt << ",Along=" << std::setw(2)
356  << fN2ndariesAlongStepDoIt << ",Post=" << std::setw(2)
357  << fN2ndariesPostStepDoIt << "), " << "#SpawnTotal="
358  << std::setw(3) << (*fSecondary).size() << " ---------------"
359  << G4endl;
360 
361  for(size_t lp1=(*fSecondary).size()-tN2ndariesTot; lp1<(*fSecondary).size(); lp1++)
362  {
363  G4cout << " : "
364  << std::setw( 9)
365  << G4BestUnit((*fSecondary)[lp1]->GetPosition().x() , "Length")<< " "
366  << std::setw( 9)
367  << G4BestUnit((*fSecondary)[lp1]->GetPosition().y() , "Length")<< " "
368  << std::setw( 9)
369  << G4BestUnit((*fSecondary)[lp1]->GetPosition().z() , "Length") << " "
370  << std::setw( 9)
371  << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy() , "Energy")<< " "
372  << std::setw(18)
373  << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
374  }
375  G4cout << " :-----------------------------" << "----------------------------------"
376  << "-- EndOf2ndaries Info ---------------" << G4endl;
377  }
378  }
379  G4cout.precision(prec);
380  }
381 }
383 void G4ITSteppingVerbose::StepInfo()
385 {
386  if(fVerboseLevel < 2)
387  {
388  return;
389  }
390 
391  CopyState();
392  G4int prec = G4cout.precision(3);
393 // G4cout.precision(16);
394 
395  if(fVerboseLevel >= 4) VerboseTrack();
396  if(fVerboseLevel >= 3)
397  {
398  G4cout << G4endl;
399  G4cout << "StepInfo" << G4endl;
400 #ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
401  G4cout << std::setw( 5) << "#TrackID" << " "
402  << std::setw( 5) << "#Step#" << " "
403  << std::setw( 8) << "X" << " " << std::setw( 8) << "Y" << " "
404  << std::setw( 8) << "Z" << " "
405  << std::setw( 9) << "KineE" << " " << std::setw( 8) << "dE" << " "
406  << std::setw(12) << "StepLeng" << " " << std::setw(12) << "TrackLeng" << " "
407  << std::setw(12) << "NextVolume" << " " << std::setw( 8) << "ProcName" << G4endl;
408 #else
409  G4cout << std::setw( 5) << "#TrackID" << " "
410  << std::setw( 5) << "#Step#" << " "
411  << std::setw( 8) << "X(mm)" << " " << std::setw( 8) << "Y(mm)" << " "
412  << std::setw( 8) << "Z(mm)" << " "
413  << std::setw( 9) << "KinE(MeV)" << " " << std::setw( 8) << "dE(MeV)" << " "
414  << std::setw( 8) << "StepLeng" << " " << std::setw( 9) << "TrackLeng" << " "
415  << std::setw(11) << "NextVolume" << " " << std::setw( 8) << "ProcName" << G4endl;
416 #endif
417  }
418  G4cout << std::setw(5) << fTrack->GetTrackID() << " " << std::setw(5)
419  << fTrack->GetCurrentStepNumber() << " " << std::setw(8)
420  << G4BestUnit(fTrack->GetPosition().x(), "Length") << " "
421  << std::setw(8) << G4BestUnit(fTrack->GetPosition().y(), "Length")
422  << " " << std::setw(8)
423  << G4BestUnit(fTrack->GetPosition().z(), "Length") << " "
424  << std::setw(9) << G4BestUnit(fTrack->GetKineticEnergy(), "Energy")
425  << " " << std::setw(8)
426  << G4BestUnit(fStep->GetTotalEnergyDeposit(), "Energy") << " "
427  << std::setw(8) << G4BestUnit(fStep->GetStepLength(), "Length") << " "
428  << std::setw(9) << G4BestUnit(fTrack->GetTrackLength(), "Length")
429  << " ";
430 
431  // Put cut comment here
432  if(fTrack->GetNextVolume() != 0)
433  {
434  G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
435  }
436  else
437  {
438  G4cout << std::setw(11) << "OutOfWorld" << " ";
439  }
440  if(fStep->GetPostStepPoint()->GetProcessDefinedStep() != 0)
441  {
442  G4cout
443  << fStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName();
444  }
445  else
446  {
447  G4cout << "User Limit";
448  }
449  G4cout << G4endl;
450  if(fVerboseLevel == 2)
451  {
452  G4int tN2ndariesTot = fN2ndariesAtRestDoIt + fN2ndariesAlongStepDoIt
453  + fN2ndariesPostStepDoIt;
454  if(tN2ndariesTot > 0)
455  {
456  G4cout << " :----- List of 2ndaries - " << "#SpawnInStep="
457  << std::setw(3) << tN2ndariesTot << "(Rest=" << std::setw(2)
458  << fN2ndariesAtRestDoIt << ",Along=" << std::setw(2)
459  << fN2ndariesAlongStepDoIt << ",Post=" << std::setw(2)
460  << fN2ndariesPostStepDoIt << "), " << "#SpawnTotal="
461  << std::setw(3) << (*fSecondary).size() << " ---------------"
462  << G4endl;
463 
464  for(size_t lp1=(*fSecondary).size()-tN2ndariesTot; lp1<(*fSecondary).size(); lp1++)
465  {
466  G4cout << " : "
467  << std::setw( 9)
468  << G4BestUnit((*fSecondary)[lp1]->GetPosition().x() , "Length")<< " "
469  << std::setw( 9)
470  << G4BestUnit((*fSecondary)[lp1]->GetPosition().y() , "Length")<< " "
471  << std::setw( 9)
472  << G4BestUnit((*fSecondary)[lp1]->GetPosition().z() , "Length") << " "
473  << std::setw( 9)
474  << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy() , "Energy")<< " "
475  << std::setw(18)
476  << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
477  }
478  G4cout << " :-----------------------------" << "----------------------------------"
479  << "-- EndOf2ndaries Info ---------------" << G4endl;
480  }
481  }
482  G4cout.precision(prec);
483 }
484 // Put cut comment here if( fStepStatus != fWorldBoundary){
485 
487 void G4ITSteppingVerbose::DPSLStarted()
489 {
490  if(fVerboseLevel == 0)
491  {
492  return;
493  }
494  CopyState();
495 
496  if(fVerboseLevel > 5)
497  {
498  G4cout << G4endl<< " >>DefinePhysicalStepLength (List of proposed StepLengths): " << G4endl;
499  }
500 }
502 void G4ITSteppingVerbose::DPSLUserLimit()
504 {
505  if(fVerboseLevel == 0)
506  {
507  return;
508  }
509  CopyState();
510 
511  if(fVerboseLevel > 5)
512  {
513  G4cout << G4endl<< G4endl;
514  G4cout << "=== Defined Physical Step Length (DPSL)" << G4endl;
515  G4cout << " ++ProposedStep(UserLimit) = " << std::setw( 9) << physIntLength
516  << " : ProcName = User defined maximum allowed Step" << G4endl;
517  }
518 }
520 void G4ITSteppingVerbose::DPSLPostStep()
522 {
523  if(fVerboseLevel == 0)
524  {
525  return;
526  }
527 
528  if(fVerboseLevel > 5)
529  {
530  CopyState();
531 
532  G4cout << " ++ProposedStep(PostStep ) = " << std::setw(9)
533  << physIntLength << " : ProcName = "
534  << fCurrentProcess->GetProcessName() << " (";
535  if(fCondition == ExclusivelyForced)
536  {
537  G4cout << "ExclusivelyForced)" << G4endl;
538  }
539  else if(fCondition==StronglyForced)
540  {
541  G4cout << "StronglyForced)" << G4endl;
542  }
543  else if(fCondition==Conditionally)
544  {
545  G4cout << "Conditionally)" << G4endl;
546  }
547  else if(fCondition==Forced)
548  {
549  G4cout << "Forced)" << G4endl;
550  }
551  else
552  {
553  G4cout << "No ForceCondition)" << G4endl;
554  }
555  }
556 }
558 void G4ITSteppingVerbose::DPSLAlongStep()
560 {
561  if(fVerboseLevel == 0)
562  {
563  return;
564  }
565 
566  if(fVerboseLevel > 5)
567  {
568  CopyState();
569 
570  G4cout << " ++ProposedStep(AlongStep) = " << std::setw(9)
571  << G4BestUnit(physIntLength, "Length") << " : ProcName = "
572  << fCurrentProcess->GetProcessName() << " (";
573  if(fGPILSelection == CandidateForSelection)
574  {
575  G4cout << "CandidateForSelection)" << G4endl;
576  }
577  else if(fGPILSelection==NotCandidateForSelection)
578  {
579  G4cout << "NotCandidateForSelection)" << G4endl;
580  }
581  else
582  {
583  G4cout << "?!?)" << G4endl;
584  }
585  }
586 }
587 
589 void G4ITSteppingVerbose::TrackingStarted(G4Track* track)
591 {
592  if(fVerboseLevel <= 1)
593  {
594  return;
595  }
596 
597  G4int prec = G4cout.precision(3);
598  if(fVerboseLevel > 0)
599  {
600  fTrack = track;
601  fStep = track->GetStep();
602 
603 //#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
604 // G4cout << std::setw(5) << "TrackID" << " " << std::setw(5) << "Step#" << " "
605 // << std::setw(8) << "X" << " " << std::setw(8) << "Y" << " "
606 // << std::setw(8) << "Z" << " " << std::setw(9) << "KineE"
607 // << " " << std::setw(8) << "dE" << " " << std::setw(12)
608 // << "StepLeng" << " " << std::setw(12) << "TrackLeng" << " "
609 // << std::setw(12) << "NextVolume" << " " << std::setw(8) << "ProcName"
610 // << G4endl;
611 //#else
612 // G4cout << std::setw(5) << "TrackID" << std::setw(5) << "Step#" << " "
613 // << std::setw(8) << "X(mm)" << " " << std::setw(8) << "Y(mm)" << " "
614 // << std::setw(8) << "Z(mm)" << " " << std::setw(9) << "KinE(MeV)"
615 // << " " << std::setw(8) << "dE(MeV)" << " " << std::setw(8)
616 // << "StepLeng" << " " << std::setw(9) << "TrackLeng" << " "
617 // << std::setw(11) << "NextVolume" << " " << std::setw(8) << "ProcName"
618 // << G4endl;
619 //#endif
620 
621  G4cout << "Start tracking : "
622  << GetIT(fTrack)->GetName()
623  << " (" << fTrack->GetTrackID() << ") from position "
624  << std::setw(8)
625  << G4BestUnit(fTrack->GetPosition().x(), "Length") << " "
626  << std::setw(8)
627  << G4BestUnit(fTrack->GetPosition().y(), "Length") << " "
628  << std::setw(8)
629  << G4BestUnit(fTrack->GetPosition().z(), "Length") << " ";
630 
631 // G4cout << std::setw(5) << fTrack->GetTrackID() << std::setw(5)
632 // << fTrack->GetCurrentStepNumber() << " " << std::setw(8)
633 // << G4BestUnit(fTrack->GetPosition().x(), "Length") << " "
634 // << std::setw(8) << G4BestUnit(fTrack->GetPosition().y(), "Length")
635 // << " " << std::setw(8)
636 // << G4BestUnit(fTrack->GetPosition().z(), "Length") << " "
637 // << std::setw(9) << G4BestUnit(fTrack->GetKineticEnergy(), "Energy")
638 // << " " << std::setw(8)
639 // << G4BestUnit(fStep->GetTotalEnergyDeposit(), "Energy") << " "
640 // << std::setw(8) << G4BestUnit(fStep->GetStepLength(), "Length")
641 // << " " << std::setw(9)
642 // << G4BestUnit(fTrack->GetTrackLength(), "Length") << " ";
643 
644  if(fTrack->GetNextVolume())
645  {
646  G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
647  }
648  else
649  {
650  G4cout << std::setw(11) << "OutOfWorld" << " ";
651  }
652  G4cout << "initStep" << G4endl;
653  }
654  G4cout.precision(prec);
655 }
656 
658 void G4ITSteppingVerbose::TrackingEnded(G4Track* track)
660 {
661  if(fVerboseLevel <= 1) return;
662 
663  G4cout << " * End tracking : " << " Particle : "
664  << track->GetDefinition()->GetParticleName() << "," << " Track ID : "
665  << track->GetTrackID();
666 
667  if(track->GetNextVolume())
668  {
669  G4cout << std::setw(11) << track->GetNextVolume()->GetName() << " ";
670  }
671 
672  G4cout << G4endl;
673 }
674 
676 void G4ITSteppingVerbose::AlongStepDoItOneByOne()
678 {
679  if(fVerboseLevel < 4)
680  {
681  return;
682  }
683 
684  CopyState();
685 
686  G4cout << G4endl;
687  G4cout << " >>AlongStepDoIt (process by process): " << " Process Name = "
688  << fCurrentProcess->GetProcessName() << G4endl;
689 
690  ShowStep();
691  G4cout << " " << "!Note! Safety of PostStep is only valid "
692  << "after all DoIt invocations." << G4endl;
693 
694  VerboseParticleChange();
695  G4cout << G4endl;
696 
697  G4cout << " ++List of secondaries generated " << "(x,y,z,kE,t,PID):"
698  << " No. of secodaries = " << fN2ndariesAlongStepDoIt << G4endl;
699 
700  if(fN2ndariesAlongStepDoIt > 0)
701  {
702  for(size_t lp1 = (*fSecondary).size() - fN2ndariesAlongStepDoIt;
703  lp1 < (*fSecondary).size(); lp1++)
704  {
705  G4cout << " " << std::setw(9)
706  << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length")
707  << " " << std::setw(9)
708  << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length")
709  << " " << std::setw(9)
710  << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length")
711  << " " << std::setw(9)
712  << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy")
713  << " " << std::setw(9)
714  << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time") << " "
715  << std::setw(18)
716  << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
717  }
718  }
719 }
721 void G4ITSteppingVerbose::PostStepDoItOneByOne()
723 {
724  if(fVerboseLevel < 4)
725  {
726  return;
727  }
728 
729  CopyState();
730  G4cout << G4endl;
731  G4cout << " >>PostStepDoIt (process by process): " << " Process Name = "
732  << fCurrentProcess->GetProcessName() << G4endl;
733 
734  ShowStep();
735  G4cout << G4endl;
736  VerboseParticleChange();
737  G4cout << G4endl;
738 
739  G4cout << " ++List of secondaries generated " << "(x,y,z,kE,t,PID):"
740  << " No. of secodaries = " << fN2ndariesPostStepDoIt << G4endl;
741 
742  if(fN2ndariesPostStepDoIt > 0)
743  {
744  for(size_t lp1 = (*fSecondary).size() - fN2ndariesPostStepDoIt;
745  lp1 < (*fSecondary).size(); lp1++)
746  {
747  G4cout << " " << std::setw(9)
748  << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length")
749  << " " << std::setw(9)
750  << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length")
751  << " " << std::setw(9)
752  << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length")
753  << " " << std::setw(9)
754  << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy")
755  << " " << std::setw(9)
756  << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time") << " "
757  << std::setw(18)
758  << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
759  }
760  }
761 }
762 
764 void G4ITSteppingVerbose::VerboseTrack()
766 {
767  if(fVerboseLevel == 0)
768  {
769  return;
770  }
771 
772  CopyState();
773 // Show header
774  G4cout << G4endl;
775  G4cout << " ++G4Track Information " << G4endl;
776  G4int prec = G4cout.precision(3);
777 
778  G4cout << " -----------------------------------------------" << G4endl;
779  G4cout << " G4Track Information " << std::setw(20) << G4endl;
780  G4cout << " -----------------------------------------------" << G4endl;
781 
782  G4cout << " Step number : " << std::setw(20)
783  << fTrack->GetCurrentStepNumber() << G4endl;
784 #ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
785  G4cout << " Position - x : " << std::setw(20)
786  << G4BestUnit(fTrack->GetPosition().x(), "Length") << G4endl;
787  G4cout << " Position - y : " << std::setw(20)
788  << G4BestUnit(fTrack->GetPosition().y(), "Length") << G4endl;
789  G4cout << " Position - z : " << std::setw(20)
790  << G4BestUnit(fTrack->GetPosition().z(), "Length") << G4endl;
791  G4cout << " Global Time : " << std::setw(20)
792  << G4BestUnit(fTrack->GetGlobalTime(), "Time") << G4endl;
793  G4cout << " Local Time : " << std::setw(20)
794  << G4BestUnit(fTrack->GetLocalTime(), "Time") << G4endl;
795 #else
796  G4cout << " Position - x (mm) : " << std::setw(20)
797  << fTrack->GetPosition().x() / mm << G4endl;
798  G4cout << " Position - y (mm) : " << std::setw(20)
799  << fTrack->GetPosition().y() / mm << G4endl;
800  G4cout << " Position - z (mm) : " << std::setw(20)
801  << fTrack->GetPosition().z() / mm << G4endl;
802  G4cout << " Global Time (ns) : " << std::setw(20)
803  << fTrack->GetGlobalTime() / ns << G4endl;
804  G4cout << " Local Time (ns) : " << std::setw(20)
805  << fTrack->GetLocalTime() / ns << G4endl;
806 #endif
807  G4cout << " Momentum Direct - x : " << std::setw(20)
808  << fTrack->GetMomentumDirection().x() << G4endl;
809  G4cout << " Momentum Direct - y : " << std::setw(20)
810  << fTrack->GetMomentumDirection().y() << G4endl;
811  G4cout << " Momentum Direct - z : " << std::setw(20)
812  << fTrack->GetMomentumDirection().z() << G4endl;
813 #ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
814  G4cout << " Kinetic Energy : "
815 #else
816  G4cout << " Kinetic Energy (MeV): "
817 #endif
818  << std::setw(20)
819  << G4BestUnit(fTrack->GetKineticEnergy(), "Energy") << G4endl;
820  G4cout << " Polarization - x : " << std::setw(20)
821  << fTrack->GetPolarization().x() << G4endl;
822  G4cout << " Polarization - y : " << std::setw(20)
823  << fTrack->GetPolarization().y() << G4endl;
824  G4cout << " Polarization - z : " << std::setw(20)
825  << fTrack->GetPolarization().z() << G4endl;
826  G4cout << " Track Length : " << std::setw(20)
827  << G4BestUnit(fTrack->GetTrackLength(), "Length") << G4endl;
828  G4cout << " Track ID # : " << std::setw(20)
829  << fTrack->GetTrackID() << G4endl;
830  G4cout << " Parent Track ID # : " << std::setw(20)
831  << fTrack->GetParentID() << G4endl;
832  G4cout << " Next Volume : " << std::setw(20);
833  if(fTrack->GetNextVolume() != 0)
834  {
835  G4cout << fTrack->GetNextVolume()->GetName() << " ";
836  }
837  else
838  {
839  G4cout << "OutOfWorld" << " ";
840  }
841  G4cout << G4endl;
842  G4cout << " Track Status : " << std::setw(20);
843  if(fTrack->GetTrackStatus() == fAlive)
844  {
845  G4cout << " Alive";
846  }
847  else if(fTrack->GetTrackStatus() == fStopButAlive)
848  {
849  G4cout << " StopButAlive";
850  }
851  else if(fTrack->GetTrackStatus() == fStopAndKill)
852  {
853  G4cout << " StopAndKill";
854  }
855  else if(fTrack->GetTrackStatus() == fKillTrackAndSecondaries)
856  {
857  G4cout << " KillTrackAndSecondaries";
858  }
859  else if(fTrack->GetTrackStatus() == fSuspend)
860  {
861  G4cout << " Suspend";
862  }
863  else if(fTrack->GetTrackStatus() == fPostponeToNextEvent)
864  {
865  G4cout << " PostponeToNextEvent";
866  }
867  G4cout << G4endl;
868 #ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
869  G4cout << " Vertex - x : " << std::setw(20)
870  << G4BestUnit(fTrack->GetVertexPosition().x(), "Length") << G4endl;
871  G4cout << " Vertex - y : " << std::setw(20)
872  << G4BestUnit(fTrack->GetVertexPosition().y(), "Length") << G4endl;
873  G4cout << " Vertex - z : " << std::setw(20)
874  << G4BestUnit(fTrack->GetVertexPosition().z(), "Length") << G4endl;
875 #else
876  G4cout << " Vertex - x (mm) : " << std::setw(20)
877  << fTrack->GetVertexPosition().x() / mm << G4endl;
878  G4cout << " Vertex - y (mm) : " << std::setw(20)
879  << fTrack->GetVertexPosition().y() / mm << G4endl;
880  G4cout << " Vertex - z (mm) : " << std::setw(20)
881  << fTrack->GetVertexPosition().z() / mm << G4endl;
882 #endif
883  G4cout << " Vertex - Px (MomDir): " << std::setw(20)
884  << fTrack->GetVertexMomentumDirection().x() << G4endl;
885  G4cout << " Vertex - Py (MomDir): " << std::setw(20)
886  << fTrack->GetVertexMomentumDirection().y() << G4endl;
887  G4cout << " Vertex - Pz (MomDir): " << std::setw(20)
888  << fTrack->GetVertexMomentumDirection().z() << G4endl;
889 #ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
890  G4cout << " Vertex - KineE : "
891 #else
892  G4cout << " Vertex - KineE (MeV): "
893 #endif
894  << std::setw(20)
895  << G4BestUnit(fTrack->GetVertexKineticEnergy(), "Energy") << G4endl;
896 
897  G4cout << " Creator Process : " << std::setw(20);
898  if(fTrack->GetCreatorProcess() == 0)
899  {
900  G4cout << " Event Generator" << G4endl;
901  }
902  else
903  {
904  G4cout << fTrack->GetCreatorProcess()->GetProcessName() << G4endl;
905  }
906 
907  G4cout << " -----------------------------------------------" << G4endl;
908 
909  G4cout.precision(prec);
910 }
911 
913 void G4ITSteppingVerbose::VerboseParticleChange()
915 {
916  if(fVerboseLevel == 0)
917  {
918  return;
919  }
920 // Show header
921  G4cout << G4endl;
922  G4cout << " ++G4ParticleChange Information " << G4endl;
923  fParticleChange->DumpInfo();
924 }
926 void G4ITSteppingVerbose::ShowStep() const
928 {
929  if(fVerboseLevel == 0)
930  {
931  return;
932  }
933 
934  G4String volName;
935  G4int oldprc;
936 
937 // Show header
938  G4cout << G4endl;
939  G4cout << " ++G4Step Information " << G4endl;
940  oldprc = G4cout.precision(16);
941 
942 // Show G4Step specific information
943  G4cout << " Address of G4Track : " << fStep->GetTrack() << G4endl;
944  G4cout << " Step Length (mm) : "
945  << fStep->GetTrack()->GetStepLength() << G4endl;
946  G4cout << " Energy Deposit (MeV) : " << fStep->GetTotalEnergyDeposit()
947  << G4endl;
948 
949 // Show G4StepPoint specific information
950  G4cout << " -------------------------------------------------------"
951  << "----------------" << G4endl;
952  G4cout << " StepPoint Information " << std::setw(20) << "PreStep"
953  << std::setw(20) << "PostStep" << G4endl;
954  G4cout << " -------------------------------------------------------"
955  << "----------------" << G4endl;
956  G4cout << " Position - x (mm) : " << std::setw(20)
957  << fStep->GetPreStepPoint()->GetPosition().x() << std::setw(20)
958  << fStep->GetPostStepPoint()->GetPosition().x() << G4endl;
959  G4cout << " Position - y (mm) : " << std::setw(20)
960  << fStep->GetPreStepPoint()->GetPosition().y() << std::setw(20)
961  << fStep->GetPostStepPoint()->GetPosition().y() << G4endl;
962  G4cout << " Position - z (mm) : " << std::setw(20)
963  << fStep->GetPreStepPoint()->GetPosition().z() << std::setw(20)
964  << fStep->GetPostStepPoint()->GetPosition().z() << G4endl;
965  G4cout << " Global Time (ns) : " << std::setw(20)
966  << fStep->GetPreStepPoint()->GetGlobalTime() << std::setw(20)
967  << fStep->GetPostStepPoint()->GetGlobalTime() << G4endl;
968  G4cout << " Local Time (ns) : " << std::setw(20)
969  << fStep->GetPreStepPoint()->GetLocalTime() << std::setw(20)
970  << fStep->GetPostStepPoint()->GetLocalTime() << G4endl;
971  G4cout << " Proper Time (ns) : " << std::setw(20)
972  << fStep->GetPreStepPoint()->GetProperTime() << std::setw(20)
973  << fStep->GetPostStepPoint()->GetProperTime() << G4endl;
974  G4cout << " Momentum Direct - x : " << std::setw(20)
975  << fStep->GetPreStepPoint()->GetMomentumDirection().x()
976  << std::setw(20)
977  << fStep->GetPostStepPoint()->GetMomentumDirection().x() << G4endl;
978  G4cout << " Momentum Direct - y : " << std::setw(20)
979  << fStep->GetPreStepPoint()->GetMomentumDirection().y()
980  << std::setw(20)
981  << fStep->GetPostStepPoint()->GetMomentumDirection().y() << G4endl;
982  G4cout << " Momentum Direct - z : " << std::setw(20)
983  << fStep->GetPreStepPoint()->GetMomentumDirection().z()
984  << std::setw(20)
985  << fStep->GetPostStepPoint()->GetMomentumDirection().z() << G4endl;
986  G4cout << " Momentum - x (MeV/c): " << std::setw(20)
987  << fStep->GetPreStepPoint()->GetMomentum().x() << std::setw(20)
988  << fStep->GetPostStepPoint()->GetMomentum().x() << G4endl;
989  G4cout << " Momentum - y (MeV/c): " << std::setw(20)
990  << fStep->GetPreStepPoint()->GetMomentum().y() << std::setw(20)
991  << fStep->GetPostStepPoint()->GetMomentum().y() << G4endl;
992  G4cout << " Momentum - z (MeV/c): " << std::setw(20)
993  << fStep->GetPreStepPoint()->GetMomentum().z() << std::setw(20)
994  << fStep->GetPostStepPoint()->GetMomentum().z() << G4endl;
995  G4cout << " Total Energy (MeV) : " << std::setw(20)
996  << fStep->GetPreStepPoint()->GetTotalEnergy() << std::setw(20)
997  << fStep->GetPostStepPoint()->GetTotalEnergy() << G4endl;
998  G4cout << " Kinetic Energy (MeV): " << std::setw(20)
999  << fStep->GetPreStepPoint()->GetKineticEnergy() << std::setw(20)
1000  << fStep->GetPostStepPoint()->GetKineticEnergy() << G4endl;
1001  G4cout << " Velocity (mm/ns) : " << std::setw(20)
1002  << fStep->GetPreStepPoint()->GetVelocity() << std::setw(20)
1003  << fStep->GetPostStepPoint()->GetVelocity() << G4endl;
1004  G4cout << " Volume Name : " << std::setw(20)
1005  << fStep->GetPreStepPoint()->GetPhysicalVolume()->GetName();
1006  if(fStep->GetPostStepPoint()->GetPhysicalVolume())
1007  {
1008  volName = fStep->GetPostStepPoint()->GetPhysicalVolume()->GetName();
1009  }
1010  else
1011  {
1012  volName = "OutOfWorld";
1013  }
1014  G4cout << std::setw(20) << volName << G4endl;
1015  G4cout << " Safety (mm) : " << std::setw(20)
1016  << fStep->GetPreStepPoint()->GetSafety() << std::setw(20)
1017  << fStep->GetPostStepPoint()->GetSafety() << G4endl;
1018  G4cout << " Polarization - x : " << std::setw(20)
1019  << fStep->GetPreStepPoint()->GetPolarization().x() << std::setw(20)
1020  << fStep->GetPostStepPoint()->GetPolarization().x() << G4endl;
1021  G4cout << " Polarization - y : " << std::setw(20)
1022  << fStep->GetPreStepPoint()->GetPolarization().y() << std::setw(20)
1023  << fStep->GetPostStepPoint()->GetPolarization().y() << G4endl;
1024  G4cout << " Polarization - Z : " << std::setw(20)
1025  << fStep->GetPreStepPoint()->GetPolarization().z() << std::setw(20)
1026  << fStep->GetPostStepPoint()->GetPolarization().z() << G4endl;
1027  G4cout << " Weight : " << std::setw(20)
1028  << fStep->GetPreStepPoint()->GetWeight() << std::setw(20)
1029  << fStep->GetPostStepPoint()->GetWeight() << G4endl;
1030  G4cout << " Step Status : ";
1031  G4StepStatus tStepStatus = fStep->GetPreStepPoint()->GetStepStatus();
1032  if(tStepStatus == fGeomBoundary)
1033  {
1034  G4cout << std::setw(20) << "Geom Limit";
1035  }
1036  else if(tStepStatus == fAlongStepDoItProc)
1037  {
1038  G4cout << std::setw(20) << "AlongStep Proc.";
1039  }
1040  else if(tStepStatus == fPostStepDoItProc)
1041  {
1042  G4cout << std::setw(20) << "PostStep Proc";
1043  }
1044  else if(tStepStatus == fAtRestDoItProc)
1045  {
1046  G4cout << std::setw(20) << "AtRest Proc";
1047  }
1048  else if(tStepStatus == fUndefined)
1049  {
1050  G4cout << std::setw(20) << "Undefined";
1051  }
1052 
1053  tStepStatus = fStep->GetPostStepPoint()->GetStepStatus();
1054  if(tStepStatus == fGeomBoundary)
1055  {
1056  G4cout << std::setw(20) << "Geom Limit";
1057  }
1058  else if(tStepStatus == fAlongStepDoItProc)
1059  {
1060  G4cout << std::setw(20) << "AlongStep Proc.";
1061  }
1062  else if(tStepStatus == fPostStepDoItProc)
1063  {
1064  G4cout << std::setw(20) << "PostStep Proc";
1065  }
1066  else if(tStepStatus == fAtRestDoItProc)
1067  {
1068  G4cout << std::setw(20) << "AtRest Proc";
1069  }
1070  else if(tStepStatus == fUndefined)
1071  {
1072  G4cout << std::setw(20) << "Undefined";
1073  }
1074 
1075  G4cout << G4endl;
1076  G4cout << " Process defined Step: ";
1077  if(fStep->GetPreStepPoint()->GetProcessDefinedStep() == 0)
1078  {
1079  G4cout << std::setw(20) << "Undefined";
1080  }
1081  else
1082  {
1083  G4cout
1084  << std::setw(20)
1085  << fStep->GetPreStepPoint()->GetProcessDefinedStep()->GetProcessName();
1086  }
1087  if(fStep->GetPostStepPoint()->GetProcessDefinedStep() == 0)
1088  {
1089  G4cout << std::setw(20) << "Undefined";
1090  }
1091  else
1092  {
1093  G4cout
1094  << std::setw(20)
1095  << fStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName();
1096  }
1097  G4cout.precision(oldprc);
1098 
1099  G4cout << G4endl;
1100  G4cout << " -------------------------------------------------------"
1101  << "----------------" << G4endl;
1102 }
1103 
1104 void G4ITSteppingVerbose::DoItStarted()
1105 {
1106  if(fVerboseLevel <= 0) return;
1107 
1108  G4IosFlagsSaver ios_saver(G4cout);
1109 #ifdef USE_COLOR
1110  G4cout << LIGHT_RED;
1111 #endif
1112  G4cout << "*** G4ITStepProcessor::DoIt ***" << G4endl;
1113  G4cout << std::setw(18) << left << "#Name" << std::setw(15) << "trackID"
1114  << std::setw(35) << "Position" << std::setw(25) << "Pre step volume"
1115  << std::setw(25) << "Post step volume" << std::setw(22) << "Process"
1116  << G4endl;
1117 #ifdef USE_COLOR
1118  G4cout << RESET_COLOR;
1119 #endif
1120 }
1121 
1122 void G4ITSteppingVerbose::PreStepVerbose(G4Track* track)
1123 {
1124  if(fVerboseLevel <= 0) return;
1125 
1126  G4IosFlagsSaver ios_saver(G4cout);
1127 
1129 // PRE STEP VERBOSE
1130 
1131 #ifdef DEBUG
1132 #ifdef USE_COLOR
1133  G4cout << LIGHT_RED;
1134 #endif
1135  G4cout << "*DoIt* " << GetIT(track)->GetName()
1136  << " ID: " << track->GetTrackID()
1137  << " at time : " << track->GetGlobalTime()
1138  << G4endl;
1139 #ifdef USE_COLOR
1140  G4cout << RESET_COLOR;
1141 #endif
1142 #endif
1143 
1144  G4String volumeName;
1145 
1146  G4TouchableHandle nextTouchable = track->GetNextTouchableHandle();
1147  G4VPhysicalVolume* volume(0);
1148 
1149  if(nextTouchable && (volume = nextTouchable->GetVolume()))
1150  {
1151  volumeName = volume->GetName();
1152 
1153  if(volume->IsParameterised() || volume->IsReplicated())
1154  {
1155  volumeName += " ";
1156  volumeName += nextTouchable->GetReplicaNumber();
1157  }
1158  }
1159  else
1160  {
1161  volumeName = "OutOfWorld";
1162  }
1163 
1164  G4cout << setw(18) << left << GetIT(track)->GetName() << setw(15)
1165  << track->GetTrackID() << std::setprecision(3) << setw(35)
1166  << G4String(G4BestUnit(track->GetPosition(), "Length")) << setw(25)
1167  << volumeName << setw(25) << "---" << G4endl;
1168 
1169 }
1170 
1171 void G4ITSteppingVerbose::PostStepVerbose(G4Track* track)
1172 {
1173  if(fVerboseLevel <= 0) return;
1174 
1175  G4IosFlagsSaver ios_saver(G4cout);
1176 
1178  // POST STEP VERBOSE
1179 
1180  G4cout << setw(18) << left << GetIT(track)->GetName() << setw(15)
1181  << track->GetTrackID() << std::setprecision(3) << setw(35)
1182  << G4String(G4BestUnit(track->GetPosition(), "Length")) << setw(25)
1183  << "---";
1184 
1185  G4TouchableHandle nextTouchable = track->GetNextTouchableHandle();
1186  G4VPhysicalVolume* volume(0);
1187 
1188  if(nextTouchable && (volume = nextTouchable->GetVolume()))
1189  {
1190  G4String volumeName = volume->GetName();
1191 
1192  if(volume->IsParameterised() || volume->IsReplicated())
1193  {
1194  volumeName += " ";
1195  volumeName += nextTouchable->GetReplicaNumber();
1196  }
1197 
1198  G4cout << setw(25) << volumeName;
1199  }
1200  else
1201  {
1202  G4cout << setw(25) << "OutOfWorld";
1203  }
1204  if(track->GetStep()->GetPostStepPoint()->GetProcessDefinedStep())
1205  {
1206  G4cout
1207  << setw(22)
1208  << track->GetStep()->GetPostStepPoint()->GetProcessDefinedStep()
1209  ->GetProcessName();
1210  }
1211  else
1212  {
1213  G4cout << "---";
1214  }
1215  G4cout << G4endl;
1216 
1217  if(fVerboseLevel > 2)
1218  {
1219  const G4TrackVector* secondaries = 0;
1220  if((secondaries = track->GetStep()->GetSecondary()))
1221  {
1222  if(secondaries->empty() == false)
1223  {
1224  G4cout << "\t\t ---->";
1225  for(size_t j = 0; j < secondaries->size(); ++j)
1226  {
1227  G4cout << GetIT((*secondaries)[j])->GetName() << "("
1228  << (*secondaries)[j]->GetTrackID() << ")" << " ";
1229  }
1230  G4cout << G4endl;
1231  }
1232  }
1233  }
1234 
1235  G4cout << G4endl;
1236 }
1237 
1238 void G4ITSteppingVerbose::AtRestDoItOneByOne()
1239 {
1240  CopyState();
1241 
1242  G4cout << " Invoke at rest process : "
1243  << fCurrentProcess->GetProcessName()
1244  << G4endl;
1245 }
G4Track::GetDefinition
G4ParticleDefinition * GetDefinition() const
G4IT.hh
mm
static constexpr double mm
Definition: G4SIunits.hh:115
fPostponeToNextEvent
Definition: G4TrackStatus.hh:62
fSuspend
Definition: G4TrackStatus.hh:61
fStopButAlive
Definition: G4TrackStatus.hh:54
G4VPhysicalVolume::IsReplicated
virtual G4bool IsReplicated() const =0
ExclusivelyForced
Definition: G4ForceCondition.hh:61
G4Track::GetPosition
const G4ThreeVector & GetPosition() const
G4UnitsTable.hh
G4IosFlagsSaver.hh
G4ITSteppingVerbose::TrackingEnded
void TrackingEnded(G4Track *)
Definition: G4ITSteppingVerbose.cc:658
G4BestUnit
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
Definition: G4SteppingVerbose.cc:53
G4IT::GetName
virtual const G4String & GetName() const =0
Forced
Definition: G4ForceCondition.hh:54
G4Track::GetStep
const G4Step * GetStep() const
G4int
int G4int
Definition: G4Types.hh:78
G4ParticleDefinition::GetParticleName
const G4String & GetParticleName() const
Definition: G4ParticleDefinition.hh:120
G4StepStatus
G4StepStatus
Definition: G4StepStatus.hh:49
fPostStepDoItProc
Definition: G4StepStatus.hh:60
G4Track::GetNextVolume
G4VPhysicalVolume * GetNextVolume() const
G4ITSteppingVerbose::TrackingStarted
void TrackingStarted(G4Track *)
Definition: G4ITSteppingVerbose.cc:589
GetIT
G4IT * GetIT(const G4Track *track)
Definition: G4IT.cc:49
CLHEP::prec
static const double prec
Definition: RanecuEngine.cc:58
G4cout
G4GLOB_DLL std::ostream G4cout
CandidateForSelection
Definition: G4GPILSelection.hh:52
G4VPhysicalVolume::GetName
const G4String & GetName() const
RESET_COLOR
#define RESET_COLOR
Definition: G4Scheduler.cc:87
fUndefined
Definition: G4StepStatus.hh:66
G4Track::GetNextTouchableHandle
const G4TouchableHandle & GetNextTouchableHandle() const
G4Track::GetTrackID
G4int GetTrackID() const
G4Track::GetGlobalTime
G4double GetGlobalTime() const
G4VProcess::GetProcessName
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
G4VPhysicalVolume::IsParameterised
virtual G4bool IsParameterised() const =0
fGeomBoundary
Definition: G4StepStatus.hh:54
NotCandidateForSelection
Definition: G4GPILSelection.hh:57
G4StepPoint::GetProcessDefinedStep
const G4VProcess * GetProcessDefinedStep() const
G4TrackVector
std::vector< G4Track * > G4TrackVector
Definition: G4TrackVector.hh:49
G4VTouchable::GetVolume
virtual G4VPhysicalVolume * GetVolume(G4int depth=0) const
Definition: G4VTouchable.cc:44
Conditionally
Definition: G4ForceCondition.hh:58
G4Step::GetPostStepPoint
G4StepPoint * GetPostStepPoint() const
G4VTouchable::GetReplicaNumber
virtual G4int GetReplicaNumber(G4int depth=0) const
Definition: G4VTouchable.cc:58
G4ITSteppingVerbose::PostStepVerbose
void PostStepVerbose(G4Track *track)
Definition: G4ITSteppingVerbose.cc:1171
fStopAndKill
Definition: G4TrackStatus.hh:56
G4endl
#define G4endl
Definition: G4ios.hh:61
G4StepStatus.hh
G4ITSteppingVerbose.hh
G4SystemOfUnits.hh
fAlive
Definition: G4TrackStatus.hh:53
fAlongStepDoItProc
Definition: G4StepStatus.hh:58
fAtRestDoItProc
Definition: G4StepStatus.hh:56
ns
#define ns
Definition: xmlparse.cc:614
fKillTrackAndSecondaries
Definition: G4TrackStatus.hh:58
G4Step::GetSecondary
const G4TrackVector * GetSecondary() const
G4ITStepProcessor.hh
StronglyForced
Definition: G4ForceCondition.hh:64
LIGHT_RED
#define LIGHT_RED
Definition: G4Scheduler.cc:84
left
Definition: F04UserTrackInformation.hh:37
G4ITSteppingVerbose::PreStepVerbose
void PreStepVerbose(G4Track *track)
Definition: G4ITSteppingVerbose.cc:1122