G4ITMultiNavigator Class Reference

#include <G4ITMultiNavigator.hh>

Inheritance 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 ()
virtual void	NewTrackState ()=0
virtual void	LoadTrackState (G4TrackStateManager &)=0
virtual void	SaveTrackState (G4TrackStateManager &)=0
virtual G4VTrackStateHandle	GetTrackState () const =0
virtual G4VTrackStateHandle	PopTrackState ()=0
virtual void	ResetTrackState ()=0

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 143 of file G4ITMultiNavigator.hh.

Constructor & Destructor Documentation

G4ITMultiNavigator()

G4ITMultiNavigator::G4ITMultiNavigator

(

)

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

~G4ITMultiNavigator()

G4ITMultiNavigator::~G4ITMultiNavigator

(

)

Definition at line 91 of file G4ITMultiNavigator.cc.

{
}

Member Function Documentation

CheckMassWorld()

void G4ITMultiNavigator::CheckMassWorld ( )

protected

Definition at line 640 of file G4ITMultiNavigator.cc.

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

ComputeSafety()

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

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

ComputeStep()

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

Definition at line 95 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
}

CreateTouchableHistoryHandle()

G4TouchableHistoryHandle G4ITMultiNavigator::CreateTouchableHistoryHandle

(

)

const

Definition at line 463 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); 
}

GetGlobalExitNormal()

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

virtual

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

Referenced by GetGlobalExitNormal().

GetLocalExitNormal()

G4ThreeVector G4ITMultiNavigator::GetLocalExitNormal ( G4bool *  obtained )

virtual

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

Referenced by GetLocalExitNormalAndCheck().

GetLocalExitNormalAndCheck()

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

virtual

Definition at line 830 of file G4ITMultiNavigator.cc.

{
  return G4ITMultiNavigator::GetLocalExitNormal( obtained);
}

GetNavigator()

G4ITNavigator * G4ITMultiNavigator::GetNavigator ( G4int  n ) const

inline

Definition at line 229 of file G4ITMultiNavigator.hh.

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

LocateGlobalPointAndSetup()

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

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

Referenced by PrepareNewTrack(), and ResetHierarchyAndLocate().

LocateGlobalPointWithinVolume()

void G4ITMultiNavigator::LocateGlobalPointWithinVolume

(

const G4ThreeVector &

position

)

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

ObtainFinalStep()

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

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

Referenced by G4ITPathFinder::DoNextCurvedStep().

PrepareNavigators()

void G4ITMultiNavigator::PrepareNavigators

(

)

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

Referenced by G4ITPathFinder::PrepareNewTrack(), and PrepareNewTrack().

PrepareNewTrack()

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

Definition at line 231 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)
}

PrintLimited()

void G4ITMultiNavigator::PrintLimited ( )

protected

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

ResetHierarchyAndLocate()

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

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

ResetState()

void G4ITMultiNavigator::ResetState ( )

protected

Definition at line 613 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 !!!
   } 
}

SetupHierarchy()

void G4ITMultiNavigator::SetupHierarchy ( )

protected

Definition at line 631 of file G4ITMultiNavigator.cc.

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

WhichLimited()

void G4ITMultiNavigator::WhichLimited ( )

protected

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

Referenced by ComputeStep().

Friends And Related Function Documentation

operator<<

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

friend

---

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

• G4ITMultiNavigator.hh
• G4ITMultiNavigator.cc