#include <G4MultiNavigator.hh>

Inheritance diagram for G4MultiNavigator:

Public Member Functions
void	Activate (G4bool flag)

void	CheckMode (G4bool mode)

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

G4Navigator *	Clone () const

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

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

G4GRSSolid *	CreateGRSSolid () const

G4GRSVolume *	CreateGRSVolume () const

G4TouchableHistory *	CreateTouchableHistory () const

G4TouchableHistory *	CreateTouchableHistory (const G4NavigationHistory *) const

G4TouchableHistoryHandle	CreateTouchableHistoryHandle () const

void	EnableBestSafety (G4bool value=false)

G4bool	EnteredDaughterVolume () const

G4bool	ExitedMotherVolume () const

	G4MultiNavigator ()

G4ThreeVector	GetCurrentLocalCoordinate () const

G4VExternalNavigation *	GetExternalNavigation () const

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

const G4AffineTransform &	GetGlobalToLocalTransform () const

G4ThreeVector	GetLastStepEndPoint () const

virtual G4ThreeVector	GetLocalExitNormal (G4bool *obtained)

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

const G4AffineTransform	GetLocalToGlobalTransform () const

G4AffineTransform	GetMotherToDaughterTransform (G4VPhysicalVolume *dVolume, G4int dReplicaNo, EVolume dVolumeType)

G4Navigator *	GetNavigator (G4int n) const

G4int	GetVerboseLevel () const

G4VPhysicalVolume *	GetWorldVolume () const

void	InformLastStep (G4double lastStep, G4bool entersDaughtVol, G4bool exitsMotherVol)

G4bool	IsActive () const

G4bool	IsCheckModeActive () const

G4VPhysicalVolume *	LocateGlobalPointAndSetup (const G4ThreeVector &point, const G4ThreeVector *direction=nullptr, const G4bool pRelativeSearch=true, const G4bool ignoreDirection=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	LocateGlobalPointAndUpdateTouchableHandle (const G4ThreeVector &position, const G4ThreeVector &direction, G4TouchableHandle &oldTouchableToUpdate, const G4bool RelativeSearch=true)

void	LocateGlobalPointWithinVolume (const G4ThreeVector &position)

G4RotationMatrix	NetRotation () const

G4ThreeVector	NetTranslation () const

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

void	PrepareNavigators ()

void	PrepareNewTrack (const G4ThreeVector position, const G4ThreeVector direction)

void	PrintState () const

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

void	ResetStackAndState ()

void	SetExternalNavigation (G4VExternalNavigation *externalNav)

void	SetGeometricallyLimitedStep ()

void	SetPushVerbosity (G4bool mode)

void	SetVerboseLevel (G4int level)

void	SetVoxelNavigation (G4VoxelNavigation *voxelNav)

void	SetWorldVolume (G4VPhysicalVolume *pWorld)

G4int	SeverityOfZeroStepping (G4int *noZeroSteps) const

	~G4MultiNavigator ()

Protected Member Functions
EVolume	CharacteriseDaughters (const G4LogicalVolume *pLog) const

void	CheckMassWorld ()

G4bool	CheckOverlapsIterative (G4VPhysicalVolume *vol)

G4ThreeVector	ComputeLocalAxis (const G4ThreeVector &pVec) const

G4ThreeVector	ComputeLocalPoint (const G4ThreeVector &rGlobPoint) const

G4int	GetDaughtersRegularStructureId (const G4LogicalVolume *pLv) const

void	PrintLimited ()

void	ResetState ()

void	RestoreSavedState ()

void	SetSavedState ()

void	SetupHierarchy ()

EVolume	VolumeType (const G4VPhysicalVolume *pVol) const

void	WhichLimited ()

Protected Attributes
G4bool	fEnteredDaughter

G4bool	fExitedMother

G4NavigationHistory	fHistory

G4ThreeVector	fLastStepEndPointLocal

G4double	fSqTol

G4ThreeVector	fStepEndPoint

G4int	fVerbose = 0

G4bool	fWasLimitedByGeometry = false

G4double	kCarTolerance

Private Member Functions
void	ComputeStepLog (const G4ThreeVector &pGlobalpoint, G4double moveLenSq) const

G4VoxelNavigation &	GetVoxelNavigator ()

Private Attributes
G4int	fAbandonThreshold_NoZeroSteps = 25

G4int	fActionThreshold_NoZeroSteps = 10

G4bool	fActive = false

G4VPhysicalVolume *	fBlockedPhysicalVolume

G4int	fBlockedReplicaNo

G4bool	fCalculatedExitNormal

G4bool	fChangedGrandMotherRefFrame

G4bool	fCheck = false

G4double	fCurrentStepSize [fMaxNav]

G4bool	fEntering

G4bool	fExiting

G4ThreeVector	fExitNormal

G4ThreeVector	fExitNormalGlobalFrame

G4ThreeVector	fGrandMotherExitNormal

G4int	fIdNavLimiting = -1

G4ThreeVector	fLastLocatedPointLocal

G4ThreeVector	fLastLocatedPosition

G4VPhysicalVolume *	fLastMassWorld = nullptr

G4VPhysicalVolume *	fLastMotherPhys = nullptr

G4bool	fLastStepWasZero

G4bool	fLastTriedStepComputation = false

ELimited	fLimitedStep [fMaxNav]

G4bool	fLimitTruth [fMaxNav]

G4bool	fLocatedOnEdge

G4bool	fLocatedOutsideWorld

G4VPhysicalVolume *	fLocatedVolume [fMaxNav]

G4double	fMinSafety = -kInfinity

G4double	fMinSafety_atSafLocation = -1.0

G4double	fMinSafety_PreStepPt = -1.0

G4double	fMinStep = -kInfinity

G4double	fNewSafety [fMaxNav]

G4int	fNoActiveNavigators = 0

G4int	fNoLimitingStep = -1

G4NormalNavigation	fnormalNav

G4int	fNumberZeroSteps

G4ParameterisedNavigation	fparamNav

G4VExternalNavigation *	fpExternalNav = nullptr

G4Navigator *	fpNavigator [fMaxNav]

G4ThreeVector	fPreStepLocation

G4double	fPreviousSafety

G4ThreeVector	fPreviousSftOrigin

G4bool	fPushed = false

G4VoxelNavigation *	fpvoxelNav

G4VoxelSafety *	fpVoxelSafety

G4RegularNavigation	fregularNav

G4ReplicaNavigation	freplicaNav

G4ThreeVector	fSafetyLocation

struct G4Navigator::G4SaveNavigatorState	fSaveState

G4VPhysicalVolume *	fTopPhysical = nullptr

G4double	fTrueMinStep = -kInfinity

G4bool	fValidExitNormal

G4bool	fWarnPush = true

G4TransportationManager *	pTransportManager

Static Private Attributes
static const G4int	fMaxNav = 16

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

Detailed Description

Definition at line 54 of file G4MultiNavigator.hh.

Constructor & Destructor Documentation

◆ G4MultiNavigator()

G4MultiNavigator::G4MultiNavigator ( )

Definition at line 46 of file G4MultiNavigator.cc.

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

References fCurrentStepSize, fLastLocatedPosition, fLastMassWorld, fLimitedStep, fLimitTruth, fLocatedVolume, fMaxNav, fNewSafety, fpNavigator, fPreStepLocation, fSafetyLocation, G4TransportationManager::GetNavigatorForTracking(), G4TransportationManager::GetTransportationManager(), G4Navigator::GetWorldVolume(), kInfinity, kUndefLimited, pTransportManager, and G4Navigator::SetWorldVolume().

◆ ~G4MultiNavigator()

G4MultiNavigator::~G4MultiNavigator ( )

Definition at line 77 of file G4MultiNavigator.cc.

78{

79}

Member Function Documentation

◆ Activate()

void G4Navigator::Activate ( G4bool flag )

inlineinherited

Referenced by G4TransportationManager::ActivateNavigator(), and G4TransportationManager::G4TransportationManager().

◆ CharacteriseDaughters()

EVolume G4Navigator::CharacteriseDaughters ( const G4LogicalVolume * pLog ) const

inlineprotectedinherited

Referenced by G4Navigator::ComputeSafety(), G4Navigator::ComputeStep(), G4Navigator::LocateGlobalPointAndSetup(), and G4Navigator::LocateGlobalPointWithinVolume().

◆ CheckMassWorld()

void G4MultiNavigator::CheckMassWorld ( )

protected

Definition at line 628 of file G4MultiNavigator.cc.

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

References FatalException, fLastMassWorld, G4Exception(), G4TransportationManager::GetNavigatorForTracking(), G4Navigator::GetWorldVolume(), and pTransportManager.

◆ CheckMode()

void G4Navigator::CheckMode ( G4bool mode )

inlineinherited

Referenced by G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck().

◆ CheckNextStep()

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

inherited

Definition at line 1255 of file G4Navigator.cc.

{
  G4double step;
 
  // Save the state, for this parasitic call
  //
  SetSavedState();
 
  step = ComputeStep ( pGlobalpoint, 
                       pDirection,
                       pCurrentProposedStepLength, 
                       pNewSafety ); 
 
  // It is a parasitic call, so attempt to restore the key parts of the state
  //
  RestoreSavedState(); 
  // NOTE: the state of the current subnavigator is NOT restored.
  // ***> TODO: restore subnavigator state
  //            if( last_located)       Need Position of last location
  //            if( last_computed step) Need Endposition of last step
  
  return step; 
}

References G4Navigator::ComputeStep(), G4Navigator::RestoreSavedState(), and G4Navigator::SetSavedState().

Referenced by G4SafetyHelper::CheckNextStep().

◆ CheckOverlapsIterative()

G4bool G4Navigator::CheckOverlapsIterative ( G4VPhysicalVolume * vol )

protectedinherited

Definition at line 2130 of file G4Navigator.cc.

{
  // Check and report overlaps
  //
  G4bool foundOverlap = false;
  G4int  nPoints = 300000,  ntrials = 9, numOverlaps = 5;
  G4double  trialLength = 1.0 * CLHEP::centimeter;
  while ( ntrials-- > 0 && !foundOverlap )
  {
    if ( fVerbose > 1 )
    {
       G4cout << " ** Running overlap checks in volume "
              <<  vol->GetName()
              << " with length = " << trialLength << G4endl;
    }
    foundOverlap = vol->CheckOverlaps(nPoints, trialLength,
                                      fVerbose, numOverlaps);
    trialLength *= 0.1;
    if ( trialLength <= 1.0e-5 ) { numOverlaps= 1;}
  }
  return foundOverlap;
}

References CLHEP::centimeter, G4VPhysicalVolume::CheckOverlaps(), G4Navigator::fVerbose, G4cout, G4endl, and G4VPhysicalVolume::GetName().

Referenced by G4Navigator::ComputeStep().

◆ Clone()

G4Navigator * G4Navigator::Clone ( ) const

inlineinherited

Referenced by G4TransportationManager::G4TransportationManager(), and G4VIntersectionLocator::G4VIntersectionLocator().

◆ ComputeLocalAxis()

G4ThreeVector G4Navigator::ComputeLocalAxis ( const G4ThreeVector & pVec ) const

inlineprotectedinherited

Referenced by G4Navigator::ComputeStep().

◆ ComputeLocalPoint()

G4ThreeVector G4Navigator::ComputeLocalPoint ( const G4ThreeVector & rGlobPoint ) const

inlineprotectedinherited

Referenced by G4Navigator::ComputeSafety(), G4Navigator::ComputeStep(), and G4Navigator::LocateGlobalPointWithinVolume().

◆ ComputeSafety()

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

virtual

Reimplemented from G4Navigator.

Definition at line 416 of file G4MultiNavigator.cc.

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

References fMinSafety_atSafLocation, fNoActiveNavigators, fSafetyLocation, G4Navigator::fVerbose, G4cout, G4endl, kInfinity, position, and pTransportManager.

◆ ComputeStep()

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

virtual

Reimplemented from G4Navigator.

Definition at line 81 of file G4MultiNavigator.cc.

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

References fCurrentStepSize, fIdNavLimiting, fMinSafety_PreStepPt, fMinStep, fNewSafety, fNoActiveNavigators, fNoLimitingStep, fPreStepLocation, fTrueMinStep, G4Navigator::fVerbose, G4cout, G4endl, kInfinity, pTransportManager, and WhichLimited().

◆ ComputeStepLog()

void G4Navigator::ComputeStepLog	(	const G4ThreeVector &	pGlobalpoint,
		G4double	moveLenSq
	)		const

privateinherited

Definition at line 2027 of file G4Navigator.cc.

{
  //  The following checks only make sense if the move is larger
  //  than the tolerance.
 
  const G4double fAccuracyForWarning   = kCarTolerance,
                 fAccuracyForException = 1000*kCarTolerance;
 
  G4ThreeVector OriginalGlobalpoint = fHistory.GetTopTransform().
                               InverseTransformPoint(fLastLocatedPointLocal); 
 
  G4double shiftOriginSafSq = (fPreviousSftOrigin-pGlobalpoint).mag2();
 
  // Check that the starting point of this step is 
  // within the isotropic safety sphere of the last point
  // to a accuracy/precision  given by fAccuracyForWarning.
  //   If so give warning.
  //   If it fails by more than fAccuracyForException exit with error.
  //
  if( shiftOriginSafSq >= sqr(fPreviousSafety) )
  {
    G4double shiftOrigin = std::sqrt(shiftOriginSafSq);
    G4double diffShiftSaf = shiftOrigin - fPreviousSafety;
 
    if( diffShiftSaf > fAccuracyForWarning )
    {
      G4int oldcoutPrec = G4cout.precision(8);
      G4int oldcerrPrec = G4cerr.precision(10);
      std::ostringstream message, suggestion;
      message << "Accuracy error or slightly inaccurate position shift."
              << G4endl
              << "     The Step's starting point has moved " 
              << std::sqrt(moveLenSq)/mm << " mm " << G4endl
              << "     since the last call to a Locate method." << G4endl
              << "     This has resulted in moving " 
              << shiftOrigin/mm << " mm " 
              << " from the last point at which the safety " 
              << "     was calculated " << G4endl
              << "     which is more than the computed safety= " 
              << fPreviousSafety/mm << " mm  at that point." << G4endl
              << "     This difference is " 
              << diffShiftSaf/mm << " mm." << G4endl
              << "     The tolerated accuracy is "
              << fAccuracyForException/mm << " mm.";
 
      suggestion << " ";
      static G4ThreadLocal G4int warnNow = 0;
      if( ((++warnNow % 100) == 1) )
      {
        message << G4endl
               << "  This problem can be due to either " << G4endl
               << "    - a process that has proposed a displacement"
               << " larger than the current safety , or" << G4endl
               << "    - inaccuracy in the computation of the safety";
        suggestion << "We suggest that you " << G4endl
                   << "   - find i) what particle is being tracked, and "
                   << " ii) through what part of your geometry " << G4endl
                   << "      for example by re-running this event with "
                   << G4endl
                   << "         /tracking/verbose 1 "  << G4endl
                   << "    - check which processes you declare for"
                   << " this particle (and look at non-standard ones)"
                   << G4endl
                   << "   - in case, create a detailed logfile"
                   << " of this event using:" << G4endl
                   << "         /tracking/verbose 6 ";
      }
      G4Exception("G4Navigator::ComputeStep()",
                  "GeomNav1002", JustWarning,
                  message, G4String(suggestion.str()));
      G4cout.precision(oldcoutPrec);
      G4cerr.precision(oldcerrPrec);
    }
#ifdef G4DEBUG_NAVIGATION
    else
    {
      G4cerr << "WARNING - G4Navigator::ComputeStep()" << G4endl
             << "          The Step's starting point has moved "
             << std::sqrt(moveLenSq) << "," << G4endl
             << "          which has taken it to the limit of"
             << " the current safety. " << G4endl;
    }
#endif
  }
  G4double safetyPlus = fPreviousSafety + fAccuracyForException;
  if ( shiftOriginSafSq > sqr(safetyPlus) )
  {
    std::ostringstream message;
    message << "May lead to a crash or unreliable results." << G4endl
            << "        Position has shifted considerably without"
            << " notifying the navigator !" << G4endl
            << "        Tolerated safety: " << safetyPlus << G4endl
            << "        Computed shift  : " << shiftOriginSafSq;
    G4Exception("G4Navigator::ComputeStep()", "GeomNav1002",
                JustWarning, message);
  }
}

References G4Navigator::fHistory, G4Navigator::fLastLocatedPointLocal, G4Navigator::fPreviousSafety, G4Navigator::fPreviousSftOrigin, G4cerr, G4cout, G4endl, G4Exception(), G4ThreadLocal, G4NavigationHistory::GetTopTransform(), JustWarning, G4Navigator::kCarTolerance, mm, and sqr().

Referenced by G4Navigator::ComputeStep().

◆ CreateGRSSolid()

G4GRSSolid * G4Navigator::CreateGRSSolid ( ) const

inlineinherited

◆ CreateGRSVolume()

G4GRSVolume * G4Navigator::CreateGRSVolume ( ) const

inlineinherited

◆ CreateTouchableHistory() [1/2]

G4TouchableHistory * G4Navigator::CreateTouchableHistory ( ) const

inlineinherited

Referenced by G4PathFinder::CreateTouchableHandle(), CreateTouchableHistoryHandle(), G4Navigator::CreateTouchableHistoryHandle(), G4VIntersectionLocator::GetLocalSurfaceNormal(), and G4SteppingManager::SetInitialStep().

◆ CreateTouchableHistory() [2/2]

G4TouchableHistory * G4Navigator::CreateTouchableHistory ( const G4NavigationHistory * ) const

inlineinherited

◆ CreateTouchableHistoryHandle()

G4TouchableHistoryHandle G4MultiNavigator::CreateTouchableHistoryHandle ( ) const

virtual

Reimplemented from G4Navigator.

Definition at line 449 of file G4MultiNavigator.cc.

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

References G4Navigator::CreateTouchableHistory(), FatalException, fLocatedVolume, fpNavigator, G4Exception(), G4TouchableHistory::GetHistory(), and G4TouchableHistory::UpdateYourself().

◆ EnableBestSafety()

void G4Navigator::EnableBestSafety ( G4bool value = false )

inlineinherited

◆ EnteredDaughterVolume()

G4bool G4Navigator::EnteredDaughterVolume ( ) const

inlineinherited

Referenced by G4Navigator::GetLocalExitNormal(), and G4Transportation::PostStepDoIt().

◆ ExitedMotherVolume()

G4bool G4Navigator::ExitedMotherVolume ( ) const

inlineinherited

Referenced by G4Transportation::PostStepDoIt().

◆ GetCurrentLocalCoordinate()

G4ThreeVector G4Navigator::GetCurrentLocalCoordinate ( ) const

inlineinherited

◆ GetDaughtersRegularStructureId()

G4int G4Navigator::GetDaughtersRegularStructureId ( const G4LogicalVolume * pLv ) const

inlineprotectedinherited

Referenced by G4Navigator::ComputeSafety(), G4Navigator::ComputeStep(), G4Navigator::LocateGlobalPointAndSetup(), and G4Navigator::LocateGlobalPointWithinVolume().

◆ GetExternalNavigation()

G4VExternalNavigation * G4Navigator::GetExternalNavigation ( ) const

inlineinherited

Referenced by G4TransportationManager::G4TransportationManager(), and G4VIntersectionLocator::G4VIntersectionLocator().

◆ GetGlobalExitNormal()

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

virtual

Reimplemented from G4Navigator.

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

References CLHEP::Hep3Vector::dot(), fIdNavLimiting, fLimitTruth, fNoActiveNavigators, fNoLimitingStep, fpNavigator, G4Navigator::fVerbose, G4endl, G4Exception(), G4TransportationManager::GetActiveNavigatorsIterator(), G4Navigator::GetGlobalExitNormal(), JustWarning, CLHEP::Hep3Vector::mag2(), perThousand, and pTransportManager.

◆ GetGlobalToLocalTransform()

const G4AffineTransform & G4Navigator::GetGlobalToLocalTransform ( ) const

inlineinherited

Referenced by G4Navigator::GetLocalExitNormalAndCheck(), and G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck().

◆ GetLastStepEndPoint()

G4ThreeVector G4Navigator::GetLastStepEndPoint ( ) const

inlineinherited

Definition at line 304 of file G4Navigator.hh.

304{ return fStepEndPoint;}

G4Navigator::fStepEndPoint

G4ThreeVector fStepEndPoint

Definition: G4Navigator.hh:388

References G4Navigator::fStepEndPoint.

◆ GetLocalExitNormal()

G4ThreeVector G4MultiNavigator::GetLocalExitNormal ( G4bool * obtained )

virtual

Reimplemented from G4Navigator.

Definition at line 783 of file G4MultiNavigator.cc.

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

References FatalException, fIdNavLimiting, fNoLimitingStep, fpNavigator, G4endl, G4Exception(), G4ThreadLocal, G4Navigator::GetLocalExitNormal(), and JustWarning.

Referenced by GetLocalExitNormalAndCheck().

◆ GetLocalExitNormalAndCheck()

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

virtual

Reimplemented from G4Navigator.

Definition at line 829 of file G4MultiNavigator.cc.

{
  return G4MultiNavigator::GetLocalExitNormal( obtained );
}

References GetLocalExitNormal().

◆ GetLocalToGlobalTransform()

const G4AffineTransform G4Navigator::GetLocalToGlobalTransform ( ) const

inlineinherited

Referenced by G4RayTrajectory::AppendStep(), and G4VIntersectionLocator::GetGlobalSurfaceNormal().

◆ GetMotherToDaughterTransform()

G4AffineTransform G4Navigator::GetMotherToDaughterTransform	(	G4VPhysicalVolume *	dVolume,
		G4int	dReplicaNo,
		EVolume	dVolumeType
	)

inherited

Definition at line 1555 of file G4Navigator.cc.

{
  switch (enteringVolumeType)
  {
    case kNormal:  // Nothing is needed to prepare the transformation
      break;       // It is stored already in the physical volume (placement)
    case kReplica: // Sets the transform in the Replica - tbc
      G4Exception("G4Navigator::GetMotherToDaughterTransform()",
                  "GeomNav0001", FatalException,
                  "Method NOT Implemented yet for replica volumes.");
      break;
    case kParameterised:
      if( pEnteringPhysVol->GetRegularStructureId() == 0 )
      {
        G4VPVParameterisation *pParam =
          pEnteringPhysVol->GetParameterisation();
        G4VSolid* pSolid =
          pParam->ComputeSolid(enteringReplicaNo, pEnteringPhysVol);
        pSolid->ComputeDimensions(pParam, enteringReplicaNo, pEnteringPhysVol);
 
        // Sets the transform in the Parameterisation
        //
        pParam->ComputeTransformation(enteringReplicaNo, pEnteringPhysVol);
 
        // Set the correct solid and material in Logical Volume
        //
        G4LogicalVolume* pLogical = pEnteringPhysVol->GetLogicalVolume();
        pLogical->SetSolid( pSolid );
      }
      break;
    case kExternal:
      // Expect that nothing is needed to prepare the transformation.
      // It is stored already in the physical volume (placement)
      break;
  }
  return G4AffineTransform(pEnteringPhysVol->GetRotation(), 
                           pEnteringPhysVol->GetTranslation()).Invert(); 
}

References G4VSolid::ComputeDimensions(), G4VPVParameterisation::ComputeSolid(), G4VPVParameterisation::ComputeTransformation(), FatalException, G4Exception(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetParameterisation(), G4VPhysicalVolume::GetRegularStructureId(), G4VPhysicalVolume::GetRotation(), G4VPhysicalVolume::GetTranslation(), G4AffineTransform::Invert(), kExternal, kNormal, kParameterised, kReplica, and G4LogicalVolume::SetSolid().

Referenced by G4Navigator::GetLocalExitNormal().

◆ GetNavigator()

G4Navigator * G4MultiNavigator::GetNavigator ( G4int n ) const

inline

Definition at line 136 of file G4MultiNavigator.hh.

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

References fNoActiveNavigators, fpNavigator, and CLHEP::detail::n.

◆ GetVerboseLevel()

G4int G4Navigator::GetVerboseLevel ( ) const

inlineinherited

Referenced by export_G4Navigator(), G4Navigator::GetGlobalExitNormal(), and G4ErrorPropagatorManager::StartNavigator().

◆ GetVoxelNavigator()

G4VoxelNavigation & G4Navigator::GetVoxelNavigator ( )

inlineprivateinherited

Referenced by G4Navigator::ComputeStep(), G4Navigator::LocateGlobalPointAndSetup(), and G4Navigator::LocateGlobalPointWithinVolume().

◆ GetWorldVolume()

G4VPhysicalVolume * G4Navigator::GetWorldVolume ( ) const

inlineinherited

Referenced by G4TransportationManager::ActivateNavigator(), G4ParallelGeometriesLimiterProcess::AddParallelWorld(), CheckMassWorld(), G4PropagatorInField::ComputeStep(), G4TransportationManager::DeActivateNavigator(), G4TransportationManager::DeRegisterNavigator(), export_G4Navigator(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GeometrySampler::G4GeometrySampler(), G4ImportanceConfigurator::G4ImportanceConfigurator(), G4MultiNavigator(), G4TransportationManager::G4TransportationManager(), G4TransportationManager::GetParallelWorld(), G4SafetyHelper::GetWorldVolume(), G4GeometryMessenger::Init(), G4SafetyHelper::InitialiseNavigator(), G4ITTransportationManager::Initialize(), G4FastSimulationManager::ListTitle(), G4FastSimHitMaker::make(), GFlashHitMaker::make(), PrepareNavigators(), PrintLimited(), G4PathFinder::PrintLimited(), G4IStore::SetWorldVolume(), G4WeightWindowStore::SetWorldVolume(), and G4ErrorPropagatorManager::StartNavigator().

◆ InformLastStep()

void G4Navigator::InformLastStep	(	G4double	lastStep,
		G4bool	entersDaughtVol,
		G4bool	exitsMotherVol
	)

inherited

Definition at line 2240 of file G4Navigator.cc.

{
  G4bool zeroStep = ( lastStep == 0.0 );
  fLocatedOnEdge   = fLastStepWasZero && zeroStep;  
  fLastStepWasZero = zeroStep;
 
  fExiting = exitsMotherVol;
  fEntering = entersDaughtVol;
}

References G4Navigator::fEntering, G4Navigator::fExiting, G4Navigator::fLastStepWasZero, and G4Navigator::fLocatedOnEdge.

◆ IsActive()

G4bool G4Navigator::IsActive ( ) const

inlineinherited

Referenced by export_G4Navigator().

◆ IsCheckModeActive()

G4bool G4Navigator::IsCheckModeActive ( ) const

inlineinherited

Referenced by G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck().

◆ LocateGlobalPointAndSetup()

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

virtual

Reimplemented from G4Navigator.

Definition at line 304 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 ( auto num=0; num< fNoActiveNavigators ; ++pNavIter,++num )
  {
     if( fWasLimitedByGeometry && fLimitTruth[num] )
     { 
        (*pNavIter)->SetGeometricallyLimitedStep(); 
     }
 
     G4VPhysicalVolume *pLocated
       = (*pNavIter)->LocateGlobalPointAndSetup( position, &direction,
                                                 relative, ignoreDirection );   
     // Set the state related to the location
     //
     fLocatedVolume[num] = pLocated; 
 
     // Clear state related to the step
     //
     fLimitedStep[num]   = kDoNot; 
     fCurrentStepSize[num] = 0.0;      
     fLimitTruth[ num ] = false;   // Always clear on locating (see Navigator)
    
#ifdef G4DEBUG_NAVIGATION
     if( fVerbose > 2 )
     {
       G4cout << " Located in world: " << num << ", at: " << position << G4endl
              << " Used geomLimStp: " << fLimitTruth[num]
              << ", found in volume: " << pLocated << G4endl; 
       G4cout << " Name = '" ;       
       if( pLocated )
       { 
         G4cout << pLocated->GetName() << "'"; 
         G4cout << " - CopyNo= " << pLocated->GetCopyNo(); 
       }
       else
       { 
         G4cout <<  "Null'   Id: Not-Set "; 
       }
       G4cout << G4endl; 
     }
#endif
  }
 
  fWasLimitedByGeometry = false;   // Clear on locating
  G4VPhysicalVolume* volMassLocated = fLocatedVolume[0]; 
 
  return volMassLocated;
}

References fCurrentStepSize, fLimitedStep, fLimitTruth, fLocatedVolume, fNoActiveNavigators, G4Navigator::fVerbose, G4Navigator::fWasLimitedByGeometry, G4cout, G4endl, G4TransportationManager::GetActiveNavigatorsIterator(), G4VPhysicalVolume::GetCopyNo(), G4VPhysicalVolume::GetName(), kDoNot, and pTransportManager.

Referenced by PrepareNewTrack(), and ResetHierarchyAndLocate().

◆ LocateGlobalPointAndUpdateTouchable() [1/2]

void G4Navigator::LocateGlobalPointAndUpdateTouchable	(	const G4ThreeVector &	position,
		const G4ThreeVector &	direction,
		G4VTouchable *	touchableToUpdate,
		const G4bool	RelativeSearch = `true`
	)

inlineinherited

Referenced by G4VReadOutGeometry::FindROTouchable(), and G4FastSimHitMaker::make().

◆ LocateGlobalPointAndUpdateTouchable() [2/2]

void G4Navigator::LocateGlobalPointAndUpdateTouchable	(	const G4ThreeVector &	position,
		G4VTouchable *	touchableToUpdate,
		const G4bool	RelativeSearch = `true`
	)

inlineinherited

◆ LocateGlobalPointAndUpdateTouchableHandle()

void G4Navigator::LocateGlobalPointAndUpdateTouchableHandle	(	const G4ThreeVector &	position,
		const G4ThreeVector &	direction,
		G4TouchableHandle &	oldTouchableToUpdate,
		const G4bool	RelativeSearch = `true`
	)

inlineinherited

◆ LocateGlobalPointWithinVolume()

void G4MultiNavigator::LocateGlobalPointWithinVolume ( const G4ThreeVector & position )

virtual

Reimplemented from G4Navigator.

Definition at line 382 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 ( auto num=0; num< fNoActiveNavigators ; ++pNavIter,++num )
  {
     //  ... none limited the step
 
     (*pNavIter)->LocateGlobalPointWithinVolume( position ); 
 
     // Clear state related to the step
     //
     fLimitedStep[num]     = kDoNot; 
     fCurrentStepSize[num] = 0.0;      
 
     fLimitTruth[ num ] = false;   // Always clear on locating (see Navigator)
  }
  fWasLimitedByGeometry = false;   // Clear on locating
  fLastLocatedPosition  = position; 
}

References fCurrentStepSize, fLastLocatedPosition, fLimitedStep, fLimitTruth, fNoActiveNavigators, G4Navigator::fVerbose, G4Navigator::fWasLimitedByGeometry, G4cout, G4endl, G4TransportationManager::GetActiveNavigatorsIterator(), kDoNot, position, and pTransportManager.

◆ NetRotation()

G4RotationMatrix G4Navigator::NetRotation ( ) const

inlineinherited

◆ NetTranslation()

G4ThreeVector G4Navigator::NetTranslation ( ) const

inlineinherited

◆ ObtainFinalStep()

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

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

References FatalException, fCurrentStepSize, fLimitedStep, fMinStep, fNewSafety, fNoActiveNavigators, G4Navigator::fVerbose, G4cout, G4endl, G4Exception(), and mm.

Referenced by G4PathFinder::DoNextCurvedStep().

◆ PrepareNavigators()

void G4MultiNavigator::PrepareNavigators ( )

Definition at line 238 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( auto num=0; num< fNoActiveNavigators; ++pNavigatorIter,++num )
  {
     fpNavigator[num] = *pNavigatorIter;   
     fLimitTruth[num] = false;
     fLimitedStep[num] = kDoNot;
     fCurrentStepSize[num] = 0.0; 
     fLocatedVolume[num] = nullptr; 
  }
  fWasLimitedByGeometry = false; 
 
  // Check the world volume of the mass navigator
  // in case a call to SetWorldVolume() changed it
 
  G4VPhysicalVolume* massWorld = GetWorldVolume();
 
  if( (massWorld != fLastMassWorld) && (massWorld!=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;
  }
}

References FatalException, fCurrentStepSize, fLastMassWorld, fLimitedStep, fLimitTruth, fLocatedVolume, fMaxNav, fNoActiveNavigators, fpNavigator, G4Navigator::fVerbose, G4Navigator::fWasLimitedByGeometry, G4cout, G4endl, G4Exception(), G4TransportationManager::GetActiveNavigatorsIterator(), G4VPhysicalVolume::GetName(), G4Navigator::GetWorldVolume(), kDoNot, pTransportManager, and G4Navigator::SetWorldVolume().

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

◆ PrepareNewTrack()

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

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

References G4Navigator::fVerbose, G4cout, G4endl, LocateGlobalPointAndSetup(), and PrepareNavigators().

◆ PrintLimited()

void G4MultiNavigator::PrintLimited ( )

protected

Definition at line 530 of file G4MultiNavigator.cc.

{
  // Report results -- for checking   
 
  static const G4String StrDoNot("DoNot"), StrUnique("Unique"),
                  StrUndefined("Undefined"),
                  StrSharedTransport("SharedTransport"),
                  StrSharedOther("SharedOther");
  G4cout << "### G4MultiNavigator::PrintLimited() reports: " << G4endl;
  G4cout << "    Minimum step (true): " << fTrueMinStep 
         << ", reported min: " << fMinStep << G4endl; 
 
#ifdef G4DEBUG_NAVIGATION
  if(fVerbose>=2)
  {
    G4cout << std::setw(5) << " NavId"  << " "
           << std::setw(12) << " step-size " << " "
           << std::setw(12) << " raw-size "  << " "
           << std::setw(12) << " pre-safety " << " " 
           << std::setw(15) << " Limited / flag"  << " "
           << std::setw(15) << "  World "  << " "
           << G4endl;  
  }
#endif
 
  for ( auto num = 0; num < fNoActiveNavigators; ++num )
  { 
    G4double rawStep = fCurrentStepSize[num]; 
    G4double stepLen = fCurrentStepSize[num]; 
    if( stepLen > fTrueMinStep )
    { 
      stepLen = fTrueMinStep;     // did not limit (went as far as asked)
    }
    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 != nullptr)
    {
       G4VPhysicalVolume *pWorld = pNav->GetWorldVolume(); 
       if( pWorld )
       {
           WorldName = pWorld->GetName(); 
       }
    }
    G4cout << " " << WorldName ; 
    G4cout << G4endl;
  }
}

References fCurrentStepSize, fLimitedStep, fLimitTruth, fMinStep, fNewSafety, fNoActiveNavigators, fpNavigator, fTrueMinStep, G4Navigator::fVerbose, G4cout, G4endl, G4VPhysicalVolume::GetName(), G4Navigator::GetWorldVolume(), kDoNot, kSharedOther, kSharedTransport, and kUnique.

◆ PrintState()

void G4Navigator::PrintState ( ) const

inherited

Definition at line 1964 of file G4Navigator.cc.

{
  G4int oldcoutPrec = G4cout.precision(4);
  if( fVerbose >= 4 )
  {
    G4cout << "The current state of G4Navigator is: " << G4endl;
    G4cout << "  ValidExitNormal= " << fValidExitNormal // << G4endl
           << "  ExitNormal     = " << fExitNormal      // << G4endl
           << "  Exiting        = " << fExiting         // << G4endl
           << "  Entering       = " << fEntering        // << G4endl
           << "  BlockedPhysicalVolume= " ;
    if (fBlockedPhysicalVolume==0)
    {
      G4cout << "None";
    }
    else
    {
      G4cout << fBlockedPhysicalVolume->GetName();
    }
    G4cout << G4endl
           << "  BlockedReplicaNo     = " <<  fBlockedReplicaNo   //  << G4endl
           << "  LastStepWasZero      = " <<  fLastStepWasZero    //  << G4endl
           << G4endl;   
  }
  if( ( 1 < fVerbose) && (fVerbose < 4) )
  {
    G4cout << G4endl; // Make sure to line up
    G4cout << 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;   
    G4cout << "( " << std::setw(7) << fExitNormal.x() 
           << ", " << std::setw(7) << fExitNormal.y()
           << ", " << std::setw(7) << fExitNormal.z() << " ) "
           << std::setw( 5)  << fValidExitNormal  << " "   
           << std::setw( 9)  << fExiting          << " "
           << std::setw( 9)  << fEntering         << " ";
    if ( fBlockedPhysicalVolume == nullptr )
    { G4cout << std::setw(15) << "None"; }
    else
    { G4cout << std::setw(15)<< fBlockedPhysicalVolume->GetName(); }
    G4cout << std::setw( 9)  << fBlockedReplicaNo  << " "
           << std::setw( 8)  << fLastStepWasZero   << " "
           << G4endl;   
  }
  if( fVerbose > 2 ) 
  {
    G4cout.precision(8);
    G4cout << " Current Localpoint = " << fLastLocatedPointLocal << G4endl;
    G4cout << " PreviousSftOrigin  = " << fPreviousSftOrigin << G4endl;
    G4cout << " PreviousSafety     = " << fPreviousSafety << G4endl; 
  }
  G4cout.precision(oldcoutPrec);
}

References G4Navigator::fBlockedPhysicalVolume, G4Navigator::fBlockedReplicaNo, G4Navigator::fEntering, G4Navigator::fExiting, G4Navigator::fExitNormal, G4Navigator::fLastLocatedPointLocal, G4Navigator::fLastStepWasZero, G4Navigator::fPreviousSafety, G4Navigator::fPreviousSftOrigin, G4Navigator::fValidExitNormal, G4Navigator::fVerbose, G4cout, G4endl, G4VPhysicalVolume::GetName(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4Navigator::ComputeSafety(), G4Navigator::ComputeStep(), export_G4Navigator(), and G4Navigator::LocateGlobalPointAndSetup().

◆ ResetHierarchyAndLocate()

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

virtual

Reimplemented from G4Navigator.

Definition at line 644 of file G4MultiNavigator.cc.

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

References FatalException, fNoActiveNavigators, fpNavigator, G4Exception(), G4TransportationManager::GetActiveNavigatorsIterator(), LocateGlobalPointAndSetup(), pTransportManager, and G4Navigator::ResetHierarchyAndLocate().

◆ ResetStackAndState()

void G4Navigator::ResetStackAndState ( )

inlineinherited

Referenced by G4Navigator::G4Navigator(), and G4Navigator::LocateGlobalPointAndSetup().

◆ ResetState()

void G4MultiNavigator::ResetState ( )

protectedvirtual

Reimplemented from G4Navigator.

Definition at line 600 of file G4MultiNavigator.cc.

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

References FatalException, G4Navigator::fWasLimitedByGeometry, and G4Exception().

◆ RestoreSavedState()

void G4Navigator::RestoreSavedState ( )

protectedinherited

Definition at line 716 of file G4Navigator.cc.

{
  fExitNormal = fSaveState.sExitNormal;
  fValidExitNormal = fSaveState.sValidExitNormal;
  fExiting = fSaveState.sExiting;
  fEntering = fSaveState.sEntering;
 
  fBlockedPhysicalVolume = fSaveState.spBlockedPhysicalVolume;
  fBlockedReplicaNo = fSaveState.sBlockedReplicaNo; 
 
  fLastStepWasZero = fSaveState.sLastStepWasZero;
  
  fLocatedOutsideWorld = fSaveState.sLocatedOutsideWorld;
  fLastLocatedPointLocal = fSaveState.sLastLocatedPointLocal;
  fEnteredDaughter = fSaveState.sEnteredDaughter;
  fExitedMother = fSaveState.sExitedMother;
  fWasLimitedByGeometry = fSaveState.sWasLimitedByGeometry;
  
  // The 'expected' behaviour is to restore these too (fix 2014.05.26)
  fPreviousSftOrigin = fSaveState.sPreviousSftOrigin;
  fPreviousSafety = fSaveState.sPreviousSafety;
}

Referenced by G4Navigator::CheckNextStep(), and G4Navigator::ComputeSafety().

◆ SetExternalNavigation()

void G4Navigator::SetExternalNavigation ( G4VExternalNavigation * externalNav )

inlineinherited

◆ SetGeometricallyLimitedStep()

void G4Navigator::SetGeometricallyLimitedStep ( )

inlineinherited

Referenced by G4Transportation::PostStepDoIt().

◆ SetPushVerbosity()

void G4Navigator::SetPushVerbosity ( G4bool mode )

inlineinherited

Referenced by G4ParallelWorldProcess::G4ParallelWorldProcess(), and G4ParallelWorldProcess::SetParallelWorld().

◆ SetSavedState()

void G4Navigator::SetSavedState ( )

protectedinherited

Definition at line 682 of file G4Navigator.cc.

{
  // Note: the state of dependent objects is not currently saved.
  //   ( This means that the full state is changed by calls between
  //     SetSavedState() and RestoreSavedState(); 
  
  fSaveState.sExitNormal = fExitNormal;
  fSaveState.sValidExitNormal = fValidExitNormal;
  fSaveState.sExiting = fExiting;
  fSaveState.sEntering = fEntering;
 
  fSaveState.spBlockedPhysicalVolume = fBlockedPhysicalVolume;
  fSaveState.sBlockedReplicaNo = fBlockedReplicaNo;
 
  fSaveState.sLastStepWasZero = fLastStepWasZero;
  
  fSaveState.sLocatedOutsideWorld = fLocatedOutsideWorld;
  fSaveState.sLastLocatedPointLocal = fLastLocatedPointLocal;
  fSaveState.sEnteredDaughter = fEnteredDaughter;
  fSaveState.sExitedMother = fExitedMother;
  fSaveState.sWasLimitedByGeometry = fWasLimitedByGeometry;
 
  // Even the safety sphere - if you want to change it do it explicitly!
  //
  fSaveState.sPreviousSftOrigin = fPreviousSftOrigin;
  fSaveState.sPreviousSafety = fPreviousSafety;
}

Referenced by G4Navigator::CheckNextStep(), and G4Navigator::ComputeSafety().

◆ SetupHierarchy()

void G4MultiNavigator::SetupHierarchy ( )

protectedvirtual

Reimplemented from G4Navigator.

Definition at line 619 of file G4MultiNavigator.cc.

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

References FatalException, and G4Exception().

◆ SetVerboseLevel()

void G4Navigator::SetVerboseLevel ( G4int level )

inlineinherited

Referenced by export_G4Navigator(), G4Navigator::GetGlobalExitNormal(), and G4ErrorPropagatorManager::StartNavigator().

◆ SetVoxelNavigation()

void G4Navigator::SetVoxelNavigation ( G4VoxelNavigation * voxelNav )

inherited

◆ SetWorldVolume()

void G4Navigator::SetWorldVolume ( G4VPhysicalVolume * pWorld )

inlineinherited

Referenced by G4VReadOutGeometry::BuildROGeometry(), G4MultiNavigator(), G4VIntersectionLocator::GetLocalSurfaceNormal(), G4TransportationManager::GetNavigator(), G4FastSimHitMaker::make(), GFlashHitMaker::make(), PrepareNavigators(), and G4ErrorPropagatorManager::StartNavigator().

◆ SeverityOfZeroStepping()

G4int G4Navigator::SeverityOfZeroStepping ( G4int * noZeroSteps ) const

inlineinherited

◆ VolumeType()

EVolume G4Navigator::VolumeType ( const G4VPhysicalVolume * pVol ) const

inlineprotectedinherited

Referenced by G4Navigator::GetLocalExitNormal(), and G4Navigator::LocateGlobalPointAndSetup().

◆ WhichLimited()

void G4MultiNavigator::WhichLimited ( )

protected

Definition at line 471 of file G4MultiNavigator.cc.

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

References fCurrentStepSize, fIdNavLimiting, fLimitedStep, fLimitTruth, fMinStep, fNoActiveNavigators, fNoLimitingStep, G4Navigator::fVerbose, G4cout, G4endl, kDoNot, kInfinity, kSharedOther, kSharedTransport, and kUnique.

Referenced by ComputeStep().

Friends And Related Function Documentation

◆ operator<<

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

friend

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