Geant4 11.1.1
Toolkit for the simulation of the passage of particles through matter
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
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//
28//---------------------------------------------------------------
29//
30// G4ITSteppingVerbose.cc
31//
32// Description:
33// Implementation of the G4ITSteppingVerbose class
34//
35//---------------------------------------------------------------
36
37#include "G4ITSteppingVerbose.hh"
38#include "G4ITStepProcessor.hh"
39#include "G4SystemOfUnits.hh"
40#include "G4StepStatus.hh" // Include from 'tracking'
41
42#include "G4IT.hh"
43#include "G4IosFlagsSaver.hh"
44
45#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
46
47#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
48#include "G4UnitsTable.hh"
49#else
50#define G4BestUnit(a,b) a
51#endif
52
53using namespace std;
54
55//////////////////////////////////////////////////
56G4ITSteppingVerbose::G4ITSteppingVerbose()
57//////////////////////////////////////////////////
58{
59#ifdef G4_TRACKING_DEBUG
60 G4cout << "G4ITSteppingVerbose has instantiated" << G4endl;
61#endif
62}
63
64//////////////////////////////////////////////////
65G4ITSteppingVerbose::~G4ITSteppingVerbose()
66//////////////////////////////////////////////////
67{
68}
69
70//////////////////////////////////////////////////
71void G4ITSteppingVerbose::NewStep()
72//////////////////////////////////////////////////
73{
74}
75
76//////////////////////////////////////////////////
77void G4ITSteppingVerbose::AtRestDoItInvoked()
78//////////////////////////////////////////////////
79{
80 if(fVerboseLevel == 0)
81 {
82 return;
83 }
84
85 G4VProcess* ptProcManager;
86 CopyState();
87
88 if(fVerboseLevel >= 3)
89 {
90 G4int npt = 0;
91 G4cout << " **List of AtRestDoIt invoked:" << G4endl;
92 for(std::size_t np = 0; np < MAXofAtRestLoops; ++np)
93 {
94 std::size_t npGPIL = MAXofAtRestLoops - np - 1;
95 if((*fSelectedAtRestDoItVector)[npGPIL] == 2)
96 {
97 ++npt;
98 ptProcManager = (*fAtRestDoItVector)[(G4int)np];
99 G4cout << " # " << npt << " : " << ptProcManager->GetProcessName()
100 << " (Forced)" << G4endl;
101 }
102 else if ( (*fSelectedAtRestDoItVector)[npGPIL] == 1 )
103 {
104 ++npt;
105 ptProcManager = (*fAtRestDoItVector)[(G4int)np];
106 G4cout << " # " << npt << " : " << ptProcManager->GetProcessName()
107 << G4endl;
108 }
109 }
110
111 G4cout << " Generated secondries # : " << fN2ndariesAtRestDoIt << G4endl;
112
113 if(fN2ndariesAtRestDoIt > 0)
114 {
115 G4cout << " -- List of secondaries generated : "
116 << "(x,y,z,kE,t,PID) --" << G4endl;
117 for(std::size_t lp1=(*fSecondary).size()-fN2ndariesAtRestDoIt;
118 lp1<(*fSecondary).size(); ++lp1)
119 {
120 G4cout << " "
121 << std::setw( 9)
122 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(),"Length") << " "
123 << std::setw( 9)
124 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(),"Length") << " "
125 << std::setw( 9)
126 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(),"Length") << " "
127 << std::setw( 9)
128 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(),"Energy") << " "
129 << std::setw( 9)
130 << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(),"Time") << " "
131 << std::setw(18)
132 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
133 }
134 }
135 }
136
137 if(fVerboseLevel >= 4)
138 {
139 ShowStep();
140 G4cout << G4endl;
141 }
142}
143/////////////////////////////////////////////////////
144void G4ITSteppingVerbose::AlongStepDoItAllDone()
145/////////////////////////////////////////////////////
146{
147 if(fVerboseLevel == 0)
148 {
149 return;
150 }
151
152 G4VProcess* ptProcManager;
153
154 CopyState();
155
156 if(fVerboseLevel >= 3)
157 {
158 G4cout << G4endl;
159 G4cout << " >>AlongStepDoIt (after all invocations):" << G4endl;
160 G4cout << " ++List of invoked processes " << G4endl;
161
162 for(std::size_t ci=0; ci<MAXofAlongStepLoops; ++ci)
163 {
164 ptProcManager = (*fAlongStepDoItVector)((G4int)ci);
165 G4cout << " " << ci+1 << ") ";
166 if(ptProcManager != 0)
167 {
168 G4cout << ptProcManager->GetProcessName() << G4endl;
169 }
170 }
171
172 ShowStep();
173 G4cout << G4endl;
174 G4cout << " ++List of secondaries generated "
175 << "(x,y,z,kE,t,PID):"
176 << " No. of secodaries = "
177 << (*fSecondary).size() << G4endl;
178
179 if((*fSecondary).size()>0)
180 {
181 for(std::size_t lp1=0; lp1<(*fSecondary).size(); ++lp1)
182 {
183 G4cout << " "
184 << std::setw( 9)
185 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(),"Length") << " "
186 << std::setw( 9)
187 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(),"Length") << " "
188 << std::setw( 9)
189 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(),"Length") << " "
190 << std::setw( 9)
191 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(),"Energy") << " "
192 << std::setw( 9)
193 << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(),"Time") << " "
194 << std::setw(18)
195 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
196 }
197 }
198 }
199}
200////////////////////////////////////////////////////
201void G4ITSteppingVerbose::PostStepDoItAllDone()
202////////////////////////////////////////////////////
203{
204 if(fVerboseLevel == 0)
205 {
206 return;
207 }
208
209 G4VProcess* ptProcManager;
210
211 CopyState();
212
213 if(fVerboseLevel >= 3)
214 {
215
216 if((fStepStatus == fPostStepDoItProc) | (fCondition == Forced)
217 | (fCondition == Conditionally) | (fCondition == ExclusivelyForced)
218 | (fCondition == StronglyForced))
219 {
220
221 G4int npt = 0;
222 G4cout << G4endl;
223 G4cout << " **PostStepDoIt (after all invocations):" << G4endl;
224 G4cout << " ++List of invoked processes " << G4endl;
225
226 for(std::size_t np = 0; np < MAXofPostStepLoops; ++np)
227 {
228 std::size_t npGPIL = MAXofPostStepLoops - np - 1;
229 if((*fSelectedPostStepDoItVector)[npGPIL] == 2)
230 {
231 npt++;
232 ptProcManager = (*fPostStepDoItVector)[(G4int)np];
233 G4cout << " " << npt << ") " << ptProcManager->GetProcessName()
234 << " (Forced)" << G4endl;
235 }
236 else if ( (*fSelectedPostStepDoItVector)[npGPIL] == 1)
237 {
238 npt++;
239 ptProcManager = (*fPostStepDoItVector)[(G4int)np];
240 G4cout << " " << npt << ") "
241 << ptProcManager->GetProcessName() << G4endl;
242 }
243 }
244
245 ShowStep();
246 G4cout << G4endl;
247 G4cout << " ++List of secondaries generated " << "(x,y,z,kE,t,PID):"
248 << " No. of secodaries = " << (*fSecondary).size() << G4endl;
249 G4cout << " [Note]Secondaries from AlongStepDoIt included." << G4endl;
250
251 if((*fSecondary).size() > 0)
252 {
253 for(std::size_t lp1 = 0; lp1 < (*fSecondary).size(); ++lp1)
254 {
255 G4cout << " " << std::setw(9)
256 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length")
257 << " " << std::setw(9)
258 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length")
259 << " " << std::setw(9)
260 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length")
261 << " " << std::setw(9)
262 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy")
263 << " " << std::setw(9)
264 << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time")
265 << " " << std::setw(18)
266 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
267 << G4endl;
268 }
269 }
270 }
271 }
272}
273
274/////////////////////////////////////////
275void G4ITSteppingVerbose::StepInfoForLeadingTrack()
276/////////////////////////////////////////
277{
278 if(fVerboseLevel == 0)
279 {
280 return;
281 }
282
283 if(fVerboseLevel < 2)
284 {
285 CopyState();
286 G4long prec = G4cout.precision(3);
287 // G4cout.precision(16);
288
289 if(fVerboseLevel >= 4) VerboseTrack();
290 if(fVerboseLevel >= 3)
291 {
292 G4cout << G4endl;
293 G4cout << "StepInfo" << G4endl;
294#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
295 G4cout << std::setw( 5) << "#TrackID" << " "
296 << std::setw( 5) << "#Step#" << " "
297 << std::setw( 8) << "X" << " " << std::setw( 8) << "Y" << " "
298 << std::setw( 8) << "Z" << " "
299 << std::setw( 9) << "KineE" << " " << std::setw( 8) << "dE" << " "
300 << std::setw(12) << "StepLeng" << " " << std::setw(12) << "TrackLeng" << " "
301 << std::setw(12) << "NextVolume" << " " << std::setw( 8) << "ProcName" << G4endl;
302#else
303 G4cout << std::setw( 5) << "#TrackID" << " "
304 << std::setw( 5) << "#Step#" << " "
305 << std::setw( 8) << "X(mm)" << " " << std::setw( 8) << "Y(mm)" << " "
306 << std::setw( 8) << "Z(mm)" << " "
307 << std::setw( 9) << "KinE(MeV)" << " " << std::setw( 8) << "dE(MeV)" << " "
308 << std::setw( 8) << "StepLeng" << " " << std::setw( 9) << "TrackLeng" << " "
309 << std::setw(11) << "NextVolume" << " " << std::setw( 8) << "ProcName" << G4endl;
310#endif
311 }
312 G4cout << std::setw(5) << fTrack->GetTrackID() << " " << std::setw(5)
313 << fTrack->GetCurrentStepNumber() << " " << std::setw(8)
314 << G4BestUnit(fTrack->GetPosition().x(), "Length") << " "
315 << std::setw(8) << G4BestUnit(fTrack->GetPosition().y(), "Length")
316 << " " << std::setw(8)
317 << G4BestUnit(fTrack->GetPosition().z(), "Length") << " "
318 << std::setw(9) << G4BestUnit(fTrack->GetKineticEnergy(), "Energy")
319 << " " << std::setw(8)
320 << G4BestUnit(fStep->GetTotalEnergyDeposit(), "Energy") << " "
321 << std::setw(8) << G4BestUnit(fStep->GetStepLength(), "Length")
322 << " " << std::setw(9)
323 << G4BestUnit(fTrack->GetTrackLength(), "Length") << " ";
324
325 // Put cut comment here
326 if(fTrack->GetNextVolume() != 0)
327 {
328 G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
329 }
330 else
331 {
332 G4cout << std::setw(11) << "OutOfWorld" << " ";
333 }
334 if(fStep->GetPostStepPoint()->GetProcessDefinedStep() != 0)
335 {
336 G4cout
337 << fStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName();
338 }
339 else
340 {
341 G4cout << "User Limit";
342 }
343
344 G4cout << G4endl;
345 if(fVerboseLevel == 2)
346 {
347 G4int tN2ndariesTot = fN2ndariesAtRestDoIt + fN2ndariesAlongStepDoIt
348 + fN2ndariesPostStepDoIt;
349 if(tN2ndariesTot > 0)
350 {
351 G4cout << " :----- List of 2ndaries - " << "#SpawnInStep="
352 << std::setw(3) << tN2ndariesTot << "(Rest=" << std::setw(2)
353 << fN2ndariesAtRestDoIt << ",Along=" << std::setw(2)
354 << fN2ndariesAlongStepDoIt << ",Post=" << std::setw(2)
355 << fN2ndariesPostStepDoIt << "), " << "#SpawnTotal="
356 << std::setw(3) << (*fSecondary).size() << " ---------------"
357 << G4endl;
358
359 for(std::size_t lp1=(*fSecondary).size()-tN2ndariesTot;
360 lp1<(*fSecondary).size(); ++lp1)
361 {
362 G4cout << " : "
363 << std::setw( 9)
364 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x() , "Length")<< " "
365 << std::setw( 9)
366 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y() , "Length")<< " "
367 << std::setw( 9)
368 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z() , "Length") << " "
369 << std::setw( 9)
370 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy() , "Energy")<< " "
371 << std::setw(18)
372 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
373 }
374 G4cout << " :-----------------------------" << "----------------------------------"
375 << "-- EndOf2ndaries Info ---------------" << G4endl;
376 }
377 }
378 G4cout.precision(prec);
379 }
380}
381/////////////////////////////////////////
382void G4ITSteppingVerbose::StepInfo()
383/////////////////////////////////////////
384{
385 if(fVerboseLevel < 2)
386 {
387 return;
388 }
389
390 CopyState();
391 G4long prec = G4cout.precision(3);
392// G4cout.precision(16);
393
394 if(fVerboseLevel >= 4) VerboseTrack();
395 if(fVerboseLevel >= 3)
396 {
397 G4cout << G4endl;
398 G4cout << "StepInfo" << G4endl;
399#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
400 G4cout << std::setw( 5) << "#TrackID" << " "
401 << std::setw( 5) << "#Step#" << " "
402 << std::setw( 8) << "X" << " " << std::setw( 8) << "Y" << " "
403 << std::setw( 8) << "Z" << " "
404 << std::setw( 9) << "KineE" << " " << std::setw( 8) << "dE" << " "
405 << std::setw(12) << "StepLeng" << " " << std::setw(12) << "TrackLeng" << " "
406 << std::setw(12) << "NextVolume" << " " << std::setw( 8) << "ProcName" << G4endl;
407#else
408 G4cout << std::setw( 5) << "#TrackID" << " "
409 << std::setw( 5) << "#Step#" << " "
410 << std::setw( 8) << "X(mm)" << " " << std::setw( 8) << "Y(mm)" << " "
411 << std::setw( 8) << "Z(mm)" << " "
412 << std::setw( 9) << "KinE(MeV)" << " " << std::setw( 8) << "dE(MeV)" << " "
413 << std::setw( 8) << "StepLeng" << " " << std::setw( 9) << "TrackLeng" << " "
414 << std::setw(11) << "NextVolume" << " " << std::setw( 8) << "ProcName" << G4endl;
415#endif
416 }
417 G4cout << std::setw(5) << fTrack->GetTrackID() << " " << std::setw(5)
418 << fTrack->GetCurrentStepNumber() << " " << std::setw(8)
419 << G4BestUnit(fTrack->GetPosition().x(), "Length") << " "
420 << std::setw(8) << G4BestUnit(fTrack->GetPosition().y(), "Length")
421 << " " << std::setw(8)
422 << G4BestUnit(fTrack->GetPosition().z(), "Length") << " "
423 << std::setw(9) << G4BestUnit(fTrack->GetKineticEnergy(), "Energy")
424 << " " << std::setw(8)
425 << G4BestUnit(fStep->GetTotalEnergyDeposit(), "Energy") << " "
426 << std::setw(8) << G4BestUnit(fStep->GetStepLength(), "Length") << " "
427 << std::setw(9) << G4BestUnit(fTrack->GetTrackLength(), "Length")
428 << " ";
429
430 // Put cut comment here
431 if(fTrack->GetNextVolume() != 0)
432 {
433 G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
434 }
435 else
436 {
437 G4cout << std::setw(11) << "OutOfWorld" << " ";
438 }
439 if(fStep->GetPostStepPoint()->GetProcessDefinedStep() != 0)
440 {
441 G4cout
442 << fStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName();
443 }
444 else
445 {
446 G4cout << "User Limit";
447 }
448 G4cout << G4endl;
449 if(fVerboseLevel == 2)
450 {
451 G4int tN2ndariesTot = fN2ndariesAtRestDoIt + fN2ndariesAlongStepDoIt
452 + fN2ndariesPostStepDoIt;
453 if(tN2ndariesTot > 0)
454 {
455 G4cout << " :----- List of 2ndaries - " << "#SpawnInStep="
456 << std::setw(3) << tN2ndariesTot << "(Rest=" << std::setw(2)
457 << fN2ndariesAtRestDoIt << ",Along=" << std::setw(2)
458 << fN2ndariesAlongStepDoIt << ",Post=" << std::setw(2)
459 << fN2ndariesPostStepDoIt << "), " << "#SpawnTotal="
460 << std::setw(3) << (*fSecondary).size() << " ---------------"
461 << G4endl;
462
463 for(std::size_t lp1=(*fSecondary).size()-tN2ndariesTot;
464 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
486////////////////////////////////////////////
487void G4ITSteppingVerbose::DPSLStarted()
488////////////////////////////////////////////
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}
501//////////////////////////////////////////////
502void G4ITSteppingVerbose::DPSLUserLimit()
503//////////////////////////////////////////////
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}
519/////////////////////////////////////////////
520void G4ITSteppingVerbose::DPSLPostStep()
521/////////////////////////////////////////////
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}
557/////////////////////////////////////////////
558void G4ITSteppingVerbose::DPSLAlongStep()
559/////////////////////////////////////////////
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
588////////////////////////////////////////////////
589void G4ITSteppingVerbose::TrackingStarted(G4Track* track)
590////////////////////////////////////////////////
591{
592 if(fVerboseLevel <= 1)
593 {
594 return;
595 }
596
597 G4long 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
657////////////////////////////////////////////////
658void G4ITSteppingVerbose::TrackingEnded(G4Track* track)
659////////////////////////////////////////////////
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
675//////////////////////////////////////////////////////
676void G4ITSteppingVerbose::AlongStepDoItOneByOne()
677//////////////////////////////////////////////////////
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(std::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}
720//////////////////////////////////////////////////////
721void G4ITSteppingVerbose::PostStepDoItOneByOne()
722//////////////////////////////////////////////////////
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(std::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
763//////////////////////////////////////
764void G4ITSteppingVerbose::VerboseTrack()
765//////////////////////////////////////
766{
767 if(fVerboseLevel == 0)
768 {
769 return;
770 }
771
772 CopyState();
773// Show header
774 G4cout << G4endl;
775 G4cout << " ++G4Track Information " << G4endl;
776 G4long 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
912///////////////////////////////////////////////
913void G4ITSteppingVerbose::VerboseParticleChange()
914///////////////////////////////////////////////
915{
916 if(fVerboseLevel == 0)
917 {
918 return;
919 }
920// Show header
921 G4cout << G4endl;
922 G4cout << " ++G4ParticleChange Information " << G4endl;
923 fParticleChange->DumpInfo();
924}
925/////////////////////////////////////////
926void G4ITSteppingVerbose::ShowStep() const
927////////////////////////////////////////
928{
929 if(fVerboseLevel == 0)
930 {
931 return;
932 }
933
934 G4String volName;
935 G4long 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
1104void 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
1122void G4ITSteppingVerbose::PreStepVerbose(G4Track* track)
1123{
1124 if(fVerboseLevel <= 0) return;
1125
1126 G4IosFlagsSaver ios_saver(G4cout);
1127
1128/////
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 += (char)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
1171void G4ITSteppingVerbose::PostStepVerbose(G4Track* track)
1172{
1173 if(fVerboseLevel <= 0) return;
1174
1175 G4IosFlagsSaver ios_saver(G4cout);
1176
1177 /////
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 += (char)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(std::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
1238void G4ITSteppingVerbose::AtRestDoItOneByOne()
1239{
1240 CopyState();
1241
1242 G4cout << " Invoke at rest process : "
1243 << fCurrentProcess->GetProcessName()
1244 << G4endl;
1245}
StronglyForced
@ StronglyForced
Definition: G4ForceCondition.hh:55
Conditionally
@ Conditionally
Definition: G4ForceCondition.hh:49
ExclusivelyForced
@ ExclusivelyForced
Definition: G4ForceCondition.hh:52
Forced
@ Forced
Definition: G4ForceCondition.hh:44
CandidateForSelection
@ CandidateForSelection
Definition: G4GPILSelection.hh:42
NotCandidateForSelection
@ NotCandidateForSelection
Definition: G4GPILSelection.hh:47
GetIT
G4IT * GetIT(const G4Track *track)
Definition: G4IT.cc:48
LIGHT_RED
#define LIGHT_RED
Definition: G4Scheduler.cc:83
RESET_COLOR
#define RESET_COLOR
Definition: G4Scheduler.cc:86
G4StepStatus
G4StepStatus
Definition: G4StepStatus.hh:40
fGeomBoundary
@ fGeomBoundary
Definition: G4StepStatus.hh:43
fUndefined
@ fUndefined
Definition: G4StepStatus.hh:55
fPostStepDoItProc
@ fPostStepDoItProc
Definition: G4StepStatus.hh:49
fAtRestDoItProc
@ fAtRestDoItProc
Definition: G4StepStatus.hh:45
fAlongStepDoItProc
@ fAlongStepDoItProc
Definition: G4StepStatus.hh:47
fKillTrackAndSecondaries
@ fKillTrackAndSecondaries
Definition: G4TrackStatus.hh:48
fSuspend
@ fSuspend
Definition: G4TrackStatus.hh:50
fAlive
@ fAlive
Definition: G4TrackStatus.hh:42
fStopAndKill
@ fStopAndKill
Definition: G4TrackStatus.hh:46
fStopButAlive
@ fStopButAlive
Definition: G4TrackStatus.hh:44
fPostponeToNextEvent
@ fPostponeToNextEvent
Definition: G4TrackStatus.hh:52
G4TrackVector
std::vector< G4Track * > G4TrackVector
Definition: G4TrackVector.hh:43
G4long
long G4long
Definition: G4Types.hh:87
G4int
int G4int
Definition: G4Types.hh:85
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout
CLHEP::Hep3Vector::z
double z() const
CLHEP::Hep3Vector::x
double x() const
CLHEP::Hep3Vector::y
double y() const
G4ITSteppingVerbose::TrackingStarted
void TrackingStarted(G4Track *)
Definition: G4ITSteppingVerbose.cc:589
G4ITSteppingVerbose::TrackingEnded
void TrackingEnded(G4Track *)
Definition: G4ITSteppingVerbose.cc:658
G4ITSteppingVerbose::PostStepVerbose
void PostStepVerbose(G4Track *track)
Definition: G4ITSteppingVerbose.cc:1171
G4ITSteppingVerbose::PreStepVerbose
void PreStepVerbose(G4Track *track)
Definition: G4ITSteppingVerbose.cc:1122
G4IT::GetName
virtual const G4String & GetName() const =0
G4ParticleDefinition::GetParticleName
const G4String & GetParticleName() const
Definition: G4ParticleDefinition.hh:109
G4StepPoint::GetTotalEnergy
G4double GetTotalEnergy() const
G4StepPoint::GetStepStatus
G4StepStatus GetStepStatus() const
G4StepPoint::GetVelocity
G4double GetVelocity() const
G4StepPoint::GetProperTime
G4double GetProperTime() const
G4StepPoint::GetGlobalTime
G4double GetGlobalTime() const
G4StepPoint::GetSafety
G4double GetSafety() const
G4StepPoint::GetProcessDefinedStep
const G4VProcess * GetProcessDefinedStep() const
G4StepPoint::GetMomentum
G4ThreeVector GetMomentum() const
G4StepPoint::GetPosition
const G4ThreeVector & GetPosition() const
G4StepPoint::GetMomentumDirection
const G4ThreeVector & GetMomentumDirection() const
G4StepPoint::GetLocalTime
G4double GetLocalTime() const
G4StepPoint::GetPhysicalVolume
G4VPhysicalVolume * GetPhysicalVolume() const
G4StepPoint::GetPolarization
const G4ThreeVector & GetPolarization() const
G4StepPoint::GetKineticEnergy
G4double GetKineticEnergy() const
G4StepPoint::GetWeight
G4double GetWeight() const
G4Step::GetTrack
G4Track * GetTrack() const
G4Step::GetSecondary
const G4TrackVector * GetSecondary() const
G4Step::GetPreStepPoint
G4StepPoint * GetPreStepPoint() const
G4Step::GetStepLength
G4double GetStepLength() const
G4Step::GetTotalEnergyDeposit
G4double GetTotalEnergyDeposit() const
G4Step::GetPostStepPoint
G4StepPoint * GetPostStepPoint() const
G4Track::GetTrackStatus
G4TrackStatus GetTrackStatus() const
G4Track::GetVertexKineticEnergy
G4double GetVertexKineticEnergy() const
G4Track::GetTrackID
G4int GetTrackID() const
G4Track::GetNextTouchableHandle
const G4TouchableHandle & GetNextTouchableHandle() const
G4Track::GetCreatorProcess
const G4VProcess * GetCreatorProcess() const
G4Track::GetNextVolume
G4VPhysicalVolume * GetNextVolume() const
G4Track::GetPosition
const G4ThreeVector & GetPosition() const
G4Track::GetTrackLength
G4double GetTrackLength() const
G4Track::GetVertexMomentumDirection
const G4ThreeVector & GetVertexMomentumDirection() const
G4Track::GetGlobalTime
G4double GetGlobalTime() const
G4Track::GetCurrentStepNumber
G4int GetCurrentStepNumber() const
G4Track::GetVertexPosition
const G4ThreeVector & GetVertexPosition() const
G4Track::GetLocalTime
G4double GetLocalTime() const
G4Track::GetDefinition
G4ParticleDefinition * GetDefinition() const
G4Track::GetMomentumDirection
const G4ThreeVector & GetMomentumDirection() const
G4Track::GetKineticEnergy
G4double GetKineticEnergy() const
G4Track::GetPolarization
const G4ThreeVector & GetPolarization() const
G4Track::GetStepLength
G4double GetStepLength() const
G4Track::GetParentID
G4int GetParentID() const
G4Track::GetStep
const G4Step * GetStep() const
G4VITSteppingVerbose::fSelectedPostStepDoItVector
G4SelectedPostStepDoItVector * fSelectedPostStepDoItVector
Definition: G4VITSteppingVerbose.hh:186
G4VITSteppingVerbose::fCurrentProcess
const G4VITProcess * fCurrentProcess
Definition: G4VITSteppingVerbose.hh:153
G4VITSteppingVerbose::fSelectedAtRestDoItVector
G4SelectedAtRestDoItVector * fSelectedAtRestDoItVector
Definition: G4VITSteppingVerbose.hh:185
G4VITSteppingVerbose::fParticleChange
const G4VParticleChange * fParticleChange
Definition: G4VITSteppingVerbose.hh:144
G4VITSteppingVerbose::fSecondary
const G4TrackVector * fSecondary
Definition: G4VITSteppingVerbose.hh:146
G4VITSteppingVerbose::fGPILSelection
G4GPILSelection fGPILSelection
Definition: G4VITSteppingVerbose.hh:196
G4VParticleChange::DumpInfo
virtual void DumpInfo() const
Definition: G4VParticleChange.cc:133
G4VPhysicalVolume::IsReplicated
virtual G4bool IsReplicated() const =0
G4VPhysicalVolume::GetName
const G4String & GetName() const
G4VPhysicalVolume::IsParameterised
virtual G4bool IsParameterised() const =0
G4VProcess::GetProcessName
const G4String & GetProcessName() const
Definition: G4VProcess.hh:386
G4VTouchable::GetVolume
virtual G4VPhysicalVolume * GetVolume(G4int depth=0) const
Definition: G4VTouchable.cc:34
G4VTouchable::GetReplicaNumber
virtual G4int GetReplicaNumber(G4int depth=0) const
Definition: G4VTouchable.cc:50
ns
#define ns(x)
Definition: xmltok.c:1649