#include <G4SteppingManager.hh>

Public Types
using	ProfilerConfig = G4Step::ProfilerConfig

Public Member Functions
	G4SteppingManager ()

G4double	GetCorrectedStep ()

G4double	GetcurrentMinimumStep ()

std::size_t	GetfAlongStepDoItProcTriggered ()

G4ProcessVector *	GetfAlongStepDoItVector ()

G4ProcessVector *	GetfAlongStepGetPhysIntVector ()

std::size_t	GetfAtRestDoItProcTriggered ()

G4ProcessVector *	GetfAtRestDoItVector ()

G4ProcessVector *	GetfAtRestGetPhysIntVector ()

G4ForceCondition	GetfCondition ()

G4VProcess *	GetfCurrentProcess ()

G4VPhysicalVolume *	GetfCurrentVolume ()

G4GPILSelection	GetfGPILSelection ()

G4bool	GetFirstStep ()

G4int	GetfN2ndariesAlongStepDoIt ()

G4int	GetfN2ndariesAtRestDoIt ()

G4int	GetfN2ndariesPostStepDoIt ()

G4Navigator *	GetfNavigator ()

G4VParticleChange *	GetfParticleChange ()

std::size_t	GetfPostStepDoItProcTriggered ()

G4ProcessVector *	GetfPostStepDoItVector ()

G4ProcessVector *	GetfPostStepGetPhysIntVector ()

G4StepPoint *	GetfPostStepPoint ()

G4StepPoint *	GetfPreStepPoint ()

G4double	GetfPreviousStepSize ()

G4TrackVector *	GetfSecondary ()

G4SelectedAlongStepDoItVector *	GetfSelectedAlongStepDoItVector ()

G4SelectedAtRestDoItVector *	GetfSelectedAtRestDoItVector ()

G4SelectedPostStepDoItVector *	GetfSelectedPostStepDoItVector ()

G4VSensitiveDetector *	GetfSensitive ()

G4Step *	GetfStep ()

G4StepStatus	GetfStepStatus ()

G4Track *	GetfTrack ()

G4double	GetGeometricalStep ()

G4double	GetMass ()

std::size_t	GetMAXofAlongStepLoops ()

std::size_t	GetMAXofAtRestLoops ()

std::size_t	GetMAXofPostStepLoops ()

G4double	GetnumberOfInteractionLengthLeft ()

G4double	GetPhysicalStep ()

G4double	GetphysIntLength ()

G4bool	GetPreStepPointIsGeom ()

void	GetProcessNumber ()

const G4TrackVector *	GetSecondary () const

G4Step *	GetStep () const

G4SteppingControl	GetStepControlFlag ()

G4double	GetsumEnergyChange ()

G4double	GetTempInitVelocity ()

G4double	GetTempVelocity ()

const G4TouchableHandle &	GetTouchableHandle ()

G4Track *	GetTrack () const

G4UserSteppingAction *	GetUserAction ()

G4int	GetverboseLevel ()

void	SetInitialStep (G4Track *valueTrack)

void	SetNavigator (G4Navigator *value)

void	SetUserAction (G4UserSteppingAction *apAction)

void	SetVerbose (G4VSteppingVerbose *)

void	SetVerboseLevel (G4int vLevel)

G4StepStatus	Stepping ()

	~G4SteppingManager ()

Private Member Functions
void	ApplyProductionCut (G4Track *)

G4double	CalculateSafety ()

void	DefinePhysicalStepLength ()

void	InvokeAlongStepDoItProcs ()

void	InvokeAtRestDoItProcs ()

void	InvokePostStepDoItProcs ()

void	InvokePSDIP (size_t)

Private Attributes
G4double	CorrectedStep = 0.0

G4double	endpointSafety = 0.0

G4ThreeVector	endpointSafOrigin

std::size_t	fAlongStepDoItProcTriggered = 0

G4ProcessVector *	fAlongStepDoItVector = nullptr

G4ProcessVector *	fAlongStepGetPhysIntVector = nullptr

std::size_t	fAtRestDoItProcTriggered = 0

G4ProcessVector *	fAtRestDoItVector = nullptr

G4ProcessVector *	fAtRestGetPhysIntVector = nullptr

G4ForceCondition	fCondition = InActivated

G4VProcess *	fCurrentProcess = nullptr

G4VPhysicalVolume *	fCurrentVolume = nullptr

G4GPILSelection	fGPILSelection = NotCandidateForSelection

G4bool	FirstStep = false

G4int	fN2ndariesAlongStepDoIt = 0

G4int	fN2ndariesAtRestDoIt = 0

G4int	fN2ndariesPostStepDoIt = 0

G4Navigator *	fNavigator = nullptr

G4NoProcess const *	fNoProcess = nullptr

G4VParticleChange *	fParticleChange = nullptr

std::size_t	fPostStepDoItProcTriggered = 0

G4ProcessVector *	fPostStepDoItVector = nullptr

G4ProcessVector *	fPostStepGetPhysIntVector = nullptr

G4StepPoint *	fPostStepPoint = nullptr

G4StepPoint *	fPreStepPoint = nullptr

G4double	fPreviousStepSize = 0.0

G4TrackVector *	fSecondary = nullptr

G4SelectedAlongStepDoItVector *	fSelectedAlongStepDoItVector = nullptr

G4SelectedAtRestDoItVector *	fSelectedAtRestDoItVector = nullptr

G4SelectedPostStepDoItVector *	fSelectedPostStepDoItVector = nullptr

G4VSensitiveDetector *	fSensitive = nullptr

G4Step *	fStep = nullptr

G4StepStatus	fStepStatus = fUndefined

G4TouchableHandle	fTouchableHandle

G4Track *	fTrack = nullptr

G4UserSteppingAction *	fUserSteppingAction = nullptr

G4VSteppingVerbose *	fVerbose = nullptr

G4double	GeometricalStep = 0.0

G4double	kCarTolerance = 0.0

G4bool	KillVerbose = false

G4double	Mass = 0.0

std::size_t	MAXofAlongStepLoops = 0

std::size_t	MAXofAtRestLoops = 0

std::size_t	MAXofPostStepLoops = 0

G4double	PhysicalStep = 0.0

G4double	physIntLength = 0.0

G4bool	PreStepPointIsGeom = false

G4double	proposedSafety = 0.0

G4SteppingControl	StepControlFlag = NormalCondition

G4double	sumEnergyChange = 0.0

G4double	TempInitVelocity = 0.0

G4double	TempVelocity = 0.0

G4int	verboseLevel = 0

Static Private Attributes
static const size_t	SizeOfSelectedDoItVector = 100

Detailed Description

Definition at line 75 of file G4SteppingManager.hh.

Member Typedef Documentation

◆ ProfilerConfig

using G4SteppingManager::ProfilerConfig = G4Step::ProfilerConfig

Definition at line 78 of file G4SteppingManager.hh.

Constructor & Destructor Documentation

◆ G4SteppingManager()

G4SteppingManager::G4SteppingManager ( )

Definition at line 49 of file G4SteppingManager.cc.

{
  // Construct simple 'has-a' related objects
 
  fStep = new G4Step();
  fSecondary = fStep->NewSecondaryVector();
  fPreStepPoint  = fStep->GetPreStepPoint();
  fPostStepPoint = fStep->GetPostStepPoint();
 
#ifdef G4VERBOSE
  fVerbose = G4VSteppingVerbose::GetInstance();
  if(fVerbose==nullptr)
  {
    if(G4VSteppingVerbose::GetMasterInstance()==nullptr)
    {
      G4int prec = G4SteppingVerbose::BestUnitPrecision();
      if(prec > 0)
      { fVerbose = new G4SteppingVerboseWithUnits(prec); }
      else
      { fVerbose = new G4SteppingVerbose(); }
    }
    else
    { fVerbose = G4VSteppingVerbose::GetMasterInstance()->Clone(); }
    KillVerbose = true;
  }
  else
  { KillVerbose = false; }
  fVerbose -> SetManager(this);
#endif
 
   SetNavigator(G4TransportationManager::GetTransportationManager()
                ->GetNavigatorForTracking());
 
   fSelectedAtRestDoItVector
      = new G4SelectedAtRestDoItVector(SizeOfSelectedDoItVector,0);
   fSelectedAlongStepDoItVector
      = new G4SelectedAlongStepDoItVector(SizeOfSelectedDoItVector,0);
   fSelectedPostStepDoItVector
      = new G4SelectedPostStepDoItVector(SizeOfSelectedDoItVector,0);
 
   SetNavigator(G4TransportationManager::GetTransportationManager()
     ->GetNavigatorForTracking());
 
   physIntLength = DBL_MAX; 
   kCarTolerance = 0.5*G4GeometryTolerance::GetInstance()
                 ->GetSurfaceTolerance();
 
   fNoProcess = new G4NoProcess;
}

References G4SteppingVerbose::BestUnitPrecision(), G4VSteppingVerbose::Clone(), DBL_MAX, fNoProcess, fPostStepPoint, fPreStepPoint, fSecondary, fSelectedAlongStepDoItVector, fSelectedAtRestDoItVector, fSelectedPostStepDoItVector, fStep, fVerbose, G4GeometryTolerance::GetInstance(), G4VSteppingVerbose::GetInstance(), G4VSteppingVerbose::GetMasterInstance(), G4Step::GetPostStepPoint(), G4Step::GetPreStepPoint(), G4GeometryTolerance::GetSurfaceTolerance(), G4TransportationManager::GetTransportationManager(), kCarTolerance, KillVerbose, G4Step::NewSecondaryVector(), physIntLength, CLHEP::prec, SetNavigator(), and SizeOfSelectedDoItVector.

◆ ~G4SteppingManager()

G4SteppingManager::~G4SteppingManager ( )

Definition at line 101 of file G4SteppingManager.cc.

{
  fTouchableHandle = 0;
 
  // Destruct simple 'has-a' objects
  //
  fStep->DeleteSecondaryVector();
 
  // delete fSecondary;
  delete fStep;
  delete fSelectedAtRestDoItVector;
  delete fSelectedAlongStepDoItVector;
  delete fSelectedPostStepDoItVector;
  delete fUserSteppingAction;
  #ifdef G4VERBOSE
    if(KillVerbose) delete fVerbose;
  #endif
}

References G4Step::DeleteSecondaryVector(), fSelectedAlongStepDoItVector, fSelectedAtRestDoItVector, fSelectedPostStepDoItVector, fStep, fTouchableHandle, fUserSteppingAction, fVerbose, and KillVerbose.

Member Function Documentation

◆ ApplyProductionCut()

void G4SteppingManager::ApplyProductionCut ( G4Track * aSecondary )

private

Definition at line 711 of file G4SteppingManager2.cc.

{
  G4bool tBelowCutEnergyAndSafety = false;
  G4int tPtclIdx
    = G4ProductionCuts::GetIndex(aSecondary->GetDefinition());
  if (tPtclIdx<0)  { return; }
  G4ProductionCutsTable* tCutsTbl
    = G4ProductionCutsTable::GetProductionCutsTable();
  G4int tCoupleIdx
    = tCutsTbl->GetCoupleIndex(fPreStepPoint->GetMaterialCutsCouple());
  if (tCoupleIdx<0)  { return; }
  G4double tProdThreshold
    = (*(tCutsTbl->GetEnergyCutsVector(tPtclIdx)))[tCoupleIdx];
  if( aSecondary->GetKineticEnergy()<tProdThreshold )
  {
    tBelowCutEnergyAndSafety = true;
    if(std::abs(aSecondary->GetDynamicParticle()->GetCharge()) > DBL_MIN)
    {
      G4double currentRange
        = G4LossTableManager::Instance()->GetRange(aSecondary->GetDefinition(),
                 aSecondary->GetKineticEnergy(),
                 fPreStepPoint->GetMaterialCutsCouple());
      tBelowCutEnergyAndSafety = (currentRange < CalculateSafety() );
    }
  }
 
  if( tBelowCutEnergyAndSafety )
  {
    if( !(aSecondary->IsGoodForTracking()) )
    {
      // Add kinetic energy to the total energy deposit
      fStep->AddTotalEnergyDeposit( aSecondary->GetKineticEnergy() );
      aSecondary->SetKineticEnergy(0.0);
    }
  }
}

References G4Step::AddTotalEnergyDeposit(), CalculateSafety(), DBL_MIN, fPreStepPoint, fStep, G4DynamicParticle::GetCharge(), G4ProductionCutsTable::GetCoupleIndex(), G4Track::GetDefinition(), G4Track::GetDynamicParticle(), G4ProductionCutsTable::GetEnergyCutsVector(), G4ProductionCuts::GetIndex(), G4Track::GetKineticEnergy(), G4StepPoint::GetMaterialCutsCouple(), G4ProductionCutsTable::GetProductionCutsTable(), G4LossTableManager::GetRange(), G4LossTableManager::Instance(), G4Track::IsGoodForTracking(), and G4Track::SetKineticEnergy().

Referenced by InvokeAlongStepDoItProcs(), InvokeAtRestDoItProcs(), and InvokePSDIP().

◆ CalculateSafety()

G4double G4SteppingManager::CalculateSafety ( )

inlineprivate

Definition at line 550 of file G4SteppingManager.hh.

  {
    return std::max( endpointSafety -
                (endpointSafOrigin - fPostStepPoint->GetPosition()).mag(),
                kCarTolerance );
  }

References endpointSafety, endpointSafOrigin, fPostStepPoint, G4StepPoint::GetPosition(), kCarTolerance, and G4INCL::Math::max().

Referenced by ApplyProductionCut(), and InvokePSDIP().

◆ DefinePhysicalStepLength()

void G4SteppingManager::DefinePhysicalStepLength ( )

private

Definition at line 126 of file G4SteppingManager2.cc.

{
  // ReSet the counter etc.
  //
  PhysicalStep  = DBL_MAX;          // Initialize by a huge number    
  physIntLength = DBL_MAX;          // Initialize by a huge number    
 
  #ifdef G4VERBOSE
    if(verboseLevel>0) fVerbose->DPSLStarted();
  #endif
 
  // GPIL for PostStep
  //
  fPostStepDoItProcTriggered = MAXofPostStepLoops;
 
  for(std::size_t np=0; np<MAXofPostStepLoops; ++np)
  {
    fCurrentProcess = (*fPostStepGetPhysIntVector)(np);
    if (fCurrentProcess == nullptr)
    {
      (*fSelectedPostStepDoItVector)[np] = InActivated;
      continue;
    } // NULL means the process is inactivated by a user on fly
 
    physIntLength = fCurrentProcess->PostStepGPIL( *fTrack,
                                     fPreviousStepSize, &fCondition );
    #ifdef G4VERBOSE
      if(verboseLevel>0) fVerbose->DPSLPostStep();
    #endif
 
    switch (fCondition)
    {
      case ExclusivelyForced:
        (*fSelectedPostStepDoItVector)[np] = ExclusivelyForced;
        fStepStatus = fExclusivelyForcedProc;
        fStep->GetPostStepPoint()->SetProcessDefinedStep(fCurrentProcess);
        break;
      case Conditionally:
        // (*fSelectedPostStepDoItVector)[np] = Conditionally;
        G4Exception("G4SteppingManager::DefinePhysicalStepLength()",
                    "Tracking1001", FatalException,
                    "This feature no more supported");
        break;
      case Forced:
        (*fSelectedPostStepDoItVector)[np] = Forced;
        break;
      case StronglyForced:
        (*fSelectedPostStepDoItVector)[np] = StronglyForced;
        break;
      default:
        (*fSelectedPostStepDoItVector)[np] = InActivated;
        break;
    }
 
    if (fCondition==ExclusivelyForced)
    { 
      for(std::size_t nrest=np+1; nrest<MAXofPostStepLoops; ++nrest)
      { 
        (*fSelectedPostStepDoItVector)[nrest] = InActivated; 
      } 
      return;  // Take note the 'return' at here !!! 
    } 
    else
    {
      if(physIntLength < PhysicalStep )
      {
        PhysicalStep = physIntLength;
        fStepStatus = fPostStepDoItProc;
        fPostStepDoItProcTriggered = G4int(np);
        fStep->GetPostStepPoint()->SetProcessDefinedStep(fCurrentProcess);
      }
    }
  }
 
  if (fPostStepDoItProcTriggered<MAXofPostStepLoops)
  {
    if ((*fSelectedPostStepDoItVector)[fPostStepDoItProcTriggered] == InActivated)
    {
      (*fSelectedPostStepDoItVector)[fPostStepDoItProcTriggered] = NotForced;
    }
  }
 
  // GPIL for AlongStep
  //
  proposedSafety = DBL_MAX;
  G4double safetyProposedToAndByProcess = proposedSafety;
  G4bool delegateToTransportation = false;
 
  for(std::size_t kp=0; kp<MAXofAlongStepLoops; ++kp)
  {
    fCurrentProcess = (*fAlongStepGetPhysIntVector)[kp];
    if (fCurrentProcess == nullptr) continue;
      // NULL means the process is inactivated by a user on fly
 
    physIntLength = fCurrentProcess->AlongStepGPIL( *fTrack,
                                     fPreviousStepSize, PhysicalStep,
                                     safetyProposedToAndByProcess,
                                     &fGPILSelection );
    #ifdef G4VERBOSE
      if(verboseLevel>0) fVerbose->DPSLAlongStep();
    #endif
 
    if(physIntLength < PhysicalStep)
    {
      PhysicalStep = physIntLength;
 
      // Check if the process wants to be the GPIL winner. For example,
      // multi-scattering proposes Step limit, but won't be the winner
      //
      if(fGPILSelection==CandidateForSelection)
      {
        fStepStatus = fAlongStepDoItProc;
        fStep->GetPostStepPoint()->SetProcessDefinedStep(fCurrentProcess);
      }
      else if(fCurrentProcess->GetProcessType()==fParallel)
      { // a parallel world is proposing the shortest but expecting Transportation
        // to win.
        delegateToTransportation = true;
      }
 
      // Transportation is assumed to be the last process in the vector
      // Transportation is winning
      if(kp == MAXofAlongStepLoops-1) 
      {
        fStepStatus = fGeomBoundary;
        delegateToTransportation = false;
      }
    }
 
    // Make sure to check the safety, even if Step is not limited 
    // by this process
    // 
    if (safetyProposedToAndByProcess < proposedSafety)
    {
      // proposedSafety keeps the smallest value
      //
      proposedSafety = safetyProposedToAndByProcess;
    }
    else
    {
      // safetyProposedToAndByProcess always proposes a valid safety
      //
      safetyProposedToAndByProcess = proposedSafety;
    }
  } 
  if(delegateToTransportation)
  {
    fStepStatus = fGeomBoundary;
    fStep->GetPostStepPoint()->SetProcessDefinedStep(fCurrentProcess);
  }
}

References G4VProcess::AlongStepGPIL(), CandidateForSelection, Conditionally, DBL_MAX, G4VSteppingVerbose::DPSLAlongStep(), G4VSteppingVerbose::DPSLPostStep(), G4VSteppingVerbose::DPSLStarted(), ExclusivelyForced, fAlongStepDoItProc, FatalException, fCondition, fCurrentProcess, fExclusivelyForcedProc, fGeomBoundary, fGPILSelection, Forced, fParallel, fPostStepDoItProc, fPostStepDoItProcTriggered, fPreviousStepSize, fSelectedPostStepDoItVector, fStep, fStepStatus, fTrack, fVerbose, G4Exception(), G4Step::GetPostStepPoint(), G4VProcess::GetProcessType(), InActivated, MAXofAlongStepLoops, MAXofPostStepLoops, NotForced, PhysicalStep, physIntLength, G4VProcess::PostStepGPIL(), proposedSafety, G4StepPoint::SetProcessDefinedStep(), StronglyForced, and verboseLevel.

Referenced by Stepping().

◆ GetCorrectedStep()

G4double G4SteppingManager::GetCorrectedStep ( )

inline

Definition at line 292 of file G4SteppingManager.hh.

  {
    return CorrectedStep;
  }

References CorrectedStep.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetcurrentMinimumStep()

G4double G4SteppingManager::GetcurrentMinimumStep ( )

◆ GetfAlongStepDoItProcTriggered()

size_t G4SteppingManager::GetfAlongStepDoItProcTriggered ( )

inline

Definition at line 427 of file G4SteppingManager.hh.

  {
    return fAtRestDoItProcTriggered;
  }

References fAtRestDoItProcTriggered.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfAlongStepDoItVector()

G4ProcessVector * G4SteppingManager::GetfAlongStepDoItVector ( )

inline

Definition at line 382 of file G4SteppingManager.hh.

  {
    return fAlongStepDoItVector;
  }

References fAlongStepDoItVector.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfAlongStepGetPhysIntVector()

G4ProcessVector * G4SteppingManager::GetfAlongStepGetPhysIntVector ( )

inline

Definition at line 397 of file G4SteppingManager.hh.

  {
    return fAlongStepGetPhysIntVector;
  }

References fAlongStepGetPhysIntVector.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfAtRestDoItProcTriggered()

size_t G4SteppingManager::GetfAtRestDoItProcTriggered ( )

inline

Definition at line 422 of file G4SteppingManager.hh.

  {
    return fAtRestDoItProcTriggered;
  }

References fAtRestDoItProcTriggered.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfAtRestDoItVector()

G4ProcessVector * G4SteppingManager::GetfAtRestDoItVector ( )

inline

Definition at line 377 of file G4SteppingManager.hh.

  {
    return fAtRestDoItVector;
  }

References fAtRestDoItVector.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfAtRestGetPhysIntVector()

G4ProcessVector * G4SteppingManager::GetfAtRestGetPhysIntVector ( )

inline

Definition at line 392 of file G4SteppingManager.hh.

  {
    return fAtRestGetPhysIntVector;
  }

References fAtRestGetPhysIntVector.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfCondition()

G4ForceCondition G4SteppingManager::GetfCondition ( )

inline

Definition at line 500 of file G4SteppingManager.hh.

  {
    return fCondition;
  }

References fCondition.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfCurrentProcess()

G4VProcess * G4SteppingManager::GetfCurrentProcess ( )

inline

Definition at line 372 of file G4SteppingManager.hh.

  {
    return fCurrentProcess;
  }

References fCurrentProcess.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfCurrentVolume()

G4VPhysicalVolume * G4SteppingManager::GetfCurrentVolume ( )

inline

Definition at line 362 of file G4SteppingManager.hh.

  {
    return fCurrentVolume;
  }

References fCurrentVolume.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfGPILSelection()

G4GPILSelection G4SteppingManager::GetfGPILSelection ( )

inline

Definition at line 505 of file G4SteppingManager.hh.

  {
    return fGPILSelection;
  }

References fGPILSelection.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetFirstStep()

G4bool G4SteppingManager::GetFirstStep ( )

inline

Definition at line 302 of file G4SteppingManager.hh.

  {
    return FirstStep;
  }

References FirstStep.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfN2ndariesAlongStepDoIt()

G4int G4SteppingManager::GetfN2ndariesAlongStepDoIt ( )

inline

Definition at line 442 of file G4SteppingManager.hh.

  {
    return fN2ndariesAlongStepDoIt;
  }

References fN2ndariesAlongStepDoIt.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfN2ndariesAtRestDoIt()

G4int G4SteppingManager::GetfN2ndariesAtRestDoIt ( )

inline

Definition at line 437 of file G4SteppingManager.hh.

  {
    return fN2ndariesAtRestDoIt;
  }

References fN2ndariesAtRestDoIt.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfN2ndariesPostStepDoIt()

G4int G4SteppingManager::GetfN2ndariesPostStepDoIt ( )

inline

Definition at line 447 of file G4SteppingManager.hh.

  {
    return fN2ndariesPostStepDoIt;
  }

References fN2ndariesPostStepDoIt.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfNavigator()

G4Navigator * G4SteppingManager::GetfNavigator ( )

inline

Definition at line 452 of file G4SteppingManager.hh.

  {
    return fNavigator;
  }

References fNavigator.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfParticleChange()

G4VParticleChange * G4SteppingManager::GetfParticleChange ( )

inline

Definition at line 332 of file G4SteppingManager.hh.

  {
    return fParticleChange;
  }

References fParticleChange.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfPostStepDoItProcTriggered()

size_t G4SteppingManager::GetfPostStepDoItProcTriggered ( )

inline

Definition at line 432 of file G4SteppingManager.hh.

  {
    return fPostStepDoItProcTriggered;
  }

References fPostStepDoItProcTriggered.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfPostStepDoItVector()

G4ProcessVector * G4SteppingManager::GetfPostStepDoItVector ( )

inline

Definition at line 387 of file G4SteppingManager.hh.

  {
    return fPostStepDoItVector;
  }

References fPostStepDoItVector.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfPostStepGetPhysIntVector()

G4ProcessVector * G4SteppingManager::GetfPostStepGetPhysIntVector ( )

inline

Definition at line 402 of file G4SteppingManager.hh.

  {
    return fPostStepGetPhysIntVector;
  }

References fPostStepGetPhysIntVector.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfPostStepPoint()

G4StepPoint * G4SteppingManager::GetfPostStepPoint ( )

inline

Definition at line 357 of file G4SteppingManager.hh.

  {
    return fPostStepPoint;
  }

References fPostStepPoint.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfPreStepPoint()

G4StepPoint * G4SteppingManager::GetfPreStepPoint ( )

inline

Definition at line 352 of file G4SteppingManager.hh.

  {
    return fPreStepPoint;
  }

References fPreStepPoint.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfPreviousStepSize()

G4double G4SteppingManager::GetfPreviousStepSize ( )

inline

Definition at line 480 of file G4SteppingManager.hh.

  {
    return fPreviousStepSize;
  }

References fPreviousStepSize.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfSecondary()

G4TrackVector * G4SteppingManager::GetfSecondary ( )

inline

Definition at line 342 of file G4SteppingManager.hh.

  {
    return fStep->GetfSecondary();
  }

References fStep, and G4Step::GetfSecondary().

Referenced by G4VSteppingVerbose::CopyState(), and G4TrackingManager::GimmeSecondaries().

◆ GetfSelectedAlongStepDoItVector()

G4SelectedAlongStepDoItVector * G4SteppingManager::GetfSelectedAlongStepDoItVector ( )

inline

Definition at line 469 of file G4SteppingManager.hh.

  {
    return fSelectedAlongStepDoItVector;
  }

References fSelectedAlongStepDoItVector.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfSelectedAtRestDoItVector()

G4SelectedAtRestDoItVector * G4SteppingManager::GetfSelectedAtRestDoItVector ( )

inline

Definition at line 463 of file G4SteppingManager.hh.

  {
    return fSelectedAtRestDoItVector;
  }

References fSelectedAtRestDoItVector.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfSelectedPostStepDoItVector()

G4SelectedPostStepDoItVector * G4SteppingManager::GetfSelectedPostStepDoItVector ( )

inline

Definition at line 475 of file G4SteppingManager.hh.

  {
    return fSelectedPostStepDoItVector;
  }

References fSelectedPostStepDoItVector.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfSensitive()

G4VSensitiveDetector * G4SteppingManager::GetfSensitive ( )

inline

Definition at line 367 of file G4SteppingManager.hh.

  {
    return fSensitive;
  }

References fSensitive.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfStep()

G4Step * G4SteppingManager::GetfStep ( )

inline

Definition at line 347 of file G4SteppingManager.hh.

  {
    return fStep;
  }

References fStep.

Referenced by G4VSteppingVerbose::CopyState(), and G4ExceptionHandler::DumpTrackInfo().

◆ GetfStepStatus()

G4StepStatus G4SteppingManager::GetfStepStatus ( )

inline

Definition at line 307 of file G4SteppingManager.hh.

  {
    return fStepStatus;
  }

References fStepStatus.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetfTrack()

G4Track * G4SteppingManager::GetfTrack ( )

inline

Definition at line 337 of file G4SteppingManager.hh.

  {
    return fTrack;
  }

References fTrack.

Referenced by G4VSteppingVerbose::CopyState(), and G4ExceptionHandler::DumpTrackInfo().

◆ GetGeometricalStep()

G4double G4SteppingManager::GetGeometricalStep ( )

inline

Definition at line 287 of file G4SteppingManager.hh.

  {
    return GeometricalStep;
  }

References GeometricalStep.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetMass()

G4double G4SteppingManager::GetMass ( )

inline

Definition at line 322 of file G4SteppingManager.hh.

  {
    return Mass;
  }

References Mass.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetMAXofAlongStepLoops()

size_t G4SteppingManager::GetMAXofAlongStepLoops ( )

inline

Definition at line 412 of file G4SteppingManager.hh.

  {
    return MAXofAlongStepLoops;
  }

References MAXofAlongStepLoops.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetMAXofAtRestLoops()

size_t G4SteppingManager::GetMAXofAtRestLoops ( )

inline

Definition at line 407 of file G4SteppingManager.hh.

  {
    return MAXofAtRestLoops;
  }

References MAXofAtRestLoops.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetMAXofPostStepLoops()

size_t G4SteppingManager::GetMAXofPostStepLoops ( )

inline

Definition at line 417 of file G4SteppingManager.hh.

  {
    return MAXofPostStepLoops;
  }

References MAXofPostStepLoops.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetnumberOfInteractionLengthLeft()

G4double G4SteppingManager::GetnumberOfInteractionLengthLeft ( )

◆ GetPhysicalStep()

G4double G4SteppingManager::GetPhysicalStep ( )

inline

Definition at line 282 of file G4SteppingManager.hh.

  {
    return PhysicalStep;
  }

References PhysicalStep.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetphysIntLength()

G4double G4SteppingManager::GetphysIntLength ( )

inline

Definition at line 495 of file G4SteppingManager.hh.

  {
    return physIntLength;
  }

References physIntLength.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetPreStepPointIsGeom()

G4bool G4SteppingManager::GetPreStepPointIsGeom ( )

inline

Definition at line 297 of file G4SteppingManager.hh.

  {
    return PreStepPointIsGeom;
  }

References PreStepPointIsGeom.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetProcessNumber()

void G4SteppingManager::GetProcessNumber ( )

Definition at line 50 of file G4SteppingManager2.cc.

{
  #ifdef debug
    G4cout << "G4SteppingManager::GetProcessNumber: is called track="
           << fTrack << G4endl;
  #endif
 
  G4ProcessManager* pm= fTrack->GetDefinition()->GetProcessManager();
  if(pm == nullptr)
  {
    G4cerr << "ERROR - G4SteppingManager::GetProcessNumber()" << G4endl
           << "        ProcessManager is NULL for particle = "
           << fTrack->GetDefinition()->GetParticleName() << ", PDG_code = "
           << fTrack->GetDefinition()->GetPDGEncoding() << G4endl;
    G4Exception("G4SteppingManager::GetProcessNumber()", "Tracking0011",
                FatalException, "Process Manager is not found.");
    return;
  }
 
  // AtRestDoits
  //
  MAXofAtRestLoops =        pm->GetAtRestProcessVector()->entries();
  fAtRestDoItVector =       pm->GetAtRestProcessVector(typeDoIt);
  fAtRestGetPhysIntVector = pm->GetAtRestProcessVector(typeGPIL);
 
  #ifdef debug
    G4cout << "G4SteppingManager::GetProcessNumber: #ofAtRest="
           << MAXofAtRestLoops << G4endl;
  #endif
 
  // AlongStepDoits
  //
  MAXofAlongStepLoops = pm->GetAlongStepProcessVector()->entries();
  fAlongStepDoItVector = pm->GetAlongStepProcessVector(typeDoIt);
  fAlongStepGetPhysIntVector = pm->GetAlongStepProcessVector(typeGPIL);
 
  #ifdef debug
    G4cout << "G4SteppingManager::GetProcessNumber:#ofAlongStp="
           << MAXofAlongStepLoops << G4endl;
  #endif
 
  // PostStepDoits
  //
  MAXofPostStepLoops = pm->GetPostStepProcessVector()->entries();
  fPostStepDoItVector = pm->GetPostStepProcessVector(typeDoIt);
  fPostStepGetPhysIntVector = pm->GetPostStepProcessVector(typeGPIL);
 
  #ifdef debug
    G4cout << "G4SteppingManager::GetProcessNumber: #ofPostStep="
           << MAXofPostStepLoops << G4endl;
  #endif
 
  if (SizeOfSelectedDoItVector<MAXofAtRestLoops    ||
      SizeOfSelectedDoItVector<MAXofAlongStepLoops ||
      SizeOfSelectedDoItVector<MAXofPostStepLoops  )
  {
    G4cerr << "ERROR - G4SteppingManager::GetProcessNumber()" << G4endl
           << "        SizeOfSelectedDoItVector= " << SizeOfSelectedDoItVector
           << " ; is smaller then one of MAXofAtRestLoops= "
           << MAXofAtRestLoops << G4endl
           << "        or MAXofAlongStepLoops= " << MAXofAlongStepLoops
           << " or MAXofPostStepLoops= " << MAXofPostStepLoops << G4endl;
    G4Exception("G4SteppingManager::GetProcessNumber()",
                "Tracking0012", FatalException,
                "The array size is smaller than the actual No of processes.");
  }
}

References G4ProcessVector::entries(), fAlongStepDoItVector, fAlongStepGetPhysIntVector, FatalException, fAtRestDoItVector, fAtRestGetPhysIntVector, fPostStepDoItVector, fPostStepGetPhysIntVector, fTrack, G4cerr, G4cout, G4endl, G4Exception(), G4ProcessManager::GetAlongStepProcessVector(), G4ProcessManager::GetAtRestProcessVector(), G4Track::GetDefinition(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGEncoding(), G4ProcessManager::GetPostStepProcessVector(), G4ParticleDefinition::GetProcessManager(), MAXofAlongStepLoops, MAXofAtRestLoops, MAXofPostStepLoops, SizeOfSelectedDoItVector, typeDoIt, and typeGPIL.

Referenced by G4ErrorPropagator::InitG4Track(), and G4TrackingManager::ProcessOneTrack().

◆ GetSecondary()

const G4TrackVector * G4SteppingManager::GetSecondary ( ) const

inline

Definition at line 510 of file G4SteppingManager.hh.

  {
    return fStep->GetSecondary(); 
  }

References fStep, and G4Step::GetSecondary().

◆ GetStep()

G4Step * G4SteppingManager::GetStep ( ) const

inline

Definition at line 545 of file G4SteppingManager.hh.

  {
    return fStep;
  }

References fStep.

Referenced by G4ErrorPropagator::InitG4Track(), and G4TrackingManager::ProcessOneTrack().

◆ GetStepControlFlag()

G4SteppingControl G4SteppingManager::GetStepControlFlag ( )

inline

Definition at line 490 of file G4SteppingManager.hh.

  {
    return StepControlFlag;
  }

References StepControlFlag.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetsumEnergyChange()

G4double G4SteppingManager::GetsumEnergyChange ( )

inline

Definition at line 327 of file G4SteppingManager.hh.

  {
    return sumEnergyChange;
  }

References sumEnergyChange.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetTempInitVelocity()

G4double G4SteppingManager::GetTempInitVelocity ( )

inline

Definition at line 312 of file G4SteppingManager.hh.

  {
    return TempInitVelocity;
  }

References TempInitVelocity.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetTempVelocity()

G4double G4SteppingManager::GetTempVelocity ( )

inline

Definition at line 317 of file G4SteppingManager.hh.

  {
    return TempVelocity;
  }

References TempVelocity.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetTouchableHandle()

const G4TouchableHandle & G4SteppingManager::GetTouchableHandle ( )

inline

Definition at line 485 of file G4SteppingManager.hh.

  {
    return fTouchableHandle;
  }

References fTouchableHandle.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetTrack()

G4Track * G4SteppingManager::GetTrack ( ) const

inline

Definition at line 530 of file G4SteppingManager.hh.

  {
    return fTrack;
  }

References fTrack.

Referenced by G4TrackingMessenger::SetNewValue().

◆ GetUserAction()

G4UserSteppingAction * G4SteppingManager::GetUserAction ( )

inline

Definition at line 525 of file G4SteppingManager.hh.

  {
    return fUserSteppingAction;
  }

References fUserSteppingAction.

Referenced by G4VSteppingVerbose::CopyState().

◆ GetverboseLevel()

G4int G4SteppingManager::GetverboseLevel ( )

inline

Definition at line 457 of file G4SteppingManager.hh.

  {
    return verboseLevel;
  }

References verboseLevel.

Referenced by G4VSteppingVerbose::CopyState().

◆ InvokeAlongStepDoItProcs()

void G4SteppingManager::InvokeAlongStepDoItProcs ( )

private

Definition at line 448 of file G4SteppingManager2.cc.

{
  // If the current Step is defined by a 'ExclusivelyForced' 
  // PostStepDoIt, then don't invoke any AlongStepDoIt
  //
  if(fStepStatus == fExclusivelyForcedProc)
  {
    return;               // Take note 'return' is here !!!
  }
 
  // Invoke all active continuous processes
  //
  for( std::size_t ci=0; ci<MAXofAlongStepLoops; ++ci )
  {
    fCurrentProcess = (*fAlongStepDoItVector)[ci];
    if (fCurrentProcess== 0) continue;
      // NULL means the process is inactivated by a user on fly.
 
    fParticleChange = fCurrentProcess->AlongStepDoIt( *fTrack, *fStep );
 
    // Update the PostStepPoint of Step according to ParticleChange
    fParticleChange->UpdateStepForAlongStep(fStep);
 
    #ifdef G4VERBOSE
      if(verboseLevel>0) fVerbose->AlongStepDoItOneByOne();
    #endif
 
    // Now Store the secondaries from ParticleChange to SecondaryList
 
    G4Track* tempSecondaryTrack;
    G4int    num2ndaries;
 
    num2ndaries = fParticleChange->GetNumberOfSecondaries();
 
    for(G4int DSecLoop=0; DSecLoop<num2ndaries; ++DSecLoop)
    {
      tempSecondaryTrack = fParticleChange->GetSecondary(DSecLoop);
 
      if(tempSecondaryTrack->GetDefinition()->GetApplyCutsFlag())
      {
        ApplyProductionCut(tempSecondaryTrack);
      }
 
      // Set parentID
      tempSecondaryTrack->SetParentID( fTrack->GetTrackID() );
 
      // Set the process pointer which created this track 
      tempSecondaryTrack->SetCreatorProcess( fCurrentProcess );
 
      // If this secondary particle has 'zero' kinetic energy, make sure
      // it invokes a rest process at the beginning of the tracking
      //
      if(tempSecondaryTrack->GetKineticEnergy() <= DBL_MIN)
      {
        G4ProcessManager* pm = tempSecondaryTrack->GetDefinition()
                               ->GetProcessManager();
        if(pm == nullptr)
        {
          G4ExceptionDescription ED;
          ED << "A track without proper process manager is pushed\n"
             << "into the track stack.\n"
             << " Particle name : "
             << tempSecondaryTrack->GetDefinition()->GetParticleName()
             << " -- ";
          if(tempSecondaryTrack->GetParentID()<0)
          {
            ED << "created by a primary particle generator.";
          }
          else
          {
            const G4VProcess* vp = tempSecondaryTrack->GetCreatorProcess();
            if(vp != nullptr)
              { ED << "created by " << vp->GetProcessName() << "."; }
            else
              { ED << "creaded by unknown process."; }
          }
          G4Exception("G4SteppingManager::InvokeAlongStepDoItProcs()",
                      "Tracking10051", FatalException, ED);
        }
        if (pm->GetAtRestProcessVector()->entries()>0)
        {
          tempSecondaryTrack->SetTrackStatus( fStopButAlive );
          fSecondary->push_back( tempSecondaryTrack );
          ++fN2ndariesAlongStepDoIt;
        }
        else
        {
          delete tempSecondaryTrack;
        }
      }
      else
      {
        fSecondary->push_back( tempSecondaryTrack );
        ++fN2ndariesAlongStepDoIt;
      }
    } //end of loop on secondary 
     
    // Set the track status according to what the process defined
    // if kinetic energy >0, otherwise set  fStopButAlive
    //
    fTrack->SetTrackStatus( fParticleChange->GetTrackStatus() );
     
    // clear ParticleChange
    fParticleChange->Clear();
  }
 
  fStep->UpdateTrack();
  G4TrackStatus fNewStatus = fTrack->GetTrackStatus();
 
  if ( fNewStatus == fAlive && fTrack->GetKineticEnergy() <= DBL_MIN )
  {
    if(MAXofAtRestLoops>0) fNewStatus = fStopButAlive;
    else                   fNewStatus = fStopAndKill;
    fTrack->SetTrackStatus( fNewStatus );
  }
}

References G4VProcess::AlongStepDoIt(), G4VSteppingVerbose::AlongStepDoItOneByOne(), ApplyProductionCut(), G4VParticleChange::Clear(), DBL_MIN, G4ProcessVector::entries(), fAlive, FatalException, fCurrentProcess, fExclusivelyForcedProc, fN2ndariesAlongStepDoIt, fParticleChange, fSecondary, fStep, fStepStatus, fStopAndKill, fStopButAlive, fTrack, fVerbose, G4Exception(), G4ParticleDefinition::GetApplyCutsFlag(), G4ProcessManager::GetAtRestProcessVector(), G4Track::GetCreatorProcess(), G4Track::GetDefinition(), G4Track::GetKineticEnergy(), G4VParticleChange::GetNumberOfSecondaries(), G4Track::GetParentID(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetProcessManager(), G4VProcess::GetProcessName(), G4VParticleChange::GetSecondary(), G4Track::GetTrackID(), G4Track::GetTrackStatus(), G4VParticleChange::GetTrackStatus(), MAXofAlongStepLoops, MAXofAtRestLoops, G4Track::SetCreatorProcess(), G4Track::SetParentID(), G4Track::SetTrackStatus(), G4VParticleChange::UpdateStepForAlongStep(), G4Step::UpdateTrack(), and verboseLevel.

Referenced by Stepping().

◆ InvokeAtRestDoItProcs()

void G4SteppingManager::InvokeAtRestDoItProcs ( )

private

Definition at line 280 of file G4SteppingManager2.cc.

{
  // Select the rest process which has the shortest time before
  // it is invoked. In rest processes, GPIL()
  // returns the time before a process occurs
 
  G4double lifeTime, shortestLifeTime;
 
  fAtRestDoItProcTriggered = 0;
  shortestLifeTime = DBL_MAX;
 
  unsigned int NofInactiveProc = 0;
  for( std::size_t ri=0 ; ri < MAXofAtRestLoops ; ++ri )
  {
    fCurrentProcess = (*fAtRestGetPhysIntVector)[ri];
    if (fCurrentProcess == nullptr)
    {
      (*fSelectedAtRestDoItVector)[ri] = InActivated;
      ++NofInactiveProc;
      continue;
    }   // NULL means the process is inactivated by a user on fly
 
    lifeTime = fCurrentProcess->AtRestGPIL( *fTrack, &fCondition );
 
    if(fCondition == Forced)
    {
      (*fSelectedAtRestDoItVector)[ri] = Forced;
    }
    else
    {
      (*fSelectedAtRestDoItVector)[ri] = InActivated;
      if(lifeTime < shortestLifeTime )
      {
        shortestLifeTime = lifeTime;
        fAtRestDoItProcTriggered = G4int(ri);
      }
    }
  }
 
  (*fSelectedAtRestDoItVector)[fAtRestDoItProcTriggered] = NotForced;
 
  // at least one process is necessary to destroy the particle exit with warning
  //
  if(NofInactiveProc==MAXofAtRestLoops)
  { 
    G4Exception("G4SteppingManager::InvokeAtRestDoItProcs()", "Tracking0013",
                JustWarning, "No AtRestDoIt process is active!" );
  }
 
  fStep->SetStepLength( 0. );  // the particle has stopped
  fTrack->SetStepLength( 0. );
 
 
  // Condition to avoid that stable ions are handled by Radioactive Decay.
  // We use a very large time threshold (many orders of magnitude bigger than
  // the universe's age) but not DBL_MAX because shortestLifeTime can be
  // sometimes slightly smaller for stable ions.
  if(shortestLifeTime < 1.0e+100)  // Unstable ion at rest: Radioactive Decay will decay it
  {
    // invoke selected process
    //
    for(std::size_t np=0; np<MAXofAtRestLoops; ++np)
    {
      //
      // Note: DoItVector has inverse order against GetPhysIntVector
      //       and SelectedAtRestDoItVector.
      //
      if( (*fSelectedAtRestDoItVector)[MAXofAtRestLoops-np-1] != InActivated)
      {
        fCurrentProcess = (*fAtRestDoItVector)[np];
        fParticleChange = fCurrentProcess->AtRestDoIt(*fTrack, *fStep);
                               
        // Set the current process as a process which defined this Step length
        //
        fStep->GetPostStepPoint()->SetProcessDefinedStep(fCurrentProcess);
 
        // Update Step
        //
        fParticleChange->UpdateStepForAtRest(fStep);
 
        // Now Store the secondaries from ParticleChange to SecondaryList
 
        G4Track* tempSecondaryTrack;
        G4int    num2ndaries;
 
        num2ndaries = fParticleChange->GetNumberOfSecondaries();
 
        for(G4int DSecLoop=0; DSecLoop< num2ndaries; ++DSecLoop)
        {
          tempSecondaryTrack = fParticleChange->GetSecondary(DSecLoop);
 
          if(tempSecondaryTrack->GetDefinition()->GetApplyCutsFlag())
          {
            ApplyProductionCut(tempSecondaryTrack);
          }
 
          // Set parentID 
          tempSecondaryTrack->SetParentID( fTrack->GetTrackID() );
 
          // Set the process pointer which created this track 
          tempSecondaryTrack->SetCreatorProcess( fCurrentProcess );
         
          // If this 2ndry particle has 'zero' kinetic energy, make sure
          // it invokes a rest process at the beginning of the tracking
          //
          if(tempSecondaryTrack->GetKineticEnergy() <= DBL_MIN)
          {
            G4ProcessManager* pm = tempSecondaryTrack->GetDefinition()
                                   ->GetProcessManager();
            if(pm == nullptr)
            {
              G4ExceptionDescription ED;
              ED << "A track without proper process manager is pushed\n"
                 << "into the track stack.\n"
                 << " Particle name : "
                 << tempSecondaryTrack->GetDefinition()->GetParticleName()
                 << " -- ";
              if(tempSecondaryTrack->GetParentID()<0)
              {
                ED << "created by a primary particle generator.";
              }
              else
              {
                const G4VProcess* vp = tempSecondaryTrack->GetCreatorProcess();
                if(vp != nullptr)
                { ED << "created by " << vp->GetProcessName() << "."; }
                else
                { ED << "creaded by unknown process."; }
              }
              G4Exception("G4SteppingManager::InvokeAtRestDoItProcs()",
                          "Tracking10051", FatalException, ED);
            }
            if (pm->GetAtRestProcessVector()->entries()>0)
            {
              tempSecondaryTrack->SetTrackStatus( fStopButAlive );
              fSecondary->push_back( tempSecondaryTrack );
              ++fN2ndariesAtRestDoIt;
            }
            else
            {
              delete tempSecondaryTrack;
            }
          }
          else
          {
            fSecondary->push_back( tempSecondaryTrack );
            ++fN2ndariesAtRestDoIt;
          }
        } //end of loop on secondary 
 
        // clear ParticleChange
        fParticleChange->Clear();
 
      }  // if(fSelectedAtRestDoItVector[np] != InActivated){
    }  // for(std::size_t np=0; np<MAXofAtRestLoops; ++np){
  }
  else  // Stable ion at rest
  {
    fStep->GetPostStepPoint()->SetProcessDefinedStep( fNoProcess );
  }  // if(shortestLifeTime < 1.0e+100)
 
  fStep->UpdateTrack();
 
  fTrack->SetTrackStatus( fStopAndKill );
}

References ApplyProductionCut(), G4VProcess::AtRestDoIt(), G4VProcess::AtRestGPIL(), G4VParticleChange::Clear(), DBL_MAX, DBL_MIN, G4ProcessVector::entries(), FatalException, fAtRestDoItProcTriggered, fCondition, fCurrentProcess, fN2ndariesAtRestDoIt, fNoProcess, Forced, fParticleChange, fSecondary, fSelectedAtRestDoItVector, fStep, fStopAndKill, fStopButAlive, fTrack, G4Exception(), G4ParticleDefinition::GetApplyCutsFlag(), G4ProcessManager::GetAtRestProcessVector(), G4Track::GetCreatorProcess(), G4Track::GetDefinition(), G4Track::GetKineticEnergy(), G4VParticleChange::GetNumberOfSecondaries(), G4Track::GetParentID(), G4ParticleDefinition::GetParticleName(), G4Step::GetPostStepPoint(), G4ParticleDefinition::GetProcessManager(), G4VProcess::GetProcessName(), G4VParticleChange::GetSecondary(), G4Track::GetTrackID(), InActivated, JustWarning, MAXofAtRestLoops, NotForced, G4Track::SetCreatorProcess(), G4Track::SetParentID(), G4StepPoint::SetProcessDefinedStep(), G4Step::SetStepLength(), G4Track::SetStepLength(), G4Track::SetTrackStatus(), G4VParticleChange::UpdateStepForAtRest(), and G4Step::UpdateTrack().

Referenced by Stepping().

◆ InvokePostStepDoItProcs()

void G4SteppingManager::InvokePostStepDoItProcs ( )

private

Definition at line 567 of file G4SteppingManager2.cc.

{
  // Invoke the specified discrete processes
  //
  for(std::size_t np=0; np<MAXofPostStepLoops; ++np)
  {
    //
    // Note: DoItVector has inverse order against GetPhysIntVector
    //       and SelectedPostStepDoItVector.
    //
    G4int Cond = (*fSelectedPostStepDoItVector)[MAXofPostStepLoops-np-1];
    if(Cond != InActivated)
    {
      if( ((Cond == NotForced) && (fStepStatus == fPostStepDoItProc)) ||
          ((Cond == Forced) && (fStepStatus != fExclusivelyForcedProc)) ||
          ((Cond == ExclusivelyForced) && (fStepStatus == fExclusivelyForcedProc)) || 
          ((Cond == StronglyForced) ) )
      {
        InvokePSDIP(np);
        if ((np==0) && (fTrack->GetNextVolume() == nullptr))
        {
          fStepStatus = fWorldBoundary;
          fStep->GetPostStepPoint()->SetStepStatus( fStepStatus );
        }
      }
    }
 
    // Exit from PostStepLoop if the track has been killed,
    // but extra treatment for processes with Strongly Forced flag
    //
    if(fTrack->GetTrackStatus() == fStopAndKill)
    {
      for(std::size_t np1=np+1; np1<MAXofPostStepLoops; ++np1)
      { 
        G4int Cond2 = (*fSelectedPostStepDoItVector)[MAXofPostStepLoops-np1-1];
        if (Cond2 == StronglyForced)
        {
          InvokePSDIP(np1);
        }
      }
      break;
    }
  }
}

References ExclusivelyForced, fExclusivelyForcedProc, Forced, fPostStepDoItProc, fStep, fStepStatus, fStopAndKill, fTrack, fWorldBoundary, G4Track::GetNextVolume(), G4Step::GetPostStepPoint(), G4Track::GetTrackStatus(), InActivated, InvokePSDIP(), MAXofPostStepLoops, NotForced, G4StepPoint::SetStepStatus(), and StronglyForced.

Referenced by Stepping().

◆ InvokePSDIP()

void G4SteppingManager::InvokePSDIP ( size_t np )

private

Definition at line 614 of file G4SteppingManager2.cc.

{
  fCurrentProcess = (*fPostStepDoItVector)[np];
  fParticleChange = fCurrentProcess->PostStepDoIt( *fTrack, *fStep);
 
  // Update PostStepPoint of Step according to ParticleChange
  fParticleChange->UpdateStepForPostStep(fStep);
 
  #ifdef G4VERBOSE
    if(verboseLevel>0) fVerbose->PostStepDoItOneByOne();
  #endif
 
  // Update G4Track according to ParticleChange after each PostStepDoIt
  fStep->UpdateTrack();
 
  // Update safety after each invocation of PostStepDoIts
  fStep->GetPostStepPoint()->SetSafety( CalculateSafety() );
 
  // Now Store the secondaries from ParticleChange to SecondaryList
 
  G4Track* tempSecondaryTrack;
  G4int    num2ndaries;
 
  num2ndaries = fParticleChange->GetNumberOfSecondaries();
 
  for(G4int DSecLoop=0; DSecLoop<num2ndaries; ++DSecLoop)
  {
    tempSecondaryTrack = fParticleChange->GetSecondary(DSecLoop);
   
    if(tempSecondaryTrack->GetDefinition()->GetApplyCutsFlag())
    {
      ApplyProductionCut(tempSecondaryTrack);
    }
 
    // Set parentID 
    tempSecondaryTrack->SetParentID( fTrack->GetTrackID() );
    
    // Set the process pointer which created this track 
    tempSecondaryTrack->SetCreatorProcess( fCurrentProcess );
 
    // If this secondary particle has 'zero' kinetic energy, make sure
    // it invokes a rest process at the beginning of the tracking
    //
    if(tempSecondaryTrack->GetKineticEnergy() <= DBL_MIN)
    {
      G4ProcessManager* pm = tempSecondaryTrack->GetDefinition()
                             ->GetProcessManager();
      if(pm == nullptr)
      {
        G4ExceptionDescription ED;
        ED << "A track without proper process manager is pushed\n"
           << "into the track stack.\n"
           << " Particle name : "
           << tempSecondaryTrack->GetDefinition()->GetParticleName()
           << " -- ";
        if(tempSecondaryTrack->GetParentID()<0)
        {
          ED << "created by a primary particle generator.";
        }
        else
        {
          const G4VProcess* vp = tempSecondaryTrack->GetCreatorProcess();
          if(vp != nullptr)
            { ED << "created by " << vp->GetProcessName() << "."; }
          else
            { ED << "creaded by unknown process."; }
        }
        G4Exception("G4SteppingManager::InvokePSDIP()","Tracking10053",
                    FatalException,ED);
      }
      if (pm->GetAtRestProcessVector()->entries()>0)
      {
        tempSecondaryTrack->SetTrackStatus( fStopButAlive );
        fSecondary->push_back( tempSecondaryTrack );
        ++fN2ndariesPostStepDoIt;
      }
      else
      {
        delete tempSecondaryTrack;
      }
    }
    else
    {
      fSecondary->push_back( tempSecondaryTrack );
      ++fN2ndariesPostStepDoIt;
    }
  } //end of loop on secondary 
 
  // Set the track status according to what the process defined
  fTrack->SetTrackStatus( fParticleChange->GetTrackStatus() );
 
  // clear ParticleChange
  fParticleChange->Clear();
}

References ApplyProductionCut(), CalculateSafety(), G4VParticleChange::Clear(), DBL_MIN, G4ProcessVector::entries(), FatalException, fCurrentProcess, fN2ndariesPostStepDoIt, fParticleChange, fSecondary, fStep, fStopButAlive, fTrack, fVerbose, G4Exception(), G4ParticleDefinition::GetApplyCutsFlag(), G4ProcessManager::GetAtRestProcessVector(), G4Track::GetCreatorProcess(), G4Track::GetDefinition(), G4Track::GetKineticEnergy(), G4VParticleChange::GetNumberOfSecondaries(), G4Track::GetParentID(), G4ParticleDefinition::GetParticleName(), G4Step::GetPostStepPoint(), G4ParticleDefinition::GetProcessManager(), G4VProcess::GetProcessName(), G4VParticleChange::GetSecondary(), G4Track::GetTrackID(), G4VParticleChange::GetTrackStatus(), G4VProcess::PostStepDoIt(), G4VSteppingVerbose::PostStepDoItOneByOne(), G4Track::SetCreatorProcess(), G4Track::SetParentID(), G4StepPoint::SetSafety(), G4Track::SetTrackStatus(), G4VParticleChange::UpdateStepForPostStep(), G4Step::UpdateTrack(), and verboseLevel.

Referenced by InvokePostStepDoItProcs().

◆ SetInitialStep()

void G4SteppingManager::SetInitialStep ( G4Track * valueTrack )

Definition at line 281 of file G4SteppingManager.cc.

{
  // Set up several local variables
  //
  PreStepPointIsGeom = false;
  FirstStep = true;
  fParticleChange = nullptr;
  fPreviousStepSize = 0.;
  fStepStatus = fUndefined;
 
  fTrack = valueTrack;
  Mass = fTrack->GetDynamicParticle()->GetMass();
 
  PhysicalStep = 0.;
  GeometricalStep = 0.;
  CorrectedStep = 0.;
  PreStepPointIsGeom = false;
  FirstStep = false;
 
  TempInitVelocity = 0.;
  TempVelocity = 0.;
  sumEnergyChange = 0.;
 
  // If the primary track has 'Suspend' or 'PostponeToNextEvent' state,
  // set the track state to 'Alive'
  //
  if ( (fTrack->GetTrackStatus()==fSuspend)
    || (fTrack->GetTrackStatus()==fPostponeToNextEvent) )
  { 
    fTrack->SetTrackStatus(fAlive);
  }
 
  // If the primary track has 'zero' kinetic energy, set the track
  // state to 'StopButAlive'
  //
  if(fTrack->GetKineticEnergy() <= 0.0)
  {
    fTrack->SetTrackStatus( fStopButAlive );
  }
 
  // Set Touchable to track and a private attribute of G4SteppingManager
 
  if ( ! fTrack->GetTouchableHandle() )
  {
    G4ThreeVector direction= fTrack->GetMomentumDirection();
    fNavigator->LocateGlobalPointAndSetup( fTrack->GetPosition(),
                                           &direction, false, false );
    fTouchableHandle = fNavigator->CreateTouchableHistory();
    fTrack->SetTouchableHandle( fTouchableHandle );
    fTrack->SetNextTouchableHandle( fTouchableHandle );
  }
  else
  {
    fTrack->SetNextTouchableHandle( fTouchableHandle = fTrack->GetTouchableHandle() );
    G4VPhysicalVolume* oldTopVolume = fTrack->GetTouchableHandle()->GetVolume();
    G4VPhysicalVolume* newTopVolume =
      fNavigator->ResetHierarchyAndLocate( fTrack->GetPosition(), 
                     fTrack->GetMomentumDirection(),
                     *((G4TouchableHistory*)fTrack->GetTouchableHandle()()) );
    if ( newTopVolume != oldTopVolume
      || oldTopVolume->GetRegularStructureId() == 1 )
    { 
      fTouchableHandle = fNavigator->CreateTouchableHistory();
      fTrack->SetTouchableHandle( fTouchableHandle );
      fTrack->SetNextTouchableHandle( fTouchableHandle );
    }
  }
 
  // Set OriginTouchableHandle for primary track
  //
  if(fTrack->GetParentID()==0)
  {
    fTrack->SetOriginTouchableHandle(fTrack->GetTouchableHandle());
  }
 
  // Set vertex information of G4Track at here
  //
  if ( fTrack->GetCurrentStepNumber() == 0 )
  {
    fTrack->SetVertexPosition( fTrack->GetPosition() );
    fTrack->SetVertexMomentumDirection( fTrack->GetMomentumDirection() );
    fTrack->SetVertexKineticEnergy( fTrack->GetKineticEnergy() );
    fTrack->SetLogicalVolumeAtVertex( fTrack->GetVolume()->GetLogicalVolume() );
  }
 
  // Initial set up for attributes of 'G4SteppingManager'
  fCurrentVolume = fTouchableHandle->GetVolume();
 
  // If track is already outside the world boundary, kill it
  //
  if( fCurrentVolume==nullptr )
  {
    // If the track is a primary, stop processing
    if(fTrack->GetParentID()==0)
    {
      G4cerr << "ERROR - G4SteppingManager::SetInitialStep()" << G4endl
             << "        Primary particle starting at - "
             << fTrack->GetPosition()
             << " - is outside of the world volume." << G4endl;
      G4Exception("G4SteppingManager::SetInitialStep()", "Tracking0010",
                  FatalException, "Primary vertex outside of the world!");
    }
 
    fTrack->SetTrackStatus( fStopAndKill );
    G4cout << "WARNING - G4SteppingManager::SetInitialStep()" << G4endl
           << "          Initial track position is outside world! - "
           << fTrack->GetPosition() << G4endl;
   }
   else
   {
     // Initial set up for attributes of 'Step'
     fStep->InitializeStep( fTrack );
   }
 
   #ifdef G4VERBOSE
     if(verboseLevel>0) fVerbose->TrackingStarted();
   #endif
}

References CorrectedStep, G4Navigator::CreateTouchableHistory(), fAlive, FatalException, fCurrentVolume, FirstStep, fNavigator, fParticleChange, fPostponeToNextEvent, fPreviousStepSize, fStep, fStepStatus, fStopAndKill, fStopButAlive, fSuspend, fTouchableHandle, fTrack, fUndefined, fVerbose, G4cerr, G4cout, G4endl, G4Exception(), GeometricalStep, G4Track::GetCurrentStepNumber(), G4Track::GetDynamicParticle(), G4Track::GetKineticEnergy(), G4VPhysicalVolume::GetLogicalVolume(), G4DynamicParticle::GetMass(), G4Track::GetMomentumDirection(), G4Track::GetParentID(), G4Track::GetPosition(), G4VPhysicalVolume::GetRegularStructureId(), G4Track::GetTouchableHandle(), G4Track::GetTrackStatus(), G4Track::GetVolume(), G4VTouchable::GetVolume(), G4Step::InitializeStep(), G4Navigator::LocateGlobalPointAndSetup(), Mass, PhysicalStep, PreStepPointIsGeom, G4Navigator::ResetHierarchyAndLocate(), G4Track::SetLogicalVolumeAtVertex(), G4Track::SetNextTouchableHandle(), G4Track::SetOriginTouchableHandle(), G4Track::SetTouchableHandle(), G4Track::SetTrackStatus(), G4Track::SetVertexKineticEnergy(), G4Track::SetVertexMomentumDirection(), G4Track::SetVertexPosition(), sumEnergyChange, TempInitVelocity, TempVelocity, G4VSteppingVerbose::TrackingStarted(), and verboseLevel.

Referenced by G4ErrorPropagator::InitG4Track(), and G4TrackingManager::ProcessOneTrack().

◆ SetNavigator()

void G4SteppingManager::SetNavigator ( G4Navigator * value )

inline

Definition at line 515 of file G4SteppingManager.hh.

  {
    fNavigator = value; 
  }

References fNavigator.

Referenced by G4SteppingManager(), and G4ErrorPropagatorManager::StartNavigator().

◆ SetUserAction()

void G4SteppingManager::SetUserAction ( G4UserSteppingAction * apAction )

inline

Definition at line 520 of file G4SteppingManager.hh.

  {
    fUserSteppingAction = apAction;
  }

References fUserSteppingAction.

Referenced by G4TrackingManager::SetUserAction().

◆ SetVerbose()

void G4SteppingManager::SetVerbose ( G4VSteppingVerbose * yourVerbose )

inline

Definition at line 540 of file G4SteppingManager.hh.

  {
    fVerbose = yourVerbose;
  }

References fVerbose.

◆ SetVerboseLevel()

void G4SteppingManager::SetVerboseLevel ( G4int vLevel )

inline

Definition at line 535 of file G4SteppingManager.hh.

  {
    verboseLevel = vLevel; 
  }

References verboseLevel.

Referenced by G4ErrorPropagatorManager::SetSteppingManagerVerboseLevel().

◆ Stepping()

G4StepStatus G4SteppingManager::Stepping ( )

Definition at line 122 of file G4SteppingManager.cc.

{
#ifdef GEANT4_USE_TIMEMORY
  ProfilerConfig profiler{ fStep };
#endif
 
  //--------
  // Prelude
  //--------
  #ifdef G4VERBOSE
    if(verboseLevel>0)
    {
      fVerbose->NewStep();
    }
    else if (verboseLevel==-1)
    { 
      G4VSteppingVerbose::SetSilent(1);
    }
    else
    {
      G4VSteppingVerbose::SetSilent(0);
    }
  #endif 
 
  // Store last PostStepPoint to PreStepPoint, and swap current and nex
  // volume information of G4Track. Reset total energy deposit in one Step.
  //
  fStep->CopyPostToPreStepPoint();
  fStep->ResetTotalEnergyDeposit();
 
  // Switch next touchable in track to current one
  //
  fTrack->SetTouchableHandle(fTrack->GetNextTouchableHandle());
 
  // Reset the secondary particles
  //
  fN2ndariesAtRestDoIt = 0;
  fN2ndariesAlongStepDoIt = 0;
  fN2ndariesPostStepDoIt = 0;
 
  // Set the volume before it is used (in DefineStepLength() for User Limit)
  //
  fCurrentVolume = fStep->GetPreStepPoint()->GetPhysicalVolume();
 
  // Reset the step's auxiliary points vector pointer
  //
  fStep->SetPointerToVectorOfAuxiliaryPoints(nullptr);
 
  //-----------------
  // AtRest Processes
  //-----------------
 
  if( fTrack->GetTrackStatus() == fStopButAlive )
  {
    if( MAXofAtRestLoops>0 )
    {
      InvokeAtRestDoItProcs();
      fStepStatus = fAtRestDoItProc;
      fStep->GetPostStepPoint()->SetStepStatus( fStepStatus );
       
      #ifdef G4VERBOSE
        if(verboseLevel>0) fVerbose->AtRestDoItInvoked();
      #endif 
 
     }
     // Make sure the track is killed
     //
     fTrack->SetTrackStatus( fStopAndKill );
  }
 
  //---------------------------------
  // AlongStep and PostStep Processes
  //---------------------------------
 
  else
  {
    // Find minimum Step length demanded by active disc./cont. processes
    DefinePhysicalStepLength();
 
    // Store the Step length (geometrical length) to G4Step and G4Track
    fStep->SetStepLength( PhysicalStep );
    fTrack->SetStepLength( PhysicalStep );
    G4double GeomStepLength = PhysicalStep;
 
    // Store StepStatus to PostStepPoint
    fStep->GetPostStepPoint()->SetStepStatus( fStepStatus );
 
    // Invoke AlongStepDoIt 
    InvokeAlongStepDoItProcs();
 
    // Update track by taking into account all changes by AlongStepDoIt
    fStep->UpdateTrack();
 
    // Update safety after invocation of all AlongStepDoIts
    endpointSafOrigin= fPostStepPoint->GetPosition();
    // endpointSafety=  std::max( proposedSafety - GeomStepLength, 0.);
    endpointSafety=  std::max( proposedSafety - GeomStepLength, kCarTolerance);
 
    fStep->GetPostStepPoint()->SetSafety( endpointSafety );
 
    #ifdef G4VERBOSE
      if(verboseLevel>0) fVerbose->AlongStepDoItAllDone();
    #endif
 
    // Invoke PostStepDoIt
    InvokePostStepDoItProcs();
 
    #ifdef G4VERBOSE
      if(verboseLevel>0) fVerbose->PostStepDoItAllDone();
    #endif
  }
 
  //-------
  // Finale
  //-------
 
  // Update 'TrackLength' and remeber the Step length of the current Step
  //
  fTrack->AddTrackLength(fStep->GetStepLength());
  fPreviousStepSize = fStep->GetStepLength();
  fStep->SetTrack(fTrack);
 
  #ifdef G4VERBOSE
    if(verboseLevel>0) fVerbose->StepInfo();
  #endif
 
  // Send G4Step information to Hit/Dig if the volume is sensitive
  //
  fCurrentVolume = fStep->GetPreStepPoint()->GetPhysicalVolume();
  StepControlFlag =  fStep->GetControlFlag();
  if( fCurrentVolume != nullptr && StepControlFlag != AvoidHitInvocation )
  {
    fSensitive = fStep->GetPreStepPoint()->GetSensitiveDetector();
    if( fSensitive != 0 )
    {
      fSensitive->Hit(fStep);
    }
  }
 
  // User intervention process
  //
  if( fUserSteppingAction != nullptr )
  {
    fUserSteppingAction->UserSteppingAction(fStep);
  }
 
  G4UserSteppingAction* regionalAction =
    fCurrentVolume->GetLogicalVolume()->GetRegion()->GetRegionalSteppingAction();
 
  if(regionalAction)
    regionalAction->UserSteppingAction(fStep);
 
  // Stepping process finish. Return the value of the StepStatus
  //
  return fStepStatus;
}