#include <G4MultiNavigator.hh>

Inheritance diagram for G4MultiNavigator:

Public Member Functions
	G4MultiNavigator ()

	~G4MultiNavigator ()

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

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)

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

void	LocateGlobalPointWithinVolume (const G4ThreeVector &position)

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

G4TouchableHistoryHandle	CreateTouchableHistoryHandle () const

virtual G4ThreeVector	GetLocalExitNormal (G4bool *obtained)

virtual G4ThreeVector	GetLocalExitNormalAndCheck (const G4ThreeVector &CurrentE_Point, G4bool *obtained)

virtual G4ThreeVector	GetGlobalExitNormal (const G4ThreeVector &CurrentE_Point, G4bool *obtained)

G4Navigator *	GetNavigator (G4int n) const

Public Member Functions inherited from G4Navigator
	G4Navigator ()

virtual	~G4Navigator ()

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

G4double	CheckNextStep (const G4ThreeVector &pGlobalPoint, const G4ThreeVector &pDirection, const G4double pCurrentProposedStepLength, G4double &pNewSafety)

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

virtual G4VPhysicalVolume *	LocateGlobalPointAndSetup (const G4ThreeVector &point, const G4ThreeVector *direction=0, const G4bool pRelativeSearch=true, const G4bool ignoreDirection=true)

virtual void	LocateGlobalPointWithinVolume (const G4ThreeVector &position)

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 ()

virtual G4double	ComputeSafety (const G4ThreeVector &globalpoint, const G4double pProposedMaxLength=DBL_MAX, const G4bool keepState=true)

G4VPhysicalVolume *	GetWorldVolume () const

void	SetWorldVolume (G4VPhysicalVolume *pWorld)

G4GRSVolume *	CreateGRSVolume () const

G4GRSSolid *	CreateGRSSolid () const

G4TouchableHistory *	CreateTouchableHistory () const

G4TouchableHistory *	CreateTouchableHistory (const G4NavigationHistory *) const

virtual G4TouchableHistoryHandle	CreateTouchableHistoryHandle () const

virtual G4ThreeVector	GetLocalExitNormal (G4bool *valid)

virtual G4ThreeVector	GetLocalExitNormalAndCheck (const G4ThreeVector &point, G4bool *valid)

virtual G4ThreeVector	GetGlobalExitNormal (const G4ThreeVector &point, G4bool *valid)

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)

Protected Member Functions
void	ResetState ()

void	SetupHierarchy ()

void	WhichLimited ()

void	PrintLimited ()

void	CheckMassWorld ()

Protected Member Functions inherited from G4Navigator
void	SetSavedState ()

void	RestoreSavedState ()

virtual void	ResetState ()

G4ThreeVector	ComputeLocalPoint (const G4ThreeVector &rGlobPoint) const

G4ThreeVector	ComputeLocalAxis (const G4ThreeVector &pVec) const

EVolume	VolumeType (const G4VPhysicalVolume *pVol) const

EVolume	CharacteriseDaughters (const G4LogicalVolume *pLog) const

G4int	GetDaughtersRegularStructureId (const G4LogicalVolume *pLog) const

virtual void	SetupHierarchy ()

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

Additional Inherited Members
Protected Attributes inherited from G4Navigator
G4double	kCarTolerance

G4NavigationHistory	fHistory

G4bool	fEnteredDaughter

G4bool	fExitedMother

G4bool	fWasLimitedByGeometry

G4ThreeVector	fStepEndPoint

G4ThreeVector	fLastStepEndPointLocal

G4int	fVerbose

Detailed Description

Definition at line 59 of file G4MultiNavigator.hh.

Constructor & Destructor Documentation

◆ G4MultiNavigator()

G4MultiNavigator::G4MultiNavigator ( )

Definition at line 50 of file G4MultiNavigator.cc.

  : G4Navigator(), fLastMassWorld(0)
{
  fNoActiveNavigators= 0; 
  G4ThreeVector Big3Vector( kInfinity, kInfinity, kInfinity ); 
  fLastLocatedPosition = Big3Vector;
  fSafetyLocation  = Big3Vector;
  fPreStepLocation = Big3Vector;
 
  fMinSafety_PreStepPt=  -1.0; 
  fMinSafety_atSafLocation= -1.0; 
  fMinSafety= -kInfinity;  
  fTrueMinStep= fMinStep= -kInfinity;  
 
  for(register int num=0; num< fMaxNav; ++num )
  {
    fpNavigator[num] =  0;   
    fLimitTruth[num] = false;
    fLimitedStep[num] = kUndefLimited;
    fCurrentStepSize[num] = fNewSafety[num] = -1.0; 
    fLocatedVolume[num] = 0; 
  }
 
  pTransportManager= G4TransportationManager::GetTransportationManager();
 
  G4Navigator* massNav= pTransportManager->GetNavigatorForTracking();
  if( massNav )
  { 
    G4VPhysicalVolume* pWorld= massNav->GetWorldVolume(); 
    if( pWorld )
    { 
      SetWorldVolume( pWorld ); 
      fLastMassWorld = pWorld; 
    }
  }
 
  fNoLimitingStep= -1; 
  fIdNavLimiting= -1; 
}

◆ ~G4MultiNavigator()

G4MultiNavigator::~G4MultiNavigator ( )

Definition at line 90 of file G4MultiNavigator.cc.

91{

92}

Member Function Documentation

◆ CheckMassWorld()

void G4MultiNavigator::CheckMassWorld ( )

protected

Definition at line 639 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`
	)

virtual

Reimplemented from G4Navigator.

Definition at line 429 of file G4MultiNavigator.cc.

{
    // Recompute safety for the relevant point
 
    G4double minSafety = kInfinity, safety = kInfinity;
  
    std::vector<G4Navigator*>::iterator pNavigatorIter;
    pNavigatorIter= pTransportManager-> GetActiveNavigatorsIterator();
 
    for( register int 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
	)

virtual

Reimplemented from G4Navigator.

Definition at line 94 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( register int 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()

G4TouchableHistoryHandle G4MultiNavigator::CreateTouchableHistoryHandle ( ) const

virtual

Reimplemented from G4Navigator.

Definition at line 462 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 == 0 )
  {
    // Workaround to ensure that the touchable is fixed !! // TODO: fix
    //
    touchHist->UpdateYourself( locatedVolume, touchHist->GetHistory() );
  }
    
  return G4TouchableHistoryHandle(touchHist); 
}

◆ GetGlobalExitNormal()

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

virtual

Reimplemented from G4Navigator.

Definition at line 694 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 )
    { 
      std::vector<G4Navigator*>::iterator pNavIter= 
        pTransportManager->GetActiveNavigatorsIterator(); 
 
      for ( register int num=0; num< fNoActiveNavigators ; ++pNavIter,++num )
      {
        G4ThreeVector oneNormal;
        if( fLimitedStep[ num ] ) 
        { 
          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;
}

Referenced by GetGlobalExitNormal().

◆ GetLocalExitNormal()

G4ThreeVector G4MultiNavigator::GetLocalExitNormal ( G4bool * obtained )

virtual

Reimplemented from G4Navigator.

Definition at line 785 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;
 
    G4int static 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 ) 
    {
        // Does not make sense - cannot obtain *local* normal in several coordinate systems
        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 &	CurrentE_Point,
		G4bool *	obtained
	)

virtual

Reimplemented from G4Navigator.

Definition at line 829 of file G4MultiNavigator.cc.

{
  return G4MultiNavigator::GetLocalExitNormal( obtained);
}

◆ GetNavigator()

G4Navigator * G4MultiNavigator::GetNavigator ( G4int n ) const

inline

Definition at line 141 of file G4MultiNavigator.hh.

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

◆ LocateGlobalPointAndSetup()

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

virtual

Reimplemented from G4Navigator.

Definition at line 317 of file G4MultiNavigator.cc.

{
  // Locate the point in each geometry
 
  G4ThreeVector direction(0.0, 0.0, 0.0);
  G4bool relative = pRelativeSearch; 
  std::vector<G4Navigator*>::iterator pNavIter
    = pTransportManager->GetActiveNavigatorsIterator(); 
 
  if( pDirection ) { 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 ( register int 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 )

virtual

Reimplemented from G4Navigator.

Definition at line 395 of file G4MultiNavigator.cc.

{
  // Relocate the point in each geometry
 
  std::vector<G4Navigator*>::iterator pNavIter
    = pTransportManager->GetActiveNavigatorsIterator(); 
 
#ifdef G4DEBUG_NAVIGATION
  if( fVerbose > 2 )
  {
    G4cout << " Entered G4MultiNavigator::ReLocate() " << G4endl
           << "  Re-locating at position: " << position  << G4endl; 
  }
#endif
 
  for ( register int 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
	)

Definition at line 193 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 ];
}

Referenced by G4PathFinder::DoNextCurvedStep().

◆ PrepareNavigators()

void G4MultiNavigator::PrepareNavigators ( )

Definition at line 251 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*>::iterator pNavigatorIter; 
  fNoActiveNavigators=  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( register int num=0; num< fNoActiveNavigators; ++pNavigatorIter,++num )
  {
     fpNavigator[num] =  *pNavigatorIter;   
     fLimitTruth[num] = false;
     fLimitedStep[num] = kDoNot;
     fCurrentStepSize[num] = 0.0; 
     fLocatedVolume[num] = 0; 
  }
  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!=0) )
  { 
     // 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 G4PathFinder::PrepareNewTrack(), and PrepareNewTrack().

◆ PrepareNewTrack()

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

Definition at line 230 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

Definition at line 542 of file G4MultiNavigator.cc.

{
  // Report results -- for checking   
 
  static 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 ( register int 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)
    }
    G4int 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)
    {
       G4VPhysicalVolume *pWorld= pNav->GetWorldVolume(); 
       if( pWorld )
       {
           WorldName = pWorld->GetName(); 
       }
    }
    G4cout << " " << WorldName ; 
    G4cout << G4endl;
  }
}

◆ ResetHierarchyAndLocate()

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

virtual

Reimplemented from G4Navigator.

Definition at line 655 of file G4MultiNavigator.cc.

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

◆ ResetState()

void G4MultiNavigator::ResetState ( )

protectedvirtual

Reimplemented from G4Navigator.

Definition at line 612 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( register int num=0; num< fNoActiveNavigators; ++pNavigatorIter,++num )
   {
       //  (*pNavigatorIter)->ResetState();  // KEEP THIS comment !!!
   } 
}

◆ SetupHierarchy()

void G4MultiNavigator::SetupHierarchy ( )

protectedvirtual

Reimplemented from G4Navigator.

Definition at line 630 of file G4MultiNavigator.cc.

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

◆ WhichLimited()

void G4MultiNavigator::WhichLimited ( )

protected

Definition at line 484 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 ( register int 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; 
  }
 
  fNoLimitingStep= noLimited;  
 
  return;
}

Referenced by ComputeStep().

Friends And Related Function Documentation

◆ operator<<

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

friend

Definition at line 1960 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
 
  G4int 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==0)
      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==0 )
      { 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:

Public Member Functions

Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4MultiNavigator()

◆ ~G4MultiNavigator()

Member Function Documentation

◆ CheckMassWorld()

◆ ComputeSafety()

◆ ComputeStep()

◆ CreateTouchableHistoryHandle()

◆ GetGlobalExitNormal()

◆ GetLocalExitNormal()

◆ GetLocalExitNormalAndCheck()

◆ GetNavigator()

◆ LocateGlobalPointAndSetup()

◆ LocateGlobalPointWithinVolume()

◆ ObtainFinalStep()

◆ PrepareNavigators()

◆ PrepareNewTrack()

◆ PrintLimited()

◆ ResetHierarchyAndLocate()

◆ ResetState()

◆ SetupHierarchy()

◆ WhichLimited()

Friends And Related Function Documentation

◆ operator<<