Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4ITSteppingVerbose Class Reference

#include <G4ITSteppingVerbose.hh>

Inheritance diagram for G4ITSteppingVerbose:
Collaboration diagram for G4ITSteppingVerbose:

Public Member Functions

 G4ITSteppingVerbose ()
 
 ~G4ITSteppingVerbose ()
 
void NewStep ()
 
void StepInfoForLeadingTrack ()
 
void AtRestDoItInvoked ()
 
void AtRestDoItOneByOne ()
 
void AlongStepDoItAllDone ()
 
void AlongStepDoItOneByOne ()
 
void PostStepDoItAllDone ()
 
void PostStepDoItOneByOne ()
 
void StepInfo ()
 
void TrackingStarted (G4Track *)
 
void TrackingEnded (G4Track *)
 
void DoItStarted ()
 
void PreStepVerbose (G4Track *track)
 
void PostStepVerbose (G4Track *track)
 
void DPSLStarted ()
 
void DPSLUserLimit ()
 
void DPSLPostStep ()
 
void DPSLAlongStep ()
 
void VerboseTrack ()
 
void VerboseParticleChange ()
 
void ShowStep () const
 
- Public Member Functions inherited from G4VITSteppingVerbose
 G4VITSteppingVerbose ()
 
virtual ~G4VITSteppingVerbose ()
 
void CopyState ()
 
void SetVerbose (int flag)
 
G4int GetVerbose ()
 
virtual void SetNewValue (G4UIcommand *command, G4String newValue)
 
virtual G4String GetCurrentValue (G4UIcommand *command)
 
void SetStepProcessor (const G4ITStepProcessor *stepProcessor)
 
void TrackBanner (G4Track *track, const G4String &message)
 

Additional Inherited Members

- Protected Types inherited from G4VITSteppingVerbose
typedef std::vector< G4intG4SelectedAtRestDoItVector
 
typedef std::vector< G4intG4SelectedAlongStepDoItVector
 
typedef std::vector< G4intG4SelectedPostStepDoItVector
 
- Protected Attributes inherited from G4VITSteppingVerbose
const G4ITStepProcessorfpStepProcessor
 
G4UIcmdWithAnIntegerfpVerboseUI
 
G4ITStepProcessorStatefpState
 
const ProcessGeneralInfofpProcessGeneralInfo
 
G4double PhysicalStep
 
G4StepStatus fStepStatus
 
const G4VParticleChangefParticleChange
 
const G4TrackfTrack
 
const G4TrackVectorfSecondary
 
const G4StepfStep
 
G4StepPointfPreStepPoint
 
G4StepPointfPostStepPoint
 
const G4VPhysicalVolumefCurrentVolume
 
const G4VITProcessfCurrentProcess
 
G4ProcessVectorfAtRestDoItVector
 
G4ProcessVectorfAlongStepDoItVector
 
G4ProcessVectorfPostStepDoItVector
 
G4ProcessVectorfAtRestGetPhysIntVector
 
G4ProcessVectorfAlongStepGetPhysIntVector
 
G4ProcessVectorfPostStepGetPhysIntVector
 
size_t MAXofAtRestLoops
 
size_t MAXofAlongStepLoops
 
size_t MAXofPostStepLoops
 
size_t fAtRestDoItProcTriggered
 
size_t fPostStepDoItProcTriggered
 
G4int fN2ndariesAtRestDoIt
 
G4int fN2ndariesAlongStepDoIt
 
G4int fN2ndariesPostStepDoIt
 
G4int fVerboseLevel
 
G4SelectedAtRestDoItVectorfSelectedAtRestDoItVector
 
G4SelectedPostStepDoItVectorfSelectedPostStepDoItVector
 
G4double fPreviousStepSize
 
G4TouchableHandle fTouchableHandle
 
G4double physIntLength
 
G4ForceCondition fCondition
 
G4GPILSelection fGPILSelection
 

Detailed Description

Definition at line 45 of file G4ITSteppingVerbose.hh.

Constructor & Destructor Documentation

G4ITSteppingVerbose::G4ITSteppingVerbose ( )

Definition at line 58 of file G4ITSteppingVerbose.cc.

60 {
61 #ifdef G4_TRACKING_DEBUG
62  G4cout << "G4ITSteppingVerbose has instantiated" << G4endl;
63 #endif
64 }
G4GLOB_DLL std::ostream G4cout
#define G4endl
Definition: G4ios.hh:61
G4ITSteppingVerbose::~G4ITSteppingVerbose ( )

Definition at line 67 of file G4ITSteppingVerbose.cc.

69 {
70 }

Member Function Documentation

void G4ITSteppingVerbose::AlongStepDoItAllDone ( )
virtual

Implements G4VITSteppingVerbose.

Definition at line 146 of file G4ITSteppingVerbose.cc.

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 }
const G4TrackVector * fSecondary
tuple x
Definition: test.py:50
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
G4GLOB_DLL std::ostream G4cout
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
tuple z
Definition: test.py:28
#define G4endl
Definition: G4ios.hh:61

Here is the call graph for this function:

void G4ITSteppingVerbose::AlongStepDoItOneByOne ( )
virtual

Implements G4VITSteppingVerbose.

Definition at line 676 of file G4ITSteppingVerbose.cc.

678 {
679  if(fVerboseLevel < 4)
680  {
681  return;
682  }
683 
684  CopyState();
685 
686  G4cout << G4endl;
687  G4cout << " >>AlongStepDoIt (process by process): " << " Process Name = "
689 
690  ShowStep();
691  G4cout << " " << "!Note! Safety of PostStep is only valid "
692  << "after all DoIt invocations." << G4endl;
693 
695  G4cout << G4endl;
696 
697  G4cout << " ++List of secondaries generated " << "(x,y,z,kE,t,PID):"
698  << " No. of secodaries = " << fN2ndariesAlongStepDoIt << G4endl;
699 
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 }
const G4TrackVector * fSecondary
const G4VITProcess * fCurrentProcess
tuple x
Definition: test.py:50
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
G4GLOB_DLL std::ostream G4cout
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
tuple z
Definition: test.py:28
#define G4endl
Definition: G4ios.hh:61
void G4ITSteppingVerbose::AtRestDoItInvoked ( )
virtual

Implements G4VITSteppingVerbose.

Definition at line 79 of file G4ITSteppingVerbose.cc.

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 }
const G4TrackVector * fSecondary
tuple x
Definition: test.py:50
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
int G4int
Definition: G4Types.hh:78
G4GLOB_DLL std::ostream G4cout
G4SelectedAtRestDoItVector * fSelectedAtRestDoItVector
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
tuple z
Definition: test.py:28
#define G4endl
Definition: G4ios.hh:61

Here is the call graph for this function:

void G4ITSteppingVerbose::AtRestDoItOneByOne ( )
virtual

Implements G4VITSteppingVerbose.

Definition at line 1238 of file G4ITSteppingVerbose.cc.

1239 {
1240  CopyState();
1241 
1242  G4cout << " Invoke at rest process : "
1244  << G4endl;
1245 }
const G4VITProcess * fCurrentProcess
G4GLOB_DLL std::ostream G4cout
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
#define G4endl
Definition: G4ios.hh:61
void G4ITSteppingVerbose::DoItStarted ( )
virtual

Implements G4VITSteppingVerbose.

Definition at line 1104 of file G4ITSteppingVerbose.cc.

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 }
G4GLOB_DLL std::ostream G4cout
#define RESET_COLOR
Definition: G4Scheduler.cc:87
#define G4endl
Definition: G4ios.hh:61
#define LIGHT_RED
Definition: G4Scheduler.cc:84
void G4ITSteppingVerbose::DPSLAlongStep ( )
virtual

Implements G4VITSteppingVerbose.

Definition at line 558 of file G4ITSteppingVerbose.cc.

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() << " (";
574  {
575  G4cout << "CandidateForSelection)" << G4endl;
576  }
578  {
579  G4cout << "NotCandidateForSelection)" << G4endl;
580  }
581  else
582  {
583  G4cout << "?!?)" << G4endl;
584  }
585  }
586 }
const G4VITProcess * fCurrentProcess
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
G4GLOB_DLL std::ostream G4cout
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
G4GPILSelection fGPILSelection
#define G4endl
Definition: G4ios.hh:61
void G4ITSteppingVerbose::DPSLPostStep ( )
virtual

Implements G4VITSteppingVerbose.

Definition at line 520 of file G4ITSteppingVerbose.cc.

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() << " (";
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 }
const G4VITProcess * fCurrentProcess
G4GLOB_DLL std::ostream G4cout
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
#define G4endl
Definition: G4ios.hh:61
void G4ITSteppingVerbose::DPSLStarted ( )
virtual

Implements G4VITSteppingVerbose.

Definition at line 487 of file G4ITSteppingVerbose.cc.

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 }
G4GLOB_DLL std::ostream G4cout
#define G4endl
Definition: G4ios.hh:61
void G4ITSteppingVerbose::DPSLUserLimit ( )
virtual

Implements G4VITSteppingVerbose.

Definition at line 502 of file G4ITSteppingVerbose.cc.

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 }
G4GLOB_DLL std::ostream G4cout
#define G4endl
Definition: G4ios.hh:61
void G4ITSteppingVerbose::NewStep ( )
virtual

Implements G4VITSteppingVerbose.

Definition at line 73 of file G4ITSteppingVerbose.cc.

75 {
76 }
void G4ITSteppingVerbose::PostStepDoItAllDone ( )
virtual

Implements G4VITSteppingVerbose.

Definition at line 203 of file G4ITSteppingVerbose.cc.

205 {
206  if(fVerboseLevel == 0)
207  {
208  return;
209  }
210 
211  G4VProcess* ptProcManager;
212 
213  CopyState();
214 
215  if(fVerboseLevel >= 3)
216  {
217 
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 }
const G4TrackVector * fSecondary
tuple x
Definition: test.py:50
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
int G4int
Definition: G4Types.hh:78
G4GLOB_DLL std::ostream G4cout
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
tuple z
Definition: test.py:28
#define G4endl
Definition: G4ios.hh:61
G4SelectedPostStepDoItVector * fSelectedPostStepDoItVector

Here is the call graph for this function:

void G4ITSteppingVerbose::PostStepDoItOneByOne ( )
virtual

Implements G4VITSteppingVerbose.

Definition at line 721 of file G4ITSteppingVerbose.cc.

723 {
724  if(fVerboseLevel < 4)
725  {
726  return;
727  }
728 
729  CopyState();
730  G4cout << G4endl;
731  G4cout << " >>PostStepDoIt (process by process): " << " Process Name = "
733 
734  ShowStep();
735  G4cout << G4endl;
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 }
const G4TrackVector * fSecondary
const G4VITProcess * fCurrentProcess
tuple x
Definition: test.py:50
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
G4GLOB_DLL std::ostream G4cout
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
tuple z
Definition: test.py:28
#define G4endl
Definition: G4ios.hh:61
void G4ITSteppingVerbose::PostStepVerbose ( G4Track track)
virtual

Implements G4VITSteppingVerbose.

Definition at line 1171 of file G4ITSteppingVerbose.cc.

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  }
1205  {
1206  G4cout
1207  << setw(22)
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 }
const G4ThreeVector & GetPosition() const
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
virtual const G4String & GetName() const =0
const G4Step * GetStep() const
G4IT * GetIT(const G4Track *track)
Definition: G4IT.cc:49
G4GLOB_DLL std::ostream G4cout
const G4TouchableHandle & GetNextTouchableHandle() const
G4int GetTrackID() const
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
const G4VProcess * GetProcessDefinedStep() const
std::vector< G4Track * > G4TrackVector
virtual G4VPhysicalVolume * GetVolume(G4int depth=0) const
Definition: G4VTouchable.cc:44
G4StepPoint * GetPostStepPoint() const
virtual G4int GetReplicaNumber(G4int depth=0) const
Definition: G4VTouchable.cc:58
#define G4endl
Definition: G4ios.hh:61
const G4TrackVector * GetSecondary() const

Here is the call graph for this function:

void G4ITSteppingVerbose::PreStepVerbose ( G4Track track)
virtual

Implements G4VITSteppingVerbose.

Definition at line 1122 of file G4ITSteppingVerbose.cc.

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 }
const G4ThreeVector & GetPosition() const
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
virtual const G4String & GetName() const =0
G4IT * GetIT(const G4Track *track)
Definition: G4IT.cc:49
G4GLOB_DLL std::ostream G4cout
#define RESET_COLOR
Definition: G4Scheduler.cc:87
const G4TouchableHandle & GetNextTouchableHandle() const
G4int GetTrackID() const
G4double GetGlobalTime() const
virtual G4VPhysicalVolume * GetVolume(G4int depth=0) const
Definition: G4VTouchable.cc:44
virtual G4int GetReplicaNumber(G4int depth=0) const
Definition: G4VTouchable.cc:58
#define G4endl
Definition: G4ios.hh:61
#define LIGHT_RED
Definition: G4Scheduler.cc:84

Here is the call graph for this function:

void G4ITSteppingVerbose::ShowStep ( ) const

Definition at line 926 of file G4ITSteppingVerbose.cc.

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)
968  G4cout << " Local Time (ns) : " << std::setw(20)
969  << fStep->GetPreStepPoint()->GetLocalTime() << std::setw(20)
971  G4cout << " Proper Time (ns) : " << std::setw(20)
972  << fStep->GetPreStepPoint()->GetProperTime() << std::setw(20)
974  G4cout << " Momentum Direct - x : " << std::setw(20)
976  << std::setw(20)
978  G4cout << " Momentum Direct - y : " << std::setw(20)
980  << std::setw(20)
982  G4cout << " Momentum Direct - z : " << std::setw(20)
984  << std::setw(20)
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)
998  G4cout << " Kinetic Energy (MeV): " << std::setw(20)
999  << fStep->GetPreStepPoint()->GetKineticEnergy() << std::setw(20)
1001  G4cout << " Velocity (mm/ns) : " << std::setw(20)
1002  << fStep->GetPreStepPoint()->GetVelocity() << std::setw(20)
1004  G4cout << " Volume Name : " << std::setw(20)
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)
1021  G4cout << " Polarization - y : " << std::setw(20)
1022  << fStep->GetPreStepPoint()->GetPolarization().y() << std::setw(20)
1024  G4cout << " Polarization - Z : " << std::setw(20)
1025  << fStep->GetPreStepPoint()->GetPolarization().z() << std::setw(20)
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: ";
1078  {
1079  G4cout << std::setw(20) << "Undefined";
1080  }
1081  else
1082  {
1083  G4cout
1084  << std::setw(20)
1086  }
1088  {
1089  G4cout << std::setw(20) << "Undefined";
1090  }
1091  else
1092  {
1093  G4cout
1094  << std::setw(20)
1096  }
1097  G4cout.precision(oldprc);
1098 
1099  G4cout << G4endl;
1100  G4cout << " -------------------------------------------------------"
1101  << "----------------" << G4endl;
1102 }
G4double GetTotalEnergy() const
G4double GetWeight() const
double x() const
G4StepStatus GetStepStatus() const
G4ThreeVector GetMomentum() const
G4double GetVelocity() const
int G4int
Definition: G4Types.hh:78
double z() const
G4StepStatus
Definition: G4StepStatus.hh:49
G4double GetLocalTime() const
G4StepPoint * GetPreStepPoint() const
const G4ThreeVector & GetMomentumDirection() const
G4GLOB_DLL std::ostream G4cout
G4VPhysicalVolume * GetPhysicalVolume() const
const G4String & GetName() const
const G4ThreeVector & GetPosition() const
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
G4double GetTotalEnergyDeposit() const
const G4VProcess * GetProcessDefinedStep() const
G4StepPoint * GetPostStepPoint() const
double y() const
G4double GetSafety() const
G4double GetProperTime() const
#define G4endl
Definition: G4ios.hh:61
G4double GetGlobalTime() const
G4double GetKineticEnergy() const
G4Track * GetTrack() const
const G4ThreeVector & GetPolarization() const
G4double GetStepLength() const
void G4ITSteppingVerbose::StepInfo ( )
virtual

Implements G4VITSteppingVerbose.

Definition at line 383 of file G4ITSteppingVerbose.cc.

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  }
441  {
442  G4cout
444  }
445  else
446  {
447  G4cout << "User Limit";
448  }
449  G4cout << G4endl;
450  if(fVerboseLevel == 2)
451  {
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 }
const G4TrackVector * fSecondary
G4double GetStepLength() const
double x() const
const G4ThreeVector & GetPosition() const
tuple x
Definition: test.py:50
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
int G4int
Definition: G4Types.hh:78
double z() const
G4VPhysicalVolume * GetNextVolume() const
static const double prec
Definition: RanecuEngine.cc:58
G4double GetKineticEnergy() const
G4GLOB_DLL std::ostream G4cout
G4int GetCurrentStepNumber() const
const G4String & GetName() const
G4int GetTrackID() const
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
G4double GetTotalEnergyDeposit() const
G4double GetTrackLength() const
const G4VProcess * GetProcessDefinedStep() const
G4StepPoint * GetPostStepPoint() const
double y() const
tuple z
Definition: test.py:28
#define G4endl
Definition: G4ios.hh:61
void G4ITSteppingVerbose::StepInfoForLeadingTrack ( )
virtual

Implements G4VITSteppingVerbose.

Definition at line 277 of file G4ITSteppingVerbose.cc.

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  }
337  {
338  G4cout
340  }
341  else
342  {
343  G4cout << "User Limit";
344  }
345 
346  G4cout << G4endl;
347  if(fVerboseLevel == 2)
348  {
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 }
const G4TrackVector * fSecondary
G4double GetStepLength() const
double x() const
const G4ThreeVector & GetPosition() const
tuple x
Definition: test.py:50
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
int G4int
Definition: G4Types.hh:78
double z() const
G4VPhysicalVolume * GetNextVolume() const
static const double prec
Definition: RanecuEngine.cc:58
G4double GetKineticEnergy() const
G4GLOB_DLL std::ostream G4cout
G4int GetCurrentStepNumber() const
const G4String & GetName() const
G4int GetTrackID() const
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
G4double GetTotalEnergyDeposit() const
G4double GetTrackLength() const
const G4VProcess * GetProcessDefinedStep() const
G4StepPoint * GetPostStepPoint() const
double y() const
tuple z
Definition: test.py:28
#define G4endl
Definition: G4ios.hh:61
void G4ITSteppingVerbose::TrackingEnded ( G4Track track)
virtual

Reimplemented from G4VITSteppingVerbose.

Definition at line 658 of file G4ITSteppingVerbose.cc.

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 }
G4ParticleDefinition * GetDefinition() const
const G4String & GetParticleName() const
G4VPhysicalVolume * GetNextVolume() const
G4GLOB_DLL std::ostream G4cout
const G4String & GetName() const
G4int GetTrackID() const
#define G4endl
Definition: G4ios.hh:61

Here is the call graph for this function:

void G4ITSteppingVerbose::TrackingStarted ( G4Track track)
virtual

Reimplemented from G4VITSteppingVerbose.

Definition at line 589 of file G4ITSteppingVerbose.cc.

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 }
double x() const
const G4ThreeVector & GetPosition() const
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
virtual const G4String & GetName() const =0
const G4Step * GetStep() const
int G4int
Definition: G4Types.hh:78
double z() const
G4VPhysicalVolume * GetNextVolume() const
G4IT * GetIT(const G4Track *track)
Definition: G4IT.cc:49
static const double prec
Definition: RanecuEngine.cc:58
G4GLOB_DLL std::ostream G4cout
const G4String & GetName() const
G4int GetTrackID() const
double y() const
#define G4endl
Definition: G4ios.hh:61

Here is the call graph for this function:

void G4ITSteppingVerbose::VerboseParticleChange ( )
virtual

Implements G4VITSteppingVerbose.

Definition at line 913 of file G4ITSteppingVerbose.cc.

915 {
916  if(fVerboseLevel == 0)
917  {
918  return;
919  }
920 // Show header
921  G4cout << G4endl;
922  G4cout << " ++G4ParticleChange Information " << G4endl;
924 }
virtual void DumpInfo() const
G4GLOB_DLL std::ostream G4cout
const G4VParticleChange * fParticleChange
#define G4endl
Definition: G4ios.hh:61
void G4ITSteppingVerbose::VerboseTrack ( )
virtual

Implements G4VITSteppingVerbose.

Definition at line 764 of file G4ITSteppingVerbose.cc.

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)
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  }
856  {
857  G4cout << " KillTrackAndSecondaries";
858  }
859  else if(fTrack->GetTrackStatus() == fSuspend)
860  {
861  G4cout << " Suspend";
862  }
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)
885  G4cout << " Vertex - Py (MomDir): " << std::setw(20)
887  G4cout << " Vertex - Pz (MomDir): " << std::setw(20)
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  {
905  }
906 
907  G4cout << " -----------------------------------------------" << G4endl;
908 
909  G4cout.precision(prec);
910 }
G4int GetParentID() const
const G4ThreeVector & GetPolarization() const
G4double GetLocalTime() const
static constexpr double mm
Definition: G4SIunits.hh:115
double x() const
const G4ThreeVector & GetPosition() const
G4TrackStatus GetTrackStatus() const
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
int G4int
Definition: G4Types.hh:78
double z() const
G4VPhysicalVolume * GetNextVolume() const
const G4VProcess * GetCreatorProcess() const
static const double prec
Definition: RanecuEngine.cc:58
G4double GetKineticEnergy() const
G4GLOB_DLL std::ostream G4cout
G4int GetCurrentStepNumber() const
const G4String & GetName() const
G4double GetVertexKineticEnergy() const
G4int GetTrackID() const
G4double GetGlobalTime() const
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
const G4ThreeVector & GetVertexPosition() const
G4double GetTrackLength() const
const G4ThreeVector & GetMomentumDirection() const
double y() const
#define G4endl
Definition: G4ios.hh:61
const G4ThreeVector & GetVertexMomentumDirection() const
#define ns
Definition: xmlparse.cc:614

The documentation for this class was generated from the following files: