G4Navigator Class Reference

#include <G4Navigator.hh>

Inheritance diagram for G4Navigator:

Data Structures
struct	G4SaveNavigatorState

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
virtual G4double	ComputeSafety (const G4ThreeVector &globalpoint, const G4double pProposedMaxLength=DBL_MAX, const G4bool keepState=true)
virtual 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
virtual G4TouchableHistoryHandle	CreateTouchableHistoryHandle () const
void	EnableBestSafety (G4bool value=false)
G4bool	EnteredDaughterVolume () const
G4bool	ExitedMotherVolume () const
	G4Navigator ()
	G4Navigator (const G4Navigator &)=delete
G4ThreeVector	GetCurrentLocalCoordinate () const
G4VExternalNavigation *	GetExternalNavigation () const
virtual G4ThreeVector	GetGlobalExitNormal (const G4ThreeVector &point, G4bool *valid)
const G4AffineTransform &	GetGlobalToLocalTransform () const
G4ThreeVector	GetLastStepEndPoint () const
virtual G4ThreeVector	GetLocalExitNormal (G4bool *valid)
virtual G4ThreeVector	GetLocalExitNormalAndCheck (const G4ThreeVector &point, G4bool *valid)
const G4AffineTransform	GetLocalToGlobalTransform () const
G4AffineTransform	GetMotherToDaughterTransform (G4VPhysicalVolume *dVolume, G4int dReplicaNo, EVolume dVolumeType)
G4int	GetVerboseLevel () const
G4VPhysicalVolume *	GetWorldVolume () const
void	InformLastStep (G4double lastStep, G4bool entersDaughtVol, G4bool exitsMotherVol)
G4bool	IsActive () const
G4bool	IsCheckModeActive () const
virtual 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)
virtual void	LocateGlobalPointWithinVolume (const G4ThreeVector &position)
G4RotationMatrix	NetRotation () const
G4ThreeVector	NetTranslation () const
G4Navigator &	operator= (const G4Navigator &)=delete
void	PrintState () const
virtual 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
virtual	~G4Navigator ()

Protected Member Functions
EVolume	CharacteriseDaughters (const G4LogicalVolume *pLog) const
G4bool	CheckOverlapsIterative (G4VPhysicalVolume *vol)
G4ThreeVector	ComputeLocalAxis (const G4ThreeVector &pVec) const
G4ThreeVector	ComputeLocalPoint (const G4ThreeVector &rGlobPoint) const
G4int	GetDaughtersRegularStructureId (const G4LogicalVolume *pLv) const
virtual void	ResetState ()
void	RestoreSavedState ()
void	SetSavedState ()
virtual void	SetupHierarchy ()
EVolume	VolumeType (const G4VPhysicalVolume *pVol) const

Protected Attributes
G4bool	fEnteredDaughter
G4bool	fExitedMother
G4NavigationHistory	fHistory
G4ThreeVector	fLastStepEndPointLocal
G4double	fMinStep
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
G4bool	fEntering
G4bool	fExiting
G4ThreeVector	fExitNormal
G4ThreeVector	fExitNormalGlobalFrame
G4ThreeVector	fGrandMotherExitNormal
G4ThreeVector	fLastLocatedPointLocal
G4VPhysicalVolume *	fLastMotherPhys = nullptr
G4bool	fLastStepWasZero
G4bool	fLastTriedStepComputation = false
G4bool	fLocatedOnEdge
G4bool	fLocatedOutsideWorld
G4NormalNavigation	fnormalNav
G4int	fNumberZeroSteps
G4ParameterisedNavigation	fparamNav
G4VExternalNavigation *	fpExternalNav = nullptr
G4double	fPreviousSafety
G4ThreeVector	fPreviousSftOrigin
G4bool	fPushed = false
G4VoxelNavigation *	fpvoxelNav
G4VoxelSafety *	fpVoxelSafety
G4RegularNavigation	fregularNav
G4ReplicaNavigation	freplicaNav
struct G4Navigator::G4SaveNavigatorState	fSaveState
G4VPhysicalVolume *	fTopPhysical = nullptr
G4bool	fValidExitNormal
G4bool	fWarnPush = true

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

Detailed Description

Definition at line 71 of file G4Navigator.hh.

Constructor & Destructor Documentation

G4Navigator() [1/2]

G4Navigator::G4Navigator

(

)

Definition at line 53 of file G4Navigator.cc.

{
  ResetStackAndState();
    // Initialises also all 
    // - exit / entry flags
    // - flags & variables for exit normals
    // - zero step counters
    // - blocked volume 
 
  if( fVerbose > 2 )
  {
    G4cout << " G4Navigator parameters: Action Threshold (No Zero Steps) = "
           << fActionThreshold_NoZeroSteps
           << "  Abandon Threshold (No Zero Steps) = "
           << fAbandonThreshold_NoZeroSteps << G4endl;
  }
  kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
  fMinStep = 0.05*kCarTolerance;
  fSqTol = sqr(kCarTolerance);
 
  fregularNav.SetNormalNavigation( &fnormalNav );
 
  fStepEndPoint = G4ThreeVector( kInfinity, kInfinity, kInfinity ); 
  fLastStepEndPointLocal = G4ThreeVector( kInfinity, kInfinity, kInfinity ); 
 
  fpVoxelSafety = new G4VoxelSafety();
#ifdef ALTERNATIVE_VOXEL_NAV
  fpvoxelNav    = new G4VoxelNavigation();
#endif  
}

References fAbandonThreshold_NoZeroSteps, fActionThreshold_NoZeroSteps, fLastStepEndPointLocal, fMinStep, fnormalNav, fpvoxelNav, fpVoxelSafety, fregularNav, fSqTol, fStepEndPoint, fVerbose, G4cout, G4endl, G4GeometryTolerance::GetInstance(), G4GeometryTolerance::GetSurfaceTolerance(), kCarTolerance, kInfinity, ResetStackAndState(), G4RegularNavigation::SetNormalNavigation(), and sqr().

G4Navigator() [2/2]

G4Navigator::G4Navigator ( const G4Navigator &  )

delete

~G4Navigator()

G4Navigator::~G4Navigator ( )

virtual

Definition at line 88 of file G4Navigator.cc.

{
  delete fpVoxelSafety;
  delete fpExternalNav;
#ifdef ALTERNATIVE_VOXEL_NAV  
  delete fpvoxelNav;
#endif
}

References fpExternalNav, fpvoxelNav, and fpVoxelSafety.

Member Function Documentation

Activate()

void G4Navigator::Activate ( G4bool  flag )

inline

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

CharacteriseDaughters()

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

inlineprotected

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

CheckMode()

void G4Navigator::CheckMode ( G4bool  mode )

inline

Referenced by G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck().

CheckNextStep()

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

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 ComputeStep(), RestoreSavedState(), and SetSavedState().

Referenced by G4SafetyHelper::CheckNextStep().

CheckOverlapsIterative()

G4bool G4Navigator::CheckOverlapsIterative ( G4VPhysicalVolume *  vol )

protected

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(), fVerbose, G4cout, G4endl, and G4VPhysicalVolume::GetName().

Referenced by ComputeStep().

Clone()

G4Navigator * G4Navigator::Clone ( ) const

inline

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

ComputeLocalAxis()

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

inlineprotected

Referenced by ComputeStep().

ComputeLocalPoint()

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

inlineprotected

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

ComputeSafety()

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

virtual

Reimplemented in G4MultiNavigator, and G4ErrorPropagationNavigator.

Definition at line 1813 of file G4Navigator.cc.

{
  G4double newSafety = 0.0;
 
#ifdef G4DEBUG_NAVIGATION
  G4int oldcoutPrec = G4cout.precision(8);
  if( fVerbose > 0 )
  {
    G4cout << "*** G4Navigator::ComputeSafety: ***" << G4endl
           << "    Called at point: " << pGlobalpoint << G4endl;
 
    G4VPhysicalVolume  *motherPhysical = fHistory.GetTopVolume();
    G4cout << "    Volume = " << motherPhysical->GetName() 
           << " - Maximum length = " << pMaxLength << G4endl; 
    if( fVerbose >= 4 )
    {
       G4cout << "    ----- Upon entering Compute Safety:" << G4endl;
       PrintState();
    }
  }
#endif
 
  G4double distEndpointSq = (pGlobalpoint-fStepEndPoint).mag2(); 
  G4bool stayedOnEndpoint = distEndpointSq < sqr(kCarTolerance); 
  G4bool endpointOnSurface = fEnteredDaughter || fExitedMother;
 
  if( endpointOnSurface && stayedOnEndpoint )
  {
#ifdef G4DEBUG_NAVIGATION
    if( fVerbose >= 2 )
    {
      G4cout << "    G4Navigator::ComputeSafety() finds that point - "
             << pGlobalpoint << " - is on surface " << G4endl;
      if( fEnteredDaughter ) { G4cout << "   entered new daughter volume"; }
      if( fExitedMother )    { G4cout << "   and exited previous volume."; }
      G4cout << G4endl;
      G4cout << " EndPoint was = " << fStepEndPoint << G4endl;
    }
#endif
      newSafety = 0.0;
  }
  else // if( !(endpointOnSurface && stayedOnEndpoint) )
  {
    if (keepState)  { SetSavedState(); }
    
    // Pseudo-relocate to this point (updates voxel information only)
    //
    LocateGlobalPointWithinVolume( pGlobalpoint ); 
      // --->> DANGER: Side effects on sub-navigator voxel information <<---
      //       Could be replaced again by 'granular' calls to sub-navigator
      //       locates (similar side-effects, but faster.  
      //       Solutions:
      //        1) Re-locate (to where?)
      //        2) Insure that the methods using (G4ComputeStep?)
      //           does a relocation (if information is disturbed only ?)
 
#ifdef G4DEBUG_NAVIGATION
    if( fVerbose >= 2 )
    {
      G4cout << "  G4Navigator::ComputeSafety() relocates-in-volume to point: "
             << pGlobalpoint << G4endl;
    }
#endif 
    G4VPhysicalVolume* motherPhysical = fHistory.GetTopVolume();
    G4LogicalVolume* motherLogical = motherPhysical->GetLogicalVolume();
    G4SmartVoxelHeader* pVoxelHeader = motherLogical->GetVoxelHeader();
    G4ThreeVector localPoint = ComputeLocalPoint(pGlobalpoint);
 
    if ( fHistory.GetTopVolumeType() != kReplica )
    {
      switch(CharacteriseDaughters(motherLogical))
      {
        case kNormal:
          if ( pVoxelHeader )
          {
            newSafety = fpVoxelSafety->ComputeSafety(localPoint,
                                             *motherPhysical, pMaxLength);
            // = VoxelNav().ComputeSafety(localPoint,fHistory,pMaxLength); // - Old method
          }
          else
          {
            newSafety=fnormalNav.ComputeSafety(localPoint,fHistory,pMaxLength);
          }
          break;
        case kParameterised:
          if( GetDaughtersRegularStructureId(motherLogical) != 1 )
          {
            newSafety=fparamNav.ComputeSafety(localPoint,fHistory,pMaxLength);
          }
          else  // Regular structure
          {
            newSafety=fregularNav.ComputeSafety(localPoint,fHistory,pMaxLength);
          }
          break;
        case kReplica:
          G4Exception("G4Navigator::ComputeSafety()", "GeomNav0001",
                      FatalException, "Not applicable for replicated volumes.");
          break;
        case kExternal:
          newSafety = fpExternalNav->ComputeSafety(localPoint, fHistory,
                                                   pMaxLength);
          break;
      }
    }
    else
    {
      newSafety = freplicaNav.ComputeSafety(pGlobalpoint, localPoint,
                                            fHistory, pMaxLength);
    }
    
    if (keepState)
    {
      RestoreSavedState();
      // This now overwrites the values of the Safety 'sphere' (correction)
    }
    
    // Remember last safety origin & value
    //
    // We overwrite the Safety 'sphere' - keeping old behaviour
    fPreviousSftOrigin = pGlobalpoint;
    fPreviousSafety = newSafety;
  }
  
#ifdef G4DEBUG_NAVIGATION
  if( fVerbose > 1 )
  {
    G4cout << "   ---- Exiting ComputeSafety  " << G4endl;
    if( fVerbose > 2 )  { PrintState(); }
    G4cout << "    Returned value of Safety = " << newSafety << G4endl;
  }
  G4cout.precision(oldcoutPrec);
#endif
 
  return newSafety;
}

References CharacteriseDaughters(), ComputeLocalPoint(), G4NormalNavigation::ComputeSafety(), G4VExternalNavigation::ComputeSafety(), G4ReplicaNavigation::ComputeSafety(), G4ParameterisedNavigation::ComputeSafety(), G4RegularNavigation::ComputeSafety(), G4VoxelSafety::ComputeSafety(), FatalException, fEnteredDaughter, fExitedMother, fHistory, fnormalNav, fparamNav, fpExternalNav, fPreviousSafety, fPreviousSftOrigin, fpVoxelSafety, fregularNav, freplicaNav, fStepEndPoint, fVerbose, G4cout, G4endl, G4Exception(), GetDaughtersRegularStructureId(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetName(), G4NavigationHistory::GetTopVolume(), G4NavigationHistory::GetTopVolumeType(), G4LogicalVolume::GetVoxelHeader(), kCarTolerance, kExternal, kNormal, kParameterised, kReplica, LocateGlobalPointWithinVolume(), PrintState(), RestoreSavedState(), SetSavedState(), and sqr().

Referenced by G4ImportanceProcess::AlongStepGetPhysicalInteractionLength(), G4WeightCutOffProcess::AlongStepGetPhysicalInteractionLength(), G4WeightWindowProcess::AlongStepGetPhysicalInteractionLength(), G4ParallelWorldProcess::AlongStepGetPhysicalInteractionLength(), G4ParallelWorldScoringProcess::AlongStepGetPhysicalInteractionLength(), G4Transportation::AlongStepGetPhysicalInteractionLength(), G4FastSimulationManagerProcess::AlongStepGetPhysicalInteractionLength(), G4ErrorPropagationNavigator::ComputeSafety(), G4SafetyHelper::ComputeSafety(), and G4PathFinder::DoNextCurvedStep().

ComputeStep()

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

virtual

Reimplemented in G4ErrorPropagationNavigator, and G4MultiNavigator.

Definition at line 770 of file G4Navigator.cc.

{
  G4ThreeVector localDirection = ComputeLocalAxis(pDirection);
  G4double Step = kInfinity;
  G4VPhysicalVolume  *motherPhysical = fHistory.GetTopVolume();
  G4LogicalVolume *motherLogical = motherPhysical->GetLogicalVolume();
 
  // All state relating to exiting normals must be reset
  //
  fExitNormalGlobalFrame = G4ThreeVector( 0., 0., 0.);
    // Reset value - to erase its memory
  fChangedGrandMotherRefFrame = false;
    // Reset - used for local exit normal
  fGrandMotherExitNormal = G4ThreeVector( 0., 0., 0.); 
  fCalculatedExitNormal = false;
    // Reset for new step
 
  static G4ThreadLocal G4int sNavCScalls = 0;
  ++sNavCScalls;
 
  fLastTriedStepComputation = true; 
 
#ifdef G4VERBOSE
  if( fVerbose > 0 )
  {
    G4cout << "*** G4Navigator::ComputeStep: ***" << G4endl; 
    G4cout << "    Volume = " << motherPhysical->GetName() 
           << " - Proposed step length = " << pCurrentProposedStepLength
           << G4endl; 
#ifdef G4DEBUG_NAVIGATION
    if( fVerbose >= 2 )
    {
      G4cout << "  Called with the arguments: " << G4endl
             << "  Globalpoint = " << std::setw(25) << pGlobalpoint << G4endl
             << "  Direction   = " << std::setw(25) << pDirection << G4endl;
      if( fVerbose >= 4 )
      {
        G4cout << "  ---- Upon entering : State" << G4endl;
        PrintState();
      }
    }
#endif
  }
#endif
 
  G4ThreeVector newLocalPoint = ComputeLocalPoint(pGlobalpoint);
  if( newLocalPoint != fLastLocatedPointLocal )
  {
    // Check whether the relocation is within safety
    //
    G4ThreeVector oldLocalPoint = fLastLocatedPointLocal;
    G4double moveLenSq = (newLocalPoint-oldLocalPoint).mag2();
 
    if ( moveLenSq >= fSqTol )
    {
#ifdef G4VERBOSE
      ComputeStepLog(pGlobalpoint, moveLenSq);
#endif
      // Relocate the point within the same volume
      //
      LocateGlobalPointWithinVolume( pGlobalpoint );
      fLastTriedStepComputation = true;     // Ensure that this is set again !!
    }
  }
  if ( fHistory.GetTopVolumeType()!=kReplica )
  {
    switch( CharacteriseDaughters(motherLogical) )
    {
      case kNormal:
        if ( motherLogical->GetVoxelHeader() )
        {
          Step = GetVoxelNavigator().ComputeStep(fLastLocatedPointLocal,
                                       localDirection,
                                       pCurrentProposedStepLength,
                                       pNewSafety,
                                       fHistory,
                                       fValidExitNormal,
                                       fExitNormal,
                                       fExiting,
                                       fEntering,
                                       &fBlockedPhysicalVolume,
                                       fBlockedReplicaNo);
      
        }
        else
        {
          if( motherPhysical->GetRegularStructureId() == 0 )
          {
            Step = fnormalNav.ComputeStep(fLastLocatedPointLocal,
                                          localDirection,
                                          pCurrentProposedStepLength,
                                          pNewSafety,
                                          fHistory,
                                          fValidExitNormal,
                                          fExitNormal,
                                          fExiting,
                                          fEntering,
                                          &fBlockedPhysicalVolume,
                                          fBlockedReplicaNo);
          }
          else  // Regular (non-voxelised) structure
          {
            LocateGlobalPointAndSetup( pGlobalpoint, &pDirection, true, true );
            fLastTriedStepComputation = true; // Ensure that this is set again!!
            //
            // if physical process limits the step, the voxel will not be the
            // one given by ComputeStepSkippingEqualMaterials() and the local
            // point will be wrongly calculated.
 
            // There is a problem: when msc limits the step and the point is
            // assigned wrongly to phantom in previous step (while it is out
            // of the container volume). Then LocateGlobalPointAndSetup() has
            // reset the history topvolume to world.
            //
            if(fHistory.GetTopVolume()->GetRegularStructureId() == 0 )
            { 
              G4Exception("G4Navigator::ComputeStep()",
                          "GeomNav1001", JustWarning,
                "Point is relocated in voxels, while it should be outside!");
              Step = fnormalNav.ComputeStep(fLastLocatedPointLocal,
                                            localDirection,
                                            pCurrentProposedStepLength,
                                            pNewSafety,
                                            fHistory,
                                            fValidExitNormal,
                                            fExitNormal,
                                            fExiting,
                                            fEntering,
                                            &fBlockedPhysicalVolume,
                                            fBlockedReplicaNo);
            }
            else
            {
              Step = fregularNav.
                   ComputeStepSkippingEqualMaterials(fLastLocatedPointLocal,
                                                     localDirection,
                                                     pCurrentProposedStepLength,
                                                     pNewSafety,
                                                     fHistory,
                                                     fValidExitNormal,
                                                     fExitNormal,
                                                     fExiting,
                                                     fEntering,
                                                     &fBlockedPhysicalVolume,
                                                     fBlockedReplicaNo,
                                                     motherPhysical);
            }
          }
        }
        break;
      case kParameterised:
        if( GetDaughtersRegularStructureId(motherLogical) != 1 )
        {
          Step = fparamNav.ComputeStep(fLastLocatedPointLocal,
                                       localDirection,
                                       pCurrentProposedStepLength,
                                       pNewSafety,
                                       fHistory,
                                       fValidExitNormal,
                                       fExitNormal,
                                       fExiting,
                                       fEntering,
                                       &fBlockedPhysicalVolume,
                                       fBlockedReplicaNo);
        }
        else  // Regular structure
        {
          Step = fregularNav.ComputeStep(fLastLocatedPointLocal,
                                         localDirection,
                                         pCurrentProposedStepLength,
                                         pNewSafety,
                                         fHistory,
                                         fValidExitNormal,
                                         fExitNormal,
                                         fExiting,
                                         fEntering,
                                         &fBlockedPhysicalVolume,
                                         fBlockedReplicaNo);
        }
        break;
      case kReplica:
        G4Exception("G4Navigator::ComputeStep()", "GeomNav0001",
                    FatalException, "Not applicable for replicated volumes.");
        break;
      case kExternal:
        Step = fpExternalNav->ComputeStep(fLastLocatedPointLocal,
                                          localDirection,
                                          pCurrentProposedStepLength,
                                          pNewSafety,
                                          fHistory,
                                          fValidExitNormal,
                                          fExitNormal,
                                          fExiting,
                                          fEntering,
                                          &fBlockedPhysicalVolume,
                                          fBlockedReplicaNo);
        break;
    }
  }
  else
  {
    // In the case of a replica, it must handle the exiting
    // edge/corner problem by itself
    //
    G4bool exitingReplica = fExitedMother;
    G4bool calculatedExitNormal;
    Step = freplicaNav.ComputeStep(pGlobalpoint,
                                   pDirection,
                                   fLastLocatedPointLocal,
                                   localDirection,
                                   pCurrentProposedStepLength,
                                   pNewSafety,
                                   fHistory,
                                   fValidExitNormal,
                                   calculatedExitNormal,
                                   fExitNormal,
                                   exitingReplica,
                                   fEntering,
                                   &fBlockedPhysicalVolume,
                                   fBlockedReplicaNo);
    fExiting = exitingReplica;                          
    fCalculatedExitNormal = calculatedExitNormal;
  }
 
  // Remember last safety origin & value.
  //
  fPreviousSftOrigin = pGlobalpoint;
  fPreviousSafety = pNewSafety; 
 
  // Count zero steps - one can occur due to changing momentum at a boundary
  //                  - one, two (or a few) can occur at common edges between
  //                    volumes
  //                  - more than two is likely a problem in the geometry
  //                    description or the Navigation 
 
  // Rule of thumb: likely at an Edge if two consecutive steps are zero,
  //                because at least two candidate volumes must have been
  //                checked
  //
  fLocatedOnEdge   = fLastStepWasZero && (Step==0.0);
  fLastStepWasZero = (Step<fMinStep);
  if (fPushed)  { fPushed = fLastStepWasZero; }
 
  // Handle large number of consecutive zero steps
  //
  if ( fLastStepWasZero )
  {
    ++fNumberZeroSteps;
    
    G4bool act     = fNumberZeroSteps >= fActionThreshold_NoZeroSteps;
    G4bool actAndReport = false;
    G4bool abandon = fNumberZeroSteps >= fAbandonThreshold_NoZeroSteps;
    G4bool inform  = false;
#ifdef G4VERBOSE
    actAndReport = act && (!fPushed) && fWarnPush;
#endif
#ifdef G4DEBUG_NAVIGATION
    inform = fNumberZeroSteps > 1;
#endif
    
    if ( act || inform )
    {
      if( act && !abandon )
      {
        // Act to recover this stuck track. Pushing it along original direction
        //
        Step += 100*kCarTolerance;
        fPushed = true;
      }
 
      if( actAndReport || abandon || inform )
      {
        std::ostringstream message;
         
        message.precision(16);      
        message << "Stuck Track: potential geometry or navigation problem."
                << G4endl;
        message << "  Track stuck, not moving for " 
                << fNumberZeroSteps << " steps."  << G4endl
                << "  Current  phys volume: '" << motherPhysical->GetName()
                << "'" << G4endl
                << "   - at position : " << pGlobalpoint << G4endl
                << "     in direction: " << pDirection   << G4endl
                << "    (local position: " << newLocalPoint << ")" << G4endl
                << "    (local direction: " << localDirection << ")." << G4endl
                << "  Previous phys volume: '"
                << ( fLastMotherPhys ? fLastMotherPhys->GetName() : "" )
                << "'" << G4endl << G4endl;
        if( actAndReport || abandon )
        {
           message << "  Likely geometry overlap - else navigation problem !"
                   << G4endl;
        }
        if( abandon ) // i.e. fNumberZeroSteps >= fAbandonThreshold_NoZeroSteps
        {
          // Must kill this stuck track
#ifdef G4VERBOSE
          if ( fWarnPush ) { CheckOverlapsIterative(motherPhysical); }
#endif
          message << " Track *abandoned* due to excessive number of Zero steps."
                  << " Event aborted. " << G4endl << G4endl;
          G4Exception("G4Navigator::ComputeStep()", "GeomNav0003",
                      EventMustBeAborted, message);
        }
        else
        {
#ifdef G4VERBOSE
          if ( actAndReport )  // (!fPushed => !wasPushed) && (fWarnPush))
          {
             message << "   *** Trying to get *unstuck* using a push"
                     << " - expanding step to " << Step << " (mm) ..."
                     << "       Potential overlap in geometry !" << G4endl;
             G4Exception("G4Navigator::ComputeStep()", "GeomNav1002",
                         JustWarning, message); 
          }
#endif
#ifdef G4DEBUG_NAVIGATION      
          else
          {
            if( fNumberZeroSteps > 1 )
            {
               message << ", nav-comp-step calls # " << sNavCScalls
                       << ", Step= " << Step << G4endl;
               G4cout << message.str();
            }
          }
#endif
        } // end of else if ( abandon )
      } // end of if( actAndReport || abandon || inform )
    } // end of if ( act || inform )
  }
  else
  {
    if (!fPushed)  { fNumberZeroSteps = 0; }
  }
  fLastMotherPhys = motherPhysical;
 
  fEnteredDaughter = fEntering;   // I expect to enter a volume in this Step
  fExitedMother = fExiting;
 
  fStepEndPoint = pGlobalpoint
                + std::min(Step,pCurrentProposedStepLength) * pDirection;
  fLastStepEndPointLocal = fLastLocatedPointLocal + Step * localDirection; 
 
  if( fExiting )
  {
#ifdef G4DEBUG_NAVIGATION
    if( fVerbose > 2 )
    { 
      G4cout << " At G4Nav CompStep End - if(exiting) - fExiting= " << fExiting
             << " fValidExitNormal = " << fValidExitNormal  << G4endl;
      G4cout << " fExitNormal= " << fExitNormal << G4endl;
    }
#endif
 
    if ( fValidExitNormal || fCalculatedExitNormal )
    {
      if (  fHistory.GetTopVolumeType() != kReplica )
      {
        // Convention: fExitNormal is in the 'grand-mother' coordinate system
        //
        fGrandMotherExitNormal = fExitNormal;
        fCalculatedExitNormal = true;
      }
      else
      {
        fGrandMotherExitNormal = fExitNormal;
      }
    }
    else
    {  
      // We must calculate the normal anyway (in order to have it if requested)
      //
      G4ThreeVector finalLocalPoint = fLastLocatedPointLocal
                                    + localDirection*Step;
 
      if (  fHistory.GetTopVolumeType() != kReplica )
      {
        // Find normal in the 'mother' coordinate system
        //
        G4ThreeVector exitNormalMotherFrame=
           motherLogical->GetSolid()->SurfaceNormal(finalLocalPoint);
        
        // Transform it to the 'grand-mother' coordinate system
        //
        const G4RotationMatrix* mRot = motherPhysical->GetRotation();
        if( mRot )
        {
          fChangedGrandMotherRefFrame = true;           
          fGrandMotherExitNormal = (*mRot).inverse() * exitNormalMotherFrame;
        }
        else
        {
          fGrandMotherExitNormal = exitNormalMotherFrame;
        }
 
        // Do not set fValidExitNormal -- this signifies
        // that the solid is convex!
        //
        fCalculatedExitNormal = true;
      }
      else
      {
        fCalculatedExitNormal = false;
        //
        // Nothing can be done at this stage currently - to solve this
        // Replica Navigation must have calculated the normal for this case
        // already.
        // Cases: mother is not convex, and exit is at previous replica level
 
#ifdef G4DEBUG_NAVIGATION
        G4ExceptionDescription desc;
 
        desc << "Problem in ComputeStep:  Replica Navigation did not provide"
             << " valid exit Normal. " << G4endl;
        desc << " Do not know how calculate it in this case." << G4endl;
        desc << "  Location    = " << finalLocalPoint << G4endl;
        desc << "  Volume name = " << motherPhysical->GetName()
             << "  copy/replica No = " << motherPhysical->GetCopyNo() << G4endl;
        G4Exception("G4Navigator::ComputeStep()", "GeomNav0003",
                    JustWarning, desc, "Normal not available for exiting.");
#endif
      }
    }
 
    // Now transform it to the global reference frame !!
    //
    if( fValidExitNormal || fCalculatedExitNormal )
    {
      G4int depth = fHistory.GetDepth();
      if( depth > 0 )
      {
        fExitNormalGlobalFrame = fHistory.GetTransform(depth-1)
                                .InverseTransformAxis( fGrandMotherExitNormal );
      }
      else
      {
        fExitNormalGlobalFrame = fGrandMotherExitNormal;
      }
    }
    else
    {
      fExitNormalGlobalFrame = G4ThreeVector( 0., 0., 0.);
    }
  }
 
  if( (Step == pCurrentProposedStepLength) && (!fExiting) && (!fEntering) )
  {
    // This if Step is not really limited by the geometry.
    // The Navigator is obliged to return "infinity"
    //
    Step = kInfinity;
  }
 
#ifdef G4VERBOSE
  if( fVerbose > 1 )
  {
    if( fVerbose >= 4 )
    {
      G4cout << "    ----- Upon exiting :" << G4endl;
      PrintState();
    }
    G4cout << "  Returned step= " << Step;
    if( fVerbose > 5 )  { G4cout << G4endl; }
    if( Step == kInfinity )
    {
       G4cout << " Requested step= " << pCurrentProposedStepLength ;
       if( fVerbose > 5)  { G4cout << G4endl; }
    }
    G4cout << "  Safety = " << pNewSafety << G4endl;
  }
#endif
 
  return Step;
}

References CharacteriseDaughters(), CheckOverlapsIterative(), ComputeLocalAxis(), ComputeLocalPoint(), G4ParameterisedNavigation::ComputeStep(), G4RegularNavigation::ComputeStep(), G4VoxelNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4NormalNavigation::ComputeStep(), G4VExternalNavigation::ComputeStep(), ComputeStepLog(), EventMustBeAborted, fAbandonThreshold_NoZeroSteps, fActionThreshold_NoZeroSteps, FatalException, fBlockedPhysicalVolume, fBlockedReplicaNo, fCalculatedExitNormal, fChangedGrandMotherRefFrame, fEnteredDaughter, fEntering, fExitedMother, fExiting, fExitNormal, fExitNormalGlobalFrame, fGrandMotherExitNormal, fHistory, fLastLocatedPointLocal, fLastMotherPhys, fLastStepEndPointLocal, fLastStepWasZero, fLastTriedStepComputation, fLocatedOnEdge, fMinStep, fnormalNav, fNumberZeroSteps, fparamNav, fpExternalNav, fPreviousSafety, fPreviousSftOrigin, fPushed, fregularNav, freplicaNav, fSqTol, fStepEndPoint, fValidExitNormal, fVerbose, fWarnPush, G4cout, G4endl, G4Exception(), G4ThreadLocal, G4VPhysicalVolume::GetCopyNo(), GetDaughtersRegularStructureId(), G4NavigationHistory::GetDepth(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetName(), G4VPhysicalVolume::GetRegularStructureId(), G4VPhysicalVolume::GetRotation(), G4LogicalVolume::GetSolid(), G4NavigationHistory::GetTopVolume(), G4NavigationHistory::GetTopVolumeType(), G4NavigationHistory::GetTransform(), G4LogicalVolume::GetVoxelHeader(), GetVoxelNavigator(), G4AffineTransform::InverseTransformAxis(), JustWarning, kCarTolerance, kExternal, kInfinity, kNormal, kParameterised, kReplica, LocateGlobalPointAndSetup(), LocateGlobalPointWithinVolume(), G4INCL::Math::min(), PrintState(), and G4VSolid::SurfaceNormal().

Referenced by G4Transportation::AlongStepGetPhysicalInteractionLength(), CheckNextStep(), G4AdjointPrimaryGenerator::ComputeAccumulatedDepthVectorAlongBackRay(), and G4ErrorPropagationNavigator::ComputeStep().

ComputeStepLog()

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

private

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 fHistory, fLastLocatedPointLocal, fPreviousSafety, fPreviousSftOrigin, G4cerr, G4cout, G4endl, G4Exception(), G4ThreadLocal, G4NavigationHistory::GetTopTransform(), JustWarning, kCarTolerance, mm, and sqr().

Referenced by ComputeStep().

CreateGRSSolid()

G4GRSSolid * G4Navigator::CreateGRSSolid ( ) const

inline

CreateGRSVolume()

G4GRSVolume * G4Navigator::CreateGRSVolume ( ) const

inline

CreateTouchableHistory() [1/2]

G4TouchableHistory * G4Navigator::CreateTouchableHistory ( ) const

inline

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

CreateTouchableHistory() [2/2]

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

inline

CreateTouchableHistoryHandle()

G4TouchableHistoryHandle G4Navigator::CreateTouchableHistoryHandle ( ) const

virtual

Reimplemented in G4MultiNavigator.

Definition at line 1955 of file G4Navigator.cc.

{
  return G4TouchableHistoryHandle( CreateTouchableHistory() );
}

References CreateTouchableHistory().

Referenced by G4FastTrack::FRecordsAffineTransformation(), and G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck().

EnableBestSafety()

void G4Navigator::EnableBestSafety ( G4bool  value = false )

inline

EnteredDaughterVolume()

G4bool G4Navigator::EnteredDaughterVolume ( ) const

inline

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

ExitedMotherVolume()

G4bool G4Navigator::ExitedMotherVolume ( ) const

inline

Referenced by G4Transportation::PostStepDoIt().

GetCurrentLocalCoordinate()

G4ThreeVector G4Navigator::GetCurrentLocalCoordinate ( ) const

inline

GetDaughtersRegularStructureId()

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

inlineprotected

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

GetExternalNavigation()

G4VExternalNavigation * G4Navigator::GetExternalNavigation ( ) const

inline

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

GetGlobalExitNormal()

G4ThreeVector G4Navigator::GetGlobalExitNormal ( const G4ThreeVector &  point, G4bool *  valid  )

virtual

Reimplemented in G4MultiNavigator, and G4ErrorPropagationNavigator.

Definition at line 1642 of file G4Navigator.cc.

{
  G4bool         validNormal;
  G4ThreeVector  localNormal, globalNormal;
 
  G4bool usingStored = fCalculatedExitNormal && (
       ( fLastTriedStepComputation && fExiting ) // Just calculated it
       ||                                        // No locate in between
       ( !fLastTriedStepComputation
          && (IntersectPointGlobal-fStepEndPoint).mag2() < 10.0*fSqTol ) );
           // Calculated it 'just' before & then called locate
           // but it did not move position
  
  if( usingStored )
  {
    // This was computed in last call to ComputeStep
    // and only if it arrived at boundary
    //
    globalNormal = fExitNormalGlobalFrame; 
    G4double  normMag2 = globalNormal.mag2(); 
    if( std::fabs ( normMag2 - 1.0 ) < perThousand ) // was perMillion
    {
       *pNormalCalculated = true; // ComputeStep always computes it if Exiting
                                  // (fExiting==true)
    }
    else
    {
       G4ExceptionDescription message;
       message.precision(10); 
       message << " WARNING> Expected normal-global-frame to be valid, "
               << " i.e. a unit vector!" << G4endl
               << "  - but |normal|   = "  << std::sqrt(normMag2)
               << "  - and |normal|^2 = "  << normMag2 << G4endl
               << " which differs from 1.0 by " << normMag2 - 1.0 << G4endl
               << "   n = " << fExitNormalGlobalFrame << G4endl
               << " Global point: " << IntersectPointGlobal << G4endl
               << " Volume: " << fHistory.GetTopVolume()->GetName() << G4endl;
#ifdef G4VERBOSE
       G4LogicalVolume* candLog = fHistory.GetTopVolume()->GetLogicalVolume();
       if ( candLog )
       {
         message << " Solid: " << candLog->GetSolid()->GetName()
                 << ", Type: " << candLog->GetSolid()->GetEntityType() << G4endl
                 << *candLog->GetSolid() << G4endl;
       }
#endif
       message << "============================================================"
               << G4endl;
       G4int oldVerbose = fVerbose; 
       fVerbose = 4; 
       message << "   State of Navigator: " << G4endl;
       message << *this << G4endl;
       fVerbose = oldVerbose; 
       message << "============================================================"
               << G4endl;
 
       G4Exception("G4Navigator::GetGlobalExitNormal()",
                   "GeomNav0003",JustWarning, message,
              "Value obtained from stored global-normal is not a unit vector.");
 
       // (Re)Compute it now -- as either it was not computed, or it is wrong.
       //
       localNormal = GetLocalExitNormalAndCheck(IntersectPointGlobal,
                                                &validNormal);
       *pNormalCalculated = fCalculatedExitNormal;
       globalNormal = fHistory.GetTopTransform()
                     .InverseTransformAxis(localNormal);
    }
  }
  else
  {
    localNormal = GetLocalExitNormalAndCheck(IntersectPointGlobal,&validNormal);
    *pNormalCalculated = fCalculatedExitNormal;
 
#ifdef G4DEBUG_NAVIGATION
    usingStored = false;
 
    if( (!validNormal) && !fCalculatedExitNormal )
    {
      G4ExceptionDescription edN;
      edN << "  Calculated = " << fCalculatedExitNormal << G4endl;
      edN << "   Entering= "  << fEntering << G4endl;
      G4int oldVerbose = this->GetVerboseLevel();
      this->SetVerboseLevel(4);
      edN << "   State of Navigator: " << G4endl;
      edN << *this << G4endl;
      this->SetVerboseLevel( oldVerbose );
       
      G4Exception("G4Navigator::GetGlobalExitNormal()",
                  "GeomNav0003", JustWarning, edN,
                  "LocalExitNormalAndCheck() did not calculate Normal.");
     }
#endif
     
     G4double localMag2 = localNormal.mag2();
     if( validNormal && (std::fabs(localMag2-1.0)) > kToleranceNormalCheck )
     {
       G4ExceptionDescription edN;
       edN.precision(10); 
       edN << "G4Navigator::GetGlobalExitNormal: "
           << "  Using Local Normal - from call to GetLocalExitNormalAndCheck. "
           << G4endl
           << "  Local  Exit Normal : " << " || = " << std::sqrt(localMag2) 
           << " vec = " << localNormal << G4endl
           << "  Global Exit Normal : " << " || = " << globalNormal.mag() 
           << " vec = " << globalNormal << G4endl
           << "  Global point: " << IntersectPointGlobal << G4endl;
       edN << "  Calculated It      = " << fCalculatedExitNormal << G4endl
           << "  Volume: " << fHistory.GetTopVolume()->GetName() << G4endl;
#ifdef G4VERBOSE
       G4LogicalVolume* candLog = fHistory.GetTopVolume()->GetLogicalVolume();
       if ( candLog )
       {
         edN << "  Solid: " << candLog->GetSolid()->GetName()
             << ", Type: " << candLog->GetSolid()->GetEntityType() << G4endl
             << *candLog->GetSolid();
       }
#endif
       G4Exception("G4Navigator::GetGlobalExitNormal()",
                   "GeomNav0003",JustWarning, edN,
                   "Value obtained from new local *solid* is incorrect.");
       localNormal = localNormal.unit(); // Should we correct it ??
     }
     globalNormal = fHistory.GetTopTransform()
                   .InverseTransformAxis(localNormal);
  }
 
#ifdef G4DEBUG_NAVIGATION
  if( usingStored )
  {
    G4ThreeVector globalNormAgn; 
 
    localNormal = GetLocalExitNormalAndCheck(IntersectPointGlobal,&validNormal);
    
    globalNormAgn = fHistory.GetTopTransform()
                   .InverseTransformAxis(localNormal);
    
    // Check the value computed against fExitNormalGlobalFrame
    G4ThreeVector diffNorm = globalNormAgn - fExitNormalGlobalFrame;
    if( diffNorm.mag2() > kToleranceNormalCheck )
    {
      G4ExceptionDescription edDfn;
      edDfn << "Found difference in normals in case of exiting mother "
            << "- when Get is called after ComputingStep " << G4endl;
      edDfn << "  Magnitude of diff =      " << diffNorm.mag() << G4endl;
      edDfn << "  Normal stored (Global)     = " << fExitNormalGlobalFrame
            << G4endl;
      edDfn << "  Global Computed from Local = " << globalNormAgn << G4endl;
      G4Exception("G4Navigator::GetGlobalExitNormal()", "GeomNav0003",
                  JustWarning, edDfn);
    }
  }
#endif
 
  // Synchronise stored global exit normal as possibly re-computed here
  //
  fExitNormalGlobalFrame = globalNormal;
 
  return globalNormal;
}

References fCalculatedExitNormal, fEntering, fExiting, fExitNormalGlobalFrame, fHistory, fLastTriedStepComputation, fSqTol, fStepEndPoint, fVerbose, G4endl, G4Exception(), G4VSolid::GetEntityType(), GetLocalExitNormalAndCheck(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetName(), G4VSolid::GetName(), G4LogicalVolume::GetSolid(), G4NavigationHistory::GetTopTransform(), G4NavigationHistory::GetTopVolume(), GetVerboseLevel(), G4AffineTransform::InverseTransformAxis(), JustWarning, kToleranceNormalCheck, CLHEP::Hep3Vector::mag(), CLHEP::Hep3Vector::mag2(), perThousand, SetVerboseLevel(), and CLHEP::Hep3Vector::unit().

Referenced by G4MultiNavigator::GetGlobalExitNormal(), G4ErrorPropagationNavigator::GetGlobalExitNormal(), G4VIntersectionLocator::GetLastSurfaceNormal(), and G4MicroElecSurface::PostStepDoIt().

GetGlobalToLocalTransform()

const G4AffineTransform & G4Navigator::GetGlobalToLocalTransform ( ) const

inline

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

GetLastStepEndPoint()

G4ThreeVector G4Navigator::GetLastStepEndPoint ( ) const

inline

Definition at line 304 of file G4Navigator.hh.

{ return fStepEndPoint;}

References fStepEndPoint.

GetLocalExitNormal()

G4ThreeVector G4Navigator::GetLocalExitNormal ( G4bool *  valid )

virtual

Reimplemented in G4MultiNavigator.

Definition at line 1389 of file G4Navigator.cc.

{
  G4ThreeVector    ExitNormal(0.,0.,0.);
  G4VSolid* currentSolid = nullptr;
  G4LogicalVolume* candidateLogical;
 
  if ( fLastTriedStepComputation ) 
  {
    // use fLastLocatedPointLocal and next candidate volume
    //
    G4ThreeVector nextSolidExitNormal(0.,0.,0.);
 
    if( fEntering && (fBlockedPhysicalVolume!=0) ) 
    { 
      candidateLogical = fBlockedPhysicalVolume->GetLogicalVolume();
      if( candidateLogical ) 
      {
        // fLastStepEndPointLocal is in the coordinates of the mother
        // we need it in the daughter's coordinate system.
 
        // The following code should also work in case of Replica
        {
          // First transform fLastLocatedPointLocal to the new daughter
          // coordinates
          //
          G4AffineTransform MotherToDaughterTransform=
            GetMotherToDaughterTransform( fBlockedPhysicalVolume, 
                                          fBlockedReplicaNo,
                                          VolumeType(fBlockedPhysicalVolume) ); 
          G4ThreeVector daughterPointOwnLocal =
            MotherToDaughterTransform.TransformPoint( fLastStepEndPointLocal ); 
 
          // OK if it is a parameterised volume
          //
          EInside inSideIt; 
          G4bool onSurface;
          G4double safety = -1.0; 
          currentSolid = candidateLogical->GetSolid(); 
          inSideIt = currentSolid->Inside(daughterPointOwnLocal); 
          onSurface = (inSideIt == kSurface); 
          if( !onSurface ) 
          {
            if( inSideIt == kOutside )
            {
              safety = (currentSolid->DistanceToIn(daughterPointOwnLocal)); 
              onSurface = safety < 100.0 * kCarTolerance; 
            }
            else if (inSideIt == kInside )
            {
              safety = (currentSolid->DistanceToOut(daughterPointOwnLocal)); 
              onSurface = safety < 100.0 * kCarTolerance; 
            }
          }
 
          if( onSurface ) 
          {
            nextSolidExitNormal =
              currentSolid->SurfaceNormal(daughterPointOwnLocal);
 
            // Entering the solid ==> opposite
            //
            // First flip ( ExitNormal = -nextSolidExitNormal; )
            //  and then rotate the the normal to the frame of the mother (current volume)
            ExitNormal = MotherToDaughterTransform
                        .InverseTransformAxis( -nextSolidExitNormal );
            fCalculatedExitNormal = true;
          }
          else
          {
#ifdef G4VERBOSE
            if(( fVerbose == 1 ) && ( fCheck ))
            {
              std::ostringstream message;
              message << "Point not on surface ! " << G4endl
                      << "  Point           = "
                      << daughterPointOwnLocal << G4endl 
                      << "  Physical volume = "
                      << fBlockedPhysicalVolume->GetName() << G4endl
                      << "  Logical volume  = "
                      << candidateLogical->GetName() << G4endl
                      << "  Solid           = " << currentSolid->GetName() 
                      << "  Type            = "
                      << currentSolid->GetEntityType() << G4endl
                      << *currentSolid << G4endl;
              if( inSideIt == kOutside )
              { 
                message << "Point is Outside. " << G4endl
                        << "  Safety (from outside) = " << safety << G4endl;
              }
              else // if( inSideIt == kInside ) 
              {
                message << "Point is Inside. " << G4endl
                        << "  Safety (from inside) = " << safety << G4endl;
              }
              G4Exception("G4Navigator::GetLocalExitNormal()", "GeomNav1001",
                          JustWarning, message);
            }
#endif
          }
          *valid = onSurface;   //   was =true;
        }
      }
    }
    else if ( fExiting ) 
    {
      ExitNormal = fGrandMotherExitNormal;
      *valid = true;
      fCalculatedExitNormal = true;  // Should be true already
    }
    else  // i.e.  ( fBlockedPhysicalVolume == 0 )
    {
      *valid = false;
      G4Exception("G4Navigator::GetLocalExitNormal()",
                  "GeomNav0003", JustWarning, 
                  "Incorrect call to GetLocalSurfaceNormal." );
    }
  }
  else //  ( ! fLastTriedStepComputation ) i.e. last call was to Locate
  {
    if ( EnteredDaughterVolume() )
    {
      G4VSolid* daughterSolid = fHistory.GetTopVolume()->GetLogicalVolume()
                                                       ->GetSolid();
      ExitNormal = -(daughterSolid->SurfaceNormal(fLastLocatedPointLocal));
      if( std::fabs(ExitNormal.mag2()-1.0 ) > kToleranceNormalCheck )
      {
        G4ExceptionDescription desc;
        desc << " Parameters of solid: " << *daughterSolid
             << " Point for surface = " << fLastLocatedPointLocal << std::endl;
        G4Exception("G4Navigator::GetLocalExitNormal()",
                    "GeomNav0003", FatalException, desc,
                    "Surface Normal returned by Solid is not a Unit Vector." );
      }
      fCalculatedExitNormal = true;
      *valid = true;
    }
    else
    {
      if( fExitedMother )
      {
        ExitNormal = fGrandMotherExitNormal;
        *valid = true;
        fCalculatedExitNormal = true;
      }
      else  // We are not at a boundary. ExitNormal remains (0,0,0)
      { 
        *valid = false;
        fCalculatedExitNormal = false; 
        G4ExceptionDescription message; 
        message << "Function called when *NOT* at a Boundary." << G4endl;
        message << "Exit Normal not calculated." << G4endl;
        G4Exception("G4Navigator::GetLocalExitNormal()",
                    "GeomNav0003", JustWarning, message); 
      }
    }
  }
  return ExitNormal;
}

References G4VSolid::DistanceToIn(), G4VSolid::DistanceToOut(), EnteredDaughterVolume(), FatalException, fBlockedPhysicalVolume, fBlockedReplicaNo, fCalculatedExitNormal, fCheck, fEntering, fExitedMother, fExiting, fGrandMotherExitNormal, fHistory, fLastLocatedPointLocal, fLastStepEndPointLocal, fLastTriedStepComputation, fVerbose, G4endl, G4Exception(), G4VSolid::GetEntityType(), G4VPhysicalVolume::GetLogicalVolume(), GetMotherToDaughterTransform(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetName(), G4VSolid::GetName(), G4LogicalVolume::GetSolid(), G4NavigationHistory::GetTopVolume(), G4VSolid::Inside(), G4AffineTransform::InverseTransformAxis(), JustWarning, kCarTolerance, kInside, kOutside, kSurface, kToleranceNormalCheck, CLHEP::Hep3Vector::mag2(), G4VSolid::SurfaceNormal(), G4AffineTransform::TransformPoint(), and VolumeType().

Referenced by G4RayTrajectory::AppendStep(), G4MultiNavigator::GetLocalExitNormal(), GetLocalExitNormalAndCheck(), and G4VTransitionRadiation::PostStepDoIt().

GetLocalExitNormalAndCheck()

G4ThreeVector G4Navigator::GetLocalExitNormalAndCheck ( const G4ThreeVector &  point, G4bool *  valid  )

virtual

Reimplemented in G4MultiNavigator.

Definition at line 1606 of file G4Navigator.cc.

{
#ifdef G4DEBUG_NAVIGATION
  // Check Current point against expected 'local' value
  //
  if ( fLastTriedStepComputation ) 
  {
    G4ThreeVector ExpectedBoundaryPointLocal;
 
    const G4AffineTransform& GlobalToLocal = GetGlobalToLocalTransform(); 
    ExpectedBoundaryPointLocal =
      GlobalToLocal.TransformPoint( ExpectedBoundaryPointGlobal ); 
 
    // Add here:  Comparison against expected position,
    //            i.e. the endpoint of ComputeStep
  }
#endif
  
  return GetLocalExitNormal( pValid ); 
}

References fLastTriedStepComputation, GetGlobalToLocalTransform(), GetLocalExitNormal(), and G4AffineTransform::TransformPoint().

Referenced by GetGlobalExitNormal().

GetLocalToGlobalTransform()

const G4AffineTransform G4Navigator::GetLocalToGlobalTransform ( ) const

inline

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

GetMotherToDaughterTransform()

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

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

GetVerboseLevel()

G4int G4Navigator::GetVerboseLevel ( ) const

inline

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

GetVoxelNavigator()

G4VoxelNavigation & G4Navigator::GetVoxelNavigator ( )

inlineprivate

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

GetWorldVolume()

G4VPhysicalVolume * G4Navigator::GetWorldVolume ( ) const

inline

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

InformLastStep()

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

Definition at line 2240 of file G4Navigator.cc.

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

References fEntering, fExiting, fLastStepWasZero, and fLocatedOnEdge.

IsActive()

G4bool G4Navigator::IsActive ( ) const

inline

Referenced by export_G4Navigator().

IsCheckModeActive()

G4bool G4Navigator::IsCheckModeActive ( ) const

inline

Referenced by G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck().

LocateGlobalPointAndSetup()

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

virtual

Reimplemented in G4MultiNavigator.

Definition at line 132 of file G4Navigator.cc.

{
  G4bool notKnownContained = true, noResult;
  G4VPhysicalVolume *targetPhysical;
  G4LogicalVolume *targetLogical;
  G4VSolid *targetSolid = 0;
  G4ThreeVector localPoint, globalDirection;
  EInside insideCode;
 
  G4bool considerDirection = (!ignoreDirection) || fLocatedOnEdge;
 
  fLastTriedStepComputation = false;   
  fChangedGrandMotherRefFrame = false;  // For local exit normal
   
  if( considerDirection && pGlobalDirection != nullptr )
  {
    globalDirection=*pGlobalDirection;
  }
 
#ifdef G4VERBOSE
  if( fVerbose > 2 )
  {
    G4int oldcoutPrec = G4cout.precision(8);
    G4cout << "*** G4Navigator::LocateGlobalPointAndSetup: ***" << G4endl; 
    G4cout << "    Called with arguments: " << G4endl
           << "        Globalpoint = " << globalPoint << G4endl
           << "        RelativeSearch = " << relativeSearch  << G4endl;
    if( fVerbose >= 4 )
    {
      G4cout << "    ----- Upon entering:" << G4endl;
      PrintState();
    }
    G4cout.precision(oldcoutPrec);
  }
#endif
 
  G4int noLevelsExited = 0;
  G4int noLevelsEntered = 0;
 
  if ( !relativeSearch )
  {
    ResetStackAndState();
  }
  else
  {
    if ( fWasLimitedByGeometry )
    {
      fWasLimitedByGeometry = false;
      fEnteredDaughter = fEntering;   // Remember
      fExitedMother = fExiting;       // Remember
      if ( fExiting )
      {
        ++noLevelsExited;  // count this first level entered too
 
        if ( fHistory.GetDepth() )
        {
          fBlockedPhysicalVolume = fHistory.GetTopVolume();
          fBlockedReplicaNo = fHistory.GetTopReplicaNo();
          fHistory.BackLevel();
        }
        else
        {
          fLastLocatedPointLocal = localPoint;
          fLocatedOutsideWorld = true;
          fBlockedPhysicalVolume = 0;   // to be sure
          fBlockedReplicaNo = -1;
          fEntering = false;            // No longer 
          fEnteredDaughter = false; 
          fExitedMother = true;      // ??
          
          return nullptr;           // Have exited world volume
        }
        // A fix for the case where a volume is "entered" at an edge
        // and a coincident surface exists outside it.
        //  - This stops it from exiting further volumes and cycling
        //  - However ReplicaNavigator treats this case itself
        //
        // assert( fBlockedPhysicalVolume!=0 );
 
        // Expect to be on edge => on surface
        //
        if ( fLocatedOnEdge && (VolumeType(fBlockedPhysicalVolume)!=kReplica ))
        { 
          fExiting = false;
          // Consider effect on Exit Normal !?
        }
      }
      else
        if ( fEntering )
        {
          // assert( fBlockedPhysicalVolume!=0 );
 
          ++noLevelsEntered;   // count the first level entered too
 
          switch (VolumeType(fBlockedPhysicalVolume))
          {
            case kNormal:
              fHistory.NewLevel(fBlockedPhysicalVolume, kNormal,
                                fBlockedPhysicalVolume->GetCopyNo());
              break;
            case kReplica:
              freplicaNav.ComputeTransformation(fBlockedReplicaNo,
                                                fBlockedPhysicalVolume);
              fHistory.NewLevel(fBlockedPhysicalVolume, kReplica,
                                fBlockedReplicaNo);
              fBlockedPhysicalVolume->SetCopyNo(fBlockedReplicaNo);
              break;
            case kParameterised:
              if( fBlockedPhysicalVolume->GetRegularStructureId() == 0 )
              {
                G4VSolid *pSolid;
                G4VPVParameterisation *pParam;
                G4TouchableHistory parentTouchable( fHistory );
                pParam = fBlockedPhysicalVolume->GetParameterisation();
                pSolid = pParam->ComputeSolid(fBlockedReplicaNo,
                                              fBlockedPhysicalVolume);
                pSolid->ComputeDimensions(pParam, fBlockedReplicaNo,
                                          fBlockedPhysicalVolume);
                pParam->ComputeTransformation(fBlockedReplicaNo,
                                              fBlockedPhysicalVolume);
                fHistory.NewLevel(fBlockedPhysicalVolume, kParameterised,
                                  fBlockedReplicaNo);
                fBlockedPhysicalVolume->SetCopyNo(fBlockedReplicaNo);
                //
                // Set the correct solid and material in Logical Volume
                //
                G4LogicalVolume *pLogical;
                pLogical = fBlockedPhysicalVolume->GetLogicalVolume();
                pLogical->SetSolid( pSolid );
                pLogical->UpdateMaterial(pParam ->
                  ComputeMaterial(fBlockedReplicaNo,
                                  fBlockedPhysicalVolume, 
                                  &parentTouchable));
              }
              break;
            case kExternal:
              G4Exception("G4Navigator::LocateGlobalPointAndSetup()",
                          "GeomNav0001", FatalException,
                          "Extra levels not applicable for external volumes.");
              break;
          }
          fEntering = false;
          fBlockedPhysicalVolume = nullptr;
          localPoint = fHistory.GetTopTransform().TransformPoint(globalPoint);
          notKnownContained = false;
        }
    }
    else
    {
      fBlockedPhysicalVolume = nullptr;
      fEntering = false;
      fEnteredDaughter = false;  // Full Step was not taken, did not enter
      fExiting = false;
      fExitedMother = false;     // Full Step was not taken, did not exit
    }
  }
  //
  // Search from top of history up through geometry until
  // containing volume found:
  // If on 
  // o OUTSIDE - Back up level, not/no longer exiting volumes
  // o SURFACE and EXITING - Back up level, setting new blocking no.s
  // else
  // o containing volume found
  //
 
  while (notKnownContained)  // Loop checking, 07.10.2016, J.Apostolakis
  {
    EVolume topVolumeType = fHistory.GetTopVolumeType(); 
    if (topVolumeType!=kReplica && topVolumeType!=kExternal)
    {
      targetSolid = fHistory.GetTopVolume()->GetLogicalVolume()->GetSolid();
      localPoint = fHistory.GetTopTransform().TransformPoint(globalPoint);
      insideCode = targetSolid->Inside(localPoint);
#ifdef G4VERBOSE
      if(( fVerbose == 1 ) && ( fCheck ))
      {
        G4String solidResponse = "-kInside-";
        if (insideCode == kOutside)
          solidResponse = "-kOutside-";
        else if (insideCode == kSurface)
          solidResponse = "-kSurface-";
        G4cout << "*** G4Navigator::LocateGlobalPointAndSetup(): ***" << G4endl
               << "    Invoked Inside() for solid: " << targetSolid->GetName()
               << ". Solid replied: " << solidResponse << G4endl
               << "    For local point p: " << localPoint << G4endl;
      }
#endif
    }
    else
    {
       if( topVolumeType == kReplica )
       {
          insideCode = freplicaNav.BackLocate(fHistory, globalPoint, localPoint,
                                              fExiting, notKnownContained);
          // !CARE! if notKnownContained returns false then the point is within
          // the containing placement volume of the replica(s). If insidecode
          // will result in the history being backed up one level, then the
          // local point returned is the point in the system of this new level
       }
       else
       {
          targetSolid = fHistory.GetTopVolume()->GetLogicalVolume()->GetSolid();
          localPoint = fHistory.GetTopTransform().TransformPoint(globalPoint);
          G4ThreeVector localDirection =
             fHistory.GetTopTransform().TransformAxis(globalDirection);
          insideCode = fpExternalNav->Inside(targetSolid, localPoint, localDirection);
       }
    }
 
    if ( insideCode==kOutside )
    {
      ++noLevelsExited; 
      if ( fHistory.GetDepth() )
      {
        fBlockedPhysicalVolume = fHistory.GetTopVolume();
        fBlockedReplicaNo = fHistory.GetTopReplicaNo();
        fHistory.BackLevel();
        fExiting = false;
 
        if( noLevelsExited > 1 )
        {
          // The first transformation was done by the sub-navigator
          //
          const G4RotationMatrix* mRot = fBlockedPhysicalVolume->GetRotation();
          if( mRot )
          { 
            fGrandMotherExitNormal *= (*mRot).inverse();
            fChangedGrandMotherRefFrame = true;
          }
        }
      }
      else
      {
        fLastLocatedPointLocal = localPoint;
        fLocatedOutsideWorld = true;
          // No extra transformation for ExitNormal - is in frame of Top Volume
        return nullptr;         // Have exited world volume
      }
    }
    else
      if ( insideCode==kSurface )
      {
        G4bool isExiting = fExiting;
        if( (!fExiting) && considerDirection )
        {
          // Figure out whether we are exiting this level's volume
          // by using the direction
          //
          G4bool directionExiting = false;
          G4ThreeVector localDirection =
              fHistory.GetTopTransform().TransformAxis(globalDirection);
 
          // Make sure localPoint in correct reference frame
          //     ( Was it already correct ? How ? )
          //
          localPoint= fHistory.GetTopTransform().TransformPoint(globalPoint);
          if ( fHistory.GetTopVolumeType() != kReplica )
          {
            G4ThreeVector normal = targetSolid->SurfaceNormal(localPoint);
            directionExiting = normal.dot(localDirection) > 0.0;
            isExiting = isExiting || directionExiting;
          }
        }
        if( isExiting )
        {
          ++noLevelsExited; 
          if ( fHistory.GetDepth() )
          {
            fBlockedPhysicalVolume = fHistory.GetTopVolume();
            fBlockedReplicaNo = fHistory.GetTopReplicaNo();
            fHistory.BackLevel();
            //
            // Still on surface but exited volume not necessarily convex
            //
            fValidExitNormal = false;
 
            if( noLevelsExited > 1 )
            {
              // The first transformation was done by the sub-navigator
              //
              const G4RotationMatrix* mRot =
                    fBlockedPhysicalVolume->GetRotation();
              if( mRot )
              { 
                fGrandMotherExitNormal *= (*mRot).inverse();
                fChangedGrandMotherRefFrame = true;
              }
            }
          } 
          else
          {
            fLastLocatedPointLocal = localPoint;
            fLocatedOutsideWorld = true;
              // No extra transformation for ExitNormal, is in frame of Top Vol
            return nullptr;          // Have exited world volume
          }
        }
        else
        {
          notKnownContained = false;
        }
      }
      else
      {
        notKnownContained = false;
      }
  }  // END while (notKnownContained)
  //
  // Search downwards until deepest containing volume found,
  // blocking fBlockedPhysicalVolume/BlockedReplicaNum
  //
  // 3 Cases:
  //
  // o Parameterised daughters
  //   =>Must be one G4PVParameterised daughter & voxels
  // o Positioned daughters & voxels
  // o Positioned daughters & no voxels
 
  noResult = true;  // noResult should be renamed to
                    // something like enteredLevel, as that is its meaning.
  do
  {
    // Determine `type' of current mother volume
    //
    targetPhysical = fHistory.GetTopVolume();
    if (!targetPhysical) { break; }
    targetLogical = targetPhysical->GetLogicalVolume();
    switch( CharacteriseDaughters(targetLogical) )
    {
      case kNormal:
        if ( targetLogical->GetVoxelHeader() )  // use optimised navigation
        {
          noResult = GetVoxelNavigator().LevelLocate(fHistory,
                                           fBlockedPhysicalVolume,
                                           fBlockedReplicaNo,
                                           globalPoint,
                                           pGlobalDirection,
                                           considerDirection,
                                           localPoint);
        }
        else                       // do not use optimised navigation
        {
          noResult = fnormalNav.LevelLocate(fHistory,
                                            fBlockedPhysicalVolume,
                                            fBlockedReplicaNo,
                                            globalPoint,
                                            pGlobalDirection,
                                            considerDirection,
                                            localPoint);
        }
        break;
      case kReplica:
        noResult = freplicaNav.LevelLocate(fHistory,
                                           fBlockedPhysicalVolume,
                                           fBlockedReplicaNo,
                                           globalPoint,
                                           pGlobalDirection,
                                           considerDirection,
                                           localPoint);
        break;
      case kParameterised:
        if( GetDaughtersRegularStructureId(targetLogical) != 1 )
        {
          noResult = fparamNav.LevelLocate(fHistory,
                                           fBlockedPhysicalVolume,
                                           fBlockedReplicaNo,
                                           globalPoint,
                                           pGlobalDirection,
                                           considerDirection,
                                           localPoint);
        }
        else  // Regular structure
        {
          noResult = fregularNav.LevelLocate(fHistory,
                                             fBlockedPhysicalVolume,
                                             fBlockedReplicaNo,
                                             globalPoint,
                                             pGlobalDirection,
                                             considerDirection,
                                             localPoint);
        }
        break;
      case kExternal:
        noResult = fpExternalNav->LevelLocate(fHistory,
                                              fBlockedPhysicalVolume,
                                              fBlockedReplicaNo,
                                              globalPoint,
                                              pGlobalDirection,
                                              considerDirection,
                                              localPoint);
        break;
    }
 
    // LevelLocate returns true if it finds a daughter volume 
    // in which globalPoint is inside (or on the surface).
 
    if ( noResult )
    {
      ++noLevelsEntered;
      
      // Entering a daughter after ascending
      //
      // The blocked volume is no longer valid - it was for another level
      //
      fBlockedPhysicalVolume = nullptr;
      fBlockedReplicaNo = -1;
 
      // fEntering should be false -- else blockedVolume is assumed good.
      // fEnteredDaughter is used for ExitNormal
      //
      fEntering = false;
      fEnteredDaughter = true;
 
      if( fExitedMother )
      {
        G4VPhysicalVolume* enteredPhysical = fHistory.GetTopVolume();
        const G4RotationMatrix* mRot = enteredPhysical->GetRotation();
        if( mRot )
        { 
          // Go deeper, i.e. move 'down' in the hierarchy
          // Apply direct rotation, not inverse
          //
          fGrandMotherExitNormal *= (*mRot);
          fChangedGrandMotherRefFrame= true;
        }
      }
 
#ifdef G4DEBUG_NAVIGATION
      if( fVerbose > 2 )
      { 
         G4VPhysicalVolume* enteredPhysical = fHistory.GetTopVolume();
         G4cout << "*** G4Navigator::LocateGlobalPointAndSetup() ***" << G4endl;
         G4cout << "    Entering volume: " << enteredPhysical->GetName()
                << G4endl;
      }
#endif
    }
  } while (noResult);  // Loop checking, 07.10.2016, J.Apostolakis
 
  fLastLocatedPointLocal = localPoint;
 
#ifdef G4VERBOSE
  if( fVerbose >= 4 )
  {
    G4int oldcoutPrec = G4cout.precision(8);
    G4String curPhysVol_Name("None");
    if (targetPhysical)  { curPhysVol_Name = targetPhysical->GetName(); }
    G4cout << "    Return value = new volume = " << curPhysVol_Name << G4endl;
    G4cout << "    ----- Upon exiting:" << G4endl;
    PrintState();
    if( fVerbose >= 5 )
    {
      G4cout << "Upon exiting LocateGlobalPointAndSetup():" << G4endl;
      G4cout << "    History = " << G4endl << fHistory << G4endl << G4endl;
    }
    G4cout.precision(oldcoutPrec);
  }
#endif
 
  fLocatedOutsideWorld = false;
 
  return targetPhysical;
}

References G4NavigationHistory::BackLevel(), G4ReplicaNavigation::BackLocate(), CharacteriseDaughters(), G4VSolid::ComputeDimensions(), G4VPVParameterisation::ComputeSolid(), G4ReplicaNavigation::ComputeTransformation(), G4VPVParameterisation::ComputeTransformation(), FatalException, fBlockedPhysicalVolume, fBlockedReplicaNo, fChangedGrandMotherRefFrame, fCheck, fEnteredDaughter, fEntering, fExitedMother, fExiting, fGrandMotherExitNormal, fHistory, fLastLocatedPointLocal, fLastTriedStepComputation, fLocatedOnEdge, fLocatedOutsideWorld, fnormalNav, fparamNav, fpExternalNav, fregularNav, freplicaNav, fValidExitNormal, fVerbose, fWasLimitedByGeometry, G4cout, G4endl, G4Exception(), G4VPhysicalVolume::GetCopyNo(), GetDaughtersRegularStructureId(), G4NavigationHistory::GetDepth(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetName(), G4VSolid::GetName(), G4VPhysicalVolume::GetParameterisation(), G4VPhysicalVolume::GetRegularStructureId(), G4VPhysicalVolume::GetRotation(), G4LogicalVolume::GetSolid(), G4NavigationHistory::GetTopReplicaNo(), G4NavigationHistory::GetTopTransform(), G4NavigationHistory::GetTopVolume(), G4NavigationHistory::GetTopVolumeType(), G4LogicalVolume::GetVoxelHeader(), GetVoxelNavigator(), G4VSolid::Inside(), G4VExternalNavigation::Inside(), kExternal, kNormal, kOutside, kParameterised, kReplica, kSurface, G4NormalNavigation::LevelLocate(), G4ParameterisedNavigation::LevelLocate(), G4RegularNavigation::LevelLocate(), G4ReplicaNavigation::LevelLocate(), G4VoxelNavigation::LevelLocate(), G4VExternalNavigation::LevelLocate(), G4NavigationHistory::NewLevel(), CLHEP::normal(), PrintState(), ResetStackAndState(), G4VPhysicalVolume::SetCopyNo(), G4LogicalVolume::SetSolid(), G4VSolid::SurfaceNormal(), G4AffineTransform::TransformAxis(), G4AffineTransform::TransformPoint(), G4LogicalVolume::UpdateMaterial(), and VolumeType().

Referenced by G4AdjointPrimaryGenerator::ComputeAccumulatedDepthVectorAlongBackRay(), ComputeStep(), G4VIntersectionLocator::GetLocalSurfaceNormal(), G4SPSPosDistribution::IsSourceConfined(), G4SafetyHelper::Locate(), G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck(), ResetHierarchyAndLocate(), and G4SteppingManager::SetInitialStep().

LocateGlobalPointAndUpdateTouchable() [1/2]

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

inline

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

LocateGlobalPointAndUpdateTouchable() [2/2]

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

inline

LocateGlobalPointAndUpdateTouchableHandle()

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

inline

LocateGlobalPointWithinVolume()

void G4Navigator::LocateGlobalPointWithinVolume ( const G4ThreeVector &  position )

virtual

Reimplemented in G4MultiNavigator.

Definition at line 614 of file G4Navigator.cc.

{
#ifdef G4DEBUG_NAVIGATION
   assert( !fWasLimitedByGeometry );   
   // Check: Either step was not limited by a boundary or 
   //          else the full step is no longer being taken
#endif
  
   fLastLocatedPointLocal = ComputeLocalPoint(pGlobalpoint);
   fLastTriedStepComputation = false;
   fChangedGrandMotherRefFrame = false;  //  Frame for Exit Normal
 
   // For the case of Voxel (or Parameterised) volume the respective 
   // Navigator must be messaged to update its voxel information etc
 
   // Update the state of the Sub Navigators 
   // - in particular any voxel information they store/cache
   //
   G4VPhysicalVolume*  motherPhysical = fHistory.GetTopVolume();
   G4LogicalVolume*    motherLogical  = motherPhysical->GetLogicalVolume();
   G4SmartVoxelHeader* pVoxelHeader   = motherLogical->GetVoxelHeader();
 
   switch( CharacteriseDaughters(motherLogical) )
   {
       case kNormal:
         if ( pVoxelHeader )
         {
           GetVoxelNavigator().VoxelLocate( pVoxelHeader, fLastLocatedPointLocal );
         }
         break;
       case kParameterised:
         if( GetDaughtersRegularStructureId(motherLogical) != 1 )
         {
           // Resets state & returns voxel node
           //
           fparamNav.ParamVoxelLocate( pVoxelHeader, fLastLocatedPointLocal );
         }
         break;
       case kReplica:
         // Nothing to do
         break;
       case kExternal:
         fpExternalNav->RelocateWithinVolume( motherPhysical,
                                              fLastLocatedPointLocal );
         break;
   }
 
   // Reset the state variables 
   //   - which would have been affected
   //     by the 'equivalent' call to LocateGlobalPointAndSetup
   //   - who's values have been invalidated by the 'move'.
   //
   fBlockedPhysicalVolume = nullptr; 
   fBlockedReplicaNo = -1;
   fEntering = false;
   fEnteredDaughter = false;  // Boundary not encountered, did not enter
   fExiting = false;
   fExitedMother = false;     // Boundary not encountered, did not exit
}

References CharacteriseDaughters(), ComputeLocalPoint(), fBlockedPhysicalVolume, fBlockedReplicaNo, fChangedGrandMotherRefFrame, fEnteredDaughter, fEntering, fExitedMother, fExiting, fHistory, fLastLocatedPointLocal, fLastTriedStepComputation, fparamNav, fpExternalNav, fWasLimitedByGeometry, GetDaughtersRegularStructureId(), G4VPhysicalVolume::GetLogicalVolume(), G4NavigationHistory::GetTopVolume(), G4LogicalVolume::GetVoxelHeader(), GetVoxelNavigator(), kExternal, kNormal, kParameterised, kReplica, G4ParameterisedNavigation::ParamVoxelLocate(), G4VExternalNavigation::RelocateWithinVolume(), and G4VoxelNavigation::VoxelLocate().

Referenced by G4VIntersectionLocator::AdjustmentOfFoundIntersection(), ComputeSafety(), ComputeStep(), G4PropagatorInField::ComputeStep(), G4BrentLocator::EstimateIntersectionPoint(), G4MultiLevelLocator::EstimateIntersectionPoint(), G4SimpleLocator::EstimateIntersectionPoint(), G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck(), G4Transportation::PostStepDoIt(), and G4SafetyHelper::ReLocateWithinVolume().

NetRotation()

G4RotationMatrix G4Navigator::NetRotation ( ) const

inline

NetTranslation()

G4ThreeVector G4Navigator::NetTranslation ( ) const

inline

operator=()

G4Navigator & G4Navigator::operator= ( const G4Navigator &  )

delete

PrintState()

void G4Navigator::PrintState

(

)

const

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 fBlockedPhysicalVolume, fBlockedReplicaNo, fEntering, fExiting, fExitNormal, fLastLocatedPointLocal, fLastStepWasZero, fPreviousSafety, fPreviousSftOrigin, fValidExitNormal, fVerbose, G4cout, G4endl, G4VPhysicalVolume::GetName(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

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

ResetHierarchyAndLocate()

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

virtual

Reimplemented in G4MultiNavigator.

Definition at line 102 of file G4Navigator.cc.

{
  ResetState();
  fHistory = *h.GetHistory();
  SetupHierarchy();
  fLastTriedStepComputation = false;  // Redundant, but best
  return LocateGlobalPointAndSetup(p, &direction, true, false);
}

References fHistory, fLastTriedStepComputation, G4TouchableHistory::GetHistory(), LocateGlobalPointAndSetup(), ResetState(), and SetupHierarchy().

Referenced by G4MultiNavigator::ResetHierarchyAndLocate(), and G4SteppingManager::SetInitialStep().

ResetStackAndState()

void G4Navigator::ResetStackAndState ( )

inline

Referenced by G4Navigator(), and LocateGlobalPointAndSetup().

ResetState()

void G4Navigator::ResetState ( )

protectedvirtual

Reimplemented in G4MultiNavigator.

Definition at line 1288 of file G4Navigator.cc.

{
  fWasLimitedByGeometry  = false;
  fEntering              = false;
  fExiting               = false;
  fLocatedOnEdge         = false;
  fLastStepWasZero       = false;
  fEnteredDaughter       = false;
  fExitedMother          = false;
  fPushed                = false;
 
  fValidExitNormal       = false;
  fChangedGrandMotherRefFrame = false;
  fCalculatedExitNormal  = false;
 
  fExitNormal            = G4ThreeVector(0,0,0);
  fGrandMotherExitNormal = G4ThreeVector(0,0,0);
  fExitNormalGlobalFrame = G4ThreeVector(0,0,0);
 
  fPreviousSftOrigin     = G4ThreeVector(0,0,0);
  fPreviousSafety        = 0.0; 
 
  fNumberZeroSteps       = 0;
 
  fBlockedPhysicalVolume = nullptr;
  fBlockedReplicaNo      = -1;
 
  fLastLocatedPointLocal = G4ThreeVector( kInfinity, -kInfinity, 0.0 ); 
  fLocatedOutsideWorld   = false;
 
  fLastMotherPhys = nullptr;
}

References fBlockedPhysicalVolume, fBlockedReplicaNo, fCalculatedExitNormal, fChangedGrandMotherRefFrame, fEnteredDaughter, fEntering, fExitedMother, fExiting, fExitNormal, fExitNormalGlobalFrame, fGrandMotherExitNormal, fLastLocatedPointLocal, fLastMotherPhys, fLastStepWasZero, fLocatedOnEdge, fLocatedOutsideWorld, fNumberZeroSteps, fPreviousSafety, fPreviousSftOrigin, fPushed, fValidExitNormal, fWasLimitedByGeometry, and kInfinity.

Referenced by ResetHierarchyAndLocate().

RestoreSavedState()

void G4Navigator::RestoreSavedState ( )

protected

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

References fBlockedPhysicalVolume, fBlockedReplicaNo, fEnteredDaughter, fEntering, fExitedMother, fExiting, fExitNormal, fLastLocatedPointLocal, fLastStepWasZero, fLocatedOutsideWorld, fPreviousSafety, fPreviousSftOrigin, fSaveState, fValidExitNormal, fWasLimitedByGeometry, G4Navigator::G4SaveNavigatorState::sBlockedReplicaNo, G4Navigator::G4SaveNavigatorState::sEnteredDaughter, G4Navigator::G4SaveNavigatorState::sEntering, G4Navigator::G4SaveNavigatorState::sExitedMother, G4Navigator::G4SaveNavigatorState::sExiting, G4Navigator::G4SaveNavigatorState::sExitNormal, G4Navigator::G4SaveNavigatorState::sLastLocatedPointLocal, G4Navigator::G4SaveNavigatorState::sLastStepWasZero, G4Navigator::G4SaveNavigatorState::sLocatedOutsideWorld, G4Navigator::G4SaveNavigatorState::spBlockedPhysicalVolume, G4Navigator::G4SaveNavigatorState::sPreviousSafety, G4Navigator::G4SaveNavigatorState::sPreviousSftOrigin, G4Navigator::G4SaveNavigatorState::sValidExitNormal, and G4Navigator::G4SaveNavigatorState::sWasLimitedByGeometry.

Referenced by CheckNextStep(), and ComputeSafety().

SetExternalNavigation()

void G4Navigator::SetExternalNavigation ( G4VExternalNavigation *  externalNav )

inline

SetGeometricallyLimitedStep()

void G4Navigator::SetGeometricallyLimitedStep ( )

inline

Referenced by G4Transportation::PostStepDoIt().

SetPushVerbosity()

void G4Navigator::SetPushVerbosity ( G4bool  mode )

inline

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

SetSavedState()

void G4Navigator::SetSavedState ( )

protected

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

References fBlockedPhysicalVolume, fBlockedReplicaNo, fEnteredDaughter, fEntering, fExitedMother, fExiting, fExitNormal, fLastLocatedPointLocal, fLastStepWasZero, fLocatedOutsideWorld, fPreviousSafety, fPreviousSftOrigin, fSaveState, fValidExitNormal, fWasLimitedByGeometry, G4Navigator::G4SaveNavigatorState::sBlockedReplicaNo, G4Navigator::G4SaveNavigatorState::sEnteredDaughter, G4Navigator::G4SaveNavigatorState::sEntering, G4Navigator::G4SaveNavigatorState::sExitedMother, G4Navigator::G4SaveNavigatorState::sExiting, G4Navigator::G4SaveNavigatorState::sExitNormal, G4Navigator::G4SaveNavigatorState::sLastLocatedPointLocal, G4Navigator::G4SaveNavigatorState::sLastStepWasZero, G4Navigator::G4SaveNavigatorState::sLocatedOutsideWorld, G4Navigator::G4SaveNavigatorState::spBlockedPhysicalVolume, G4Navigator::G4SaveNavigatorState::sPreviousSafety, G4Navigator::G4SaveNavigatorState::sPreviousSftOrigin, G4Navigator::G4SaveNavigatorState::sValidExitNormal, and G4Navigator::G4SaveNavigatorState::sWasLimitedByGeometry.

Referenced by CheckNextStep(), and ComputeSafety().

SetupHierarchy()

void G4Navigator::SetupHierarchy ( )

protectedvirtual

Reimplemented in G4MultiNavigator.

Definition at line 1329 of file G4Navigator.cc.

{
  const G4int cdepth = fHistory.GetDepth();
  G4VPhysicalVolume* current;
  G4VSolid* pSolid;
  G4VPVParameterisation* pParam;
 
  for ( auto i=1; i<=cdepth; ++i )
  {
    current = fHistory.GetVolume(i);
    switch ( fHistory.GetVolumeType(i) )
    {
      case kNormal:
      case kExternal:
        break;
      case kReplica:
        freplicaNav.ComputeTransformation(fHistory.GetReplicaNo(i), current);
        break;
      case kParameterised:
        G4int replicaNo;
        pParam = current->GetParameterisation();
        replicaNo = fHistory.GetReplicaNo(i);
        pSolid = pParam->ComputeSolid(replicaNo, current);
 
        // Set up dimensions & transform in solid/physical volume
        //
        pSolid->ComputeDimensions(pParam, replicaNo, current);
        pParam->ComputeTransformation(replicaNo, current);
 
        G4TouchableHistory* pTouchable = nullptr;
        if( pParam->IsNested() )
        {
          pTouchable= new G4TouchableHistory( fHistory );
          pTouchable->MoveUpHistory(); // Move up to the parent level
            // Adequate only if Nested at the Branch level (last)
            // To extend to other cases:
            // pTouchable->MoveUpHistory(cdepth-i-1);
            // Move to the parent level of *Current* level
            // Could replace this line and constructor with a revised
            // c-tor for History(levels to drop)
        }
        // Set up the correct solid and material in Logical Volume
        //
        G4LogicalVolume* pLogical = current->GetLogicalVolume();
        pLogical->SetSolid( pSolid );
        pLogical->UpdateMaterial( pParam ->
          ComputeMaterial(replicaNo, current, pTouchable) );
        delete pTouchable;
        break;
    }
  }
}

References G4VSolid::ComputeDimensions(), G4VPVParameterisation::ComputeSolid(), G4ReplicaNavigation::ComputeTransformation(), G4VPVParameterisation::ComputeTransformation(), fHistory, freplicaNav, G4NavigationHistory::GetDepth(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetParameterisation(), G4NavigationHistory::GetReplicaNo(), G4NavigationHistory::GetVolume(), G4NavigationHistory::GetVolumeType(), G4VPVParameterisation::IsNested(), kExternal, kNormal, kParameterised, kReplica, G4TouchableHistory::MoveUpHistory(), G4LogicalVolume::SetSolid(), and G4LogicalVolume::UpdateMaterial().

Referenced by ResetHierarchyAndLocate().

SetVerboseLevel()

void G4Navigator::SetVerboseLevel ( G4int  level )

inline

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

SetVoxelNavigation()

void G4Navigator::SetVoxelNavigation

(

G4VoxelNavigation *

voxelNav

)

SetWorldVolume()

void G4Navigator::SetWorldVolume ( G4VPhysicalVolume *  pWorld )

inline

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

SeverityOfZeroStepping()

G4int G4Navigator::SeverityOfZeroStepping ( G4int *  noZeroSteps ) const

inline

VolumeType()

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

inlineprotected

Referenced by GetLocalExitNormal(), and LocateGlobalPointAndSetup().

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

Field Documentation

fAbandonThreshold_NoZeroSteps

G4int G4Navigator::fAbandonThreshold_NoZeroSteps = 25

private

Definition at line 453 of file G4Navigator.hh.

Referenced by ComputeStep(), and G4Navigator().

fActionThreshold_NoZeroSteps

G4int G4Navigator::fActionThreshold_NoZeroSteps = 10

private

Definition at line 451 of file G4Navigator.hh.

Referenced by ComputeStep(), and G4Navigator().

fActive

G4bool G4Navigator::fActive = false

private

Definition at line 456 of file G4Navigator.hh.

fBlockedPhysicalVolume

G4VPhysicalVolume* G4Navigator::fBlockedPhysicalVolume

private

Definition at line 438 of file G4Navigator.hh.

Referenced by ComputeStep(), GetLocalExitNormal(), LocateGlobalPointAndSetup(), LocateGlobalPointWithinVolume(), PrintState(), ResetState(), RestoreSavedState(), and SetSavedState().

fBlockedReplicaNo

G4int G4Navigator::fBlockedReplicaNo

private

Definition at line 439 of file G4Navigator.hh.

Referenced by ComputeStep(), GetLocalExitNormal(), LocateGlobalPointAndSetup(), LocateGlobalPointWithinVolume(), PrintState(), ResetState(), RestoreSavedState(), and SetSavedState().

fCalculatedExitNormal

G4bool G4Navigator::fCalculatedExitNormal

private

Definition at line 483 of file G4Navigator.hh.

Referenced by ComputeStep(), GetGlobalExitNormal(), GetLocalExitNormal(), and ResetState().

fChangedGrandMotherRefFrame

G4bool G4Navigator::fChangedGrandMotherRefFrame

private

Definition at line 482 of file G4Navigator.hh.

Referenced by ComputeStep(), LocateGlobalPointAndSetup(), LocateGlobalPointWithinVolume(), and ResetState().

fCheck

G4bool G4Navigator::fCheck = false

private

Definition at line 537 of file G4Navigator.hh.

Referenced by GetLocalExitNormal(), and LocateGlobalPointAndSetup().

fEnteredDaughter

G4bool G4Navigator::fEnteredDaughter

protected

Definition at line 398 of file G4Navigator.hh.

Referenced by ComputeSafety(), ComputeStep(), LocateGlobalPointAndSetup(), LocateGlobalPointWithinVolume(), ResetState(), RestoreSavedState(), and SetSavedState().

fEntering

G4bool G4Navigator::fEntering

private

Definition at line 465 of file G4Navigator.hh.

Referenced by ComputeStep(), GetGlobalExitNormal(), GetLocalExitNormal(), InformLastStep(), LocateGlobalPointAndSetup(), LocateGlobalPointWithinVolume(), PrintState(), ResetState(), RestoreSavedState(), and SetSavedState().

fExitedMother

G4bool G4Navigator::fExitedMother

protected

Definition at line 404 of file G4Navigator.hh.

Referenced by ComputeSafety(), ComputeStep(), GetLocalExitNormal(), LocateGlobalPointAndSetup(), LocateGlobalPointWithinVolume(), ResetState(), RestoreSavedState(), and SetSavedState().

fExiting

G4bool G4Navigator::fExiting

private

Definition at line 465 of file G4Navigator.hh.

Referenced by ComputeStep(), GetGlobalExitNormal(), GetLocalExitNormal(), InformLastStep(), LocateGlobalPointAndSetup(), LocateGlobalPointWithinVolume(), PrintState(), ResetState(), RestoreSavedState(), and SetSavedState().

fExitNormal

G4ThreeVector G4Navigator::fExitNormal

private

Definition at line 417 of file G4Navigator.hh.

Referenced by ComputeStep(), PrintState(), ResetState(), RestoreSavedState(), and SetSavedState().

fExitNormalGlobalFrame

G4ThreeVector G4Navigator::fExitNormalGlobalFrame

private

Definition at line 425 of file G4Navigator.hh.

Referenced by ComputeStep(), GetGlobalExitNormal(), and ResetState().

fGrandMotherExitNormal

G4ThreeVector G4Navigator::fGrandMotherExitNormal

private

Definition at line 423 of file G4Navigator.hh.

Referenced by ComputeStep(), GetLocalExitNormal(), LocateGlobalPointAndSetup(), and ResetState().

fHistory

G4NavigationHistory G4Navigator::fHistory

protected

Definition at line 384 of file G4Navigator.hh.

Referenced by ComputeSafety(), ComputeStep(), ComputeStepLog(), GetGlobalExitNormal(), GetLocalExitNormal(), LocateGlobalPointAndSetup(), LocateGlobalPointWithinVolume(), ResetHierarchyAndLocate(), and SetupHierarchy().

fLastLocatedPointLocal

G4ThreeVector G4Navigator::fLastLocatedPointLocal

private

Definition at line 413 of file G4Navigator.hh.

Referenced by ComputeStep(), ComputeStepLog(), GetLocalExitNormal(), LocateGlobalPointAndSetup(), LocateGlobalPointWithinVolume(), PrintState(), ResetState(), RestoreSavedState(), and SetSavedState().

fLastMotherPhys

G4VPhysicalVolume* G4Navigator::fLastMotherPhys = nullptr

private

Definition at line 434 of file G4Navigator.hh.

Referenced by ComputeStep(), and ResetState().

fLastStepEndPointLocal

G4ThreeVector G4Navigator::fLastStepEndPointLocal

protected

Definition at line 391 of file G4Navigator.hh.

Referenced by ComputeStep(), G4Navigator(), and GetLocalExitNormal().

fLastStepWasZero

G4bool G4Navigator::fLastStepWasZero

private

Definition at line 475 of file G4Navigator.hh.

Referenced by ComputeStep(), InformLastStep(), PrintState(), ResetState(), RestoreSavedState(), and SetSavedState().

fLastTriedStepComputation

G4bool G4Navigator::fLastTriedStepComputation = false

private

Definition at line 459 of file G4Navigator.hh.

Referenced by ComputeStep(), GetGlobalExitNormal(), GetLocalExitNormal(), GetLocalExitNormalAndCheck(), LocateGlobalPointAndSetup(), LocateGlobalPointWithinVolume(), and ResetHierarchyAndLocate().

fLocatedOnEdge

G4bool G4Navigator::fLocatedOnEdge

private

Definition at line 477 of file G4Navigator.hh.

Referenced by ComputeStep(), InformLastStep(), LocateGlobalPointAndSetup(), and ResetState().

fLocatedOutsideWorld

G4bool G4Navigator::fLocatedOutsideWorld

private

Definition at line 479 of file G4Navigator.hh.

Referenced by LocateGlobalPointAndSetup(), ResetState(), RestoreSavedState(), and SetSavedState().

fMinStep

G4double G4Navigator::fMinStep

protected

Definition at line 377 of file G4Navigator.hh.

Referenced by ComputeStep(), and G4Navigator().

fnormalNav

G4NormalNavigation G4Navigator::fnormalNav

private

Definition at line 523 of file G4Navigator.hh.

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

fNumberZeroSteps

G4int G4Navigator::fNumberZeroSteps

private

Definition at line 449 of file G4Navigator.hh.

Referenced by ComputeStep(), and ResetState().

fparamNav

G4ParameterisedNavigation G4Navigator::fparamNav

private

Definition at line 529 of file G4Navigator.hh.

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

fpExternalNav

G4VExternalNavigation* G4Navigator::fpExternalNav = nullptr

private

Definition at line 532 of file G4Navigator.hh.

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

fPreviousSafety

G4double G4Navigator::fPreviousSafety

private

Definition at line 429 of file G4Navigator.hh.

Referenced by ComputeSafety(), ComputeStep(), ComputeStepLog(), PrintState(), ResetState(), RestoreSavedState(), and SetSavedState().

fPreviousSftOrigin

G4ThreeVector G4Navigator::fPreviousSftOrigin

private

Definition at line 428 of file G4Navigator.hh.

Referenced by ComputeSafety(), ComputeStep(), ComputeStepLog(), PrintState(), ResetState(), RestoreSavedState(), and SetSavedState().

fPushed

G4bool G4Navigator::fPushed = false

private

Definition at line 539 of file G4Navigator.hh.

Referenced by ComputeStep(), and ResetState().

fpvoxelNav

G4VoxelNavigation* G4Navigator::fpvoxelNav

private

Definition at line 525 of file G4Navigator.hh.

Referenced by G4Navigator(), and ~G4Navigator().

fpVoxelSafety

G4VoxelSafety* G4Navigator::fpVoxelSafety

private

Definition at line 533 of file G4Navigator.hh.

Referenced by ComputeSafety(), G4Navigator(), and ~G4Navigator().

fregularNav

G4RegularNavigation G4Navigator::fregularNav

private

Definition at line 531 of file G4Navigator.hh.

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

freplicaNav

G4ReplicaNavigation G4Navigator::freplicaNav

private

Definition at line 530 of file G4Navigator.hh.

Referenced by ComputeSafety(), ComputeStep(), LocateGlobalPointAndSetup(), and SetupHierarchy().

fSaveState

struct G4Navigator::G4SaveNavigatorState G4Navigator::fSaveState

private

Referenced by RestoreSavedState(), and SetSavedState().

fSqTol

G4double G4Navigator::fSqTol

protected

Definition at line 377 of file G4Navigator.hh.

Referenced by ComputeStep(), G4Navigator(), and GetGlobalExitNormal().

fStepEndPoint

G4ThreeVector G4Navigator::fStepEndPoint

protected

Definition at line 388 of file G4Navigator.hh.

Referenced by ComputeSafety(), ComputeStep(), G4Navigator(), GetGlobalExitNormal(), and GetLastStepEndPoint().

fTopPhysical

G4VPhysicalVolume* G4Navigator::fTopPhysical = nullptr

private

Definition at line 517 of file G4Navigator.hh.

fValidExitNormal

G4bool G4Navigator::fValidExitNormal

private

Definition at line 474 of file G4Navigator.hh.

Referenced by ComputeStep(), LocateGlobalPointAndSetup(), PrintState(), ResetState(), RestoreSavedState(), and SetSavedState().

fVerbose

G4int G4Navigator::fVerbose = 0

protected

Definition at line 395 of file G4Navigator.hh.

Referenced by CheckOverlapsIterative(), G4MultiNavigator::ComputeSafety(), ComputeSafety(), G4MultiNavigator::ComputeStep(), ComputeStep(), G4Navigator(), G4MultiNavigator::GetGlobalExitNormal(), GetGlobalExitNormal(), GetLocalExitNormal(), G4MultiNavigator::LocateGlobalPointAndSetup(), LocateGlobalPointAndSetup(), G4MultiNavigator::LocateGlobalPointWithinVolume(), G4MultiNavigator::ObtainFinalStep(), G4MultiNavigator::PrepareNavigators(), G4MultiNavigator::PrepareNewTrack(), G4MultiNavigator::PrintLimited(), PrintState(), and G4MultiNavigator::WhichLimited().

fWarnPush

G4bool G4Navigator::fWarnPush = true

private

Definition at line 539 of file G4Navigator.hh.

Referenced by ComputeStep().

fWasLimitedByGeometry

G4bool G4Navigator::fWasLimitedByGeometry = false

protected

Definition at line 408 of file G4Navigator.hh.

Referenced by G4MultiNavigator::LocateGlobalPointAndSetup(), LocateGlobalPointAndSetup(), G4MultiNavigator::LocateGlobalPointWithinVolume(), LocateGlobalPointWithinVolume(), G4MultiNavigator::PrepareNavigators(), G4MultiNavigator::ResetState(), ResetState(), RestoreSavedState(), and SetSavedState().

kCarTolerance

G4double G4Navigator::kCarTolerance

protected

Definition at line 377 of file G4Navigator.hh.

Referenced by ComputeSafety(), ComputeStep(), ComputeStepLog(), G4Navigator(), G4ErrorPropagationNavigator::GetGlobalExitNormal(), and GetLocalExitNormal().

---

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

• source/geometry/navigation/include/G4Navigator.hh
• source/geometry/navigation/src/G4Navigator.cc