G4Transportation Class Reference

#include <G4Transportation.hh>

Inheritance diagram for G4Transportation:

Public Member Functions
G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)
G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety, G4GPILSelection *selection)
G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)
virtual void	DumpInfo () const
void	EnableShortStepOptimisation (G4bool optimise=true)
virtual void	EndTracking ()
G4bool	FieldExertedForce ()
	G4Transportation (G4int verbosityLevel=1)
G4double	GetCurrentInteractionLength () const
const G4VProcess *	GetMasterProcess () const
G4double	GetMaxEnergyKilled () const
G4double	GetNumberOfInteractionLengthLeft () const
const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
G4double	GetPILfactor () const
virtual const G4ProcessManager *	GetProcessManager ()
const G4String &	GetProcessName () const
G4int	GetProcessSubType () const
G4ProcessType	GetProcessType () const
G4PropagatorInField *	GetPropagatorInField ()
G4double	GetSumEnergyKilled () const
G4double	GetThresholdImportantEnergy () const
G4int	GetThresholdTrials () const
G4double	GetThresholdWarningEnergy () const
G4double	GetTotalNumberOfInteractionLengthTraversed () const
G4int	GetVerboseLevel () const
G4bool	isAlongStepDoItIsEnabled () const
virtual G4bool	IsApplicable (const G4ParticleDefinition &)
G4bool	isAtRestDoItIsEnabled () const
G4bool	isPostStepDoItIsEnabled () const
G4bool	operator!= (const G4VProcess &right) const
G4bool	operator== (const G4VProcess &right) const
G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)
G4double	PostStepGetPhysicalInteractionLength (const G4Track &, G4double previousStepSize, G4ForceCondition *pForceCond)
G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
virtual void	PreparePhysicsTable (const G4ParticleDefinition &)
virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)
void	PrintStatistics (std::ostream &outStr) const
virtual void	ProcessDescription (std::ostream &outFile) const
void	PushThresholdsToLogger ()
void	ReportLooperThresholds ()
void	ResetKilledStatistics (G4int report=1)
virtual void	ResetNumberOfInteractionLengthLeft ()
virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
void	SetHighLooperThresholds ()
void	SetLowLooperThresholds ()
virtual void	SetMasterProcess (G4VProcess *masterP)
void	SetPILfactor (G4double value)
virtual void	SetProcessManager (const G4ProcessManager *)
void	SetProcessSubType (G4int)
void	SetProcessType (G4ProcessType)
void	SetPropagatorInField (G4PropagatorInField *pFieldPropagator)
void	SetThresholdImportantEnergy (G4double newEnImp)
void	SetThresholdTrials (G4int newMaxTrials)
void	SetThresholdWarningEnergy (G4double newEnWarn)
void	SetVerboseLevel (G4int value)
void	StartTracking (G4Track *aTrack)
virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
	~G4Transportation ()

Static Public Member Functions
static G4bool	EnableGravity (G4bool useGravity=true)
static G4bool	EnableMagneticMoment (G4bool useMoment=true)
static G4bool	EnableUseMagneticMoment (G4bool useMoment=true)
static const G4String &	GetProcessTypeName (G4ProcessType)
static G4bool	GetSilenceLooperWarnings ()
static void	SetSilenceLooperWarnings (G4bool val)

Protected Member Functions
void	ClearNumberOfInteractionLengthLeft ()
G4bool	DoesAnyFieldExist ()
void	ReportMissingLogger (const char *methodName)
void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)

Protected Attributes
G4ParticleChange	aParticleChange
const G4ProcessManager *	aProcessManager = nullptr
G4double	currentInteractionLength = -1.0
G4bool	enableAlongStepDoIt = true
G4bool	enableAtRestDoIt = true
G4bool	enablePostStepDoIt = true
G4VParticleChange *	pParticleChange = nullptr
G4double	theInitialNumberOfInteractionLength = -1.0
G4double	theNumberOfInteractionLengthLeft = -1.0
G4String	thePhysicsTableFileName
G4double	thePILfactor = 1.0
G4String	theProcessName
G4int	theProcessSubType = -1
G4ProcessType	theProcessType = fNotDefined
G4int	verboseLevel = 0

Private Attributes
G4int	fAbandonUnstableTrials = 0
G4bool	fAnyFieldExists = false
G4double	fCandidateEndGlobalTime = 0.0
G4TouchableHandle	fCurrentTouchableHandle
G4bool	fEndGlobalTimeComputed = false
G4double	fEndPointDistance
G4bool	fFieldExertedForce = false
G4PropagatorInField *	fFieldPropagator
G4bool	fFirstStepInVolume = true
G4bool	fGeometryLimitedStep = true
G4bool	fLastStepInVolume = false
G4Navigator *	fLinearNavigator
G4double	fMaxEnergyKilled = -1.0
G4int	fMaxEnergyKilled_NonElecPDG = 0
G4double	fMaxEnergyKilled_NonElectron = -1.0
G4int	fMaxEnergyKilledPDG = 0
G4double	fMaxEnergySaved = -1.0
G4bool	fMomentumChanged = true
G4bool	fNewTrack = true
G4int	fNoLooperTrials = 0
unsigned long	fNumLoopersKilled = 0
unsigned long	fNumLoopersKilled_NonElectron = 0
G4ParticleChangeForTransport	fParticleChange
G4bool	fParticleIsLooping = false
G4TransportationLogger *	fpLogger
G4double	fPreviousSafety
G4ThreeVector	fPreviousSftOrigin
G4ProcessTable *	fProcessTable = nullptr
G4SafetyHelper *	fpSafetyHelper
G4bool	fShortStepOptimisation
G4double	fSumEnergyKilled = 0.0
G4double	fSumEnergyKilled_NonElectron = 0.0
G4double	fSumEnergySaved = 0.0
G4double	fSumEnergyUnstableSaved = 0.0
G4double	fSumEnerSqKilled = 0.0
G4double	fSumEnerSqKilled_NonElectron = 0.0
G4double	fThreshold_Important_Energy = 1.0 * CLHEP::MeV
G4double	fThreshold_Warning_Energy = 1.0 * CLHEP::keV
G4int	fThresholdTrials = 10
G4double	fTransportEndKineticEnergy = 0.0
G4ThreeVector	fTransportEndMomentumDir = G4ThreeVector( 0.0, 0.0, 0.0 )
G4ThreeVector	fTransportEndPosition = G4ThreeVector( 0.0, 0.0, 0.0 )
G4ThreeVector	fTransportEndSpin = G4ThreeVector( 0.0, 0.0, 0.0 )
G4VProcess *	masterProcessShadow = nullptr

Static Private Attributes
static G4bool	fSilenceLooperWarnings = false
static G4bool	fUseGravity = false
static G4bool	fUseMagneticMoment =false

Friends
class	G4CoupledTransportation

Detailed Description

Definition at line 60 of file G4Transportation.hh.

Constructor & Destructor Documentation

G4Transportation()

G4Transportation::G4Transportation

(

G4int

verbosityLevel = 1

)

Definition at line 69 of file G4Transportation.cc.

  : G4VProcess( G4String("Transportation"), fTransportation ),
    fFieldExertedForce( false ),
    fPreviousSftOrigin( 0.,0.,0. ),
    fPreviousSafety( 0.0 ),
    fEndPointDistance( -1.0 ), 
    fShortStepOptimisation( false ) // Old default: true (=fast short steps)
{
  SetProcessSubType(static_cast<G4int>(TRANSPORTATION));
  pParticleChange= &fParticleChange;   // Required to conform to G4VProcess 
  SetVerboseLevel(verbosity);
 
  G4TransportationManager* transportMgr ; 
 
  transportMgr = G4TransportationManager::GetTransportationManager() ; 
 
  fLinearNavigator = transportMgr->GetNavigatorForTracking() ; 
 
  fFieldPropagator = transportMgr->GetPropagatorInField() ;
 
  fpSafetyHelper =   transportMgr->GetSafetyHelper();  // New 
 
  fpLogger = new G4TransportationLogger("G4Transportation", verbosity);
 
  SetHighLooperThresholds();
  // Use the old defaults: Warning = 100 MeV, Important = 250 MeV, No Trials = 10;
  
  PushThresholdsToLogger();
  // Should be done by Set methods in SetHighLooperThresholds -- making sure
  
  // Cannot determine whether a field exists here, as it would 
  //  depend on the relative order of creating the detector's 
  //  field and this process. That order is not guaranted.
  fAnyFieldExists= DoesAnyFieldExist();
  //  This value must be updated using DoesAnyFieldExist() at least at the
  //    start of each Run -- for now this is at the Start of every Track. TODO
  
  static G4ThreadLocal G4TouchableHandle* pNullTouchableHandle = 0;
  if ( !pNullTouchableHandle)
  {
    pNullTouchableHandle = new G4TouchableHandle;
  }
  fCurrentTouchableHandle = *pNullTouchableHandle;
    // Points to (G4VTouchable*) 0
 
  
#ifdef G4VERBOSE
  if( verboseLevel > 0) 
  { 
     G4cout << " G4Transportation constructor> set fShortStepOptimisation to "; 
     if ( fShortStepOptimisation )  { G4cout << "true"  << G4endl; }
     else                           { G4cout << "false" << G4endl; }
  } 
#endif
}

References DoesAnyFieldExist(), fAnyFieldExists, fCurrentTouchableHandle, fFieldPropagator, fLinearNavigator, fParticleChange, fpLogger, fpSafetyHelper, fShortStepOptimisation, G4cout, G4endl, G4ThreadLocal, G4TransportationManager::GetNavigatorForTracking(), G4TransportationManager::GetPropagatorInField(), G4TransportationManager::GetSafetyHelper(), G4TransportationManager::GetTransportationManager(), G4VProcess::pParticleChange, PushThresholdsToLogger(), SetHighLooperThresholds(), G4VProcess::SetProcessSubType(), G4VProcess::SetVerboseLevel(), TRANSPORTATION, and G4VProcess::verboseLevel.

~G4Transportation()

G4Transportation::~G4Transportation

(

)

Definition at line 127 of file G4Transportation.cc.

{
  if( fSumEnergyKilled > 0.0 )
  {
     PrintStatistics( G4cout );     
  }
  delete fpLogger;
}

References fpLogger, fSumEnergyKilled, G4cout, and PrintStatistics().

Member Function Documentation

AlongStepDoIt()

G4VParticleChange * G4Transportation::AlongStepDoIt ( const G4Track &  track, const G4Step &  stepData  )

virtual

Implements G4VProcess.

Definition at line 492 of file G4Transportation.cc.

{
#if defined(G4VERBOSE) || defined(G4DEBUG_TRANSPORT)
  static G4ThreadLocal G4long noCallsASDI=0;
  noCallsASDI++;
#else
  #define noCallsASDI 0
#endif
 
  fParticleChange.Initialize(track) ;
 
  //  Code for specific process 
  //
  fParticleChange.ProposePosition(fTransportEndPosition) ;
  fParticleChange.ProposeMomentumDirection(fTransportEndMomentumDir) ;
  fParticleChange.ProposeEnergy(fTransportEndKineticEnergy) ;
  fParticleChange.SetMomentumChanged(fMomentumChanged) ;
 
  fParticleChange.ProposePolarization(fTransportEndSpin);
 
  G4double deltaTime = 0.0 ;
 
  // Calculate  Lab Time of Flight (ONLY if field Equations used it!)
  // G4double endTime   = fCandidateEndGlobalTime;
  // G4double delta_time = endTime - startTime;
 
  G4double startTime = track.GetGlobalTime() ;
  
  if (!fEndGlobalTimeComputed)
  {
     // The time was not integrated .. make the best estimate possible
     //
     G4double initialVelocity = stepData.GetPreStepPoint()->GetVelocity();
     G4double stepLength      = track.GetStepLength();
 
     deltaTime= 0.0;  // in case initialVelocity = 0 
     if ( initialVelocity > 0.0 )  { deltaTime = stepLength/initialVelocity; }
 
     fCandidateEndGlobalTime   = startTime + deltaTime ;
     fParticleChange.ProposeLocalTime(  track.GetLocalTime() + deltaTime) ;
  }
  else
  {
     deltaTime = fCandidateEndGlobalTime - startTime ;
     fParticleChange.ProposeGlobalTime( fCandidateEndGlobalTime ) ;
  }
 
 
  // Now Correct by Lorentz factor to get delta "proper" Time
  
  G4double  restMass       = track.GetDynamicParticle()->GetMass() ;
  G4double deltaProperTime = deltaTime*( restMass/track.GetTotalEnergy() ) ;
 
  fParticleChange.ProposeProperTime(track.GetProperTime() + deltaProperTime) ;
  //fParticleChange.ProposeTrueStepLength( track.GetStepLength() ) ;
 
  // If the particle is caught looping or is stuck (in very difficult
  // boundaries) in a magnetic field (doing many steps) THEN can kill it ...
  //
  if ( fParticleIsLooping )
  {
      G4double endEnergy= fTransportEndKineticEnergy;
      fNoLooperTrials ++; 
      auto particleType= track.GetDynamicParticle()->GetParticleDefinition();
      
      G4bool stable = particleType->GetPDGStable();
      G4bool candidateForEnd = (endEnergy < fThreshold_Important_Energy) 
                            || (fNoLooperTrials >= fThresholdTrials) ;
      G4bool unstableAndKillable = !stable && ( fAbandonUnstableTrials != 0);
      G4bool unstableForEnd = (endEnergy < fThreshold_Important_Energy)
                              && (fNoLooperTrials >= fAbandonUnstableTrials) ;
      if( (candidateForEnd && stable) || (unstableAndKillable && unstableForEnd) )
      {
        // Kill the looping particle 
        //
        fParticleChange.ProposeTrackStatus( fStopAndKill )  ;
        G4int particlePDG= particleType->GetPDGEncoding();
        const G4int electronPDG= 11; // G4Electron::G4Electron()->GetPDGEncoding();
 
        // Simple statistics
        fSumEnergyKilled += endEnergy;
        fSumEnerSqKilled = endEnergy * endEnergy;
        fNumLoopersKilled++;
        
        if( endEnergy > fMaxEnergyKilled ) {
           fMaxEnergyKilled = endEnergy;
           fMaxEnergyKilledPDG = particlePDG; 
        }
        if(  particleType->GetPDGEncoding() != electronPDG )
        {
           fSumEnergyKilled_NonElectron += endEnergy;
           fSumEnerSqKilled_NonElectron += endEnergy * endEnergy;
           fNumLoopersKilled_NonElectron++;
           
           if( endEnergy > fMaxEnergyKilled_NonElectron )
           {
              fMaxEnergyKilled_NonElectron = endEnergy;
              fMaxEnergyKilled_NonElecPDG =  particlePDG;
           }
        }
 
        if( endEnergy > fThreshold_Warning_Energy && ! fSilenceLooperWarnings )
        {
          fpLogger->ReportLoopingTrack( track, stepData, fNoLooperTrials,
                                        noCallsASDI, __func__ );
        }
        fNoLooperTrials=0; 
      }
      else
      {
        fMaxEnergySaved = std::max( endEnergy, fMaxEnergySaved);
        if( fNoLooperTrials == 1 ) {
          fSumEnergySaved += endEnergy;
          if ( !stable )
             fSumEnergyUnstableSaved += endEnergy;
        }
#ifdef G4VERBOSE
        if( verboseLevel > 2 && ! fSilenceLooperWarnings )
        {
          G4cout << "   " << __func__
                 << " Particle is looping but is saved ..."  << G4endl             
                 << "   Number of trials = " << fNoLooperTrials << G4endl
                 << "   No of calls to  = " << noCallsASDI << G4endl;
        }
#endif
      }
  }
  else
  {
      fNoLooperTrials=0; 
  }
 
  // Another (sometimes better way) is to use a user-limit maximum Step size
  // to alleviate this problem .. 
 
  // Introduce smooth curved trajectories to particle-change
  //
  fParticleChange.SetPointerToVectorOfAuxiliaryPoints
    (fFieldPropagator->GimmeTrajectoryVectorAndForgetIt() );
 
  return &fParticleChange ;
}

References fAbandonUnstableTrials, fCandidateEndGlobalTime, fEndGlobalTimeComputed, fFieldPropagator, fMaxEnergyKilled, fMaxEnergyKilled_NonElecPDG, fMaxEnergyKilled_NonElectron, fMaxEnergyKilledPDG, fMaxEnergySaved, fMomentumChanged, fNoLooperTrials, fNumLoopersKilled, fNumLoopersKilled_NonElectron, fParticleChange, fParticleIsLooping, fpLogger, fSilenceLooperWarnings, fStopAndKill, fSumEnergyKilled, fSumEnergyKilled_NonElectron, fSumEnergySaved, fSumEnergyUnstableSaved, fSumEnerSqKilled, fSumEnerSqKilled_NonElectron, fThreshold_Important_Energy, fThreshold_Warning_Energy, fThresholdTrials, fTransportEndKineticEnergy, fTransportEndMomentumDir, fTransportEndPosition, fTransportEndSpin, G4cout, G4endl, G4ThreadLocal, G4Track::GetDynamicParticle(), G4Track::GetGlobalTime(), G4Track::GetLocalTime(), G4DynamicParticle::GetMass(), G4DynamicParticle::GetParticleDefinition(), G4ParticleDefinition::GetPDGStable(), G4Step::GetPreStepPoint(), G4Track::GetProperTime(), G4Track::GetStepLength(), G4Track::GetTotalEnergy(), G4StepPoint::GetVelocity(), G4PropagatorInField::GimmeTrajectoryVectorAndForgetIt(), G4ParticleChangeForTransport::Initialize(), G4INCL::Math::max(), noCallsASDI, G4ParticleChange::ProposeEnergy(), G4ParticleChange::ProposeGlobalTime(), G4ParticleChange::ProposeLocalTime(), G4ParticleChange::ProposeMomentumDirection(), G4ParticleChange::ProposePolarization(), G4ParticleChange::ProposePosition(), G4ParticleChange::ProposeProperTime(), G4VParticleChange::ProposeTrackStatus(), G4TransportationLogger::ReportLoopingTrack(), G4ParticleChangeForTransport::SetMomentumChanged(), G4ParticleChangeForTransport::SetPointerToVectorOfAuxiliaryPoints(), and G4VProcess::verboseLevel.

AlongStepGetPhysicalInteractionLength()

G4double G4Transportation::AlongStepGetPhysicalInteractionLength ( const G4Track &  track, G4double  previousStepSize, G4double  currentMinimumStep, G4double &  currentSafety, G4GPILSelection *  selection  )

virtual

Implements G4VProcess.

Definition at line 181 of file G4Transportation.cc.

{
  // Initial actions moved to  StartTrack()
  // --------------------------------------
  // Note: in case another process changes touchable handle
  //    it will be necessary to add here (for all steps)
  // fCurrentTouchableHandle = aTrack->GetTouchableHandle();
 
  // GPILSelection is set to defaule value of CandidateForSelection
  // It is a return value
  //
  *selection = CandidateForSelection;
 
  // Get initial Energy/Momentum of the track
  //
  const G4ThreeVector startPosition    = track.GetPosition();
  const G4ThreeVector startMomentumDir = track.GetMomentumDirection();
 
  // The Step Point safety can be limited by other geometries and/or the
  // assumptions of any process - it's not always the geometrical safety.
  // We calculate the starting point's isotropic safety here.
  {
    const G4double MagSqShift = (startPosition - fPreviousSftOrigin).mag2();
 
    if(MagSqShift >= sqr(fPreviousSafety))
      currentSafety = 0.0;
    else
      currentSafety = fPreviousSafety - std::sqrt(MagSqShift);
  }
 
  // Is the particle charged or has it a magnetic moment?
  //
  const G4DynamicParticle* pParticle = track.GetDynamicParticle();
 
  const G4double particleMass   = pParticle->GetMass();
  const G4double particleCharge = pParticle->GetCharge();
  const G4double kineticEnergy = pParticle->GetKineticEnergy();
 
  const G4double magneticMoment    = pParticle->GetMagneticMoment();
  const G4ThreeVector particleSpin = pParticle->GetPolarization();
 
  // There is no need to locate the current volume. It is Done elsewhere:
  //   On track construction
  //   By the tracking, after all AlongStepDoIts, in "Relocation"
 
  // Check if the particle has a force, EM or gravitational, exerted on it
  //
 
  G4bool eligibleEM =
    (particleCharge != 0.0) || ((magneticMoment != 0.0) && fUseMagneticMoment);
  G4bool eligibleGrav = (particleMass != 0.0) && fUseGravity;
 
  fFieldExertedForce = false;
 
  if(eligibleEM || eligibleGrav)
  {
    if(G4FieldManager* fieldMgr =
         fFieldPropagator->FindAndSetFieldManager(track.GetVolume()))
    {
      // User can configure the field Manager for this track
      fieldMgr->ConfigureForTrack(&track);
      // Called here to allow a transition from no-field pointer
      // to finite field (non-zero pointer).
 
      // If the field manager has no field ptr, the field is zero
      //   by definition ( = there is no field ! )
      if(const G4Field* ptrField = fieldMgr->GetDetectorField())
        fFieldExertedForce =
          eligibleEM || (eligibleGrav && ptrField->IsGravityActive());
    }
  }
 
  G4double geometryStepLength = currentMinimumStep;
 
  if(currentMinimumStep == 0.0)
  {
    fEndPointDistance = 0.0;
    // flag step as geometry limited if current safety is also zero
    fGeometryLimitedStep = (currentSafety == 0.0);
 
    fMomentumChanged           = false;
    fParticleIsLooping         = false;
    fEndGlobalTimeComputed     = false;
    fTransportEndPosition      = startPosition;
    fTransportEndMomentumDir   = startMomentumDir;
    fTransportEndKineticEnergy = kineticEnergy;
    fTransportEndSpin          = particleSpin;
  }
  else if(!fFieldExertedForce)
  {
    fGeometryLimitedStep = false;
    if(geometryStepLength > currentSafety || !fShortStepOptimisation)
    {
      const G4double linearStepLength = fLinearNavigator->ComputeStep(
        startPosition, startMomentumDir, currentMinimumStep, currentSafety);
 
      if(linearStepLength <= currentMinimumStep)
      {
        geometryStepLength = linearStepLength;
        fGeometryLimitedStep = true;
      }
      // Remember last safety origin & value.
      //
      fPreviousSftOrigin = startPosition;
      fPreviousSafety    = currentSafety;
      fpSafetyHelper->SetCurrentSafety(currentSafety, startPosition);
    }
 
    fEndPointDistance    = geometryStepLength;
 
    fMomentumChanged       = false;
    fParticleIsLooping     = false;
    fEndGlobalTimeComputed = false;
    fTransportEndPosition =
      startPosition + geometryStepLength * startMomentumDir;
    fTransportEndMomentumDir   = startMomentumDir;
    fTransportEndKineticEnergy = kineticEnergy;
    fTransportEndSpin          = particleSpin;
  }
  else  //  A field exerts force
  {
    const auto pParticleDef    = pParticle->GetDefinition();
    const auto particlePDGSpin = pParticleDef->GetPDGSpin();
    const auto particlePDGMagM = pParticleDef->GetPDGMagneticMoment();
 
    auto equationOfMotion = fFieldPropagator->GetCurrentEquationOfMotion();
 
    // The charge can change (dynamic), therefore the use of G4ChargeState
    //
    equationOfMotion->SetChargeMomentumMass(
      G4ChargeState(particleCharge, magneticMoment, particlePDGSpin),
      pParticle->GetTotalMomentum(), particleMass);
 
    G4FieldTrack aFieldTrack(startPosition,
                             track.GetGlobalTime(),  // Lab.
                             startMomentumDir, kineticEnergy, particleMass,
                             particleCharge, particleSpin, particlePDGMagM,
                             0.0,  // Length along track
                             particlePDGSpin);
 
    // Do the Transport in the field (non recti-linear)
    //
    const G4double lengthAlongCurve = fFieldPropagator->ComputeStep(
      aFieldTrack, currentMinimumStep, currentSafety, track.GetVolume(),
      kineticEnergy < fThreshold_Important_Energy);
 
    if(lengthAlongCurve < geometryStepLength)
      geometryStepLength = lengthAlongCurve;
 
    // Remember last safety origin & value.
    //
    fPreviousSftOrigin = startPosition;
    fPreviousSafety    = currentSafety;
    fpSafetyHelper->SetCurrentSafety(currentSafety, startPosition);
 
    fGeometryLimitedStep = fFieldPropagator->IsLastStepInVolume();
    //
    // It is possible that step was reduced in PropagatorInField due to
    // previous zero steps. To cope with case that reduced step is taken
    // in full, we must rely on PiF to obtain this value
 
    G4bool changesEnergy =
      fFieldPropagator->GetCurrentFieldManager()->DoesFieldChangeEnergy();
 
    fMomentumChanged   = true;
    fParticleIsLooping = fFieldPropagator->IsParticleLooping();
 
    fEndGlobalTimeComputed = changesEnergy;
    fTransportEndPosition    = aFieldTrack.GetPosition();
    fTransportEndMomentumDir = aFieldTrack.GetMomentumDir();
 
    fEndPointDistance  = (fTransportEndPosition - startPosition).mag();
 
    // Ignore change in energy for fields that conserve energy
    // This hides the integration error, but gives a better physical answer
    fTransportEndKineticEnergy =
      changesEnergy ? aFieldTrack.GetKineticEnergy() : kineticEnergy;
    fTransportEndSpin = aFieldTrack.GetSpin();
 
    if(fEndGlobalTimeComputed)
    {
      // If the field can change energy, then the time must be integrated
      //    - so this should have been updated
      //
      fCandidateEndGlobalTime = aFieldTrack.GetLabTimeOfFlight();
 
      // was ( fCandidateEndGlobalTime != track.GetGlobalTime() );
      // a cleaner way is to have FieldTrack knowing whether time is updated.
    }
#if defined(G4VERBOSE) || defined(G4DEBUG_TRANSPORT)
    else
    {
      // The energy should be unchanged by field transport,
      //    - so the time changed will be calculated elsewhere
      //
      // Check that the integration preserved the energy
      //     -  and if not correct this!
      G4double startEnergy = kineticEnergy;
      G4double endEnergy   = fTransportEndKineticEnergy;
 
      static G4ThreadLocal G4int no_inexact_steps = 0, no_large_ediff;
      G4double absEdiff = std::fabs(startEnergy - endEnergy);
      if(absEdiff > perMillion * endEnergy)
      {
        no_inexact_steps++;
        // Possible statistics keeping here ...
      }
      if(verboseLevel > 1)
      {
        if(std::fabs(startEnergy - endEnergy) > perThousand * endEnergy)
        {
          static G4ThreadLocal G4int no_warnings = 0, warnModulo = 1,
                                     moduloFactor = 10;
          no_large_ediff++;
          if((no_large_ediff % warnModulo) == 0)
          {
            no_warnings++;
            std::ostringstream message;
            message << "Energy change in Step is above 1^-3 relative value. "
                    << G4endl << "     Relative change in 'tracking' step = "
                    << std::setw(15) << (endEnergy - startEnergy) / startEnergy
                    << G4endl << "     Starting E= " << std::setw(12)
                    << startEnergy / MeV << " MeV " << G4endl
                    << "     Ending   E= " << std::setw(12) << endEnergy / MeV
                    << " MeV " << G4endl
                    << "Energy has been corrected -- however, review"
                    << " field propagation parameters for accuracy." << G4endl;
            if((verboseLevel > 2) || (no_warnings < 4) ||
               (no_large_ediff == warnModulo * moduloFactor))
            {
              message << "These include EpsilonStepMax(/Min) in G4FieldManager "
                      << G4endl
                      << "which determine fractional error per step for "
                         "integrated quantities. "
                      << G4endl
                      << "Note also the influence of the permitted number of "
                         "integration steps."
                      << G4endl;
            }
            message << "Bad 'endpoint'. Energy change detected and corrected."
                    << G4endl << "Has occurred already " << no_large_ediff
                    << " times.";
            G4Exception("G4Transportation::AlongStepGetPIL()", "EnergyChange",
                        JustWarning, message);
            if(no_large_ediff == warnModulo * moduloFactor)
            {
              warnModulo *= moduloFactor;
            }
          }
        }
      }  // end of if (verboseLevel)
    }
#endif
  }
 
  // Update the safety starting from the end-point,
  // if it will become negative at the end-point.
  //
  if(currentSafety < fEndPointDistance)
  {
    if(particleCharge != 0.0)
    {
      G4double endSafety =
        fLinearNavigator->ComputeSafety(fTransportEndPosition);
      currentSafety      = endSafety;
      fPreviousSftOrigin = fTransportEndPosition;
      fPreviousSafety    = currentSafety;
      fpSafetyHelper->SetCurrentSafety(currentSafety, fTransportEndPosition);
 
      // Because the Stepping Manager assumes it is from the start point,
      //  add the StepLength
      //
      currentSafety += fEndPointDistance;
 
#ifdef G4DEBUG_TRANSPORT
      G4cout.precision(12);
      G4cout << "***G4Transportation::AlongStepGPIL ** " << G4endl;
      G4cout << "  Called Navigator->ComputeSafety at " << fTransportEndPosition
             << "    and it returned safety=  " << endSafety << G4endl;
      G4cout << "  Adding endpoint distance   " << fEndPointDistance
             << "    to obtain pseudo-safety= " << currentSafety << G4endl;
    }
    else
    {
      G4cout << "***G4Transportation::AlongStepGPIL ** " << G4endl;
      G4cout << "  Avoiding call to ComputeSafety : " << G4endl;
      G4cout << "    charge     = " << particleCharge << G4endl;
      G4cout << "    mag moment = " << magneticMoment << G4endl;
#endif
    }
  }
 
  fFirstStepInVolume = fNewTrack || fLastStepInVolume;
  fLastStepInVolume  = false;
  fNewTrack          = false;
 
  fParticleChange.ProposeFirstStepInVolume(fFirstStepInVolume);
  fParticleChange.ProposeTrueStepLength(geometryStepLength);
 
  return geometryStepLength;
}

References CandidateForSelection, G4Navigator::ComputeSafety(), G4Navigator::ComputeStep(), G4PropagatorInField::ComputeStep(), G4FieldManager::DoesFieldChangeEnergy(), fCandidateEndGlobalTime, fEndGlobalTimeComputed, fEndPointDistance, fFieldExertedForce, fFieldPropagator, fFirstStepInVolume, fGeometryLimitedStep, G4PropagatorInField::FindAndSetFieldManager(), fLastStepInVolume, fLinearNavigator, fMomentumChanged, fNewTrack, fParticleChange, fParticleIsLooping, fPreviousSafety, fPreviousSftOrigin, fpSafetyHelper, fShortStepOptimisation, fThreshold_Important_Energy, fTransportEndKineticEnergy, fTransportEndMomentumDir, fTransportEndPosition, fTransportEndSpin, fUseGravity, fUseMagneticMoment, G4cout, G4endl, G4Exception(), G4ThreadLocal, G4DynamicParticle::GetCharge(), G4PropagatorInField::GetCurrentEquationOfMotion(), G4PropagatorInField::GetCurrentFieldManager(), G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), G4Track::GetGlobalTime(), G4FieldTrack::GetKineticEnergy(), G4DynamicParticle::GetKineticEnergy(), G4FieldTrack::GetLabTimeOfFlight(), G4DynamicParticle::GetMagneticMoment(), G4DynamicParticle::GetMass(), G4FieldTrack::GetMomentumDir(), G4Track::GetMomentumDirection(), G4ParticleDefinition::GetPDGSpin(), G4DynamicParticle::GetPolarization(), G4FieldTrack::GetPosition(), G4Track::GetPosition(), G4FieldTrack::GetSpin(), G4DynamicParticle::GetTotalMomentum(), G4Track::GetVolume(), G4PropagatorInField::IsLastStepInVolume(), G4PropagatorInField::IsParticleLooping(), JustWarning, MeV, perMillion, perThousand, G4VParticleChange::ProposeFirstStepInVolume(), G4VParticleChange::ProposeTrueStepLength(), G4EquationOfMotion::SetChargeMomentumMass(), G4SafetyHelper::SetCurrentSafety(), sqr(), and G4VProcess::verboseLevel.

AlongStepGPIL()

G4double G4VProcess::AlongStepGPIL ( const G4Track &  track, G4double  previousStepSize, G4double  currentMinimumStep, G4double &  proposedSafety, G4GPILSelection *  selection  )

inlineinherited

Definition at line 461 of file G4VProcess.hh.

{
  return AlongStepGetPhysicalInteractionLength(track, previousStepSize,
                             currentMinimumStep, proposedSafety, selection);
}

References G4VProcess::AlongStepGetPhysicalInteractionLength().

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

AtRestDoIt()

G4VParticleChange * G4Transportation::AtRestDoIt ( const G4Track &  , const G4Step &    )

inlinevirtual

Implements G4VProcess.

Definition at line 147 of file G4Transportation.hh.

       { return 0; }     // No operation in AtRestDoIt

AtRestGetPhysicalInteractionLength()

G4double G4Transportation::AtRestGetPhysicalInteractionLength ( const G4Track &  , G4ForceCondition *    )

inlinevirtual

Implements G4VProcess.

Definition at line 143 of file G4Transportation.hh.

       { return -1.0; }  // No operation in AtRestGPIL

AtRestGPIL()

G4double G4VProcess::AtRestGPIL ( const G4Track &  track, G4ForceCondition *  condition  )

inlineinherited

Definition at line 472 of file G4VProcess.hh.

{
  return thePILfactor * AtRestGetPhysicalInteractionLength(track, condition);
}

References G4VProcess::AtRestGetPhysicalInteractionLength(), condition(), and G4VProcess::thePILfactor.

Referenced by G4ITStepProcessor::GetAtRestIL(), and G4SteppingManager::InvokeAtRestDoItProcs().

BuildPhysicsTable()

virtual void G4VProcess::BuildPhysicsTable ( const G4ParticleDefinition &  )

inlinevirtualinherited

Reimplemented in G4ITTransportation, G4VITProcess, G4DNABrownianTransportation, G4DNASecondOrderReaction, G4RadioactiveDecay, G4HadronStoppingProcess, G4MuonMinusAtomicCapture, G4WrapperProcess, G4Channeling, G4GammaGeneralProcess, G4Decay, G4UnknownDecay, G4AdjointForcedInteractionForGamma, G4AdjointProcessEquivalentToDirectProcess, G4VAdjointReverseReaction, G4DNAElectronHoleRecombination, G4DNAScavengerProcess, G4AnnihiToMuPair, G4GammaConversionToMuons, G4LowECapture, G4MicroElecSurface, G4PolarizedAnnihilation, G4PolarizedCompton, G4PolarizedIonisation, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4SynchrotronRadiation, G4VXTRenergyLoss, G4HadronicProcess, G4hImpactIonisation, G4ChargeExchangeProcess, G4Cerenkov, G4Scintillation, G4OpRayleigh, G4OpWLS, G4OpWLS2, and G4BiasingProcessInterface.

Definition at line 187 of file G4VProcess.hh.

{}

Referenced by G4VUserPhysicsList::BuildIntegralPhysicsTable(), G4WrapperProcess::BuildPhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::BuildPhysicsTable(), G4BiasingProcessInterface::BuildPhysicsTable(), G4VProcess::BuildWorkerPhysicsTable(), and export_G4VProcess().

BuildWorkerPhysicsTable()

void G4VProcess::BuildWorkerPhysicsTable ( const G4ParticleDefinition &  part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 200 of file G4VProcess.cc.

{
  BuildPhysicsTable(part);
}

References G4VProcess::BuildPhysicsTable().

Referenced by G4BiasingProcessInterface::BuildWorkerPhysicsTable().

ClearNumberOfInteractionLengthLeft()

void G4VProcess::ClearNumberOfInteractionLengthLeft ( )

inlineprotectedinherited

Definition at line 424 of file G4VProcess.hh.

{
  theInitialNumberOfInteractionLength = -1.0; 
  theNumberOfInteractionLengthLeft =  -1.0;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4VContinuousDiscreteProcess::AlongStepDoIt(), G4VRestContinuousDiscreteProcess::AtRestDoIt(), G4VRestContinuousProcess::AtRestDoIt(), G4VRestDiscreteProcess::AtRestDoIt(), G4VRestProcess::AtRestDoIt(), G4RadioactiveDecay::DecayAnalog(), G4Decay::DecayIt(), G4UnknownDecay::DecayIt(), G4Radioactivation::DecayIt(), G4RadioactiveDecay::DecayIt(), G4MuonicAtomDecay::DecayIt(), G4Decay::EndTracking(), G4VContinuousDiscreteProcess::PostStepDoIt(), G4VDiscreteProcess::PostStepDoIt(), G4VRestContinuousDiscreteProcess::PostStepDoIt(), G4VRestDiscreteProcess::PostStepDoIt(), G4VAdjointReverseReaction::PostStepDoIt(), G4TransitionRadiation::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4HadronicProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), and G4MuNeutrinoNucleusProcess::PostStepDoIt().

DoesAnyFieldExist()

G4bool G4Transportation::DoesAnyFieldExist ( )

protected

Referenced by G4Transportation(), and StartTracking().

DumpInfo()

void G4VProcess::DumpInfo ( ) const

virtualinherited

Reimplemented in G4AdjointAlongStepWeightCorrection, G4AdjointForcedInteractionForGamma, G4AdjointhMultipleScattering, G4ContinuousGainOfEnergy, G4eAdjointMultipleScattering, G4eInverseBremsstrahlung, G4eInverseCompton, G4eInverseIonisation, G4InversePEEffect, G4IonInverseIonisation, G4PolarizedAnnihilation, G4PolarizedBremsstrahlung, G4PolarizedCompton, G4PolarizedGammaConversion, G4PolarizedIonisation, G4PolarizedPhotoElectric, G4Cerenkov, G4ForwardXrayTR, G4GammaXTRadiator, G4GaussXTRadiator, G4RegularXTRadiator, G4Scintillation, G4StrawTubeXTRadiator, G4SynchrotronRadiation, G4TransitionRadiation, G4TransparentRegXTRadiator, G4VTransitionRadiation, G4VXTRenergyLoss, G4XTRGammaRadModel, G4XTRRegularRadModel, and G4XTRTransparentRegRadModel.

Definition at line 167 of file G4VProcess.cc.

{
  G4cout << "Process Name " << theProcessName ;
  G4cout << " : Type[" << GetProcessTypeName(theProcessType) << "]";
  G4cout << " : SubType[" << theProcessSubType << "]"<< G4endl;
}

References G4cout, G4endl, G4VProcess::GetProcessTypeName(), G4VProcess::theProcessName, G4VProcess::theProcessSubType, and G4VProcess::theProcessType.

Referenced by G4ProcessTable::DumpInfo(), export_G4VProcess(), G4Scintillation::ProcessDescription(), G4Cerenkov::ProcessDescription(), and G4ProcessManagerMessenger::SetNewValue().

EnableGravity()

G4bool G4Transportation::EnableGravity ( G4bool  useGravity = true )

static

Definition at line 830 of file G4Transportation.cc.

{
  G4bool lastValue= fUseGravity;
  fUseGravity= useGravity;
  G4CoupledTransportation::fUseGravity= useGravity;
  return lastValue;
}

References G4CoupledTransportation::fUseGravity, and fUseGravity.

EnableMagneticMoment()

G4bool G4Transportation::EnableMagneticMoment ( G4bool  useMoment = true )

static

Definition at line 819 of file G4Transportation.cc.

{
  G4bool lastValue= fUseMagneticMoment;
  fUseMagneticMoment= useMoment;
  G4CoupledTransportation::fUseMagneticMoment= useMoment;
  return lastValue;
}

References G4CoupledTransportation::fUseMagneticMoment, and fUseMagneticMoment.

Referenced by EnableUseMagneticMoment().

EnableShortStepOptimisation()

void G4Transportation::EnableShortStepOptimisation ( G4bool  optimise = true )

inline

EnableUseMagneticMoment()

static G4bool G4Transportation::EnableUseMagneticMoment ( G4bool  useMoment = true )

inlinestatic

Definition at line 138 of file G4Transportation.hh.

     { return EnableMagneticMoment(useMoment); }  // Old name - will be deprecated

References EnableMagneticMoment().

EndTracking()

void G4VProcess::EndTracking ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, G4WrapperProcess, G4FastSimulationManagerProcess, G4VPhononProcess, G4CoupledTransportation, G4Decay, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 102 of file G4VProcess.cc.

{
#ifdef G4VERBOSE
  if (verboseLevel>2)
  {
    G4cout << "G4VProcess::EndTracking() - [" << theProcessName << "]"
           << G4endl;
  }
#endif
  theNumberOfInteractionLengthLeft = -1.0;
  currentInteractionLength = -1.0;
  theInitialNumberOfInteractionLength=-1.0;
}

References G4VProcess::currentInteractionLength, G4cout, G4endl, G4VProcess::theInitialNumberOfInteractionLength, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4BiasingProcessInterface::EndTracking(), G4WrapperProcess::EndTracking(), G4VPhononProcess::EndTracking(), and G4AdjointProcessEquivalentToDirectProcess::EndTracking().

FieldExertedForce()

G4bool G4Transportation::FieldExertedForce ( )

inline

Definition at line 96 of file G4Transportation.hh.

{ return fFieldExertedForce; }

References fFieldExertedForce.

GetCurrentInteractionLength()

G4double G4VProcess::GetCurrentInteractionLength ( ) const

inlineinherited

Definition at line 443 of file G4VProcess.hh.

{
  return currentInteractionLength;
}

References G4VProcess::currentInteractionLength.

Referenced by G4BiasingProcessInterface::InvokeWrappedProcessPostStepGPIL(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), and G4BOptrForceCollision::ProposeOccurenceBiasingOperation().

GetMasterProcess()

const G4VProcess * G4VProcess::GetMasterProcess ( ) const

inlineinherited

Definition at line 518 of file G4VProcess.hh.

{
  return masterProcessShadow;
}

References G4VProcess::masterProcessShadow.

Referenced by G4PolarizedCompton::BuildPhysicsTable(), G4PolarizedIonisation::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4BiasingProcessInterface::SetMasterProcess(), and G4VMultipleScattering::StorePhysicsTable().

GetMaxEnergyKilled()

G4double G4Transportation::GetMaxEnergyKilled ( ) const

inline

GetNumberOfInteractionLengthLeft()

G4double G4VProcess::GetNumberOfInteractionLengthLeft ( ) const

inlineinherited

Definition at line 431 of file G4VProcess.hh.

{
  return theNumberOfInteractionLengthLeft;
}

References G4VProcess::theNumberOfInteractionLengthLeft.

GetPhysicsTableFileName()

const G4String & G4VProcess::GetPhysicsTableFileName ( const G4ParticleDefinition *  particle, const G4String &  directory, const G4String &  tableName, G4bool  ascii = false  )

inherited

Definition at line 181 of file G4VProcess.cc.

{
  G4String thePhysicsTableFileExt;
  if (ascii) thePhysicsTableFileExt = ".asc";
  else       thePhysicsTableFileExt = ".dat";
 
  thePhysicsTableFileName = directory + "/";
  thePhysicsTableFileName += tableName + "." +  theProcessName + ".";
  thePhysicsTableFileName += particle->GetParticleName()
                           + thePhysicsTableFileExt;
  
  return thePhysicsTableFileName;
}

References G4ParticleDefinition::GetParticleName(), G4VProcess::thePhysicsTableFileName, and G4VProcess::theProcessName.

Referenced by export_G4VProcess(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrieveTable(), G4GammaGeneralProcess::StorePhysicsTable(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), and G4VEnergyLossProcess::StoreTable().

GetPILfactor()

G4double G4VProcess::GetPILfactor ( ) const

inlineinherited

Definition at line 455 of file G4VProcess.hh.

{
  return thePILfactor;
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

GetProcessManager()

const G4ProcessManager * G4VProcess::GetProcessManager ( )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 494 of file G4VProcess.hh.

{
  return aProcessManager; 
}

References G4VProcess::aProcessManager.

Referenced by G4BiasingProcessInterface::GetProcessManager(), and G4WrapperProcess::GetProcessManager().

GetProcessName()

const G4String & G4VProcess::GetProcessName ( ) const

inlineinherited

Definition at line 382 of file G4VProcess.hh.

{
  return theProcessName;
}

References G4VProcess::theProcessName.

Referenced by G4VEnergyLossProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateForcedInteraction(), G4ProcessManager::ActivateProcess(), G4VEmProcess::ActivateSecondaryBiasing(), G4VEnergyLossProcess::ActivateSecondaryBiasing(), G4ParallelGeometriesLimiterProcess::AddParallelWorld(), G4IonQMDPhysics::AddProcess(), G4IonINCLXXPhysics::AddProcess(), G4ProcessManager::AddProcess(), G4ProcessPlacer::AddProcessAs(), G4ITSteppingVerbose::AlongStepDoItAllDone(), G4SteppingVerbose::AlongStepDoItAllDone(), G4SteppingVerboseWithUnits::AlongStepDoItAllDone(), G4ITSteppingVerbose::AlongStepDoItOneByOne(), G4SteppingVerbose::AlongStepDoItOneByOne(), G4SteppingVerboseWithUnits::AlongStepDoItOneByOne(), G4VContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4ParallelWorldProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4VContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4BOptnLeadingParticle::ApplyFinalStateBiasing(), G4ITSteppingVerbose::AtRestDoItInvoked(), G4SteppingVerbose::AtRestDoItInvoked(), G4SteppingVerboseWithUnits::AtRestDoItInvoked(), G4ITSteppingVerbose::AtRestDoItOneByOne(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4HadronicProcess::BiasCrossSectionByFactor(), G4VXTRenergyLoss::BuildAngleForEnergyBank(), G4VEnergyLossProcess::BuildDEDXTable(), G4VUserPhysicsList::BuildIntegralPhysicsTable(), G4VEmProcess::BuildLambdaTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4DNABrownianTransportation::BuildPhysicsTable(), G4GammaGeneralProcess::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4LossTableManager::BuildPhysicsTable(), G4LossTableManager::BuildTables(), G4HadronicProcess::CheckEnergyMomentumConservation(), G4ProcessManager::CheckOrderingParameters(), G4HadronicProcess::CheckResult(), G4StackChecker::ClassifyNewTrack(), G4BOptrForceCollision::ConfigureForWorker(), G4RunManagerKernel::ConfirmCoupledTransportation(), G4FastSimulationPhysics::ConstructProcess(), G4GenericBiasingPhysics::ConstructProcess(), G4IonElasticPhysics::ConstructProcess(), G4LossTableManager::CopyTables(), G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4VPhononProcess::CreateSecondary(), G4EmExtraParameters::DefineRegParamForEM(), G4EmExtraParameters::DefineRegParamForLoss(), G4HadronicProcessStore::DeRegisterExtraProcess(), G4ITSteppingVerbose::DPSLAlongStep(), G4SteppingVerbose::DPSLAlongStep(), G4SteppingVerboseWithUnits::DPSLAlongStep(), G4ITSteppingVerbose::DPSLPostStep(), G4SteppingVerbose::DPSLPostStep(), G4SteppingVerboseWithUnits::DPSLPostStep(), G4HadronicProcessStore::Dump(), G4HadronicProcess::DumpState(), G4MuonicAtomDecay::DumpState(), G4ExceptionHandler::DumpTrackInfo(), export_G4VProcess(), G4EmCalculator::FindEmModel(), G4VEmProcess::FindLambdaMax(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ErrorEnergyLoss::G4ErrorEnergyLoss(), G4ErrorTrackLengthTarget::G4ErrorTrackLengthTarget(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4ImportanceProcess::G4ImportanceProcess(), G4MaxTimeCuts::G4MaxTimeCuts(), G4MicroElecSurface::G4MicroElecSurface(), G4MinEkineCuts::G4MinEkineCuts(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4Scintillation::G4Scintillation(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4SpecialCuts::G4SpecialCuts(), G4StepLimiter::G4StepLimiter(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UserSpecialCuts::G4UserSpecialCuts(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4HadronicProcess::GetElementCrossSection(), G4VEmProcess::GetEmProcess(), G4GammaGeneralProcess::GetEmProcess(), G4WeightWindowProcess::GetName(), G4ProcessManager::GetProcess(), G4ProcessManager::GetProcessVectorIndex(), G4GammaGeneralProcess::GetSubProcessName(), G4ProcessManager::InActivateProcess(), G4hhIonisation::InitialiseEnergyLossProcess(), G4ProcessTable::Insert(), G4ITStepProcessor::InvokeAlongStepDoItProcs(), G4SteppingManager::InvokeAlongStepDoItProcs(), G4SteppingManager::InvokeAtRestDoItProcs(), G4SteppingManager::InvokePSDIP(), G4LossTableManager::LocalPhysicsTables(), G4ErrorPropagator::MakeOneStep(), G4VEmProcess::PostStepDoIt(), G4ITSteppingVerbose::PostStepDoItAllDone(), G4SteppingVerbose::PostStepDoItAllDone(), G4SteppingVerboseWithUnits::PostStepDoItAllDone(), G4ITSteppingVerbose::PostStepDoItOneByOne(), G4SteppingVerbose::PostStepDoItOneByOne(), G4SteppingVerboseWithUnits::PostStepDoItOneByOne(), G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNASecondOrderReaction::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4ITSteppingVerbose::PostStepVerbose(), G4EmConfigurator::PrepareModels(), G4HadronStoppingProcess::PreparePhysicsTable(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4LossTableManager::PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4HadronicProcessStore::PrintHtml(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4hImpactIonisation::PrintInfoDefinition(), G4ProcessPlacer::PrintProcVec(), G4VEnergyLossProcess::PrintWarning(), G4VEmProcess::PrintWarning(), G4SynchrotronRadiation::ProcessDescription(), G4Decay::ProcessDescription(), G4DecayWithSpin::ProcessDescription(), G4PionDecayMakeSpin::ProcessDescription(), G4UnknownDecay::ProcessDescription(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), G4StackManager::PushOneTrack(), G4HadronicProcessStore::Register(), G4LossTableManager::Register(), G4LossTableManager::RegisterExtraParticle(), G4HadronicProcessStore::RegisterExtraProcess(), G4HadronicProcessStore::RegisterParticle(), G4WrapperProcess::RegisterProcess(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTable::Remove(), G4ParallelGeometriesLimiterProcess::RemoveParallelWorld(), G4ProcessManager::RemoveProcess(), G4ProcessPlacer::RemoveProcess(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEmProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCSDARangeTable(), G4VEnergyLossProcess::SetInverseRangeTable(), G4VEnergyLossProcess::SetLambdaTable(), G4ProcessTableMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), G4ProcessManager::SetProcessOrdering(), G4ProcessManager::SetProcessOrderingToFirst(), G4ProcessManager::SetProcessOrderingToLast(), G4ProcessManager::SetProcessOrderingToSecond(), G4VEnergyLossProcess::SetRangeTableForLoss(), G4VEnergyLossProcess::SetSecondaryRangeTable(), G4FastSimulationManagerProcess::SetWorldVolume(), G4ITSteppingVerbose::ShowStep(), G4SteppingVerbose::ShowStep(), G4SteppingVerboseWithUnits::ShowStep(), G4ChannelingOptrChangeCrossSection::StartRun(), G4ITSteppingVerbose::StepInfo(), G4SteppingVerbose::StepInfo(), G4SteppingVerboseWithUnits::StepInfo(), G4ITSteppingVerbose::StepInfoForLeadingTrack(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), G4VMultipleScattering::StreamInfo(), G4EmCalculator::UpdateParticle(), G4ParallelWorldScoringProcess::Verbose(), G4ScoreSplittingProcess::Verbose(), G4ITSteppingVerbose::VerboseTrack(), G4SteppingVerbose::VerboseTrack(), and G4SteppingVerboseWithUnits::VerboseTrack().

GetProcessSubType()

G4int G4VProcess::GetProcessSubType ( ) const

inlineinherited

Definition at line 400 of file G4VProcess.hh.

{
  return theProcessSubType;
}

References G4VProcess::theProcessSubType.

Referenced by G4GammaGeneralProcess::AddEmProcess(), G4DNABrownianTransportation::BuildPhysicsTable(), G4HadronicProcessStore::FindProcess(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4HadronicProcessStore::GetCrossSectionPerAtom(), G4HadronicProcessStore::GetCrossSectionPerVolume(), G4GammaGeneralProcess::GetSubProcessSubType(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4PhysicsListHelper::RegisterProcess(), G4ElectronIonPair::ResidualeChargePostStep(), G4EmConfigurator::SetModelForRegion(), G4ChannelingOptrChangeCrossSection::StartRun(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), and G4VMultipleScattering::StreamInfo().

GetProcessType()

G4ProcessType G4VProcess::GetProcessType ( ) const

inlineinherited

Definition at line 388 of file G4VProcess.hh.

{
  return theProcessType;
}

References G4VProcess::theProcessType.

Referenced by G4BiasingHelper::ActivatePhysicsBiasing(), G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4SteppingManager::DefinePhysicalStepLength(), export_G4VProcess(), G4ProcessTable::Find(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4WrapperProcess::RegisterProcess(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTableMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), and G4ChannelingOptrChangeCrossSection::StartRun().

GetProcessTypeName()

const G4String & G4VProcess::GetProcessTypeName ( G4ProcessType  aType )

staticinherited

Definition at line 134 of file G4VProcess.cc.

{
  switch (aType)
  {
    case fNotDefined:         return typeNotDefined; break;
    case fTransportation:     return typeTransportation; break;
    case fElectromagnetic:    return typeElectromagnetic; break;
    case fOptical:            return typeOptical; break;
    case fHadronic:           return typeHadronic; break;
    case fPhotolepton_hadron: return typePhotolepton_hadron; break;
    case fDecay:              return typeDecay; break;
    case fGeneral:            return typeGeneral; break;
    case fParameterisation:   return typeParameterisation; break;
    case fUserDefined:        return typeUserDefined; break;
    case fPhonon:             return typePhonon; break;
    default: ;
  }
  return noType;  
}

References fDecay, fElectromagnetic, fGeneral, fHadronic, fNotDefined, fOptical, fParameterisation, fPhonon, fPhotolepton_hadron, fTransportation, fUserDefined, anonymous_namespace{G4VProcess.cc}::noType, anonymous_namespace{G4VProcess.cc}::typeDecay, anonymous_namespace{G4VProcess.cc}::typeElectromagnetic, anonymous_namespace{G4VProcess.cc}::typeGeneral, anonymous_namespace{G4VProcess.cc}::typeHadronic, anonymous_namespace{G4VProcess.cc}::typeNotDefined, anonymous_namespace{G4VProcess.cc}::typeOptical, anonymous_namespace{G4VProcess.cc}::typeParameterisation, anonymous_namespace{G4VProcess.cc}::typePhonon, anonymous_namespace{G4VProcess.cc}::typePhotolepton_hadron, anonymous_namespace{G4VProcess.cc}::typeTransportation, and anonymous_namespace{G4VProcess.cc}::typeUserDefined.

Referenced by G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4ProcessManager::DumpInfo(), G4VProcess::DumpInfo(), G4ProcessTableMessenger::G4ProcessTableMessenger(), G4ProcessTableMessenger::GetProcessType(), G4ProcessTableMessenger::GetProcessTypeName(), and G4ProcessTableMessenger::SetNumberOfProcessType().

GetPropagatorInField()

G4PropagatorInField * G4Transportation::GetPropagatorInField

(

)

GetSilenceLooperWarnings()

G4bool G4Transportation::GetSilenceLooperWarnings ( )

static

Definition at line 850 of file G4Transportation.cc.

{
  return fSilenceLooperWarnings; 
}

References fSilenceLooperWarnings.

GetSumEnergyKilled()

G4double G4Transportation::GetSumEnergyKilled ( ) const

inline

GetThresholdImportantEnergy()

G4double G4Transportation::GetThresholdImportantEnergy ( ) const

inline

GetThresholdTrials()

G4int G4Transportation::GetThresholdTrials ( ) const

inline

GetThresholdWarningEnergy()

G4double G4Transportation::GetThresholdWarningEnergy ( ) const

inline

GetTotalNumberOfInteractionLengthTraversed()

G4double G4VProcess::GetTotalNumberOfInteractionLengthTraversed ( ) const

inlineinherited

Definition at line 437 of file G4VProcess.hh.

{
  return theInitialNumberOfInteractionLength - theNumberOfInteractionLengthLeft;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4HadronicProcess::XBiasSecondaryWeight(), and G4HadronicProcess::XBiasSurvivalProbability().

GetVerboseLevel()

G4int G4VProcess::GetVerboseLevel ( ) const

inlineinherited

Definition at line 418 of file G4VProcess.hh.

{
  return  verboseLevel;
}

References G4VProcess::verboseLevel.

Referenced by G4MuonMinusAtomicCapture::AtRestDoIt(), G4Decay::DecayIt(), G4UnknownDecay::DecayIt(), G4ProcessTable::DumpInfo(), export_G4VProcess(), G4Decay::G4Decay(), G4UnknownDecay::G4UnknownDecay(), G4Decay::GetMeanFreePath(), G4Decay::GetMeanLifeTime(), and G4DecayWithSpin::Spin_Precession().

isAlongStepDoItIsEnabled()

G4bool G4VProcess::isAlongStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 506 of file G4VProcess.hh.

{
  return enableAlongStepDoIt;
}

References G4VProcess::enableAlongStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

IsApplicable()

virtual G4bool G4VProcess::IsApplicable ( const G4ParticleDefinition &  )

inlinevirtualinherited

Reimplemented in G4DNAAttachment, G4DNAChargeDecrease, G4DNAChargeIncrease, G4DNADissociation, G4DNAElastic, G4DNAElectronSolvation, G4DNAExcitation, G4DNAIonisation, G4DNAPlasmonExcitation, G4DNAPositronium, G4DNARotExcitation, G4DNAVibExcitation, G4hImpactIonisation, G4RadioactiveDecay, G4HadronicAbsorptionBertini, G4HadronicAbsorptionFritiof, G4HadronicAbsorptionFritiofWithBinaryCascade, G4HadronStoppingProcess, G4MuonicAtomDecay, G4MuonMinusAtomicCapture, G4MuonMinusCapture, G4WrapperProcess, G4PhononDownconversion, G4NeutronKiller, G4ComptonScattering, G4GammaConversion, G4PhotoElectricEffect, G4GammaGeneralProcess, G4Decay, G4UnknownDecay, G4AdjointProcessEquivalentToDirectProcess, G4DNAElectronHoleRecombination, G4DNAMolecularDissociation, G4AnnihiToMuPair, G4GammaConversionToMuons, G4JAEAElasticScattering, G4LowECapture, G4MicroElecElastic, G4MicroElecInelastic, G4MicroElecLOPhononScattering, G4RayleighScattering, G4PolarizedCompton, G4PolarizedGammaConversion, G4PolarizedPhotoElectric, G4SynchrotronRadiation, G4SynchrotronRadiationInMat, G4VXTRenergyLoss, G4HadronInelasticProcess, G4NoProcess, G4ChargeExchangeProcess, G4MuonNuclearProcess, G4UCNAbsorption, G4UCNBoundaryProcess, G4UCNLoss, G4UCNMultiScattering, G4NeutronCaptureProcess, G4MicroElecSurface, G4ErrorEnergyLoss, G4Cerenkov, G4Scintillation, G4TransitionRadiation, G4VTransitionRadiation, G4OpAbsorption, G4OpBoundaryProcess, G4OpMieHG, G4OpRayleigh, G4OpWLS, G4OpWLS2, G4Channeling, G4VPhononProcess, G4NeutronFissionProcess, G4CoulombScattering, G4eBremsstrahlung, G4eIonisation, G4eMultipleScattering, G4eplusAnnihilation, G4hMultipleScattering, G4ionIonisation, G4NuclearStopping, G4AdjointhMultipleScattering, G4eAdjointMultipleScattering, G4eeToHadrons, G4hBremsstrahlung, G4hhIonisation, G4hPairProduction, G4mplIonisation, G4ePairProduction, G4MuBremsstrahlung, G4MuIonisation, G4MuMultipleScattering, G4MuPairProduction, G4PolarizedIonisation, G4hIonisation, G4VEmProcess, and G4BiasingProcessInterface.

Definition at line 182 of file G4VProcess.hh.

{ return true; }

Referenced by G4ProcessManager::AddProcess(), export_G4VProcess(), G4WrapperProcess::IsApplicable(), G4AdjointProcessEquivalentToDirectProcess::IsApplicable(), and G4BiasingProcessInterface::IsApplicable().

isAtRestDoItIsEnabled()

G4bool G4VProcess::isAtRestDoItIsEnabled ( ) const

inlineinherited

Definition at line 500 of file G4VProcess.hh.

{
  return enableAtRestDoIt;
}

References G4VProcess::enableAtRestDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

isPostStepDoItIsEnabled()

G4bool G4VProcess::isPostStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 512 of file G4VProcess.hh.

{
  return enablePostStepDoIt;
}

References G4VProcess::enablePostStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

operator!=()

G4bool G4VProcess::operator!= ( const G4VProcess &  right ) const

inherited

Definition at line 161 of file G4VProcess.cc.

{
  return (this !=  &right);
}

operator==()

G4bool G4VProcess::operator== ( const G4VProcess &  right ) const

inherited

Definition at line 155 of file G4VProcess.cc.

{
  return (this == &right);
}

PostStepDoIt()

G4VParticleChange * G4Transportation::PostStepDoIt ( const G4Track &  track, const G4Step &  stepData  )

virtual

Implements G4VProcess.

Definition at line 655 of file G4Transportation.cc.

{
   G4TouchableHandle retCurrentTouchable ;   // The one to return
   G4bool isLastStep= false; 
 
  // Initialize ParticleChange  (by setting all its members equal
  //                             to corresponding members in G4Track)
  // fParticleChange.Initialize(track) ;  // To initialise TouchableChange
 
  fParticleChange.ProposeTrackStatus(track.GetTrackStatus()) ;
 
  // If the Step was determined by the volume boundary,
  // logically relocate the particle
 
  if(fGeometryLimitedStep)
  {  
    // fCurrentTouchable will now become the previous touchable, 
    // and what was the previous will be freed.
    // (Needed because the preStepPoint can point to the previous touchable)
 
    fLinearNavigator->SetGeometricallyLimitedStep() ;
    fLinearNavigator->
    LocateGlobalPointAndUpdateTouchableHandle( track.GetPosition(),
                                               track.GetMomentumDirection(),
                                               fCurrentTouchableHandle,
                                               true                      ) ;
    // Check whether the particle is out of the world volume 
    // If so it has exited and must be killed.
    //
    if( fCurrentTouchableHandle->GetVolume() == 0 )
    {
       fParticleChange.ProposeTrackStatus( fStopAndKill ) ;
    }
    retCurrentTouchable = fCurrentTouchableHandle ;
    fParticleChange.SetTouchableHandle( fCurrentTouchableHandle ) ;
 
    // Update the Step flag which identifies the Last Step in a volume
    if( !fFieldExertedForce )
       isLastStep =  fLinearNavigator->ExitedMotherVolume() 
                  || fLinearNavigator->EnteredDaughterVolume() ;
    else
       isLastStep = fFieldPropagator->IsLastStepInVolume(); 
  }
  else                 // fGeometryLimitedStep  is false
  {                    
    // This serves only to move the Navigator's location
    //
    fLinearNavigator->LocateGlobalPointWithinVolume( track.GetPosition() ) ;
 
    // The value of the track's current Touchable is retained. 
    // (and it must be correct because we must use it below to
    // overwrite the (unset) one in particle change)
    //  It must be fCurrentTouchable too ??
    //
    fParticleChange.SetTouchableHandle( track.GetTouchableHandle() ) ;
    retCurrentTouchable = track.GetTouchableHandle() ;
 
    isLastStep= false;
  }         // endif ( fGeometryLimitedStep ) 
  fLastStepInVolume= isLastStep; 
  
  fParticleChange.ProposeFirstStepInVolume(fFirstStepInVolume);
  fParticleChange.ProposeLastStepInVolume(isLastStep);    
 
  const G4VPhysicalVolume* pNewVol = retCurrentTouchable->GetVolume() ;
  const G4Material* pNewMaterial   = 0 ;
  const G4VSensitiveDetector* pNewSensitiveDetector   = 0 ;
                                                                                       
  if( pNewVol != 0 )
  {
    pNewMaterial= pNewVol->GetLogicalVolume()->GetMaterial();
    pNewSensitiveDetector= pNewVol->GetLogicalVolume()->GetSensitiveDetector();
  }
 
  fParticleChange.SetMaterialInTouchable( (G4Material *) pNewMaterial ) ;
  fParticleChange.SetSensitiveDetectorInTouchable( (G4VSensitiveDetector *) pNewSensitiveDetector ) ;
 
  const G4MaterialCutsCouple* pNewMaterialCutsCouple = 0;
  if( pNewVol != 0 )
  {
    pNewMaterialCutsCouple=pNewVol->GetLogicalVolume()->GetMaterialCutsCouple();
  }
 
  if ( pNewVol!=0 && pNewMaterialCutsCouple!=0
    && pNewMaterialCutsCouple->GetMaterial()!=pNewMaterial )
  {
    // for parametrized volume
    //
    pNewMaterialCutsCouple =
      G4ProductionCutsTable::GetProductionCutsTable()
                             ->GetMaterialCutsCouple(pNewMaterial,
                               pNewMaterialCutsCouple->GetProductionCuts());
  }
  fParticleChange.SetMaterialCutsCoupleInTouchable( pNewMaterialCutsCouple );
 
  // temporarily until Get/Set Material of ParticleChange, 
  // and StepPoint can be made const. 
  // Set the touchable in ParticleChange
  // this must always be done because the particle change always
  // uses this value to overwrite the current touchable pointer.
  //
  fParticleChange.SetTouchableHandle(retCurrentTouchable) ;
 
  return &fParticleChange ;
}

References G4Navigator::EnteredDaughterVolume(), G4Navigator::ExitedMotherVolume(), fCurrentTouchableHandle, fFieldExertedForce, fFieldPropagator, fFirstStepInVolume, fGeometryLimitedStep, fLastStepInVolume, fLinearNavigator, fParticleChange, fStopAndKill, G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetMaterial(), G4MaterialCutsCouple::GetMaterial(), G4LogicalVolume::GetMaterialCutsCouple(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4Track::GetMomentumDirection(), G4Track::GetPosition(), G4MaterialCutsCouple::GetProductionCuts(), G4ProductionCutsTable::GetProductionCutsTable(), G4LogicalVolume::GetSensitiveDetector(), G4Track::GetTouchableHandle(), G4Track::GetTrackStatus(), G4VTouchable::GetVolume(), G4PropagatorInField::IsLastStepInVolume(), G4Navigator::LocateGlobalPointWithinVolume(), G4VParticleChange::ProposeFirstStepInVolume(), G4VParticleChange::ProposeLastStepInVolume(), G4VParticleChange::ProposeTrackStatus(), G4Navigator::SetGeometricallyLimitedStep(), G4ParticleChangeForTransport::SetMaterialCutsCoupleInTouchable(), G4ParticleChangeForTransport::SetMaterialInTouchable(), G4ParticleChangeForTransport::SetSensitiveDetectorInTouchable(), and G4ParticleChangeForTransport::SetTouchableHandle().

PostStepGetPhysicalInteractionLength()

G4double G4Transportation::PostStepGetPhysicalInteractionLength ( const G4Track &  , G4double  previousStepSize, G4ForceCondition *  pForceCond  )

virtual

Implements G4VProcess.

Definition at line 642 of file G4Transportation.cc.

{
  fFieldExertedForce = false; // Not known
  *pForceCond = Forced ; 
  return DBL_MAX ;  // was kInfinity ; but convention now is DBL_MAX
}

References DBL_MAX, fFieldExertedForce, and Forced.

PostStepGPIL()

G4double G4VProcess::PostStepGPIL ( const G4Track &  track, G4double  previousStepSize, G4ForceCondition *  condition  )

inlineinherited

Definition at line 479 of file G4VProcess.hh.

{
  return thePILfactor *
      PostStepGetPhysicalInteractionLength(track, previousStepSize, condition);
}

References condition(), G4VProcess::PostStepGetPhysicalInteractionLength(), and G4VProcess::thePILfactor.

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

PreparePhysicsTable()

virtual void G4VProcess::PreparePhysicsTable ( const G4ParticleDefinition &  )

inlinevirtualinherited

Reimplemented in G4NeutrinoElectronProcess, G4HadronStoppingProcess, G4MuonMinusAtomicCapture, G4WrapperProcess, G4GammaGeneralProcess, G4AdjointProcessEquivalentToDirectProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4HadronicProcess, G4ElNeutrinoNucleusProcess, G4MuNeutrinoNucleusProcess, G4OpAbsorption, G4OpBoundaryProcess, G4OpMieHG, G4OpRayleigh, G4OpWLS, G4OpWLS2, G4Cerenkov, G4Scintillation, and G4BiasingProcessInterface.

Definition at line 194 of file G4VProcess.hh.

{}

Referenced by export_G4VProcess(), G4WrapperProcess::PreparePhysicsTable(), G4GammaGeneralProcess::PreparePhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::PreparePhysicsTable(), G4BiasingProcessInterface::PreparePhysicsTable(), and G4VProcess::PrepareWorkerPhysicsTable().

PrepareWorkerPhysicsTable()

void G4VProcess::PrepareWorkerPhysicsTable ( const G4ParticleDefinition &  part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.cc.

{
  PreparePhysicsTable(part);
}

References G4VProcess::PreparePhysicsTable().

Referenced by G4BiasingProcessInterface::PrepareWorkerPhysicsTable().

PrintStatistics()

void G4Transportation::PrintStatistics

(

std::ostream &

outStr

)

const

Definition at line 139 of file G4Transportation.cc.

{
   outStr << " G4Transportation: Statistics for looping particles " << G4endl;   
   if( fSumEnergyKilled > 0.0 || fNumLoopersKilled > 0 )
   {
      outStr << "   Sum of energy of looping tracks killed: "
             <<  fSumEnergyKilled / CLHEP::MeV << " MeV "          
             << " from " << fNumLoopersKilled << "  tracks "  << G4endl
             <<  "  Sum of energy of non-electrons        : "
             << fSumEnergyKilled_NonElectron / CLHEP::MeV << " MeV "
             << "  from " << fNumLoopersKilled_NonElectron << " tracks "
             << G4endl;
      outStr << "   Max energy of  *any type*  looper killed: " << fMaxEnergyKilled
             << "    its PDG was " << fMaxEnergyKilledPDG  << G4endl;
      if( fMaxEnergyKilled_NonElectron > 0.0 )
      {
         outStr << "   Max energy of non-electron looper killed: " 
                << fMaxEnergyKilled_NonElectron
                << "    its PDG was " << fMaxEnergyKilled_NonElecPDG << G4endl;
      }
      if( fMaxEnergySaved > 0.0 )
      {
         outStr << "   Max energy of loopers 'saved':  " << fMaxEnergySaved << G4endl;
         outStr << "   Sum of energy of loopers 'saved': "
                <<  fSumEnergySaved << G4endl;
         outStr << "   Sum of energy of unstable loopers 'saved': "
                << fSumEnergyUnstableSaved << G4endl;
      }
   }
   else
   {
      outStr << " No looping tracks found or killed. " << G4endl;
   }
}

References fMaxEnergyKilled, fMaxEnergyKilled_NonElecPDG, fMaxEnergyKilled_NonElectron, fMaxEnergyKilledPDG, fMaxEnergySaved, fNumLoopersKilled, fNumLoopersKilled_NonElectron, fSumEnergyKilled, fSumEnergyKilled_NonElectron, fSumEnergySaved, fSumEnergyUnstableSaved, G4endl, and CLHEP::MeV.

Referenced by ~G4Transportation().

ProcessDescription()

void G4Transportation::ProcessDescription ( std::ostream &  outFile ) const

virtual

Reimplemented from G4VProcess.

Definition at line 909 of file G4Transportation.cc.

{
  G4String indent = "  "; //  : "");
  G4int oldPrec= outStr.precision(6);
  // outStr << std::setprecision(6);
  outStr << G4endl << indent << GetProcessName() << ": ";
 
  outStr << "   Parameters for looping particles: " << G4endl
         << "     warning-E = " << fThreshold_Warning_Energy / CLHEP::MeV  << " MeV "  << G4endl
         << "     important E = " << fThreshold_Important_Energy / CLHEP::MeV << " MeV " << G4endl
         << "     thresholdTrials " << fThresholdTrials << G4endl;
  outStr.precision(oldPrec);
}

References G4endl, and CLHEP::MeV.

PushThresholdsToLogger()

void G4Transportation::PushThresholdsToLogger

(

)

Referenced by G4Transportation(), ReportLooperThresholds(), SetHighLooperThresholds(), and SetLowLooperThresholds().

ReportLooperThresholds()

void G4Transportation::ReportLooperThresholds

(

)

Definition at line 901 of file G4Transportation.cc.

{
   PushThresholdsToLogger();  // To be absolutely certain they are in sync   
   fpLogger->ReportLooperThresholds("G4Transportation");
}

References fpLogger, PushThresholdsToLogger(), and G4TransportationLogger::ReportLooperThresholds().

Referenced by SetHighLooperThresholds(), and SetLowLooperThresholds().

ReportMissingLogger()

void G4Transportation::ReportMissingLogger ( const char *  methodName )

protected

Definition at line 890 of file G4Transportation.cc.

{
   const char* message= "Logger object missing from G4Transportation object";
   G4String classAndMethod= G4String("G4Transportation") + G4String( methodName );
   G4Exception(classAndMethod, "Missing Logger", JustWarning, message);   
}

References G4Exception(), and JustWarning.

ResetKilledStatistics()

void G4Transportation::ResetKilledStatistics ( G4int  report = 1 )

inline

ResetNumberOfInteractionLengthLeft()

void G4VProcess::ResetNumberOfInteractionLengthLeft ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4VITProcess, G4WrapperProcess, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 80 of file G4VProcess.cc.

{
  theNumberOfInteractionLengthLeft =  -1.*G4Log( G4UniformRand() );
  theInitialNumberOfInteractionLength = theNumberOfInteractionLengthLeft; 
}

References G4Log(), G4UniformRand, G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4MuonicAtomDecay::AtRestGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4BiasingProcessInterface::InvokeWrappedProcessPostStepGPIL(), G4BiasingProcessInterface::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4BiasingProcessInterface::ResetNumberOfInteractionLengthLeft(), G4WrapperProcess::ResetNumberOfInteractionLengthLeft(), G4AdjointProcessEquivalentToDirectProcess::ResetNumberOfInteractionLengthLeft(), and G4Decay::StartTracking().

RetrievePhysicsTable()

virtual G4bool G4VProcess::RetrievePhysicsTable ( const G4ParticleDefinition *  , const G4String &  , G4bool    )

inlinevirtualinherited

Reimplemented in G4GammaGeneralProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4WrapperProcess, G4AdjointProcessEquivalentToDirectProcess, and G4BiasingProcessInterface.

Definition at line 211 of file G4VProcess.hh.

                                                               { return false; }

Referenced by export_G4VProcess(), G4WrapperProcess::RetrievePhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::RetrievePhysicsTable(), and G4BiasingProcessInterface::RetrievePhysicsTable().

SetHighLooperThresholds()

void G4Transportation::SetHighLooperThresholds

(

)

Definition at line 858 of file G4Transportation.cc.

{
  // Restores the old high values -- potentially appropriate for energy-frontier
  //   HEP experiments.
  // Caution:  All tracks with E < 100 MeV that are found to loop are 
  SetThresholdWarningEnergy(    100.0 * CLHEP::MeV ); // Warn above this energy
  SetThresholdImportantEnergy(  250.0 * CLHEP::MeV ); // Extra trial above this En
 
  G4int maxTrials = 10;
  SetThresholdTrials( maxTrials );
  
  PushThresholdsToLogger();  // Again, to be sure
  if( verboseLevel )  ReportLooperThresholds();    
}

References CLHEP::MeV, PushThresholdsToLogger(), ReportLooperThresholds(), SetThresholdImportantEnergy(), SetThresholdTrials(), SetThresholdWarningEnergy(), and G4VProcess::verboseLevel.

Referenced by G4Transportation().

SetLowLooperThresholds()

void G4Transportation::SetLowLooperThresholds

(

)

Definition at line 874 of file G4Transportation.cc.

{
  // These values were the default in Geant4 10.5 - beta
  SetThresholdWarningEnergy(     1.0 * CLHEP::keV ); // Warn above this En
  SetThresholdImportantEnergy(   1.0 * CLHEP::MeV ); // Extra trials above it
 
  G4int maxTrials = 30; //  A new value - was 10
  SetThresholdTrials( maxTrials );
 
  PushThresholdsToLogger();  // Again, to be sure
  if( verboseLevel )  ReportLooperThresholds();  
}

References CLHEP::keV, CLHEP::MeV, PushThresholdsToLogger(), ReportLooperThresholds(), SetThresholdImportantEnergy(), SetThresholdTrials(), SetThresholdWarningEnergy(), and G4VProcess::verboseLevel.

SetMasterProcess()

void G4VProcess::SetMasterProcess ( G4VProcess *  masterP )

virtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 212 of file G4VProcess.cc.

{
  masterProcessShadow = masterP;
}

References G4VProcess::masterProcessShadow.

Referenced by G4BiasingProcessInterface::SetMasterProcess(), and G4WrapperProcess::SetMasterProcess().

SetPILfactor()

void G4VProcess::SetPILfactor ( G4double  value )

inlineinherited

Definition at line 449 of file G4VProcess.hh.

{
  if (value>0.) { thePILfactor = value; }
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

SetProcessManager()

void G4VProcess::SetProcessManager ( const G4ProcessManager *  procMan )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, and G4WrapperProcess.

Definition at line 488 of file G4VProcess.hh.

{
  aProcessManager = procMan; 
}

References G4VProcess::aProcessManager.

Referenced by G4ProcessManager::AddProcess(), G4BiasingProcessInterface::SetProcessManager(), and G4WrapperProcess::SetProcessManager().

SetProcessSubType()

void G4VProcess::SetProcessSubType ( G4int  value )

inlineinherited

Definition at line 406 of file G4VProcess.hh.

{
  theProcessSubType = value;
}

References G4VProcess::theProcessSubType.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4AnnihiToMuPair::G4AnnihiToMuPair(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4CoupledTransportation::G4CoupledTransportation(), G4Decay::G4Decay(), G4DecayWithSpin::G4DecayWithSpin(), G4DNAAttachment::G4DNAAttachment(), G4DNABrownianTransportation::G4DNABrownianTransportation(), G4DNAChargeDecrease::G4DNAChargeDecrease(), G4DNAChargeIncrease::G4DNAChargeIncrease(), G4DNAElastic::G4DNAElastic(), G4DNAElectronSolvation::G4DNAElectronSolvation(), G4DNAExcitation::G4DNAExcitation(), G4DNAIonisation::G4DNAIonisation(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4DNAVibExcitation::G4DNAVibExcitation(), G4eBremsstrahlung::G4eBremsstrahlung(), G4eeToHadrons::G4eeToHadrons(), G4eIonisation::G4eIonisation(), G4ePairProduction::G4ePairProduction(), G4eplusAnnihilation::G4eplusAnnihilation(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GammaConversion::G4GammaConversion(), G4GammaConversionToMuons::G4GammaConversionToMuons(), G4GammaGeneralProcess::G4GammaGeneralProcess(), G4HadronicProcess::G4HadronicProcess(), G4hhIonisation::G4hhIonisation(), G4hIonisation::G4hIonisation(), G4ionIonisation::G4ionIonisation(), G4ITTransportation::G4ITTransportation(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4MicroElecElastic::G4MicroElecElastic(), G4MicroElecInelastic::G4MicroElecInelastic(), G4MicroElecLOPhononScattering::G4MicroElecLOPhononScattering(), G4MicroElecSurface::G4MicroElecSurface(), G4mplIonisation::G4mplIonisation(), G4MuBremsstrahlung::G4MuBremsstrahlung(), G4MuIonisation::G4MuIonisation(), G4MuonMinusAtomicCapture::G4MuonMinusAtomicCapture(), G4MuPairProduction::G4MuPairProduction(), G4NeutronKiller::G4NeutronKiller(), G4NuclearStopping::G4NuclearStopping(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4PhotoElectricEffect::G4PhotoElectricEffect(), G4PionDecayMakeSpin::G4PionDecayMakeSpin(), G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), G4PolarizedIonisation::G4PolarizedIonisation(), G4PolarizedPhotoElectric::G4PolarizedPhotoElectric(), G4RadioactiveDecay::G4RadioactiveDecay(), G4RayleighScattering::G4RayleighScattering(), G4Scintillation::G4Scintillation(), G4StepLimiter::G4StepLimiter(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4TransitionRadiation::G4TransitionRadiation(), G4Transportation(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UnknownDecay::G4UnknownDecay(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VMultipleScattering::G4VMultipleScattering(), G4VTransitionRadiation::G4VTransitionRadiation(), G4VXTRenergyLoss::G4VXTRenergyLoss(), and G4Decay::SetExtDecayer().

SetProcessType()

void G4VProcess::SetProcessType ( G4ProcessType  aType )

inlineinherited

Definition at line 394 of file G4VProcess.hh.

{
  theProcessType = aType;
}

References G4VProcess::theProcessType.

Referenced by G4MaxTimeCuts::G4MaxTimeCuts(), and G4MinEkineCuts::G4MinEkineCuts().

SetPropagatorInField()

void G4Transportation::SetPropagatorInField

(

G4PropagatorInField *

pFieldPropagator

)

SetSilenceLooperWarnings()

void G4Transportation::SetSilenceLooperWarnings ( G4bool  val )

static

Definition at line 842 of file G4Transportation.cc.

{
  fSilenceLooperWarnings= val;  // Flag to *Supress* all 'looper' warnings  
  // G4CoupledTransportation::fSilenceLooperWarnings= val;
}

References fSilenceLooperWarnings.

SetThresholdImportantEnergy()

void G4Transportation::SetThresholdImportantEnergy ( G4double  newEnImp )

inline

Referenced by SetHighLooperThresholds(), and SetLowLooperThresholds().

SetThresholdTrials()

void G4Transportation::SetThresholdTrials ( G4int  newMaxTrials )

inline

Referenced by SetHighLooperThresholds(), and SetLowLooperThresholds().

SetThresholdWarningEnergy()

void G4Transportation::SetThresholdWarningEnergy ( G4double  newEnWarn )

inline

Referenced by SetHighLooperThresholds(), and SetLowLooperThresholds().

SetVerboseLevel()

void G4VProcess::SetVerboseLevel ( G4int  value )

inlineinherited

Definition at line 412 of file G4VProcess.hh.

{
  verboseLevel = value;
}

References G4VProcess::verboseLevel.

Referenced by G4EmDNAChemistry::ConstructProcess(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4EmDNAChemistry_option2::ConstructProcess(), G4ProcessTable::DumpInfo(), export_G4VProcess(), G4CoupledTransportation::G4CoupledTransportation(), G4GammaGeneralProcess::G4GammaGeneralProcess(), G4hhIonisation::G4hhIonisation(), G4mplIonisation::G4mplIonisation(), G4Transportation(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), G4CoulombScattering::InitialiseProcess(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4ProcessManagerMessenger::SetNewValue(), and G4ProcessTableMessenger::SetNewValue().

StartTracking()

void G4Transportation::StartTracking ( G4Track *  aTrack )

virtual

Reimplemented from G4VProcess.

Definition at line 769 of file G4Transportation.cc.

{
  G4VProcess::StartTracking(aTrack);
  fNewTrack= true;
  fFirstStepInVolume= true;
  fLastStepInVolume= false;
  
  // The actions here are those that were taken in AlongStepGPIL
  // when track.GetCurrentStepNumber()==1
 
  // Whether field exists should be determined at run level -- TODO
  fAnyFieldExists= DoesAnyFieldExist(); 
  
  // reset safety value and center
  //
  fPreviousSafety    = 0.0 ; 
  fPreviousSftOrigin = G4ThreeVector(0.,0.,0.) ;
  
  // reset looping counter -- for motion in field
  fNoLooperTrials= 0; 
  // Must clear this state .. else it depends on last track's value
  //  --> a better solution would set this from state of suspended track TODO ? 
  // Was if( aTrack->GetCurrentStepNumber()==1 ) { .. }
 
  // ChordFinder reset internal state
  //
  if( fFieldPropagator && fAnyFieldExists )     
  {
     fFieldPropagator->ClearPropagatorState();   
       // Resets all state of field propagator class (ONLY) including safety
       // values (in case of overlaps and to wipe for first track).
  }
 
  // Make sure to clear the chord finders of all fields (i.e. managers)
  //
  G4FieldManagerStore* fieldMgrStore = G4FieldManagerStore::GetInstance();
  fieldMgrStore->ClearAllChordFindersState(); 
 
  // Update the current touchable handle  (from the track's)
  //
  fCurrentTouchableHandle = aTrack->GetTouchableHandle();
 
  // Inform field propagator of new track
  //
  fFieldPropagator->PrepareNewTrack();
}

References G4FieldManagerStore::ClearAllChordFindersState(), G4PropagatorInField::ClearPropagatorState(), DoesAnyFieldExist(), fAnyFieldExists, fCurrentTouchableHandle, fFieldPropagator, fFirstStepInVolume, fLastStepInVolume, fNewTrack, fNoLooperTrials, fPreviousSafety, fPreviousSftOrigin, G4FieldManagerStore::GetInstance(), G4Track::GetTouchableHandle(), G4PropagatorInField::PrepareNewTrack(), and G4VProcess::StartTracking().

StorePhysicsTable()

virtual G4bool G4VProcess::StorePhysicsTable ( const G4ParticleDefinition *  , const G4String &  , G4bool    )

inlinevirtualinherited

Reimplemented in G4WrapperProcess, G4GammaGeneralProcess, G4AdjointProcessEquivalentToDirectProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, and G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.hh.

                                                              { return true; }

Referenced by export_G4VProcess(), G4WrapperProcess::StorePhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::StorePhysicsTable(), and G4BiasingProcessInterface::StorePhysicsTable().

SubtractNumberOfInteractionLengthLeft()

void G4VProcess::SubtractNumberOfInteractionLengthLeft ( G4double  prevStepSize )

inlineprotectedinherited

Definition at line 524 of file G4VProcess.hh.

{
  if (currentInteractionLength>0.0)
  {
    theNumberOfInteractionLengthLeft -= prevStepSize/currentInteractionLength;
    if(theNumberOfInteractionLengthLeft<0.)
    {
       theNumberOfInteractionLengthLeft=CLHEP::perMillion;
    }
  }
  else
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cerr << "G4VProcess::SubtractNumberOfInteractionLengthLeft()";
      G4cerr << " [" << theProcessName << "]" <<G4endl;
      G4cerr << " currentInteractionLength = "
             << currentInteractionLength << " [mm]";
      G4cerr << " previousStepSize = " << prevStepSize << " [mm]";
      G4cerr << G4endl;
    }
#endif
    G4String msg = "Negative currentInteractionLength for ";
    msg += theProcessName;
    G4Exception("G4VProcess::SubtractNumberOfInteractionLengthLeft()",
                "ProcMan201", EventMustBeAborted, msg);
  }
}

References G4VProcess::currentInteractionLength, EventMustBeAborted, G4cerr, G4endl, G4Exception(), CLHEP::perMillion, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), and G4Decay::PostStepGetPhysicalInteractionLength().

Friends And Related Function Documentation

G4CoupledTransportation

friend class G4CoupledTransportation

friend

Definition at line 240 of file G4Transportation.hh.

Field Documentation

aParticleChange

G4ParticleChange G4VProcess::aParticleChange

protectedinherited

Definition at line 327 of file G4VProcess.hh.

Referenced by G4ContinuousGainOfEnergy::AlongStepDoIt(), G4ErrorEnergyLoss::AlongStepDoIt(), G4hImpactIonisation::AlongStepDoIt(), G4DNAMolecularDissociation::DecayIt(), G4OpBoundaryProcess::DoAbsorption(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4VProcess::G4VProcess(), G4PhononDownconversion::MakeLTSecondaries(), G4PhononDownconversion::MakeTTSecondaries(), G4SpecialCuts::PostStepDoIt(), G4Channeling::PostStepDoIt(), G4PhononDownconversion::PostStepDoIt(), G4PhononReflection::PostStepDoIt(), G4PhononScattering::PostStepDoIt(), G4StepLimiter::PostStepDoIt(), G4UserSpecialCuts::PostStepDoIt(), G4TransitionRadiation::PostStepDoIt(), G4UCNAbsorption::PostStepDoIt(), G4UCNBoundaryProcess::PostStepDoIt(), G4UCNLoss::PostStepDoIt(), G4UCNMultiScattering::PostStepDoIt(), G4AnnihiToMuPair::PostStepDoIt(), G4GammaConversionToMuons::PostStepDoIt(), G4MicroElecSurface::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), G4ForwardXrayTR::PostStepDoIt(), G4Scintillation::PostStepDoIt(), G4OpAbsorption::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpMieHG::PostStepDoIt(), G4OpRayleigh::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), G4hImpactIonisation::PostStepDoIt(), G4SynchrotronRadiation::PostStepDoIt(), and G4SynchrotronRadiationInMat::PostStepDoIt().

aProcessManager

const G4ProcessManager* G4VProcess::aProcessManager = nullptr

protectedinherited

Definition at line 319 of file G4VProcess.hh.

Referenced by G4VProcess::GetProcessManager(), and G4VProcess::SetProcessManager().

currentInteractionLength

G4double G4VProcess::currentInteractionLength = -1.0

protectedinherited

Definition at line 335 of file G4VProcess.hh.

Referenced by G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4VProcess::EndTracking(), G4Decay::EndTracking(), G4VProcess::GetCurrentInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4Decay::PostStepGetPhysicalInteractionLength(), G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::StartTracking(), G4Decay::StartTracking(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

enableAlongStepDoIt

G4bool G4VProcess::enableAlongStepDoIt = true

protectedinherited

Definition at line 360 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ITTransportation::G4ITTransportation(), G4NuclearStopping::G4NuclearStopping(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), G4VITRestDiscreteProcess::G4VITRestDiscreteProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestDiscreteProcess::G4VRestDiscreteProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isAlongStepDoItIsEnabled().

enableAtRestDoIt

G4bool G4VProcess::enableAtRestDoIt = true

protectedinherited

Definition at line 359 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4eplusAnnihilation::G4eplusAnnihilation(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VContinuousDiscreteProcess::G4VContinuousDiscreteProcess(), G4VContinuousProcess::G4VContinuousProcess(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), and G4VProcess::isAtRestDoItIsEnabled().

enablePostStepDoIt

G4bool G4VProcess::enablePostStepDoIt = true

protectedinherited

Definition at line 361 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4NuclearStopping::G4NuclearStopping(), G4VContinuousProcess::G4VContinuousProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestContinuousProcess::G4VRestContinuousProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isPostStepDoItIsEnabled().

fAbandonUnstableTrials

G4int G4Transportation::fAbandonUnstableTrials = 0

private

Definition at line 209 of file G4Transportation.hh.

Referenced by AlongStepDoIt().

fAnyFieldExists

G4bool G4Transportation::fAnyFieldExists = false

private

Definition at line 179 of file G4Transportation.hh.

Referenced by G4Transportation(), and StartTracking().

fCandidateEndGlobalTime

G4double G4Transportation::fCandidateEndGlobalTime = 0.0

private

Definition at line 176 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and AlongStepGetPhysicalInteractionLength().

fCurrentTouchableHandle

G4TouchableHandle G4Transportation::fCurrentTouchableHandle

private

Definition at line 191 of file G4Transportation.hh.

Referenced by G4Transportation(), PostStepDoIt(), and StartTracking().

fEndGlobalTimeComputed

G4bool G4Transportation::fEndGlobalTimeComputed = false

private

Definition at line 175 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and AlongStepGetPhysicalInteractionLength().

fEndPointDistance

G4double G4Transportation::fEndPointDistance

private

Definition at line 200 of file G4Transportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength().

fFieldExertedForce

G4bool G4Transportation::fFieldExertedForce = false

private

Definition at line 189 of file G4Transportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength(), FieldExertedForce(), PostStepDoIt(), and PostStepGetPhysicalInteractionLength().

fFieldPropagator

G4PropagatorInField* G4Transportation::fFieldPropagator

private

Definition at line 167 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), AlongStepGetPhysicalInteractionLength(), G4Transportation(), PostStepDoIt(), and StartTracking().

fFirstStepInVolume

G4bool G4Transportation::fFirstStepInVolume = true

private

Definition at line 183 of file G4Transportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength(), PostStepDoIt(), and StartTracking().

fGeometryLimitedStep

G4bool G4Transportation::fGeometryLimitedStep = true

private

Definition at line 186 of file G4Transportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength(), and PostStepDoIt().

fLastStepInVolume

G4bool G4Transportation::fLastStepInVolume = false

private

Definition at line 184 of file G4Transportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength(), PostStepDoIt(), and StartTracking().

fLinearNavigator

G4Navigator* G4Transportation::fLinearNavigator

private

Definition at line 166 of file G4Transportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength(), G4Transportation(), and PostStepDoIt().

fMaxEnergyKilled

G4double G4Transportation::fMaxEnergyKilled = -1.0

private

Definition at line 219 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and PrintStatistics().

fMaxEnergyKilled_NonElecPDG

G4int G4Transportation::fMaxEnergyKilled_NonElecPDG = 0

private

Definition at line 225 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and PrintStatistics().

fMaxEnergyKilled_NonElectron

G4double G4Transportation::fMaxEnergyKilled_NonElectron = -1.0

private

Definition at line 224 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and PrintStatistics().

fMaxEnergyKilledPDG

G4int G4Transportation::fMaxEnergyKilledPDG = 0

private

Definition at line 220 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and PrintStatistics().

fMaxEnergySaved

G4double G4Transportation::fMaxEnergySaved = -1.0

private

Definition at line 228 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and PrintStatistics().

fMomentumChanged

G4bool G4Transportation::fMomentumChanged = true

private

Definition at line 174 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and AlongStepGetPhysicalInteractionLength().

fNewTrack

G4bool G4Transportation::fNewTrack = true

private

Definition at line 182 of file G4Transportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength(), and StartTracking().

fNoLooperTrials

G4int G4Transportation::fNoLooperTrials = 0

private

Definition at line 213 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and StartTracking().

fNumLoopersKilled

unsigned long G4Transportation::fNumLoopersKilled = 0

private

Definition at line 221 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and PrintStatistics().

fNumLoopersKilled_NonElectron

unsigned long G4Transportation::fNumLoopersKilled_NonElectron = 0

private

Definition at line 226 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and PrintStatistics().

fParticleChange

G4ParticleChangeForTransport G4Transportation::fParticleChange

private

Definition at line 197 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), AlongStepGetPhysicalInteractionLength(), G4Transportation(), and PostStepDoIt().

fParticleIsLooping

G4bool G4Transportation::fParticleIsLooping = false

private

Definition at line 181 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and AlongStepGetPhysicalInteractionLength().

fpLogger

G4TransportationLogger* G4Transportation::fpLogger

private

Definition at line 236 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), G4Transportation(), ReportLooperThresholds(), and ~G4Transportation().

fPreviousSafety

G4double G4Transportation::fPreviousSafety

private

Definition at line 194 of file G4Transportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength(), and StartTracking().

fPreviousSftOrigin

G4ThreeVector G4Transportation::fPreviousSftOrigin

private

Definition at line 193 of file G4Transportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength(), and StartTracking().

fProcessTable

G4ProcessTable* G4VProcess::fProcessTable = nullptr

privateinherited

Definition at line 374 of file G4VProcess.hh.

Referenced by G4VProcess::G4VProcess(), and G4VProcess::~G4VProcess().

fpSafetyHelper

G4SafetyHelper* G4Transportation::fpSafetyHelper

private

Definition at line 235 of file G4Transportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength(), and G4Transportation().

fShortStepOptimisation

G4bool G4Transportation::fShortStepOptimisation

private

Definition at line 233 of file G4Transportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength(), and G4Transportation().

fSilenceLooperWarnings

G4bool G4Transportation::fSilenceLooperWarnings = false

staticprivate

Definition at line 243 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), GetSilenceLooperWarnings(), and SetSilenceLooperWarnings().

fSumEnergyKilled

G4double G4Transportation::fSumEnergyKilled = 0.0

private

Definition at line 217 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), PrintStatistics(), and ~G4Transportation().

fSumEnergyKilled_NonElectron

G4double G4Transportation::fSumEnergyKilled_NonElectron = 0.0

private

Definition at line 222 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and PrintStatistics().

fSumEnergySaved

G4double G4Transportation::fSumEnergySaved = 0.0

private

Definition at line 227 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and PrintStatistics().

fSumEnergyUnstableSaved

G4double G4Transportation::fSumEnergyUnstableSaved = 0.0

private

Definition at line 229 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and PrintStatistics().

fSumEnerSqKilled

G4double G4Transportation::fSumEnerSqKilled = 0.0

private

Definition at line 218 of file G4Transportation.hh.

Referenced by AlongStepDoIt().

fSumEnerSqKilled_NonElectron

G4double G4Transportation::fSumEnerSqKilled_NonElectron = 0.0

private

Definition at line 223 of file G4Transportation.hh.

Referenced by AlongStepDoIt().

fThreshold_Important_Energy

G4double G4Transportation::fThreshold_Important_Energy = 1.0 * CLHEP::MeV

private

Definition at line 205 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and AlongStepGetPhysicalInteractionLength().

fThreshold_Warning_Energy

G4double G4Transportation::fThreshold_Warning_Energy = 1.0 * CLHEP::keV

private

Definition at line 204 of file G4Transportation.hh.

Referenced by AlongStepDoIt().

fThresholdTrials

G4int G4Transportation::fThresholdTrials = 10

private

Definition at line 206 of file G4Transportation.hh.

Referenced by AlongStepDoIt().

fTransportEndKineticEnergy

G4double G4Transportation::fTransportEndKineticEnergy = 0.0

private

Definition at line 172 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and AlongStepGetPhysicalInteractionLength().

fTransportEndMomentumDir

G4ThreeVector G4Transportation::fTransportEndMomentumDir = G4ThreeVector( 0.0, 0.0, 0.0 )

private

Definition at line 171 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and AlongStepGetPhysicalInteractionLength().

fTransportEndPosition

G4ThreeVector G4Transportation::fTransportEndPosition = G4ThreeVector( 0.0, 0.0, 0.0 )

private

Definition at line 170 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and AlongStepGetPhysicalInteractionLength().

fTransportEndSpin

G4ThreeVector G4Transportation::fTransportEndSpin = G4ThreeVector( 0.0, 0.0, 0.0 )

private

Definition at line 173 of file G4Transportation.hh.

Referenced by AlongStepDoIt(), and AlongStepGetPhysicalInteractionLength().

fUseGravity

G4bool G4Transportation::fUseGravity = false

staticprivate

Definition at line 242 of file G4Transportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength(), G4CoupledTransportation::EnableGravity(), and EnableGravity().

fUseMagneticMoment

G4bool G4Transportation::fUseMagneticMoment =false

staticprivate

Definition at line 241 of file G4Transportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength(), G4CoupledTransportation::EnableMagneticMoment(), and EnableMagneticMoment().

masterProcessShadow

G4VProcess* G4VProcess::masterProcessShadow = nullptr

privateinherited

Definition at line 370 of file G4VProcess.hh.

Referenced by G4VProcess::GetMasterProcess(), and G4VProcess::SetMasterProcess().

pParticleChange

G4VParticleChange* G4VProcess::pParticleChange = nullptr

protectedinherited

Definition at line 321 of file G4VProcess.hh.

Referenced by G4VMultipleScattering::AddEmModel(), G4VEmProcess::AddEmModel(), G4VEnergyLossProcess::AddEmModel(), G4ImportanceProcess::AlongStepDoIt(), G4WeightCutOffProcess::AlongStepDoIt(), G4WeightWindowProcess::AlongStepDoIt(), G4VContinuousDiscreteProcess::AlongStepDoIt(), G4VContinuousProcess::AlongStepDoIt(), G4VRestContinuousDiscreteProcess::AlongStepDoIt(), G4VRestContinuousProcess::AlongStepDoIt(), G4ParallelWorldProcess::AlongStepDoIt(), G4ParallelWorldScoringProcess::AlongStepDoIt(), G4VITRestProcess::AtRestDoIt(), G4VRestContinuousDiscreteProcess::AtRestDoIt(), G4VRestContinuousProcess::AtRestDoIt(), G4VRestDiscreteProcess::AtRestDoIt(), G4VRestProcess::AtRestDoIt(), G4ParallelWorldProcess::AtRestDoIt(), G4ParallelWorldScoringProcess::AtRestDoIt(), G4ScoreSplittingProcess::AtRestDoIt(), G4VITRestDiscreteProcess::AtRestDoIt(), G4eplusAnnihilation::AtRestDoIt(), G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4VEnergyLossProcess::FillSecondariesAlongStep(), G4Decay::G4Decay(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ImportanceProcess::G4ImportanceProcess(), G4ITTransportation::G4ITTransportation(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4RadioactiveDecay::G4RadioactiveDecay(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4Transportation(), G4UnknownDecay::G4UnknownDecay(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), G4VProcess::G4VProcess(), G4VXTRenergyLoss::G4VXTRenergyLoss(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4VITDiscreteProcess::PostStepDoIt(), G4VContinuousDiscreteProcess::PostStepDoIt(), G4VDiscreteProcess::PostStepDoIt(), G4VRestContinuousDiscreteProcess::PostStepDoIt(), G4VRestDiscreteProcess::PostStepDoIt(), G4ParallelWorldProcess::PostStepDoIt(), G4ParallelWorldScoringProcess::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4NeutronKiller::PostStepDoIt(), G4VITRestDiscreteProcess::PostStepDoIt(), G4LowECapture::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), and G4VTransitionRadiation::PostStepDoIt().

theInitialNumberOfInteractionLength

G4double G4VProcess::theInitialNumberOfInteractionLength = -1.0

protectedinherited

Definition at line 338 of file G4VProcess.hh.

Referenced by G4VProcess::ClearNumberOfInteractionLengthLeft(), G4VProcess::EndTracking(), G4VProcess::GetTotalNumberOfInteractionLengthTraversed(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::ResetNumberOfInteractionLengthLeft(), and G4VProcess::StartTracking().

theNumberOfInteractionLengthLeft

G4double G4VProcess::theNumberOfInteractionLengthLeft = -1.0

protectedinherited

Definition at line 331 of file G4VProcess.hh.

Referenced by G4AdjointForcedInteractionForGamma::AlongStepDoIt(), G4MuonicAtomDecay::AtRestGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4Decay::AtRestGetPhysicalInteractionLength(), G4VProcess::ClearNumberOfInteractionLengthLeft(), G4MuonicAtomDecay::DecayIt(), G4VProcess::EndTracking(), G4VProcess::GetNumberOfInteractionLengthLeft(), G4VProcess::GetTotalNumberOfInteractionLengthTraversed(), G4GammaGeneralProcess::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4Decay::PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::ResetNumberOfInteractionLengthLeft(), G4VProcess::StartTracking(), G4GammaGeneralProcess::StartTracking(), G4VEmProcess::StartTracking(), G4VEnergyLossProcess::StartTracking(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

thePhysicsTableFileName

G4String G4VProcess::thePhysicsTableFileName

protectedinherited

Definition at line 344 of file G4VProcess.hh.

Referenced by G4VProcess::GetPhysicsTableFileName().

thePILfactor

G4double G4VProcess::thePILfactor = 1.0

protectedinherited

Definition at line 352 of file G4VProcess.hh.

Referenced by G4VProcess::AtRestGPIL(), G4VProcess::GetPILfactor(), G4VProcess::PostStepGPIL(), and G4VProcess::SetPILfactor().

theProcessName

G4String G4VProcess::theProcessName

protectedinherited

Definition at line 341 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4VProcess::EndTracking(), G4ImportanceProcess::GetName(), G4WeightCutOffProcess::GetName(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetProcessName(), G4WrapperProcess::RegisterProcess(), G4VProcess::StartTracking(), G4VITProcess::SubtractNumberOfInteractionLengthLeft(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

theProcessSubType

G4int G4VProcess::theProcessSubType = -1

protectedinherited

Definition at line 349 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VProcess::GetProcessSubType(), and G4VProcess::SetProcessSubType().

theProcessType

G4ProcessType G4VProcess::theProcessType = fNotDefined

protectedinherited

Definition at line 346 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4VProcess::GetProcessType(), G4WrapperProcess::RegisterProcess(), and G4VProcess::SetProcessType().

verboseLevel

G4int G4VProcess::verboseLevel = 0

protectedinherited

Definition at line 356 of file G4VProcess.hh.

Referenced by G4VEnergyLossProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateSecondaryBiasing(), G4VEnergyLossProcess::ActivateSecondaryBiasing(), G4LowECapture::AddRegion(), G4CoupledTransportation::AlongStepDoIt(), AlongStepDoIt(), G4VContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4ParallelWorldProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4CoupledTransportation::AlongStepGetPhysicalInteractionLength(), AlongStepGetPhysicalInteractionLength(), G4VContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4hImpactIonisation::AntiProtonParametrisedDEDX(), G4ParallelWorldScoringProcess::AtRestDoIt(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4VXTRenergyLoss::BuildAngleForEnergyBank(), G4VXTRenergyLoss::BuildAngleTable(), G4VEnergyLossProcess::BuildDEDXTable(), G4VXTRenergyLoss::BuildEnergyTable(), G4VXTRenergyLoss::BuildGlobalAngleTable(), G4VEmProcess::BuildLambdaTable(), G4hImpactIonisation::BuildLambdaTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4hImpactIonisation::BuildLossTable(), G4DNABrownianTransportation::BuildPhysicsTable(), G4GammaGeneralProcess::BuildPhysicsTable(), G4LowECapture::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4SynchrotronRadiation::BuildPhysicsTable(), G4VXTRenergyLoss::BuildPhysicsTable(), G4hImpactIonisation::BuildPhysicsTable(), G4ChargeExchangeProcess::BuildPhysicsTable(), G4OpRayleigh::CalculateRayleighMeanFreePaths(), G4PolarizedAnnihilation::ComputeSaturationFactor(), G4PolarizedCompton::ComputeSaturationFactor(), G4PolarizedIonisation::ComputeSaturationFactor(), G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4VPhononProcess::CreateSecondary(), G4VProcess::EndTracking(), G4VEmProcess::FindLambdaMax(), G4Cerenkov::G4Cerenkov(), G4ChargeExchangeProcess::G4ChargeExchangeProcess(), G4CoupledTransportation::G4CoupledTransportation(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ErrorEnergyLoss::G4ErrorEnergyLoss(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GaussXTRadiator::G4GaussXTRadiator(), G4ImportanceProcess::G4ImportanceProcess(), G4MaxTimeCuts::G4MaxTimeCuts(), G4MicroElecSurface::G4MicroElecSurface(), G4MinEkineCuts::G4MinEkineCuts(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4PolarizedIonisation::G4PolarizedIonisation(), G4Scintillation::G4Scintillation(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4SpecialCuts::G4SpecialCuts(), G4StepLimiter::G4StepLimiter(), G4StrawTubeXTRadiator::G4StrawTubeXTRadiator(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4TransparentRegXTRadiator::G4TransparentRegXTRadiator(), G4Transportation(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VXTRenergyLoss::G4VXTRenergyLoss(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4VXTRenergyLoss::GetAngleVector(), G4ChargeExchangeProcess::GetElementCrossSection(), G4VXTRenergyLoss::GetGasZmuProduct(), G4PhononDownconversion::GetMeanFreePath(), G4PhononScattering::GetMeanFreePath(), G4PolarizedCompton::GetMeanFreePath(), G4VXTRenergyLoss::GetMeanFreePath(), G4UCNAbsorption::GetMeanFreePath(), G4PolarizedAnnihilation::GetMeanFreePath(), G4PolarizedIonisation::GetMeanFreePath(), G4SynchrotronRadiation::GetMeanFreePath(), G4VXTRenergyLoss::GetNumberOfPhotons(), G4VXTRenergyLoss::GetPlateZmuProduct(), G4SynchrotronRadiation::GetRandomEnergySR(), G4VProcess::GetVerboseLevel(), G4hhIonisation::InitialiseEnergyLossProcess(), G4eeToHadrons::InitialiseProcess(), G4hImpactIonisation::InitializeMe(), G4UCNBoundaryProcess::MRreflect(), G4UCNBoundaryProcess::MRreflectHigh(), G4DNASecondOrderReaction::PostStepDoIt(), G4ParallelWorldScoringProcess::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4DNAScavengerProcess::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4UCNAbsorption::PostStepDoIt(), G4UCNBoundaryProcess::PostStepDoIt(), G4UCNLoss::PostStepDoIt(), G4UCNMultiScattering::PostStepDoIt(), G4MicroElecSurface::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), G4Scintillation::PostStepDoIt(), G4VXTRenergyLoss::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4OpAbsorption::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpMieHG::PostStepDoIt(), G4OpRayleigh::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), G4CoupledTransportation::PostStepDoIt(), G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNASecondOrderReaction::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNAScavengerProcess::PostStepGetPhysicalInteractionLength(), G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4hImpactIonisation::ProtonParametrisedDEDX(), G4UCNBoundaryProcess::Reflect(), G4CoupledTransportation::ReportInexactEnergy(), G4CoupledTransportation::ReportMissingLogger(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrieveTable(), G4VEmProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCSDARangeTable(), G4CoupledTransportation::SetHighLooperThresholds(), SetHighLooperThresholds(), G4VEnergyLossProcess::SetInverseRangeTable(), G4LowECapture::SetKinEnergyLimit(), G4NeutronKiller::SetKinEnergyLimit(), G4VEnergyLossProcess::SetLambdaTable(), G4CoupledTransportation::SetLowLooperThresholds(), SetLowLooperThresholds(), G4VEnergyLossProcess::SetRangeTableForLoss(), G4VEnergyLossProcess::SetSecondaryRangeTable(), G4NeutronKiller::SetTimeLimit(), G4VProcess::SetVerboseLevel(), G4Cerenkov::SetVerboseLevel(), G4Scintillation::SetVerboseLevel(), G4OpAbsorption::SetVerboseLevel(), G4OpBoundaryProcess::SetVerboseLevel(), G4OpMieHG::SetVerboseLevel(), G4OpRayleigh::SetVerboseLevel(), G4OpWLS::SetVerboseLevel(), G4OpWLS2::SetVerboseLevel(), G4FastSimulationManagerProcess::SetWorldVolume(), G4GaussXTRadiator::SpectralXTRdEdx(), G4RegularXTRadiator::SpectralXTRdEdx(), G4TransparentRegXTRadiator::SpectralXTRdEdx(), G4XTRRegularRadModel::SpectralXTRdEdx(), G4VProcess::StartTracking(), G4CoupledTransportation::StartTracking(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), G4VEnergyLossProcess::StoreTable(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), G4VMultipleScattering::StreamInfo(), G4VITProcess::SubtractNumberOfInteractionLengthLeft(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

---

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

• source/processes/transportation/include/G4Transportation.hh
• source/processes/transportation/src/G4Transportation.cc