Concrete class that does the geometrical transport. More...

#include <G4LongLivedNeutralTransportation.h>

Inheritance diagram for G4LongLivedNeutralTransportation:

Public Member Functions
	G4LongLivedNeutralTransportation (G4int verbosityLevel=1)
	Constructor.

	~G4LongLivedNeutralTransportation ()
	Destructor.

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

G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)
	G4VProcess::AlongStepDoIt() implementation,.

G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)
	G4VProcess::PostStepDoIt() implementation,.

G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *pForceCond)
	G4VProcess::PostStepGetPhysicalInteractionLength() implementation.

G4bool	FieldExertedForce ()
	References fFieldExertedForce.

G4PropagatorInField *	GetPropagatorInField ()
	Access fFieldPropagator, the assistant class that Propagate in a Field.

void	SetPropagatorInField (G4PropagatorInField *pFieldPropagator)
	Access/set the assistant class that Propagate in a Field.

G4double	GetThresholdWarningEnergy () const
	Access fThreshold_Warning_Energy.

G4double	GetThresholdImportantEnergy () const
	Access fThreshold_Important_Energy.

G4int	GetThresholdTrials () const
	Access fThresholdTrials.

void	SetThresholdWarningEnergy (G4double newEnWarn)
	Set fThreshold_Warning_Energy.

void	SetThresholdImportantEnergy (G4double newEnImp)
	Set fThreshold_Important_Energy.

void	SetThresholdTrials (G4int newMaxTrials)
	Set fThresholdTrials.

void	SetHighLooperThresholds ()
	Get/Set parameters for killing loopers: Above 'important' energy a 'looping' particle in field will NOT be abandoned, except after fThresholdTrials attempts.

void	SetLowLooperThresholds ()
	Shortcut method - old values (meant for HEP)

void	ReportLooperThresholds ()
	Set low thresholds - for low-E applications.

G4double	GetMaxEnergyKilled () const
	Print values of looper thresholds.

G4double	GetSumEnergyKilled () const
	Access fSumEnergyKilled.

void	ResetKilledStatistics (G4int report=1)
	Statistics for tracks killed (currently due to looping in field)

void	EnableShortStepOptimisation (G4bool optimise=true)
	Whether short steps < safety will avoid to call Navigator (if field=0)

G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
	No operation in AtRestGPIL.

G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
	No operation in AtRestDoIt.

void	StartTracking (G4Track *aTrack)
	Reset state for new (potentially resumed) track.

virtual void	ProcessDescription (std::ostream &outStream) const
	G4LongLivedNeutralTransportation::ProcessDescription()

void	PrintStatistics (std::ostream &outStr) const
	returns current logging info of the algorithm

Static Public Member Functions
static void	SetSilenceLooperWarnings (G4bool val)
	Do not warn about 'looping' particles.

static G4bool	GetSilenceLooperWarnings ()
	Do not throw exception about 'looping' particles.

Protected Member Functions
G4bool	DoesGlobalFieldExist ()
	Checks whether a field exists for the "global" field manager.

Private Attributes
G4Navigator *	fLinearNavigator
	Propagator used to transport the particle.

G4PropagatorInField *	fFieldPropagator
	Propagator used to transport the particle.

G4ThreeVector	fTransportEndPosition = G4ThreeVector(0.0, 0.0, 0.0)
	The particle's state after this Step, Store for DoIt.

G4ThreeVector	fTransportEndMomentumDir = G4ThreeVector(0.0, 0.0, 0.0)
	The particle's state after this Step, Store for DoIt.

G4double	fTransportEndKineticEnergy = 0.0
	The particle's state after this Step, Store for DoIt.

G4ThreeVector	fTransportEndSpin = G4ThreeVector(0.0, 0.0, 0.0)
	The particle's state after this Step, Store for DoIt.

G4bool	fMomentumChanged = true
	The particle's state after this Step, Store for DoIt.

G4bool	fEndGlobalTimeComputed = false
	The particle's state after this Step, Store for DoIt.

G4double	fCandidateEndGlobalTime = 0.0
	The particle's state after this Step, Store for DoIt.

G4bool	fAnyFieldExists = false
	Flag for existing fields.

G4bool	fNewTrack = true
	Flag from StartTracking.

G4bool	fFirstStepInVolume = true
	Flag first step in a geom.

G4bool	fLastStepInVolume = false
	Flag last step in a geom.

G4bool	fGeometryLimitedStep = true
	Flag to determine whether a boundary was reached.

G4bool	fFieldExertedForce = false
	During current step.

G4TouchableHandle	fCurrentTouchableHandle
	Current touchable handle.

G4ThreeVector	fPreviousSftOrigin
	Remember last safety origin.

G4double	fPreviousSafety
	Remember last safety value.

G4ParticleChangeForTransport	fParticleChange
	New ParticleChange.

G4double	fEndPointDistance
	Endpoint distance.

G4double	fThreshold_Warning_Energy = 1.0 * CLHEP::keV
	Warn above this energy about looping particle.

G4double	fThreshold_Important_Energy = 1.0 * CLHEP::MeV
	Give a few trial above this E for looping particle.

G4int	fThresholdTrials = 10
	Number of trials an important looper survives.

G4int	fAbandonUnstableTrials = 0
	Number of trials after which to abandon.

G4int	fNoLooperTrials = 0
	Counter for steps in which particle reports 'looping', if it is above 'Important' Energy.

G4double	fSumEnergyKilled = 0.0
	Sum of abandoned looping tracks energies.

G4bool	fShortStepOptimisation
	Whether to avoid calling G4Navigator for short step ( < safety) If using it, the safety estimate for endpoint will likely be smaller.

G4SafetyHelper *	fpSafetyHelper
	To pass it the safety value obtained.

Static Private Attributes
static G4bool	fUseMagneticMoment
	Flag take into account magnetic moment.

static G4bool	fUseGravity
	Flag take into account gravity.

static G4bool	fSilenceLooperWarnings = false
	Flag to Supress all 'looper' warnings.

Friends
class	G4CoupledTransportation

Detailed Description

Concrete class that does the geometrical transport.

Definition at line 36 of file G4LongLivedNeutralTransportation.h.

Constructor & Destructor Documentation

◆ G4LongLivedNeutralTransportation()

G4LongLivedNeutralTransportation ( G4int verbosityLevel = 1 )

Constructor.

Parameters

verbosityLevel

Definition at line 33 of file G4LongLivedNeutralTransportation.cc.

  : G4VProcess(G4String("LongLivedNeutralTransportation"), 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() ;
 
 
 
 
  SetHighLooperThresholds();
  // Use the old defaults: Warning = 100 MeV, Important = 250 MeV, No Trials = 10;
 
  // 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 guaranteed.
  fAnyFieldExists = DoesGlobalFieldExist();
  //  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;
  pNullTouchableHandle = new G4TouchableHandle;
  fCurrentTouchableHandle = *pNullTouchableHandle;
  // Points to (G4VTouchable*) 0
 
 
#ifdef G4VERBOSE
  if (verboseLevel > 0) {
    G4cout << " G4LongLivedNeutralTransportation constructor> set fShortStepOptimisation to ";
    if (fShortStepOptimisation)  { G4cout << "true"  << G4endl; }
    else                           { G4cout << "false" << G4endl; }
  }
#endif
}

◆ ~G4LongLivedNeutralTransportation()

~G4LongLivedNeutralTransportation ( )

Destructor.

Definition at line 83 of file G4LongLivedNeutralTransportation.cc.

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

Member Function Documentation

◆ AlongStepDoIt()

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

G4VProcess::AlongStepDoIt() implementation,.

Parameters

track	Propagating particle track reference
stepData	Current step reference

Definition at line 259 of file G4LongLivedNeutralTransportation.cc.

{
  // static G4ThreadLocal G4long noCallsASDI = 0;
  // noCallsASDI++;
 
  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() ;
 
  const G4DynamicParticle*    pParticle    = track.GetDynamicParticle() ;
  const G4PrimaryParticle* primaryParticle = pParticle->GetPrimaryParticle();
 
 
  if (!fEndGlobalTimeComputed) {
    // The time was not integrated .. make the best estimate possible
    //
 
    // use c*beta from primary particle, llp will not be slowed down anyways
    // default was: stepData.GetPreStepPoint()->GetVelocity();, but assumes wrong values from particle definition
    B2DEBUG(0, "Velocity calculated from Step data: " << stepData.GetPreStepPoint()->GetVelocity());
 
    G4double initialVelocity = c_light * primaryParticle->GetTotalMomentum() / primaryParticle->GetTotalEnergy();
    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       = primaryParticle->GetMass() ;
  G4double deltaProperTime = deltaTime * (restMass / primaryParticle->GetTotalEnergy()) ;
 
  fParticleChange.ProposeProperTime(track.GetProperTime() + deltaProperTime) ;
  //fParticleChange.ProposeTrueStepLength( track.GetStepLength() ) ;
 
  // 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 ;
}

◆ AlongStepGetPhysicalInteractionLength()

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

G4VProcess::AlongStepGetPhysicalInteractionLength() implementation,.

Parameters

track	Propagating particle track reference
previousStepSize	This argument of base function is ignored
currentMinimumStep	Current minimum step size
currentSafety	Reference to current step safety
selection	Pointer for return value of GPILSelection, which is set to default value of CandidateForSelection

Returns: Next geometry step length

Definition at line 108 of file G4LongLivedNeutralTransportation.cc.

{
  G4double geometryStepLength = -1.0, newSafety = -1.0;
 
  // 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 default value of CandidateForSelection
  // It is a return value
  //
  *selection = CandidateForSelection ;
 
  fFirstStepInVolume = fNewTrack || fLastStepInVolume;
  fLastStepInVolume = false;
  fNewTrack = false;
 
  fParticleChange.ProposeFirstStepInVolume(fFirstStepInVolume);
 
  // Get initial Energy/Momentum of the track
  //
  const G4DynamicParticle*    pParticle    = track.GetDynamicParticle() ;
  const G4PrimaryParticle* primaryParticle = pParticle->GetPrimaryParticle();
  G4ThreeVector startMomentumDir = primaryParticle->GetMomentumDirection() ;
  G4ThreeVector startPosition    = track.GetPosition() ;
 
  // 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.
  //
  G4ThreeVector OriginShift = startPosition - fPreviousSftOrigin ;
  G4double      MagSqShift  = OriginShift.mag2() ;
  if (MagSqShift >= sqr(fPreviousSafety)) {
    currentSafety = 0.0 ;
  } else {
    currentSafety = fPreviousSafety - std::sqrt(MagSqShift) ;
  }
 
  // Is the particle charged or has it a magnetic moment?
  //
  G4double particleCharge = 0 ;
 
  fGeometryLimitedStep = false ;
 
  // There is no need to locate the current volume. It is Done elsewhere:
  //   On track construction
  //   By the tracking, after all AlongStepDoIts, in "Relocation"
 
  G4double linearStepLength ;
  if (fShortStepOptimisation && (currentMinimumStep <= currentSafety)) {
    // The Step is guaranteed to be taken
    //
    geometryStepLength   = currentMinimumStep ;
    fGeometryLimitedStep = false ;
  } else {
    //  Find whether the straight path intersects a volume
    //
    linearStepLength = fLinearNavigator->ComputeStep(startPosition,
                                                     startMomentumDir,
                                                     currentMinimumStep,
                                                     newSafety) ;
    // Remember last safety origin & value.
    //
    fPreviousSftOrigin = startPosition ;
    fPreviousSafety    = newSafety ;
 
 
    currentSafety = newSafety ;
 
    fGeometryLimitedStep = (linearStepLength <= currentMinimumStep);
    if (fGeometryLimitedStep) {
      // The geometry limits the Step size (an intersection was found.)
      geometryStepLength   = linearStepLength ;
    } else {
      // The full Step is taken.
      geometryStepLength   = currentMinimumStep ;
    }
 
    fEndPointDistance = geometryStepLength ;
 
    // Calculate final position
    //
    fTransportEndPosition = startPosition + geometryStepLength * startMomentumDir;
 
    // Momentum direction, energy and polarisation are unchanged by transport
    //
    fTransportEndMomentumDir   = startMomentumDir ;
    fTransportEndKineticEnergy = primaryParticle->GetKineticEnergy() ;
    fTransportEndSpin          = track.GetPolarization();
    fMomentumChanged           = false ;
    fEndGlobalTimeComputed     = false ;
  }
 
 
  // If we are asked to go a step length of 0, and we are on a boundary
  // then a boundary will also limit the step -> we must flag this.
  //
  if (currentMinimumStep == 0.0) {
    if (currentSafety == 0.0)  { fGeometryLimitedStep = true; }
  }
 
  // 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 ;
 
 
      // Because the Stepping Manager assumes it is from the start point,
      //  add the StepLength
      //
      currentSafety     += fEndPointDistance ;
 
#ifdef G4DEBUG_TRANSPORT
      G4cout.precision(12) ;
      G4cout << "***G4LongLivedNeutralTransportation::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 << "***G4LongLivedNeutralTransportation::AlongStepGPIL ** " << G4endl  ;
      G4cout << "  Avoiding call to ComputeSafety : " << G4endl;
      G4cout << "    charge     = " << particleCharge     << G4endl;
      G4cout << "    mag moment = " << magneticMoment     << G4endl;
#endif
    }
  }
 
  fParticleChange.ProposeTrueStepLength(geometryStepLength) ;
 
  return geometryStepLength ;
}

◆ AtRestDoIt()

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

inline

No operation in AtRestDoIt.

Definition at line 177 of file G4LongLivedNeutralTransportation.h.

178 { return 0; }

◆ AtRestGetPhysicalInteractionLength()

G4double AtRestGetPhysicalInteractionLength	(	const G4Track &	,
		G4ForceCondition *
	)

inline

No operation in AtRestGPIL.

Definition at line 170 of file G4LongLivedNeutralTransportation.h.

172 { return -1.0; }

◆ DoesGlobalFieldExist()

G4bool DoesGlobalFieldExist ( )

inlineprotected

Checks whether a field exists for the "global" field manager.

Definition at line 198 of file G4LongLivedNeutralTransportation.h.

    {
      G4TransportationManager* transportMgr;
      transportMgr = G4TransportationManager::GetTransportationManager();
 
      // fFieldExists= transportMgr->GetFieldManager()->DoesFieldExist();
      // return fFieldExists;
      return transportMgr->GetFieldManager()->DoesFieldExist();
    }

◆ FieldExertedForce()

G4bool FieldExertedForce ( )

inline

References fFieldExertedForce.

Definition at line 109 of file G4LongLivedNeutralTransportation.h.

◆ GetMaxEnergyKilled()

G4double GetMaxEnergyKilled ( ) const

inline

Print values of looper thresholds.

Access fMaxEnergyKilled

◆ GetSilenceLooperWarnings()

G4bool GetSilenceLooperWarnings ( )

static

Do not throw exception about 'looping' particles.

Definition at line 515 of file G4LongLivedNeutralTransportation.cc.

{
  return fSilenceLooperWarnings;
}

◆ PostStepDoIt()

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

G4VProcess::PostStepDoIt() implementation,.

Parameters

track
stepData

Definition at line 346 of file G4LongLivedNeutralTransportation.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()
                    or 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() ;
  G4Material* pNewMaterial   = nullptr ;
  G4VSensitiveDetector* pNewSensitiveDetector   = nullptr ;
 
  if (pNewVol != 0) {
    pNewMaterial = pNewVol->GetLogicalVolume()->GetMaterial();
    pNewSensitiveDetector = pNewVol->GetLogicalVolume()->GetSensitiveDetector();
  }
 
  fParticleChange.SetMaterialInTouchable(pNewMaterial) ;
  fParticleChange.SetSensitiveDetectorInTouchable(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 ;
}

◆ PostStepGetPhysicalInteractionLength()

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

G4VProcess::PostStepGetPhysicalInteractionLength() implementation.

Parameters

track	This argument of base function is ignored
previousStepSize	This argument of base function is ignored
pForceCond	Force condition by default

Forces the PostStepDoIt action to be called, but does not limit the step

Definition at line 333 of file G4LongLivedNeutralTransportation.cc.

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

◆ PrintStatistics()

void PrintStatistics ( std::ostream & outStr ) const

returns current logging info of the algorithm

Definition at line 94 of file G4LongLivedNeutralTransportation.cc.

{
  outStr << " G4LongLivedNeutralTransportation: Statistics for looping particles " << G4endl;
  outStr << " No looping tracks found or killed. " << G4endl;
 
}

◆ ProcessDescription()

void ProcessDescription ( std::ostream & outStream ) const

virtual

G4LongLivedNeutralTransportation::ProcessDescription()

Parameters

outStream Output file with a description of process

Definition at line 558 of file G4LongLivedNeutralTransportation.cc.

{
  G4String indent = "  "; //  : "");
  G4int oldPrec = outStream.precision(6);
  // outStream << std::setprecision(6);
  outStream << G4endl << indent << GetProcessName() << ": ";
 
  outStream << "   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;
  outStream.precision(oldPrec);
}

◆ SetHighLooperThresholds()

void SetHighLooperThresholds ( )

Get/Set parameters for killing loopers: Above 'important' energy a 'looping' particle in field will NOT be abandoned, except after fThresholdTrials attempts.

Below Warning energy, no verbosity for looping particles is issued

Definition at line 523 of file G4LongLivedNeutralTransportation.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);
 
 
 
}

◆ SetLowLooperThresholds()

void SetLowLooperThresholds ( )

Shortcut method - old values (meant for HEP)

Definition at line 539 of file G4LongLivedNeutralTransportation.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);
 
}

◆ SetSilenceLooperWarnings()

void SetSilenceLooperWarnings ( G4bool val )

static

Do not warn about 'looping' particles.

Definition at line 507 of file G4LongLivedNeutralTransportation.cc.

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

◆ SetThresholdImportantEnergy()

void SetThresholdImportantEnergy ( G4double newEnImp )

inline

Set fThreshold_Important_Energy.

Definition at line 127 of file G4LongLivedNeutralTransportation.h.

◆ SetThresholdTrials()

void SetThresholdTrials ( G4int newMaxTrials )

inline

Set fThresholdTrials.

Definition at line 131 of file G4LongLivedNeutralTransportation.h.

◆ SetThresholdWarningEnergy()

void SetThresholdWarningEnergy ( G4double newEnWarn )

inline

Set fThreshold_Warning_Energy.

Definition at line 123 of file G4LongLivedNeutralTransportation.h.

◆ StartTracking()

void StartTracking ( G4Track * aTrack )

Reset state for new (potentially resumed) track.

Definition at line 453 of file G4LongLivedNeutralTransportation.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 = DoesGlobalFieldExist();
 
  // 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
  //
  if (fFieldPropagator) fFieldPropagator->PrepareNewTrack();
}

Friends And Related Function Documentation

◆ G4CoupledTransportation

friend class G4CoupledTransportation

friend

Definition at line 265 of file G4LongLivedNeutralTransportation.h.

Member Data Documentation

◆ fAbandonUnstableTrials

G4int fAbandonUnstableTrials = 0

private

Number of trials after which to abandon.

Definition at line 246 of file G4LongLivedNeutralTransportation.h.

◆ fAnyFieldExists

G4bool fAnyFieldExists = false

private

Flag for existing fields.

Definition at line 221 of file G4LongLivedNeutralTransportation.h.

◆ fCandidateEndGlobalTime

G4double fCandidateEndGlobalTime = 0.0

private

The particle's state after this Step, Store for DoIt.

Definition at line 219 of file G4LongLivedNeutralTransportation.h.

◆ fCurrentTouchableHandle

G4TouchableHandle fCurrentTouchableHandle

private

Current touchable handle.

Definition at line 230 of file G4LongLivedNeutralTransportation.h.

◆ fEndGlobalTimeComputed

G4bool fEndGlobalTimeComputed = false

private

The particle's state after this Step, Store for DoIt.

Definition at line 218 of file G4LongLivedNeutralTransportation.h.

◆ fEndPointDistance

G4double fEndPointDistance

private

Endpoint distance.

Definition at line 237 of file G4LongLivedNeutralTransportation.h.

◆ fFieldExertedForce

G4bool fFieldExertedForce = false

private

During current step.

Definition at line 228 of file G4LongLivedNeutralTransportation.h.

◆ fFieldPropagator

G4PropagatorInField* fFieldPropagator

private

Propagator used to transport the particle.

Definition at line 211 of file G4LongLivedNeutralTransportation.h.

◆ fFirstStepInVolume

G4bool fFirstStepInVolume = true

private

Flag first step in a geom.

volume

Definition at line 224 of file G4LongLivedNeutralTransportation.h.

◆ fGeometryLimitedStep

G4bool fGeometryLimitedStep = true

private

Flag to determine whether a boundary was reached.

Definition at line 226 of file G4LongLivedNeutralTransportation.h.

◆ fLastStepInVolume

G4bool fLastStepInVolume = false

private

Flag last step in a geom.

volume

Definition at line 225 of file G4LongLivedNeutralTransportation.h.

◆ fLinearNavigator

G4Navigator* fLinearNavigator

private

Propagator used to transport the particle.

Definition at line 210 of file G4LongLivedNeutralTransportation.h.

◆ fMomentumChanged

G4bool fMomentumChanged = true

private

The particle's state after this Step, Store for DoIt.

Definition at line 217 of file G4LongLivedNeutralTransportation.h.

◆ fNewTrack

G4bool fNewTrack = true

private

Flag from StartTracking.

Definition at line 223 of file G4LongLivedNeutralTransportation.h.

◆ fNoLooperTrials

G4int fNoLooperTrials = 0

private

Counter for steps in which particle reports 'looping', if it is above 'Important' Energy.

Definition at line 250 of file G4LongLivedNeutralTransportation.h.

◆ fParticleChange

G4ParticleChangeForTransport fParticleChange

private

New ParticleChange.

Definition at line 235 of file G4LongLivedNeutralTransportation.h.

◆ fPreviousSafety

G4double fPreviousSafety

private

Remember last safety value.

Definition at line 233 of file G4LongLivedNeutralTransportation.h.

◆ fPreviousSftOrigin

G4ThreeVector fPreviousSftOrigin

private

Remember last safety origin.

Definition at line 232 of file G4LongLivedNeutralTransportation.h.

◆ fpSafetyHelper

G4SafetyHelper* fpSafetyHelper

private

To pass it the safety value obtained.

Definition at line 261 of file G4LongLivedNeutralTransportation.h.

◆ fShortStepOptimisation

G4bool fShortStepOptimisation

private

Whether to avoid calling G4Navigator for short step ( < safety) If using it, the safety estimate for endpoint will likely be smaller.

Definition at line 259 of file G4LongLivedNeutralTransportation.h.

◆ fSilenceLooperWarnings

G4bool fSilenceLooperWarnings = false

staticprivate

Flag to Supress all 'looper' warnings.

Definition at line 268 of file G4LongLivedNeutralTransportation.h.

◆ fSumEnergyKilled

G4double fSumEnergyKilled = 0.0

private

Sum of abandoned looping tracks energies.

Definition at line 254 of file G4LongLivedNeutralTransportation.h.

◆ fThreshold_Important_Energy

G4double fThreshold_Important_Energy = 1.0 * CLHEP::MeV

private

Give a few trial above this E for looping particle.

Definition at line 242 of file G4LongLivedNeutralTransportation.h.

◆ fThreshold_Warning_Energy

G4double fThreshold_Warning_Energy = 1.0 * CLHEP::keV

private

Warn above this energy about looping particle.

Definition at line 241 of file G4LongLivedNeutralTransportation.h.

◆ fThresholdTrials

G4int fThresholdTrials = 10

private

Number of trials an important looper survives.

Definition at line 243 of file G4LongLivedNeutralTransportation.h.

◆ fTransportEndKineticEnergy

G4double fTransportEndKineticEnergy = 0.0

private

The particle's state after this Step, Store for DoIt.

Definition at line 215 of file G4LongLivedNeutralTransportation.h.

◆ fTransportEndMomentumDir

G4ThreeVector fTransportEndMomentumDir = G4ThreeVector(0.0, 0.0, 0.0)

private

The particle's state after this Step, Store for DoIt.

Definition at line 214 of file G4LongLivedNeutralTransportation.h.

◆ fTransportEndPosition

G4ThreeVector fTransportEndPosition = G4ThreeVector(0.0, 0.0, 0.0)

private

The particle's state after this Step, Store for DoIt.

Definition at line 213 of file G4LongLivedNeutralTransportation.h.

◆ fTransportEndSpin

G4ThreeVector fTransportEndSpin = G4ThreeVector(0.0, 0.0, 0.0)

private

The particle's state after this Step, Store for DoIt.

Definition at line 216 of file G4LongLivedNeutralTransportation.h.

◆ fUseGravity

G4bool fUseGravity

staticprivate

Flag take into account gravity.

Definition at line 267 of file G4LongLivedNeutralTransportation.h.

◆ fUseMagneticMoment

G4bool fUseMagneticMoment

staticprivate

Flag take into account magnetic moment.

Definition at line 266 of file G4LongLivedNeutralTransportation.h.

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

simulation/longlivedneutral/include/G4LongLivedNeutralTransportation.h
simulation/longlivedneutral/src/G4LongLivedNeutralTransportation.cc

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ G4LongLivedNeutralTransportation()

◆ ~G4LongLivedNeutralTransportation()

Member Function Documentation

◆ AlongStepDoIt()

◆ AlongStepGetPhysicalInteractionLength()

◆ AtRestDoIt()

◆ AtRestGetPhysicalInteractionLength()

◆ DoesGlobalFieldExist()

◆ FieldExertedForce()

◆ GetMaxEnergyKilled()

◆ GetSilenceLooperWarnings()

◆ PostStepDoIt()

◆ PostStepGetPhysicalInteractionLength()

◆ PrintStatistics()

◆ ProcessDescription()

◆ SetHighLooperThresholds()

◆ SetLowLooperThresholds()

◆ SetSilenceLooperWarnings()

◆ SetThresholdImportantEnergy()

◆ SetThresholdTrials()

◆ SetThresholdWarningEnergy()

◆ StartTracking()

Friends And Related Function Documentation

◆ G4CoupledTransportation

Member Data Documentation

◆ fAbandonUnstableTrials

◆ fAnyFieldExists

◆ fCandidateEndGlobalTime

◆ fCurrentTouchableHandle

◆ fEndGlobalTimeComputed

◆ fEndPointDistance

◆ fFieldExertedForce

◆ fFieldPropagator

◆ fFirstStepInVolume

◆ fGeometryLimitedStep

◆ fLastStepInVolume

◆ fLinearNavigator

◆ fMomentumChanged

◆ fNewTrack

◆ fNoLooperTrials

◆ fParticleChange

◆ fPreviousSafety

◆ fPreviousSftOrigin

◆ fpSafetyHelper

◆ fShortStepOptimisation

◆ fSilenceLooperWarnings

◆ fSumEnergyKilled

◆ fThreshold_Important_Energy

◆ fThreshold_Warning_Energy

◆ fThresholdTrials

◆ fTransportEndKineticEnergy

◆ fTransportEndMomentumDir

◆ fTransportEndPosition

◆ fTransportEndSpin

◆ fUseGravity

◆ fUseMagneticMoment