G4PathFinder directs the lock-stepped propagation of a track in the 'mass' and other parallel geometries. It ensures that tracking in a magnetic field sees these parallel geometries at each trial step and that the earliest boundary limits the step. More...

#include <G4PathFinder.hh>

Public Member Functions
	~G4PathFinder ()
G4double	ComputeStep (const G4FieldTrack &pFieldTrack, G4double pCurrentProposedStepLength, G4int navigatorId, G4int stepNo, G4double &pNewSafety, ELimited &limitedStep, G4FieldTrack &EndState, G4VPhysicalVolume *currentVolume)
void	Locate (const G4ThreeVector &position, const G4ThreeVector &direction, G4bool relativeSearch=true)
void	ReLocate (const G4ThreeVector &position)
void	PrepareNewTrack (const G4ThreeVector &position, const G4ThreeVector &direction, G4VPhysicalVolume *massStartVol=nullptr)
void	EndTrack ()
G4TouchableHandle	CreateTouchableHandle (G4int navId) const
G4VPhysicalVolume *	GetLocatedVolume (G4int navId) const
G4double	GetCurrentSafety () const
G4double	GetMinimumStep () const
unsigned int	GetNumberGeometriesLimitingStep () const
G4double	ComputeSafety (const G4ThreeVector &globalPoint)
G4double	ObtainSafety (G4int navId, G4ThreeVector &globalCenterPoint)
void	EnableParallelNavigation (G4bool enableChoice=true)
G4int	SetVerboseLevel (G4int lev=-1)
G4int	GetMaxLoopCount () const
void	SetMaxLoopCount (G4int new_max)
void	MovePoint ()
G4double	LastPreSafety (G4int navId, G4ThreeVector &globCenterPoint, G4double &minSafety)
void	PushPostSafetyToPreSafety ()
G4String &	LimitedString (ELimited lim)

Static Public Member Functions
static G4PathFinder *	GetInstance ()
static G4PathFinder *	GetInstanceIfExist ()

Detailed Description

G4PathFinder directs the lock-stepped propagation of a track in the 'mass' and other parallel geometries. It ensures that tracking in a magnetic field sees these parallel geometries at each trial step and that the earliest boundary limits the step.

Definition at line 60 of file G4PathFinder.hh.

Constructor & Destructor Documentation

◆ ~G4PathFinder()

G4PathFinder::~G4PathFinder ( )

Destructor, called only by G4RunManagerKernel.

Definition at line 106 of file G4PathFinder.cc.

{
   delete fpMultiNavigator;
   fpPathFinder = nullptr;
}

Member Function Documentation

◆ ComputeSafety()

G4double G4PathFinder::ComputeSafety ( const G4ThreeVector & globalPoint )

Recomputes the safety for the relevant point, i.e. the endpoint of the last step. Maintains a vector of individual safety values (used by next method below).

Parameters

[in] globalPoint Point in global coordinates system.

Returns: The safety value for the specified point in the geometry.

Definition at line 735 of file G4PathFinder.cc.

{
    // Recompute safety for the relevant point
 
   G4double minSafety = kInfinity; 
  
   std::vector<G4Navigator*>::iterator pNavigatorIter;
   pNavigatorIter = fpTransportManager->GetActiveNavigatorsIterator();
 
   for( auto num=0; num<fNoActiveNavigators; ++pNavigatorIter,++num )
   {
      G4double safety = (*pNavigatorIter)->ComputeSafety(position,DBL_MAX,true);
      if( safety < minSafety ) { minSafety = safety; } 
      fNewSafetyComputed[num] = safety;
   } 
 
   fSafetyLocation = position;
   fMinSafety_atSafLocation = minSafety;
 
#ifdef G4DEBUG_PATHFINDER
   if( fVerboseLevel > 1 )
   { 
     G4cout << " G4PathFinder::ComputeSafety - returns " 
            << minSafety << " at location " << position << G4endl;
   }
#endif
   return minSafety; 
}

Referenced by ReLocate().

◆ ComputeStep()

G4double G4PathFinder::ComputeStep	(	const G4FieldTrack &	pFieldTrack,
		G4double	pCurrentProposedStepLength,
		G4int	navigatorId,
		G4int	stepNo,
		G4double &	pNewSafety,
		ELimited &	limitedStep,
		G4FieldTrack &	EndState,
		G4VPhysicalVolume *	currentVolume )

Computes the next geometric Step, curved or linear. If it is called with a larger 'stepNo' it will execute a new step; if 'stepNo' is same as last call, then the results for the geometry with Id number 'navigatorId' will be returned.

Parameters

[in,out]	pFieldTrack	Field track to be filled.
[in]	pCurrentProposedStepLength	Current proposed step length.
[in]	navigatorId	Identifier of the geometry.
[in]	stepNo	Step number; see next step/check.
[in,out]	pNewSafety	New safety for this geometry.
[in,out]	limitedStep	Step characterisation to be returned.
[in,out]	EndState	Field track end state.
[in]	currentVolume	Pointer to the current volume.

Returns: Step length.

Definition at line 142 of file G4PathFinder.cc.

{
  G4double possibleStep = -1.0; 
 
#ifdef G4DEBUG_PATHFINDER
  if( fVerboseLevel > 2 )
  { 
    G4cout << " -------------------------" <<  G4endl;
    G4cout << " G4PathFinder::ComputeStep - entered " << G4endl;
    G4cout << "   - stepNo = "  << std::setw(4) << stepNo  << " "
           << " navigatorId = " << std::setw(2) << navigatorNo  << " "
           << " proposed step len = " << proposedStepLength << " " << G4endl;
    G4cout << " PF::ComputeStep requested step " 
           << " from " << InitialFieldTrack.GetPosition()
           << " dir  " << InitialFieldTrack.GetMomentumDirection() << G4endl;
  }
#endif
#ifdef G4VERBOSE
  if( navigatorNo >= fNoActiveNavigators )
  {
    std::ostringstream message;
    message << "Bad Navigator ID !" << G4endl
            << "        Requested Navigator ID = " << navigatorNo << G4endl
            << "        Number of active navigators = " << fNoActiveNavigators;
    G4Exception("G4PathFinder::ComputeStep()", "GeomNav0002",
                FatalException, message); 
  }
#endif
 
  if( fNewTrack || (stepNo != fLastStepNo)  )
  {
    // This is a new track or a new step, so we must make the step
    // ( else we can simply retrieve its results for this Navigator Id )    
 
    G4FieldTrack currentState = InitialFieldTrack;
 
    fCurrentStepNo = stepNo; 
 
    // Check whether a process shifted the position 
    // since the last step -- by physics processes
    //
    G4ThreeVector newPosition = InitialFieldTrack.GetPosition();   
    G4ThreeVector moveVector = newPosition - fLastLocatedPosition; 
    G4double moveLenSq = moveVector.mag2(); 
    if( moveLenSq > sqr(kCarTolerance) )
    { 
       G4ThreeVector newDirection = InitialFieldTrack.GetMomentumDirection();   
#ifdef G4DEBUG_PATHFINDER
       if( fVerboseLevel > 2 )
       { 
          G4double moveLen= std::sqrt( moveLenSq ); 
          G4cout << " G4PathFinder::ComputeStep : Point moved since last step " 
                 << " -- at step # = " << stepNo << G4endl
                 << " by " << moveLen  << " to " << newPosition << G4endl;      
       } 
#endif
       MovePoint();  // Unintentional changed -- ????
 
       // Relocate to cope with this move -- else could abort !?
       //
       Locate( newPosition, newDirection ); 
    }
 
    // Check whether the particle have an (EM) field force exerting upon it
    //
    G4double particleCharge = currentState.GetCharge(); 
 
    G4FieldManager* fieldMgr = nullptr;
    G4bool          fieldExertsForce = false ;
    if( particleCharge != 0.0 )
    {
        fieldMgr = fpFieldPropagator->FindAndSetFieldManager( currentVolume );
 
        // Protect for case where field manager has no field (= field is zero)
        //
        fieldExertsForce = (fieldMgr != nullptr) 
                        && (fieldMgr->GetDetectorField() != nullptr);
    }
    fFieldExertedForce = fieldExertsForce;  // Store for use in later calls
                                            // referring to this 'step'.
 
    fNoGeometriesLimiting = -1;  // At start of track, no process limited step
    if( fieldExertsForce )
    {
       DoNextCurvedStep( currentState, proposedStepLength, currentVolume ); 
       //--------------
    }else{
       DoNextLinearStep( currentState, proposedStepLength ); 
       //--------------
    }
    fLastStepNo = stepNo; 
    fRelocatedPoint = false;
 
#ifdef  G4DEBUG_PATHFINDER
    if ( (fNoGeometriesLimiting < 0)
      || (fNoGeometriesLimiting > fNoActiveNavigators) )
    {
      std::ostringstream message;
      message << "Number of geometries limiting the step not set." << G4endl
              << "        Number of geometries limiting step = "
              << fNoGeometriesLimiting;
      G4Exception("G4PathFinder::ComputeStep()", 
                  "GeomNav0002", FatalException, message); 
    }
#endif
  }
#ifdef G4DEBUG_PATHFINDER      
  else
  {
     const G4double checkTolerance = 1.0e-9; 
     if( proposedStepLength < fTrueMinStep * ( 1.0 - checkTolerance) )
     {                                                   // For 2nd+ geometry 
       std::ostringstream message;
       message.precision( 12 ); 
       message << "Problem in step size request." << G4endl
               << "        Being requested to make a step which is shorter"
               << " than the minimum Step " << G4endl
               << "        already computed for any Navigator/geometry during"
               << " this tracking-step: " << G4endl
               << "        This could happen due to an error in process ordering."
               << G4endl
               << "        Check that all physics processes are registered"
               << "        before all processes with a navigator/geometry."
               << G4endl
               << "        If using pre-packaged physics list and/or"
               << "        functionality, please report this error."
               << G4endl << G4endl
               << "        Additional information for problem: "  << G4endl
               << "        Steps request/proposed = " << proposedStepLength
               << G4endl
               << "        MinimumStep (true) = " << fTrueMinStep
               << G4endl
               << "        MinimumStep (navraw)  = " << fMinStep
               << G4endl
               << "        Navigator raw return value" << G4endl
               << "        Requested step now = " << proposedStepLength
               << G4endl
               << "        Difference min-req (absolute) = "
               << fTrueMinStep-proposedStepLength << G4endl
               << "        Relative (to max of two) = " 
               << (fTrueMinStep-proposedStepLength)
                  / std::max(proposedStepLength, fTrueMinStep) << G4endl
               << "     -- Step info> stepNo= " << stepNo
               << " last= " << fLastStepNo 
               << " newTr= " << fNewTrack << G4endl;
        G4Exception("G4PathFinder::ComputeStep()", 
                    "GeomNav0003", FatalException, message);
     }
     else
     { 
        // This is neither a new track nor a new step -- just another 
        // client accessing information for the current track, step 
        // We will simply retrieve the results of the synchronous
        // stepping for this Navigator Id below.
        //
        if( fVerboseLevel > 1 )
        { 
           G4cout << " G4P::CS -> Not calling DoNextLinearStep: " 
                  << " stepNo= " << stepNo << " last= " << fLastStepNo 
                  << " new= " << fNewTrack << " Step already done" << G4endl; 
        }
     } 
  }
#endif
 
  fNewTrack = false; 
 
  // Prepare the information to return
 
  pNewSafety  = fCurrentPreStepSafety[ navigatorNo ]; 
  limitedStep = fLimitedStep[ navigatorNo ];
 
  possibleStep = std::min(proposedStepLength, fCurrentStepSize[ navigatorNo ]);
  EndState = fEndState;  //  now corrected for smaller step, if needed
 
#ifdef G4DEBUG_PATHFINDER
  if( fVerboseLevel > 0 )
  { 
    G4cout << " G4PathFinder::ComputeStep returns "
           << fCurrentStepSize[ navigatorNo ]
           << " for Navigator " << navigatorNo 
           << " Limited step = " << limitedStep 
           << " Safety(mm) = " << pNewSafety / mm 
           << G4endl; 
  }
#endif
 
  return possibleStep;
}

◆ CreateTouchableHandle()

G4TouchableHandle G4PathFinder::CreateTouchableHandle ( G4int navId ) const

Creates a touchable handle for the specified navigator.

Parameters

[in] navId The navigator identifier.

Returns: A touchable handle of the geometry.

Definition at line 768 of file G4PathFinder.cc.

{
#ifdef G4DEBUG_PATHFINDER
  if( fVerboseLevel > 2 )
  {
    G4cout << "G4PathFinder::CreateTouchableHandle : navId = "
           << navId << " -- " << GetNavigator(navId) << G4endl;
  }
#endif
 
  G4TouchableHistory* touchHist;
  touchHist = GetNavigator(navId)->CreateTouchableHistory(); 
 
  G4VPhysicalVolume* locatedVolume = fLocatedVolume[navId]; 
  if( locatedVolume == nullptr )
  {
     // Workaround to ensure that the touchable is fixed !! // TODO: fix
 
     touchHist->UpdateYourself( locatedVolume, touchHist->GetHistory() );
  }
 
#ifdef G4DEBUG_PATHFINDER
  if( fVerboseLevel > 2 )
  {   
    G4String VolumeName("None"); 
    if( locatedVolume ) { VolumeName = locatedVolume->GetName(); }
    G4cout << " Touchable History created at address " << touchHist
           << "; volume = " << locatedVolume << "; name= " << VolumeName
           << G4endl;
  }
#endif
 
  return touchHist; 
}

◆ EnableParallelNavigation()

void G4PathFinder::EnableParallelNavigation ( G4bool enableChoice = true )

To enable parallel navigation. Must call it to ensure that G4PathFinder is prepared, especially for curved tracks. If true it switches G4PropagatorInField to use G4MultiNavigator. Must call it with false to undo (i.e. G4PropagatorInField uses classic G4Navigator for tracking in such case).

Parameters

[in] enableChoice Flag to enable/disable parallel navigation.

Definition at line 115 of file G4PathFinder.cc.

{
   G4Navigator *navigatorForPropagation = nullptr, *massNavigator = nullptr;
 
   massNavigator = fpTransportManager->GetNavigatorForTracking(); 
   if( enableChoice )
   {
      navigatorForPropagation = fpMultiNavigator;
 
      // Enable SafetyHelper to use PF
      //
      fpTransportManager->GetSafetyHelper()->EnableParallelNavigation(true);
   }
   else
   {
      navigatorForPropagation = massNavigator;
       
      // Disable SafetyHelper to use PF
      //
      fpTransportManager->GetSafetyHelper()->EnableParallelNavigation(false);
   }
   fpFieldPropagator->SetNavigatorForPropagating(navigatorForPropagation);
}

Referenced by EndTrack(), and PrepareNewTrack().

◆ EndTrack()

void G4PathFinder::EndTrack ( )

Signals the end of tracking of the current track. Resets internal state and informs G4TransportationManager to use 'ordinary' Navigator.

Definition at line 432 of file G4PathFinder.cc.

{
  EnableParallelNavigation(false);  // Else it will be continue to be used
}

◆ GetCurrentSafety()

G4double G4PathFinder::GetCurrentSafety ( ) const

inline

Returns the minimum value of safety after last ComputeStep().

◆ GetInstance()

G4PathFinder * G4PathFinder::GetInstance ( )

static

Retrieves singleton instance and creates it if not existing.

Definition at line 52 of file G4PathFinder.cc.

{
   if( fpPathFinder == nullptr )
   {
     fpPathFinder = new G4PathFinder; 
   }
   return fpPathFinder;
}

Referenced by G4CoupledTransportation::G4CoupledTransportation(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4ImportanceProcess::G4ImportanceProcess(), G4ParallelGeometriesLimiterProcess::G4ParallelGeometriesLimiterProcess(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4ITSafetyHelper::InitialiseNavigator(), and G4SafetyHelper::InitialiseNavigator().

◆ GetInstanceIfExist()

G4PathFinder * G4PathFinder::GetInstanceIfExist ( )

static

Retrieve singleton instance pointer.

Definition at line 66 of file G4PathFinder.cc.

{
   return fpPathFinder;
}

Referenced by G4RunManagerKernel::~G4RunManagerKernel().

◆ GetLocatedVolume()

G4VPhysicalVolume * G4PathFinder::GetLocatedVolume ( G4int navId ) const

inline

Returns the located volume for the specified navigator.

Parameters

[in] navId The navigator identifier.

Returns: A pointer to the located volume in the geometry.

◆ GetMaxLoopCount()

G4int G4PathFinder::GetMaxLoopCount ( ) const

inline

To get/set the maximum for the number of steps that a (looping) particle can take.

◆ GetMinimumStep()

G4double G4PathFinder::GetMinimumStep ( ) const

inline

Gets the minimum step size from the last ComputeStep() call.

Note: In case full step is taken, this is kInfinity.

◆ GetNumberGeometriesLimitingStep()

unsigned int G4PathFinder::GetNumberGeometriesLimitingStep ( ) const

inline

Returns the number of all geometries limiting the step.

◆ LastPreSafety()

G4double G4PathFinder::LastPreSafety	(	G4int	navId,
		G4ThreeVector &	globCenterPoint,
		G4double &	minSafety )

inline

Obtains the last safety needed in ComputeStep() for the specified geometry 'navId' (i.e. the last point at which ComputeStep() has recalculated the safety). Returns the point (center) for which this safety is valid and also the minimum safety over all navigators.

Parameters

[in]	navId	The navigator identifier.
[in,out]	globCenterPoint	The point (center) for which this safety is valid.
[in,out]	minSafety	The minimum safety over all navigators.

Returns: The safety value in the specified geometry.

◆ LimitedString()

G4String & G4PathFinder::LimitedString ( ELimited lim )

Utility to convert ELimited specification to a string.

Definition at line 1363 of file G4PathFinder.cc.

{
  static G4String StrDoNot("DoNot"),
                  StrUnique("Unique"),
                  StrUndefined("Undefined"),
                  StrSharedTransport("SharedTransport"),  
                  StrSharedOther("SharedOther");
 
  G4String* limitedStr;
  switch ( lim )
  {
     case kDoNot:  limitedStr = &StrDoNot; break;
     case kUnique: limitedStr = &StrUnique; break; 
     case kSharedTransport:  limitedStr = &StrSharedTransport; break; 
     case kSharedOther: limitedStr = &StrSharedOther; break;
     default: limitedStr = &StrUndefined; break;
  }
  return *limitedStr;
}

◆ Locate()

void G4PathFinder::Locate	(	const G4ThreeVector &	position,
		const G4ThreeVector &	direction,
		G4bool	relativeSearch = true )

Makes primary relocation of the global point in all navigators, and updates them.

Parameters

[in]	position	Point in global coordinates system.
[in]	direction	Global direction vector.
[in]	relativeSearch	If set to true (default), the search begins is the geometrical hierarchy at the location of the last located point.

Definition at line 461 of file G4PathFinder.cc.

{
  // Locate the point in each geometry
 
  auto pNavIter = fpTransportManager->GetActiveNavigatorsIterator(); 
 
  G4ThreeVector lastEndPosition = fRelocatedPoint
                                ? fLastLocatedPosition
                                : fEndState.GetPosition();
  fLastLocatedPosition = position; 
 
#ifdef G4DEBUG_PATHFINDER
  static const G4double movLenTol = 10*sqr(kCarTolerance);
 
  G4ThreeVector moveVec = ( position - lastEndPosition );
  G4double      moveLenSq = moveVec.mag2();
  if( (!fNewTrack) && ( moveLenSq > movLenTol ) )
  {
     ReportMove( lastEndPosition, position,
                 " (End) Position / G4PathFinder::Locate" ); 
  }
 
  if( fVerboseLevel > 2 )
  {
    G4cout << G4endl; 
    G4cout << " G4PathFinder::Locate : entered " << G4endl;
    G4cout << " --------------------   -------" <<  G4endl;
    G4cout << "   Locating at position " << position
           << "  with direction " << direction 
           << "  relative= " << relative << G4endl;
    if ( (fVerboseLevel > 1) || ( moveLenSq > 0.0) )
    { 
       G4cout << "  lastEndPosition = " << lastEndPosition
              << "  moveVec = " << moveVec
              << "  newTr = " << fNewTrack 
              << "  relocated = " << fRelocatedPoint << G4endl;
    }
 
    G4cout << " Located at " << position ; 
    if( fNoActiveNavigators > 1 )  { G4cout << G4endl; }
  }
#endif
 
  for ( auto num=0; num<fNoActiveNavigators ; ++pNavIter,++num )
  {
     //  ... who limited the step ....
 
     if( fLimitTruth[num] ) { (*pNavIter)->SetGeometricallyLimitedStep(); }
 
     G4VPhysicalVolume *pLocated= 
     (*pNavIter)->LocateGlobalPointAndSetup( position, &direction,
                                             relative,  
                                             false);   
     // Set the state related to the location
     //
     fLocatedVolume[num] = pLocated; 
 
     // Clear state related to the step
     //
     fLimitedStep[num] = kDoNot; 
     fCurrentStepSize[num] = 0.0;      
    
#ifdef G4DEBUG_PATHFINDER
     if( fVerboseLevel > 2 )
     {
       G4cout << " - In world " << num << " geomLimStep= " << fLimitTruth[num]
              << "  gives volume= " << pLocated ; 
       if( pLocated )
       { 
         G4cout << "  name = '" << pLocated->GetName() << "'"; 
         G4cout << " - CopyNo= " << pLocated->GetCopyNo(); 
       } 
       G4cout  << G4endl; 
     }
#endif
  }
 
  fRelocatedPoint = false;
}

Referenced by ComputeStep(), and PrepareNewTrack().

◆ MovePoint()

void G4PathFinder::MovePoint ( )

inline

Signals that the point location will be moved.

Note: Internal use primarily.

Referenced by ComputeStep(), and PrepareNewTrack().

◆ ObtainSafety()

G4double G4PathFinder::ObtainSafety	(	G4int	navId,
		G4ThreeVector &	globalCenterPoint )

inline

Obtains the safety for the specified navigator/geometry for last point 'computed' (i.e., the last point for which ComputeSafety() was called).

Parameters

[in]	navId	The navigator identifier.
[in,out]	globalCenterPoint	The point (center) for which this safety is valid.

Returns: The safety value in the specified geometry.

◆ PrepareNewTrack()

void G4PathFinder::PrepareNewTrack	(	const G4ThreeVector &	position,
		const G4ThreeVector &	direction,
		G4VPhysicalVolume *	massStartVol = nullptr )

Checks and caches the set of active navigators.

Parameters

[in]	position	Point in global coordinates system.
[in]	direction	Global direction vector.
[in]	massStartVol	Pointer to the mass geometry world.

Definition at line 342 of file G4PathFinder.cc.

{
  // Key purposes:
  //   - Check and cache set of active navigators
  //   - Reset state for new track
 
  G4int num=0; 
 
  EnableParallelNavigation(true); 
    // Switch PropagatorInField to use MultiNavigator
 
  fpTransportManager->GetSafetyHelper()->InitialiseHelper(); 
    // Reinitialise state of safety helper -- avoid problems with overlaps
 
  fNewTrack = true; 
  this->MovePoint();   // Signal further that the last status is wiped
 
  fpFieldPropagator->PrepareNewTrack(); // Inform field propagator of new track
  
  // Message the G4NavigatorPanel / Dispatcher to find active navigators
  //
  std::vector<G4Navigator*>::iterator pNavigatorIter; 
 
  fNoActiveNavigators = (G4int)fpTransportManager-> GetNoActiveNavigators();
  if( fNoActiveNavigators > fMaxNav )
  {
    std::ostringstream message;
    message << "Too many active Navigators / worlds." << G4endl
            << "        Transportation Manager has "
            << fNoActiveNavigators << " active navigators." << G4endl
            << "        This is more than the number allowed = "
            << fMaxNav << " !";
    G4Exception("G4PathFinder::PrepareNewTrack()", "GeomNav0002",  
                FatalException, message); 
  }
 
  fpMultiNavigator->PrepareNavigators(); 
  //------------------------------------
 
  pNavigatorIter = fpTransportManager->GetActiveNavigatorsIterator();
  for( num=0; num< fNoActiveNavigators; ++pNavigatorIter,++num )
  {
     // Keep information in C-array ... for creating touchables - at least
     //
     fpNavigator[num] = *pNavigatorIter;   
     fLimitTruth[num] = false;
     fLimitedStep[num] = kDoNot;
     fCurrentStepSize[num] = 0.0; 
     fLocatedVolume[num] = nullptr; 
  }
  fNoGeometriesLimiting = 0;  // At start of track, no process limited step
 
  // In case of one geometry, the tracking will have done the locating!!
 
  if( fNoActiveNavigators > 1 )
  {
     Locate( position, direction, false );   
  }
  else
  {
     // Update state -- depending on the tracking's call to Mass Navigator
 
     fLastLocatedPosition = position; 
     fLocatedVolume[0] = massStartVol; // This information must be given
                                       // by transportation
     fLimitedStep[0] = kDoNot; 
     fCurrentStepSize[0] = 0.0;
  }
 
  // Reset Safety Information -- as in case of overlaps this can cause
  // inconsistencies ...
  //
  fMinSafety_PreStepPt = fPreSafetyMinValue = fMinSafety_atSafLocation = 0.0; 
 
  for( num=0; num<fNoActiveNavigators; ++num )
  {
     fPreSafetyValues[num] = 0.0; 
     fNewSafetyComputed[num] = 0.0; 
     fCurrentPreStepSafety[num] = 0.0;
  }
 
  // The first location for each Navigator must be non-relative
  // or else call ResetStackAndState() for each Navigator
 
  fRelocatedPoint = false; 
}

◆ PushPostSafetyToPreSafety()

void G4PathFinder::PushPostSafetyToPreSafety ( )

Tells G4PathFinder to copy PostStep Safety to PreSafety for use at the next step.

Definition at line 1383 of file G4PathFinder.cc.

{
  fPreSafetyLocation = fSafetyLocation;
  fPreSafetyMinValue = fMinSafety_atSafLocation;
  for( auto nav=0; nav < fNoActiveNavigators; ++nav )
  {
     fPreSafetyValues[nav] = fNewSafetyComputed[nav];
  }
}

◆ ReLocate()

void G4PathFinder::ReLocate ( const G4ThreeVector & position )

Makes secondary relocation of the global point (within safety only) in all navigators, and updates them.

Parameters

[in] position Point in global coordinates system.

Definition at line 543 of file G4PathFinder.cc.

{
  // Locate the point in each geometry
 
  auto pNavIter = fpTransportManager->GetActiveNavigatorsIterator(); 
 
#ifdef G4DEBUG_PATHFINDER
 
  // Check that this relocation does not violate safety
  //   - at endpoint (computed from start point) AND
  //   - at last safety location  (likely just called)
 
  G4ThreeVector lastEndPosition = fEndState.GetPosition();
 
  // Calculate end-point safety ...
  //
  G4double DistanceStartEnd = (lastEndPosition - fPreStepLocation).mag();
  G4double endPointSafety_raw = fMinSafety_PreStepPt - DistanceStartEnd; 
  G4double endPointSafety_Est1 = std::max( 0.0, endPointSafety_raw ); 
 
  // ... and check move from endpoint against this endpoint safety
  //
  G4ThreeVector moveVecEndPos  = position - lastEndPosition;
  G4double      moveLenEndPosSq = moveVecEndPos.mag2(); 
 
  // Check that move from endpoint of last step is within safety
  // -- or check against last location or relocation ?? 
  //
  G4ThreeVector moveVecSafety = position - fSafetyLocation; 
  G4double      moveLenSafSq = moveVecSafety.mag2();
 
  G4double distCheckEnd_sq = ( moveLenEndPosSq - endPointSafety_Est1 
                                                *endPointSafety_Est1 ); 
  G4double distCheckSaf_sq = ( moveLenSafSq - fMinSafety_atSafLocation
                                             *fMinSafety_atSafLocation ); 
 
  G4bool longMoveEnd = distCheckEnd_sq > 0.0; 
  G4bool longMoveSaf = distCheckSaf_sq > 0.0; 
 
  G4double revisedSafety = 0.0;
 
  if( (!fNewTrack) && ( longMoveEnd && longMoveSaf ) )
  {  
     // Recompute ComputeSafety for end position
     //
     revisedSafety = ComputeSafety(lastEndPosition); 
 
     const G4double kRadTolerance =
           G4GeometryTolerance::GetInstance()->GetRadialTolerance();
     const G4double cErrorTolerance = 1e-12;   
       // Maximum relative error from roundoff of arithmetic 
 
     G4double distCheckRevisedEnd = moveLenEndPosSq - sqr(revisedSafety);
 
     G4bool  longMoveRevisedEnd = ( distCheckRevisedEnd > 0. ) ; 
 
     G4double moveMinusSafety = 0.0; 
     G4double moveLenEndPosition = std::sqrt( moveLenEndPosSq );
     moveMinusSafety = moveLenEndPosition - revisedSafety; 
 
     if ( longMoveRevisedEnd && ( moveMinusSafety > 0.0 )
                             && ( revisedSafety > 0.0 ) )
     {
        // Take into account possibility of roundoff error causing
        // this apparent move further than safety
 
        if( fVerboseLevel > 0 )
        {
           G4cout << " G4PF:Relocate> Ratio to revised safety is " 
                  << std::fabs(moveMinusSafety)/revisedSafety << G4endl;
        }
 
        G4double absMoveMinusSafety = std::fabs(moveMinusSafety);
        G4bool smallRatio = absMoveMinusSafety < kRadTolerance * revisedSafety;
        G4double maxCoordPos = std::max( 
                                      std::max( std::fabs(position.x()), 
                                                std::fabs(position.y())), 
                                      std::fabs(position.z()) );
        G4bool smallValue= absMoveMinusSafety < cErrorTolerance * maxCoordPos;
        if( !(smallRatio || smallValue) )
        {
           G4cout << " G4PF:Relocate> Ratio to revised safety is " 
                  << std::fabs(moveMinusSafety)/revisedSafety << G4endl;
           G4cout << " Difference of move and safety is not very small."
                  << G4endl;
        }
        else
        {
          moveMinusSafety = 0.0; 
          longMoveRevisedEnd = false;   // Numerical issue -- not too long!
 
          G4cout << " Difference of move & safety is very small in magnitude, "
                 << absMoveMinusSafety << G4endl;
          if( smallRatio )
          {
            G4cout << " ratio to safety " << revisedSafety 
                   << " is " <<  absMoveMinusSafety / revisedSafety
                   << "smaller than " << kRadTolerance << " of safety ";
          }
          else
          {
            G4cout << " as fraction " << absMoveMinusSafety / maxCoordPos 
                   << " of position vector max-coord " << maxCoordPos
                   << " smaller than " << cErrorTolerance ;
          }
          G4cout << " -- reset moveMinusSafety to "
                 << moveMinusSafety << G4endl;
        }
     }
 
     if ( longMoveEnd && longMoveSaf
       && longMoveRevisedEnd && (moveMinusSafety>0.0) )
     { 
        std::ostringstream message;
        message.precision(9); 
        message << "ReLocation is further than end-safety value." << G4endl
                << " Moved from last endpoint by " << moveLenEndPosition 
                << " compared to end safety (from preStep point) = " 
                << endPointSafety_Est1 << G4endl
                << "  --> last PreSafety Location was " << fPreSafetyLocation
                << G4endl
                << "       safety value =  " << fPreSafetyMinValue << G4endl
                << "  --> last PreStep Location was " << fPreStepLocation
                << G4endl
                << "       safety value =  " << fMinSafety_PreStepPt << G4endl
                << "  --> last EndStep Location was " << lastEndPosition
                << G4endl
                << "       safety value =  " << endPointSafety_Est1 
                << " raw-value = " << endPointSafety_raw << G4endl
                << "  --> Calling again at this endpoint, we get "
                <<  revisedSafety << " as safety value."  << G4endl
                << "  --> last position for safety " << fSafetyLocation
                << G4endl
                << "       its safety value =  " << fMinSafety_atSafLocation
                << G4endl
                << "       move from safety location = "
                << std::sqrt(moveLenSafSq) << G4endl
                << "         again= " << moveVecSafety.mag() << G4endl
                << "       safety - Move-from-end= " 
                << revisedSafety - moveLenEndPosition
                << " (negative is Bad.)" << G4endl
                << " Debug:  distCheckRevisedEnd = "
                << distCheckRevisedEnd;
        ReportMove( lastEndPosition, position, "Position" ); 
        G4Exception("G4PathFinder::ReLocate", "GeomNav0003", 
                    FatalException, message); 
    }
  }
 
  if( fVerboseLevel > 2 )
  {
    G4cout << G4endl; 
    G4cout << " G4PathFinder::ReLocate : entered " << G4endl;
    G4cout << " ----------------------   -------" <<  G4endl;
    G4cout << "  *Re*Locating at position " << position  << G4endl; 
    if ( (fVerboseLevel > -1) || ( moveLenEndPosSq > 0.0) )
    {
       G4cout << "  lastEndPosition = " << lastEndPosition
              << "  moveVec from step-end = " << moveVecEndPos
              << "  is new Track = " << fNewTrack 
              << "  relocated = " << fRelocatedPoint << G4endl;
    }
  }
#endif // G4DEBUG_PATHFINDER
 
  for ( auto num=0; num< fNoActiveNavigators ; ++pNavIter,++num )
  {
     //  ... none limited the step
 
     (*pNavIter)->LocateGlobalPointWithinVolume( position ); 
 
     // Clear state related to the step
     //
     fLimitedStep[num] = kDoNot; 
     fCurrentStepSize[num] = 0.0;      
     fLimitTruth[num] = false;   
  }
 
  fLastLocatedPosition = position; 
  fRelocatedPoint = true;
 
#ifdef G4DEBUG_PATHFINDER
  if( fVerboseLevel > 2 )
  {
    G4cout << " G4PathFinder::ReLocate : exiting " 
           << "  at position " << fLastLocatedPosition << G4endl << G4endl;
  }
#endif
}

◆ SetMaxLoopCount()

void G4PathFinder::SetMaxLoopCount ( G4int new_max )

inline

◆ SetVerboseLevel()

G4int G4PathFinder::SetVerboseLevel ( G4int lev = -1 )

inline

To control the level of verbosity. Default is no verbosity.

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

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ ~G4PathFinder()

Member Function Documentation

◆ ComputeSafety()

◆ ComputeStep()

◆ CreateTouchableHandle()

◆ EnableParallelNavigation()

◆ EndTrack()

◆ GetCurrentSafety()

◆ GetInstance()

◆ GetInstanceIfExist()

◆ GetLocatedVolume()

◆ GetMaxLoopCount()

◆ GetMinimumStep()

◆ GetNumberGeometriesLimitingStep()

◆ LastPreSafety()

◆ LimitedString()

◆ Locate()

◆ MovePoint()

◆ ObtainSafety()

◆ PrepareNewTrack()

◆ PushPostSafetyToPreSafety()

◆ ReLocate()

◆ SetMaxLoopCount()

◆ SetVerboseLevel()