G4SteppingManager Class Reference

#include <G4SteppingManager.hh>

Collaboration diagram for G4SteppingManager:

Public Member Functions
	G4SteppingManager ()
	~G4SteppingManager ()
const G4TrackVector *	GetSecondary () const
void	SetUserAction (G4UserSteppingAction *apAction)
G4Track *	GetTrack () const
void	SetVerboseLevel (G4int vLevel)
void	SetVerbose (G4VSteppingVerbose *)
G4Step *	GetStep () const
void	SetNavigator (G4Navigator *value)
G4StepStatus	Stepping ()
void	SetInitialStep (G4Track *valueTrack)
void	GetProcessNumber ()
G4double	GetPhysicalStep ()
G4double	GetGeometricalStep ()
G4double	GetCorrectedStep ()
G4bool	GetPreStepPointIsGeom ()
G4bool	GetFirstStep ()
G4StepStatus	GetfStepStatus ()
G4double	GetTempInitVelocity ()
G4double	GetTempVelocity ()
G4double	GetMass ()
G4double	GetsumEnergyChange ()
G4VParticleChange *	GetfParticleChange ()
G4Track *	GetfTrack ()
G4TrackVector *	GetfSecondary ()
G4Step *	GetfStep ()
G4StepPoint *	GetfPreStepPoint ()
G4StepPoint *	GetfPostStepPoint ()
G4VPhysicalVolume *	GetfCurrentVolume ()
G4VSensitiveDetector *	GetfSensitive ()
G4VProcess *	GetfCurrentProcess ()
G4ProcessVector *	GetfAtRestDoItVector ()
G4ProcessVector *	GetfAlongStepDoItVector ()
G4ProcessVector *	GetfPostStepDoItVector ()
G4ProcessVector *	GetfAlongStepGetPhysIntVector ()
G4ProcessVector *	GetfPostStepGetPhysIntVector ()
G4ProcessVector *	GetfAtRestGetPhysIntVector ()
G4double	GetcurrentMinimumStep ()
G4double	GetnumberOfInteractionLengthLeft ()
size_t	GetfAtRestDoItProcTriggered ()
size_t	GetfAlongStepDoItProcTriggered ()
size_t	GetfPostStepDoItProcTriggered ()
G4int	GetfN2ndariesAtRestDoIt ()
G4int	GetfN2ndariesAlongStepDoIt ()
G4int	GetfN2ndariesPostStepDoIt ()
G4Navigator *	GetfNavigator ()
G4int	GetverboseLevel ()
size_t	GetMAXofAtRestLoops ()
size_t	GetMAXofAlongStepLoops ()
size_t	GetMAXofPostStepLoops ()
G4SelectedAtRestDoItVector *	GetfSelectedAtRestDoItVector ()
G4SelectedAlongStepDoItVector *	GetfSelectedAlongStepDoItVector ()
G4SelectedPostStepDoItVector *	GetfSelectedPostStepDoItVector ()
G4double	GetfPreviousStepSize ()
const G4TouchableHandle &	GetTouchableHandle ()
G4SteppingControl	GetStepControlFlag ()
G4UserSteppingAction *	GetUserAction ()
G4double	GetphysIntLength ()
G4ForceCondition	GetfCondition ()
G4GPILSelection	GetfGPILSelection ()

Public Attributes
G4bool	KillVerbose

Private Member Functions
void	DefinePhysicalStepLength ()
void	InvokeAtRestDoItProcs ()
void	InvokeAlongStepDoItProcs ()
void	InvokePostStepDoItProcs ()
void	InvokePSDIP (size_t)
G4double	CalculateSafety ()
void	ApplyProductionCut (G4Track *)

Private Attributes
G4UserSteppingAction *	fUserSteppingAction
G4VSteppingVerbose *	fVerbose
G4double	PhysicalStep
G4double	GeometricalStep
G4double	CorrectedStep
G4bool	PreStepPointIsGeom
G4bool	FirstStep
G4StepStatus	fStepStatus
G4double	TempInitVelocity
G4double	TempVelocity
G4double	Mass
G4double	sumEnergyChange
G4VParticleChange *	fParticleChange
G4Track *	fTrack
G4TrackVector *	fSecondary
G4Step *	fStep
G4StepPoint *	fPreStepPoint
G4StepPoint *	fPostStepPoint
G4VPhysicalVolume *	fCurrentVolume
G4VSensitiveDetector *	fSensitive
G4VProcess *	fCurrentProcess
G4ProcessVector *	fAtRestDoItVector
G4ProcessVector *	fAlongStepDoItVector
G4ProcessVector *	fPostStepDoItVector
G4ProcessVector *	fAtRestGetPhysIntVector
G4ProcessVector *	fAlongStepGetPhysIntVector
G4ProcessVector *	fPostStepGetPhysIntVector
size_t	MAXofAtRestLoops
size_t	MAXofAlongStepLoops
size_t	MAXofPostStepLoops
size_t	fAtRestDoItProcTriggered
size_t	fAlongStepDoItProcTriggered
size_t	fPostStepDoItProcTriggered
G4int	fN2ndariesAtRestDoIt
G4int	fN2ndariesAlongStepDoIt
G4int	fN2ndariesPostStepDoIt
G4Navigator *	fNavigator
G4int	verboseLevel
G4SelectedAtRestDoItVector *	fSelectedAtRestDoItVector
G4SelectedAlongStepDoItVector *	fSelectedAlongStepDoItVector
G4SelectedPostStepDoItVector *	fSelectedPostStepDoItVector
G4double	fPreviousStepSize
G4TouchableHandle	fTouchableHandle
G4SteppingControl	StepControlFlag
G4double	kCarTolerance
G4double	proposedSafety
G4ThreeVector	endpointSafOrigin
G4double	endpointSafety
G4double	physIntLength
G4ForceCondition	fCondition
G4GPILSelection	fGPILSelection

Detailed Description

Definition at line 92 of file G4SteppingManager.hh.

Constructor & Destructor Documentation

G4SteppingManager()

G4SteppingManager::G4SteppingManager

(

)

Definition at line 56 of file G4SteppingManager.cc.

  : fUserSteppingAction(0), verboseLevel(0)
{

// Construct simple 'has-a' related objects
   fStep = new G4Step();
   fSecondary = fStep->NewSecondaryVector();
   fPreStepPoint  = fStep->GetPreStepPoint();
   fPostStepPoint = fStep->GetPostStepPoint();
#ifdef G4VERBOSE
   if(G4VSteppingVerbose::GetInstance()==0) {
     fVerbose =  new G4SteppingVerbose();
     G4VSteppingVerbose::SetInstance(fVerbose);
     fVerbose -> SetManager(this);
     KillVerbose = true;
   }
   else { 
      fVerbose = G4VSteppingVerbose::GetInstance();
      fVerbose -> SetManager(this);
      KillVerbose = false;
   }
#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();
}

Here is the call graph for this function:

~G4SteppingManager()

G4SteppingManager::~G4SteppingManager

(

)

Definition at line 97 of file G4SteppingManager.cc.

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

Member Function Documentation

ApplyProductionCut()

void G4SteppingManager::ApplyProductionCut ( G4Track *  aSecondary )

private

Definition at line 592 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());
  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()) )
    {
//G4cout << "!! Warning - G4SteppingManager:" << G4endl
//<< " This physics process generated a secondary"
//<< " of which energy is below cut but"
//<< " GoodForTracking is off !!!!!" << G4endl;
    // Add kinetic energy to the total energy deposit
      fStep->AddTotalEnergyDeposit(
      aSecondary->GetKineticEnergy() );
      aSecondary->SetKineticEnergy(0.0);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

CalculateSafety()

G4double G4SteppingManager::CalculateSafety ( )

inlineprivate

Definition at line 490 of file G4SteppingManager.hh.

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

Here is the caller graph for this function:

DefinePhysicalStepLength()

void G4SteppingManager::DefinePhysicalStepLength ( )

private

Definition at line 128 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
                         // !!!!! Verbose
           if(verboseLevel>0) fVerbose->DPSLStarted();
#endif

// Obtain the user defined maximum allowed Step in the volume
//   1997.12.13 adds argument for  GetMaxAllowedStep by K.Kurashige
//   2004.01.20 This block will be removed by Geant4 7.0 
//   G4UserLimits* ul= fCurrentVolume->GetLogicalVolume()->GetUserLimits();
//   if (ul) {
//      physIntLength = ul->GetMaxAllowedStep(*fTrack);
//#ifdef G4VERBOSE
//                         // !!!!! Verbose
//           if(verboseLevel>0) fVerbose->DPSLUserLimit();
//#endif
//   }
//
//   if(physIntLength < PhysicalStep ){
//      PhysicalStep = physIntLength;
//      fStepStatus = fUserDefinedLimit;
//      fStep->GetPostStepPoint()
//           ->SetProcessDefinedStep(0);
//      // Take note that the process pointer is 'NULL' if the Step
//      // is defined by the user defined limit.
//   }
//   2004.01.20 This block will be removed by Geant4 7.0 

// GPIL for PostStep
   fPostStepDoItProcTriggered = MAXofPostStepLoops;

   for(size_t np=0; np < MAXofPostStepLoops; np++){
     fCurrentProcess = (*fPostStepGetPhysIntVector)(np);
     if (fCurrentProcess== 0) {
       (*fSelectedPostStepDoItVector)[np] = InActivated;
       continue;
     }   // NULL means the process is inactivated by a user on fly.

     physIntLength = fCurrentProcess->
                     PostStepGPIL( *fTrack,
                                                 fPreviousStepSize,
                                                      &fCondition );
#ifdef G4VERBOSE
                         // !!!!! Verbose
     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(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;

   for(size_t kp=0; kp < MAXofAlongStepLoops; kp++){
     fCurrentProcess = (*fAlongStepGetPhysIntVector)[kp];
     if (fCurrentProcess== 0) continue;
         // NULL means the process is inactivated by a user on fly.

     physIntLength = fCurrentProcess->
                     AlongStepGPIL( *fTrack, fPreviousStepSize,
                                     PhysicalStep,
                     safetyProposedToAndByProcess,
                                    &fGPILSelection );
#ifdef G4VERBOSE
                         // !!!!! Verbose
     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);
       }

          // Transportation is assumed to be the last process in the vector
       if(kp == MAXofAlongStepLoops-1)
      fStepStatus = fGeomBoundary;
     }

     // Make sure to check the safety, even if Step is not limited 
     //  by this process.                      J. Apostolakis, June 20, 1998
     // 
     if (safetyProposedToAndByProcess < proposedSafety)
        // proposedSafety keeps the smallest value:
        proposedSafety               = safetyProposedToAndByProcess;
     else
        // safetyProposedToAndByProcess always proposes a valid safety:
        safetyProposedToAndByProcess = proposedSafety;
      
   } 
} // void G4SteppingManager::DefinePhysicalStepLength() //

Here is the call graph for this function:

Here is the caller graph for this function:

GetCorrectedStep()

G4double G4SteppingManager::GetCorrectedStep ( )

inline

Definition at line 307 of file G4SteppingManager.hh.

                                                      {
    return CorrectedStep;
  }

Here is the caller graph for this function:

GetcurrentMinimumStep()

G4double G4SteppingManager::GetcurrentMinimumStep

(

)

GetfAlongStepDoItProcTriggered()

size_t G4SteppingManager::GetfAlongStepDoItProcTriggered ( )

inline

Definition at line 403 of file G4SteppingManager.hh.

                                                                 {
   return fAtRestDoItProcTriggered;
  }

Here is the caller graph for this function:

GetfAlongStepDoItVector()

G4ProcessVector * G4SteppingManager::GetfAlongStepDoItVector ( )

inline

Definition at line 371 of file G4SteppingManager.hh.

                                                                    {
   return fAlongStepDoItVector;
  }

Here is the caller graph for this function:

GetfAlongStepGetPhysIntVector()

G4ProcessVector * G4SteppingManager::GetfAlongStepGetPhysIntVector ( )

inline

Definition at line 382 of file G4SteppingManager.hh.

                                                                          {
   return fAlongStepGetPhysIntVector;
  }

Here is the caller graph for this function:

GetfAtRestDoItProcTriggered()

size_t G4SteppingManager::GetfAtRestDoItProcTriggered ( )

inline

Definition at line 400 of file G4SteppingManager.hh.

                                                              {
   return fAtRestDoItProcTriggered;
  }

Here is the caller graph for this function:

GetfAtRestDoItVector()

G4ProcessVector * G4SteppingManager::GetfAtRestDoItVector ( )

inline

Definition at line 368 of file G4SteppingManager.hh.

                                                                 {
   return fAtRestDoItVector;
  }

Here is the caller graph for this function:

GetfAtRestGetPhysIntVector()

G4ProcessVector * G4SteppingManager::GetfAtRestGetPhysIntVector ( )

inline

Definition at line 378 of file G4SteppingManager.hh.

                                                                       {
   return fAtRestGetPhysIntVector;
  }

Here is the caller graph for this function:

GetfCondition()

G4ForceCondition G4SteppingManager::GetfCondition ( )

inline

Definition at line 452 of file G4SteppingManager.hh.

                                                          {
   return fCondition;
  }

Here is the caller graph for this function:

GetfCurrentProcess()

G4VProcess * G4SteppingManager::GetfCurrentProcess ( )

inline

Definition at line 364 of file G4SteppingManager.hh.

                                                          {
   return fCurrentProcess;
  }

Here is the caller graph for this function:

GetfCurrentVolume()

G4VPhysicalVolume * G4SteppingManager::GetfCurrentVolume ( )

inline

Definition at line 358 of file G4SteppingManager.hh.

                                                                {
   return fCurrentVolume;
  }

Here is the caller graph for this function:

GetfGPILSelection()

G4GPILSelection G4SteppingManager::GetfGPILSelection ( )

inline

Definition at line 455 of file G4SteppingManager.hh.

                                                              {
   return fGPILSelection;
  }

Here is the caller graph for this function:

GetFirstStep()

G4bool G4SteppingManager::GetFirstStep ( )

inline

Definition at line 315 of file G4SteppingManager.hh.

                                               {
   return FirstStep;
  }

Here is the caller graph for this function:

GetfN2ndariesAlongStepDoIt()

G4int G4SteppingManager::GetfN2ndariesAlongStepDoIt ( )

inline

Definition at line 412 of file G4SteppingManager.hh.

                                                            {
   return fN2ndariesAlongStepDoIt;
  }

Here is the caller graph for this function:

GetfN2ndariesAtRestDoIt()

G4int G4SteppingManager::GetfN2ndariesAtRestDoIt ( )

inline

Definition at line 409 of file G4SteppingManager.hh.

                                                         {
   return fN2ndariesAtRestDoIt;
  }

Here is the caller graph for this function:

GetfN2ndariesPostStepDoIt()

G4int G4SteppingManager::GetfN2ndariesPostStepDoIt ( )

inline

Definition at line 415 of file G4SteppingManager.hh.

                                                           {
   return fN2ndariesPostStepDoIt;
  }

Here is the caller graph for this function:

GetfNavigator()

G4Navigator * G4SteppingManager::GetfNavigator ( )

inline

Definition at line 419 of file G4SteppingManager.hh.

                                                      {
   return fNavigator;
  }

Here is the caller graph for this function:

GetfParticleChange()

G4VParticleChange * G4SteppingManager::GetfParticleChange ( )

inline

Definition at line 337 of file G4SteppingManager.hh.

                                                                 {
   return fParticleChange;
  }

Here is the caller graph for this function:

GetfPostStepDoItProcTriggered()

size_t G4SteppingManager::GetfPostStepDoItProcTriggered ( )

inline

Definition at line 406 of file G4SteppingManager.hh.

                                                                {
   return fPostStepDoItProcTriggered;
  }

Here is the caller graph for this function:

GetfPostStepDoItVector()

G4ProcessVector * G4SteppingManager::GetfPostStepDoItVector ( )

inline

Definition at line 374 of file G4SteppingManager.hh.

                                                                   {
   return fPostStepDoItVector;
  }

Here is the caller graph for this function:

GetfPostStepGetPhysIntVector()

G4ProcessVector * G4SteppingManager::GetfPostStepGetPhysIntVector ( )

inline

Definition at line 386 of file G4SteppingManager.hh.

                                                                         {
   return fPostStepGetPhysIntVector;
  }

Here is the caller graph for this function:

GetfPostStepPoint()

G4StepPoint * G4SteppingManager::GetfPostStepPoint ( )

inline

Definition at line 354 of file G4SteppingManager.hh.

                                                          {
   return fPostStepPoint;
  }

Here is the caller graph for this function:

GetfPreStepPoint()

G4StepPoint * G4SteppingManager::GetfPreStepPoint ( )

inline

Definition at line 351 of file G4SteppingManager.hh.

                                                         {
   return fPreStepPoint;
  }

Here is the caller graph for this function:

GetfPreviousStepSize()

G4double G4SteppingManager::GetfPreviousStepSize ( )

inline

Definition at line 438 of file G4SteppingManager.hh.

                                                           {
   return fPreviousStepSize;
  }

Here is the caller graph for this function:

GetfSecondary()

G4TrackVector * G4SteppingManager::GetfSecondary ( )

inline

Definition at line 345 of file G4SteppingManager.hh.

                                                        {
   return fStep->GetfSecondary();
  }

Here is the caller graph for this function:

GetfSelectedAlongStepDoItVector()

G4SelectedAlongStepDoItVector * G4SteppingManager::GetfSelectedAlongStepDoItVector ( )

inline

Definition at line 430 of file G4SteppingManager.hh.

                                                                                          {
   return fSelectedAlongStepDoItVector;
  }

Here is the caller graph for this function:

GetfSelectedAtRestDoItVector()

G4SelectedAtRestDoItVector * G4SteppingManager::GetfSelectedAtRestDoItVector ( )

inline

Definition at line 426 of file G4SteppingManager.hh.

                                                                                    {
   return fSelectedAtRestDoItVector;
  }

Here is the caller graph for this function:

GetfSelectedPostStepDoItVector()

G4SelectedPostStepDoItVector * G4SteppingManager::GetfSelectedPostStepDoItVector ( )

inline

Definition at line 434 of file G4SteppingManager.hh.

                                                                                        {
   return fSelectedPostStepDoItVector;
  }

Here is the caller graph for this function:

GetfSensitive()

G4VSensitiveDetector * G4SteppingManager::GetfSensitive ( )

inline

Definition at line 361 of file G4SteppingManager.hh.

                                                               {
   return fSensitive;
  }

Here is the caller graph for this function:

GetfStep()

G4Step * G4SteppingManager::GetfStep ( )

inline

Definition at line 348 of file G4SteppingManager.hh.

                                            {
   return fStep;
  }

Here is the caller graph for this function:

GetfStepStatus()

G4StepStatus G4SteppingManager::GetfStepStatus ( )

inline

Definition at line 319 of file G4SteppingManager.hh.

                                                       {
   return fStepStatus;
  }

Here is the caller graph for this function:

GetfTrack()

G4Track * G4SteppingManager::GetfTrack ( )

inline

Definition at line 341 of file G4SteppingManager.hh.

                                              {
   return fTrack;
  }

Here is the caller graph for this function:

GetGeometricalStep()

G4double G4SteppingManager::GetGeometricalStep ( )

inline

Definition at line 303 of file G4SteppingManager.hh.

                                                        {
    return GeometricalStep;
  }

Here is the caller graph for this function:

GetMass()

G4double G4SteppingManager::GetMass ( )

inline

Definition at line 329 of file G4SteppingManager.hh.

                                            {
   return Mass;
  }

Here is the caller graph for this function:

GetMAXofAlongStepLoops()

size_t G4SteppingManager::GetMAXofAlongStepLoops ( )

inline

Definition at line 393 of file G4SteppingManager.hh.

                                                         {
   return MAXofAlongStepLoops;
  }

Here is the caller graph for this function:

GetMAXofAtRestLoops()

size_t G4SteppingManager::GetMAXofAtRestLoops ( )

inline

Definition at line 390 of file G4SteppingManager.hh.

                                                      {
   return MAXofAtRestLoops;
  }

Here is the caller graph for this function:

GetMAXofPostStepLoops()

size_t G4SteppingManager::GetMAXofPostStepLoops ( )

inline

Definition at line 396 of file G4SteppingManager.hh.

                                                        {
   return MAXofPostStepLoops;
  }

Here is the caller graph for this function:

GetnumberOfInteractionLengthLeft()

G4double G4SteppingManager::GetnumberOfInteractionLengthLeft

(

)

GetPhysicalStep()

G4double G4SteppingManager::GetPhysicalStep ( )

inline

Definition at line 299 of file G4SteppingManager.hh.

                                                    {
    return PhysicalStep;
  }

Here is the caller graph for this function:

GetphysIntLength()

G4double G4SteppingManager::GetphysIntLength ( )

inline

Definition at line 449 of file G4SteppingManager.hh.

                                                     {
   return physIntLength;
  }

Here is the caller graph for this function:

GetPreStepPointIsGeom()

G4bool G4SteppingManager::GetPreStepPointIsGeom ( )

inline

Definition at line 311 of file G4SteppingManager.hh.

                                                        {
   return PreStepPointIsGeom;
  }

Here is the caller graph for this function:

GetProcessNumber()

void G4SteppingManager::GetProcessNumber

(

)

Definition at line 56 of file G4SteppingManager2.cc.

{
#ifdef debug
  G4cout<<"G4SteppingManager::GetProcessNumber: is called track="
        <<fTrack<<G4endl;
#endif

  G4ProcessManager* pm= fTrack->GetDefinition()->GetProcessManager();
  if(!pm)
  {
    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.");
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetSecondary()

const G4TrackVector * G4SteppingManager::GetSecondary ( ) const

inline

Definition at line 459 of file G4SteppingManager.hh.

                                                                    {
    return fStep->GetSecondary(); 
  }

Here is the caller graph for this function:

GetStep()

G4Step * G4SteppingManager::GetStep ( ) const

inline

Definition at line 486 of file G4SteppingManager.hh.

                                                  {
    return fStep;
  }

Here is the caller graph for this function:

GetStepControlFlag()

G4SteppingControl G4SteppingManager::GetStepControlFlag ( )

inline

Definition at line 446 of file G4SteppingManager.hh.

                                                                {
   return StepControlFlag;
  }

Here is the caller graph for this function:

GetsumEnergyChange()

G4double G4SteppingManager::GetsumEnergyChange ( )

inline

Definition at line 333 of file G4SteppingManager.hh.

                                                       {
   return sumEnergyChange;
  }

Here is the caller graph for this function:

GetTempInitVelocity()

G4double G4SteppingManager::GetTempInitVelocity ( )

inline

Definition at line 323 of file G4SteppingManager.hh.

                                                        {
   return TempInitVelocity;
  }

Here is the caller graph for this function:

GetTempVelocity()

G4double G4SteppingManager::GetTempVelocity ( )

inline

Definition at line 326 of file G4SteppingManager.hh.

                                                    {
   return TempVelocity;
  }

Here is the caller graph for this function:

GetTouchableHandle()

const G4TouchableHandle & G4SteppingManager::GetTouchableHandle ( )

inline

Definition at line 442 of file G4SteppingManager.hh.

                                                                        {
   return fTouchableHandle;
  }

Here is the caller graph for this function:

GetTrack()

G4Track * G4SteppingManager::GetTrack ( ) const

inline

Definition at line 474 of file G4SteppingManager.hh.

                                                    {
    return fTrack; 
  }

Here is the caller graph for this function:

GetUserAction()

G4UserSteppingAction * G4SteppingManager::GetUserAction ( )

inline

Definition at line 470 of file G4SteppingManager.hh.

                                                               {
    return fUserSteppingAction;
  }

Here is the caller graph for this function:

GetverboseLevel()

G4int G4SteppingManager::GetverboseLevel ( )

inline

Definition at line 422 of file G4SteppingManager.hh.

                                                 {
   return verboseLevel;
  }

Here is the caller graph for this function:

InvokeAlongStepDoItProcs()

void G4SteppingManager::InvokeAlongStepDoItProcs ( )

private

Definition at line 400 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' at here !!!
   }

// Invoke the all active continuous processes
   for( 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
                         // !!!!! Verbose
               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 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 && tempSecondaryTrack->GetDefinition()->IsGeneralIon())
           { pm = G4ParticleTable::GetParticleTable()->GetGenericIon()->GetProcessManager(); }
       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 );
   }

}

Here is the call graph for this function:

Here is the caller graph for this function:

InvokeAtRestDoItProcs()

void G4SteppingManager::InvokeAtRestDoItProcs ( )

private

Definition at line 282 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( size_t ri=0 ; ri < MAXofAtRestLoops ; ri++ ){
     fCurrentProcess = (*fAtRestGetPhysIntVector)[ri];
     if (fCurrentProcess== 0) {
       (*fSelectedAtRestDoItVector)[ri] = InActivated;
       NofInactiveProc++;
       continue;
     }   // NULL means the process is inactivated by a user on fly.

     lifeTime =
       fCurrentProcess->AtRestGPIL( *fTrack, &fCondition );

     

     if(fCondition==Forced && fCurrentProcess){
       (*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. );

// invoke selected process
   for(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 && tempSecondaryTrack->GetDefinition()->IsGeneralIon())
           { pm = G4ParticleTable::GetParticleTable()->GetGenericIon()->GetProcessManager(); }
       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(size_t np=0; np < MAXofAtRestLoops; np++){
   fStep->UpdateTrack();

   fTrack->SetTrackStatus( fStopAndKill );
}

Here is the call graph for this function:

Here is the caller graph for this function:

InvokePostStepDoItProcs()

void G4SteppingManager::InvokePostStepDoItProcs ( )

private

Definition at line 483 of file G4SteppingManager2.cc.

{

// Invoke the specified discrete processes
   for(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 == Conditionally) && (fStepStatus == fAlongStepDoItProc)) ||
       ((Cond == ExclusivelyForced) && (fStepStatus == fExclusivelyForcedProc)) || 
       ((Cond == StronglyForced) ) 
      ) {

     InvokePSDIP(np);
         if ((np==0) && (fTrack->GetNextVolume() == 0)){
           fStepStatus = fWorldBoundary;
           fStep->GetPostStepPoint()->SetStepStatus( fStepStatus );
         }
       }
     } //if(*fSelectedPostStepDoItVector(np)........

     // Exit from PostStepLoop if the track has been killed,
     // but extra treatment for processes with Strongly Forced flag
     if(fTrack->GetTrackStatus() == fStopAndKill) {
       for(size_t np1=np+1; np1 < MAXofPostStepLoops; np1++){ 
     G4int Cond2 = (*fSelectedPostStepDoItVector)[MAXofPostStepLoops-np1-1];
     if (Cond2 == StronglyForced) {
       InvokePSDIP(np1);
         }
       }
       break;
     }
   } //for(size_t np=0; np < MAXofPostStepLoops; np++){
}

Here is the call graph for this function:

Here is the caller graph for this function:

InvokePSDIP()

void G4SteppingManager::InvokePSDIP ( size_t  np )

private

Definition at line 526 of file G4SteppingManager2.cc.

{
         fCurrentProcess = (*fPostStepDoItVector)[np];
         fParticleChange 
            = fCurrentProcess->PostStepDoIt( *fTrack, *fStep);

         // Update PostStepPoint of Step according to ParticleChange
     fParticleChange->UpdateStepForPostStep(fStep);
#ifdef G4VERBOSE
                 // !!!!! Verbose
           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 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 && tempSecondaryTrack->GetDefinition()->IsGeneralIon())
              { pm = G4ParticleTable::GetParticleTable()->GetGenericIon()->GetProcessManager(); }
          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();
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetInitialStep()

void G4SteppingManager::SetInitialStep

(

G4Track *

valueTrack

)

Definition at line 256 of file G4SteppingManager.cc.

{

// Set up several local variables.
   PreStepPointIsGeom = false;
   FirstStep = true;
   fParticleChange = 0;
   fPreviousStepSize = 0.;
   fStepStatus = fUndefined;

   fTrack = valueTrack;
   Mass = fTrack->GetDynamicParticle()->GetMass();

   PhysicalStep = 0.;
   GeometricalStep = 0.;
   CorrectedStep = 0.;
   PreStepPointIsGeom = false;
   FirstStep = false;
   fStepStatus = fUndefined;

   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 ){
     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==0 ){
       // 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 attribues of 'Step'
       fStep->InitializeStep( fTrack );
   }
#ifdef G4VERBOSE
                         // !!!!! Verbose
   if(verboseLevel>0) fVerbose->TrackingStarted();
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetNavigator()

void G4SteppingManager::SetNavigator ( G4Navigator *  value )

inline

Definition at line 463 of file G4SteppingManager.hh.

                                                               {
    fNavigator = value; 
  }

Here is the caller graph for this function:

SetUserAction()

void G4SteppingManager::SetUserAction ( G4UserSteppingAction *  apAction )

inline

Definition at line 467 of file G4SteppingManager.hh.

                                                                            {
    fUserSteppingAction = apAction;
  }

Here is the caller graph for this function:

SetVerbose()

void G4SteppingManager::SetVerbose ( G4VSteppingVerbose *  yourVerbose )

inline

Definition at line 482 of file G4SteppingManager.hh.

                                                                          {
     fVerbose = yourVerbose;
  }

SetVerboseLevel()

void G4SteppingManager::SetVerboseLevel ( G4int  vLevel )

inline

Definition at line 478 of file G4SteppingManager.hh.

                                                            {
    verboseLevel = vLevel; 
  }

Here is the caller graph for this function:

Stepping()

G4StepStatus G4SteppingManager::Stepping

(

)

Definition at line 116 of file G4SteppingManager.cc.

{

//--------
// Prelude
//--------
#ifdef G4VERBOSE
            // !!!!! Verbose
             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;

//JA 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(0);

//-----------------
// AtRest Processes
//-----------------

   if( fTrack->GetTrackStatus() == fStopButAlive ){
     if( MAXofAtRestLoops>0 ){
        InvokeAtRestDoItProcs();
        fStepStatus = fAtRestDoItProc;
        fStep->GetPostStepPoint()->SetStepStatus( fStepStatus );
       
#ifdef G4VERBOSE
            // !!!!! Verbose
             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
                         // !!!!! Verbose
           if(verboseLevel>0) fVerbose->AlongStepDoItAllDone();
#endif

     // Invoke PostStepDoIt
     InvokePostStepDoItProcs();

#ifdef G4VERBOSE
                 // !!!!! Verbose
     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
                         // !!!!! Verbose

           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 != 0 && StepControlFlag != AvoidHitInvocation) {
      fSensitive = fStep->GetPreStepPoint()->
                                   GetSensitiveDetector();
      if( fSensitive != 0 ) {
        fSensitive->Hit(fStep);
      }
   }

// User intervention process.
   if( fUserSteppingAction != 0 ) {
      fUserSteppingAction->UserSteppingAction(fStep);
   }
   G4UserSteppingAction* regionalAction
    = fStep->GetPreStepPoint()->GetPhysicalVolume()->GetLogicalVolume()->GetRegion()
      ->GetRegionalSteppingAction();
   if( regionalAction ) regionalAction->UserSteppingAction(fStep);

// Stepping process finish. Return the value of the StepStatus.
   return fStepStatus;

}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

CorrectedStep

G4double G4SteppingManager::CorrectedStep

private

Definition at line 213 of file G4SteppingManager.hh.

endpointSafety

G4double G4SteppingManager::endpointSafety

private

Definition at line 279 of file G4SteppingManager.hh.

endpointSafOrigin

G4ThreeVector G4SteppingManager::endpointSafOrigin

private

Definition at line 278 of file G4SteppingManager.hh.

fAlongStepDoItProcTriggered

size_t G4SteppingManager::fAlongStepDoItProcTriggered

private

Definition at line 251 of file G4SteppingManager.hh.

fAlongStepDoItVector

G4ProcessVector* G4SteppingManager::fAlongStepDoItVector

private

Definition at line 239 of file G4SteppingManager.hh.

fAlongStepGetPhysIntVector

G4ProcessVector* G4SteppingManager::fAlongStepGetPhysIntVector

private

Definition at line 243 of file G4SteppingManager.hh.

fAtRestDoItProcTriggered

size_t G4SteppingManager::fAtRestDoItProcTriggered

private

Definition at line 250 of file G4SteppingManager.hh.

fAtRestDoItVector

G4ProcessVector* G4SteppingManager::fAtRestDoItVector

private

Definition at line 238 of file G4SteppingManager.hh.

fAtRestGetPhysIntVector

G4ProcessVector* G4SteppingManager::fAtRestGetPhysIntVector

private

Definition at line 242 of file G4SteppingManager.hh.

fCondition

G4ForceCondition G4SteppingManager::fCondition

private

Definition at line 283 of file G4SteppingManager.hh.

fCurrentProcess

G4VProcess* G4SteppingManager::fCurrentProcess

private

Definition at line 233 of file G4SteppingManager.hh.

fCurrentVolume

G4VPhysicalVolume* G4SteppingManager::fCurrentVolume

private

Definition at line 231 of file G4SteppingManager.hh.

fGPILSelection

G4GPILSelection G4SteppingManager::fGPILSelection

private

Definition at line 284 of file G4SteppingManager.hh.

FirstStep

G4bool G4SteppingManager::FirstStep

private

Definition at line 215 of file G4SteppingManager.hh.

fN2ndariesAlongStepDoIt

G4int G4SteppingManager::fN2ndariesAlongStepDoIt

private

Definition at line 255 of file G4SteppingManager.hh.

fN2ndariesAtRestDoIt

G4int G4SteppingManager::fN2ndariesAtRestDoIt

private

Definition at line 254 of file G4SteppingManager.hh.

fN2ndariesPostStepDoIt

G4int G4SteppingManager::fN2ndariesPostStepDoIt

private

Definition at line 256 of file G4SteppingManager.hh.

fNavigator

G4Navigator* G4SteppingManager::fNavigator

private

Definition at line 260 of file G4SteppingManager.hh.

fParticleChange

G4VParticleChange* G4SteppingManager::fParticleChange

private

Definition at line 224 of file G4SteppingManager.hh.

fPostStepDoItProcTriggered

size_t G4SteppingManager::fPostStepDoItProcTriggered

private

Definition at line 252 of file G4SteppingManager.hh.

fPostStepDoItVector

G4ProcessVector* G4SteppingManager::fPostStepDoItVector

private

Definition at line 240 of file G4SteppingManager.hh.

fPostStepGetPhysIntVector

G4ProcessVector* G4SteppingManager::fPostStepGetPhysIntVector

private

Definition at line 244 of file G4SteppingManager.hh.

fPostStepPoint

G4StepPoint* G4SteppingManager::fPostStepPoint

private

Definition at line 229 of file G4SteppingManager.hh.

fPreStepPoint

G4StepPoint* G4SteppingManager::fPreStepPoint

private

Definition at line 228 of file G4SteppingManager.hh.

fPreviousStepSize

G4double G4SteppingManager::fPreviousStepSize

private

Definition at line 268 of file G4SteppingManager.hh.

fSecondary

G4TrackVector* G4SteppingManager::fSecondary

private

Definition at line 226 of file G4SteppingManager.hh.

fSelectedAlongStepDoItVector

G4SelectedAlongStepDoItVector* G4SteppingManager::fSelectedAlongStepDoItVector

private

Definition at line 265 of file G4SteppingManager.hh.

fSelectedAtRestDoItVector

G4SelectedAtRestDoItVector* G4SteppingManager::fSelectedAtRestDoItVector

private

Definition at line 264 of file G4SteppingManager.hh.

fSelectedPostStepDoItVector

G4SelectedPostStepDoItVector* G4SteppingManager::fSelectedPostStepDoItVector

private

Definition at line 266 of file G4SteppingManager.hh.

fSensitive

G4VSensitiveDetector* G4SteppingManager::fSensitive

private

Definition at line 232 of file G4SteppingManager.hh.

fStep

G4Step* G4SteppingManager::fStep

private

Definition at line 227 of file G4SteppingManager.hh.

fStepStatus

G4StepStatus G4SteppingManager::fStepStatus

private

Definition at line 216 of file G4SteppingManager.hh.

fTouchableHandle

G4TouchableHandle G4SteppingManager::fTouchableHandle

private

Definition at line 270 of file G4SteppingManager.hh.

fTrack

G4Track* G4SteppingManager::fTrack

private

Definition at line 225 of file G4SteppingManager.hh.

fUserSteppingAction

G4UserSteppingAction* G4SteppingManager::fUserSteppingAction

private

Definition at line 207 of file G4SteppingManager.hh.

fVerbose

G4VSteppingVerbose* G4SteppingManager::fVerbose

private

Definition at line 209 of file G4SteppingManager.hh.

GeometricalStep

G4double G4SteppingManager::GeometricalStep

private

Definition at line 212 of file G4SteppingManager.hh.

kCarTolerance

G4double G4SteppingManager::kCarTolerance

private

Definition at line 274 of file G4SteppingManager.hh.

KillVerbose

G4bool G4SteppingManager::KillVerbose

Definition at line 186 of file G4SteppingManager.hh.

Mass

G4double G4SteppingManager::Mass

private

Definition at line 220 of file G4SteppingManager.hh.

MAXofAlongStepLoops

size_t G4SteppingManager::MAXofAlongStepLoops

private

Definition at line 247 of file G4SteppingManager.hh.

MAXofAtRestLoops

size_t G4SteppingManager::MAXofAtRestLoops

private

Definition at line 246 of file G4SteppingManager.hh.

MAXofPostStepLoops

size_t G4SteppingManager::MAXofPostStepLoops

private

Definition at line 248 of file G4SteppingManager.hh.

PhysicalStep

G4double G4SteppingManager::PhysicalStep

private

Definition at line 211 of file G4SteppingManager.hh.

physIntLength

G4double G4SteppingManager::physIntLength

private

Definition at line 282 of file G4SteppingManager.hh.

PreStepPointIsGeom

G4bool G4SteppingManager::PreStepPointIsGeom

private

Definition at line 214 of file G4SteppingManager.hh.

proposedSafety

G4double G4SteppingManager::proposedSafety

private

Definition at line 276 of file G4SteppingManager.hh.

StepControlFlag

G4SteppingControl G4SteppingManager::StepControlFlag

private

Definition at line 272 of file G4SteppingManager.hh.

sumEnergyChange

G4double G4SteppingManager::sumEnergyChange

private

Definition at line 222 of file G4SteppingManager.hh.

TempInitVelocity

G4double G4SteppingManager::TempInitVelocity

private

Definition at line 218 of file G4SteppingManager.hh.

TempVelocity

G4double G4SteppingManager::TempVelocity

private

Definition at line 219 of file G4SteppingManager.hh.

verboseLevel

G4int G4SteppingManager::verboseLevel

private

Definition at line 262 of file G4SteppingManager.hh.

---

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

• G4SteppingManager.hh
• G4SteppingManager.cc
• G4SteppingManager2.cc