G4MultiNavigator Class Reference

G4MultiNavigator is a utility class for polling the navigators of several geometries to identify the next boundary. More...

#include <G4MultiNavigator.hh>

Inheritance diagram for G4MultiNavigator:

Public Member Functions
	G4MultiNavigator ()
	~G4MultiNavigator () override=default
G4double	ComputeStep (const G4ThreeVector &pGlobalPoint, const G4ThreeVector &pDirection, const G4double pCurrentProposedStepLength, G4double &pNewSafety) override
G4double	ObtainFinalStep (G4int navigatorId, G4double &pNewSafety, G4double &minStepLast, ELimited &limitedStep)
void	PrepareNavigators ()
void	PrepareNewTrack (const G4ThreeVector &position, const G4ThreeVector direction)
G4VPhysicalVolume *	ResetHierarchyAndLocate (const G4ThreeVector &point, const G4ThreeVector &direction, const G4TouchableHistory &h) override
G4VPhysicalVolume *	LocateGlobalPointAndSetup (const G4ThreeVector &point, const G4ThreeVector *direction=nullptr, const G4bool pRelativeSearch=true, const G4bool ignoreDirection=true) override
void	LocateGlobalPointWithinVolume (const G4ThreeVector &position) override
G4double	ComputeSafety (const G4ThreeVector &globalpoint, const G4double pProposedMaxLength=DBL_MAX, const G4bool keepState=false) override
G4TouchableHandle	CreateTouchableHistoryHandle () const override
G4ThreeVector	GetLocalExitNormal (G4bool *obtained) override
G4ThreeVector	GetLocalExitNormalAndCheck (const G4ThreeVector &point, G4bool *obtained) override
G4ThreeVector	GetGlobalExitNormal (const G4ThreeVector &point, G4bool *obtained) override
G4Navigator *	GetNavigator (G4int n) const
Public Member Functions inherited from G4Navigator
	G4Navigator ()
	G4Navigator (const G4Navigator &)=delete
G4Navigator &	operator= (const G4Navigator &)=delete
virtual	~G4Navigator ()
G4double	CheckNextStep (const G4ThreeVector &pGlobalPoint, const G4ThreeVector &pDirection, const G4double pCurrentProposedStepLength, G4double &pNewSafety)
void	LocateGlobalPointAndUpdateTouchableHandle (const G4ThreeVector &position, const G4ThreeVector &direction, G4TouchableHandle &oldTouchableToUpdate, const G4bool RelativeSearch=true)
void	LocateGlobalPointAndUpdateTouchable (const G4ThreeVector &position, const G4ThreeVector &direction, G4VTouchable *touchableToUpdate, const G4bool RelativeSearch=true)
void	LocateGlobalPointAndUpdateTouchable (const G4ThreeVector &position, G4VTouchable *touchableToUpdate, const G4bool RelativeSearch=true)
void	SetGeometricallyLimitedStep ()
G4VPhysicalVolume *	GetWorldVolume () const
void	SetWorldVolume (G4VPhysicalVolume *pWorld)
G4TouchableHistory *	CreateTouchableHistory () const
G4TouchableHistory *	CreateTouchableHistory (const G4NavigationHistory *h) const
G4int	GetVerboseLevel () const
void	SetVerboseLevel (G4int level)
G4bool	IsActive () const
void	Activate (G4bool flag)
G4bool	EnteredDaughterVolume () const
G4bool	ExitedMotherVolume () const
void	CheckMode (G4bool mode)
G4bool	IsCheckModeActive () const
void	SetPushVerbosity (G4bool mode)
void	PrintState () const
const G4AffineTransform &	GetGlobalToLocalTransform () const
const G4AffineTransform	GetLocalToGlobalTransform () const
G4AffineTransform	GetMotherToDaughterTransform (G4VPhysicalVolume *dVolume, G4int dReplicaNo, EVolume dVolumeType)
void	ResetStackAndState ()
G4int	SeverityOfZeroStepping (G4int *noZeroSteps) const
G4ThreeVector	GetCurrentLocalCoordinate () const
G4ThreeVector	NetTranslation () const
G4RotationMatrix	NetRotation () const
void	EnableBestSafety (G4bool value=false)
G4VExternalNavigation *	GetExternalNavigation () const
void	SetExternalNavigation (G4VExternalNavigation *externalNav)
G4VoxelNavigation &	GetVoxelNavigator ()
void	SetVoxelNavigation (G4VoxelNavigation *voxelNav)
G4Navigator *	Clone () const
G4ThreeVector	GetLastStepEndPoint () const
void	InformLastStep (G4double lastStep, G4bool entersDaughtVol, G4bool exitsMotherVol)

Protected Member Functions
void	ResetState () override
void	SetupHierarchy () override
void	WhichLimited ()
void	PrintLimited ()
void	CheckMassWorld ()
Protected Member Functions inherited from G4Navigator
void	SetSavedState ()
void	RestoreSavedState ()
G4ThreeVector	ComputeLocalPoint (const G4ThreeVector &rGlobP) const
G4ThreeVector	ComputeLocalAxis (const G4ThreeVector &pVec) const
EVolume	VolumeType (const G4VPhysicalVolume *pVol) const
EVolume	CharacteriseDaughters (const G4LogicalVolume *pLog) const
G4int	GetDaughtersRegularStructureId (const G4LogicalVolume *pLv) const
G4bool	CheckOverlapsIterative (G4VPhysicalVolume *vol)

Friends
std::ostream &	operator<< (std::ostream &os, const G4Navigator &n)

Additional Inherited Members
Protected Attributes inherited from G4Navigator
G4double	kCarTolerance
G4double	fMinStep
G4double	fSqTol
G4NavigationHistory	fHistory
G4ThreeVector	fStepEndPoint
G4ThreeVector	fLastStepEndPointLocal
G4int	fVerbose = 0
G4bool	fEnteredDaughter
G4bool	fExitedMother
G4bool	fWasLimitedByGeometry = false

Detailed Description

G4MultiNavigator is a utility class for polling the navigators of several geometries to identify the next boundary.

Definition at line 58 of file G4MultiNavigator.hh.

Constructor & Destructor Documentation

G4MultiNavigator()

G4MultiNavigator::G4MultiNavigator

(

)

Constructor and default Destructor.

Definition at line 42 of file G4MultiNavigator.cc.

{
  G4ThreeVector Big3Vector( kInfinity, kInfinity, kInfinity ); 
  fLastLocatedPosition = Big3Vector;
  fSafetyLocation  = Big3Vector;
  fPreStepLocation = Big3Vector;
 
  for(auto num=0; num< fMaxNav; ++num )
  {
    fpNavigator[num] = nullptr;   
    fLimitTruth[num] = false;
    fLimitedStep[num] = kUndefLimited;
    fCurrentStepSize[num] = fNewSafety[num] = -1.0; 
    fLocatedVolume[num] = nullptr; 
  }
 
  pTransportManager= G4TransportationManager::GetTransportationManager();
 
  G4Navigator* massNav= pTransportManager->GetNavigatorForTracking();
  if( massNav != nullptr )
  { 
    G4VPhysicalVolume* pWorld= massNav->GetWorldVolume(); 
    if( pWorld != nullptr )
    { 
      SetWorldVolume( pWorld ); 
      fLastMassWorld = pWorld; 
    }
  }
}

~G4MultiNavigator()

G4MultiNavigator::~G4MultiNavigator ( )

overridedefault

Member Function Documentation

CheckMassWorld()

void G4MultiNavigator::CheckMassWorld ( )

protected

Checks if mass world pointed has been changed => issues and exception.

Definition at line 618 of file G4MultiNavigator.cc.

{
   G4VPhysicalVolume* navTrackWorld =
     pTransportManager->GetNavigatorForTracking()->GetWorldVolume();
 
   if( navTrackWorld != fLastMassWorld )
   { 
      G4Exception( "G4MultiNavigator::CheckMassWorld()",
                   "GeomNav0003", FatalException, 
                   "Mass world pointer has been changed." ); 
   }
}

ComputeSafety()

G4double G4MultiNavigator::ComputeSafety ( const G4ThreeVector & globalpoint, const G4double pProposedMaxLength = DBL_MAX, const G4bool keepState = false )

overridevirtual

Calculates the isotropic distance to the nearest boundary in any geometry from the specified point in the global coordinates system.

Note

The geometry must be closed.

Parameters

[in]	globalpoint	The point in global coordinates system. The point must be within the current volume.
[in]	pProposedMaxLength	The proposed maximum length is used to avoid volume safety calculations.
[in]	keepState	Flag to instruct keeping the state (default false) to ensure minimum side effects from the call.

Returns

Length from current point to closest boundary surface. The value returned is usually an underestimate.

Reimplemented from G4Navigator.

Definition at line 407 of file G4MultiNavigator.cc.

{
    // Recompute safety for the relevant point
 
    G4double minSafety = kInfinity, safety = kInfinity;
  
    std::vector<G4Navigator*>::iterator pNavigatorIter;
    pNavigatorIter= pTransportManager-> GetActiveNavigatorsIterator();
 
    for( auto num=0; num< fNoActiveNavigators; ++pNavigatorIter,++num )
    {
       safety = (*pNavigatorIter)->ComputeSafety( position, maxDistance, state);
       if( safety < minSafety ) { minSafety = safety; } 
    } 
 
    fSafetyLocation = position;
    fMinSafety_atSafLocation = minSafety;
 
#ifdef G4DEBUG_NAVIGATION
    if( fVerbose > 1 )
    { 
      G4cout << " G4MultiNavigator::ComputeSafety - returns: " 
             << minSafety << ", at location: " << position << G4endl;
    }
#endif
    return minSafety; 
}

ComputeStep()

G4double G4MultiNavigator::ComputeStep ( const G4ThreeVector & pGlobalPoint, const G4ThreeVector & pDirection, const G4double pCurrentProposedStepLength, G4double & pNewSafety )

overridevirtual

Computes the distance to the next boundary of any geometry.

Parameters

[in]	pGlobalPoint	The point in global coordinates system.
[in]	pDirection	The normalised vector direction.
[in]	pCurrentProposedStepLength	Current proposed step length.
[in,out]	newSafety	New safety.

Returns

Length from current point to next boundary surface along pDirection.

Reimplemented from G4Navigator.

Definition at line 74 of file G4MultiNavigator.cc.

{
  G4double safety= 0.0, step=0.0;
  G4double minSafety= kInfinity, minStep= kInfinity;
 
  fNoLimitingStep= -1; 
  fIdNavLimiting= -1;     // Reset for new step
 
#ifdef G4DEBUG_NAVIGATION
  if( fVerbose > 2 )
  {
    G4cout << " G4MultiNavigator::ComputeStep : entered " << G4endl;
    G4cout << "   Input position= " << pGlobalPoint
           << "   direction= "      << pDirection         << G4endl;
    G4cout << "   Requested step= " << proposedStepLength << G4endl;
  }
#endif
 
  std::vector<G4Navigator*>::iterator pNavigatorIter;
 
  pNavigatorIter= pTransportManager-> GetActiveNavigatorsIterator();
 
  G4ThreeVector initialPosition = pGlobalPoint;
  G4ThreeVector initialDirection= pDirection;
 
  for( auto num=0; num< fNoActiveNavigators; ++pNavigatorIter,++num )
  {
     safety= kInfinity;
 
     step= (*pNavigatorIter)->ComputeStep( initialPosition, 
                                           initialDirection,
                                           proposedStepLength,
                                           safety ); 
     if( safety < minSafety ){ minSafety = safety; } 
     if( step < minStep )    { minStep= step; } 
 
     fCurrentStepSize[num] = step; 
     fNewSafety[num]= safety; 
      // This is currently the safety from the last sub-step
 
#ifdef G4DEBUG_NAVIGATION
     if( fVerbose > 2 )
     {
       G4cout << "G4MultiNavigator::ComputeStep : Navigator ["
              << num << "] -- step size " << step
              << " safety= " << safety << G4endl;
     }
#endif
  } 
 
  // Save safety value, related position
  //
  fPreStepLocation     = initialPosition; 
  fMinSafety_PreStepPt = minSafety;
  fMinStep = minStep; 
 
  if( fMinStep == kInfinity )
  {
     fTrueMinStep = proposedStepLength;   //  Use this below for endpoint !!
  }
  else
  {
     fTrueMinStep = minStep;
  }
 
#ifdef G4DEBUG_NAVIGATION
  if( fVerbose > 1 )
  {
    G4ThreeVector endPosition = initialPosition+fTrueMinStep*initialDirection;
 
    G4int oldPrec = G4cout.precision(8); 
    G4cout << "G4MultiNavigator::ComputeStep : "
           << " initialPosition = " << initialPosition 
           << " and endPosition = " << endPosition << G4endl;
    G4cout.precision( oldPrec );
  }
#endif
 
  pNewSafety = minSafety; 
 
  this->WhichLimited(); 
 
#ifdef G4DEBUG_NAVIGATION
  if( fVerbose > 2 )
  {
    G4cout << " G4MultiNavigator::ComputeStep : exits returning "
           << minStep << G4endl;
  }
#endif
 
  return minStep;  // must return kInfinity if do not limit step
}

CreateTouchableHistoryHandle()

G4TouchableHandle G4MultiNavigator::CreateTouchableHistoryHandle ( ) const

overridevirtual

Returns a reference counted handle to a touchable history.

Reimplemented from G4Navigator.

Definition at line 439 of file G4MultiNavigator.cc.

{
  G4Exception( "G4MultiNavigator::CreateTouchableHistoryHandle()", 
               "GeomNav0001", FatalException,  
               "Getting a touchable from G4MultiNavigator is not defined."); 
 
  G4TouchableHistory* touchHist;
  touchHist= fpNavigator[0] -> CreateTouchableHistory(); 
 
  G4VPhysicalVolume* locatedVolume= fLocatedVolume[0]; 
  if( locatedVolume == nullptr )
  {
    // Workaround to ensure that the touchable is fixed !! // TODO: fix
    //
    touchHist->UpdateYourself( locatedVolume, touchHist->GetHistory() );
  }
    
  return {touchHist}; 
}

GetGlobalExitNormal()

G4ThreeVector G4MultiNavigator::GetGlobalExitNormal ( const G4ThreeVector & point, G4bool * obtained )

overridevirtual

Obtains the Normal vector to a surface (in global coordinates) pointing out of previous volume and into current volume The method takes full care about how to calculate the normal, but if the surfaces are not convex it will return valid=false.

Parameters

[in]	point	Point in global coordinates system to compare to.
[in,out]	obtained	Flag indicating if normal is valid.

Returns

A Exit Surface Normal vector and validity too.

Reimplemented from G4Navigator.

Definition at line 672 of file G4MultiNavigator.cc.

{
  G4ThreeVector normalGlobalCrd(0.0, 0.0, 0.0); 
  G4bool isObtained = false; 
  // These default values will be used if fNoLimitingStep== 0
  G4int firstNavigatorId = -1;
  G4bool oneObtained = false;
    
  if( fNoLimitingStep == 1 )
  { 
    // Only message the Navigator which limited the step!
    normalGlobalCrd = fpNavigator[ fIdNavLimiting ]
                    ->GetGlobalExitNormal( argPoint, &isObtained ); 
    *argpObtained = isObtained; 
  }
  else 
  {
    if( fNoLimitingStep > 1 )
    { 
      auto pNavIter= pTransportManager->GetActiveNavigatorsIterator(); 
 
      for ( auto num = 0; num < fNoActiveNavigators ; ++pNavIter, ++num )
      {
        G4ThreeVector oneNormal;
        if( fLimitTruth[ num ] )  // Did this geometry limit the step ? 
        { 
          G4ThreeVector newNormal =
            (*pNavIter)->GetGlobalExitNormal( argPoint, &oneObtained );
          if( oneObtained )
          {
            // Keep first one - only if it is valid (ie not null)
            if( !isObtained && (newNormal.mag2() != 0.0) )
            {
              normalGlobalCrd = newNormal; 
              isObtained = oneObtained;
              firstNavigatorId = num; 
            }
            else
            {
              // Check for clash
              G4double dotNewPrevious = newNormal.dot( normalGlobalCrd );
              G4double productMagSq = normalGlobalCrd.mag2()*newNormal.mag2(); 
              if( productMagSq > 0.0 ) 
              {
                G4double productMag = std::sqrt( productMagSq ); 
                dotNewPrevious /= productMag; // Normalise
                if( dotNewPrevious < (1 - perThousand) ) 
                {
                  *argpObtained = false; 
 
                  if( fVerbose > 2 )  //  dotNewPrevious <= 0.0 )
                  {
                    std::ostringstream message;
                    message << "Clash of Normal from different Navigators!"
                            << G4endl
                            << "        Previous Navigator Id = "
                            << firstNavigatorId << G4endl
                            << "        Current  Navigator Id = "
                            << num << G4endl;
                    message << "  Dot product of 2 normals = "
                            << dotNewPrevious << G4endl;
                    message << "        Normal (previous) = "
                            << normalGlobalCrd << G4endl;
                    message << "        Normal (current)  = " << newNormal       << G4endl;
                    G4Exception("G4MultiNavigator::GetGlobalExitNormal()",
                                "GeomNav0002", JustWarning, message); 
                  }
                }
                else
                {
                  // Close agreement - Do not change 
                }
              }
            }
          }
        }
      } // end for over the Navigators
 
      // Report if no Normal was obtained
      if( !oneObtained ) 
      {
        std::ostringstream message;
        message << "No Normal obtained despite having " << fNoLimitingStep
                << " candidate Navigators limiting the step!" << G4endl;
        G4Exception("G4MultiNavigator::GetGlobalExitNormal()", "GeomNav0002",
                    JustWarning, message); 
      }
 
    } // end if ( fNoLimiting > 1 ) 
  } // end else
 
  *argpObtained = isObtained;
  return normalGlobalCrd;
}

GetLocalExitNormal()

G4ThreeVector G4MultiNavigator::GetLocalExitNormal ( G4bool * obtained )

overridevirtual

Obtains the Normal vector to a surface (in local coordinates) pointing out of previous volume and into current volume Convention: the local normal is in the coordinate system of the final volume. The method takes full care about how to calculate this normal, but if the surfaces are not convex it will return valid=false.

Parameters

[in,out]

obtained

Flag indicating if normal is valid.

Returns

A Exit Surface Normal vector and validity too.

Reimplemented from G4Navigator.

Definition at line 771 of file G4MultiNavigator.cc.

{
  // If it is the mass navigator, then expect
  G4ThreeVector normalGlobalCrd(0.0, 0.0, 0.0); 
  G4bool isObtained = false; 
  // These default values will be used if fNoLimitingStep== 0
 
  if( fNoLimitingStep == 1 )
  { 
    // Only message the Navigator which limited the step!
    normalGlobalCrd = fpNavigator[ fIdNavLimiting ]
                    ->GetLocalExitNormal( &isObtained ); 
    *argpObtained = isObtained;
 
    static G4ThreadLocal G4int numberWarnings = 0;
    G4int noWarningsStart = 10, noModuloWarnings = 100; 
    ++numberWarnings; 
    if( (numberWarnings < noWarningsStart )
     || (numberWarnings%noModuloWarnings == 0) ) 
    {
      std::ostringstream message;
      message << "Cannot obtain normal in local coordinates of two or more "
              << "coordinate systems." << G4endl;
      G4Exception("G4MultiNavigator::GetGlobalExitNormal()", "GeomNav0002",
                  JustWarning, message);       
    }
  }
  else
  {
    if( fNoLimitingStep > 1 ) 
    {
      std::ostringstream message;
      message << "Cannot obtain normal in local coordinates of two or more "
              << "coordinate systems." << G4endl;
      G4Exception("G4MultiNavigator::GetGlobalExitNormal()", "GeomNav0002",
                  FatalException, message);       
    }
  }
    
  *argpObtained = isObtained;
  return normalGlobalCrd; 
}

Referenced by GetLocalExitNormalAndCheck().

GetLocalExitNormalAndCheck()

G4ThreeVector G4MultiNavigator::GetLocalExitNormalAndCheck ( const G4ThreeVector & point, G4bool * obtained )

overridevirtual

Obtains the Normal vector to a surface (in local coordinates) pointing out of previous volume and into current volume, and checks the current point against expected 'local' value. Convention: the local normal is in the coordinate system of the final volume. The method takes full care about how to calculate this normal, but if the surfaces are not convex it will return valid=false.

Parameters

[in]	point	Point in global coordinates system to compare to.
[in,out]	obtained	Flag indicating if normal is valid.

Returns

A Exit Surface Normal vector and validity too.

Reimplemented from G4Navigator.

Definition at line 817 of file G4MultiNavigator.cc.

{
  return G4MultiNavigator::GetLocalExitNormal( obtained );
}

GetNavigator()

G4Navigator * G4MultiNavigator::GetNavigator ( G4int n ) const

inline

Returns a pointer to a navigator, given its index.

Definition at line 286 of file G4MultiNavigator.hh.

{ 
  if( (n>fNoActiveNavigators) || (n<0) ) { n=0; }
  return fpNavigator[n]; 
}

LocateGlobalPointAndSetup()

G4VPhysicalVolume * G4MultiNavigator::LocateGlobalPointAndSetup ( const G4ThreeVector & point, const G4ThreeVector * direction = nullptr, const G4bool pRelativeSearch = true, const G4bool ignoreDirection = true )

overridevirtual

Locates the point in all geometries. Maintains a vector of other volumes, to be returned separately.

Note

In order to call this the geometry MUST be closed.

Parameters

[in]	point	The point in global coordinates system.
[in]	direction	The normalised vector direction.
[in]	pRelativeSearch	Flag to specify where search starts from.
[in]	ignoreDirection	Flag to specify if to use direction or not.

Returns

The volume in the first (mass) geometry.

Reimplemented from G4Navigator.

Definition at line 297 of file G4MultiNavigator.cc.

{
  // Locate the point in each geometry
 
  G4ThreeVector direction(0.0, 0.0, 0.0);
  G4bool relative = pRelativeSearch; 
  auto pNavIter = pTransportManager->GetActiveNavigatorsIterator(); 
 
  if( pDirection != nullptr ) { direction = *pDirection; }
 
#ifdef G4DEBUG_NAVIGATION
  if( fVerbose > 2 )
  {
    G4cout << " Entered G4MultiNavigator::LocateGlobalPointAndSetup() "
           << G4endl;
    G4cout << "   Locating at position: " << position
           << ", with direction: " << direction << G4endl
           << "   Relative: " << relative 
           << ", ignore direction: " << ignoreDirection << G4endl;
    G4cout << "   Number of active navigators: " << fNoActiveNavigators
           << G4endl;
  }
#endif
 
  for ( auto num=0; num< fNoActiveNavigators ; ++pNavIter,++num )
  {
     if( fWasLimitedByGeometry && fLimitTruth[num] )
     { 
        (*pNavIter)->SetGeometricallyLimitedStep(); 
     }
 
     G4VPhysicalVolume *pLocated
       = (*pNavIter)->LocateGlobalPointAndSetup( position, &direction,
                                                 relative, ignoreDirection );   
     // Set the state related to the location
     //
     fLocatedVolume[num] = pLocated; 
 
     // Clear state related to the step
     //
     fLimitedStep[num]   = kDoNot; 
     fCurrentStepSize[num] = 0.0;      
     fLimitTruth[ num ] = false;   // Always clear on locating (see Navigator)
    
#ifdef G4DEBUG_NAVIGATION
     if( fVerbose > 2 )
     {
       G4cout << " Located in world: " << num << ", at: " << position << G4endl
              << " Used geomLimStp: " << fLimitTruth[num]
              << ", found in volume: " << pLocated << G4endl; 
       G4cout << " Name = '" ;       
       if( pLocated )
       { 
         G4cout << pLocated->GetName() << "'"; 
         G4cout << " - CopyNo= " << pLocated->GetCopyNo(); 
       }
       else
       { 
         G4cout <<  "Null'   Id: Not-Set "; 
       }
       G4cout << G4endl; 
     }
#endif
  }
 
  fWasLimitedByGeometry = false;   // Clear on locating
  G4VPhysicalVolume* volMassLocated = fLocatedVolume[0]; 
 
  return volMassLocated;
}

Referenced by PrepareNewTrack(), and ResetHierarchyAndLocate().

LocateGlobalPointWithinVolume()

void G4MultiNavigator::LocateGlobalPointWithinVolume ( const G4ThreeVector & position )

overridevirtual

Relocates in all geometries for point that has not changed volume, i.e. is within safety in all geometries or its distance is less that along the direction of a computed step.

Parameters

[in]

position

The position point in global coordinates system.

Reimplemented from G4Navigator.

Definition at line 374 of file G4MultiNavigator.cc.

{
  // Relocate the point in each geometry
 
  auto pNavIter = pTransportManager->GetActiveNavigatorsIterator(); 
 
#ifdef G4DEBUG_NAVIGATION
  if( fVerbose > 2 )
  {
    G4cout << " Entered G4MultiNavigator::ReLocate() " << G4endl
           << "  Re-locating at position: " << position  << G4endl; 
  }
#endif
 
  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;   // Always clear on locating (see Navigator)
  }
  fWasLimitedByGeometry = false;   // Clear on locating
  fLastLocatedPosition  = position; 
}

ObtainFinalStep()

G4double G4MultiNavigator::ObtainFinalStep	(	G4int	navigatorId,
		G4double &	pNewSafety,
		G4double &	minStepLast,
		ELimited &	limitedStep )

Gets values for a single geometry.

Parameters

[in]	navigatorId	The navigator identifier.
[in,out]	pnewSafety	New safety for this geometry.
[in,out]	minStepLast	The last minimum step returned.
[in,out]	limitedStep	The step characterisation returned.

Returns

The step size for the geometry associated to 'navigatorId'.

Definition at line 173 of file G4MultiNavigator.cc.

{
  if( navigatorId > fNoActiveNavigators )
  { 
     std::ostringstream message;
     message << "Bad Navigator Id!" << G4endl
             << "        Navigator Id = " << navigatorId 
             << "        No Active = " << fNoActiveNavigators << ".";
     G4Exception("G4MultiNavigator::ObtainFinalStep()", "GeomNav0002",
                 FatalException, message); 
  }
 
  // Prepare the information to return
  //
  pNewSafety  = fNewSafety[ navigatorId ]; 
  limitedStep = fLimitedStep[ navigatorId ];
  minStep= fMinStep; 
 
#ifdef G4DEBUG_NAVIGATION
  if( fVerbose > 1 )
  { 
     G4cout << " G4MultiNavigator::ComputeStep returns "
            << fCurrentStepSize[ navigatorId ]
            << " for Navigator " << navigatorId
            << " Limited step = " << limitedStep 
            << " Safety(mm) = " << pNewSafety / mm << G4endl; 
  }
#endif
 
  return fCurrentStepSize[ navigatorId ];
}

PrepareNavigators()

void G4MultiNavigator::PrepareNavigators

(

)

Finds which geometries are registered for this particles, and keeps info.

Definition at line 231 of file G4MultiNavigator.cc.

{
  // Key purposes:
  //   - Check and cache set of active navigators
  //   - Reset state for new track
 
#ifdef G4DEBUG_NAVIGATION
  if( fVerbose > 1 )
  {
    G4cout << " Entered G4MultiNavigator::PrepareNavigators() " << G4endl;
  }
#endif
 
  // Message the transportation-manager to find active navigators
 
  std::vector<G4Navigator*>::const_iterator pNavigatorIter; 
  fNoActiveNavigators = (G4int)pTransportManager-> GetNoActiveNavigators();
 
  if( fNoActiveNavigators > fMaxNav )
  {
    std::ostringstream message;
    message << "Too many active Navigators / worlds !" << G4endl
            << "        Active Navigators (worlds): "
            << fNoActiveNavigators << G4endl
            << "        which is more than the number allowed: "
            << fMaxNav << " !";
    G4Exception("G4MultiNavigator::PrepareNavigators()", "GeomNav0002",  
                FatalException, message); 
  }
 
  pNavigatorIter= pTransportManager->GetActiveNavigatorsIterator();
  for( auto num=0; num< fNoActiveNavigators; ++pNavigatorIter,++num )
  {
     fpNavigator[num] = *pNavigatorIter;   
     fLimitTruth[num] = false;
     fLimitedStep[num] = kDoNot;
     fCurrentStepSize[num] = 0.0; 
     fLocatedVolume[num] = nullptr; 
  }
  fWasLimitedByGeometry = false; 
 
  // Check the world volume of the mass navigator
  // in case a call to SetWorldVolume() changed it
 
  G4VPhysicalVolume* massWorld = GetWorldVolume();
 
  if( (massWorld != fLastMassWorld) && (massWorld!=nullptr) )
  { 
     // Pass along change to Mass Navigator
     fpNavigator[0] -> SetWorldVolume( massWorld );
 
#ifdef G4DEBUG_NAVIGATION
     if( fVerbose > 0 )
     { 
       G4cout << " G4MultiNavigator::PrepareNavigators() changed world volume " 
              << " for mass geometry to " << massWorld->GetName() << G4endl; 
     }
#endif
 
     fLastMassWorld = massWorld;
  }
}

Referenced by PrepareNewTrack().

PrepareNewTrack()

void G4MultiNavigator::PrepareNewTrack	(	const G4ThreeVector &	position,
		const G4ThreeVector	direction )

Prepares Navigators and locates.

Parameters

[in]	position	The position point in global coordinates system.
[in]	direction	The normalised vector direction.

Definition at line 210 of file G4MultiNavigator.cc.

{
#ifdef G4DEBUG_NAVIGATION
  if( fVerbose > 1 )
  {
    G4cout << " Entered G4MultiNavigator::PrepareNewTrack() " << G4endl;
  }
#endif
 
  G4MultiNavigator::PrepareNavigators(); 
 
  LocateGlobalPointAndSetup( position, &direction, false, false );   
  //
  // The first location for each Navigator must be non-relative
  // or else call ResetStackAndState() for each Navigator
  // Use direction to get correct side of boundary (ignore dir= false)
}

PrintLimited()

void G4MultiNavigator::PrintLimited ( )

protected

Auxiliary, debugging printing.

Definition at line 520 of file G4MultiNavigator.cc.

{
  // Report results -- for checking   
 
  static const G4String StrDoNot("DoNot"), StrUnique("Unique"),
                  StrUndefined("Undefined"),
                  StrSharedTransport("SharedTransport"),
                  StrSharedOther("SharedOther");
  G4cout << "### G4MultiNavigator::PrintLimited() reports: " << G4endl;
  G4cout << "    Minimum step (true): " << fTrueMinStep 
         << ", reported min: " << fMinStep << G4endl; 
 
#ifdef G4DEBUG_NAVIGATION
  if(fVerbose>=2)
  {
    G4cout << std::setw(5) << " NavId"  << " "
           << std::setw(12) << " step-size " << " "
           << std::setw(12) << " raw-size "  << " "
           << std::setw(12) << " pre-safety " << " " 
           << std::setw(15) << " Limited / flag"  << " "
           << std::setw(15) << "  World "  << " "
           << G4endl;  
  }
#endif
 
  for ( auto num = 0; num < fNoActiveNavigators; ++num )
  { 
    G4double rawStep = fCurrentStepSize[num]; 
    G4double stepLen = fCurrentStepSize[num]; 
    if( stepLen > fTrueMinStep )
    { 
      stepLen = fTrueMinStep;     // did not limit (went as far as asked)
    }
    G4long oldPrec = G4cout.precision(9); 
 
    G4cout << std::setw(5) << num  << " "
           << std::setw(12) << stepLen << " "
           << std::setw(12) << rawStep << " "
           << std::setw(12) << fNewSafety[num] << " "
           << std::setw(5) << (fLimitTruth[num] ? "YES" : " NO") << " ";
    G4String limitedStr;
    switch ( fLimitedStep[num] )
    {
      case kDoNot          : limitedStr = StrDoNot; break;
      case kUnique         : limitedStr = StrUnique; break; 
      case kSharedTransport: limitedStr = StrSharedTransport; break; 
      case kSharedOther    : limitedStr = StrSharedOther; break;
      default              : limitedStr = StrUndefined; break;
    }
    G4cout << " " << std::setw(15) << limitedStr << " ";  
    G4cout.precision(oldPrec); 
 
    G4Navigator *pNav = fpNavigator[ num ]; 
    G4String  WorldName( "Not-Set" ); 
    if (pNav != nullptr)
    {
       G4VPhysicalVolume *pWorld = pNav->GetWorldVolume(); 
       if( pWorld != nullptr )
       {
           WorldName = pWorld->GetName(); 
       }
    }
    G4cout << " " << WorldName ; 
    G4cout << G4endl;
  }
}

ResetHierarchyAndLocate()

G4VPhysicalVolume * G4MultiNavigator::ResetHierarchyAndLocate ( const G4ThreeVector & point, const G4ThreeVector & direction, const G4TouchableHistory & h )

overridevirtual

Resets the geometrical hierarchy for all geometries. Use the touchable history for the first (mass) geometry.

Note

In order to call this the geometries MUST be closed.

Parameters

[in]	point	The point in global coordinates system.
[in]	direction	The normalised vector direction.
[in]	h	The touchable history to be used for initialisation.

Returns

The pointer to the volume in the first (mass) geometry.

Reimplemented from G4Navigator.

Definition at line 634 of file G4MultiNavigator.cc.

{
   // Reset geometry for all -- and use the touchable for the mass history
 
   G4VPhysicalVolume* massVolume = nullptr; 
   G4Navigator* pMassNavigator = fpNavigator[0]; 
 
   if( pMassNavigator != nullptr )
   {
      massVolume= pMassNavigator->ResetHierarchyAndLocate( point, direction,
                                                           MassHistory); 
   }
   else
   {
      G4Exception("G4MultiNavigator::ResetHierarchyAndLocate()",
                  "GeomNav0002", FatalException,
                  "Cannot reset hierarchy before navigators are initialised.");
   }
 
   auto pNavIter= pTransportManager->GetActiveNavigatorsIterator(); 
 
   for ( auto num = 0; num < fNoActiveNavigators ; ++pNavIter,++num )
   {
      G4bool relativeSearch, ignoreDirection; 
 
      (*pNavIter)-> LocateGlobalPointAndSetup( point, 
                                               &direction, 
                                               relativeSearch=false,
                                               ignoreDirection=false);
   }
   return massVolume; 
}

ResetState()

void G4MultiNavigator::ResetState ( )

overrideprotectedvirtual

Utility method to reset the navigator state machine.

Reimplemented from G4Navigator.

Definition at line 590 of file G4MultiNavigator.cc.

{
   fWasLimitedByGeometry = false; 
 
   G4Exception("G4MultiNavigator::ResetState()", "GeomNav0001",  
               FatalException,  
               "Cannot reset state for navigators of G4MultiNavigator.");
/*
   std::vector<G4Navigator*>::iterator pNavigatorIter;
   pNavigatorIter = pTransportManager->GetActiveNavigatorsIterator();
   for( auto num = 0; num< fNoActiveNavigators; ++pNavigatorIter,++num )
   {
       //  (*pNavigatorIter)->ResetState();  // KEEP THIS comment !!!
   }
*/
}

SetupHierarchy()

void G4MultiNavigator::SetupHierarchy ( )

overrideprotectedvirtual

Renavigates & resets hierarchy described by the current history, i.e. resets volumes and recomputes transforms and/or solids of replicated/parameterised volumes.

Reimplemented from G4Navigator.

Definition at line 609 of file G4MultiNavigator.cc.

{
  G4Exception( "G4MultiNavigator::SetupHierarchy()", 
               "GeomNav0001", FatalException,  
               "Cannot setup hierarchy for navigators of G4MultiNavigator."); 
}

WhichLimited()

void G4MultiNavigator::WhichLimited ( )

protected

Flags which processes limited the step.

Definition at line 461 of file G4MultiNavigator.cc.

{
  // Flag which processes limited the step
 
  G4int last=-1; 
  const G4int IdTransport= 0;  // Id of Mass Navigator !!
  G4int noLimited=0; 
  ELimited shared= kSharedOther; 
 
#ifdef G4DEBUG_NAVIGATION
  if( fVerbose > 2 )
  {
    G4cout << " Entered G4MultiNavigator::WhichLimited() " << G4endl;
  }
#endif
 
  // Assume that [IdTransport] is Mass / Transport
  // 
  G4bool transportLimited = (fCurrentStepSize[IdTransport] == fMinStep)
                         && ( fMinStep!= kInfinity); 
  if( transportLimited )
  { 
     shared = kSharedTransport;
  }
 
  for ( auto num = 0; num < fNoActiveNavigators; ++num )
  { 
    G4bool limitedStep;
 
    G4double step = fCurrentStepSize[num]; 
 
    limitedStep = ( step == fMinStep ) && ( step != kInfinity); 
   
    fLimitTruth[ num ] = limitedStep; 
    if( limitedStep )
    {
      ++noLimited;  
      fLimitedStep[num] = shared;
      last= num; 
    }
    else
    {
      fLimitedStep[num] = kDoNot;
    }
  }
  if( (last > -1) && (noLimited == 1 ) )
  {
    fLimitedStep[ last ] = kUnique;
    fIdNavLimiting = last;
  }
 
  fNoLimitingStep = noLimited;  
 
  return;
}

Referenced by ComputeStep().

Friends And Related Symbol Documentation

operator<<

std::ostream & operator<< ( std::ostream & os, const G4Navigator & n )

friend

Definition at line 2013 of file G4Navigator.cc.

{
  //  Old version did only the following:
  // os << "Current History: " << G4endl << n.fHistory;
  //  Old behaviour is recovered for fVerbose = 0
  
  // Adapted from G4Navigator::PrintState() const
 
  G4long oldcoutPrec = os.precision(4);
  if( n.fVerbose >= 4 )
  {
    os << "The current state of G4Navigator is: " << G4endl;
    os << "  ValidExitNormal= " << n.fValidExitNormal << G4endl
    << "  ExitNormal     = " << n.fExitNormal      << G4endl
    << "  Exiting        = " << n.fExiting         << G4endl
    << "  Entering       = " << n.fEntering        << G4endl
    << "  BlockedPhysicalVolume= " ;
    if (n.fBlockedPhysicalVolume==nullptr)
    {
      os << "None";
    }
    else
    {
      os << n.fBlockedPhysicalVolume->GetName();
    }
    os << G4endl
    << "  BlockedReplicaNo     = " <<  n.fBlockedReplicaNo       << G4endl
    << "  LastStepWasZero      = " <<   n.fLastStepWasZero       << G4endl
    << G4endl;
  }
  if( ( 1 < n.fVerbose) && (n.fVerbose < 4) )
  {
    os << G4endl; // Make sure to line up
    os << std::setw(30) << " ExitNormal "  << " "
    << std::setw( 5) << " Valid "       << " "
    << std::setw( 9) << " Exiting "     << " "
    << std::setw( 9) << " Entering"     << " "
    << std::setw(15) << " Blocked:Volume "  << " "
    << std::setw( 9) << " ReplicaNo"        << " "
    << std::setw( 8) << " LastStepZero  "   << " "
    << G4endl;
    os << "( " << std::setw(7) << n.fExitNormal.x()
    << ", " << std::setw(7) << n.fExitNormal.y()
    << ", " << std::setw(7) << n.fExitNormal.z() << " ) "
    << std::setw( 5)  << n.fValidExitNormal  << " "
    << std::setw( 9)  << n.fExiting          << " "
    << std::setw( 9)  << n.fEntering         << " ";
    if ( n.fBlockedPhysicalVolume==nullptr )
      { os << std::setw(15) << "None"; }
    else
      { os << std::setw(15)<< n.fBlockedPhysicalVolume->GetName(); }
    os << std::setw( 9)  << n.fBlockedReplicaNo  << " "
    << std::setw( 8)  << n.fLastStepWasZero   << " "
    << G4endl;
  }
  if( n.fVerbose > 2 )
  {
    os.precision(8);
    os << " Current Localpoint = " << n.fLastLocatedPointLocal << G4endl;
    os << " PreviousSftOrigin  = " << n.fPreviousSftOrigin << G4endl;
    os << " PreviousSafety     = " << n.fPreviousSafety << G4endl;
  }
  if( n.fVerbose > 3 || n.fVerbose == 0 )
  {
    os << "Current History: " << G4endl << n.fHistory;
  }
    
  os.precision(oldcoutPrec);
  return os;
}

---

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

• G4MultiNavigator.hh
• G4MultiNavigator.cc