G4ITSteppingVerbose Class Reference

#include <G4ITSteppingVerbose.hh>

Inheritance diagram for G4ITSteppingVerbose:

Public Member Functions
	G4ITSteppingVerbose ()
	~G4ITSteppingVerbose () override
void	NewStep () override
void	StepInfoForLeadingTrack () override
void	AtRestDoItInvoked () override
void	AtRestDoItOneByOne () override
void	AlongStepDoItAllDone () override
void	AlongStepDoItOneByOne () override
void	PostStepDoItAllDone () override
void	PostStepDoItOneByOne () override
void	StepInfo () override
void	TrackingStarted (G4Track *) override
void	TrackingEnded (G4Track *) override
void	DoItStarted () override
void	PreStepVerbose (G4Track *track) override
void	PostStepVerbose (G4Track *track) override
void	DPSLStarted () override
void	DPSLUserLimit () override
void	DPSLPostStep () override
void	DPSLAlongStep () override
void	VerboseTrack () override
void	VerboseParticleChange () override
void	ShowStep () const
Public Member Functions inherited from G4VITSteppingVerbose
	G4VITSteppingVerbose ()
	~G4VITSteppingVerbose () override
void	CopyState ()
void	SetVerbose (int flag)
G4int	GetVerbose ()
void	SetNewValue (G4UIcommand *command, G4String newValue) override
G4String	GetCurrentValue (G4UIcommand *command) override
void	SetStepProcessor (const G4ITStepProcessor *stepProcessor)
void	TrackBanner (G4Track *track, const G4String &message)

Additional Inherited Members
Protected Types inherited from G4VITSteppingVerbose
using	G4SelectedAtRestDoItVector = std::vector<G4int>
using	G4SelectedAlongStepDoItVector = std::vector<G4int>
using	G4SelectedPostStepDoItVector = std::vector<G4int>
Protected Attributes inherited from G4VITSteppingVerbose
const G4ITStepProcessor *	fpStepProcessor
G4UIcmdWithAnInteger *	fpVerboseUI
G4ITStepProcessorState *	fpState
const ProcessGeneralInfo *	fpProcessGeneralInfo
G4double	PhysicalStep
G4StepStatus	fStepStatus
const G4VParticleChange *	fParticleChange
const G4Track *	fTrack
const G4TrackVector *	fSecondary
const G4Step *	fStep
G4StepPoint *	fPreStepPoint
G4StepPoint *	fPostStepPoint
const G4VPhysicalVolume *	fCurrentVolume
const G4VITProcess *	fCurrentProcess
G4ProcessVector *	fAtRestDoItVector
G4ProcessVector *	fAlongStepDoItVector
G4ProcessVector *	fPostStepDoItVector
G4ProcessVector *	fAtRestGetPhysIntVector
G4ProcessVector *	fAlongStepGetPhysIntVector
G4ProcessVector *	fPostStepGetPhysIntVector
size_t	MAXofAtRestLoops
size_t	MAXofAlongStepLoops
size_t	MAXofPostStepLoops
size_t	fAtRestDoItProcTriggered
size_t	fPostStepDoItProcTriggered
G4int	fN2ndariesAtRestDoIt
G4int	fN2ndariesAlongStepDoIt
G4int	fN2ndariesPostStepDoIt
G4int	fVerboseLevel
G4SelectedAtRestDoItVector *	fSelectedAtRestDoItVector
G4SelectedPostStepDoItVector *	fSelectedPostStepDoItVector
G4double	fPreviousStepSize
G4TouchableHandle	fTouchableHandle
G4double	physIntLength
G4ForceCondition	fCondition
G4GPILSelection	fGPILSelection

Detailed Description

Definition at line 44 of file G4ITSteppingVerbose.hh.

Constructor & Destructor Documentation

G4ITSteppingVerbose()

G4ITSteppingVerbose::G4ITSteppingVerbose ( )

default

~G4ITSteppingVerbose()

G4ITSteppingVerbose::~G4ITSteppingVerbose ( )

overridedefault

Member Function Documentation

AlongStepDoItAllDone()

void G4ITSteppingVerbose::AlongStepDoItAllDone ( )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 135 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel == 0)
  {
    return;
  }
 
  G4VProcess* ptProcManager;
 
  CopyState();
 
  if(fVerboseLevel >= 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 secodaries = "
    << (*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 G4ITSteppingVerbose::AlongStepDoItOneByOne ( )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 667 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel < 4)
  {
    return;
  }
 
  CopyState();
 
  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 secodaries = " << 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 G4ITSteppingVerbose::AtRestDoItInvoked ( )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 68 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel == 0)
  {
    return;
  }
 
  G4VProcess* ptProcManager;
  CopyState();
 
  if(fVerboseLevel >= 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] == 2)
      {
        ++npt;
        ptProcManager = (*fAtRestDoItVector)[(G4int)np];
        G4cout << "   # " << npt << " : " << ptProcManager->GetProcessName()
               << " (Forced)" << G4endl;
      }
      else if ( (*fSelectedAtRestDoItVector)[npGPIL] == 1 )
      {
        ++npt;
        ptProcManager = (*fAtRestDoItVector)[(G4int)np];
        G4cout << "   # " << npt << " : " << ptProcManager->GetProcessName()
        << G4endl;
      }
    }
 
    G4cout << "   Generated secondries # : " << 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(fVerboseLevel >= 4)
  {
    ShowStep();
    G4cout << G4endl;
  }
}

AtRestDoItOneByOne()

void G4ITSteppingVerbose::AtRestDoItOneByOne ( )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 1229 of file G4ITSteppingVerbose.cc.

{
  CopyState();
 
  G4cout << " Invoke at rest process : "
          << fCurrentProcess->GetProcessName()
          << G4endl;
}

DoItStarted()

void G4ITSteppingVerbose::DoItStarted ( )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 1095 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel <= 0) return;
 
  G4IosFlagsSaver ios_saver(G4cout);
#ifdef USE_COLOR
  G4cout << LIGHT_RED;
#endif
  G4cout << "*** G4ITStepProcessor::DoIt ***" << G4endl;
  G4cout << std::setw(18) << left << "#Name" << std::setw(15) << "trackID"
         << std::setw(35) << "Position" << std::setw(25) << "Pre step volume"
         << std::setw(25) << "Post step volume" << std::setw(22) << "Process"
         << G4endl;
#ifdef USE_COLOR
  G4cout << RESET_COLOR;
#endif
}

DPSLAlongStep()

void G4ITSteppingVerbose::DPSLAlongStep ( )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 549 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel == 0)
  {
    return;
  }
 
  if(fVerboseLevel > 5)
  {
    CopyState();
 
    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 G4ITSteppingVerbose::DPSLPostStep ( )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 511 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel == 0)
  {
    return;
  }
 
  if(fVerboseLevel > 5)
  {
    CopyState();
 
    G4cout << "    ++ProposedStep(PostStep ) = " << std::setw(9)
           << physIntLength << " : 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 G4ITSteppingVerbose::DPSLStarted ( )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 478 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel == 0)
  {
    return;
  }
  CopyState();
 
  if(fVerboseLevel > 5)
  {
    G4cout << G4endl<< " >>DefinePhysicalStepLength (List of proposed StepLengths): " << G4endl;
  }
}

DPSLUserLimit()

void G4ITSteppingVerbose::DPSLUserLimit ( )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 493 of file G4ITSteppingVerbose.cc.

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

NewStep()

void G4ITSteppingVerbose::NewStep ( )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 62 of file G4ITSteppingVerbose.cc.

{
}

PostStepDoItAllDone()

void G4ITSteppingVerbose::PostStepDoItAllDone ( )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 192 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel == 0)
  {
    return;
  }
 
  G4VProcess* ptProcManager;
 
  CopyState();
 
  if(fVerboseLevel >= 3)
  {
 
    if((fStepStatus == fPostStepDoItProc) || (fCondition == Forced)
       || (fCondition == Conditionally) || (fCondition == ExclusivelyForced)
       || (fCondition == StronglyForced))
    {
 
      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] == 2)
        {
          npt++;
          ptProcManager = (*fPostStepDoItVector)[(G4int)np];
          G4cout << "      " << npt << ") " << ptProcManager->GetProcessName()
                 << " (Forced)" << G4endl;
        }
        else if ( (*fSelectedPostStepDoItVector)[npGPIL] == 1)
        {
          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 secodaries = " << (*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 G4ITSteppingVerbose::PostStepDoItOneByOne ( )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 712 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel < 4)
  {
    return;
  }
 
  CopyState();
  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 secodaries = " << 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;
    }
  }
}

PostStepVerbose()

void G4ITSteppingVerbose::PostStepVerbose ( G4Track * track )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 1162 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel <= 0) return;
 
  G4IosFlagsSaver ios_saver(G4cout);
 
  /////
  // POST STEP VERBOSE
 
  G4cout << setw(18) << left << GetIT(track)->GetName() << setw(15)
         << track->GetTrackID() << std::setprecision(3) << setw(35)
         << G4String(G4BestUnit(track->GetPosition(), "Length")) << setw(25)
         << "---";
 
  G4TouchableHandle nextTouchable = track->GetNextTouchableHandle();
  G4VPhysicalVolume* volume(nullptr);
 
  if(nextTouchable && ((volume = nextTouchable->GetVolume()) != nullptr))
  {
    G4String volumeName = volume->GetName();
 
    if(volume->IsParameterised() || volume->IsReplicated())
    {
      volumeName += " ";
      volumeName += (char)nextTouchable->GetReplicaNumber();
    }
 
    G4cout << setw(25) << volumeName;
  }
  else
  {
    G4cout << setw(25) << "OutOfWorld";
  }
  if(track->GetStep()->GetPostStepPoint()->GetProcessDefinedStep() != nullptr)
  {
    G4cout
        << setw(22)
        << track->GetStep()->GetPostStepPoint()->GetProcessDefinedStep()
            ->GetProcessName();
  }
  else
  {
    G4cout << "---";
  }
  G4cout << G4endl;
 
  if(fVerboseLevel > 2)
  {
    const G4TrackVector* secondaries = nullptr;
    if((secondaries = track->GetStep()->GetSecondary()) != nullptr)
    {
      if(!secondaries->empty())
      {
        G4cout << "\t\t ---->";
        for(const auto secondarie : *secondaries)
        {
          G4cout << GetIT(secondarie)->GetName() << "("
                 << secondarie->GetTrackID() << ")" << " ";
        }
        G4cout << G4endl;
      }
    }
  }
 
  G4cout << G4endl;
}

PreStepVerbose()

void G4ITSteppingVerbose::PreStepVerbose ( G4Track * track )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 1113 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel <= 0) return;
 
  G4IosFlagsSaver ios_saver(G4cout);
 
/////
// PRE STEP VERBOSE
 
#ifdef DEBUG
#ifdef USE_COLOR
  G4cout << LIGHT_RED;
#endif
  G4cout << "*DoIt* " << GetIT(track)->GetName()
  << " ID: " << track->GetTrackID()
  << " at time : " << track->GetGlobalTime()
  << G4endl;
#ifdef USE_COLOR
  G4cout << RESET_COLOR;
#endif
#endif
 
  G4String volumeName;
 
  G4TouchableHandle nextTouchable = track->GetNextTouchableHandle();
  G4VPhysicalVolume* volume(nullptr);
 
  if(nextTouchable && ((volume = nextTouchable->GetVolume()) != nullptr))
  {
    volumeName = volume->GetName();
 
    if(volume->IsParameterised() || volume->IsReplicated())
    {
      volumeName += " ";
      volumeName += (char)nextTouchable->GetReplicaNumber();
    }
  }
  else
  {
    volumeName = "OutOfWorld";
  }
 
  G4cout << setw(18) << left << GetIT(track)->GetName() << setw(15)
         << track->GetTrackID() << std::setprecision(3) << setw(35)
         << G4String(G4BestUnit(track->GetPosition(), "Length")) << setw(25)
         << volumeName << setw(25) << "---" << G4endl;
 
}

ShowStep()

void G4ITSteppingVerbose::ShowStep

(

)

const

Definition at line 917 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel == 0)
  {
    return;
  }
 
  G4String volName;
  G4long oldprc;
 
// Show header
  G4cout << G4endl;
  G4cout << "    ++G4Step Information " << G4endl;
  oldprc = G4cout.precision(16);
 
// Show G4Step specific information
  G4cout << "      Address of G4Track    : " << fStep->GetTrack() << G4endl;
  G4cout << "      Step Length (mm)      : "
         << fStep->GetTrack()->GetStepLength() << G4endl;
  G4cout << "      Energy Deposit (MeV)  : " << fStep->GetTotalEnergyDeposit()
         << G4endl;
 
// Show G4StepPoint specific information
  G4cout << "      -------------------------------------------------------"
         << "----------------" << G4endl;
  G4cout << "        StepPoint Information  " << std::setw(20) << "PreStep"
         << std::setw(20) << "PostStep" << G4endl;
  G4cout << "      -------------------------------------------------------"
         << "----------------" << G4endl;
  G4cout << "         Position - x (mm)   : " << std::setw(20)
         << fStep->GetPreStepPoint()->GetPosition().x() << std::setw(20)
         << fStep->GetPostStepPoint()->GetPosition().x() << G4endl;
  G4cout << "         Position - y (mm)   : " << std::setw(20)
         << fStep->GetPreStepPoint()->GetPosition().y() << std::setw(20)
         << fStep->GetPostStepPoint()->GetPosition().y() << G4endl;
  G4cout << "         Position - z (mm)   : " << std::setw(20)
         << fStep->GetPreStepPoint()->GetPosition().z() << std::setw(20)
         << fStep->GetPostStepPoint()->GetPosition().z() << G4endl;
  G4cout << "         Global Time (ns)    : " << std::setw(20)
         << fStep->GetPreStepPoint()->GetGlobalTime() << std::setw(20)
         << fStep->GetPostStepPoint()->GetGlobalTime() << G4endl;
  G4cout << "         Local Time (ns)     : " << std::setw(20)
         << fStep->GetPreStepPoint()->GetLocalTime() << std::setw(20)
         << fStep->GetPostStepPoint()->GetLocalTime() << G4endl;
  G4cout << "         Proper Time (ns)    : " << std::setw(20)
         << fStep->GetPreStepPoint()->GetProperTime() << std::setw(20)
         << fStep->GetPostStepPoint()->GetProperTime() << 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 (MeV/c): " << std::setw(20)
         << fStep->GetPreStepPoint()->GetMomentum().x() << std::setw(20)
         << fStep->GetPostStepPoint()->GetMomentum().x() << G4endl;
  G4cout << "         Momentum - y (MeV/c): " << std::setw(20)
         << fStep->GetPreStepPoint()->GetMomentum().y() << std::setw(20)
         << fStep->GetPostStepPoint()->GetMomentum().y() << G4endl;
  G4cout << "         Momentum - z (MeV/c): " << std::setw(20)
         << fStep->GetPreStepPoint()->GetMomentum().z() << std::setw(20)
         << fStep->GetPostStepPoint()->GetMomentum().z() << G4endl;
  G4cout << "         Total Energy (MeV)  : " << std::setw(20)
         << fStep->GetPreStepPoint()->GetTotalEnergy() << std::setw(20)
         << fStep->GetPostStepPoint()->GetTotalEnergy() << G4endl;
  G4cout << "         Kinetic Energy (MeV): " << std::setw(20)
         << fStep->GetPreStepPoint()->GetKineticEnergy() << std::setw(20)
         << fStep->GetPostStepPoint()->GetKineticEnergy() << G4endl;
  G4cout << "         Velocity (mm/ns)    : " << std::setw(20)
         << fStep->GetPreStepPoint()->GetVelocity() << std::setw(20)
         << fStep->GetPostStepPoint()->GetVelocity() << G4endl;
  G4cout << "         Volume Name         : " << std::setw(20)
         << fStep->GetPreStepPoint()->GetPhysicalVolume()->GetName();
  if(fStep->GetPostStepPoint()->GetPhysicalVolume() != nullptr)
  {
    volName = fStep->GetPostStepPoint()->GetPhysicalVolume()->GetName();
  }
  else
  {
    volName = "OutOfWorld";
  }
  G4cout << std::setw(20) << volName << G4endl;
  G4cout << "         Safety (mm)         : " << std::setw(20)
         << fStep->GetPreStepPoint()->GetSafety() << std::setw(20)
         << fStep->GetPostStepPoint()->GetSafety() << 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 G4ITSteppingVerbose::StepInfo ( )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 373 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel < 2)
  {
    return;
  }
 
  CopyState();
  G4long prec = G4cout.precision(3);
//    G4cout.precision(16);
 
  if(fVerboseLevel >= 4) VerboseTrack();
  if(fVerboseLevel >= 3)
  {
    G4cout << G4endl;
    G4cout << "StepInfo" << G4endl;
#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE      
    G4cout << std::setw( 5) << "#TrackID" << " "
    << std::setw( 5) << "#Step#" << " "
    << std::setw( 8) << "X" << "     " << std::setw( 8) << "Y" << "     "
    << std::setw( 8) << "Z" << "     "
    << std::setw( 9) << "KineE" << "     " << std::setw( 8) << "dE" << "     "
    << std::setw(12) << "StepLeng" << " " << std::setw(12) << "TrackLeng" << " "
    << std::setw(12) << "NextVolume" << " " << std::setw( 8) << "ProcName" << G4endl;
#else
    G4cout << std::setw( 5) << "#TrackID" << " "
    << std::setw( 5) << "#Step#" << " "
    << std::setw( 8) << "X(mm)" << " " << std::setw( 8) << "Y(mm)" << " "
    << std::setw( 8) << "Z(mm)" << " "
    << std::setw( 9) << "KinE(MeV)" << " " << std::setw( 8) << "dE(MeV)" << " "
    << std::setw( 8) << "StepLeng" << " " << std::setw( 9) << "TrackLeng" << " "
    << std::setw(11) << "NextVolume" << " " << std::setw( 8) << "ProcName" << G4endl;
#endif       
  }
  G4cout << std::setw(5) << fTrack->GetTrackID() << " " << std::setw(5)
         << fTrack->GetCurrentStepNumber() << " " << std::setw(8)
         << G4BestUnit(fTrack->GetPosition().x(), "Length") << " "
         << std::setw(8) << G4BestUnit(fTrack->GetPosition().y(), "Length")
         << " " << std::setw(8)
         << G4BestUnit(fTrack->GetPosition().z(), "Length") << " "
         << std::setw(9) << G4BestUnit(fTrack->GetKineticEnergy(), "Energy")
         << " " << std::setw(8)
         << G4BestUnit(fStep->GetTotalEnergyDeposit(), "Energy") << " "
         << std::setw(8) << G4BestUnit(fStep->GetStepLength(), "Length") << " "
         << std::setw(9) << G4BestUnit(fTrack->GetTrackLength(), "Length")
         << " ";
 
  // Put cut comment here
  if(fTrack->GetNextVolume() != nullptr)
  {
    G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
  }
  else
  {
    G4cout << std::setw(11) << "OutOfWorld" << " ";
  }
  if(fStep->GetPostStepPoint()->GetProcessDefinedStep() != nullptr)
  {
    G4cout
        << fStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName();
  }
  else
  {
    G4cout << "User Limit";
  }
  G4cout << G4endl;
  if(fVerboseLevel == 2)
  {
    G4int tN2ndariesTot = fN2ndariesAtRestDoIt + fN2ndariesAlongStepDoIt
                          + fN2ndariesPostStepDoIt;
    if(tN2ndariesTot > 0)
    {
      G4cout << "    :----- List of 2ndaries - " << "#SpawnInStep="
             << std::setw(3) << tN2ndariesTot << "(Rest=" << std::setw(2)
             << fN2ndariesAtRestDoIt << ",Along=" << std::setw(2)
             << fN2ndariesAlongStepDoIt << ",Post=" << std::setw(2)
             << fN2ndariesPostStepDoIt << "), " << "#SpawnTotal="
             << std::setw(3) << (*fSecondary).size() << " ---------------"
             << G4endl;
 
      for(std::size_t lp1=(*fSecondary).size()-tN2ndariesTot;
                 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(18)
        << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
      }
      G4cout << "    :-----------------------------" << "----------------------------------"
      << "-- EndOf2ndaries Info ---------------" << G4endl;
    }
  }
  G4cout.precision(prec);
}

StepInfoForLeadingTrack()

void G4ITSteppingVerbose::StepInfoForLeadingTrack ( )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 266 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel == 0)
  {
    return;
  }
 
  if(fVerboseLevel < 2)
  {
    CopyState();
    G4long prec = G4cout.precision(3);
    //    G4cout.precision(16);
 
    if(fVerboseLevel >= 4) VerboseTrack();
    if(fVerboseLevel >= 3)
    {
      G4cout << G4endl;
      G4cout << "StepInfo" << G4endl;
#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
      G4cout << std::setw( 5) << "#TrackID" << " "
      << std::setw( 5) << "#Step#" << " "
      << std::setw( 8) << "X" << "     " << std::setw( 8) << "Y" << "     "
      << std::setw( 8) << "Z" << "     "
      << std::setw( 9) << "KineE" << "     " << std::setw( 8) << "dE" << "     "
      << std::setw(12) << "StepLeng" << " " << std::setw(12) << "TrackLeng" << " "
      << std::setw(12) << "NextVolume" << " " << std::setw( 8) << "ProcName" << G4endl;
#else
      G4cout << std::setw( 5) << "#TrackID" << " "
      << std::setw( 5) << "#Step#" << " "
      << std::setw( 8) << "X(mm)" << " " << std::setw( 8) << "Y(mm)" << " "
      << std::setw( 8) << "Z(mm)" << " "
      << std::setw( 9) << "KinE(MeV)" << " " << std::setw( 8) << "dE(MeV)" << " "
      << std::setw( 8) << "StepLeng" << " " << std::setw( 9) << "TrackLeng" << " "
      << std::setw(11) << "NextVolume" << " " << std::setw( 8) << "ProcName" << G4endl;
#endif
    }
    G4cout << std::setw(5) << fTrack->GetTrackID() << " " << std::setw(5)
           << fTrack->GetCurrentStepNumber() << " " << std::setw(8)
           << G4BestUnit(fTrack->GetPosition().x(), "Length") << " "
           << std::setw(8) << G4BestUnit(fTrack->GetPosition().y(), "Length")
           << " " << std::setw(8)
           << G4BestUnit(fTrack->GetPosition().z(), "Length") << " "
           << std::setw(9) << G4BestUnit(fTrack->GetKineticEnergy(), "Energy")
           << " " << std::setw(8)
           << G4BestUnit(fStep->GetTotalEnergyDeposit(), "Energy") << " "
           << std::setw(8) << G4BestUnit(fStep->GetStepLength(), "Length")
           << " " << std::setw(9)
           << G4BestUnit(fTrack->GetTrackLength(), "Length") << " ";
 
    // Put cut comment here
    if(fTrack->GetNextVolume() != nullptr)
    {
      G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
    }
    else
    {
      G4cout << std::setw(11) << "OutOfWorld" << " ";
    }
    if(fStep->GetPostStepPoint()->GetProcessDefinedStep() != nullptr)
    {
      G4cout
          << fStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName();
    }
    else
    {
      G4cout << "User Limit";
    }
 
    G4cout << G4endl;
    if(fVerboseLevel == 2)
    {
      G4int tN2ndariesTot = fN2ndariesAtRestDoIt + fN2ndariesAlongStepDoIt
                            + fN2ndariesPostStepDoIt;
      if(tN2ndariesTot > 0)
      {
        G4cout << "    :----- List of 2ndaries - " << "#SpawnInStep="
               << std::setw(3) << tN2ndariesTot << "(Rest=" << std::setw(2)
               << fN2ndariesAtRestDoIt << ",Along=" << std::setw(2)
               << fN2ndariesAlongStepDoIt << ",Post=" << std::setw(2)
               << fN2ndariesPostStepDoIt << "), " << "#SpawnTotal="
               << std::setw(3) << (*fSecondary).size() << " ---------------"
               << G4endl;
 
        for(std::size_t lp1=(*fSecondary).size()-tN2ndariesTot;
                   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(18)
          << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
        }
        G4cout << "    :-----------------------------" << "----------------------------------"
        << "-- EndOf2ndaries Info ---------------" << G4endl;
      }
    }
    G4cout.precision(prec);
  }
}

TrackingEnded()

void G4ITSteppingVerbose::TrackingEnded ( G4Track * track )

overridevirtual

Reimplemented from G4VITSteppingVerbose.

Definition at line 649 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel <= 1) return;
 
  G4cout << " * End tracking : " << "   Particle : "
         << track->GetDefinition()->GetParticleName() << "," << "   Track ID : "
         << track->GetTrackID();
 
  if(track->GetNextVolume() != nullptr)
  {
    G4cout << std::setw(11) << track->GetNextVolume()->GetName() << " ";
  }
 
  G4cout << G4endl;
}

TrackingStarted()

void G4ITSteppingVerbose::TrackingStarted ( G4Track * track )

overridevirtual

Reimplemented from G4VITSteppingVerbose.

Definition at line 580 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel <= 1)
  {
    return;
  }
 
  G4long prec = G4cout.precision(3);
  if(fVerboseLevel > 0)
  {
    fTrack = track;
    fStep = track->GetStep();
 
//#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
//    G4cout << std::setw(5) << "TrackID" << " " << std::setw(5) << "Step#" << " "
//           << std::setw(8) << "X" << "     " << std::setw(8) << "Y" << "     "
//           << std::setw(8) << "Z" << "     " << std::setw(9) << "KineE"
//           << "     " << std::setw(8) << "dE" << "     " << std::setw(12)
//           << "StepLeng" << " " << std::setw(12) << "TrackLeng" << " "
//           << std::setw(12) << "NextVolume" << " " << std::setw(8) << "ProcName"
//           << G4endl;
//#else
//    G4cout << std::setw(5) << "TrackID" << std::setw(5) << "Step#" << " "
//    << std::setw(8) << "X(mm)" << " " << std::setw(8) << "Y(mm)" << " "
//    << std::setw(8) << "Z(mm)" << " " << std::setw(9) << "KinE(MeV)"
//    << " " << std::setw(8) << "dE(MeV)" << " " << std::setw(8)
//    << "StepLeng" << " " << std::setw(9) << "TrackLeng" << " "
//    << std::setw(11) << "NextVolume" << " " << std::setw(8) << "ProcName"
//    << G4endl;
//#endif
 
    G4cout << "Start tracking : "
        << GetIT(fTrack)->GetName()
           << " (" << fTrack->GetTrackID() << ") from position "
           << std::setw(8)
           << G4BestUnit(fTrack->GetPosition().x(), "Length") << " "
           << std::setw(8)
           << G4BestUnit(fTrack->GetPosition().y(), "Length") << " "
           << std::setw(8)
           << G4BestUnit(fTrack->GetPosition().z(), "Length") << " ";
 
//    G4cout << std::setw(5) << fTrack->GetTrackID() << std::setw(5)
//           << fTrack->GetCurrentStepNumber() << " " << std::setw(8)
//           << G4BestUnit(fTrack->GetPosition().x(), "Length") << " "
//           << std::setw(8) << G4BestUnit(fTrack->GetPosition().y(), "Length")
//           << " " << std::setw(8)
//           << G4BestUnit(fTrack->GetPosition().z(), "Length") << " "
//           << std::setw(9) << G4BestUnit(fTrack->GetKineticEnergy(), "Energy")
//           << " " << std::setw(8)
//           << G4BestUnit(fStep->GetTotalEnergyDeposit(), "Energy") << " "
//           << std::setw(8) << G4BestUnit(fStep->GetStepLength(), "Length")
//           << " " << std::setw(9)
//           << G4BestUnit(fTrack->GetTrackLength(), "Length") << " ";
 
    if(fTrack->GetNextVolume() != nullptr)
    {
      G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
    }
    else
    {
      G4cout << std::setw(11) << "OutOfWorld" << " ";
    }
    G4cout << "initStep" << G4endl;
  }
  G4cout.precision(prec);
}

VerboseParticleChange()

void G4ITSteppingVerbose::VerboseParticleChange ( )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 904 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel == 0)
  {
    return;
  }
// Show header
  G4cout << G4endl;
  G4cout << "    ++G4ParticleChange Information " << G4endl;
  fParticleChange->DumpInfo();
}

Referenced by AlongStepDoItOneByOne(), and PostStepDoItOneByOne().

VerboseTrack()

void G4ITSteppingVerbose::VerboseTrack ( )

overridevirtual

Implements G4VITSteppingVerbose.

Definition at line 755 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel == 0)
  {
    return;
  }
 
  CopyState();
// Show header
  G4cout << G4endl;
  G4cout << "    ++G4Track Information " << G4endl;
  G4long prec = G4cout.precision(3);
 
  G4cout << "      -----------------------------------------------" << G4endl;
  G4cout << "        G4Track Information  " << std::setw(20) << G4endl;
  G4cout << "      -----------------------------------------------" << G4endl;
 
  G4cout << "        Step number         : " << std::setw(20)
         << fTrack->GetCurrentStepNumber() << G4endl;
#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
  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;
#else
  G4cout << "        Position - x (mm)   : " << std::setw(20)
  << fTrack->GetPosition().x() / mm << G4endl;
  G4cout << "        Position - y (mm)   : " << std::setw(20)
  << fTrack->GetPosition().y() / mm << G4endl;
  G4cout << "        Position - z (mm)   : " << std::setw(20)
  << fTrack->GetPosition().z() / mm << G4endl;
  G4cout << "        Global Time (ns)    : " << std::setw(20)
  << fTrack->GetGlobalTime() / ns << G4endl;
  G4cout << "        Local Time (ns)     : " << std::setw(20)
  << fTrack->GetLocalTime() / ns << G4endl;
#endif
  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;
#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
  G4cout << "        Kinetic Energy      : "
#else
         G4cout << "        Kinetic Energy (MeV): "
#endif
         << 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;
#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
  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;
#else
  G4cout << "        Vertex - x (mm)     : " << std::setw(20)
  << fTrack->GetVertexPosition().x() / mm << G4endl;
  G4cout << "        Vertex - y (mm)     : " << std::setw(20)
  << fTrack->GetVertexPosition().y() / mm << G4endl;
  G4cout << "        Vertex - z (mm)     : " << std::setw(20)
  << fTrack->GetVertexPosition().z() / mm << G4endl;
#endif
  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;
#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
  G4cout << "        Vertex - KineE      : "
#else
         G4cout << "        Vertex - KineE (MeV): "
#endif
         << 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(prec);
}

Referenced by StepInfo(), and StepInfoForLeadingTrack().

---

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

• G4ITSteppingVerbose.hh
• G4ITSteppingVerbose.cc