G4SteppingVerboseWithUnits Class Reference

#include <G4SteppingVerboseWithUnits.hh>

Inheritance diagram for G4SteppingVerboseWithUnits:

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

Additional Inherited Members
Static Public Member Functions inherited from G4SteppingVerbose
static void	UseBestUnit (G4int prec=4)
static G4int	BestUnitPrecision ()
Static Public Member Functions inherited from G4VSteppingVerbose
static void	SetInstance (G4VSteppingVerbose *Instance)
static G4VSteppingVerbose *	GetInstance ()
static G4VSteppingVerbose *	GetMasterInstance ()
static G4int	GetSilent ()
static void	SetSilent (G4int fSilent)
static G4int	GetSilentStepInfo ()
static void	SetSilentStepInfo (G4int fSilent)
Protected Types inherited from G4VSteppingVerbose
using	G4SelectedAtRestDoItVector = std::vector<G4int>
using	G4SelectedAlongStepDoItVector = std::vector<G4int>
using	G4SelectedPostStepDoItVector = std::vector<G4int>
Protected Member Functions inherited from G4VSteppingVerbose
	G4VSteppingVerbose ()
Protected Attributes inherited from G4VSteppingVerbose
G4SteppingManager *	fManager = nullptr
G4UserSteppingAction *	fUserSteppingAction = nullptr
G4double	PhysicalStep = 0.0
G4double	GeometricalStep = 0.0
G4double	CorrectedStep = 0.0
G4bool	PreStepPointIsGeom = false
G4bool	FirstStep = false
G4StepStatus	fStepStatus = fUndefined
G4double	TempInitVelocity = 0.0
G4double	TempVelocity = 0.0
G4double	Mass = 0.0
G4double	sumEnergyChange = 0.0
G4VParticleChange *	fParticleChange = nullptr
G4Track *	fTrack = nullptr
G4TrackVector *	fSecondary = nullptr
G4Step *	fStep = nullptr
G4StepPoint *	fPreStepPoint = nullptr
G4StepPoint *	fPostStepPoint = nullptr
G4VPhysicalVolume *	fCurrentVolume = nullptr
G4VSensitiveDetector *	fSensitive = nullptr
G4VProcess *	fCurrentProcess = nullptr
G4ProcessVector *	fAtRestDoItVector = nullptr
G4ProcessVector *	fAlongStepDoItVector = nullptr
G4ProcessVector *	fPostStepDoItVector = nullptr
G4ProcessVector *	fAtRestGetPhysIntVector = nullptr
G4ProcessVector *	fAlongStepGetPhysIntVector = nullptr
G4ProcessVector *	fPostStepGetPhysIntVector = nullptr
std::size_t	MAXofAtRestLoops = 0
std::size_t	MAXofAlongStepLoops = 0
std::size_t	MAXofPostStepLoops = 0
G4double	currentMinimumStep = 0.0
G4double	numberOfInteractionLengthLeft = 0.0
std::size_t	fAtRestDoItProcTriggered = 0
std::size_t	fAlongStepDoItProcTriggered = 0
std::size_t	fPostStepDoItProcTriggered = 0
G4int	fN2ndariesAtRestDoIt = 0
G4int	fN2ndariesAlongStepDoIt = 0
G4int	fN2ndariesPostStepDoIt = 0
G4Navigator *	fNavigator = nullptr
G4int	verboseLevel = 0
G4SelectedAtRestDoItVector *	fSelectedAtRestDoItVector = nullptr
G4SelectedAlongStepDoItVector *	fSelectedAlongStepDoItVector = nullptr
G4SelectedPostStepDoItVector *	fSelectedPostStepDoItVector = nullptr
G4double	fPreviousStepSize = 0.0
G4TouchableHandle	fTouchableHandle
G4SteppingControl	StepControlFlag = NormalCondition
G4double	physIntLength = 0.0
G4ForceCondition	fCondition = InActivated
G4GPILSelection	fGPILSelection = NotCandidateForSelection
Static Protected Attributes inherited from G4VSteppingVerbose
static G4ThreadLocal G4VSteppingVerbose *	fInstance = nullptr
static G4VSteppingVerbose *	fMasterInstance = nullptr
static G4TRACKING_DLL G4ThreadLocal G4int	Silent = 0
static G4TRACKING_DLL G4ThreadLocal G4int	SilentStepInfo = 0

Detailed Description

Definition at line 48 of file G4SteppingVerboseWithUnits.hh.

Constructor & Destructor Documentation

G4SteppingVerboseWithUnits()

G4SteppingVerboseWithUnits::G4SteppingVerboseWithUnits

(

G4int

precision = 4

)

Definition at line 46 of file G4SteppingVerboseWithUnits.cc.

: fprec(prec) {}

Referenced by Clone().

~G4SteppingVerboseWithUnits()

G4SteppingVerboseWithUnits::~G4SteppingVerboseWithUnits ( )

override

Definition at line 50 of file G4SteppingVerboseWithUnits.cc.

{ delete fmessenger; }

Member Function Documentation

AlongStepDoItAllDone()

void G4SteppingVerboseWithUnits::AlongStepDoItAllDone ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 206 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)((G4int)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).empty()) {
      for (auto& lp1 : *fSecondary) {
        G4cout << "      " << std::setw(9) << G4BestUnit(lp1->GetPosition().x(), "Length") << " "
               << std::setw(9) << G4BestUnit(lp1->GetPosition().y(), "Length") << " "
               << std::setw(9) << G4BestUnit(lp1->GetPosition().z(), "Length") << " "
               << std::setw(9) << G4BestUnit(lp1->GetKineticEnergy(), "Energy") << " "
               << std::setw(9) << G4BestUnit(lp1->GetGlobalTime(), "Time") << " " << std::setw(18)
               << lp1->GetDefinition()->GetParticleName() << G4endl;
      }
    }
  }
}

AlongStepDoItOneByOne()

void G4SteppingVerboseWithUnits::AlongStepDoItOneByOne ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 377 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;
      }
    }
  }
}

AtRestDoItInvoked()

void G4SteppingVerboseWithUnits::AtRestDoItInvoked ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 156 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)[(G4int)np];
        G4cout << "   # " << npt << " : " << ptProcManager->GetProcessName() << " (Forced)"
               << G4endl;
      }
      else if ((*fSelectedAtRestDoItVector)[npGPIL] == G4ForceCondition::NotForced) {
        ++npt;
        ptProcManager = (*fAtRestDoItVector)[(G4int)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;
  }
}

Clone()

G4VSteppingVerbose * G4SteppingVerboseWithUnits::Clone ( )

inlineoverridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 54 of file G4SteppingVerboseWithUnits.hh.

{ return new G4SteppingVerboseWithUnits; }

DPSLAlongStep()

void G4SteppingVerboseWithUnits::DPSLAlongStep ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 355 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;
    }
  }
}

DPSLPostStep()

void G4SteppingVerboseWithUnits::DPSLPostStep ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 327 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;
    }
  }
}

DPSLStarted()

void G4SteppingVerboseWithUnits::DPSLStarted ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 301 of file G4SteppingVerboseWithUnits.cc.

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

DPSLUserLimit()

void G4SteppingVerboseWithUnits::DPSLUserLimit ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 312 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;
  }
}

PostStepDoItAllDone()

void G4SteppingVerboseWithUnits::PostStepDoItAllDone ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 246 of file G4SteppingVerboseWithUnits.cc.

{
  G4VProcess* ptProcManager;
 
  CopyState();
 
  if ((static_cast<int>(fStepStatus == fPostStepDoItProc) | static_cast<int>(fCondition == Forced) |
        static_cast<int>(fCondition == Conditionally) |
        static_cast<int>(fCondition == ExclusivelyForced) |
        static_cast<int>(fCondition == StronglyForced)) != 0)
  {
    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)[(G4int)np];
          G4cout << "      " << npt << ") " << ptProcManager->GetProcessName() << " (Forced)"
                 << G4endl;
        }
        else if ((*fSelectedPostStepDoItVector)[npGPIL] == G4ForceCondition::NotForced) {
          ++npt;
          ptProcManager = (*fPostStepDoItVector)[(G4int)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).empty()) {
        for (auto& lp1 : *fSecondary) {
          G4cout << "      " << std::setw(9) << G4BestUnit(lp1->GetPosition().x(), "Length") << " "
                 << std::setw(9) << G4BestUnit(lp1->GetPosition().y(), "Length") << " "
                 << std::setw(9) << G4BestUnit(lp1->GetPosition().z(), "Length") << " "
                 << std::setw(9) << G4BestUnit(lp1->GetKineticEnergy(), "Energy") << " "
                 << std::setw(9) << G4BestUnit(lp1->GetGlobalTime(), "Time") << " " << std::setw(18)
                 << lp1->GetDefinition()->GetParticleName() << G4endl;
        }
      }
    }
  }
}

PostStepDoItOneByOne()

void G4SteppingVerboseWithUnits::PostStepDoItOneByOne ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 416 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;
      }
    }
  }
}

SetManager()

void G4SteppingVerboseWithUnits::SetManager ( G4SteppingManager * const fMan )

overridevirtual

Reimplemented from G4VSteppingVerbose.

Definition at line 54 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);
}

ShowStep()

void G4SteppingVerboseWithUnits::ShowStep ( ) const

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 551 of file G4SteppingVerboseWithUnits.cc.

{
  // Show header
  G4cout << G4endl;
  G4cout << "    ++G4Step Information " << G4endl;
  G4long 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() != nullptr)
    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() == nullptr) {
    G4cout << std::setw(20) << "Undefined";
  }
  else {
    G4cout << std::setw(20) << fStep->GetPreStepPoint()->GetProcessDefinedStep()->GetProcessName();
  }
  if (fStep->GetPostStepPoint()->GetProcessDefinedStep() == nullptr) {
    G4cout << std::setw(20) << "Undefined";
  }
  else {
    G4cout << std::setw(20) << fStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName();
  }
  G4cout.precision(oldprc);
 
  G4cout << G4endl;
  G4cout << "      -------------------------------------------------------"
         << "----------------" << G4endl;
}

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

StepInfo()

void G4SteppingVerboseWithUnits::StepInfo ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 98 of file G4SteppingVerboseWithUnits.cc.

{
  CopyState();
  G4long 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();
      if (! secondary->empty()) {
        G4cout << "\n    :----- List of secondaries ----------------" << G4endl;
        G4cout.precision(4);
        for (auto lp : *secondary) {
          G4cout << "   " << std::setw(13) << lp->GetDefinition()->GetParticleName()
                 << ":  energy =" << std::setw(6) << G4BestUnit(lp->GetKineticEnergy(), "Energy")
                 << "  time =" << std::setw(6) << G4BestUnit(lp->GetGlobalTime(), "Time");
          G4cout << G4endl;
        }
 
        G4cout << "    :------------------------------------------\n" << G4endl;
      }
    }
  }
  G4cout.precision(oldprec);
}

TrackingStarted()

void G4SteppingVerboseWithUnits::TrackingStarted ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 65 of file G4SteppingVerboseWithUnits.cc.

{
  CopyState();
  G4long 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);
}

VerboseParticleChange()

void G4SteppingVerboseWithUnits::VerboseParticleChange ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 542 of file G4SteppingVerboseWithUnits.cc.

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

Referenced by AlongStepDoItOneByOne(), and PostStepDoItOneByOne().

VerboseTrack()

void G4SteppingVerboseWithUnits::VerboseTrack ( )

overridevirtual

Reimplemented from G4SteppingVerbose.

Definition at line 452 of file G4SteppingVerboseWithUnits.cc.

{
  CopyState();
 
  G4cout << G4endl;
  G4cout << "    ++G4Track Information " << G4endl;
  G4long 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() != nullptr)
    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() == nullptr)
    G4cout << " Event Generator" << G4endl;
  else
    G4cout << fTrack->GetCreatorProcess()->GetProcessName() << G4endl;
 
  G4cout << "      -----------------------------------------------" << G4endl;
  G4cout.precision(oldprec);
}

Referenced by StepInfo().

---

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

• G4SteppingVerboseWithUnits.hh
• G4SteppingVerboseWithUnits.cc