G4SteppingVerboseWithUnits Class Reference

#include <G4SteppingVerboseWithUnits.hh>

Inheritance diagram for G4SteppingVerboseWithUnits:

Public Member Functions
void	AlongStepDoItAllDone () override
void	AlongStepDoItOneByOne () override
void	AtRestDoItInvoked () override
G4VSteppingVerbose *	Clone () override
void	CopyState ()
void	DPSLAlongStep () override
void	DPSLPostStep () override
void	DPSLStarted () override
void	DPSLUserLimit () override
	G4SteppingVerboseWithUnits (G4int precision=4)
virtual void	NewStep ()
void	PostStepDoItAllDone () override
void	PostStepDoItOneByOne () override
void	SetManager (G4SteppingManager *const) override
void	ShowStep () const override
void	StepInfo () override
void	TrackingStarted () override
void	VerboseParticleChange () override
void	VerboseTrack () override
	~G4SteppingVerboseWithUnits () override

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

Private Attributes
G4GenericMessenger *	fmessenger = nullptr
G4int	fprec

Static Private Attributes
static G4int	useBestUnitPrecision = -1

Detailed Description

Definition at line 48 of file G4SteppingVerboseWithUnits.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

G4SteppingVerboseWithUnits()

G4SteppingVerboseWithUnits::G4SteppingVerboseWithUnits

(

G4int

precision = 4

)

Definition at line 46 of file G4SteppingVerboseWithUnits.cc.

  : G4SteppingVerbose(), fprec(prec)
{
}

Referenced by Clone().

~G4SteppingVerboseWithUnits()

G4SteppingVerboseWithUnits::~G4SteppingVerboseWithUnits ( )

override

Definition at line 53 of file G4SteppingVerboseWithUnits.cc.

{
  delete fmessenger;
} 

References fmessenger.

Member Function Documentation

AlongStepDoItAllDone()

void G4SteppingVerboseWithUnits::AlongStepDoItAllDone ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 246 of file G4SteppingVerboseWithUnits.cc.

{
  G4VProcess* ptProcManager;
 
  CopyState();
 
  if(verboseLevel >= 3)
  {
    G4cout << G4endl;
    G4cout << " >>AlongStepDoIt (after all invocations):" << G4endl;
    G4cout << "    ++List of invoked processes " << G4endl;
 
    for(std::size_t ci=0; ci<MAXofAlongStepLoops; ++ci)
    {
      ptProcManager = (*fAlongStepDoItVector)(ci);
      G4cout << "      " << ci+1 << ") ";
      if(ptProcManager != nullptr)
      {
        G4cout << ptProcManager->GetProcessName() << G4endl;
      }
    }
 
    ShowStep();
    G4cout << G4endl;
    G4cout << "    ++List of secondaries generated " 
           << "(x,y,z,kE,t,PID):"
           << "  No. of secondaries = " 
           << (*fSecondary).size() << G4endl;
 
    if((*fSecondary).size()>0)
    {
      for(std::size_t lp1=0; lp1<(*fSecondary).size(); ++lp1)
      {
        G4cout << "      "
               << std::setw( 9)
               << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(),"Length")
               << " " << std::setw( 9)
               << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(),"Length")
               << " " << std::setw( 9)
               << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(),"Length")
               << " " << std::setw( 9)
               << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(),"Energy")
               << " " << std::setw( 9)
               << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(),"Time")
               << " " << std::setw(18)
               << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
               << G4endl;
      }
    }
  }
}

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

AlongStepDoItOneByOne()

void G4SteppingVerboseWithUnits::AlongStepDoItOneByOne ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 466 of file G4SteppingVerboseWithUnits.cc.

{ 
  CopyState();
 
  if(verboseLevel >= 4)
  { 
    G4cout << G4endl;
    G4cout << " >>AlongStepDoIt (process by process): "
           << "   Process Name = " 
           << fCurrentProcess->GetProcessName() << G4endl;
 
    ShowStep();
    G4cout << "          "
           << "!Note! Safety of PostStep is only valid "
           << "after all DoIt invocations."
           << G4endl; 
 
    VerboseParticleChange();    
    G4cout << G4endl;
 
    G4cout << "    ++List of secondaries generated " 
           << "(x,y,z,kE,t,PID):"
           << "  No. of secondaries = " 
           << fN2ndariesAlongStepDoIt << G4endl;
 
    if(fN2ndariesAlongStepDoIt>0)
    {
      for(std::size_t lp1=(*fSecondary).size()-fN2ndariesAlongStepDoIt;
                      lp1<(*fSecondary).size(); ++lp1)
      {
         G4cout  << "      "
                 << std::setw( 9)
                 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length")
                 << " " << std::setw( 9)
                 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length")
                 << " " << std::setw( 9)
                 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length")
                 << " " << std::setw( 9)
                 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy")
                 << " " << std::setw( 9)
                 << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time")
                 << " " << std::setw(18)
                 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
                 << G4endl;
      }
    }
  }
}

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

AtRestDoItInvoked()

void G4SteppingVerboseWithUnits::AtRestDoItInvoked ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 181 of file G4SteppingVerboseWithUnits.cc.

{
  G4VProcess* ptProcManager;
  CopyState();
 
  if(verboseLevel >= 3)
  {
    G4int npt=0;
    G4cout << " **List of AtRestDoIt invoked:" << G4endl;
    for(std::size_t np=0; np<MAXofAtRestLoops; ++np)
    {
      std::size_t npGPIL = MAXofAtRestLoops-np-1;
      if( (*fSelectedAtRestDoItVector)[npGPIL] == G4ForceCondition::Forced )
      {
        ++npt;                
        ptProcManager = (*fAtRestDoItVector)[np];
        G4cout << "   # " << npt << " : " 
               << ptProcManager->GetProcessName() 
               << " (Forced)" << G4endl;
      }
      else if ( (*fSelectedAtRestDoItVector)[npGPIL] == G4ForceCondition::NotForced )
      {
        ++npt;                
        ptProcManager = (*fAtRestDoItVector)[np];
        G4cout << "   # " << npt << " : "  << ptProcManager->GetProcessName()
               << G4endl;
      }
    }
     
    G4cout << "   Generated secondaries = " << fN2ndariesAtRestDoIt << G4endl;
     
    if( fN2ndariesAtRestDoIt > 0 )
    {
      G4cout << "   -- List of secondaries generated : "
             << "(x,y,z,kE,t,PID) --" << G4endl; 
      for( std::size_t lp1=(*fSecondary).size()-fN2ndariesAtRestDoIt;
                       lp1<(*fSecondary).size(); ++lp1)
      {
        G4cout << "      "
               << std::setw( 9)
               << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(),"Length")
               << " " << std::setw( 9)
               << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(),"Length")
               << " " << std::setw( 9)
               << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(),"Length")
               << " " << std::setw( 9)
               << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(),"Energy")
               << " " << std::setw( 9)
               << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(),"Time")
               << " " << std::setw(18)
               << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
               << G4endl;
      }
    }
  }
   
  if( verboseLevel >= 4 )
  { 
    ShowStep();
    G4cout << G4endl;
  }
}

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

BestUnitPrecision()

G4int G4SteppingVerbose::BestUnitPrecision ( )

staticinherited

Definition at line 1045 of file G4SteppingVerbose.cc.

{ return useBestUnitPrecision; }

References G4SteppingVerbose::useBestUnitPrecision.

Referenced by G4SteppingManager::G4SteppingManager().

Clone()

G4VSteppingVerbose * G4SteppingVerboseWithUnits::Clone ( )

inlineoverridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 55 of file G4SteppingVerboseWithUnits.hh.

      { return new G4SteppingVerboseWithUnits; }

References G4SteppingVerboseWithUnits().

CopyState()

void G4VSteppingVerbose::CopyState ( )

inherited

Definition at line 81 of file G4VSteppingVerbose.cc.

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

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 G4SteppingVerbose::AlongStepDoItAllDone(), AlongStepDoItAllDone(), G4SteppingVerbose::AlongStepDoItOneByOne(), AlongStepDoItOneByOne(), G4SteppingVerbose::AtRestDoItInvoked(), AtRestDoItInvoked(), G4SteppingVerbose::DPSLAlongStep(), DPSLAlongStep(), G4SteppingVerbose::DPSLPostStep(), DPSLPostStep(), G4SteppingVerbose::DPSLStarted(), DPSLStarted(), G4SteppingVerbose::DPSLUserLimit(), DPSLUserLimit(), G4SteppingVerbose::PostStepDoItAllDone(), PostStepDoItAllDone(), G4SteppingVerbose::PostStepDoItOneByOne(), PostStepDoItOneByOne(), G4SteppingVerbose::StepInfo(), StepInfo(), G4SteppingVerbose::TrackingStarted(), TrackingStarted(), G4SteppingVerbose::VerboseTrack(), and VerboseTrack().

DPSLAlongStep()

void G4SteppingVerboseWithUnits::DPSLAlongStep ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 438 of file G4SteppingVerboseWithUnits.cc.

{
  CopyState();
 
  if( verboseLevel > 5 )
  {
    G4cout << "    ++ProposedStep(AlongStep) = " 
           << std::setw( 9) << G4BestUnit(physIntLength , "Length")
           << " : ProcName = "
           << fCurrentProcess->GetProcessName() 
           << " (";
    if(fGPILSelection==CandidateForSelection)
    {
      G4cout << "CandidateForSelection)" << G4endl;
    }
    else if(fGPILSelection==NotCandidateForSelection)
    {
      G4cout << "NotCandidateForSelection)" << G4endl;
    }
    else
    {
      G4cout << "?!?)" << G4endl;
    }
  }
}

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

DPSLPostStep()

void G4SteppingVerboseWithUnits::DPSLPostStep ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 404 of file G4SteppingVerboseWithUnits.cc.

{
  CopyState();
 
  if( verboseLevel > 5 )
  {
    G4cout << "    ++ProposedStep(PostStep ) = "
           << std::setw( 9) << G4BestUnit(physIntLength , "Length")
           << " : ProcName = " << fCurrentProcess->GetProcessName() << " (";
    if(fCondition==ExclusivelyForced)
    {
      G4cout << "ExclusivelyForced)" << G4endl;
    }
    else if(fCondition==StronglyForced)
    {
      G4cout << "StronglyForced)" << G4endl;
    }
    else if(fCondition==Conditionally)
    {
      G4cout << "Conditionally)" << G4endl;
    }
    else if(fCondition==Forced)
    {
      G4cout << "Forced)" << G4endl;
    }
    else
    {
      G4cout << "No ForceCondition)" << G4endl;
    }
  }
}

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

DPSLStarted()

void G4SteppingVerboseWithUnits::DPSLStarted ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 374 of file G4SteppingVerboseWithUnits.cc.

{
  CopyState();
 
  if( verboseLevel > 5 )
  {
    G4cout << G4endl
           << " >>DefinePhysicalStepLength (List of proposed StepLengths): "
           << G4endl;
  }
}

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

DPSLUserLimit()

void G4SteppingVerboseWithUnits::DPSLUserLimit ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 388 of file G4SteppingVerboseWithUnits.cc.

{
  CopyState();
 
  if( verboseLevel > 5 )
  {
    G4cout << G4endl << G4endl;
    G4cout << "=== Defined Physical Step Length (DPSL)" << G4endl;
    G4cout << "    ++ProposedStep(UserLimit) = "
           << std::setw( 9) << G4BestUnit(physIntLength , "Length")
           << " : ProcName = User defined maximum allowed Step" << G4endl;
  }
}

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

GetInstance()

G4VSteppingVerbose * G4VSteppingVerbose::GetInstance ( )

staticinherited

Definition at line 152 of file G4VSteppingVerbose.cc.

{
  return fInstance;
}

References G4VSteppingVerbose::fInstance.

Referenced by G4SteppingManager::G4SteppingManager().

GetMasterInstance()

G4VSteppingVerbose * G4VSteppingVerbose::GetMasterInstance ( )

staticinherited

Definition at line 157 of file G4VSteppingVerbose.cc.

{
  return fMasterInstance;
}

References G4VSteppingVerbose::fMasterInstance.

Referenced by G4SteppingManager::G4SteppingManager().

GetSilent()

G4int G4VSteppingVerbose::GetSilent ( )

staticinherited

Definition at line 162 of file G4VSteppingVerbose.cc.

{
  return Silent;
}

References G4VSteppingVerbose::Silent.

Referenced by G4TrackingManager::ProcessOneTrack().

GetSilentStepInfo()

G4int G4VSteppingVerbose::GetSilentStepInfo ( )

staticinherited

Definition at line 172 of file G4VSteppingVerbose.cc.

{
  return SilentStepInfo;
}

References G4VSteppingVerbose::SilentStepInfo.

NewStep()

void G4SteppingVerbose::NewStep ( )

virtualinherited

Implements G4VSteppingVerbose.

Definition at line 66 of file G4SteppingVerbose.cc.

{
}

PostStepDoItAllDone()

void G4SteppingVerboseWithUnits::PostStepDoItAllDone ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 300 of file G4SteppingVerboseWithUnits.cc.

{
  G4VProcess* ptProcManager;
 
  CopyState();
 
  if( (fStepStatus == fPostStepDoItProc) |
      (fCondition  == Forced)            |
      (fCondition  == Conditionally)     |
      (fCondition  == ExclusivelyForced) |
      (fCondition  == StronglyForced) )
  {
    if(verboseLevel >= 3)
    {
      G4int npt=0;
      G4cout << G4endl;
      G4cout << " **PostStepDoIt (after all invocations):" << G4endl;
      G4cout << "    ++List of invoked processes " << G4endl;
 
      for(std::size_t np=0; np<MAXofPostStepLoops; ++np)
      {
        std::size_t npGPIL = MAXofPostStepLoops-np-1;
        if( (*fSelectedPostStepDoItVector)[npGPIL] == G4ForceCondition::Forced )
        {
          ++npt;
          ptProcManager = (*fPostStepDoItVector)[np];
          G4cout << "      " << npt << ") "
                 << ptProcManager->GetProcessName()
                 << " (Forced)" << G4endl;
        }
        else if ( (*fSelectedPostStepDoItVector)[npGPIL] == G4ForceCondition::NotForced )
        {
          ++npt;
          ptProcManager = (*fPostStepDoItVector)[np];
          G4cout << "      " << npt << ") " << ptProcManager->GetProcessName()
                 << G4endl;
        }
      }
 
      ShowStep();
      G4cout << G4endl;
      G4cout << "    ++List of secondaries generated "
             << "(x,y,z,kE,t,PID):"
             << "  No. of secondaries = "
             << (*fSecondary).size() << G4endl;
      G4cout << "      [Note]Secondaries from AlongStepDoIt included."
             << G4endl;
 
      if((*fSecondary).size()>0)
      {
        for(std::size_t lp1=0; lp1<(*fSecondary).size(); ++lp1)
        {
          G4cout << "      "
                 << std::setw( 9)
                 << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length")
                 << " " << std::setw( 9)
                 << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length")
                 << " " << std::setw( 9)
                 << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length")
                 << " " << std::setw( 9)
                 << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy")
                 << " " << std::setw( 9)
                 << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time")
                 << " " << std::setw(18)
                 << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
                 << G4endl;
        }
      }
    }
  }
}

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

PostStepDoItOneByOne()

void G4SteppingVerboseWithUnits::PostStepDoItOneByOne ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 517 of file G4SteppingVerboseWithUnits.cc.

{
  CopyState();
 
  if(verboseLevel >= 4)
  { 
    G4cout << G4endl;
    G4cout << " >>PostStepDoIt (process by process): "
           << "   Process Name = " 
           << fCurrentProcess->GetProcessName() << G4endl;
 
    ShowStep();
    G4cout << G4endl;
    VerboseParticleChange();    
    G4cout << G4endl;
 
    G4cout << "    ++List of secondaries generated " 
           << "(x,y,z,kE,t,PID):"
           << "  No. of secondaries = " 
           << fN2ndariesPostStepDoIt << G4endl;
 
    if(fN2ndariesPostStepDoIt>0)
    {
      for(std::size_t lp1=(*fSecondary).size()-fN2ndariesPostStepDoIt;
                      lp1<(*fSecondary).size(); ++lp1)
      {
        G4cout << "      "
               << std::setw( 9)
               << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(), "Length")
               << " " << std::setw( 9)
               << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length")
               << " " << std::setw( 9)
               << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length")
               << " " << std::setw( 9)
               << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy")
               << " " << std::setw( 9)
               << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time")
               << " " << std::setw(18)
               << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()
               << G4endl;
      }
    }
  }
}

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

SetInstance()

void G4VSteppingVerbose::SetInstance ( G4VSteppingVerbose *  Instance )

staticinherited

Definition at line 149 of file G4VSteppingVerbose.cc.

{;}

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

SetManager()

void G4SteppingVerboseWithUnits::SetManager ( G4SteppingManager * const  fMan )

overridevirtual

Reimplemented from G4VSteppingVerbose.

Definition at line 60 of file G4SteppingVerboseWithUnits.cc.

{
  fManager = fMan;
  fmessenger = new G4GenericMessenger(this,"/tracking/",
               "precision of verbose output");
  auto& cmd = fmessenger->DeclareProperty("setVerbosePrecision",fprec,
               "set precision of verbose output");
  cmd.SetStates(G4State_PreInit,G4State_Idle);
}

References G4GenericMessenger::DeclareProperty(), G4VSteppingVerbose::fManager, fmessenger, fprec, G4State_Idle, G4State_PreInit, and G4GenericMessenger::Command::SetStates().

SetSilent()

void G4VSteppingVerbose::SetSilent ( G4int  fSilent )

staticinherited

Definition at line 167 of file G4VSteppingVerbose.cc.

{
  Silent=fSilent;
}

References G4VSteppingVerbose::Silent.

Referenced by G4SteppingManager::Stepping().

SetSilentStepInfo()

void G4VSteppingVerbose::SetSilentStepInfo ( G4int  fSilent )

staticinherited

Definition at line 177 of file G4VSteppingVerbose.cc.

{
  SilentStepInfo = fSilent;
}

References G4VSteppingVerbose::SilentStepInfo.

ShowStep()

void G4SteppingVerboseWithUnits::ShowStep ( ) const

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 693 of file G4SteppingVerboseWithUnits.cc.

{
   // Show header
   G4cout << G4endl;
   G4cout << "    ++G4Step Information " << G4endl;
   G4int oldprc = G4cout.precision(fprec);
 
   // Show G4Step specific information
   G4cout << "      Address of G4Track : "
          << fStep->GetTrack() << G4endl;
   G4cout << "      Step Length        : "
          << G4BestUnit(fStep->GetTrack()->GetStepLength(), "Length") << G4endl;
   G4cout << "      Energy Deposit     : "
          << G4BestUnit(fStep->GetTotalEnergyDeposit(), "Energy") << G4endl;
 
   // Show G4StepPoint specific information
   G4cout << "      -------------------------------------------------------" 
          << "----------------" <<  G4endl;
   G4cout << "        StepPoint Information  "
          << std::setw(20) << "PreStep" << std::setw(20) << "PostStep" << G4endl;
   G4cout << "      -------------------------------------------------------" 
          << "----------------" <<  G4endl;
   G4cout << "         Position - x        : " 
          << std::setw(17) 
      << G4BestUnit(fStep->GetPreStepPoint()->GetPosition().x(), "Length") 
          << std::setw(17) 
      << G4BestUnit(fStep->GetPostStepPoint()->GetPosition().x(), "Length")
          << G4endl;
   G4cout << "         Position - y        : " 
          << std::setw(17) 
      << G4BestUnit(fStep->GetPreStepPoint()->GetPosition().y(), "Length") 
          << std::setw(17) 
      << G4BestUnit(fStep->GetPostStepPoint()->GetPosition().y(), "Length")
          << G4endl;
   G4cout << "         Position - z        : " 
          << std::setw(17) 
      << G4BestUnit(fStep->GetPreStepPoint()->GetPosition().z(), "Length") 
          << std::setw(17) 
      << G4BestUnit(fStep->GetPostStepPoint()->GetPosition().z(), "Length")
          << G4endl;      
   G4cout << "         Global Time         : " 
          << std::setw(17)
      << G4BestUnit(fStep->GetPreStepPoint()->GetGlobalTime(), "Time")
          << std::setw(17) 
      << G4BestUnit(fStep->GetPostStepPoint()->GetGlobalTime(), "Time")
          << G4endl;
   G4cout << "         Local  Time         : " 
          << std::setw(17)
      << G4BestUnit(fStep->GetPreStepPoint()->GetLocalTime(), "Time")
          << std::setw(17) 
      << G4BestUnit(fStep->GetPostStepPoint()->GetLocalTime(), "Time")
          << G4endl;
   G4cout << "         Proper Time         : " 
          << std::setw(17)
      << G4BestUnit(fStep->GetPreStepPoint()->GetProperTime(), "Time")
          << std::setw(17) 
      << G4BestUnit(fStep->GetPostStepPoint()->GetProperTime(), "Time")
          << G4endl;
   G4cout << "         Momentum Direct - x : " 
       << std::setw(20) << fStep->GetPreStepPoint()->GetMomentumDirection().x()
       << std::setw(20) << fStep->GetPostStepPoint()->GetMomentumDirection().x()
          << G4endl;
   G4cout << "         Momentum Direct - y : " 
       << std::setw(20) << fStep->GetPreStepPoint()->GetMomentumDirection().y()
       << std::setw(20) << fStep->GetPostStepPoint()->GetMomentumDirection().y()
          << G4endl;
   G4cout << "         Momentum Direct - z : " 
       << std::setw(20) << fStep->GetPreStepPoint()->GetMomentumDirection().z()
       << std::setw(20) << fStep->GetPostStepPoint()->GetMomentumDirection().z()
          << G4endl;
   G4cout << "         Momentum - x        : " 
          << std::setw(14) 
      << G4BestUnit(fStep->GetPreStepPoint()->GetMomentum().x(),"Momentum")
          << std::setw(14) 
      << G4BestUnit(fStep->GetPostStepPoint()->GetMomentum().x(),"Momentum")
          << G4endl;
   G4cout << "         Momentum - y        : " 
          << std::setw(14) 
      << G4BestUnit(fStep->GetPreStepPoint()->GetMomentum().y(),"Momentum")
          << std::setw(14) 
      << G4BestUnit(fStep->GetPostStepPoint()->GetMomentum().y(),"Momentum")
          << G4endl;
   G4cout << "         Momentum - z        : " 
          << std::setw(14) 
      << G4BestUnit(fStep->GetPreStepPoint()->GetMomentum().z(),"Momentum")
          << std::setw(14) 
      << G4BestUnit(fStep->GetPostStepPoint()->GetMomentum().z(),"Momentum")
          << G4endl;            
   G4cout << "         Total Energy        : " 
          << std::setw(16) 
      << G4BestUnit(fStep->GetPreStepPoint()->GetTotalEnergy(),"Energy")
          << std::setw(16) 
      << G4BestUnit(fStep->GetPostStepPoint()->GetTotalEnergy(),"Energy")
          << G4endl;
   G4cout << "         Kinetic Energy      : " 
          << std::setw(16) 
      << G4BestUnit(fStep->GetPreStepPoint()->GetKineticEnergy(),"Energy")
          << std::setw(16) 
      << G4BestUnit(fStep->GetPostStepPoint()->GetKineticEnergy(),"Energy")
          << G4endl;      
   G4cout << "         Velocity            : " 
          << std::setw(14) 
      << G4BestUnit(fStep->GetPreStepPoint()->GetVelocity(),"Velocity")
          << std::setw(14) 
      << G4BestUnit(fStep->GetPostStepPoint()->GetVelocity(),"Velocity")
          << G4endl;
   G4cout << "         Volume Name         : "
          << std::setw(20)
          << fStep->GetPreStepPoint()->GetPhysicalVolume()->GetName();
   G4String volName = "OutOfWorld";
   if (fStep->GetPostStepPoint()->GetPhysicalVolume())
     volName = fStep->GetPostStepPoint()->GetPhysicalVolume()->GetName();
   G4cout << std::setw(20) << volName 
          << G4endl;
   G4cout << "         Safety              : " 
          << std::setw(17) 
      << G4BestUnit(fStep->GetPreStepPoint()->GetSafety(),"Length")
          << std::setw(17) 
      << G4BestUnit(fStep->GetPostStepPoint()->GetSafety(),"Length")
          << G4endl;
   G4cout << "         Polarization - x    : " 
          << std::setw(20) << fStep->GetPreStepPoint()->GetPolarization().x()
          << std::setw(20) << fStep->GetPostStepPoint()->GetPolarization().x()
          << G4endl;
   G4cout << "         Polarization - y    : " 
          << std::setw(20) << fStep->GetPreStepPoint()->GetPolarization().y()
          << std::setw(20) << fStep->GetPostStepPoint()->GetPolarization().y()
          << G4endl;
   G4cout << "         Polarization - Z    : " 
          << std::setw(20) << fStep->GetPreStepPoint()->GetPolarization().z()
          << std::setw(20) << fStep->GetPostStepPoint()->GetPolarization().z()
          << G4endl;
   G4cout << "         Weight              : " 
          << std::setw(20) << fStep->GetPreStepPoint()->GetWeight()
          << std::setw(20) << fStep->GetPostStepPoint()->GetWeight()
          << G4endl;
   G4cout << "         Step Status         : " ;
   G4StepStatus  tStepStatus = fStep->GetPreStepPoint()->GetStepStatus();
   if( tStepStatus == fGeomBoundary )
   {
     G4cout << std::setw(20) << "Geom Limit";
   }
   else if ( tStepStatus == fAlongStepDoItProc )
   {
     G4cout << std::setw(20) << "AlongStep Proc.";
   }
   else if ( tStepStatus == fPostStepDoItProc )
   {
     G4cout << std::setw(20) << "PostStep Proc";
   }
   else if ( tStepStatus == fAtRestDoItProc )
   {
     G4cout << std::setw(20) << "AtRest Proc";
   }
   else if ( tStepStatus == fUndefined )
   {
     G4cout << std::setw(20) << "Undefined";
   }
 
   tStepStatus = fStep->GetPostStepPoint()->GetStepStatus();
   if( tStepStatus == fGeomBoundary )
   {
     G4cout << std::setw(20) << "Geom Limit";
   }
   else if ( tStepStatus == fAlongStepDoItProc )
   {
     G4cout << std::setw(20) << "AlongStep Proc.";
   }
   else if ( tStepStatus == fPostStepDoItProc )
   {
     G4cout << std::setw(20) << "PostStep Proc";
   }
   else if ( tStepStatus == fAtRestDoItProc )
   {
     G4cout << std::setw(20) << "AtRest Proc";
   }
   else if ( tStepStatus == fUndefined )
   {
     G4cout << std::setw(20) << "Undefined";
   }
 
   G4cout << G4endl;
   G4cout << "         Process defined Step: " ;
   if( fStep->GetPreStepPoint()->GetProcessDefinedStep() == 0 )
   {
     G4cout << std::setw(20) << "Undefined";
   }
   else
   {
     G4cout << std::setw(20)
            << fStep->GetPreStepPoint()
                    ->GetProcessDefinedStep()->GetProcessName();
   }
   if( fStep->GetPostStepPoint()->GetProcessDefinedStep() == 0)
   {
     G4cout << std::setw(20) << "Undefined";
   }
   else
   {
     G4cout << std::setw(20)
            << fStep->GetPostStepPoint()
                    ->GetProcessDefinedStep()->GetProcessName(); 
   }
   G4cout.precision(oldprc);
 
   G4cout << G4endl;
   G4cout << "      -------------------------------------------------------" 
          << "----------------" << G4endl;
}

References fAlongStepDoItProc, fAtRestDoItProc, fGeomBoundary, fPostStepDoItProc, fprec, G4VSteppingVerbose::fStep, fUndefined, G4BestUnit, 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(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

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

StepInfo()

void G4SteppingVerboseWithUnits::StepInfo ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 108 of file G4SteppingVerboseWithUnits.cc.

{  
 CopyState();
 G4int oldprec = G4cout.precision(fprec);
 
 if( verboseLevel >= 1 )
 {
   if( verboseLevel >= 4 ) VerboseTrack();
   if( verboseLevel >= 3 )
   {
     G4cout << G4endl;    
     G4cout << std::setw(5)       << "#Step#"     << " "
            << std::setw(fprec+3) << "X"          << "    "
            << std::setw(fprec+3) << "Y"          << "    "  
            << std::setw(fprec+3) << "Z"          << "    "
            << std::setw(fprec+6) << "KineE"      << " "
            << std::setw(fprec+10) << "dEStep"     << " "  
            << std::setw(fprec+7) << "StepLeng"     
            << std::setw(fprec+7) << "TrakLeng" 
            << std::setw(10)      << "Volume"    << "  "
            << std::setw(10)      << "Process"   << G4endl;                  
    }
 
    G4cout << std::setw(5)  << fTrack->GetCurrentStepNumber() << " "
      << std::setw(fprec+3) << G4BestUnit(fTrack->GetPosition().x(),"Length")
      << std::setw(fprec+3) << G4BestUnit(fTrack->GetPosition().y(),"Length")
      << std::setw(fprec+3) << G4BestUnit(fTrack->GetPosition().z(),"Length")
      << std::setw(fprec+3) << G4BestUnit(fTrack->GetKineticEnergy(),"Energy")
      << std::setw(fprec+7) << G4BestUnit(fStep->GetTotalEnergyDeposit(),"Energy")
      << std::setw(fprec+3) << G4BestUnit(fStep->GetStepLength(),"Length")
      << std::setw(fprec+3) << G4BestUnit(fTrack->GetTrackLength(),"Length")
      << std::setw(10)      << fTrack->GetVolume()->GetName();
 
    const G4VProcess* process 
                      = fStep->GetPostStepPoint()->GetProcessDefinedStep();
    G4String procName = " UserLimit";
    if (process != nullptr) procName = process->GetProcessName();
    if (fStepStatus == fWorldBoundary) procName = "OutOfWorld";
    G4cout << "   " << std::setw( 9) << procName;
    G4cout << G4endl;
 
    if (verboseLevel == 2)
    {
      const std::vector<const G4Track*>* secondary 
                                    = fStep->GetSecondaryInCurrentStep();
      std::size_t nbtrk = (*secondary).size();
      if (nbtrk)
      {
        G4cout << "\n    :----- List of secondaries ----------------" << G4endl;
        G4cout.precision(4);
        for (std::size_t lp=0; lp<(*secondary).size(); ++lp)
        {
          G4cout << "   "
                 << std::setw(13)                 
                 << (*secondary)[lp]->GetDefinition()->GetParticleName()
                 << ":  energy ="
                 << std::setw(6)
                 << G4BestUnit((*secondary)[lp]->GetKineticEnergy(),"Energy")
                 << "  time ="
                 << std::setw(6)
                 << G4BestUnit((*secondary)[lp]->GetGlobalTime(),"Time");
          G4cout << G4endl;
        }
              
        G4cout << "    :------------------------------------------\n" << G4endl;
      }
    }
  }
  G4cout.precision(oldprec);
}

References G4VSteppingVerbose::CopyState(), fprec, G4VSteppingVerbose::fStep, G4VSteppingVerbose::fStepStatus, G4VSteppingVerbose::fTrack, fWorldBoundary, G4BestUnit, G4cout, G4endl, G4Track::GetCurrentStepNumber(), G4Track::GetKineticEnergy(), G4VPhysicalVolume::GetName(), G4Track::GetPosition(), G4Step::GetPostStepPoint(), G4StepPoint::GetProcessDefinedStep(), G4VProcess::GetProcessName(), G4Step::GetSecondaryInCurrentStep(), G4Step::GetStepLength(), G4Step::GetTotalEnergyDeposit(), G4Track::GetTrackLength(), G4Track::GetVolume(), G4VSteppingVerbose::verboseLevel, VerboseTrack(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

TrackingStarted()

void G4SteppingVerboseWithUnits::TrackingStarted ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 72 of file G4SteppingVerboseWithUnits.cc.

{  
 CopyState();
 G4int oldprec = G4cout.precision(fprec);
  
 // Step zero
 //  
 if( verboseLevel > 0 )
 {
   G4cout << std::setw(  5)     << "Step#"      << " "
          << std::setw(fprec+3) << "X"          << "    "
          << std::setw(fprec+3) << "Y"          << "    "  
          << std::setw(fprec+3) << "Z"          << "    "
          << std::setw(fprec+6) << "KineE"      << " "
          << std::setw(fprec+10) << "dEStep"     << " "  
          << std::setw(fprec+7) << "StepLeng"  
          << std::setw(fprec+7) << "TrakLeng"
          << std::setw( 10)     << "Volume"     << "  "
          << std::setw( 10)     << "Process"    << G4endl;             
 
   G4cout << std::setw(5)  << fTrack->GetCurrentStepNumber() << " "
     << std::setw(fprec+3) << G4BestUnit(fTrack->GetPosition().x(),"Length")
     << std::setw(fprec+3) << G4BestUnit(fTrack->GetPosition().y(),"Length")
     << std::setw(fprec+3) << G4BestUnit(fTrack->GetPosition().z(),"Length")
     << std::setw(fprec+3) << G4BestUnit(fTrack->GetKineticEnergy(),"Energy")
     << std::setw(fprec+7) << G4BestUnit(fStep->GetTotalEnergyDeposit(),"Energy")
     << std::setw(fprec+3) << G4BestUnit(fStep->GetStepLength(),"Length")
     << std::setw(fprec+3) << G4BestUnit(fTrack->GetTrackLength(),"Length")
     << std::setw(10)      << fTrack->GetVolume()->GetName()
     << std::setw( 9)      << "   initStep" << G4endl;        
  }
  G4cout.precision(oldprec);
}

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

UseBestUnit()

void G4SteppingVerbose::UseBestUnit ( G4int  prec = 4 )

staticinherited

Definition at line 1040 of file G4SteppingVerbose.cc.

{ useBestUnitPrecision = prec; }

References CLHEP::prec, and G4SteppingVerbose::useBestUnitPrecision.

VerboseParticleChange()

void G4SteppingVerboseWithUnits::VerboseParticleChange ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 684 of file G4SteppingVerboseWithUnits.cc.

{
  G4cout << G4endl;
  G4cout << "    ++G4ParticleChange Information " << G4endl;
  fParticleChange->DumpInfo();
}

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

Referenced by AlongStepDoItOneByOne(), and PostStepDoItOneByOne().

VerboseTrack()

void G4SteppingVerboseWithUnits::VerboseTrack ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 564 of file G4SteppingVerboseWithUnits.cc.

{
  CopyState();
 
  G4cout << G4endl;
  G4cout << "    ++G4Track Information " << G4endl;
  G4int oldprec = G4cout.precision(fprec);
 
 
  G4cout << "      -----------------------------------------------" << G4endl;
  G4cout << "        G4Track Information  " << std::setw(20)        << G4endl;
  G4cout << "      -----------------------------------------------" << G4endl;
 
  G4cout << "        Step number         : " 
         << std::setw(20) << fTrack->GetCurrentStepNumber() << G4endl; 
  G4cout << "        Position - x        : " 
         << std::setw(20) << G4BestUnit(fTrack->GetPosition().x(), "Length")
         << G4endl; 
  G4cout << "        Position - y        : " 
         << std::setw(20) << G4BestUnit(fTrack->GetPosition().y(), "Length")
         << G4endl; 
  G4cout << "        Position - z        : " 
         << std::setw(20) << G4BestUnit(fTrack->GetPosition().z(), "Length")
         << G4endl;
  G4cout << "        Global Time         : " 
         << std::setw(20) << G4BestUnit(fTrack->GetGlobalTime(), "Time")
         << G4endl;
  G4cout << "        Local Time          : " 
         << std::setw(20) << G4BestUnit(fTrack->GetLocalTime(), "Time")
         << G4endl;
  G4cout << "        Momentum Direct - x : " 
         << std::setw(20) << fTrack->GetMomentumDirection().x()
         << G4endl;
  G4cout << "        Momentum Direct - y : " 
         << std::setw(20) << fTrack->GetMomentumDirection().y()
         << G4endl;
  G4cout << "        Momentum Direct - z : " 
         << std::setw(20) << fTrack->GetMomentumDirection().z()
         << G4endl;
  G4cout << "        Kinetic Energy      : " 
         << std::setw(20) << G4BestUnit(fTrack->GetKineticEnergy(), "Energy")
         << G4endl;
  G4cout << "        Polarization - x    : " 
         << std::setw(20) << fTrack->GetPolarization().x()
         << G4endl;
  G4cout << "        Polarization - y    : " 
         << std::setw(20) << fTrack->GetPolarization().y()
         << G4endl;
  G4cout << "        Polarization - z    : " 
         << std::setw(20) << fTrack->GetPolarization().z()
         << G4endl;
  G4cout << "        Track Length        : " 
         << std::setw(20) << G4BestUnit(fTrack->GetTrackLength(), "Length")
         << G4endl;
  G4cout << "        Track ID #          : " 
         << std::setw(20) << fTrack->GetTrackID()
         << G4endl;
  G4cout << "        Parent Track ID #   : " 
         << std::setw(20) << fTrack->GetParentID()
         << G4endl;
  G4cout << "        Next Volume         : " 
         << std::setw(20);
  if (fTrack->GetNextVolume() != 0)  
         G4cout << fTrack->GetNextVolume()->GetName() << " ";
    else G4cout << "OutOfWorld" << " ";
  G4cout << G4endl;
  G4cout << "        Track Status        : " 
         << std::setw(20);
  if( fTrack->GetTrackStatus() == fAlive )
    G4cout << " Alive";
  else if( fTrack->GetTrackStatus() == fStopButAlive )
    G4cout << " StopButAlive";
  else if( fTrack->GetTrackStatus() == fStopAndKill )
    G4cout << " StopAndKill";
  else if( fTrack->GetTrackStatus() == fKillTrackAndSecondaries )
    G4cout << " KillTrackAndSecondaries";
  else if( fTrack->GetTrackStatus() == fSuspend )
    G4cout << " Suspend";
  else if( fTrack->GetTrackStatus() == fPostponeToNextEvent )
    G4cout << " PostponeToNextEvent";
  G4cout << G4endl;
  G4cout << "        Vertex - x          : " 
         << std::setw(20)
         << G4BestUnit(fTrack->GetVertexPosition().x(),"Length")
         << G4endl; 
  G4cout << "        Vertex - y          : " 
         << std::setw(20)
         << G4BestUnit(fTrack->GetVertexPosition().y(),"Length")
         << G4endl; 
  G4cout << "        Vertex - z          : " 
         << std::setw(20)
         << G4BestUnit(fTrack->GetVertexPosition().z(),"Length")
         << G4endl;
  G4cout << "        Vertex - Px (MomDir): " 
         << std::setw(20) << fTrack->GetVertexMomentumDirection().x()
         << G4endl;
  G4cout << "        Vertex - Py (MomDir): " 
         << std::setw(20) << fTrack->GetVertexMomentumDirection().y()
         << G4endl;
  G4cout << "        Vertex - Pz (MomDir): " 
         << std::setw(20) << fTrack->GetVertexMomentumDirection().z()
         << G4endl;
  G4cout << "        Vertex - KineE      : " 
         << std::setw(20)
         << G4BestUnit(fTrack->GetVertexKineticEnergy(),"Energy")
         << G4endl;
  
  G4cout << "        Creator Process     : " 
         << std::setw(20);
  if (fTrack->GetCreatorProcess() == 0)
    G4cout << " Event Generator" << G4endl;
  else
    G4cout << fTrack->GetCreatorProcess()->GetProcessName() << G4endl;
 
  G4cout << "      -----------------------------------------------"  << G4endl;
  G4cout.precision(oldprec);      
}

References G4VSteppingVerbose::CopyState(), fAlive, fKillTrackAndSecondaries, fPostponeToNextEvent, fprec, 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(), 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(), G4SteppingVerbose::DPSLPostStep(), DPSLPostStep(), G4SteppingVerbose::PostStepDoItAllDone(), and PostStepDoItAllDone().

fCurrentProcess

G4VProcess* G4VSteppingVerbose::fCurrentProcess = nullptr

protectedinherited

Definition at line 139 of file G4VSteppingVerbose.hh.

Referenced by G4SteppingVerbose::AlongStepDoItOneByOne(), AlongStepDoItOneByOne(), G4VSteppingVerbose::CopyState(), G4SteppingVerbose::DPSLAlongStep(), DPSLAlongStep(), G4SteppingVerbose::DPSLPostStep(), DPSLPostStep(), G4SteppingVerbose::PostStepDoItOneByOne(), and 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(), G4SteppingVerbose::DPSLAlongStep(), and 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 SetManager().

fMasterInstance

G4VSteppingVerbose * G4VSteppingVerbose::fMasterInstance = nullptr

staticprotectedinherited

Definition at line 107 of file G4VSteppingVerbose.hh.

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

fmessenger

G4GenericMessenger* G4SteppingVerboseWithUnits::fmessenger = nullptr

private

Definition at line 79 of file G4SteppingVerboseWithUnits.hh.

Referenced by SetManager(), and ~G4SteppingVerboseWithUnits().

fN2ndariesAlongStepDoIt

G4int G4VSteppingVerbose::fN2ndariesAlongStepDoIt = 0

protectedinherited

Definition at line 163 of file G4VSteppingVerbose.hh.

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

fN2ndariesAtRestDoIt

G4int G4VSteppingVerbose::fN2ndariesAtRestDoIt = 0

protectedinherited

Definition at line 162 of file G4VSteppingVerbose.hh.

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

fN2ndariesPostStepDoIt

G4int G4VSteppingVerbose::fN2ndariesPostStepDoIt = 0

protectedinherited

Definition at line 164 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState(), G4SteppingVerbose::PostStepDoItOneByOne(), PostStepDoItOneByOne(), and G4SteppingVerbose::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(), G4SteppingVerbose::VerboseParticleChange(), and 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().

fprec

G4int G4SteppingVerboseWithUnits::fprec

private

Definition at line 78 of file G4SteppingVerboseWithUnits.hh.

Referenced by SetManager(), ShowStep(), StepInfo(), TrackingStarted(), and VerboseTrack().

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 G4SteppingVerbose::AlongStepDoItAllDone(), AlongStepDoItAllDone(), G4SteppingVerbose::AlongStepDoItOneByOne(), AlongStepDoItOneByOne(), G4SteppingVerbose::AtRestDoItInvoked(), AtRestDoItInvoked(), G4VSteppingVerbose::CopyState(), G4SteppingVerbose::PostStepDoItAllDone(), PostStepDoItAllDone(), G4SteppingVerbose::PostStepDoItOneByOne(), PostStepDoItOneByOne(), and G4SteppingVerbose::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 G4SteppingVerbose::AtRestDoItInvoked(), AtRestDoItInvoked(), and G4VSteppingVerbose::CopyState().

fSelectedPostStepDoItVector

G4SelectedPostStepDoItVector* G4VSteppingVerbose::fSelectedPostStepDoItVector = nullptr

protectedinherited

Definition at line 178 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState(), G4SteppingVerbose::PostStepDoItAllDone(), and 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(), G4SteppingVerbose::ShowStep(), ShowStep(), G4SteppingVerbose::StepInfo(), StepInfo(), G4SteppingVerbose::TrackingStarted(), and TrackingStarted().

fStepStatus

G4StepStatus G4VSteppingVerbose::fStepStatus = fUndefined

protectedinherited

Definition at line 122 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState(), G4SteppingVerbose::PostStepDoItAllDone(), PostStepDoItAllDone(), and 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(), G4SteppingVerbose::StepInfo(), StepInfo(), G4SteppingVerbose::TrackingStarted(), TrackingStarted(), G4SteppingVerbose::VerboseTrack(), and 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 G4SteppingVerbose::AlongStepDoItAllDone(), AlongStepDoItAllDone(), and G4VSteppingVerbose::CopyState().

MAXofAtRestLoops

std::size_t G4VSteppingVerbose::MAXofAtRestLoops = 0

protectedinherited

Definition at line 151 of file G4VSteppingVerbose.hh.

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

MAXofPostStepLoops

std::size_t G4VSteppingVerbose::MAXofPostStepLoops = 0

protectedinherited

Definition at line 153 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::CopyState(), G4SteppingVerbose::PostStepDoItAllDone(), and 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(), G4SteppingVerbose::DPSLAlongStep(), DPSLAlongStep(), G4SteppingVerbose::DPSLPostStep(), DPSLPostStep(), G4SteppingVerbose::DPSLUserLimit(), and 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 G4SteppingVerbose::AlongStepDoItAllDone(), G4SteppingVerbose::AlongStepDoItOneByOne(), G4SteppingVerbose::AtRestDoItInvoked(), G4SteppingVerbose::DPSLAlongStep(), G4SteppingVerbose::DPSLPostStep(), G4SteppingVerbose::DPSLStarted(), G4SteppingVerbose::DPSLUserLimit(), G4VSteppingVerbose::GetSilent(), G4SteppingVerbose::PostStepDoItAllDone(), G4SteppingVerbose::PostStepDoItOneByOne(), G4VSteppingVerbose::SetSilent(), G4SteppingVerbose::ShowStep(), G4SteppingVerbose::StepInfo(), G4SteppingVerbose::TrackingStarted(), G4SteppingVerbose::VerboseParticleChange(), and G4SteppingVerbose::VerboseTrack().

SilentStepInfo

G4ThreadLocal G4int G4VSteppingVerbose::SilentStepInfo = 0

staticprotectedinherited

Definition at line 111 of file G4VSteppingVerbose.hh.

Referenced by G4VSteppingVerbose::GetSilentStepInfo(), G4VSteppingVerbose::SetSilentStepInfo(), and G4SteppingVerbose::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

staticprivateinherited

Definition at line 73 of file G4SteppingVerbose.hh.

Referenced by G4SteppingVerbose::BestUnitPrecision(), and G4SteppingVerbose::UseBestUnit().

verboseLevel

G4int G4VSteppingVerbose::verboseLevel = 0

protectedinherited

Definition at line 170 of file G4VSteppingVerbose.hh.

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

---

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

• source/tracking/include/G4SteppingVerboseWithUnits.hh
• source/tracking/src/G4SteppingVerboseWithUnits.cc