Geant4-11
Public Member Functions | Static Public Member Functions | Protected Types | Protected Attributes | Static Protected Attributes | Static Private Attributes
G4SteppingVerbose Class Reference

#include <G4SteppingVerbose.hh>

Inheritance diagram for G4SteppingVerbose:
G4VSteppingVerbose G4SteppingVerboseWithUnits

Public Member Functions

virtual void AlongStepDoItAllDone ()
 
virtual void AlongStepDoItOneByOne ()
 
virtual void AtRestDoItInvoked ()
 
virtual G4VSteppingVerbose * Clone ()
 
void CopyState ()
 
virtual void DPSLAlongStep ()
 
virtual void DPSLPostStep ()
 
virtual void DPSLStarted ()
 
virtual void DPSLUserLimit ()
 
 G4SteppingVerbose ()
 
virtual void NewStep ()
 
virtual void PostStepDoItAllDone ()
 
virtual void PostStepDoItOneByOne ()
 
virtual void SetManager (G4SteppingManager *const)
 
virtual void ShowStep () const
 
virtual void StepInfo ()
 
virtual void TrackingStarted ()
 
virtual void VerboseParticleChange ()
 
virtual void VerboseTrack ()
 
virtual ~G4SteppingVerbose ()
 

Static Public Member Functions

static G4int BestUnitPrecision ()
 
static G4VSteppingVerbose * GetInstance ()
 
static G4VSteppingVerbose * GetMasterInstance ()
 
static G4int GetSilent ()
 
static G4int GetSilentStepInfo ()
 
static void SetInstance (G4VSteppingVerbose *Instance)
 
static void SetSilent (G4int fSilent)
 
static void SetSilentStepInfo (G4int fSilent)
 
static void UseBestUnit (G4int prec=4)
 

Protected Types

using G4SelectedAlongStepDoItVector = std::vector< G4int >
 
using G4SelectedAtRestDoItVector = std::vector< G4int >
 
using G4SelectedPostStepDoItVector = std::vector< G4int >
 

Protected Attributes

G4double CorrectedStep = 0.0
 
G4double currentMinimumStep = 0.0
 
std::size_t fAlongStepDoItProcTriggered = 0
 
G4ProcessVector * fAlongStepDoItVector = nullptr
 
G4ProcessVector * fAlongStepGetPhysIntVector = nullptr
 
std::size_t fAtRestDoItProcTriggered = 0
 
G4ProcessVector * fAtRestDoItVector = nullptr
 
G4ProcessVector * fAtRestGetPhysIntVector = nullptr
 
G4ForceCondition fCondition = InActivated
 
G4VProcess * fCurrentProcess = nullptr
 
G4VPhysicalVolume * fCurrentVolume = nullptr
 
G4GPILSelection fGPILSelection = NotCandidateForSelection
 
G4bool FirstStep = false
 
G4SteppingManager * fManager = nullptr
 
G4int fN2ndariesAlongStepDoIt = 0
 
G4int fN2ndariesAtRestDoIt = 0
 
G4int fN2ndariesPostStepDoIt = 0
 
G4Navigator * fNavigator = nullptr
 
G4VParticleChange * fParticleChange = nullptr
 
std::size_t fPostStepDoItProcTriggered = 0
 
G4ProcessVector * fPostStepDoItVector = nullptr
 
G4ProcessVector * fPostStepGetPhysIntVector = nullptr
 
G4StepPoint * fPostStepPoint = nullptr
 
G4StepPoint * fPreStepPoint = nullptr
 
G4double fPreviousStepSize = 0.0
 
G4TrackVector * fSecondary = nullptr
 
G4SelectedAlongStepDoItVector * fSelectedAlongStepDoItVector = nullptr
 
G4SelectedAtRestDoItVector * fSelectedAtRestDoItVector = nullptr
 
G4SelectedPostStepDoItVector * fSelectedPostStepDoItVector = nullptr
 
G4VSensitiveDetector * fSensitive = nullptr
 
G4Step * fStep = nullptr
 
G4StepStatus fStepStatus = fUndefined
 
G4TouchableHandle fTouchableHandle
 
G4Track * fTrack = nullptr
 
G4UserSteppingAction * fUserSteppingAction = nullptr
 
G4double GeometricalStep = 0.0
 
G4double Mass = 0.0
 
std::size_t MAXofAlongStepLoops = 0
 
std::size_t MAXofAtRestLoops = 0
 
std::size_t MAXofPostStepLoops = 0
 
G4double numberOfInteractionLengthLeft = 0.0
 
G4double PhysicalStep = 0.0
 
G4double physIntLength = 0.0
 
G4bool PreStepPointIsGeom = false
 
G4SteppingControl StepControlFlag = NormalCondition
 
G4double sumEnergyChange = 0.0
 
G4double TempInitVelocity = 0.0
 
G4double TempVelocity = 0.0
 
G4int verboseLevel = 0
 

Static Protected Attributes

static G4ThreadLocal G4VSteppingVerbose * fInstance = nullptr
 
static G4VSteppingVerbose * fMasterInstance = nullptr
 
static G4TRACKING_DLL G4ThreadLocal G4int Silent = 0
 
static G4TRACKING_DLL G4ThreadLocal G4int SilentStepInfo = 0
 

Static Private Attributes

static G4int useBestUnitPrecision = -1
 

Detailed Description

Definition at line 42 of file G4SteppingVerbose.hh.

Member Typedef Documentation

◆ G4SelectedAlongStepDoItVector

using G4VSteppingVerbose::G4SelectedAlongStepDoItVector = std::vector<G4int>
protectedinherited

Definition at line 173 of file G4VSteppingVerbose.hh.

◆ G4SelectedAtRestDoItVector

using G4VSteppingVerbose::G4SelectedAtRestDoItVector = std::vector<G4int>
protectedinherited

Definition at line 172 of file G4VSteppingVerbose.hh.

◆ G4SelectedPostStepDoItVector

using G4VSteppingVerbose::G4SelectedPostStepDoItVector = std::vector<G4int>
protectedinherited

Definition at line 174 of file G4VSteppingVerbose.hh.

Constructor & Destructor Documentation

◆ G4SteppingVerbose()

G4SteppingVerbose::G4SteppingVerbose ( )

Definition at line 51 of file G4SteppingVerbose.cc.

53{
54#ifdef G4_TRACKING_DEBUG
55 G4cout << "G4SteppingVerbose has instantiated" << G4endl;
56#endif
57}
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout

References G4cout, and G4endl.

Referenced by Clone().

◆ ~G4SteppingVerbose()

G4SteppingVerbose::~G4SteppingVerbose ( )
virtual

Definition at line 60 of file G4SteppingVerbose.cc.

62{
63}

Member Function Documentation

◆ AlongStepDoItAllDone()

void G4SteppingVerbose::AlongStepDoItAllDone ( )
virtual

Implements G4VSteppingVerbose.

Reimplemented in G4SteppingVerboseWithUnits.

Definition at line 139 of file G4SteppingVerbose.cc.

141{
142 if(Silent==1){ return; }
143
144 G4VProcess* ptProcManager;
145
146 CopyState();
147
148 if(verboseLevel >= 3)
149 {
150 G4cout << G4endl;
151 G4cout << " >>AlongStepDoIt (after all invocations):" << G4endl;
152 G4cout << " ++List of invoked processes " << G4endl;
153
154 for(std::size_t ci=0; ci<MAXofAlongStepLoops; ++ci)
155 {
156 ptProcManager = (*fAlongStepDoItVector)(ci);
157 G4cout << " " << ci+1 << ") ";
158 if(ptProcManager != nullptr)
159 {
160 G4cout << ptProcManager->GetProcessName() << G4endl;
161 }
162 }
163
164 ShowStep();
165 G4cout << G4endl;
166 G4cout << " ++List of secondaries generated "
167 << "(x,y,z,kE,t,PID):"
168 << " No. of secondaries = "
169 << (*fSecondary).size() << G4endl;
170
171 if((*fSecondary).size()>0)
172 {
173 for(std::size_t lp1=0; lp1<(*fSecondary).size(); ++lp1)
174 {
175 G4cout << " "
176 << std::setw( 9)
177 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(),"Length")
178 << " " << std::setw( 9)
179 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(),"Length")
180 << " " << std::setw( 9)
181 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(),"Length")
182 << " " << std::setw( 9)
183 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(),"Energy")
184 << " " << std::setw( 9)
185 << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(),"Time")
186 << " " << std::setw(18)
187 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
188 << G4endl;
189 }
190 }
191 }
192}
G4BestUnit
#define G4BestUnit(a, b)
Definition: G4SteppingVerbose.cc:45
G4SteppingVerbose::ShowStep
virtual void ShowStep() const
Definition: G4SteppingVerbose.cc:845
G4VProcess::GetProcessName
const G4String & GetProcessName() const
Definition: G4VProcess.hh:382
G4VSteppingVerbose::MAXofAlongStepLoops
std::size_t MAXofAlongStepLoops
Definition: G4VSteppingVerbose.hh:152
G4VSteppingVerbose::Silent
static G4TRACKING_DLL G4ThreadLocal G4int Silent
Definition: G4VSteppingVerbose.hh:109
G4VSteppingVerbose::fSecondary
G4TrackVector * fSecondary
Definition: G4VSteppingVerbose.hh:132

References G4VSteppingVerbose::CopyState(), G4VSteppingVerbose::fSecondary, G4BestUnit, G4cout, G4endl, G4VProcess::GetProcessName(), G4VSteppingVerbose::MAXofAlongStepLoops, ShowStep(), G4VSteppingVerbose::Silent, and G4VSteppingVerbose::verboseLevel.

◆ AlongStepDoItOneByOne()

void G4SteppingVerbose::AlongStepDoItOneByOne ( )
virtual

Implements G4VSteppingVerbose.

Reimplemented in G4SteppingVerboseWithUnits.

Definition at line 547 of file G4SteppingVerbose.cc.

549{
550 if(Silent==1){ return; }
551
552 CopyState();
553
554 if(verboseLevel >= 4)
555 {
556 G4cout << G4endl;
557 G4cout << " >>AlongStepDoIt (process by process): "
558 << " Process Name = "
559 << fCurrentProcess->GetProcessName() << G4endl;
560
561 ShowStep();
562 G4cout << " "
563 << "!Note! Safety of PostStep is only valid "
564 << "after all DoIt invocations."
565 << G4endl;
566
567 VerboseParticleChange();
568 G4cout << G4endl;
569
570 G4cout << " ++List of secondaries generated "
571 << "(x,y,z,kE,t,PID):"
572 << " No. of secodaries = "
573 << fN2ndariesAlongStepDoIt << G4endl;
574
575 if(fN2ndariesAlongStepDoIt>0)
576 {
577 for(std::size_t lp1=(*fSecondary).size()-fN2ndariesAlongStepDoIt;
578 lp1<(*fSecondary).size(); ++lp1)
579 {
580 G4cout << " "
581 << std::setw( 9)
582 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length")
583 << " " << std::setw( 9)
584 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length")
585 << " " << std::setw( 9)
586 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length")
587 << " " << std::setw( 9)
588 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy")
589 << " " << std::setw( 9)
590 << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time")
591 << " " << std::setw(18)
592 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
593 << G4endl;
594 }
595 }
596 }
597}
G4SteppingVerbose::VerboseParticleChange
virtual void VerboseParticleChange()
Definition: G4SteppingVerbose.cc:834
G4VSteppingVerbose::fCurrentProcess
G4VProcess * fCurrentProcess
Definition: G4VSteppingVerbose.hh:139

References G4VSteppingVerbose::CopyState(), G4VSteppingVerbose::fCurrentProcess, G4VSteppingVerbose::fN2ndariesAlongStepDoIt, G4VSteppingVerbose::fSecondary, G4BestUnit, G4cout, G4endl, G4VProcess::GetProcessName(), ShowStep(), G4VSteppingVerbose::Silent, G4VSteppingVerbose::verboseLevel, and VerboseParticleChange().

◆ AtRestDoItInvoked()

void G4SteppingVerbose::AtRestDoItInvoked ( )
virtual

Implements G4VSteppingVerbose.

Reimplemented in G4SteppingVerboseWithUnits.

Definition at line 72 of file G4SteppingVerbose.cc.

74{
75 if(Silent==1) { return; }
76
77 G4VProcess* ptProcManager;
78 CopyState();
79
80 if(verboseLevel >= 3)
81 {
82 G4int npt=0;
83 G4cout << " **List of AtRestDoIt invoked:" << G4endl;
84 for(std::size_t np=0; np<MAXofAtRestLoops; ++np)
85 {
86 std::size_t npGPIL = MAXofAtRestLoops-np-1;
87 if( (*fSelectedAtRestDoItVector)[npGPIL] == G4ForceCondition::Forced )
88 {
89 ++npt;
90 ptProcManager = (*fAtRestDoItVector)[np];
91 G4cout << " # " << npt << " : "
92 << ptProcManager->GetProcessName()
93 << " (Forced)" << G4endl;
94 }
95 else if ( (*fSelectedAtRestDoItVector)[npGPIL] == G4ForceCondition::NotForced )
96 {
97 ++npt;
98 ptProcManager = (*fAtRestDoItVector)[np];
99 G4cout << " # " << npt << " : " << ptProcManager->GetProcessName()
100 << G4endl;
101 }
102 }
103
104 G4cout << " Generated secondries # : " << fN2ndariesAtRestDoIt << G4endl;
105
106 if( fN2ndariesAtRestDoIt > 0 )
107 {
108 G4cout << " -- List of secondaries generated : "
109 << "(x,y,z,kE,t,PID) --" << G4endl;
110 for( std::size_t lp1=(*fSecondary).size()-fN2ndariesAtRestDoIt;
111 lp1<(*fSecondary).size(); ++lp1)
112 {
113 G4cout << " "
114 << std::setw( 9)
115 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(),"Length")
116 << " " << std::setw( 9)
117 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(),"Length")
118 << " " << std::setw( 9)
119 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(),"Length")
120 << " " << std::setw( 9)
121 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(),"Energy")
122 << " " << std::setw( 9)
123 << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(),"Time")
124 << " " << std::setw(18)
125 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
126 << G4endl;
127 }
128 }
129 }
130
131 if( verboseLevel >= 4 )
132 {
133 ShowStep();
134 G4cout << G4endl;
135 }
136}
NotForced
@ NotForced
Definition: G4ForceCondition.hh:47
Forced
@ Forced
Definition: G4ForceCondition.hh:44
G4int
int G4int
Definition: G4Types.hh:85
G4VSteppingVerbose::fSelectedAtRestDoItVector
G4SelectedAtRestDoItVector * fSelectedAtRestDoItVector
Definition: G4VSteppingVerbose.hh:176

References G4VSteppingVerbose::CopyState(), G4VSteppingVerbose::fN2ndariesAtRestDoIt, Forced, G4VSteppingVerbose::fSecondary, G4VSteppingVerbose::fSelectedAtRestDoItVector, G4BestUnit, G4cout, G4endl, G4VProcess::GetProcessName(), G4VSteppingVerbose::MAXofAtRestLoops, NotForced, ShowStep(), G4VSteppingVerbose::Silent, and G4VSteppingVerbose::verboseLevel.

◆ BestUnitPrecision()

G4int G4SteppingVerbose::BestUnitPrecision ( )
static

Definition at line 1045 of file G4SteppingVerbose.cc.

1047{ return useBestUnitPrecision; }
G4SteppingVerbose::useBestUnitPrecision
static G4int useBestUnitPrecision
Definition: G4SteppingVerbose.hh:73

References useBestUnitPrecision.

Referenced by G4SteppingManager::G4SteppingManager().

◆ Clone()

virtual G4VSteppingVerbose * G4SteppingVerbose::Clone ( )
inlinevirtual

Reimplemented from G4VSteppingVerbose.

Reimplemented in G4SteppingVerboseWithUnits.

Definition at line 51 of file G4SteppingVerbose.hh.

52 { return new G4SteppingVerbose; }

References G4SteppingVerbose().

◆ CopyState()

void G4VSteppingVerbose::CopyState ( )
inherited

Definition at line 81 of file G4VSteppingVerbose.cc.

83{
84 fUserSteppingAction = fManager->GetUserAction();
85
86 PhysicalStep = fManager->GetPhysicalStep();
87 GeometricalStep = fManager->GetGeometricalStep();
88 CorrectedStep = fManager->GetCorrectedStep();
89 PreStepPointIsGeom = fManager->GetPreStepPointIsGeom();
90 FirstStep = fManager->GetFirstStep();
91 fStepStatus = fManager->GetfStepStatus();
92
93 TempInitVelocity = fManager->GetTempInitVelocity();
94 TempVelocity = fManager->GetTempVelocity();
95 Mass = fManager->GetMass();
96
97 sumEnergyChange = fManager->GetsumEnergyChange();
98
99 fParticleChange = fManager->GetfParticleChange();
100 fTrack = fManager->GetfTrack();
101 fSecondary = fManager->GetfSecondary();
102 fStep = fManager->GetfStep();
103 fPreStepPoint = fManager->GetfPreStepPoint();
104 fPostStepPoint = fManager->GetfPostStepPoint();
105
106 fCurrentVolume = fManager->GetfCurrentVolume();
107 fSensitive = fManager->GetfSensitive();
108 fCurrentProcess = fManager->GetfCurrentProcess();
109
110 fAtRestDoItVector = fManager->GetfAtRestDoItVector();
111 fAlongStepDoItVector = fManager->GetfAlongStepDoItVector();
112 fPostStepDoItVector = fManager->GetfPostStepDoItVector();
113
114 fAtRestGetPhysIntVector = fManager->GetfAtRestGetPhysIntVector();
115 fAlongStepGetPhysIntVector = fManager->GetfAlongStepGetPhysIntVector();
116 fPostStepGetPhysIntVector = fManager->GetfPostStepGetPhysIntVector();
117
118 MAXofAtRestLoops = fManager->GetMAXofAtRestLoops();
119 MAXofAlongStepLoops = fManager->GetMAXofAlongStepLoops();
120 MAXofPostStepLoops = fManager->GetMAXofPostStepLoops();
121
122 fAtRestDoItProcTriggered = fManager->GetfAtRestDoItProcTriggered();
123 fAlongStepDoItProcTriggered = fManager->GetfAlongStepDoItProcTriggered();
124 fPostStepDoItProcTriggered = fManager->GetfPostStepDoItProcTriggered();
125
126 fN2ndariesAtRestDoIt = fManager->GetfN2ndariesAtRestDoIt();
127 fN2ndariesAlongStepDoIt = fManager->GetfN2ndariesAlongStepDoIt();
128 fN2ndariesPostStepDoIt = fManager->GetfN2ndariesPostStepDoIt();
129
130 fNavigator = fManager->GetfNavigator();
131
132 verboseLevel = fManager->GetverboseLevel();
133
134 fSelectedAtRestDoItVector = fManager->GetfSelectedAtRestDoItVector();
135 fSelectedAlongStepDoItVector = fManager->GetfSelectedAlongStepDoItVector();
136 fSelectedPostStepDoItVector = fManager->GetfSelectedPostStepDoItVector();
137
138 fPreviousStepSize = fManager->GetfPreviousStepSize();
139
140 fTouchableHandle = fManager->GetTouchableHandle();
141
142 StepControlFlag = fManager->GetStepControlFlag();
143
144 physIntLength = fManager->GetphysIntLength();
145 fCondition = fManager->GetfCondition();
146 fGPILSelection = fManager->GetfGPILSelection();
147}
G4SteppingManager::GetfPostStepDoItVector
G4ProcessVector * GetfPostStepDoItVector()
Definition: G4SteppingManager.hh:387
G4SteppingManager::GetfAtRestDoItProcTriggered
std::size_t GetfAtRestDoItProcTriggered()
Definition: G4SteppingManager.hh:422
G4SteppingManager::GetMAXofAtRestLoops
std::size_t GetMAXofAtRestLoops()
Definition: G4SteppingManager.hh:407
G4SteppingManager::GetfSecondary
G4TrackVector * GetfSecondary()
Definition: G4SteppingManager.hh:342
G4SteppingManager::GetMAXofAlongStepLoops
std::size_t GetMAXofAlongStepLoops()
Definition: G4SteppingManager.hh:412
G4SteppingManager::GetStepControlFlag
G4SteppingControl GetStepControlFlag()
Definition: G4SteppingManager.hh:490
G4SteppingManager::GetMAXofPostStepLoops
std::size_t GetMAXofPostStepLoops()
Definition: G4SteppingManager.hh:417
G4SteppingManager::GetfSelectedPostStepDoItVector
G4SelectedPostStepDoItVector * GetfSelectedPostStepDoItVector()
Definition: G4SteppingManager.hh:475
G4SteppingManager::GetfNavigator
G4Navigator * GetfNavigator()
Definition: G4SteppingManager.hh:452
G4SteppingManager::GetfCurrentVolume
G4VPhysicalVolume * GetfCurrentVolume()
Definition: G4SteppingManager.hh:362
G4SteppingManager::GetfPreStepPoint
G4StepPoint * GetfPreStepPoint()
Definition: G4SteppingManager.hh:352
G4SteppingManager::GetfAlongStepDoItVector
G4ProcessVector * GetfAlongStepDoItVector()
Definition: G4SteppingManager.hh:382
G4SteppingManager::GetfParticleChange
G4VParticleChange * GetfParticleChange()
Definition: G4SteppingManager.hh:332
G4SteppingManager::GetfPostStepDoItProcTriggered
std::size_t GetfPostStepDoItProcTriggered()
Definition: G4SteppingManager.hh:432
G4SteppingManager::GetfAlongStepDoItProcTriggered
std::size_t GetfAlongStepDoItProcTriggered()
Definition: G4SteppingManager.hh:427
G4SteppingManager::GetfPreviousStepSize
G4double GetfPreviousStepSize()
Definition: G4SteppingManager.hh:480
G4SteppingManager::GetfSelectedAlongStepDoItVector
G4SelectedAlongStepDoItVector * GetfSelectedAlongStepDoItVector()
Definition: G4SteppingManager.hh:469
G4SteppingManager::GetfCondition
G4ForceCondition GetfCondition()
Definition: G4SteppingManager.hh:500
G4SteppingManager::GetfAlongStepGetPhysIntVector
G4ProcessVector * GetfAlongStepGetPhysIntVector()
Definition: G4SteppingManager.hh:397
G4SteppingManager::GetsumEnergyChange
G4double GetsumEnergyChange()
Definition: G4SteppingManager.hh:327
G4SteppingManager::GetTempInitVelocity
G4double GetTempInitVelocity()
Definition: G4SteppingManager.hh:312
G4SteppingManager::GetfSensitive
G4VSensitiveDetector * GetfSensitive()
Definition: G4SteppingManager.hh:367
G4SteppingManager::GetfAtRestDoItVector
G4ProcessVector * GetfAtRestDoItVector()
Definition: G4SteppingManager.hh:377
G4SteppingManager::GetfStepStatus
G4StepStatus GetfStepStatus()
Definition: G4SteppingManager.hh:307
G4SteppingManager::GetfSelectedAtRestDoItVector
G4SelectedAtRestDoItVector * GetfSelectedAtRestDoItVector()
Definition: G4SteppingManager.hh:463
G4SteppingManager::GetfN2ndariesAlongStepDoIt
G4int GetfN2ndariesAlongStepDoIt()
Definition: G4SteppingManager.hh:442
G4SteppingManager::GetfGPILSelection
G4GPILSelection GetfGPILSelection()
Definition: G4SteppingManager.hh:505
G4SteppingManager::GetfAtRestGetPhysIntVector
G4ProcessVector * GetfAtRestGetPhysIntVector()
Definition: G4SteppingManager.hh:392
G4SteppingManager::GetfPostStepGetPhysIntVector
G4ProcessVector * GetfPostStepGetPhysIntVector()
Definition: G4SteppingManager.hh:402
G4SteppingManager::GetfPostStepPoint
G4StepPoint * GetfPostStepPoint()
Definition: G4SteppingManager.hh:357
G4SteppingManager::GetUserAction
G4UserSteppingAction * GetUserAction()
Definition: G4SteppingManager.hh:525
G4SteppingManager::GetfCurrentProcess
G4VProcess * GetfCurrentProcess()
Definition: G4SteppingManager.hh:372
G4SteppingManager::GetTouchableHandle
const G4TouchableHandle & GetTouchableHandle()
Definition: G4SteppingManager.hh:485
G4SteppingManager::GetGeometricalStep
G4double GetGeometricalStep()
Definition: G4SteppingManager.hh:287
G4VSteppingVerbose::fPostStepPoint
G4StepPoint * fPostStepPoint
Definition: G4VSteppingVerbose.hh:135
G4VSteppingVerbose::fPostStepGetPhysIntVector
G4ProcessVector * fPostStepGetPhysIntVector
Definition: G4VSteppingVerbose.hh:149
G4VSteppingVerbose::fUserSteppingAction
G4UserSteppingAction * fUserSteppingAction
Definition: G4VSteppingVerbose.hh:115
G4VSteppingVerbose::fCondition
G4ForceCondition fCondition
Definition: G4VSteppingVerbose.hh:187
G4VSteppingVerbose::fAlongStepGetPhysIntVector
G4ProcessVector * fAlongStepGetPhysIntVector
Definition: G4VSteppingVerbose.hh:148
G4VSteppingVerbose::fTouchableHandle
G4TouchableHandle fTouchableHandle
Definition: G4VSteppingVerbose.hh:182
G4VSteppingVerbose::fGPILSelection
G4GPILSelection fGPILSelection
Definition: G4VSteppingVerbose.hh:188
G4VSteppingVerbose::fAlongStepDoItProcTriggered
std::size_t fAlongStepDoItProcTriggered
Definition: G4VSteppingVerbose.hh:159
G4VSteppingVerbose::fParticleChange
G4VParticleChange * fParticleChange
Definition: G4VSteppingVerbose.hh:130
G4VSteppingVerbose::StepControlFlag
G4SteppingControl StepControlFlag
Definition: G4VSteppingVerbose.hh:184
G4VSteppingVerbose::fCurrentVolume
G4VPhysicalVolume * fCurrentVolume
Definition: G4VSteppingVerbose.hh:137
G4VSteppingVerbose::fSelectedPostStepDoItVector
G4SelectedPostStepDoItVector * fSelectedPostStepDoItVector
Definition: G4VSteppingVerbose.hh:178
G4VSteppingVerbose::fAtRestDoItVector
G4ProcessVector * fAtRestDoItVector
Definition: G4VSteppingVerbose.hh:143
G4VSteppingVerbose::fAtRestGetPhysIntVector
G4ProcessVector * fAtRestGetPhysIntVector
Definition: G4VSteppingVerbose.hh:147
G4VSteppingVerbose::fSelectedAlongStepDoItVector
G4SelectedAlongStepDoItVector * fSelectedAlongStepDoItVector
Definition: G4VSteppingVerbose.hh:177
G4VSteppingVerbose::fPreStepPoint
G4StepPoint * fPreStepPoint
Definition: G4VSteppingVerbose.hh:134
G4VSteppingVerbose::fAtRestDoItProcTriggered
std::size_t fAtRestDoItProcTriggered
Definition: G4VSteppingVerbose.hh:158
G4VSteppingVerbose::fSensitive
G4VSensitiveDetector * fSensitive
Definition: G4VSteppingVerbose.hh:138
G4VSteppingVerbose::fPostStepDoItVector
G4ProcessVector * fPostStepDoItVector
Definition: G4VSteppingVerbose.hh:145
G4VSteppingVerbose::fAlongStepDoItVector
G4ProcessVector * fAlongStepDoItVector
Definition: G4VSteppingVerbose.hh:144
G4VSteppingVerbose::fPostStepDoItProcTriggered
std::size_t fPostStepDoItProcTriggered
Definition: G4VSteppingVerbose.hh:160
G4VSteppingVerbose::fManager
G4SteppingManager * fManager
Definition: G4VSteppingVerbose.hh:114
G4VSteppingVerbose::MAXofPostStepLoops
std::size_t MAXofPostStepLoops
Definition: G4VSteppingVerbose.hh:153

References G4VSteppingVerbose::CorrectedStep, G4VSteppingVerbose::fAlongStepDoItProcTriggered, G4VSteppingVerbose::fAlongStepDoItVector, G4VSteppingVerbose::fAlongStepGetPhysIntVector, G4VSteppingVerbose::fAtRestDoItProcTriggered, G4VSteppingVerbose::fAtRestDoItVector, G4VSteppingVerbose::fAtRestGetPhysIntVector, G4VSteppingVerbose::fCondition, G4VSteppingVerbose::fCurrentProcess, G4VSteppingVerbose::fCurrentVolume, G4VSteppingVerbose::fGPILSelection, G4VSteppingVerbose::FirstStep, G4VSteppingVerbose::fManager, G4VSteppingVerbose::fN2ndariesAlongStepDoIt, G4VSteppingVerbose::fN2ndariesAtRestDoIt, G4VSteppingVerbose::fN2ndariesPostStepDoIt, G4VSteppingVerbose::fNavigator, G4VSteppingVerbose::fParticleChange, G4VSteppingVerbose::fPostStepDoItProcTriggered, G4VSteppingVerbose::fPostStepDoItVector, G4VSteppingVerbose::fPostStepGetPhysIntVector, G4VSteppingVerbose::fPostStepPoint, G4VSteppingVerbose::fPreStepPoint, G4VSteppingVerbose::fPreviousStepSize, G4VSteppingVerbose::fSecondary, G4VSteppingVerbose::fSelectedAlongStepDoItVector, G4VSteppingVerbose::fSelectedAtRestDoItVector, G4VSteppingVerbose::fSelectedPostStepDoItVector, G4VSteppingVerbose::fSensitive, G4VSteppingVerbose::fStep, G4VSteppingVerbose::fStepStatus, G4VSteppingVerbose::fTouchableHandle, G4VSteppingVerbose::fTrack, G4VSteppingVerbose::fUserSteppingAction, G4VSteppingVerbose::GeometricalStep, G4SteppingManager::GetCorrectedStep(), G4SteppingManager::GetfAlongStepDoItProcTriggered(), G4SteppingManager::GetfAlongStepDoItVector(), G4SteppingManager::GetfAlongStepGetPhysIntVector(), G4SteppingManager::GetfAtRestDoItProcTriggered(), G4SteppingManager::GetfAtRestDoItVector(), G4SteppingManager::GetfAtRestGetPhysIntVector(), G4SteppingManager::GetfCondition(), G4SteppingManager::GetfCurrentProcess(), G4SteppingManager::GetfCurrentVolume(), G4SteppingManager::GetfGPILSelection(), G4SteppingManager::GetFirstStep(), G4SteppingManager::GetfN2ndariesAlongStepDoIt(), G4SteppingManager::GetfN2ndariesAtRestDoIt(), G4SteppingManager::GetfN2ndariesPostStepDoIt(), G4SteppingManager::GetfNavigator(), G4SteppingManager::GetfParticleChange(), G4SteppingManager::GetfPostStepDoItProcTriggered(), G4SteppingManager::GetfPostStepDoItVector(), G4SteppingManager::GetfPostStepGetPhysIntVector(), G4SteppingManager::GetfPostStepPoint(), G4SteppingManager::GetfPreStepPoint(), G4SteppingManager::GetfPreviousStepSize(), G4SteppingManager::GetfSecondary(), G4SteppingManager::GetfSelectedAlongStepDoItVector(), G4SteppingManager::GetfSelectedAtRestDoItVector(), G4SteppingManager::GetfSelectedPostStepDoItVector(), G4SteppingManager::GetfSensitive(), G4SteppingManager::GetfStep(), G4SteppingManager::GetfStepStatus(), G4SteppingManager::GetfTrack(), G4SteppingManager::GetGeometricalStep(), G4SteppingManager::GetMass(), G4SteppingManager::GetMAXofAlongStepLoops(), G4SteppingManager::GetMAXofAtRestLoops(), G4SteppingManager::GetMAXofPostStepLoops(), G4SteppingManager::GetPhysicalStep(), G4SteppingManager::GetphysIntLength(), G4SteppingManager::GetPreStepPointIsGeom(), G4SteppingManager::GetStepControlFlag(), G4SteppingManager::GetsumEnergyChange(), G4SteppingManager::GetTempInitVelocity(), G4SteppingManager::GetTempVelocity(), G4SteppingManager::GetTouchableHandle(), G4SteppingManager::GetUserAction(), G4SteppingManager::GetverboseLevel(), G4VSteppingVerbose::Mass, G4VSteppingVerbose::MAXofAlongStepLoops, G4VSteppingVerbose::MAXofAtRestLoops, G4VSteppingVerbose::MAXofPostStepLoops, G4VSteppingVerbose::PhysicalStep, G4VSteppingVerbose::physIntLength, G4VSteppingVerbose::PreStepPointIsGeom, G4VSteppingVerbose::StepControlFlag, G4VSteppingVerbose::sumEnergyChange, G4VSteppingVerbose::TempInitVelocity, G4VSteppingVerbose::TempVelocity, and G4VSteppingVerbose::verboseLevel.

Referenced by AlongStepDoItAllDone(), G4SteppingVerboseWithUnits::AlongStepDoItAllDone(), AlongStepDoItOneByOne(), G4SteppingVerboseWithUnits::AlongStepDoItOneByOne(), AtRestDoItInvoked(), G4SteppingVerboseWithUnits::AtRestDoItInvoked(), DPSLAlongStep(), G4SteppingVerboseWithUnits::DPSLAlongStep(), DPSLPostStep(), G4SteppingVerboseWithUnits::DPSLPostStep(), DPSLStarted(), G4SteppingVerboseWithUnits::DPSLStarted(), DPSLUserLimit(), G4SteppingVerboseWithUnits::DPSLUserLimit(), PostStepDoItAllDone(), G4SteppingVerboseWithUnits::PostStepDoItAllDone(), PostStepDoItOneByOne(), G4SteppingVerboseWithUnits::PostStepDoItOneByOne(), StepInfo(), G4SteppingVerboseWithUnits::StepInfo(), TrackingStarted(), G4SteppingVerboseWithUnits::TrackingStarted(), VerboseTrack(), and G4SteppingVerboseWithUnits::VerboseTrack().

◆ DPSLAlongStep()

void G4SteppingVerbose::DPSLAlongStep ( )
virtual

Implements G4VSteppingVerbose.

Reimplemented in G4SteppingVerboseWithUnits.

Definition at line 454 of file G4SteppingVerbose.cc.

456{
457 if(Silent==1){ return; }
458 CopyState();
459
460 if( verboseLevel > 5 )
461 {
462 G4cout << " ++ProposedStep(AlongStep) = "
463 << std::setw( 9) << G4BestUnit(physIntLength , "Length")
464 << " : ProcName = "
465 << fCurrentProcess->GetProcessName()
466 << " (";
467 if(fGPILSelection==CandidateForSelection)
468 {
469 G4cout << "CandidateForSelection)" << G4endl;
470 }
471 else if(fGPILSelection==NotCandidateForSelection)
472 {
473 G4cout << "NotCandidateForSelection)" << G4endl;
474 }
475 else
476 {
477 G4cout << "?!?)" << G4endl;
478 }
479 }
480}
CandidateForSelection
@ CandidateForSelection
Definition: G4GPILSelection.hh:42
NotCandidateForSelection
@ NotCandidateForSelection
Definition: G4GPILSelection.hh:47

References CandidateForSelection, G4VSteppingVerbose::CopyState(), G4VSteppingVerbose::fCurrentProcess, G4VSteppingVerbose::fGPILSelection, G4BestUnit, G4cout, G4endl, G4VProcess::GetProcessName(), NotCandidateForSelection, G4VSteppingVerbose::physIntLength, G4VSteppingVerbose::Silent, and G4VSteppingVerbose::verboseLevel.

◆ DPSLPostStep()

void G4SteppingVerbose::DPSLPostStep ( )
virtual

Implements G4VSteppingVerbose.

Reimplemented in G4SteppingVerboseWithUnits.

Definition at line 419 of file G4SteppingVerbose.cc.

421{
422 if(Silent==1){ return; }
423 CopyState();
424
425 if( verboseLevel > 5 )
426 {
427 G4cout << " ++ProposedStep(PostStep ) = "
428 << std::setw( 9) << physIntLength
429 << " : ProcName = " << fCurrentProcess->GetProcessName() << " (";
430 if(fCondition==ExclusivelyForced)
431 {
432 G4cout << "ExclusivelyForced)" << G4endl;
433 }
434 else if(fCondition==StronglyForced)
435 {
436 G4cout << "StronglyForced)" << G4endl;
437 }
438 else if(fCondition==Conditionally)
439 {
440 G4cout << "Conditionally)" << G4endl;
441 }
442 else if(fCondition==Forced)
443 {
444 G4cout << "Forced)" << G4endl;
445 }
446 else
447 {
448 G4cout << "No ForceCondition)" << G4endl;
449 }
450 }
451}
StronglyForced
@ StronglyForced
Definition: G4ForceCondition.hh:55
Conditionally
@ Conditionally
Definition: G4ForceCondition.hh:49
ExclusivelyForced
@ ExclusivelyForced
Definition: G4ForceCondition.hh:52

References Conditionally, G4VSteppingVerbose::CopyState(), ExclusivelyForced, G4VSteppingVerbose::fCondition, G4VSteppingVerbose::fCurrentProcess, Forced, G4cout, G4endl, G4VProcess::GetProcessName(), G4VSteppingVerbose::physIntLength, G4VSteppingVerbose::Silent, StronglyForced, and G4VSteppingVerbose::verboseLevel.

◆ DPSLStarted()

void G4SteppingVerbose::DPSLStarted ( )
virtual

Implements G4VSteppingVerbose.

Reimplemented in G4SteppingVerboseWithUnits.

Definition at line 387 of file G4SteppingVerbose.cc.

389{
390 if(Silent==1){ return; }
391 CopyState();
392
393 if( verboseLevel > 5 )
394 {
395 G4cout << G4endl
396 << " >>DefinePhysicalStepLength (List of proposed StepLengths): "
397 << G4endl;
398 }
399}

References G4VSteppingVerbose::CopyState(), G4cout, G4endl, G4VSteppingVerbose::Silent, and G4VSteppingVerbose::verboseLevel.

◆ DPSLUserLimit()

void G4SteppingVerbose::DPSLUserLimit ( )
virtual

Implements G4VSteppingVerbose.

Reimplemented in G4SteppingVerboseWithUnits.

Definition at line 402 of file G4SteppingVerbose.cc.

404{
405 if(Silent==1){ return; }
406 CopyState();
407
408 if( verboseLevel > 5 )
409 {
410 G4cout << G4endl << G4endl;
411 G4cout << "=== Defined Physical Step Length (DPSL)" << G4endl;
412 G4cout << " ++ProposedStep(UserLimit) = "
413 << std::setw( 9) << physIntLength
414 << " : ProcName = User defined maximum allowed Step" << G4endl;
415 }
416}

References G4VSteppingVerbose::CopyState(), G4cout, G4endl, G4VSteppingVerbose::physIntLength, G4VSteppingVerbose::Silent, and G4VSteppingVerbose::verboseLevel.

◆ GetInstance()

G4VSteppingVerbose * G4VSteppingVerbose::GetInstance ( )
staticinherited

Definition at line 152 of file G4VSteppingVerbose.cc.

153{
154 return fInstance;
155}
G4VSteppingVerbose::fInstance
static G4ThreadLocal G4VSteppingVerbose * fInstance
Definition: G4VSteppingVerbose.hh:105

References G4VSteppingVerbose::fInstance.

Referenced by G4SteppingManager::G4SteppingManager().

◆ GetMasterInstance()

G4VSteppingVerbose * G4VSteppingVerbose::GetMasterInstance ( )
staticinherited

Definition at line 157 of file G4VSteppingVerbose.cc.

158{
159 return fMasterInstance;
160}
G4VSteppingVerbose::fMasterInstance
static G4VSteppingVerbose * fMasterInstance
Definition: G4VSteppingVerbose.hh:107

References G4VSteppingVerbose::fMasterInstance.

Referenced by G4SteppingManager::G4SteppingManager().

◆ GetSilent()

G4int G4VSteppingVerbose::GetSilent ( )
staticinherited

Definition at line 162 of file G4VSteppingVerbose.cc.

163{
164 return Silent;
165}

References G4VSteppingVerbose::Silent.

Referenced by G4TrackingManager::ProcessOneTrack().

◆ GetSilentStepInfo()

G4int G4VSteppingVerbose::GetSilentStepInfo ( )
staticinherited

Definition at line 172 of file G4VSteppingVerbose.cc.

173{
174 return SilentStepInfo;
175}
G4VSteppingVerbose::SilentStepInfo
static G4TRACKING_DLL G4ThreadLocal G4int SilentStepInfo
Definition: G4VSteppingVerbose.hh:111

References G4VSteppingVerbose::SilentStepInfo.

◆ NewStep()

void G4SteppingVerbose::NewStep ( )
virtual

Implements G4VSteppingVerbose.

Definition at line 66 of file G4SteppingVerbose.cc.

68{
69}

◆ PostStepDoItAllDone()

void G4SteppingVerbose::PostStepDoItAllDone ( )
virtual

Implements G4VSteppingVerbose.

Reimplemented in G4SteppingVerboseWithUnits.

Definition at line 195 of file G4SteppingVerbose.cc.

197{
198 if(Silent==1) { return; }
199
200 G4VProcess* ptProcManager;
201
202 CopyState();
203
204 if( (fStepStatus == fPostStepDoItProc) |
205 (fCondition == Forced) |
206 (fCondition == Conditionally) |
207 (fCondition == ExclusivelyForced) |
208 (fCondition == StronglyForced) )
209 {
210 if(verboseLevel >= 3)
211 {
212 G4int npt=0;
213 G4cout << G4endl;
214 G4cout << " **PostStepDoIt (after all invocations):" << G4endl;
215 G4cout << " ++List of invoked processes " << G4endl;
216
217 for(std::size_t np=0; np<MAXofPostStepLoops; ++np)
218 {
219 std::size_t npGPIL = MAXofPostStepLoops-np-1;
220 if( (*fSelectedPostStepDoItVector)[npGPIL] == G4ForceCondition::Forced )
221 {
222 ++npt;
223 ptProcManager = (*fPostStepDoItVector)[np];
224 G4cout << " " << npt << ") "
225 << ptProcManager->GetProcessName()
226 << " (Forced)" << G4endl;
227 }
228 else if ( (*fSelectedPostStepDoItVector)[npGPIL] == G4ForceCondition::NotForced )
229 {
230 ++npt;
231 ptProcManager = (*fPostStepDoItVector)[np];
232 G4cout << " " << npt << ") " << ptProcManager->GetProcessName()
233 << G4endl;
234 }
235 }
236
237 ShowStep();
238 G4cout << G4endl;
239 G4cout << " ++List of secondaries generated "
240 << "(x,y,z,kE,t,PID):"
241 << " No. of secodaries = "
242 << (*fSecondary).size() << G4endl;
243 G4cout << " [Note]Secondaries from AlongStepDoIt included."
244 << G4endl;
245
246 if((*fSecondary).size()>0)
247 {
248 for(std::size_t lp1=0; lp1<(*fSecondary).size(); ++lp1)
249 {
250 G4cout << " "
251 << std::setw( 9)
252 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length")
253 << " " << std::setw( 9)
254 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length")
255 << " " << std::setw( 9)
256 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length")
257 << " " << std::setw( 9)
258 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy")
259 << " " << std::setw( 9)
260 << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time")
261 << " " << std::setw(18)
262 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
263 << G4endl;
264 }
265 }
266 }
267 }
268}
fPostStepDoItProc
@ fPostStepDoItProc
Definition: G4StepStatus.hh:49

References Conditionally, G4VSteppingVerbose::CopyState(), ExclusivelyForced, G4VSteppingVerbose::fCondition, Forced, fPostStepDoItProc, G4VSteppingVerbose::fSecondary, G4VSteppingVerbose::fSelectedPostStepDoItVector, G4VSteppingVerbose::fStepStatus, G4BestUnit, G4cout, G4endl, G4VProcess::GetProcessName(), G4VSteppingVerbose::MAXofPostStepLoops, NotForced, ShowStep(), G4VSteppingVerbose::Silent, StronglyForced, and G4VSteppingVerbose::verboseLevel.

◆ PostStepDoItOneByOne()

void G4SteppingVerbose::PostStepDoItOneByOne ( )
virtual

Implements G4VSteppingVerbose.

Reimplemented in G4SteppingVerboseWithUnits.

Definition at line 600 of file G4SteppingVerbose.cc.

602{
603 if(Silent==1) { return; }
604
605 CopyState();
606
607 if(verboseLevel >= 4)
608 {
609 G4cout << G4endl;
610 G4cout << " >>PostStepDoIt (process by process): "
611 << " Process Name = "
612 << fCurrentProcess->GetProcessName() << G4endl;
613
614 ShowStep();
615 G4cout << G4endl;
616 VerboseParticleChange();
617 G4cout << G4endl;
618
619 G4cout << " ++List of secondaries generated "
620 << "(x,y,z,kE,t,PID):"
621 << " No. of secodaries = "
622 << fN2ndariesPostStepDoIt << G4endl;
623
624 if(fN2ndariesPostStepDoIt>0)
625 {
626 for(std::size_t lp1=(*fSecondary).size()-fN2ndariesPostStepDoIt;
627 lp1<(*fSecondary).size(); ++lp1)
628 {
629 G4cout << " "
630 << std::setw( 9)
631 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length")
632 << " " << std::setw( 9)
633 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length")
634 << " " << std::setw( 9)
635 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length")
636 << " " << std::setw( 9)
637 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy")
638 << " " << std::setw( 9)
639 << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time")
640 << " " << std::setw(18)
641 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
642 << G4endl;
643 }
644 }
645 }
646}

References G4VSteppingVerbose::CopyState(), G4VSteppingVerbose::fCurrentProcess, G4VSteppingVerbose::fN2ndariesPostStepDoIt, G4VSteppingVerbose::fSecondary, G4BestUnit, G4cout, G4endl, G4VProcess::GetProcessName(), ShowStep(), G4VSteppingVerbose::Silent, G4VSteppingVerbose::verboseLevel, and VerboseParticleChange().

◆ SetInstance()

void G4VSteppingVerbose::SetInstance ( G4VSteppingVerbose *  Instance)
staticinherited

Definition at line 149 of file G4VSteppingVerbose.cc.

150{;}

Referenced by G4TaskRunManagerKernel::InitializeWorker(), and G4MTRunManagerKernel::StartThread().

◆ SetManager()

void G4VSteppingVerbose::SetManager ( G4SteppingManager * const  fMan)
virtualinherited

Reimplemented in G4SteppingVerboseWithUnits.

Definition at line 74 of file G4VSteppingVerbose.cc.

76{
77 fManager = fMan;
78}

References G4VSteppingVerbose::fManager.

◆ SetSilent()

void G4VSteppingVerbose::SetSilent ( G4int  fSilent)
staticinherited

Definition at line 167 of file G4VSteppingVerbose.cc.

168{
169 Silent=fSilent;
170}

References G4VSteppingVerbose::Silent.

Referenced by G4SteppingManager::Stepping().

◆ SetSilentStepInfo()

void G4VSteppingVerbose::SetSilentStepInfo ( G4int  fSilent)
staticinherited

Definition at line 177 of file G4VSteppingVerbose.cc.

178{
179 SilentStepInfo = fSilent;
180}

References G4VSteppingVerbose::SilentStepInfo.

◆ ShowStep()

void G4SteppingVerbose::ShowStep ( ) const
virtual

Reimplemented in G4SteppingVerboseWithUnits.

Definition at line 845 of file G4SteppingVerbose.cc.

847{
848 if(Silent==1){ return; }
849 G4String volName;
850 G4int oldprc;
851
852 // Show header
853 G4cout << G4endl;
854 G4cout << " ++G4Step Information " << G4endl;
855 oldprc = G4cout.precision(16);
856
857 // Show G4Step specific information
858 G4cout << " Address of G4Track : "
859 << fStep->GetTrack() << G4endl;
860 G4cout << " Step Length (mm) : "
861 << fStep->GetTrack()->GetStepLength() << G4endl;
862 G4cout << " Energy Deposit (MeV) : "
863 << fStep->GetTotalEnergyDeposit() << G4endl;
864
865 // Show G4StepPoint specific information
866 G4cout << " -------------------------------------------------------"
867 << "----------------" << G4endl;
868 G4cout << " StepPoint Information "
869 << std::setw(20) << "PreStep"
870 << std::setw(20) << "PostStep" << G4endl;
871 G4cout << " -------------------------------------------------------"
872 << "----------------" << G4endl;
873 G4cout << " Position - x (mm) : "
874 << std::setw(20) << fStep->GetPreStepPoint()->GetPosition().x()
875 << std::setw(20) << fStep->GetPostStepPoint()->GetPosition().x()
876 << G4endl;
877 G4cout << " Position - y (mm) : "
878 << std::setw(20) << fStep->GetPreStepPoint()->GetPosition().y()
879 << std::setw(20) << fStep->GetPostStepPoint()->GetPosition().y()
880 << G4endl;
881 G4cout << " Position - z (mm) : "
882 << std::setw(20) << fStep->GetPreStepPoint()->GetPosition().z()
883 << std::setw(20) << fStep->GetPostStepPoint()->GetPosition().z()
884 << G4endl;
885 G4cout << " Global Time (ns) : "
886 << std::setw(20) << fStep->GetPreStepPoint()->GetGlobalTime()
887 << std::setw(20) << fStep->GetPostStepPoint()->GetGlobalTime()
888 << G4endl;
889 G4cout << " Local Time (ns) : "
890 << std::setw(20) << fStep->GetPreStepPoint()->GetLocalTime()
891 << std::setw(20) << fStep->GetPostStepPoint()->GetLocalTime()
892 << G4endl;
893 G4cout << " Proper Time (ns) : "
894 << std::setw(20) << fStep->GetPreStepPoint()->GetProperTime()
895 << std::setw(20) << fStep->GetPostStepPoint()->GetProperTime()
896 << G4endl;
897 G4cout << " Momentum Direct - x : "
898 << std::setw(20) << fStep->GetPreStepPoint()->GetMomentumDirection().x()
899 << std::setw(20) << fStep->GetPostStepPoint()->GetMomentumDirection().x()
900 << G4endl;
901 G4cout << " Momentum Direct - y : "
902 << std::setw(20) << fStep->GetPreStepPoint()->GetMomentumDirection().y()
903 << std::setw(20) << fStep->GetPostStepPoint()->GetMomentumDirection().y()
904 << G4endl;
905 G4cout << " Momentum Direct - z : "
906 << std::setw(20) << fStep->GetPreStepPoint()->GetMomentumDirection().z()
907 << std::setw(20) << fStep->GetPostStepPoint()->GetMomentumDirection().z()
908 << G4endl;
909 G4cout << " Momentum - x (MeV/c): "
910 << std::setw(20) << fStep->GetPreStepPoint()->GetMomentum().x()
911 << std::setw(20) << fStep->GetPostStepPoint()->GetMomentum().x()
912 << G4endl;
913 G4cout << " Momentum - y (MeV/c): "
914 << std::setw(20) << fStep->GetPreStepPoint()->GetMomentum().y()
915 << std::setw(20) << fStep->GetPostStepPoint()->GetMomentum().y()
916 << G4endl;
917 G4cout << " Momentum - z (MeV/c): "
918 << std::setw(20) << fStep->GetPreStepPoint()->GetMomentum().z()
919 << std::setw(20) << fStep->GetPostStepPoint()->GetMomentum().z()
920 << G4endl;
921 G4cout << " Total Energy (MeV) : "
922 << std::setw(20) << fStep->GetPreStepPoint()->GetTotalEnergy()
923 << std::setw(20) << fStep->GetPostStepPoint()->GetTotalEnergy()
924 << G4endl;
925 G4cout << " Kinetic Energy (MeV): "
926 << std::setw(20) << fStep->GetPreStepPoint()->GetKineticEnergy()
927 << std::setw(20) << fStep->GetPostStepPoint()->GetKineticEnergy()
928 << G4endl;
929 G4cout << " Velocity (mm/ns) : "
930 << std::setw(20) << fStep->GetPreStepPoint()->GetVelocity()
931 << std::setw(20) << fStep->GetPostStepPoint()->GetVelocity()
932 << G4endl;
933 G4cout << " Volume Name : "
934 << std::setw(20)
935 << fStep->GetPreStepPoint()->GetPhysicalVolume()->GetName();
936 if (fStep->GetPostStepPoint()->GetPhysicalVolume())
937 {
938 volName = fStep->GetPostStepPoint()->GetPhysicalVolume()->GetName();
939 }
940 else
941 {
942 volName = "OutOfWorld";
943 }
944 G4cout << std::setw(20) << volName << G4endl;
945 G4cout << " Safety (mm) : "
946 << std::setw(20) << fStep->GetPreStepPoint()->GetSafety()
947 << std::setw(20) << fStep->GetPostStepPoint()->GetSafety()
948 << G4endl;
949 G4cout << " Polarization - x : "
950 << std::setw(20) << fStep->GetPreStepPoint()->GetPolarization().x()
951 << std::setw(20) << fStep->GetPostStepPoint()->GetPolarization().x()
952 << G4endl;
953 G4cout << " Polarization - y : "
954 << std::setw(20) << fStep->GetPreStepPoint()->GetPolarization().y()
955 << std::setw(20) << fStep->GetPostStepPoint()->GetPolarization().y()
956 << G4endl;
957 G4cout << " Polarization - Z : "
958 << std::setw(20) << fStep->GetPreStepPoint()->GetPolarization().z()
959 << std::setw(20) << fStep->GetPostStepPoint()->GetPolarization().z()
960 << G4endl;
961 G4cout << " Weight : "
962 << std::setw(20) << fStep->GetPreStepPoint()->GetWeight()
963 << std::setw(20) << fStep->GetPostStepPoint()->GetWeight()
964 << G4endl;
965 G4cout << " Step Status : " ;
966 G4StepStatus tStepStatus = fStep->GetPreStepPoint()->GetStepStatus();
967 if( tStepStatus == fGeomBoundary )
968 {
969 G4cout << std::setw(20) << "Geom Limit";
970 }
971 else if ( tStepStatus == fAlongStepDoItProc )
972 {
973 G4cout << std::setw(20) << "AlongStep Proc.";
974 }
975 else if ( tStepStatus == fPostStepDoItProc )
976 {
977 G4cout << std::setw(20) << "PostStep Proc";
978 }
979 else if ( tStepStatus == fAtRestDoItProc )
980 {
981 G4cout << std::setw(20) << "AtRest Proc";
982 }
983 else if ( tStepStatus == fUndefined )
984 {
985 G4cout << std::setw(20) << "Undefined";
986 }
987
988 tStepStatus = fStep->GetPostStepPoint()->GetStepStatus();
989 if( tStepStatus == fGeomBoundary )
990 {
991 G4cout << std::setw(20) << "Geom Limit";
992 }
993 else if ( tStepStatus == fAlongStepDoItProc )
994 {
995 G4cout << std::setw(20) << "AlongStep Proc.";
996 }
997 else if ( tStepStatus == fPostStepDoItProc )
998 {
999 G4cout << std::setw(20) << "PostStep Proc";
1000 }
1001 else if ( tStepStatus == fAtRestDoItProc )
1002 {
1003 G4cout << std::setw(20) << "AtRest Proc";
1004 }
1005 else if ( tStepStatus == fUndefined )
1006 {
1007 G4cout << std::setw(20) << "Undefined";
1008 }
1009
1010 G4cout << G4endl;
1011 G4cout << " Process defined Step: " ;
1012 if( fStep->GetPreStepPoint()->GetProcessDefinedStep() == 0 )
1013 {
1014 G4cout << std::setw(20) << "Undefined";
1015 }
1016 else
1017 {
1018 G4cout << std::setw(20)
1019 << fStep->GetPreStepPoint()
1020 ->GetProcessDefinedStep()->GetProcessName();
1021 }
1022 if( fStep->GetPostStepPoint()->GetProcessDefinedStep() == 0)
1023 {
1024 G4cout << std::setw(20) << "Undefined";
1025 }
1026 else
1027 {
1028 G4cout << std::setw(20)
1029 << fStep->GetPostStepPoint()
1030 ->GetProcessDefinedStep()->GetProcessName();
1031 }
1032 G4cout.precision(oldprc);
1033
1034 G4cout << G4endl;
1035 G4cout << " -------------------------------------------------------"
1036 << "----------------" << G4endl;
1037}
G4StepStatus
G4StepStatus
Definition: G4StepStatus.hh:40
fGeomBoundary
@ fGeomBoundary
Definition: G4StepStatus.hh:43
fUndefined
@ fUndefined
Definition: G4StepStatus.hh:55
fAtRestDoItProc
@ fAtRestDoItProc
Definition: G4StepStatus.hh:45
fAlongStepDoItProc
@ fAlongStepDoItProc
Definition: G4StepStatus.hh:47
CLHEP::Hep3Vector::z
double z() const
CLHEP::Hep3Vector::x
double x() const
CLHEP::Hep3Vector::y
double y() const
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::GetPreStepPoint
G4StepPoint * GetPreStepPoint() const
G4Step::GetTotalEnergyDeposit
G4double GetTotalEnergyDeposit() const
G4Step::GetPostStepPoint
G4StepPoint * GetPostStepPoint() const
G4Track::GetStepLength
G4double GetStepLength() const
G4VPhysicalVolume::GetName
const G4String & GetName() const

References fAlongStepDoItProc, fAtRestDoItProc, fGeomBoundary, fPostStepDoItProc, G4VSteppingVerbose::fStep, fUndefined, G4cout, G4endl, G4StepPoint::GetGlobalTime(), G4StepPoint::GetKineticEnergy(), G4StepPoint::GetLocalTime(), G4StepPoint::GetMomentum(), G4StepPoint::GetMomentumDirection(), G4VPhysicalVolume::GetName(), G4StepPoint::GetPhysicalVolume(), G4StepPoint::GetPolarization(), G4StepPoint::GetPosition(), G4Step::GetPostStepPoint(), G4Step::GetPreStepPoint(), G4StepPoint::GetProcessDefinedStep(), G4VProcess::GetProcessName(), G4StepPoint::GetProperTime(), G4StepPoint::GetSafety(), G4Track::GetStepLength(), G4StepPoint::GetStepStatus(), G4StepPoint::GetTotalEnergy(), G4Step::GetTotalEnergyDeposit(), G4Step::GetTrack(), G4StepPoint::GetVelocity(), G4StepPoint::GetWeight(), G4VSteppingVerbose::Silent, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by AlongStepDoItAllDone(), AlongStepDoItOneByOne(), AtRestDoItInvoked(), PostStepDoItAllDone(), and PostStepDoItOneByOne().

◆ StepInfo()

void G4SteppingVerbose::StepInfo ( )
virtual

Implements G4VSteppingVerbose.

Reimplemented in G4SteppingVerboseWithUnits.

Definition at line 271 of file G4SteppingVerbose.cc.

273{
274 if(Silent==1) { return; }
275 if(SilentStepInfo==1) { return; }
276
277 CopyState();
278 G4cout.precision(16);
279 G4int prec = G4cout.precision(3);
280
281 if( verboseLevel >= 1 )
282 {
283 if( verboseLevel >= 4 ) VerboseTrack();
284 if( verboseLevel >= 3 )
285 {
286 G4cout << G4endl;
287#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
288 G4cout << std::setw( 5) << "#Step#" << " "
289 << std::setw( 8) << "X" << " "
290 << std::setw( 8) << "Y" << " "
291 << std::setw( 8) << "Z" << " "
292 << std::setw( 9) << "KineE" << " "
293 << std::setw( 8) << "dE" << " "
294 << std::setw(12) << "StepLeng" << " "
295 << std::setw(12) << "TrackLeng" << " "
296 << std::setw(12) << "NextVolume" << " "
297 << std::setw( 8) << "ProcName" << G4endl;
298#else
299 G4cout << std::setw( 5) << "#Step#" << " "
300 << std::setw( 8) << "X(mm)" << " "
301 << std::setw( 8) << "Y(mm)" << " "
302 << std::setw( 8) << "Z(mm)" << " "
303 << std::setw( 9) << "KinE(MeV)" << " "
304 << std::setw( 8) << "dE(MeV)" << " "
305 << std::setw( 8) << "StepLeng" << " "
306 << std::setw( 9) << "TrackLeng" << " "
307 << std::setw(11) << "NextVolume" << " "
308 << std::setw( 8) << "ProcName" << G4endl;
309#endif
310 }
311 G4cout << std::setw( 5) << fTrack->GetCurrentStepNumber() << " "
312 << std::setw( 8)
313 << G4BestUnit(fTrack->GetPosition().x(), "Length") << " "
314 << std::setw( 8)
315 << G4BestUnit(fTrack->GetPosition().y(), "Length") << " "
316 << std::setw( 8)
317 << G4BestUnit(fTrack->GetPosition().z(), "Length") << " "
318 << std::setw( 9)
319 << G4BestUnit(fTrack->GetKineticEnergy(), "Energy") << " "
320 << std::setw( 8)
321 << G4BestUnit(fStep->GetTotalEnergyDeposit(), "Energy") << " "
322 << std::setw( 8)
323 << G4BestUnit(fStep->GetStepLength(), "Length") << " "
324 << std::setw( 9)
325 << G4BestUnit(fTrack->GetTrackLength(), "Length") << " ";
326
327 if( fTrack->GetNextVolume() != 0 )
328 {
329 G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
330 }
331 else
332 {
333 G4cout << std::setw(11) << "OutOfWorld" << " ";
334 }
335 if(fStep->GetPostStepPoint()->GetProcessDefinedStep() != 0)
336 {
337 G4cout << fStep->GetPostStepPoint()
338 ->GetProcessDefinedStep()->GetProcessName();
339 }
340 else
341 {
342 G4cout << "User Limit";
343 }
344 G4cout << G4endl;
345 if( verboseLevel == 2 )
346 {
347 G4int tN2ndariesTot = fN2ndariesAtRestDoIt + fN2ndariesAlongStepDoIt
348 + fN2ndariesPostStepDoIt;
349 if(tN2ndariesTot>0)
350 {
351 G4cout << " :----- List of 2ndaries - "
352 << "#SpawnInStep=" << std::setw(3) << tN2ndariesTot
353 << "(Rest=" << std::setw(2) << fN2ndariesAtRestDoIt
354 << ",Along=" << std::setw(2) << fN2ndariesAlongStepDoIt
355 << ",Post=" << std::setw(2) << fN2ndariesPostStepDoIt
356 << "), "
357 << "#SpawnTotal=" << std::setw(3) << (*fSecondary).size()
358 << " ---------------"
359 << G4endl;
360
361 for(std::size_t lp1=(*fSecondary).size()-tN2ndariesTot;
362 lp1<(*fSecondary).size(); ++lp1)
363 {
364 G4cout << " : "
365 << std::setw( 9)
366 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length")
367 << " " << std::setw( 9)
368 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length")
369 << " " << std::setw( 9)
370 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length")
371 << " " << std::setw( 9)
372 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy")
373 << " " << std::setw(18)
374 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
375 << G4endl;
376 }
377 G4cout << " :-----------------------------"
378 << "----------------------------------"
379 << "-- EndOf2ndaries Info ---------------" << G4endl;
380 }
381 }
382 }
383 G4cout.precision(prec);
384}
G4Step::GetStepLength
G4double GetStepLength() const
G4SteppingVerbose::VerboseTrack
virtual void VerboseTrack()
Definition: G4SteppingVerbose.cc:649
G4Track::GetNextVolume
G4VPhysicalVolume * GetNextVolume() const
G4Track::GetPosition
const G4ThreeVector & GetPosition() const
G4Track::GetTrackLength
G4double GetTrackLength() const
G4Track::GetCurrentStepNumber
G4int GetCurrentStepNumber() const
G4Track::GetKineticEnergy
G4double GetKineticEnergy() const
CLHEP::prec
static const double prec
Definition: RanecuEngine.cc:61

References G4VSteppingVerbose::CopyState(), G4VSteppingVerbose::fN2ndariesAlongStepDoIt, G4VSteppingVerbose::fN2ndariesAtRestDoIt, G4VSteppingVerbose::fN2ndariesPostStepDoIt, G4VSteppingVerbose::fSecondary, G4VSteppingVerbose::fStep, G4VSteppingVerbose::fTrack, G4BestUnit, G4cout, G4endl, G4Track::GetCurrentStepNumber(), G4Track::GetKineticEnergy(), G4VPhysicalVolume::GetName(), G4Track::GetNextVolume(), G4Track::GetPosition(), G4Step::GetPostStepPoint(), G4StepPoint::GetProcessDefinedStep(), G4VProcess::GetProcessName(), G4Step::GetStepLength(), G4Step::GetTotalEnergyDeposit(), G4Track::GetTrackLength(), CLHEP::prec, G4VSteppingVerbose::Silent, G4VSteppingVerbose::SilentStepInfo, G4VSteppingVerbose::verboseLevel, VerboseTrack(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

◆ TrackingStarted()

void G4SteppingVerbose::TrackingStarted ( )
virtual

Implements G4VSteppingVerbose.

Reimplemented in G4SteppingVerboseWithUnits.

Definition at line 483 of file G4SteppingVerbose.cc.

485{
486 if(Silent==1){ return; }
487
488 CopyState();
489
490 G4int prec = G4cout.precision(3);
491 if( verboseLevel > 0 )
492 {
493#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
494 G4cout << std::setw( 5) << "Step#" << " "
495 << std::setw( 8) << "X" << " "
496 << std::setw( 8) << "Y" << " "
497 << std::setw( 8) << "Z" << " "
498 << std::setw( 9) << "KineE" << " "
499 << std::setw( 8) << "dE" << " "
500 << std::setw(12) << "StepLeng" << " "
501 << std::setw(12) << "TrackLeng" << " "
502 << std::setw(12) << "NextVolume" << " "
503 << std::setw( 8) << "ProcName" << G4endl;
504#else
505 G4cout << std::setw( 5) << "Step#" << " "
506 << std::setw( 8) << "X(mm)" << " "
507 << std::setw( 8) << "Y(mm)" << " "
508 << std::setw( 8) << "Z(mm)" << " "
509 << std::setw( 9) << "KinE(MeV)" << " "
510 << std::setw( 8) << "dE(MeV)" << " "
511 << std::setw( 8) << "StepLeng" << " "
512 << std::setw( 9) << "TrackLeng" << " "
513 << std::setw(11) << "NextVolume" << " "
514 << std::setw( 8) << "ProcName" << G4endl;
515#endif
516
517 G4cout << std::setw( 5) << fTrack->GetCurrentStepNumber() << " "
518 << std::setw( 8)
519 << G4BestUnit(fTrack->GetPosition().x(),"Length") << " "
520 << std::setw( 8)
521 << G4BestUnit(fTrack->GetPosition().y(),"Length") << " "
522 << std::setw( 8)
523 << G4BestUnit(fTrack->GetPosition().z(),"Length") << " "
524 << std::setw( 9)
525 << G4BestUnit(fTrack->GetKineticEnergy(),"Energy") << " "
526 << std::setw( 8)
527 << G4BestUnit(fStep->GetTotalEnergyDeposit(),"Energy") << " "
528 << std::setw( 8)
529 << G4BestUnit(fStep->GetStepLength(),"Length") << " "
530 << std::setw( 9)
531 << G4BestUnit(fTrack->GetTrackLength(),"Length") << " ";
532
533 if(fTrack->GetNextVolume())
534 {
535 G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
536 }
537 else
538 {
539 G4cout << std::setw(11) << "OutOfWorld" << " ";
540 }
541 G4cout << "initStep" << G4endl;
542 }
543 G4cout.precision(prec);
544}

References G4VSteppingVerbose::CopyState(), G4VSteppingVerbose::fStep, G4VSteppingVerbose::fTrack, G4BestUnit, G4cout, G4endl, G4Track::GetCurrentStepNumber(), G4Track::GetKineticEnergy(), G4VPhysicalVolume::GetName(), G4Track::GetNextVolume(), G4Track::GetPosition(), G4Step::GetStepLength(), G4Step::GetTotalEnergyDeposit(), G4Track::GetTrackLength(), CLHEP::prec, G4VSteppingVerbose::Silent, G4VSteppingVerbose::verboseLevel, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

◆ UseBestUnit()

void G4SteppingVerbose::UseBestUnit ( G4int  prec = 4)
static

Definition at line 1040 of file G4SteppingVerbose.cc.

1042{ useBestUnitPrecision = prec; }

References CLHEP::prec, and useBestUnitPrecision.

◆ VerboseParticleChange()

void G4SteppingVerbose::VerboseParticleChange ( )
virtual

Implements G4VSteppingVerbose.

Reimplemented in G4SteppingVerboseWithUnits.

Definition at line 834 of file G4SteppingVerbose.cc.

836{
837 if(Silent==1) { return; }
838
839 G4cout << G4endl;
840 G4cout << " ++G4ParticleChange Information " << G4endl;
841 fParticleChange->DumpInfo();
842}
G4VParticleChange::DumpInfo
virtual void DumpInfo() const
Definition: G4VParticleChange.cc:232

References G4VParticleChange::DumpInfo(), G4VSteppingVerbose::fParticleChange, G4cout, G4endl, and G4VSteppingVerbose::Silent.

Referenced by AlongStepDoItOneByOne(), and PostStepDoItOneByOne().

◆ VerboseTrack()

void G4SteppingVerbose::VerboseTrack ( )
virtual

Implements G4VSteppingVerbose.

Reimplemented in G4SteppingVerboseWithUnits.

Definition at line 649 of file G4SteppingVerbose.cc.

651{
652 if(Silent==1){ return; }
653
654 CopyState();
655
656 G4cout << G4endl;
657 G4cout << " ++G4Track Information " << G4endl;
658 G4int prec = G4cout.precision(3);
659
660
661 G4cout << " -----------------------------------------------"
662 << G4endl;
663 G4cout << " G4Track Information " << std::setw(20) << G4endl;
664 G4cout << " -----------------------------------------------"
665 << G4endl;
666
667 G4cout << " Step number : "
668 << std::setw(20) << fTrack->GetCurrentStepNumber()
669 << G4endl;
670#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
671 G4cout << " Position - x : "
672 << std::setw(20) << G4BestUnit(fTrack->GetPosition().x(), "Length")
673 << G4endl;
674 G4cout << " Position - y : "
675 << std::setw(20) << G4BestUnit(fTrack->GetPosition().y(), "Length")
676 << G4endl;
677 G4cout << " Position - z : "
678 << std::setw(20) << G4BestUnit(fTrack->GetPosition().z(), "Length")
679 << G4endl;
680 G4cout << " Global Time : "
681 << std::setw(20) << G4BestUnit(fTrack->GetGlobalTime(), "Time")
682 << G4endl;
683 G4cout << " Local Time : "
684 << std::setw(20) << G4BestUnit(fTrack->GetLocalTime(), "Time")
685 << G4endl;
686#else
687 G4cout << " Position - x (mm) : "
688 << std::setw(20) << fTrack->GetPosition().x() /mm
689 << G4endl;
690 G4cout << " Position - y (mm) : "
691 << std::setw(20) << fTrack->GetPosition().y() /mm
692 << G4endl;
693 G4cout << " Position - z (mm) : "
694 << std::setw(20) << fTrack->GetPosition().z() /mm
695 << G4endl;
696 G4cout << " Global Time (ns) : "
697 << std::setw(20) << fTrack->GetGlobalTime() /ns
698 << G4endl;
699 G4cout << " Local Time (ns) : "
700 << std::setw(20) << fTrack->GetLocalTime() /ns
701 << G4endl;
702#endif
703 G4cout << " Momentum Direct - x : "
704 << std::setw(20) << fTrack->GetMomentumDirection().x()
705 << G4endl;
706 G4cout << " Momentum Direct - y : "
707 << std::setw(20) << fTrack->GetMomentumDirection().y()
708 << G4endl;
709 G4cout << " Momentum Direct - z : "
710 << std::setw(20) << fTrack->GetMomentumDirection().z()
711 << G4endl;
712#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
713 G4cout << " Kinetic Energy : "
714#else
715 G4cout << " Kinetic Energy (MeV): "
716#endif
717 << std::setw(20) << G4BestUnit(fTrack->GetKineticEnergy(), "Energy")
718 << G4endl;
719 G4cout << " Polarization - x : "
720 << std::setw(20) << fTrack->GetPolarization().x()
721 << G4endl;
722 G4cout << " Polarization - y : "
723 << std::setw(20) << fTrack->GetPolarization().y()
724 << G4endl;
725 G4cout << " Polarization - z : "
726 << std::setw(20) << fTrack->GetPolarization().z()
727 << G4endl;
728 G4cout << " Track Length : "
729 << std::setw(20) << G4BestUnit(fTrack->GetTrackLength(), "Length")
730 << G4endl;
731 G4cout << " Track ID # : "
732 << std::setw(20) << fTrack->GetTrackID()
733 << G4endl;
734 G4cout << " Parent Track ID # : "
735 << std::setw(20) << fTrack->GetParentID()
736 << G4endl;
737 G4cout << " Next Volume : "
738 << std::setw(20);
739 if( fTrack->GetNextVolume() != 0 )
740 {
741 G4cout << fTrack->GetNextVolume()->GetName() << " ";
742 }
743 else
744 {
745 G4cout << "OutOfWorld" << " ";
746 }
747 G4cout << G4endl;
748 G4cout << " Track Status : "
749 << std::setw(20);
750 if( fTrack->GetTrackStatus() == fAlive )
751 {
752 G4cout << " Alive";
753 }
754 else if( fTrack->GetTrackStatus() == fStopButAlive )
755 {
756 G4cout << " StopButAlive";
757 }
758 else if( fTrack->GetTrackStatus() == fStopAndKill )
759 {
760 G4cout << " StopAndKill";
761 }
762 else if( fTrack->GetTrackStatus() == fKillTrackAndSecondaries )
763 {
764 G4cout << " KillTrackAndSecondaries";
765 }
766 else if( fTrack->GetTrackStatus() == fSuspend )
767 {
768 G4cout << " Suspend";
769 }
770 else if( fTrack->GetTrackStatus() == fPostponeToNextEvent )
771 {
772 G4cout << " PostponeToNextEvent";
773 }
774 G4cout << G4endl;
775#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
776 G4cout << " Vertex - x : "
777 << std::setw(20)
778 << G4BestUnit(fTrack->GetVertexPosition().x(),"Length")
779 << G4endl;
780 G4cout << " Vertex - y : "
781 << std::setw(20)
782 << G4BestUnit(fTrack->GetVertexPosition().y(),"Length")
783 << G4endl;
784 G4cout << " Vertex - z : "
785 << std::setw(20)
786 << G4BestUnit(fTrack->GetVertexPosition().z(),"Length")
787 << G4endl;
788#else
789 G4cout << " Vertex - x (mm) : "
790 << std::setw(20) << fTrack->GetVertexPosition().x()/mm
791 << G4endl;
792 G4cout << " Vertex - y (mm) : "
793 << std::setw(20) << fTrack->GetVertexPosition().y()/mm
794 << G4endl;
795 G4cout << " Vertex - z (mm) : "
796 << std::setw(20) << fTrack->GetVertexPosition().z()/mm
797 << G4endl;
798#endif
799 G4cout << " Vertex - Px (MomDir): "
800 << std::setw(20) << fTrack->GetVertexMomentumDirection().x()
801 << G4endl;
802 G4cout << " Vertex - Py (MomDir): "
803 << std::setw(20) << fTrack->GetVertexMomentumDirection().y()
804 << G4endl;
805 G4cout << " Vertex - Pz (MomDir): "
806 << std::setw(20) << fTrack->GetVertexMomentumDirection().z()
807 << G4endl;
808#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
809 G4cout << " Vertex - KineE : "
810#else
811 G4cout << " Vertex - KineE (MeV): "
812#endif
813 << std::setw(20)
814 << G4BestUnit(fTrack->GetVertexKineticEnergy(),"Energy")
815 << G4endl;
816
817 G4cout << " Creator Process : "
818 << std::setw(20);
819 if( fTrack->GetCreatorProcess() == 0)
820 {
821 G4cout << " Event Generator" << G4endl;
822 }
823 else
824 {
825 G4cout << fTrack->GetCreatorProcess()->GetProcessName() << G4endl;
826 }
827
828 G4cout << " -----------------------------------------------"
829 << G4endl;
830 G4cout.precision(prec);
831}
mm
static constexpr double mm
Definition: G4SIunits.hh:95
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
G4Track::GetTrackStatus
G4TrackStatus GetTrackStatus() const
G4Track::GetVertexKineticEnergy
G4double GetVertexKineticEnergy() const
G4Track::GetTrackID
G4int GetTrackID() const
G4Track::GetCreatorProcess
const G4VProcess * GetCreatorProcess() const
G4Track::GetVertexMomentumDirection
const G4ThreeVector & GetVertexMomentumDirection() const
G4Track::GetGlobalTime
G4double GetGlobalTime() const
G4Track::GetVertexPosition
const G4ThreeVector & GetVertexPosition() const
G4Track::GetLocalTime
G4double GetLocalTime() const
G4Track::GetMomentumDirection
const G4ThreeVector & GetMomentumDirection() const
G4Track::GetPolarization
const G4ThreeVector & GetPolarization() const
G4Track::GetParentID
G4int GetParentID() const
ns
#define ns
Definition: xmlparse.cc:614

References G4VSteppingVerbose::CopyState(), fAlive, fKillTrackAndSecondaries, fPostponeToNextEvent, fStopAndKill, fStopButAlive, fSuspend, G4VSteppingVerbose::fTrack, G4BestUnit, G4cout, G4endl, G4Track::GetCreatorProcess(), G4Track::GetCurrentStepNumber(), G4Track::GetGlobalTime(), G4Track::GetKineticEnergy(), G4Track::GetLocalTime(), G4Track::GetMomentumDirection(), G4VPhysicalVolume::GetName(), G4Track::GetNextVolume(), G4Track::GetParentID(), G4Track::GetPolarization(), G4Track::GetPosition(), G4VProcess::GetProcessName(), G4Track::GetTrackID(), G4Track::GetTrackLength(), G4Track::GetTrackStatus(), G4Track::GetVertexKineticEnergy(), G4Track::GetVertexMomentumDirection(), G4Track::GetVertexPosition(), mm, ns, CLHEP::prec, G4VSteppingVerbose::Silent, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by StepInfo().

Field Documentation

◆ CorrectedStep

G4double G4VSteppingVerbose::CorrectedStep = 0.0
protectedinherited

Definition at line 119 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ currentMinimumStep

G4double G4VSteppingVerbose::currentMinimumStep = 0.0
protectedinherited

Definition at line 155 of file G4VSteppingVerbose.hh.

◆ fAlongStepDoItProcTriggered

std::size_t G4VSteppingVerbose::fAlongStepDoItProcTriggered = 0
protectedinherited

Definition at line 159 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fAlongStepDoItVector

G4ProcessVector* G4VSteppingVerbose::fAlongStepDoItVector = nullptr
protectedinherited

Definition at line 144 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fAlongStepGetPhysIntVector

G4ProcessVector* G4VSteppingVerbose::fAlongStepGetPhysIntVector = nullptr
protectedinherited

Definition at line 148 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fAtRestDoItProcTriggered

std::size_t G4VSteppingVerbose::fAtRestDoItProcTriggered = 0
protectedinherited

Definition at line 158 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fAtRestDoItVector

G4ProcessVector* G4VSteppingVerbose::fAtRestDoItVector = nullptr
protectedinherited

Definition at line 143 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fAtRestGetPhysIntVector

G4ProcessVector* G4VSteppingVerbose::fAtRestGetPhysIntVector = nullptr
protectedinherited

Definition at line 147 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fCondition

G4ForceCondition G4VSteppingVerbose::fCondition = InActivated
protectedinherited

Definition at line 187 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState(), DPSLPostStep(), G4SteppingVerboseWithUnits::DPSLPostStep(), PostStepDoItAllDone(), and G4SteppingVerboseWithUnits::PostStepDoItAllDone().

◆ fCurrentProcess

G4VProcess* G4VSteppingVerbose::fCurrentProcess = nullptr
protectedinherited

Definition at line 139 of file G4VSteppingVerbose.hh.

Referenced by AlongStepDoItOneByOne(), G4SteppingVerboseWithUnits::AlongStepDoItOneByOne(), G4VSteppingVerbose::CopyState(), DPSLAlongStep(), G4SteppingVerboseWithUnits::DPSLAlongStep(), DPSLPostStep(), G4SteppingVerboseWithUnits::DPSLPostStep(), PostStepDoItOneByOne(), and G4SteppingVerboseWithUnits::PostStepDoItOneByOne().

◆ fCurrentVolume

G4VPhysicalVolume* G4VSteppingVerbose::fCurrentVolume = nullptr
protectedinherited

Definition at line 137 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fGPILSelection

G4GPILSelection G4VSteppingVerbose::fGPILSelection = NotCandidateForSelection
protectedinherited

Definition at line 188 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState(), DPSLAlongStep(), and G4SteppingVerboseWithUnits::DPSLAlongStep().

◆ fInstance

G4ThreadLocal G4VSteppingVerbose * G4VSteppingVerbose::fInstance = nullptr
staticprotectedinherited

Definition at line 105 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::G4VSteppingVerbose(), G4VSteppingVerbose::GetInstance(), and G4VSteppingVerbose::~G4VSteppingVerbose().

◆ FirstStep

G4bool G4VSteppingVerbose::FirstStep = false
protectedinherited

Definition at line 121 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fManager

G4SteppingManager* G4VSteppingVerbose::fManager = nullptr
protectedinherited

Definition at line 114 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState(), G4VSteppingVerbose::SetManager(), and G4SteppingVerboseWithUnits::SetManager().

◆ fMasterInstance

G4VSteppingVerbose * G4VSteppingVerbose::fMasterInstance = nullptr
staticprotectedinherited

Definition at line 107 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::G4VSteppingVerbose(), and G4VSteppingVerbose::GetMasterInstance().

◆ fN2ndariesAlongStepDoIt

G4int G4VSteppingVerbose::fN2ndariesAlongStepDoIt = 0
protectedinherited

Definition at line 163 of file G4VSteppingVerbose.hh.

Referenced by AlongStepDoItOneByOne(), G4SteppingVerboseWithUnits::AlongStepDoItOneByOne(), G4VSteppingVerbose::CopyState(), and StepInfo().

◆ fN2ndariesAtRestDoIt

G4int G4VSteppingVerbose::fN2ndariesAtRestDoIt = 0
protectedinherited

Definition at line 162 of file G4VSteppingVerbose.hh.

Referenced by AtRestDoItInvoked(), G4SteppingVerboseWithUnits::AtRestDoItInvoked(), G4VSteppingVerbose::CopyState(), and StepInfo().

◆ fN2ndariesPostStepDoIt

G4int G4VSteppingVerbose::fN2ndariesPostStepDoIt = 0
protectedinherited

Definition at line 164 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState(), PostStepDoItOneByOne(), G4SteppingVerboseWithUnits::PostStepDoItOneByOne(), and StepInfo().

◆ fNavigator

G4Navigator* G4VSteppingVerbose::fNavigator = nullptr
protectedinherited

Definition at line 168 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fParticleChange

G4VParticleChange* G4VSteppingVerbose::fParticleChange = nullptr
protectedinherited

Definition at line 130 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState(), VerboseParticleChange(), and G4SteppingVerboseWithUnits::VerboseParticleChange().

◆ fPostStepDoItProcTriggered

std::size_t G4VSteppingVerbose::fPostStepDoItProcTriggered = 0
protectedinherited

Definition at line 160 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fPostStepDoItVector

G4ProcessVector* G4VSteppingVerbose::fPostStepDoItVector = nullptr
protectedinherited

Definition at line 145 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fPostStepGetPhysIntVector

G4ProcessVector* G4VSteppingVerbose::fPostStepGetPhysIntVector = nullptr
protectedinherited

Definition at line 149 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fPostStepPoint

G4StepPoint* G4VSteppingVerbose::fPostStepPoint = nullptr
protectedinherited

Definition at line 135 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fPreStepPoint

G4StepPoint* G4VSteppingVerbose::fPreStepPoint = nullptr
protectedinherited

Definition at line 134 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fPreviousStepSize

G4double G4VSteppingVerbose::fPreviousStepSize = 0.0
protectedinherited

Definition at line 180 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fSecondary

G4TrackVector* G4VSteppingVerbose::fSecondary = nullptr
protectedinherited

Definition at line 132 of file G4VSteppingVerbose.hh.

Referenced by AlongStepDoItAllDone(), G4SteppingVerboseWithUnits::AlongStepDoItAllDone(), AlongStepDoItOneByOne(), G4SteppingVerboseWithUnits::AlongStepDoItOneByOne(), AtRestDoItInvoked(), G4SteppingVerboseWithUnits::AtRestDoItInvoked(), G4VSteppingVerbose::CopyState(), PostStepDoItAllDone(), G4SteppingVerboseWithUnits::PostStepDoItAllDone(), PostStepDoItOneByOne(), G4SteppingVerboseWithUnits::PostStepDoItOneByOne(), and StepInfo().

◆ fSelectedAlongStepDoItVector

G4SelectedAlongStepDoItVector* G4VSteppingVerbose::fSelectedAlongStepDoItVector = nullptr
protectedinherited

Definition at line 177 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fSelectedAtRestDoItVector

G4SelectedAtRestDoItVector* G4VSteppingVerbose::fSelectedAtRestDoItVector = nullptr
protectedinherited

Definition at line 176 of file G4VSteppingVerbose.hh.

Referenced by AtRestDoItInvoked(), G4SteppingVerboseWithUnits::AtRestDoItInvoked(), and G4VSteppingVerbose::CopyState().

◆ fSelectedPostStepDoItVector

G4SelectedPostStepDoItVector* G4VSteppingVerbose::fSelectedPostStepDoItVector = nullptr
protectedinherited

Definition at line 178 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState(), PostStepDoItAllDone(), and G4SteppingVerboseWithUnits::PostStepDoItAllDone().

◆ fSensitive

G4VSensitiveDetector* G4VSteppingVerbose::fSensitive = nullptr
protectedinherited

Definition at line 138 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fStep

G4Step* G4VSteppingVerbose::fStep = nullptr
protectedinherited

Definition at line 133 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState(), ShowStep(), G4SteppingVerboseWithUnits::ShowStep(), StepInfo(), G4SteppingVerboseWithUnits::StepInfo(), TrackingStarted(), and G4SteppingVerboseWithUnits::TrackingStarted().

◆ fStepStatus

G4StepStatus G4VSteppingVerbose::fStepStatus = fUndefined
protectedinherited

Definition at line 122 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState(), PostStepDoItAllDone(), G4SteppingVerboseWithUnits::PostStepDoItAllDone(), and G4SteppingVerboseWithUnits::StepInfo().

◆ fTouchableHandle

G4TouchableHandle G4VSteppingVerbose::fTouchableHandle
protectedinherited

Definition at line 182 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ fTrack

G4Track* G4VSteppingVerbose::fTrack = nullptr
protectedinherited

Definition at line 131 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState(), StepInfo(), G4SteppingVerboseWithUnits::StepInfo(), TrackingStarted(), G4SteppingVerboseWithUnits::TrackingStarted(), VerboseTrack(), and G4SteppingVerboseWithUnits::VerboseTrack().

◆ fUserSteppingAction

G4UserSteppingAction* G4VSteppingVerbose::fUserSteppingAction = nullptr
protectedinherited

Definition at line 115 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ GeometricalStep

G4double G4VSteppingVerbose::GeometricalStep = 0.0
protectedinherited

Definition at line 118 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ Mass

G4double G4VSteppingVerbose::Mass = 0.0
protectedinherited

Definition at line 126 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ MAXofAlongStepLoops

std::size_t G4VSteppingVerbose::MAXofAlongStepLoops = 0
protectedinherited

Definition at line 152 of file G4VSteppingVerbose.hh.

Referenced by AlongStepDoItAllDone(), G4SteppingVerboseWithUnits::AlongStepDoItAllDone(), and G4VSteppingVerbose::CopyState().

◆ MAXofAtRestLoops

std::size_t G4VSteppingVerbose::MAXofAtRestLoops = 0
protectedinherited

Definition at line 151 of file G4VSteppingVerbose.hh.

Referenced by AtRestDoItInvoked(), G4SteppingVerboseWithUnits::AtRestDoItInvoked(), and G4VSteppingVerbose::CopyState().

◆ MAXofPostStepLoops

std::size_t G4VSteppingVerbose::MAXofPostStepLoops = 0
protectedinherited

Definition at line 153 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState(), PostStepDoItAllDone(), and G4SteppingVerboseWithUnits::PostStepDoItAllDone().

◆ numberOfInteractionLengthLeft

G4double G4VSteppingVerbose::numberOfInteractionLengthLeft = 0.0
protectedinherited

Definition at line 156 of file G4VSteppingVerbose.hh.

◆ PhysicalStep

G4double G4VSteppingVerbose::PhysicalStep = 0.0
protectedinherited

Definition at line 117 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ physIntLength

G4double G4VSteppingVerbose::physIntLength = 0.0
protectedinherited

Definition at line 186 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState(), DPSLAlongStep(), G4SteppingVerboseWithUnits::DPSLAlongStep(), DPSLPostStep(), G4SteppingVerboseWithUnits::DPSLPostStep(), DPSLUserLimit(), and G4SteppingVerboseWithUnits::DPSLUserLimit().

◆ PreStepPointIsGeom

G4bool G4VSteppingVerbose::PreStepPointIsGeom = false
protectedinherited

Definition at line 120 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ Silent

G4ThreadLocal G4int G4VSteppingVerbose::Silent = 0
staticprotectedinherited

Definition at line 109 of file G4VSteppingVerbose.hh.

Referenced by AlongStepDoItAllDone(), AlongStepDoItOneByOne(), AtRestDoItInvoked(), DPSLAlongStep(), DPSLPostStep(), DPSLStarted(), DPSLUserLimit(), G4VSteppingVerbose::GetSilent(), PostStepDoItAllDone(), PostStepDoItOneByOne(), G4VSteppingVerbose::SetSilent(), ShowStep(), StepInfo(), TrackingStarted(), VerboseParticleChange(), and VerboseTrack().

◆ SilentStepInfo

G4ThreadLocal G4int G4VSteppingVerbose::SilentStepInfo = 0
staticprotectedinherited

Definition at line 111 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::GetSilentStepInfo(), G4VSteppingVerbose::SetSilentStepInfo(), and StepInfo().

◆ StepControlFlag

G4SteppingControl G4VSteppingVerbose::StepControlFlag = NormalCondition
protectedinherited

Definition at line 184 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ sumEnergyChange

G4double G4VSteppingVerbose::sumEnergyChange = 0.0
protectedinherited

Definition at line 128 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ TempInitVelocity

G4double G4VSteppingVerbose::TempInitVelocity = 0.0
protectedinherited

Definition at line 124 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ TempVelocity

G4double G4VSteppingVerbose::TempVelocity = 0.0
protectedinherited

Definition at line 125 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState().

◆ useBestUnitPrecision

G4int G4SteppingVerbose::useBestUnitPrecision = -1
staticprivate

Definition at line 73 of file G4SteppingVerbose.hh.

Referenced by BestUnitPrecision(), and UseBestUnit().

◆ verboseLevel

G4int G4VSteppingVerbose::verboseLevel = 0
protectedinherited

Definition at line 170 of file G4VSteppingVerbose.hh.

Referenced by AlongStepDoItAllDone(), G4SteppingVerboseWithUnits::AlongStepDoItAllDone(), AlongStepDoItOneByOne(), G4SteppingVerboseWithUnits::AlongStepDoItOneByOne(), AtRestDoItInvoked(), G4SteppingVerboseWithUnits::AtRestDoItInvoked(), G4VSteppingVerbose::CopyState(), DPSLAlongStep(), G4SteppingVerboseWithUnits::DPSLAlongStep(), DPSLPostStep(), G4SteppingVerboseWithUnits::DPSLPostStep(), DPSLStarted(), G4SteppingVerboseWithUnits::DPSLStarted(), DPSLUserLimit(), G4SteppingVerboseWithUnits::DPSLUserLimit(), PostStepDoItAllDone(), G4SteppingVerboseWithUnits::PostStepDoItAllDone(), PostStepDoItOneByOne(), G4SteppingVerboseWithUnits::PostStepDoItOneByOne(), StepInfo(), G4SteppingVerboseWithUnits::StepInfo(), TrackingStarted(), and G4SteppingVerboseWithUnits::TrackingStarted().

The documentation for this class was generated from the following files:
Generated by doxygen 1.9.3