#include <G4ITSteppingVerbose.hh>

Inheritance diagram for G4ITSteppingVerbose:

Public Member Functions
void	AlongStepDoItAllDone ()

void	AlongStepDoItOneByOne ()

void	AtRestDoItInvoked ()

void	AtRestDoItOneByOne ()

void	CopyState ()

void	DoItStarted ()

void	DPSLAlongStep ()

void	DPSLPostStep ()

void	DPSLStarted ()

void	DPSLUserLimit ()

	G4ITSteppingVerbose ()

virtual G4String	GetCurrentValue (G4UIcommand *command)

G4int	GetVerbose ()

void	NewStep ()

void	PostStepDoItAllDone ()

void	PostStepDoItOneByOne ()

void	PostStepVerbose (G4Track *track)

void	PreStepVerbose (G4Track *track)

virtual void	SetNewValue (G4UIcommand *command, G4String newValue)

void	SetStepProcessor (const G4ITStepProcessor *stepProcessor)

void	SetVerbose (int flag)

void	ShowStep () const

void	StepInfo ()

void	StepInfoForLeadingTrack ()

void	TrackBanner (G4Track *track, const G4String &message)

void	TrackingEnded (G4Track *)

void	TrackingStarted (G4Track *)

void	VerboseParticleChange ()

void	VerboseTrack ()

	~G4ITSteppingVerbose ()

Protected Types
typedef std::vector< G4int >	G4SelectedAlongStepDoItVector

typedef std::vector< G4int >	G4SelectedAtRestDoItVector

typedef std::vector< G4int >	G4SelectedPostStepDoItVector

Protected Attributes
G4ProcessVector *	fAlongStepDoItVector

G4ProcessVector *	fAlongStepGetPhysIntVector

size_t	fAtRestDoItProcTriggered

G4ProcessVector *	fAtRestDoItVector

G4ProcessVector *	fAtRestGetPhysIntVector

G4ForceCondition	fCondition

const G4VITProcess *	fCurrentProcess

const G4VPhysicalVolume *	fCurrentVolume

G4GPILSelection	fGPILSelection

G4int	fN2ndariesAlongStepDoIt

G4int	fN2ndariesAtRestDoIt

G4int	fN2ndariesPostStepDoIt

const G4VParticleChange *	fParticleChange

size_t	fPostStepDoItProcTriggered

G4ProcessVector *	fPostStepDoItVector

G4ProcessVector *	fPostStepGetPhysIntVector

G4StepPoint *	fPostStepPoint

const ProcessGeneralInfo *	fpProcessGeneralInfo

G4StepPoint *	fPreStepPoint

G4double	fPreviousStepSize

G4ITStepProcessorState *	fpState

const G4ITStepProcessor *	fpStepProcessor

G4UIcmdWithAnInteger *	fpVerboseUI

const G4TrackVector *	fSecondary

G4SelectedAtRestDoItVector *	fSelectedAtRestDoItVector

G4SelectedPostStepDoItVector *	fSelectedPostStepDoItVector

const G4Step *	fStep

G4StepStatus	fStepStatus

G4TouchableHandle	fTouchableHandle

const G4Track *	fTrack

G4int	fVerboseLevel

size_t	MAXofAlongStepLoops

size_t	MAXofAtRestLoops

size_t	MAXofPostStepLoops

G4double	PhysicalStep

G4double	physIntLength

Private Member Functions
void	AddUIcommand (G4UIcommand *newCommand)

G4String	BtoS (G4bool b)

G4bool	CommandsShouldBeInMaster () const

template<typename T >
T *	CreateCommand (const G4String &cname, const G4String &dsc)

void	CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)

G4String	DtoS (G4double a)

G4String	ItoS (G4int i)

G4bool	operator!= (const G4UImessenger &messenger) const

G4bool	operator== (const G4UImessenger &messenger) const

G4bool	StoB (G4String s)

G4double	StoD (G4String s)

G4int	StoI (G4String s)

G4long	StoL (G4String s)

Private Attributes
G4UIdirectory *	baseDir = nullptr

G4String	baseDirName = ""

G4bool	commandsShouldBeInMaster = false

Detailed Description

Definition at line 44 of file G4ITSteppingVerbose.hh.

Member Typedef Documentation

◆ G4SelectedAlongStepDoItVector

typedef std::vector<G4int> G4VITSteppingVerbose::G4SelectedAlongStepDoItVector

protectedinherited

Definition at line 183 of file G4VITSteppingVerbose.hh.

◆ G4SelectedAtRestDoItVector

typedef std::vector<G4int> G4VITSteppingVerbose::G4SelectedAtRestDoItVector

protectedinherited

Definition at line 182 of file G4VITSteppingVerbose.hh.

◆ G4SelectedPostStepDoItVector

typedef std::vector<G4int> G4VITSteppingVerbose::G4SelectedPostStepDoItVector

protectedinherited

Definition at line 184 of file G4VITSteppingVerbose.hh.

Constructor & Destructor Documentation

◆ G4ITSteppingVerbose()

G4ITSteppingVerbose::G4ITSteppingVerbose ( )

Definition at line 57 of file G4ITSteppingVerbose.cc.

{
#ifdef G4_TRACKING_DEBUG
  G4cout << "G4ITSteppingVerbose has instantiated" << G4endl;
#endif
}

References G4cout, and G4endl.

◆ ~G4ITSteppingVerbose()

G4ITSteppingVerbose::~G4ITSteppingVerbose ( )

Definition at line 66 of file G4ITSteppingVerbose.cc.

68{

69}

Member Function Documentation

◆ AddUIcommand()

void G4UImessenger::AddUIcommand ( G4UIcommand * newCommand )

protectedinherited

Definition at line 149 of file G4UImessenger.cc.

{
  G4cerr << "Warning : Old style definition of G4UIcommand <"
         << newCommand->GetCommandPath() << ">." << G4endl;
}

References G4cerr, G4endl, and G4UIcommand::GetCommandPath().

◆ AlongStepDoItAllDone()

void G4ITSteppingVerbose::AlongStepDoItAllDone ( )

virtual

Implements G4VITSteppingVerbose.

Definition at line 145 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(size_t ci=0; ci<MAXofAlongStepLoops; ci++)
    {
      ptProcManager = (*fAlongStepDoItVector)(ci);
      G4cout << "      " << ci+1 << ") ";
      if(ptProcManager != 0)
      {
        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).size()>0)
    {
      for(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 G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::fSecondary, G4VITSteppingVerbose::fVerboseLevel, G4BestUnit, G4cout, G4endl, G4VProcess::GetProcessName(), G4VITSteppingVerbose::MAXofAlongStepLoops, and ShowStep().

◆ AlongStepDoItOneByOne()

void G4ITSteppingVerbose::AlongStepDoItOneByOne ( )

virtual

Implements G4VITSteppingVerbose.

Definition at line 675 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(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 G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::fCurrentProcess, G4VITSteppingVerbose::fN2ndariesAlongStepDoIt, G4VITSteppingVerbose::fSecondary, G4VITSteppingVerbose::fVerboseLevel, G4BestUnit, G4cout, G4endl, G4VProcess::GetProcessName(), ShowStep(), and VerboseParticleChange().

◆ AtRestDoItInvoked()

void G4ITSteppingVerbose::AtRestDoItInvoked ( )

virtual

Implements G4VITSteppingVerbose.

Definition at line 78 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel == 0)
  {
    return;
  }
 
  G4VProcess* ptProcManager;
  CopyState();
 
  if(fVerboseLevel >= 3)
  {
    G4int npt = 0;
    G4cout << " **List of AtRestDoIt invoked:" << G4endl;
    for(size_t np = 0; np < MAXofAtRestLoops; np++)
    {
      size_t npGPIL = MAXofAtRestLoops - np - 1;
      if((*fSelectedAtRestDoItVector)[npGPIL] == 2)
      {
        npt++;
        ptProcManager = (*fAtRestDoItVector)[np];
        G4cout << "   # " << npt << " : " << ptProcManager->GetProcessName()
               << " (Forced)" << G4endl;
      }
      else if ( (*fSelectedAtRestDoItVector)[npGPIL] == 1 )
      {
        npt++;
        ptProcManager = (*fAtRestDoItVector)[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( 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;
  }
}

References G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::fN2ndariesAtRestDoIt, G4VITSteppingVerbose::fSecondary, G4VITSteppingVerbose::fSelectedAtRestDoItVector, G4VITSteppingVerbose::fVerboseLevel, G4BestUnit, G4cout, G4endl, G4VProcess::GetProcessName(), G4VITSteppingVerbose::MAXofAtRestLoops, and ShowStep().

◆ AtRestDoItOneByOne()

void G4ITSteppingVerbose::AtRestDoItOneByOne ( )

virtual

Implements G4VITSteppingVerbose.

Definition at line 1237 of file G4ITSteppingVerbose.cc.

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

References G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::fCurrentProcess, G4cout, G4endl, and G4VProcess::GetProcessName().

◆ BtoS()

G4String G4UImessenger::BtoS ( G4bool b )

protectedinherited

Definition at line 98 of file G4UImessenger.cc.

{
  G4String vl = "0";
  if(b)
    vl = "true";
  return vl;
}

◆ CommandsShouldBeInMaster()

G4bool G4UImessenger::CommandsShouldBeInMaster ( ) const

inlineinherited

Definition at line 77 of file G4UImessenger.hh.

    {
      return commandsShouldBeInMaster;
    }

References G4UImessenger::commandsShouldBeInMaster.

Referenced by G4UIcommand::G4UIcommandCommonConstructorCode().

◆ CopyState()

void G4VITSteppingVerbose::CopyState ( )

inherited

Definition at line 106 of file G4VITSteppingVerbose.cc.

{
 
  if(fpState) *fpState = *(fpStepProcessor->GetProcessorState());
  else
  {
    fpState = new G4ITStepProcessorState(*fpStepProcessor->GetProcessorState());
  }
 
  fpProcessGeneralInfo = fpStepProcessor->GetCurrentProcessInfo();
 
  PhysicalStep = fpStepProcessor->GetPhysIntLength();
  fStepStatus = fpState->fStepStatus;
 
  fParticleChange = fpStepProcessor->GetParticleChange();
  fTrack = fpStepProcessor->GetTrack();
  fSecondary = fpStepProcessor->GetSecondaries();
  fStep = fpStepProcessor->GetStep();
  fPreStepPoint = fStep->GetPreStepPoint();
  fPostStepPoint = fStep->GetPostStepPoint();
 
  fCurrentVolume = fpStepProcessor->GetCurrentVolume();
//  fSensitive = fpStepProcessor->GetfSensitive();
  fCurrentProcess = fpStepProcessor->GetCurrentProcess();
 
  fAtRestDoItVector = fpProcessGeneralInfo->fpAtRestDoItVector;
  fAlongStepDoItVector = fpProcessGeneralInfo->fpAlongStepDoItVector;
  fPostStepDoItVector = fpProcessGeneralInfo->fpPostStepDoItVector;
 
  fAtRestGetPhysIntVector = fpProcessGeneralInfo->fpAtRestGetPhysIntVector;
  fAlongStepGetPhysIntVector =
      fpProcessGeneralInfo->fpAlongStepGetPhysIntVector;
  fPostStepGetPhysIntVector = fpProcessGeneralInfo->fpPostStepGetPhysIntVector;
 
  MAXofAtRestLoops = fpProcessGeneralInfo->MAXofAtRestLoops;
  MAXofAlongStepLoops = fpProcessGeneralInfo->MAXofAlongStepLoops;
  MAXofPostStepLoops = fpProcessGeneralInfo->MAXofPostStepLoops;
 
  fAtRestDoItProcTriggered = fpStepProcessor->GetAtRestDoItProcTriggered();
  fPostStepDoItProcTriggered = fpStepProcessor->GetPostStepDoItProcTriggered();
 
  fN2ndariesAtRestDoIt = fpStepProcessor->GetN2ndariesAtRestDoIt();
  fN2ndariesAlongStepDoIt = fpStepProcessor->GetN2ndariesAlongStepDoIt();
  fN2ndariesPostStepDoIt = fpStepProcessor->GetN2ndariesPostStepDoIt();
 
//  fNavigator = fpStepProcessor->GetfNavigator();
 
  fSelectedAtRestDoItVector = &(fpState->fSelectedAtRestDoItVector);
  fSelectedPostStepDoItVector = &(fpState->fSelectedPostStepDoItVector);
 
  fPreviousStepSize = fpState->fPreviousStepSize;
 
  fTouchableHandle = fpState->fTouchableHandle;
 
//  StepControlFlag = fpStepProcessor->GetStepControlFlag();
 
  physIntLength = fpStepProcessor->GetPhysIntLength();
  fCondition = fpStepProcessor->GetCondition();
  fGPILSelection = fpStepProcessor->GetGPILSelection();
}

Referenced by AlongStepDoItAllDone(), AlongStepDoItOneByOne(), AtRestDoItInvoked(), AtRestDoItOneByOne(), DPSLAlongStep(), DPSLPostStep(), DPSLStarted(), DPSLUserLimit(), PostStepDoItAllDone(), PostStepDoItOneByOne(), StepInfo(), StepInfoForLeadingTrack(), and VerboseTrack().

◆ CreateCommand()

template<typename T >

T * G4UImessenger::CreateCommand	(	const G4String &	cname,
		const G4String &	dsc
	)

protectedinherited

Definition at line 110 of file G4UImessenger.hh.

{
  G4String path;
  if(cname[0] != '/')
  {
    path = baseDirName + cname;
    if(path[0] != '/')
      path = "/" + path;
  }
 
  T* command = new T(path.c_str(), this);
  command->SetGuidance(dsc.c_str());
 
  return command;
}

References G4UImessenger::baseDirName.

◆ CreateDirectory()

void G4UImessenger::CreateDirectory	(	const G4String &	path,
		const G4String &	dsc,
		G4bool	commandsToBeBroadcasted = `true`
	)

protectedinherited

Definition at line 156 of file G4UImessenger.cc.

{
  G4UImanager* ui = G4UImanager::GetUIpointer();
 
  G4String fullpath = path;
  if(fullpath.back() != '/')
    fullpath.append("/");
 
  G4UIcommandTree* tree = ui->GetTree()->FindCommandTree(fullpath.c_str());
  if(tree != nullptr)
  {
    baseDirName = tree->GetPathName();
  }
  else
  {
    baseDir     = new G4UIdirectory(fullpath.c_str(), commandsToBeBroadcasted);
    baseDirName = fullpath;
    baseDir->SetGuidance(dsc.c_str());
  }
}

References G4UImessenger::baseDir, G4UImessenger::baseDirName, G4UIcommandTree::FindCommandTree(), G4UIcommandTree::GetPathName(), G4UImanager::GetTree(), G4UImanager::GetUIpointer(), and G4UIcommand::SetGuidance().

Referenced by G4MoleculeShootMessenger::G4MoleculeShootMessenger(), and G4UImessenger::G4UImessenger().

◆ DoItStarted()

void G4ITSteppingVerbose::DoItStarted ( )

virtual

Implements G4VITSteppingVerbose.

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

References G4VITSteppingVerbose::fVerboseLevel, G4cout, G4endl, LIGHT_RED, and RESET_COLOR.

◆ DPSLAlongStep()

void G4ITSteppingVerbose::DPSLAlongStep ( )

virtual

Implements G4VITSteppingVerbose.

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

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

◆ DPSLPostStep()

void G4ITSteppingVerbose::DPSLPostStep ( )

virtual

Implements G4VITSteppingVerbose.

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

References Conditionally, G4VITSteppingVerbose::CopyState(), ExclusivelyForced, G4VITSteppingVerbose::fCondition, G4VITSteppingVerbose::fCurrentProcess, Forced, G4VITSteppingVerbose::fVerboseLevel, G4cout, G4endl, G4VProcess::GetProcessName(), G4VITSteppingVerbose::physIntLength, and StronglyForced.

◆ DPSLStarted()

void G4ITSteppingVerbose::DPSLStarted ( )

virtual

Implements G4VITSteppingVerbose.

Definition at line 486 of file G4ITSteppingVerbose.cc.

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

References G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::fVerboseLevel, G4cout, and G4endl.

◆ DPSLUserLimit()

void G4ITSteppingVerbose::DPSLUserLimit ( )

virtual

Implements G4VITSteppingVerbose.

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

References G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::fVerboseLevel, G4cout, G4endl, and G4VITSteppingVerbose::physIntLength.

◆ DtoS()

G4String G4UImessenger::DtoS ( G4double a )

protectedinherited

Definition at line 90 of file G4UImessenger.cc.

{
  std::ostringstream os;
  os << a;
  return G4String(os.str());
}

Referenced by G4ScoreQuantityMessenger::FilterCommands(), and G4UIcontrolMessenger::SetNewValue().

◆ GetCurrentValue()

G4String G4VITSteppingVerbose::GetCurrentValue ( G4UIcommand * command )

virtualinherited

Reimplemented from G4UImessenger.

Definition at line 179 of file G4VITSteppingVerbose.cc.

{
  return command->ConvertToString(fVerboseLevel);
}

References G4UIcommand::ConvertToString(), and G4VITSteppingVerbose::fVerboseLevel.

◆ GetVerbose()

G4int G4VITSteppingVerbose::GetVerbose ( )

inlineinherited

Definition at line 112 of file G4VITSteppingVerbose.hh.

  {
    return fVerboseLevel;
  }

References G4VITSteppingVerbose::fVerboseLevel.

Referenced by G4ITTrackingInteractivity::GetSteppingVerboseLevel().

◆ ItoS()

G4String G4UImessenger::ItoS ( G4int i )

protectedinherited

Definition at line 82 of file G4UImessenger.cc.

{
  std::ostringstream os;
  os << i;
  return G4String(os.str());
}

Referenced by G4GenericMessenger::DeclareMethod(), and G4ParticleGunMessenger::GetCurrentValue().

◆ NewStep()

void G4ITSteppingVerbose::NewStep ( )

virtual

Implements G4VITSteppingVerbose.

Definition at line 72 of file G4ITSteppingVerbose.cc.

74{

75}

◆ operator!=()

G4bool G4UImessenger::operator!= ( const G4UImessenger & messenger ) const

inherited

Definition at line 76 of file G4UImessenger.cc.

{
  return this != &messenger;
}

◆ operator==()

G4bool G4UImessenger::operator== ( const G4UImessenger & messenger ) const

inherited

Definition at line 70 of file G4UImessenger.cc.

{
  return this == &messenger;
}

◆ PostStepDoItAllDone()

void G4ITSteppingVerbose::PostStepDoItAllDone ( )

virtual

Implements G4VITSteppingVerbose.

Definition at line 202 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(size_t np = 0; np < MAXofPostStepLoops; np++)
      {
        size_t npGPIL = MAXofPostStepLoops - np - 1;
        if((*fSelectedPostStepDoItVector)[npGPIL] == 2)
        {
          npt++;
          ptProcManager = (*fPostStepDoItVector)[np];
          G4cout << "      " << npt << ") " << ptProcManager->GetProcessName()
                 << " (Forced)" << G4endl;
        }
        else if ( (*fSelectedPostStepDoItVector)[npGPIL] == 1)
        {
          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 secodaries = " << (*fSecondary).size() << G4endl;
      G4cout << "      [Note]Secondaries from AlongStepDoIt included." << G4endl;
 
      if((*fSecondary).size() > 0)
      {
        for(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, G4VITSteppingVerbose::CopyState(), ExclusivelyForced, G4VITSteppingVerbose::fCondition, Forced, fPostStepDoItProc, G4VITSteppingVerbose::fSecondary, G4VITSteppingVerbose::fSelectedPostStepDoItVector, G4VITSteppingVerbose::fStepStatus, G4VITSteppingVerbose::fVerboseLevel, G4BestUnit, G4cout, G4endl, G4VProcess::GetProcessName(), G4VITSteppingVerbose::MAXofPostStepLoops, ShowStep(), and StronglyForced.

◆ PostStepDoItOneByOne()

void G4ITSteppingVerbose::PostStepDoItOneByOne ( )

virtual

Implements G4VITSteppingVerbose.

Definition at line 720 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(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 G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::fCurrentProcess, G4VITSteppingVerbose::fN2ndariesPostStepDoIt, G4VITSteppingVerbose::fSecondary, G4VITSteppingVerbose::fVerboseLevel, G4BestUnit, G4cout, G4endl, G4VProcess::GetProcessName(), ShowStep(), and VerboseParticleChange().

◆ PostStepVerbose()

void G4ITSteppingVerbose::PostStepVerbose ( G4Track * track )

virtual

Implements G4VITSteppingVerbose.

Definition at line 1170 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(0);
 
  if(nextTouchable && (volume = nextTouchable->GetVolume()))
  {
    G4String volumeName = volume->GetName();
 
    if(volume->IsParameterised() || volume->IsReplicated())
    {
      volumeName += " ";
      volumeName += nextTouchable->GetReplicaNumber();
    }
 
    G4cout << setw(25) << volumeName;
  }
  else
  {
    G4cout << setw(25) << "OutOfWorld";
  }
  if(track->GetStep()->GetPostStepPoint()->GetProcessDefinedStep())
  {
    G4cout
        << setw(22)
        << track->GetStep()->GetPostStepPoint()->GetProcessDefinedStep()
            ->GetProcessName();
  }
  else
  {
    G4cout << "---";
  }
  G4cout << G4endl;
 
  if(fVerboseLevel > 2)
  {
    const G4TrackVector* secondaries = 0;
    if((secondaries = track->GetStep()->GetSecondary()))
    {
      if(secondaries->empty() == false)
      {
        G4cout << "\t\t ---->";
        for(size_t j = 0; j < secondaries->size(); ++j)
        {
          G4cout << GetIT((*secondaries)[j])->GetName() << "("
                 << (*secondaries)[j]->GetTrackID() << ")" << " ";
        }
        G4cout << G4endl;
      }
    }
  }
 
  G4cout << G4endl;
}

References G4VITSteppingVerbose::fVerboseLevel, G4BestUnit, G4cout, G4endl, GetIT(), G4VPhysicalVolume::GetName(), G4IT::GetName(), G4Track::GetNextTouchableHandle(), G4Track::GetPosition(), G4Step::GetPostStepPoint(), G4StepPoint::GetProcessDefinedStep(), G4VProcess::GetProcessName(), G4VTouchable::GetReplicaNumber(), G4Step::GetSecondary(), G4Track::GetStep(), G4Track::GetTrackID(), G4VTouchable::GetVolume(), G4VPhysicalVolume::IsParameterised(), and G4VPhysicalVolume::IsReplicated().

◆ PreStepVerbose()

void G4ITSteppingVerbose::PreStepVerbose ( G4Track * track )

virtual

Implements G4VITSteppingVerbose.

Definition at line 1121 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(0);
 
  if(nextTouchable && (volume = nextTouchable->GetVolume()))
  {
    volumeName = volume->GetName();
 
    if(volume->IsParameterised() || volume->IsReplicated())
    {
      volumeName += " ";
      volumeName += 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;
 
}

References G4VITSteppingVerbose::fVerboseLevel, G4BestUnit, G4cout, G4endl, G4Track::GetGlobalTime(), GetIT(), G4VPhysicalVolume::GetName(), G4IT::GetName(), G4Track::GetNextTouchableHandle(), G4Track::GetPosition(), G4VTouchable::GetReplicaNumber(), G4Track::GetTrackID(), G4VTouchable::GetVolume(), G4VPhysicalVolume::IsParameterised(), G4VPhysicalVolume::IsReplicated(), LIGHT_RED, and RESET_COLOR.

◆ SetNewValue()

void G4VITSteppingVerbose::SetNewValue	(	G4UIcommand *	command,
		G4String	newValue
	)

virtualinherited

Reimplemented from G4UImessenger.

Definition at line 169 of file G4VITSteppingVerbose.cc.

{
  if(command == fpVerboseUI)
  {
    fVerboseLevel = fpVerboseUI->GetNewIntValue(newValue);
  }
}

References G4VITSteppingVerbose::fpVerboseUI, G4VITSteppingVerbose::fVerboseLevel, and G4UIcmdWithAnInteger::GetNewIntValue().

◆ SetStepProcessor()

void G4VITSteppingVerbose::SetStepProcessor ( const G4ITStepProcessor * stepProcessor )

inlineinherited

Definition at line 127 of file G4VITSteppingVerbose.hh.

  {
    this->fpStepProcessor = stepProcessor;
  }

References G4VITSteppingVerbose::fpStepProcessor.

Referenced by G4ITStepProcessor::Initialize().

◆ SetVerbose()

void G4VITSteppingVerbose::SetVerbose ( int flag )

inlineinherited

Definition at line 107 of file G4VITSteppingVerbose.hh.

  {
    fVerboseLevel = flag;
  }

References G4VITSteppingVerbose::fVerboseLevel.

Referenced by G4ITTrackingInteractivity::SetSteppingVerboseLevel().

◆ ShowStep()

void G4ITSteppingVerbose::ShowStep ( ) const

Definition at line 925 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel == 0)
  {
    return;
  }
 
  G4String volName;
  G4int 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())
  {
    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() == 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;
}

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

◆ StepInfo()

void G4ITSteppingVerbose::StepInfo ( )

virtual

Implements G4VITSteppingVerbose.

Definition at line 382 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel < 2)
  {
    return;
  }
 
  CopyState();
  G4int 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() != 0)
  {
    G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
  }
  else
  {
    G4cout << std::setw(11) << "OutOfWorld" << " ";
  }
  if(fStep->GetPostStepPoint()->GetProcessDefinedStep() != 0)
  {
    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(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 ( )

virtual

Implements G4VITSteppingVerbose.

Definition at line 276 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel == 0)
  {
    return;
  }
 
  if(fVerboseLevel < 2)
  {
    CopyState();
    G4int 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() != 0)
    {
      G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
    }
    else
    {
      G4cout << std::setw(11) << "OutOfWorld" << " ";
    }
    if(fStep->GetPostStepPoint()->GetProcessDefinedStep() != 0)
    {
      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(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);
  }
}

◆ StoB()

G4bool G4UImessenger::StoB ( G4String s )

protectedinherited

Definition at line 137 of file G4UImessenger.cc.

{
  G4String v = G4StrUtil::to_upper_copy(str);
  G4bool vl = false;
  if(v == "Y" || v == "YES" || v == "1" || v == "T" || v == "TRUE")
  {
    vl = true;
  }
  return vl;
}

References G4StrUtil::to_upper_copy().

Referenced by G4LocalThreadCoutMessenger::SetNewValue(), G4CascadeParamMessenger::SetNewValue(), G4ScoreQuantityMessenger::SetNewValue(), and G4ScoringMessenger::SetNewValue().

◆ StoD()

G4double G4UImessenger::StoD ( G4String s )

protectedinherited

Definition at line 127 of file G4UImessenger.cc.

{
  G4double vl;
  const char* t = str;
  std::istringstream is(t);
  is >> vl;
  return vl;
}

Referenced by G4ScoreQuantityMessenger::FParticleWithEnergyCommand(), G4ParticleGunMessenger::IonCommand(), G4GeneralParticleSourceMessenger::IonCommand(), G4UIcontrolMessenger::SetNewValue(), G4MatScanMessenger::SetNewValue(), G4VisCommandSceneAddText::SetNewValue(), G4VisCommandSceneAddText2D::SetNewValue(), G4ScoreQuantityMessenger::SetNewValue(), G4ScoringMessenger::SetNewValue(), and G4PolarizationMessenger::SetNewValue().

◆ StoI()

G4int G4UImessenger::StoI ( G4String s )

protectedinherited

Definition at line 107 of file G4UImessenger.cc.

{
  G4int vl;
  const char* t = str;
  std::istringstream is(t);
  is >> vl;
  return vl;
}

Referenced by G4ScoringMessenger::Fill1D(), G4ParticleGunMessenger::IonCommand(), G4GeneralParticleSourceMessenger::IonCommand(), G4ParticleGunMessenger::IonLevelCommand(), G4GeneralParticleSourceMessenger::IonLvlCommand(), G4ScoringMessenger::MeshBinCommand(), G4LocalThreadCoutMessenger::SetNewValue(), G4UIcontrolMessenger::SetNewValue(), G4MatScanMessenger::SetNewValue(), G4GMocrenMessenger::SetNewValue(), G4ScoreQuantityMessenger::SetNewValue(), and G4ScoringMessenger::SetNewValue().

◆ StoL()

G4long G4UImessenger::StoL ( G4String s )

protectedinherited

Definition at line 117 of file G4UImessenger.cc.

{
  G4long vl;
  const char* t = str;
  std::istringstream is(t);
  is >> vl;
  return vl;
}

Referenced by G4RunMessenger::SetNewValue().

◆ TrackBanner()

void G4VITSteppingVerbose::TrackBanner	(	G4Track *	track,
		const G4String &	message
	)

inherited

Definition at line 219 of file G4VITSteppingVerbose.cc.

{
  G4cout << G4endl;
  G4cout << "*******************************************************"
         << "**************************************************"
         << G4endl;
  if(message != "")
  {
    G4cout << message;
  }
  G4cout << " * G4Track Information: "
         << "   Particle : " << track->GetDefinition()->GetParticleName()
         << ","
         << "   Track ID : " << track->GetTrackID()
         << ","
         << "   Parent ID : " << track->GetParentID()
         << G4endl;
  G4cout << "*******************************************************"
         << "**************************************************"
         << G4endl;
  G4cout << G4endl;
}

References G4cout, G4endl, G4Track::GetDefinition(), G4Track::GetParentID(), G4ParticleDefinition::GetParticleName(), and G4Track::GetTrackID().

Referenced by G4VITSteppingVerbose::TrackingEnded(), and G4VITSteppingVerbose::TrackingStarted().

◆ TrackingEnded()

void G4ITSteppingVerbose::TrackingEnded ( G4Track * track )

virtual

Reimplemented from G4VITSteppingVerbose.

Definition at line 657 of file G4ITSteppingVerbose.cc.

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

References G4VITSteppingVerbose::fVerboseLevel, G4cout, G4endl, G4Track::GetDefinition(), G4VPhysicalVolume::GetName(), G4Track::GetNextVolume(), G4ParticleDefinition::GetParticleName(), and G4Track::GetTrackID().

◆ TrackingStarted()

void G4ITSteppingVerbose::TrackingStarted ( G4Track * track )

virtual

Reimplemented from G4VITSteppingVerbose.

Definition at line 588 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel <= 1)
  {
    return;
  }
 
  G4int 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())
    {
      G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
    }
    else
    {
      G4cout << std::setw(11) << "OutOfWorld" << " ";
    }
    G4cout << "initStep" << G4endl;
  }
  G4cout.precision(prec);
}

References G4VITSteppingVerbose::fStep, G4VITSteppingVerbose::fTrack, G4VITSteppingVerbose::fVerboseLevel, G4BestUnit, G4cout, G4endl, GetIT(), G4VPhysicalVolume::GetName(), G4IT::GetName(), G4Track::GetNextVolume(), G4Track::GetPosition(), G4Track::GetStep(), G4Track::GetTrackID(), CLHEP::prec, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

◆ VerboseParticleChange()

void G4ITSteppingVerbose::VerboseParticleChange ( )

virtual

Implements G4VITSteppingVerbose.

Definition at line 912 of file G4ITSteppingVerbose.cc.

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

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

Referenced by AlongStepDoItOneByOne(), and PostStepDoItOneByOne().

◆ VerboseTrack()

void G4ITSteppingVerbose::VerboseTrack ( )

virtual

Implements G4VITSteppingVerbose.

Definition at line 763 of file G4ITSteppingVerbose.cc.

{
  if(fVerboseLevel == 0)
  {
    return;
  }
 
  CopyState();
// Show header
  G4cout << G4endl;
  G4cout << "    ++G4Track Information " << G4endl;
  G4int 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() != 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;
#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() == 0)
  {
    G4cout << " Event Generator" << G4endl;
  }
  else
  {
    G4cout << fTrack->GetCreatorProcess()->GetProcessName() << G4endl;
  }
 
  G4cout << "      -----------------------------------------------" << G4endl;
 
  G4cout.precision(prec);
}

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

Referenced by StepInfo(), and StepInfoForLeadingTrack().

Field Documentation

◆ baseDir

G4UIdirectory* G4UImessenger::baseDir = nullptr

protectedinherited

Definition at line 102 of file G4UImessenger.hh.

Referenced by G4UImessenger::CreateDirectory(), and G4UImessenger::~G4UImessenger().

◆ baseDirName

G4String G4UImessenger::baseDirName = ""

protectedinherited

Definition at line 103 of file G4UImessenger.hh.

Referenced by G4UImessenger::CreateCommand(), and G4UImessenger::CreateDirectory().

◆ commandsShouldBeInMaster

G4bool G4UImessenger::commandsShouldBeInMaster = false

protectedinherited

Definition at line 104 of file G4UImessenger.hh.

Referenced by G4UImessenger::CommandsShouldBeInMaster(), and G4GeneralParticleSourceMessenger::G4GeneralParticleSourceMessenger().

◆ fAlongStepDoItVector

G4ProcessVector* G4VITSteppingVerbose::fAlongStepDoItVector

protectedinherited

Definition at line 158 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ fAlongStepGetPhysIntVector

G4ProcessVector* G4VITSteppingVerbose::fAlongStepGetPhysIntVector

protectedinherited

Definition at line 162 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ fAtRestDoItProcTriggered

size_t G4VITSteppingVerbose::fAtRestDoItProcTriggered

protectedinherited

Definition at line 169 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ fAtRestDoItVector

G4ProcessVector* G4VITSteppingVerbose::fAtRestDoItVector

protectedinherited

Definition at line 157 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ fAtRestGetPhysIntVector

G4ProcessVector* G4VITSteppingVerbose::fAtRestGetPhysIntVector

protectedinherited

Definition at line 161 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ fCondition

G4ForceCondition G4VITSteppingVerbose::fCondition

protectedinherited

Definition at line 195 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), DPSLPostStep(), G4VITSteppingVerbose::G4VITSteppingVerbose(), and PostStepDoItAllDone().

◆ fCurrentProcess

const G4VITProcess* G4VITSteppingVerbose::fCurrentProcess

protectedinherited

Definition at line 153 of file G4VITSteppingVerbose.hh.

Referenced by AlongStepDoItOneByOne(), AtRestDoItOneByOne(), G4VITSteppingVerbose::CopyState(), DPSLAlongStep(), DPSLPostStep(), G4VITSteppingVerbose::G4VITSteppingVerbose(), and PostStepDoItOneByOne().

◆ fCurrentVolume

const G4VPhysicalVolume* G4VITSteppingVerbose::fCurrentVolume

protectedinherited

Definition at line 151 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ fGPILSelection

G4GPILSelection G4VITSteppingVerbose::fGPILSelection

protectedinherited

Definition at line 196 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), DPSLAlongStep(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ fN2ndariesAlongStepDoIt

G4int G4VITSteppingVerbose::fN2ndariesAlongStepDoIt

protectedinherited

Definition at line 173 of file G4VITSteppingVerbose.hh.

Referenced by AlongStepDoItOneByOne(), G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::G4VITSteppingVerbose(), StepInfo(), and StepInfoForLeadingTrack().

◆ fN2ndariesAtRestDoIt

G4int G4VITSteppingVerbose::fN2ndariesAtRestDoIt

protectedinherited

Definition at line 172 of file G4VITSteppingVerbose.hh.

Referenced by AtRestDoItInvoked(), G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::G4VITSteppingVerbose(), StepInfo(), and StepInfoForLeadingTrack().

◆ fN2ndariesPostStepDoIt

G4int G4VITSteppingVerbose::fN2ndariesPostStepDoIt

protectedinherited

Definition at line 174 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::G4VITSteppingVerbose(), PostStepDoItOneByOne(), StepInfo(), and StepInfoForLeadingTrack().

◆ fParticleChange

const G4VParticleChange* G4VITSteppingVerbose::fParticleChange

protectedinherited

Definition at line 144 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::G4VITSteppingVerbose(), and VerboseParticleChange().

◆ fPostStepDoItProcTriggered

size_t G4VITSteppingVerbose::fPostStepDoItProcTriggered

protectedinherited

Definition at line 170 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ fPostStepDoItVector

G4ProcessVector* G4VITSteppingVerbose::fPostStepDoItVector

protectedinherited

Definition at line 159 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ fPostStepGetPhysIntVector

G4ProcessVector* G4VITSteppingVerbose::fPostStepGetPhysIntVector

protectedinherited

Definition at line 163 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ fPostStepPoint

G4StepPoint* G4VITSteppingVerbose::fPostStepPoint

protectedinherited

Definition at line 149 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ fpProcessGeneralInfo

const ProcessGeneralInfo* G4VITSteppingVerbose::fpProcessGeneralInfo

protectedinherited

Definition at line 139 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ fPreStepPoint

G4StepPoint* G4VITSteppingVerbose::fPreStepPoint

protectedinherited

Definition at line 148 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ fPreviousStepSize

G4double G4VITSteppingVerbose::fPreviousStepSize

protectedinherited

Definition at line 188 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ fpState

G4ITStepProcessorState* G4VITSteppingVerbose::fpState

protectedinherited

Definition at line 138 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ fpStepProcessor

const G4ITStepProcessor* G4VITSteppingVerbose::fpStepProcessor

protectedinherited

Definition at line 135 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::G4VITSteppingVerbose(), and G4VITSteppingVerbose::SetStepProcessor().

◆ fpVerboseUI

G4UIcmdWithAnInteger* G4VITSteppingVerbose::fpVerboseUI

protectedinherited

Definition at line 137 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::G4VITSteppingVerbose(), G4VITSteppingVerbose::SetNewValue(), and G4VITSteppingVerbose::~G4VITSteppingVerbose().

◆ fSecondary

const G4TrackVector* G4VITSteppingVerbose::fSecondary

protectedinherited

Definition at line 146 of file G4VITSteppingVerbose.hh.

Referenced by AlongStepDoItAllDone(), AlongStepDoItOneByOne(), AtRestDoItInvoked(), G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::G4VITSteppingVerbose(), PostStepDoItAllDone(), PostStepDoItOneByOne(), StepInfo(), and StepInfoForLeadingTrack().

◆ fSelectedAtRestDoItVector

G4SelectedAtRestDoItVector* G4VITSteppingVerbose::fSelectedAtRestDoItVector

protectedinherited

Definition at line 185 of file G4VITSteppingVerbose.hh.

Referenced by AtRestDoItInvoked(), G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ fSelectedPostStepDoItVector

G4SelectedPostStepDoItVector* G4VITSteppingVerbose::fSelectedPostStepDoItVector

protectedinherited

Definition at line 186 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::G4VITSteppingVerbose(), and PostStepDoItAllDone().

◆ fStep

const G4Step* G4VITSteppingVerbose::fStep

protectedinherited

Definition at line 147 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::G4VITSteppingVerbose(), ShowStep(), StepInfo(), StepInfoForLeadingTrack(), and TrackingStarted().

◆ fStepStatus

G4StepStatus G4VITSteppingVerbose::fStepStatus

protectedinherited

Definition at line 142 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::G4VITSteppingVerbose(), and PostStepDoItAllDone().

◆ fTouchableHandle

G4TouchableHandle G4VITSteppingVerbose::fTouchableHandle

protectedinherited

Definition at line 190 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ fTrack

const G4Track* G4VITSteppingVerbose::fTrack

protectedinherited

Definition at line 145 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::G4VITSteppingVerbose(), StepInfo(), StepInfoForLeadingTrack(), TrackingStarted(), and VerboseTrack().

◆ fVerboseLevel

G4int G4VITSteppingVerbose::fVerboseLevel

protectedinherited

◆ MAXofAlongStepLoops

size_t G4VITSteppingVerbose::MAXofAlongStepLoops

protectedinherited

Definition at line 166 of file G4VITSteppingVerbose.hh.

Referenced by AlongStepDoItAllDone(), G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ MAXofAtRestLoops

size_t G4VITSteppingVerbose::MAXofAtRestLoops

protectedinherited

Definition at line 165 of file G4VITSteppingVerbose.hh.

Referenced by AtRestDoItInvoked(), G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ MAXofPostStepLoops

size_t G4VITSteppingVerbose::MAXofPostStepLoops

protectedinherited

Definition at line 167 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), G4VITSteppingVerbose::G4VITSteppingVerbose(), and PostStepDoItAllDone().

◆ PhysicalStep

G4double G4VITSteppingVerbose::PhysicalStep

protectedinherited

Definition at line 141 of file G4VITSteppingVerbose.hh.

Referenced by G4VITSteppingVerbose::CopyState(), and G4VITSteppingVerbose::G4VITSteppingVerbose().

◆ physIntLength

G4double G4VITSteppingVerbose::physIntLength

protectedinherited

Definition at line 194 of file G4VITSteppingVerbose.hh.

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

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

source/processes/electromagnetic/dna/management/include/G4ITSteppingVerbose.hh
source/processes/electromagnetic/dna/management/src/G4ITSteppingVerbose.cc

Public Member Functions

Protected Types

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ G4SelectedAlongStepDoItVector

◆ G4SelectedAtRestDoItVector

◆ G4SelectedPostStepDoItVector

Constructor & Destructor Documentation

◆ G4ITSteppingVerbose()

◆ ~G4ITSteppingVerbose()

Member Function Documentation

◆ AddUIcommand()

◆ AlongStepDoItAllDone()

◆ AlongStepDoItOneByOne()

◆ AtRestDoItInvoked()

◆ AtRestDoItOneByOne()

◆ BtoS()

◆ CommandsShouldBeInMaster()

◆ CopyState()

◆ CreateCommand()

◆ CreateDirectory()

◆ DoItStarted()

◆ DPSLAlongStep()

◆ DPSLPostStep()

◆ DPSLStarted()

◆ DPSLUserLimit()

◆ DtoS()

◆ GetCurrentValue()

◆ GetVerbose()

◆ ItoS()

◆ NewStep()

◆ operator!=()

◆ operator==()

◆ PostStepDoItAllDone()

◆ PostStepDoItOneByOne()

◆ PostStepVerbose()

◆ PreStepVerbose()

◆ SetNewValue()

◆ SetStepProcessor()

◆ SetVerbose()

◆ ShowStep()

◆ StepInfo()

◆ StepInfoForLeadingTrack()

◆ StoB()

◆ StoD()

◆ StoI()

◆ StoL()

◆ TrackBanner()

◆ TrackingEnded()

◆ TrackingStarted()

◆ VerboseParticleChange()

◆ VerboseTrack()

Field Documentation

◆ baseDir

◆ baseDirName

◆ commandsShouldBeInMaster

◆ fAlongStepDoItVector

◆ fAlongStepGetPhysIntVector

◆ fAtRestDoItProcTriggered

◆ fAtRestDoItVector

◆ fAtRestGetPhysIntVector

◆ fCondition

◆ fCurrentProcess

◆ fCurrentVolume

◆ fGPILSelection

◆ fN2ndariesAlongStepDoIt

◆ fN2ndariesAtRestDoIt

◆ fN2ndariesPostStepDoIt

◆ fParticleChange

◆ fPostStepDoItProcTriggered

◆ fPostStepDoItVector

◆ fPostStepGetPhysIntVector

◆ fPostStepPoint

◆ fpProcessGeneralInfo

◆ fPreStepPoint

◆ fPreviousStepSize

◆ fpState