Geant4 11.1.1
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
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