G4PropagatorInField Class Reference

#include <G4PropagatorInField.hh>

Public Member Functions
void	CheckMode (G4bool mode)
void	ClearPropagatorState ()
G4double	ComputeStep (G4FieldTrack &pFieldTrack, G4double pCurrentProposedStepLength, G4double &pNewSafety, G4VPhysicalVolume *pPhysVol=nullptr, G4bool canRelaxDeltaChord=false)
G4ThreeVector	EndMomentumDir () const
G4ThreeVector	EndPosition () const
G4FieldManager *	FindAndSetFieldManager (G4VPhysicalVolume *pCurrentPhysVol)
	G4PropagatorInField (G4Navigator *theNavigator, G4FieldManager *detectorFieldMgr, G4VIntersectionLocator *vLocator=nullptr)
G4ChordFinder *	GetChordFinder ()
G4EquationOfMotion *	GetCurrentEquationOfMotion ()
G4FieldManager *	GetCurrentFieldManager ()
G4double	GetDeltaIntersection () const
G4double	GetDeltaOneStep () const
G4FieldTrack	GetEndState () const
G4double	GetEpsilonStep () const
G4VIntersectionLocator *	GetIntersectionLocator ()
G4int	GetIterationsToIncreaseChordDistance () const
G4double	GetLargestAcceptableStep ()
G4double	GetMaximumEpsilonStep () const
G4int	GetMaxLoopCount () const
G4double	GetMinimumEpsilonStep () const
G4Navigator *	GetNavigatorForPropagating ()
G4int	GetThresholdNoZeroSteps (G4int i)
G4bool	GetUseSafetyForOptimization ()
G4int	GetVerboseLevel () const
G4bool	GetVerboseTrace ()
G4double	GetZeroStepThreshold ()
std::vector< G4ThreeVector > *	GimmeTrajectoryVectorAndForgetIt () const
G4bool	IntersectChord (const G4ThreeVector &StartPointA, const G4ThreeVector &EndPointB, G4double &NewSafety, G4double &LinearStepLength, G4ThreeVector &IntersectionPoint)
G4bool	IsFirstStepInVolume ()
G4bool	IsLastStepInVolume ()
G4bool	IsParticleLooping () const
void	PrepareNewTrack ()
void	printStatus (const G4FieldTrack &startFT, const G4FieldTrack &currentFT, G4double requestStep, G4double safety, G4int step, G4VPhysicalVolume *startVolume)
void	RefreshIntersectionLocator ()
void	SetDetectorFieldManager (G4FieldManager *newGlobalFieldManager)
void	SetEpsilonStep (G4double newEps)
void	SetIntersectionLocator (G4VIntersectionLocator *pLocator)
void	SetIterationsToIncreaseChordDistance (G4int numIters)
void	SetLargestAcceptableStep (G4double newBigDist)
void	SetMaximumEpsilonStep (G4double newEpsMax)
void	SetMaxLoopCount (G4int new_max)
void	SetMinimumEpsilonStep (G4double newEpsMin)
void	SetNavigatorForPropagating (G4Navigator *SimpleOrMultiNavigator)
void	SetThresholdNoZeroStep (G4int noAct, G4int noHarsh, G4int noAbandon)
void	SetTrajectoryFilter (G4VCurvedTrajectoryFilter *filter)
void	SetUseSafetyForOptimization (G4bool)
G4int	SetVerboseLevel (G4int verbose)
void	SetVerboseTrace (G4bool enable)
void	SetZeroStepThreshold (G4double newLength)
G4int	Verbose () const
	~G4PropagatorInField ()

Protected Member Functions
void	PrintStepLengthDiagnostic (G4double currentProposedStepLength, G4double decreaseFactor, G4double stepTrial, const G4FieldTrack &aFieldTrack)
void	ReportLoopingParticle (G4int count, G4double StepTaken, G4double stepRequest, const char *methodName, G4ThreeVector momentumVec, G4VPhysicalVolume *physVol)
void	ReportStuckParticle (G4int noZeroSteps, G4double proposedStep, G4double lastTriedStep, G4VPhysicalVolume *physVol)

Private Attributes
G4FieldTrack	End_PointAndTangent
G4int	fAbandonThreshold_NoZeroSteps = 50
G4int	fActionThreshold_NoZeroSteps = 2
G4bool	fAllocatedLocator
G4bool	fCheck = false
G4FieldManager *	fCurrentFieldMgr
G4FieldManager *	fDetectorFieldMgr
G4double	fEpsilonStep
G4bool	fFirstStepInVolume = true
G4double	fFull_CurveLen_of_LastAttempt = -1
G4int	fIncreaseChordDistanceThreshold = 100
G4VIntersectionLocator *	fIntersectionLocator
G4double	fLargestAcceptableStep
G4double	fLast_ProposedStepLength = -1
G4bool	fLastStepInVolume = true
G4int	fMax_loop_count = 1000
G4Navigator *	fNavigator
G4bool	fNewTrack = true
G4int	fNoZeroStep = 0
G4bool	fParticleIsLooping = false
G4double	fPreviousSafety = 0.0
G4ThreeVector	fPreviousSftOrigin
G4VCurvedTrajectoryFilter *	fpTrajectoryFilter = nullptr
G4bool	fSetFieldMgr = false
G4int	fSevereActionThreshold_NoZeroSteps = 10
G4bool	fUseSafetyForOptimisation = true
G4int	fVerboseLevel = 0
G4bool	fVerbTracePiF = false
G4double	fZeroStepThreshold = 0.0
G4double	kCarTolerance

Detailed Description

Definition at line 57 of file G4PropagatorInField.hh.

Constructor & Destructor Documentation

G4PropagatorInField()

G4PropagatorInField::G4PropagatorInField	(	G4Navigator *	theNavigator,
		G4FieldManager *	detectorFieldMgr,
		G4VIntersectionLocator *	vLocator = nullptr
	)

Definition at line 55 of file G4PropagatorInField.cc.

  : fDetectorFieldMgr(detectorFieldMgr), 
    fNavigator(theNavigator),
    fCurrentFieldMgr(detectorFieldMgr),
    End_PointAndTangent(G4ThreeVector(0.,0.,0.),
                        G4ThreeVector(0.,0.,0.),0.0,0.0,0.0,0.0,0.0)
{
  fEpsilonStep = (fDetectorFieldMgr != nullptr)
               ? fDetectorFieldMgr->GetMaximumEpsilonStep() : 1.0e-5;
  fLargestAcceptableStep = 1000.0 * meter;
 
  fPreviousSftOrigin = G4ThreeVector(0.,0.,0.);
  kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
  fZeroStepThreshold = std::max( 1.0e5 * kCarTolerance, 1.0e-1 * micrometer );
 
#ifdef G4DEBUG_FIELD
  G4cout << " PiF: Zero Step Threshold set to "
         << fZeroStepThreshold / millimeter
         << " mm." << G4endl;
  G4cout << " PiF:   Value of kCarTolerance = "
         << kCarTolerance / millimeter 
         << " mm. " << G4endl;
  fVerboseLevel = 2;
  fVerbTracePiF = true;   
#endif 
 
  // Defining Intersection Locator and his parameters
  if ( vLocator == nullptr )
  {
    fIntersectionLocator = new G4MultiLevelLocator(theNavigator);
    fAllocatedLocator = true;
  }
  else
  {
    fIntersectionLocator = vLocator;
    fAllocatedLocator = false;
  }
  RefreshIntersectionLocator();  //  Copy all relevant parameters
}

References fAllocatedLocator, fDetectorFieldMgr, fEpsilonStep, fIntersectionLocator, fLargestAcceptableStep, fPreviousSftOrigin, fVerboseLevel, fVerbTracePiF, fZeroStepThreshold, G4cout, G4endl, G4GeometryTolerance::GetInstance(), G4FieldManager::GetMaximumEpsilonStep(), G4GeometryTolerance::GetSurfaceTolerance(), kCarTolerance, G4INCL::Math::max(), meter, micrometer, millimeter, and RefreshIntersectionLocator().

~G4PropagatorInField()

G4PropagatorInField::~G4PropagatorInField

(

)

Definition at line 99 of file G4PropagatorInField.cc.

{
  if(fAllocatedLocator)  { delete  fIntersectionLocator; }
}

References fAllocatedLocator, and fIntersectionLocator.

Member Function Documentation

CheckMode()

void G4PropagatorInField::CheckMode ( G4bool  mode )

inline

Referenced by G4GeometryMessenger::SetCheckMode().

ClearPropagatorState()

void G4PropagatorInField::ClearPropagatorState

(

)

Definition at line 674 of file G4PropagatorInField.cc.

{
  // Goal: Clear all memory of previous steps,  cached information
 
  fParticleIsLooping = false;
  fNoZeroStep = 0;
 
  fSetFieldMgr = false;  // Has field-manager been set for the current step?
  fEpsilonStep= 1.0e-5;  // Relative accuracy of current Step
  
  End_PointAndTangent= G4FieldTrack( G4ThreeVector(0.,0.,0.),
                                     G4ThreeVector(0.,0.,0.),
                                     0.0,0.0,0.0,0.0,0.0); 
  fFull_CurveLen_of_LastAttempt = -1; 
  fLast_ProposedStepLength = -1;
 
  fPreviousSftOrigin= G4ThreeVector(0.,0.,0.);
  fPreviousSafety= 0.0;
 
  fNewTrack = true;
}

References End_PointAndTangent, fEpsilonStep, fFull_CurveLen_of_LastAttempt, fLast_ProposedStepLength, fNewTrack, fNoZeroStep, fParticleIsLooping, fPreviousSafety, fPreviousSftOrigin, and fSetFieldMgr.

Referenced by G4ITTransportation::StartTracking(), G4CoupledTransportation::StartTracking(), and G4Transportation::StartTracking().

ComputeStep()

G4double G4PropagatorInField::ComputeStep	(	G4FieldTrack &	pFieldTrack,
		G4double	pCurrentProposedStepLength,
		G4double &	pNewSafety,
		G4VPhysicalVolume *	pPhysVol = nullptr,
		G4bool	canRelaxDeltaChord = false
	)

Definition at line 118 of file G4PropagatorInField.cc.

{  
  GetChordFinder()->OnComputeStep();
  const G4double deltaChord = GetChordFinder()->GetDeltaChord();
 
  // If CurrentProposedStepLength is too small for finding Chords
  // then return with no action (for now - TODO: some action)
  //
  const char* methodName = "G4PropagatorInField::ComputeStep";
  if (CurrentProposedStepLength<kCarTolerance)
  {
    return kInfinity;
  }
 
  // Introducing smooth trajectory display (jacek 01/11/2002)
  //
  if (fpTrajectoryFilter)
  {
    fpTrajectoryFilter->CreateNewTrajectorySegment();
  }
 
  fFirstStepInVolume = fNewTrack ? true : fLastStepInVolume;
  fLastStepInVolume = false;
  fNewTrack = false; 
 
  if( fVerboseLevel > 2 )
  {
    G4cout << methodName << " called" << G4endl;
    G4cout << "   Starting FT: " << pFieldTrack;
    G4cout << "   Requested length = " << CurrentProposedStepLength << G4endl;
    G4cout << "   PhysVol = ";
    if( pPhysVol )
       G4cout << pPhysVol->GetName() << G4endl;
    else
       G4cout << " N/A ";
    G4cout << G4endl;
  }
  
  // Parameters for adaptive Runge-Kutta integration
  
  G4double h_TrialStepSize;        // 1st Step Size 
  G4double TruePathLength = CurrentProposedStepLength;
  G4double StepTaken = 0.0; 
  G4double s_length_taken, epsilon; 
  G4bool   intersects;
  G4bool   first_substep = true;
 
  G4double NewSafety;
  fParticleIsLooping = false;
 
  // If not yet done, 
  //   Set the field manager to the local  one if the volume has one, 
  //                      or to the global one if not
  //
  if( !fSetFieldMgr )
  {
    fCurrentFieldMgr = FindAndSetFieldManager( pPhysVol );
  }
  fSetFieldMgr = false; // For next call, the field manager must be set again
 
  G4FieldTrack CurrentState(pFieldTrack);
  G4FieldTrack OriginalState = CurrentState;
 
  // If the Step length is "infinite", then an approximate-maximum Step
  // length (used to calculate the relative accuracy) must be guessed
  //
  if( CurrentProposedStepLength >= fLargestAcceptableStep )
  {
    G4ThreeVector StartPointA, VelocityUnit;
    StartPointA  = pFieldTrack.GetPosition();
    VelocityUnit = pFieldTrack.GetMomentumDir();
 
    G4double trialProposedStep = 1.e2 * ( 10.0 * cm + 
      fNavigator->GetWorldVolume()->GetLogicalVolume()->
                  GetSolid()->DistanceToOut(StartPointA, VelocityUnit) );
    CurrentProposedStepLength = std::min( trialProposedStep,
                                          fLargestAcceptableStep ); 
  }
  epsilon = fCurrentFieldMgr->GetDeltaOneStep() / CurrentProposedStepLength;
  G4double epsilonMin= fCurrentFieldMgr->GetMinimumEpsilonStep();
  G4double epsilonMax= fCurrentFieldMgr->GetMaximumEpsilonStep();
  if( epsilon < epsilonMin )  { epsilon = epsilonMin; }
  if( epsilon > epsilonMax )  { epsilon = epsilonMax; }
  SetEpsilonStep( epsilon );
 
  // Values for Intersection Locator has to be updated on each call for the
  // case that CurrentFieldManager has changed from the one of previous step
  //
  RefreshIntersectionLocator();
 
  // Shorten the proposed step in case of earlier problems (zero steps)
  // 
  if( fNoZeroStep > fActionThreshold_NoZeroSteps )
  {
    G4double stepTrial;
 
    stepTrial = fFull_CurveLen_of_LastAttempt; 
    if( (stepTrial <= 0.0) && (fLast_ProposedStepLength > 0.0) )
    {
      stepTrial = fLast_ProposedStepLength; 
    }
 
    G4double decreaseFactor = 0.9; // Unused default
    if(   (fNoZeroStep < fSevereActionThreshold_NoZeroSteps)
       && (stepTrial > 100.0*fZeroStepThreshold) )
    {
      // Attempt quick convergence
      //
      decreaseFactor= 0.25;
    } 
    else
    {
      // We are in significant difficulties, probably at a boundary that
      // is either geometrically sharp or between very different materials.
      // Careful decreases to cope with tolerance are required
      //
      if( stepTrial > 100.0*fZeroStepThreshold )
        decreaseFactor = 0.35;     // Try decreasing slower
      else if( stepTrial > 30.0*fZeroStepThreshold )
        decreaseFactor= 0.5;       // Try yet slower decrease
      else if( stepTrial > 10.0*fZeroStepThreshold )
        decreaseFactor= 0.75;      // Try even slower decreases
      else
        decreaseFactor= 0.9;       // Try very slow decreases
     }
     stepTrial *= decreaseFactor;
 
#ifdef G4DEBUG_FIELD
     if( fVerboseLevel > 2
      || (fNoZeroStep >= fSevereActionThreshold_NoZeroSteps) )
     {
        G4cerr << " " << methodName
               << "  Decreasing step after " << fNoZeroStep << " zero steps "
               << " - in volume " << pPhysVol;
        if( pPhysVol )
           G4cerr << " with name " << pPhysVol->GetName();
        else
           G4cerr << " i.e. *unknown* volume.";
        G4cerr << G4endl;
        PrintStepLengthDiagnostic(CurrentProposedStepLength, decreaseFactor,
                                  stepTrial, pFieldTrack);
     }
#endif
     if( stepTrial == 0.0 )  //  Change to make it < 0.1 * kCarTolerance ??
     {
       std::ostringstream message;
       message << "Particle abandoned due to lack of progress in field."
               << G4endl
               << "  Properties : " << pFieldTrack << G4endl
               << "  Attempting a zero step = " << stepTrial << G4endl
               << "  while attempting to progress after " << fNoZeroStep
               << " trial steps. Will abandon step.";
       G4Exception(methodName, "GeomNav1002", JustWarning, message);
       fParticleIsLooping = true;
       return 0;  // = stepTrial;
     }
     if( stepTrial < CurrentProposedStepLength )
     {
       CurrentProposedStepLength = stepTrial;
     }
  }
  fLast_ProposedStepLength = CurrentProposedStepLength;
 
  G4int do_loop_count = 0; 
  do  // Loop checking, 07.10.2016, JA
  { 
    G4FieldTrack SubStepStartState = CurrentState;
    G4ThreeVector SubStartPoint = CurrentState.GetPosition(); 
    
    if(!first_substep)
    {
      if( fVerboseLevel > 4 )
      {
        G4cout << " PiF: Calling Nav/Locate Global Point within-Volume "
               << G4endl;
      }
      fNavigator->LocateGlobalPointWithinVolume( SubStartPoint );
    }
 
    // How far to attempt to move the particle !
    //
    h_TrialStepSize = CurrentProposedStepLength - StepTaken;
 
    if (canRelaxDeltaChord &&
        fIncreaseChordDistanceThreshold > 0  &&
        do_loop_count > fIncreaseChordDistanceThreshold && 
        do_loop_count % fIncreaseChordDistanceThreshold == 0)
    {
        GetChordFinder()->SetDeltaChord(
          GetChordFinder()->GetDeltaChord() * 2.0
        );
    }
 
    // Integrate as far as "chord miss" rule allows.
    //
    s_length_taken = GetChordFinder()->AdvanceChordLimited( 
                             CurrentState,    // Position & velocity
                             h_TrialStepSize,
                             fEpsilonStep,
                             fPreviousSftOrigin,
                             fPreviousSafety );
      // CurrentState is now updated with the final position and velocity
 
    fFull_CurveLen_of_LastAttempt = s_length_taken;
 
    G4ThreeVector EndPointB = CurrentState.GetPosition(); 
    G4ThreeVector InterSectionPointE;
    G4double      LinearStepLength;
 
    // Intersect chord AB with geometry
    //
    intersects= IntersectChord( SubStartPoint, EndPointB, 
                                NewSafety, LinearStepLength, 
                                InterSectionPointE );
      // E <- Intersection Point of chord AB and either volume A's surface 
      //                                  or a daughter volume's surface ..
 
    if( first_substep )
    { 
       currentSafety = NewSafety;
    } // Updating safety in other steps is potential future extention
 
    if( intersects )
    {
       G4FieldTrack IntersectPointVelct_G(CurrentState);  // FT-Def-Construct
 
       // Find the intersection point of AB true path with the surface
       //   of vol(A), if it exists. Start with point E as first "estimate".
       G4bool recalculatedEndPt = false;
       
       G4bool found_intersection = fIntersectionLocator->
         EstimateIntersectionPoint( SubStepStartState, CurrentState, 
                                    InterSectionPointE, IntersectPointVelct_G,
                                    recalculatedEndPt, fPreviousSafety,
                                    fPreviousSftOrigin);
       intersects = found_intersection;
       if( found_intersection )
       {        
          End_PointAndTangent= IntersectPointVelct_G;  // G is our EndPoint ...
          StepTaken = TruePathLength = IntersectPointVelct_G.GetCurveLength()
                                     - OriginalState.GetCurveLength();
       }
       else
       {
          // Either "minor" chords do not intersect
          // or else stopped (due to too many steps)
          //
          if( recalculatedEndPt )
          {
             G4double endAchieved = IntersectPointVelct_G.GetCurveLength();
             G4double endExpected = CurrentState.GetCurveLength(); 
 
             // Detect failure - due to too many steps
             G4bool shortEnd = endAchieved
                             < (endExpected*(1.0-CLHEP::perMillion));
 
             G4double stepAchieved = endAchieved
                                   - SubStepStartState.GetCurveLength();
 
             // Update remaining state - must work for 'full' step or
             // abandonned intersection
             //
             CurrentState = IntersectPointVelct_G;
             s_length_taken = stepAchieved;
             if( shortEnd )
             {
                fParticleIsLooping = true;
             } 
          }
       }
    }
    if( !intersects )
    {
      StepTaken += s_length_taken;
 
      if (fpTrajectoryFilter) // For smooth trajectory display (jacek 1/11/2002)
      {
        fpTrajectoryFilter->TakeIntermediatePoint(CurrentState.GetPosition());
      }
    }
    first_substep = false;
 
#ifdef G4DEBUG_FIELD
    if( fNoZeroStep > fActionThreshold_NoZeroSteps )
    {
      if( fNoZeroStep > fSevereActionThreshold_NoZeroSteps )
        G4cout << " Above 'Severe Action' threshold -- for Zero steps.  ";
      else
        G4cout << " Above 'action' threshold -- for Zero steps.  ";         
      G4cout << " Number of zero steps = " << fNoZeroStep << G4endl;
      printStatus( SubStepStartState,  // or OriginalState,
                   CurrentState, CurrentProposedStepLength, 
                   NewSafety, do_loop_count, pPhysVol );
    }
    if( (fVerboseLevel > 1) && (do_loop_count > fMax_loop_count-10 ))
    {
      if( do_loop_count == fMax_loop_count-9 )
      {
        G4cout << " G4PropagatorInField::ComputeStep(): " << G4endl
               << "  Difficult track - taking many sub steps." << G4endl;
        printStatus( SubStepStartState, SubStepStartState, CurrentProposedStepLength, 
                     NewSafety, 0, pPhysVol );        
      }
      printStatus( SubStepStartState, CurrentState, CurrentProposedStepLength, 
                   NewSafety, do_loop_count, pPhysVol );
    }
#endif
 
    ++do_loop_count;
 
  } while( (!intersects )
        && (!fParticleIsLooping)
        && (StepTaken + kCarTolerance < CurrentProposedStepLength)  
        && ( do_loop_count < fMax_loop_count ) );
 
  if(  do_loop_count >= fMax_loop_count
    && (StepTaken + kCarTolerance < CurrentProposedStepLength) )
  {
    fParticleIsLooping = true;
  }
  if ( ( fParticleIsLooping ) && (fVerboseLevel > 0) )
  {
    ReportLoopingParticle( do_loop_count, StepTaken,
                           CurrentProposedStepLength, methodName,
                           CurrentState.GetMomentum(), pPhysVol );
  }
    
  if( !intersects )
  {
    // Chord AB or "minor chords" do not intersect
    // B is the endpoint Step of the current Step.
    //
    End_PointAndTangent = CurrentState; 
    TruePathLength = StepTaken;   //  Original code
 
    // Tried the following to avoid potential issue with round-off error
    // - but has issues... Suppressing this change JA 2015/05/02
    // TruePathLength = CurrentProposedStepLength;
  }
  fLastStepInVolume = intersects;
  
  // Set pFieldTrack to the return value
  //
  pFieldTrack = End_PointAndTangent;
 
#ifdef G4VERBOSE
  // Check that "s" is correct
  //
  if( std::fabs(OriginalState.GetCurveLength() + TruePathLength 
      - End_PointAndTangent.GetCurveLength()) > 3.e-4 * TruePathLength )
  {
    std::ostringstream message;
    message << "Curve length mis-match between original state "
            << "and proposed endpoint of propagation." << G4endl
            << "  The curve length of the endpoint should be: " 
            << OriginalState.GetCurveLength() + TruePathLength << G4endl
            << "  and it is instead: "
            << End_PointAndTangent.GetCurveLength() << "." << G4endl
            << "  A difference of: "
            << OriginalState.GetCurveLength() + TruePathLength 
               - End_PointAndTangent.GetCurveLength() << G4endl
            << "  Original state = " << OriginalState   << G4endl
            << "  Proposed state = " << End_PointAndTangent;
    G4Exception(methodName, "GeomNav0003", FatalException, message);
  }
#endif
 
  if( TruePathLength+kCarTolerance >= CurrentProposedStepLength )
  {
     fNoZeroStep = 0;     
  }
  else
  {     
     // In particular anomalous cases, we can get repeated zero steps
     // We identify these cases and take corrective action when they occur.
     // 
     if( TruePathLength < std::max( fZeroStepThreshold, 0.5*kCarTolerance ) )
     {
        ++fNoZeroStep;
     }
     else
     {
        fNoZeroStep = 0;
     }
  }
  if( fNoZeroStep > fAbandonThreshold_NoZeroSteps )
  { 
     fParticleIsLooping = true;
     ReportStuckParticle( fNoZeroStep, CurrentProposedStepLength,
                          fFull_CurveLen_of_LastAttempt, pPhysVol );
     fNoZeroStep = 0; 
  }
 
  GetChordFinder()->SetDeltaChord(deltaChord);
  return TruePathLength;
}

References G4ChordFinder::AdvanceChordLimited(), cm, G4VCurvedTrajectoryFilter::CreateNewTrajectorySegment(), End_PointAndTangent, epsilon(), fAbandonThreshold_NoZeroSteps, fActionThreshold_NoZeroSteps, FatalException, fCurrentFieldMgr, fEpsilonStep, fFirstStepInVolume, fFull_CurveLen_of_LastAttempt, fIncreaseChordDistanceThreshold, FindAndSetFieldManager(), fIntersectionLocator, fLargestAcceptableStep, fLast_ProposedStepLength, fLastStepInVolume, fMax_loop_count, fNavigator, fNewTrack, fNoZeroStep, fParticleIsLooping, fPreviousSafety, fPreviousSftOrigin, fpTrajectoryFilter, fSetFieldMgr, fSevereActionThreshold_NoZeroSteps, fVerboseLevel, fZeroStepThreshold, G4cerr, G4cout, G4endl, G4Exception(), GetChordFinder(), G4FieldTrack::GetCurveLength(), G4ChordFinder::GetDeltaChord(), G4FieldManager::GetDeltaOneStep(), G4VPhysicalVolume::GetLogicalVolume(), G4FieldManager::GetMaximumEpsilonStep(), G4FieldManager::GetMinimumEpsilonStep(), G4FieldTrack::GetMomentum(), G4FieldTrack::GetMomentumDir(), G4VPhysicalVolume::GetName(), G4FieldTrack::GetPosition(), G4Navigator::GetWorldVolume(), IntersectChord(), JustWarning, kCarTolerance, kInfinity, G4Navigator::LocateGlobalPointWithinVolume(), G4INCL::Math::max(), G4INCL::Math::min(), G4ChordFinder::OnComputeStep(), CLHEP::perMillion, printStatus(), PrintStepLengthDiagnostic(), RefreshIntersectionLocator(), ReportLoopingParticle(), ReportStuckParticle(), G4ChordFinder::SetDeltaChord(), SetEpsilonStep(), and G4VCurvedTrajectoryFilter::TakeIntermediatePoint().

Referenced by G4Transportation::AlongStepGetPhysicalInteractionLength(), and G4PathFinder::DoNextCurvedStep().

EndMomentumDir()

G4ThreeVector G4PropagatorInField::EndMomentumDir ( ) const

inline

EndPosition()

G4ThreeVector G4PropagatorInField::EndPosition ( ) const

inline

FindAndSetFieldManager()

G4FieldManager * G4PropagatorInField::FindAndSetFieldManager

(

G4VPhysicalVolume *

pCurrentPhysVol

)

Definition at line 698 of file G4PropagatorInField.cc.

{
  G4FieldManager* currentFieldMgr;
 
  currentFieldMgr = fDetectorFieldMgr;
  if( pCurrentPhysicalVolume != nullptr )
  {
     G4FieldManager *pRegionFieldMgr = nullptr, *localFieldMgr = nullptr;
     G4LogicalVolume* pLogicalVol = pCurrentPhysicalVolume->GetLogicalVolume();
 
     if( pLogicalVol != nullptr )
     { 
        // Value for Region, if any, overrides
        //
        G4Region*  pRegion = pLogicalVol->GetRegion();
        if( pRegion != nullptr )
        { 
           pRegionFieldMgr = pRegion->GetFieldManager();
           if( pRegionFieldMgr != nullptr )
           {
              currentFieldMgr= pRegionFieldMgr;
           }
        }
 
        // 'Local' Value from logical volume, if any, overrides
        //
        localFieldMgr = pLogicalVol->GetFieldManager();
        if ( localFieldMgr != nullptr )
        {
           currentFieldMgr = localFieldMgr;
        }
     }
  }
  fCurrentFieldMgr = currentFieldMgr;
 
  // Flag that field manager has been set
  //
  fSetFieldMgr = true;
 
  return currentFieldMgr;
}

References fCurrentFieldMgr, fDetectorFieldMgr, fSetFieldMgr, G4LogicalVolume::GetFieldManager(), G4Region::GetFieldManager(), G4VPhysicalVolume::GetLogicalVolume(), and G4LogicalVolume::GetRegion().

Referenced by G4CoupledTransportation::AlongStepGetPhysicalInteractionLength(), G4Transportation::AlongStepGetPhysicalInteractionLength(), G4ITTransportation::AlongStepGetPhysicalInteractionLength(), G4PathFinder::ComputeStep(), ComputeStep(), G4SynchrotronRadiation::GetMeanFreePath(), G4SynchrotronRadiationInMat::GetMeanFreePath(), G4SynchrotronRadiationInMat::GetPhotonEnergy(), G4SynchrotronRadiation::PostStepDoIt(), and G4SynchrotronRadiationInMat::PostStepDoIt().

GetChordFinder()

G4ChordFinder * G4PropagatorInField::GetChordFinder ( )

inline

Referenced by ComputeStep(), RefreshIntersectionLocator(), SetVerboseLevel(), and G4CoupledTransportation::StartTracking().

GetCurrentEquationOfMotion()

G4EquationOfMotion * G4PropagatorInField::GetCurrentEquationOfMotion ( )

inline

Referenced by G4CoupledTransportation::AlongStepGetPhysicalInteractionLength(), G4Transportation::AlongStepGetPhysicalInteractionLength(), and G4PathFinder::DoNextCurvedStep().

GetCurrentFieldManager()

G4FieldManager * G4PropagatorInField::GetCurrentFieldManager ( )

inline

Referenced by G4CoupledTransportation::AlongStepGetPhysicalInteractionLength(), G4Transportation::AlongStepGetPhysicalInteractionLength(), and G4DecayWithSpin::AtRestDoIt().

GetDeltaIntersection()

G4double G4PropagatorInField::GetDeltaIntersection ( ) const

inline

GetDeltaOneStep()

G4double G4PropagatorInField::GetDeltaOneStep ( ) const

inline

GetEndState()

G4FieldTrack G4PropagatorInField::GetEndState ( ) const

inline

GetEpsilonStep()

G4double G4PropagatorInField::GetEpsilonStep ( ) const

inline

GetIntersectionLocator()

G4VIntersectionLocator * G4PropagatorInField::GetIntersectionLocator ( )

inline

Referenced by G4ErrorPropagatorManager::StartNavigator().

GetIterationsToIncreaseChordDistance()

G4int G4PropagatorInField::GetIterationsToIncreaseChordDistance ( ) const

inline

GetLargestAcceptableStep()

G4double G4PropagatorInField::GetLargestAcceptableStep ( )

inline

GetMaximumEpsilonStep()

G4double G4PropagatorInField::GetMaximumEpsilonStep ( ) const

inline

GetMaxLoopCount()

G4int G4PropagatorInField::GetMaxLoopCount ( ) const

inline

GetMinimumEpsilonStep()

G4double G4PropagatorInField::GetMinimumEpsilonStep ( ) const

inline

GetNavigatorForPropagating()

G4Navigator * G4PropagatorInField::GetNavigatorForPropagating ( )

inline

GetThresholdNoZeroSteps()

G4int G4PropagatorInField::GetThresholdNoZeroSteps ( G4int  i )

inline

GetUseSafetyForOptimization()

G4bool G4PropagatorInField::GetUseSafetyForOptimization ( )

inline

GetVerboseLevel()

G4int G4PropagatorInField::GetVerboseLevel ( ) const

inline

GetVerboseTrace()

G4bool G4PropagatorInField::GetVerboseTrace ( )

inline

GetZeroStepThreshold()

G4double G4PropagatorInField::GetZeroStepThreshold ( )

inline

GimmeTrajectoryVectorAndForgetIt()

std::vector< G4ThreeVector > * G4PropagatorInField::GimmeTrajectoryVectorAndForgetIt

(

)

const

Definition at line 649 of file G4PropagatorInField.cc.

{
  // NB, GimmeThePointsAndForgetThem really forgets them, so it can
  // only be called (exactly) once for each step.
 
  if (fpTrajectoryFilter != nullptr)
  {
    return fpTrajectoryFilter->GimmeThePointsAndForgetThem();
  }
  else
  {
    return nullptr;
  }
}

References fpTrajectoryFilter, and G4VCurvedTrajectoryFilter::GimmeThePointsAndForgetThem().

Referenced by G4ITTransportation::AlongStepDoIt(), G4CoupledTransportation::AlongStepDoIt(), and G4Transportation::AlongStepDoIt().

IntersectChord()

G4bool G4PropagatorInField::IntersectChord ( const G4ThreeVector &  StartPointA, const G4ThreeVector &  EndPointB, G4double &  NewSafety, G4double &  LinearStepLength, G4ThreeVector &  IntersectionPoint  )

inline

Referenced by ComputeStep().

IsFirstStepInVolume()

G4bool G4PropagatorInField::IsFirstStepInVolume ( )

inline

IsLastStepInVolume()

G4bool G4PropagatorInField::IsLastStepInVolume ( )

inline

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

IsParticleLooping()

G4bool G4PropagatorInField::IsParticleLooping ( ) const

inline

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

PrepareNewTrack()

void G4PropagatorInField::PrepareNewTrack ( )

inline

Referenced by G4PathFinder::PrepareNewTrack(), and G4Transportation::StartTracking().

printStatus()

void G4PropagatorInField::printStatus	(	const G4FieldTrack &	startFT,
		const G4FieldTrack &	currentFT,
		G4double	requestStep,
		G4double	safety,
		G4int	step,
		G4VPhysicalVolume *	startVolume
	)

Definition at line 524 of file G4PropagatorInField.cc.

{
  const G4int verboseLevel = fVerboseLevel;
  const G4ThreeVector StartPosition       = StartFT.GetPosition();
  const G4ThreeVector StartUnitVelocity   = StartFT.GetMomentumDir();
  const G4ThreeVector CurrentPosition     = CurrentFT.GetPosition();
  const G4ThreeVector CurrentUnitVelocity = CurrentFT.GetMomentumDir();
 
  G4double step_len = CurrentFT.GetCurveLength() - StartFT.GetCurveLength();
 
  G4int oldprec;   // cout/cerr precision settings
      
  if( ((stepNo == 0) && (verboseLevel <3)) || (verboseLevel >= 3) )
  {
    oldprec = G4cout.precision(4);
    G4cout << std::setw( 5) << "Step#" 
           << std::setw(10) << "  s  " << " "
           << std::setw(10) << "X(mm)" << " "
           << std::setw(10) << "Y(mm)" << " "  
           << std::setw(10) << "Z(mm)" << " "
           << std::setw( 7) << " N_x " << " "
           << std::setw( 7) << " N_y " << " "
           << std::setw( 7) << " N_z " << " " ;
    G4cout << std::setw( 7) << " Delta|N|" << " "
           << std::setw( 9) << "StepLen" << " "  
           << std::setw(12) << "StartSafety" << " "  
           << std::setw( 9) << "PhsStep" << " ";  
    if( startVolume != nullptr )
      { G4cout << std::setw(18) << "NextVolume" << " "; }
    G4cout.precision(oldprec);
    G4cout << G4endl;
  }
  if((stepNo == 0) && (verboseLevel <=3))
  {
    // Recurse to print the start values
    //
    printStatus( StartFT, StartFT, -1.0, safety, -1, startVolume);
  }
  if( verboseLevel <= 3 )
  {
    if( stepNo >= 0)
      { G4cout << std::setw( 4) << stepNo << " "; }
    else
      { G4cout << std::setw( 5) << "Start" ; }
    oldprec = G4cout.precision(8);
    G4cout << std::setw(10) << CurrentFT.GetCurveLength() << " "; 
    G4cout.precision(8);
    G4cout << std::setw(10) << CurrentPosition.x() << " "
           << std::setw(10) << CurrentPosition.y() << " "
           << std::setw(10) << CurrentPosition.z() << " ";
    G4cout.precision(4);
    G4cout << std::setw( 7) << CurrentUnitVelocity.x() << " "
           << std::setw( 7) << CurrentUnitVelocity.y() << " "
           << std::setw( 7) << CurrentUnitVelocity.z() << " ";
    G4cout.precision(3); 
    G4cout << std::setw( 7)
           << CurrentFT.GetMomentum().mag()-StartFT.GetMomentum().mag() << " "; 
    G4cout << std::setw( 9) << step_len << " "; 
    G4cout << std::setw(12) << safety << " ";
    if( requestStep != -1.0 ) 
      { G4cout << std::setw( 9) << requestStep << " "; }
    else
      { G4cout << std::setw( 9) << "Init/NotKnown" << " "; }
    if( startVolume != 0)
      { G4cout << std::setw(12) << startVolume->GetName() << " "; }
    G4cout.precision(oldprec);
    G4cout << G4endl;
  }
  else // if( verboseLevel > 3 )
  {
    //  Multi-line output
      
    G4cout << "Step taken was " << step_len  
           << " out of PhysicalStep = " <<  requestStep << G4endl;
    G4cout << "Final safety is: " << safety << G4endl;
    G4cout << "Chord length = " << (CurrentPosition-StartPosition).mag()
           << G4endl;
    G4cout << G4endl; 
  }
}

References fVerboseLevel, G4cout, G4endl, G4FieldTrack::GetCurveLength(), G4FieldTrack::GetMomentum(), G4FieldTrack::GetMomentumDir(), G4VPhysicalVolume::GetName(), G4FieldTrack::GetPosition(), CLHEP::Hep3Vector::mag(), printStatus(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by ComputeStep(), and printStatus().

PrintStepLengthDiagnostic()

void G4PropagatorInField::PrintStepLengthDiagnostic ( G4double  currentProposedStepLength, G4double  decreaseFactor, G4double  stepTrial, const G4FieldTrack &  aFieldTrack  )

protected

Definition at line 614 of file G4PropagatorInField.cc.

{
  G4int  iprec= G4cout.precision(8); 
  G4cout << " " << std::setw(12) << " PiF: NoZeroStep " 
         << " " << std::setw(20) << " CurrentProposed len " 
         << " " << std::setw(18) << " Full_curvelen_last" 
         << " " << std::setw(18) << " last proposed len " 
         << " " << std::setw(18) << " decrease factor   " 
         << " " << std::setw(15) << " step trial  " 
         << G4endl;
 
  G4cout << " " << std::setw(10) << fNoZeroStep << "  "
         << " " << std::setw(20) << CurrentProposedStepLength
         << " " << std::setw(18) << fFull_CurveLen_of_LastAttempt
         << " " << std::setw(18) << fLast_ProposedStepLength 
         << " " << std::setw(18) << decreaseFactor
         << " " << std::setw(15) << stepTrial
         << G4endl;
  G4cout.precision( iprec );
}

References fFull_CurveLen_of_LastAttempt, fLast_ProposedStepLength, fNoZeroStep, G4cout, and G4endl.

Referenced by ComputeStep().

RefreshIntersectionLocator()

void G4PropagatorInField::RefreshIntersectionLocator

(

)

Definition at line 107 of file G4PropagatorInField.cc.

{
  fIntersectionLocator->SetEpsilonStepFor(fEpsilonStep);
  fIntersectionLocator->SetDeltaIntersectionFor(fCurrentFieldMgr->GetDeltaIntersection());
  fIntersectionLocator->SetChordFinderFor(GetChordFinder());
  fIntersectionLocator->SetSafetyParametersFor( fUseSafetyForOptimisation);
}

References fCurrentFieldMgr, fEpsilonStep, fIntersectionLocator, fUseSafetyForOptimisation, GetChordFinder(), G4FieldManager::GetDeltaIntersection(), G4VIntersectionLocator::SetChordFinderFor(), G4VIntersectionLocator::SetDeltaIntersectionFor(), G4VIntersectionLocator::SetEpsilonStepFor(), and G4VIntersectionLocator::SetSafetyParametersFor().

Referenced by ComputeStep(), and G4PropagatorInField().

ReportLoopingParticle()

void G4PropagatorInField::ReportLoopingParticle ( G4int  count, G4double  StepTaken, G4double  stepRequest, const char *  methodName, G4ThreeVector  momentumVec, G4VPhysicalVolume *  physVol  )

protected

Definition at line 760 of file G4PropagatorInField.cc.

{
   std::ostringstream message;
   G4double fraction = StepTaken / StepRequested;
   message << " Unfinished integration of track (likely looping particle)  "
           << " of momentum " << momentumVec << " ( magnitude = "
           << momentumVec.mag() << " ) " << G4endl
           << " after " << count << " field substeps "
           << " totaling " << std::setprecision(12) << StepTaken / mm << " mm "
           << " out of requested step " << std::setprecision(12)
           << StepRequested / mm << " mm ";
   message << " a fraction of ";
   G4int prec = 4;
   if( fraction > 0.99 )
   {
     prec = 7;
   }
   else
   {
     if (fraction > 0.97 )  { prec = 5; }
   }
   message << std::setprecision(prec) 
           << 100. * StepTaken / StepRequested << " % " << G4endl ;
   if( pPhysVol )
   {
      message << " in volume " << pPhysVol->GetName() ;
      auto material = pPhysVol->GetLogicalVolume()->GetMaterial();
      if( material != nullptr )
         message << " with material " << material->GetName()
                 << " ( density = "
                 << material->GetDensity() / ( g/(cm*cm*cm) ) << " g / cm^3 ) ";
   }
   else
   {
      message << " in unknown (null) volume. " ;
   }
   G4Exception(methodName, "GeomNav1002", JustWarning, message);   
}

References cm, g, G4endl, G4Exception(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetMaterial(), G4VPhysicalVolume::GetName(), JustWarning, CLHEP::Hep3Vector::mag(), eplot::material, mm, and CLHEP::prec.

Referenced by ComputeStep().

ReportStuckParticle()

void G4PropagatorInField::ReportStuckParticle ( G4int  noZeroSteps, G4double  proposedStep, G4double  lastTriedStep, G4VPhysicalVolume *  physVol  )

protected

Definition at line 806 of file G4PropagatorInField.cc.

{
   std::ostringstream message;
   message << "Particle is stuck; it will be killed." << G4endl
           << "  Zero progress for " << noZeroSteps << " attempted steps." 
           << G4endl
           << "  Proposed Step is " << proposedStep
           << " but Step Taken is "<< lastTriedStep << G4endl;
   if( physVol != nullptr )
      message << " in volume " << physVol->GetName() ; 
   else
      message << " in unknown or null volume. " ; 
   G4Exception("G4PropagatorInField::ComputeStep()",
               "GeomNav1002", JustWarning, message);
}

References G4endl, G4Exception(), G4VPhysicalVolume::GetName(), and JustWarning.

Referenced by ComputeStep().

SetDetectorFieldManager()

void G4PropagatorInField::SetDetectorFieldManager ( G4FieldManager *  newGlobalFieldManager )

inline

SetEpsilonStep()

void G4PropagatorInField::SetEpsilonStep ( G4double  newEps )

inline

Referenced by ComputeStep().

SetIntersectionLocator()

void G4PropagatorInField::SetIntersectionLocator ( G4VIntersectionLocator *  pLocator )

inline

SetIterationsToIncreaseChordDistance()

void G4PropagatorInField::SetIterationsToIncreaseChordDistance ( G4int  numIters )

inline

SetLargestAcceptableStep()

void G4PropagatorInField::SetLargestAcceptableStep ( G4double  newBigDist )

inline

SetMaximumEpsilonStep()

void G4PropagatorInField::SetMaximumEpsilonStep ( G4double  newEpsMax )

inline

SetMaxLoopCount()

void G4PropagatorInField::SetMaxLoopCount ( G4int  new_max )

inline

SetMinimumEpsilonStep()

void G4PropagatorInField::SetMinimumEpsilonStep ( G4double  newEpsMin )

inline

SetNavigatorForPropagating()

void G4PropagatorInField::SetNavigatorForPropagating ( G4Navigator *  SimpleOrMultiNavigator )

inline

Referenced by G4PathFinder::EnableParallelNavigation(), and G4TransportationManager::SetNavigatorForTracking().

SetThresholdNoZeroStep()

void G4PropagatorInField::SetThresholdNoZeroStep ( G4int  noAct, G4int  noHarsh, G4int  noAbandon  )

inline

SetTrajectoryFilter()

void G4PropagatorInField::SetTrajectoryFilter

(

G4VCurvedTrajectoryFilter *

filter

)

Definition at line 667 of file G4PropagatorInField.cc.

{
  fpTrajectoryFilter = filter;
}

References fpTrajectoryFilter.

Referenced by G4TrackingMessenger::SetNewValue().

SetUseSafetyForOptimization()

void G4PropagatorInField::SetUseSafetyForOptimization ( G4bool  )

inline

SetVerboseLevel()

G4int G4PropagatorInField::SetVerboseLevel

(

G4int

verbose

)

Definition at line 743 of file G4PropagatorInField.cc.

{
  G4int oldval = fVerboseLevel;
  fVerboseLevel = level;
 
  // Forward the verbose level 'reduced' to ChordFinder,
  // MagIntegratorDriver ... ? 
  //
  auto integrDriver = GetChordFinder()->GetIntegrationDriver(); 
  integrDriver->SetVerboseLevel( fVerboseLevel - 2 );
  G4cout << "Set Driver verbosity to " << fVerboseLevel - 2 << G4endl;
 
  return oldval;
}

References fVerboseLevel, G4cout, G4endl, GetChordFinder(), G4ChordFinder::GetIntegrationDriver(), and G4VIntegrationDriver::SetVerboseLevel().

SetVerboseTrace()

void G4PropagatorInField::SetVerboseTrace ( G4bool  enable )

inline

SetZeroStepThreshold()

void G4PropagatorInField::SetZeroStepThreshold ( G4double  newLength )

inline

Verbose()

G4int G4PropagatorInField::Verbose ( ) const

inline

Field Documentation

End_PointAndTangent

G4FieldTrack G4PropagatorInField::End_PointAndTangent

private

Definition at line 283 of file G4PropagatorInField.hh.

Referenced by ClearPropagatorState(), and ComputeStep().

fAbandonThreshold_NoZeroSteps

G4int G4PropagatorInField::fAbandonThreshold_NoZeroSteps = 50

private

Definition at line 238 of file G4PropagatorInField.hh.

Referenced by ComputeStep().

fActionThreshold_NoZeroSteps

G4int G4PropagatorInField::fActionThreshold_NoZeroSteps = 2

private

Definition at line 236 of file G4PropagatorInField.hh.

Referenced by ComputeStep().

fAllocatedLocator

G4bool G4PropagatorInField::fAllocatedLocator

private

Definition at line 249 of file G4PropagatorInField.hh.

Referenced by G4PropagatorInField(), and ~G4PropagatorInField().

fCheck

G4bool G4PropagatorInField::fCheck = false

private

Definition at line 297 of file G4PropagatorInField.hh.

fCurrentFieldMgr

G4FieldManager* G4PropagatorInField::fCurrentFieldMgr

private

Definition at line 277 of file G4PropagatorInField.hh.

Referenced by ComputeStep(), FindAndSetFieldManager(), and RefreshIntersectionLocator().

fDetectorFieldMgr

G4FieldManager* G4PropagatorInField::fDetectorFieldMgr

private

Definition at line 254 of file G4PropagatorInField.hh.

Referenced by FindAndSetFieldManager(), and G4PropagatorInField().

fEpsilonStep

G4double G4PropagatorInField::fEpsilonStep

private

Definition at line 282 of file G4PropagatorInField.hh.

Referenced by ClearPropagatorState(), ComputeStep(), G4PropagatorInField(), and RefreshIntersectionLocator().

fFirstStepInVolume

G4bool G4PropagatorInField::fFirstStepInVolume = true

private

Definition at line 300 of file G4PropagatorInField.hh.

Referenced by ComputeStep().

fFull_CurveLen_of_LastAttempt

G4double G4PropagatorInField::fFull_CurveLen_of_LastAttempt = -1

private

Definition at line 288 of file G4PropagatorInField.hh.

Referenced by ClearPropagatorState(), ComputeStep(), and PrintStepLengthDiagnostic().

fIncreaseChordDistanceThreshold

G4int G4PropagatorInField::fIncreaseChordDistanceThreshold = 100

private

Definition at line 230 of file G4PropagatorInField.hh.

Referenced by ComputeStep().

fIntersectionLocator

G4VIntersectionLocator* G4PropagatorInField::fIntersectionLocator

private

Definition at line 257 of file G4PropagatorInField.hh.

Referenced by ComputeStep(), G4PropagatorInField(), RefreshIntersectionLocator(), and ~G4PropagatorInField().

fLargestAcceptableStep

G4double G4PropagatorInField::fLargestAcceptableStep

private

Definition at line 242 of file G4PropagatorInField.hh.

Referenced by ComputeStep(), and G4PropagatorInField().

fLast_ProposedStepLength

G4double G4PropagatorInField::fLast_ProposedStepLength = -1

private

Definition at line 289 of file G4PropagatorInField.hh.

Referenced by ClearPropagatorState(), ComputeStep(), and PrintStepLengthDiagnostic().

fLastStepInVolume

G4bool G4PropagatorInField::fLastStepInVolume = true

private

Definition at line 301 of file G4PropagatorInField.hh.

Referenced by ComputeStep().

fMax_loop_count

G4int G4PropagatorInField::fMax_loop_count = 1000

private

Definition at line 228 of file G4PropagatorInField.hh.

Referenced by ComputeStep().

fNavigator

G4Navigator* G4PropagatorInField::fNavigator

private

Definition at line 267 of file G4PropagatorInField.hh.

Referenced by ComputeStep().

fNewTrack

G4bool G4PropagatorInField::fNewTrack = true

private

Definition at line 302 of file G4PropagatorInField.hh.

Referenced by ClearPropagatorState(), and ComputeStep().

fNoZeroStep

G4int G4PropagatorInField::fNoZeroStep = 0

private

Definition at line 285 of file G4PropagatorInField.hh.

Referenced by ClearPropagatorState(), ComputeStep(), and PrintStepLengthDiagnostic().

fParticleIsLooping

G4bool G4PropagatorInField::fParticleIsLooping = false

private

Definition at line 284 of file G4PropagatorInField.hh.

Referenced by ClearPropagatorState(), and ComputeStep().

fPreviousSafety

G4double G4PropagatorInField::fPreviousSafety = 0.0

private

Definition at line 292 of file G4PropagatorInField.hh.

Referenced by ClearPropagatorState(), and ComputeStep().

fPreviousSftOrigin

G4ThreeVector G4PropagatorInField::fPreviousSftOrigin

private

Definition at line 291 of file G4PropagatorInField.hh.

Referenced by ClearPropagatorState(), ComputeStep(), and G4PropagatorInField().

fpTrajectoryFilter

G4VCurvedTrajectoryFilter* G4PropagatorInField::fpTrajectoryFilter = nullptr

private

Definition at line 260 of file G4PropagatorInField.hh.

Referenced by ComputeStep(), GimmeTrajectoryVectorAndForgetIt(), and SetTrajectoryFilter().

fSetFieldMgr

G4bool G4PropagatorInField::fSetFieldMgr = false

private

Definition at line 279 of file G4PropagatorInField.hh.

Referenced by ClearPropagatorState(), ComputeStep(), and FindAndSetFieldManager().

fSevereActionThreshold_NoZeroSteps

G4int G4PropagatorInField::fSevereActionThreshold_NoZeroSteps = 10

private

Definition at line 237 of file G4PropagatorInField.hh.

Referenced by ComputeStep().

fUseSafetyForOptimisation

G4bool G4PropagatorInField::fUseSafetyForOptimisation = true

private

Definition at line 231 of file G4PropagatorInField.hh.

Referenced by RefreshIntersectionLocator().

fVerboseLevel

G4int G4PropagatorInField::fVerboseLevel = 0

private

Definition at line 295 of file G4PropagatorInField.hh.

Referenced by ComputeStep(), G4PropagatorInField(), printStatus(), and SetVerboseLevel().

fVerbTracePiF

G4bool G4PropagatorInField::fVerbTracePiF = false

private

Definition at line 296 of file G4PropagatorInField.hh.

Referenced by G4PropagatorInField().

fZeroStepThreshold

G4double G4PropagatorInField::fZeroStepThreshold = 0.0

private

Definition at line 239 of file G4PropagatorInField.hh.

Referenced by ComputeStep(), and G4PropagatorInField().

kCarTolerance

G4double G4PropagatorInField::kCarTolerance

private

Definition at line 246 of file G4PropagatorInField.hh.

Referenced by ComputeStep(), and G4PropagatorInField().

---

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

• source/geometry/navigation/include/G4PropagatorInField.hh
• source/geometry/navigation/src/G4PropagatorInField.cc