#include <G4MultiNavigator.hh>

Inheritance diagram for G4MultiNavigator:

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

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

virtual G4bool	RecheckDistanceToCurrentBoundary (const G4ThreeVector &pGlobalPoint, const G4ThreeVector &pDirection, const G4double CurrentProposedStepLength, G4double prDistance, G4double prNewSafety=0) const

G4VPhysicalVolume *	GetWorldVolume () const

void	SetWorldVolume (G4VPhysicalVolume *pWorld)

G4GRSVolume *	CreateGRSVolume () const

G4GRSSolid *	CreateGRSSolid () const

G4TouchableHistory *	CreateTouchableHistory () const

G4TouchableHistory *	CreateTouchableHistory (const G4NavigationHistory *) 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)

Protected Member Functions
void	ResetState ()

void	SetupHierarchy ()

void	WhichLimited ()

void	PrintLimited ()

void	CheckMassWorld ()

Protected Member Functions inherited from G4Navigator
void	SetSavedState ()

void	RestoreSavedState ()

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

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

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

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(G4int 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; 
 }

Here is the call graph for this function:

G4MultiNavigator::~G4MultiNavigator ( )

Definition at line 90 of file G4MultiNavigator.cc.

91 {

92 }

Member Function Documentation

void G4MultiNavigator::CheckMassWorld ( )

protected

Definition at line 640 of file G4MultiNavigator.cc.

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

Here is the call graph for this function:

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( G4int 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; 
 }

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( G4int 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
 }

Here is the call graph for this function:

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); 
 }

Here is the call graph for this function:

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

virtual

Reimplemented from G4Navigator.

Definition at line 695 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 ( G4int 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;
 }

Here is the call graph for this function:

G4ThreeVector G4MultiNavigator::GetLocalExitNormal ( G4bool * obtained )

virtual

Reimplemented from G4Navigator.

Definition at line 786 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 ) 
     {
         // 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; 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

Reimplemented from G4Navigator.

Definition at line 830 of file G4MultiNavigator.cc.

 {
   return G4MultiNavigator::GetLocalExitNormal( obtained);
 }

Here is the call graph for this function:

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]; 
   }

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 ( G4int 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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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 ( G4int 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; 
 }

Here is the call graph for this function:

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 ];
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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( G4int 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;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

void G4MultiNavigator::PrintLimited ( )

protected

Definition at line 543 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 ( G4int 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;
   }
 }

Here is the call graph for this function:

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

virtual

Reimplemented from G4Navigator.

Definition at line 656 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 ( G4int num=0; num< fNoActiveNavigators ; ++pNavIter,++num )
    {
       G4bool relativeSearch, ignoreDirection; 
 
       (*pNavIter)-> LocateGlobalPointAndSetup( point, 
                                                &direction, 
                                                relativeSearch=false,
                                                ignoreDirection=false);
    }
    return massVolume; 
 }

Here is the call graph for this function:

void G4MultiNavigator::ResetState ( )

protectedvirtual

Reimplemented from G4Navigator.

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

Here is the call graph for this function:

void G4MultiNavigator::SetupHierarchy ( )

protectedvirtual

Reimplemented from G4Navigator.

Definition at line 631 of file G4MultiNavigator.cc.

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

Here is the call graph for this function:

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 ( G4int 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;
 }

Here is the caller graph for this function:

Friends And Related Function Documentation

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

friend

Definition at line 2250 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:

geant4.10.03.p01/source/geometry/navigation/include/G4MultiNavigator.hh
geant4.10.03.p01/source/geometry/navigation/src/G4MultiNavigator.cc

Public Member Functions

Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation