#include <G4ITMultiNavigator.hh>

Inheritance diagram for G4ITMultiNavigator:

Collaboration diagram for G4ITMultiNavigator:

Public Member Functions
	G4ITMultiNavigator ()

	~G4ITMultiNavigator ()

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)

G4ITNavigator *	GetNavigator (G4int n) const

Public Member Functions inherited from G4TrackStateDependent< G4ITMultiNavigator >
virtual	~G4TrackStateDependent ()

virtual void	SetTrackState (G4shared_ptr< StateType > state)

virtual G4VTrackStateHandle	PopTrackState ()

virtual G4VTrackStateHandle	GetTrackState () const

virtual StateTypeHandle	GetConcreteTrackState () const

virtual void	LoadTrackState (G4TrackStateManager &manager)

virtual void	SaveTrackState (G4TrackStateManager &manager)

virtual void	NewTrackState ()

virtual StateTypeHandle	CreateTrackState () const

virtual void	ResetTrackState ()

Public Member Functions inherited from G4VTrackStateDependent
	G4VTrackStateDependent ()

virtual	~G4VTrackStateDependent ()

Protected Member Functions
void	ResetState ()

void	SetupHierarchy ()

void	WhichLimited ()

void	PrintLimited ()

void	CheckMassWorld ()

Protected Member Functions inherited from G4TrackStateDependent< G4ITMultiNavigator >
	G4TrackStateDependent ()

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

Additional Inherited Members
Public Types inherited from G4TrackStateDependent< G4ITMultiNavigator >
typedef G4ITMultiNavigator	ClassType

typedef G4TrackState < G4ITMultiNavigator >	StateType

typedef G4shared_ptr< StateType >	StateTypeHandle

Protected Attributes inherited from G4TrackStateDependent< G4ITMultiNavigator >
StateTypeHandle	fpTrackState

Detailed Description

Definition at line 144 of file G4ITMultiNavigator.hh.

Constructor & Destructor Documentation

G4ITMultiNavigator::G4ITMultiNavigator ( )

Definition at line 68 of file G4ITMultiNavigator.cc.

   : G4ITNavigator(), fLastMassWorld(0)
 {
   fNoActiveNavigators= 0; 
 
   for(G4int num=0; num< fMaxNav; ++num )
   {
     fpNavigator[num] =  0;   
   }
 
   pTransportManager= G4ITTransportationManager::GetTransportationManager();
 
   G4ITNavigator* massNav= pTransportManager->GetNavigatorForTracking();
   if( massNav )
   { 
     G4VPhysicalVolume* pWorld= massNav->GetWorldVolume(); 
     if( pWorld )
     { 
       SetWorldVolume( pWorld ); 
       fLastMassWorld = pWorld; 
     }
   }
 }

Here is the call graph for this function:

G4ITMultiNavigator::~G4ITMultiNavigator ( )

Definition at line 92 of file G4ITMultiNavigator.cc.

93 {

94 }

Member Function Documentation

void G4ITMultiNavigator::CheckMassWorld ( )

protected

Definition at line 641 of file G4ITMultiNavigator.cc.

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

Here is the call graph for this function:

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

Definition at line 431 of file G4ITMultiNavigator.cc.

 {
     // Recompute safety for the relevant point
 
     G4double minSafety = kInfinity, safety = kInfinity;
   
     std::vector<G4ITNavigator*>::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 << " G4ITMultiNavigator::ComputeSafety - returns: "
              << minSafety << ", at location: " << position << G4endl;
     }
 #endif
     return minSafety; 
 }

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

Definition at line 96 of file G4ITMultiNavigator.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 << " G4ITMultiNavigator::ComputeStep : entered " << G4endl;
     G4cout << "   Input position= " << pGlobalPoint
            << "   direction= "      << pDirection         << G4endl;
     G4cout << "   Requested step= " << proposedStepLength << G4endl;
   }
 #endif
 
   std::vector<G4ITNavigator*>::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 << "G4ITMultiNavigator::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 << "G4ITMultiNavigator::ComputeStep : "
            << " initialPosition = " << initialPosition 
            << " and endPosition = " << endPosition << G4endl;
     G4cout.precision( oldPrec );
   }
 #endif
 
   pNewSafety = minSafety; 
 
   this->WhichLimited(); 
 
 #ifdef G4DEBUG_NAVIGATION
   if( fVerbose > 2 )
   {
     G4cout << " G4ITMultiNavigator::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 G4ITMultiNavigator::CreateTouchableHistoryHandle ( ) const

Definition at line 464 of file G4ITMultiNavigator.cc.

 {
   G4Exception( "G4ITMultiNavigator::CreateTouchableHistoryHandle()",
                "GeomNav0001", FatalException,  
                "Getting a touchable from G4ITMultiNavigator 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 G4ITMultiNavigator::GetGlobalExitNormal	(	const G4ThreeVector &	CurrentE_Point,
		G4bool *	obtained
	)

virtual

Definition at line 696 of file G4ITMultiNavigator.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<G4ITNavigator*>::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("G4ITMultiNavigator::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("G4ITMultiNavigator::GetGlobalExitNormal()", "GeomNav0002",
                     JustWarning, message); 
       }
 
     } // end if ( fNoLimiting > 1 ) 
   } // end else
 
   *argpObtained= isObtained;
   return normalGlobalCrd;
 }

Here is the call graph for this function:

G4ThreeVector G4ITMultiNavigator::GetLocalExitNormal ( G4bool * obtained )

virtual

Definition at line 787 of file G4ITMultiNavigator.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("G4ITMultiNavigator::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("G4ITMultiNavigator::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 G4ITMultiNavigator::GetLocalExitNormalAndCheck	(	const G4ThreeVector &	CurrentE_Point,
		G4bool *	obtained
	)

virtual

Definition at line 831 of file G4ITMultiNavigator.cc.

 {
   return G4ITMultiNavigator::GetLocalExitNormal( obtained);
 }

Here is the call graph for this function:

G4ITNavigator* G4ITMultiNavigator::GetNavigator ( G4int n ) const

inline

Definition at line 230 of file G4ITMultiNavigator.hh.

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

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

Definition at line 319 of file G4ITMultiNavigator.cc.

 {
   // Locate the point in each geometry
 
   G4ThreeVector direction(0.0, 0.0, 0.0);
   G4bool relative = pRelativeSearch; 
   std::vector<G4ITNavigator*>::iterator pNavIter
     = pTransportManager->GetActiveNavigatorsIterator(); 
 
   if( pDirection ) { direction = *pDirection; }
 
 #ifdef G4DEBUG_NAVIGATION
   if( fVerbose > 2 )
   {
     G4cout << " Entered G4ITMultiNavigator::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 G4ITMultiNavigator::LocateGlobalPointWithinVolume ( const G4ThreeVector & position )

Definition at line 397 of file G4ITMultiNavigator.cc.

 {
   // Relocate the point in each geometry
 
   std::vector<G4ITNavigator*>::iterator pNavIter
     = pTransportManager->GetActiveNavigatorsIterator(); 
 
 #ifdef G4DEBUG_NAVIGATION
   if( fVerbose > 2 )
   {
     G4cout << " Entered G4ITMultiNavigator::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 G4ITMultiNavigator::ObtainFinalStep	(	G4int	navigatorId,
		G4double &	pNewSafety,
		G4double &	minStepLast,
		ELimited &	limitedStep
	)

Definition at line 195 of file G4ITMultiNavigator.cc.

 {
   if( navigatorId > fNoActiveNavigators )
   { 
      std::ostringstream message;
      message << "Bad Navigator Id!" << G4endl
              << "        Navigator Id = " << navigatorId 
              << "        No Active = " << fNoActiveNavigators << ".";
      G4Exception("G4ITMultiNavigator::ObtainFinalStep()", "GeomNav0002",
                  FatalException, message); 
   }
 
   // Prepare the information to return
   //
   pNewSafety  = fNewSafety[ navigatorId ]; 
   limitedStep = fLimitedStep[ navigatorId ];
   minStep= fMinStep; 
 
 #ifdef G4DEBUG_NAVIGATION
   if( fVerbose > 1 )
   { 
      G4cout << " G4ITMultiNavigator::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 G4ITMultiNavigator::PrepareNavigators ( )

Definition at line 253 of file G4ITMultiNavigator.cc.

 {
   // Key purposes:
   //   - Check and cache set of active navigators
   //   - Reset state for new track
 
 #ifdef G4DEBUG_NAVIGATION
   if( fVerbose > 1 )
   {
     G4cout << " Entered G4ITMultiNavigator::PrepareNavigators() " << G4endl;
   }
 #endif
 
   // Message the transportation-manager to find active navigators
 
   std::vector<G4ITNavigator*>::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("G4ITMultiNavigator::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 << " G4ITMultiNavigator::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 G4ITMultiNavigator::PrepareNewTrack	(	const G4ThreeVector	position,
		const G4ThreeVector	direction
	)

Definition at line 232 of file G4ITMultiNavigator.cc.

 {
 #ifdef G4DEBUG_NAVIGATION
   if( fVerbose > 1 )
   {
     G4cout << " Entered G4ITMultiNavigator::PrepareNewTrack() " << G4endl;
   }
 #endif
 
   G4ITMultiNavigator::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 G4ITMultiNavigator::PrintLimited ( )

protected

Definition at line 544 of file G4ITMultiNavigator.cc.

 {
   // Report results -- for checking   
 
   static const G4String StrDoNot("DoNot"), StrUnique("Unique"),
                   StrUndefined("Undefined"),
                   StrSharedTransport("SharedTransport"),
                   StrSharedOther("SharedOther");
   G4cout << "### G4ITMultiNavigator::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); 
 
     G4ITNavigator *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 * G4ITMultiNavigator::ResetHierarchyAndLocate	(	const G4ThreeVector &	point,
		const G4ThreeVector &	direction,
		const G4TouchableHistory &	h
	)

Definition at line 657 of file G4ITMultiNavigator.cc.

 {
    // Reset geometry for all -- and use the touchable for the mass history
 
    G4VPhysicalVolume* massVolume=0; 
    G4ITNavigator* pMassNavigator= fpNavigator[0];
 
    if( pMassNavigator )
    {
       massVolume= pMassNavigator->ResetHierarchyAndLocate( point, direction,
                                                            MassHistory); 
    }
    else
    {
       G4Exception("G4ITMultiNavigator::ResetHierarchyAndLocate()",
                   "GeomNav0002", FatalException,
                   "Cannot reset hierarchy before navigators are initialised.");
    }
 
    std::vector<G4ITNavigator*>::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 G4ITMultiNavigator::ResetState ( )

protected

Definition at line 614 of file G4ITMultiNavigator.cc.

 {
    fWasLimitedByGeometry= false; 
 
    G4Exception("G4ITMultiNavigator::ResetState()", "GeomNav0001",
                FatalException,  
                "Cannot reset state for navigators of G4ITMultiNavigator.");
    
    std::vector<G4ITNavigator*>::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 G4ITMultiNavigator::SetupHierarchy ( )

protected

Definition at line 632 of file G4ITMultiNavigator.cc.

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

Here is the call graph for this function:

void G4ITMultiNavigator::WhichLimited ( )

protected

Definition at line 486 of file G4ITMultiNavigator.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 G4ITMultiNavigator::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; 
   }
 
   fNoLimitingStep= noLimited;  
 
   return;
 }

Here is the caller graph for this function:

Friends And Related Function Documentation

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

friend

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

geant4.10.03.p01/source/processes/electromagnetic/dna/management/include/G4ITMultiNavigator.hh
geant4.10.03.p01/source/processes/electromagnetic/dna/management/src/G4ITMultiNavigator.cc

Public Member Functions

Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation