G4Navigator Class Reference

G4Navigator is a class for use by the tracking management, able to obtain/calculate dynamic tracking time information such as the distance to the next volume, or to find the physical volume containing a given point in the world reference system. The navigator maintains a transformation history and other information to optimise the tracking time performance. More...

#include <G4Navigator.hh>

Inheritance diagram for G4Navigator:

Public Member Functions
	G4Navigator ()
	G4Navigator (const G4Navigator &)=delete
G4Navigator &	operator= (const G4Navigator &)=delete
virtual	~G4Navigator ()
virtual G4double	ComputeStep (const G4ThreeVector &pGlobalPoint, const G4ThreeVector &pDirection, const G4double pCurrentProposedStepLength, G4double &pNewSafety)
G4double	CheckNextStep (const G4ThreeVector &pGlobalPoint, const G4ThreeVector &pDirection, const G4double pCurrentProposedStepLength, G4double &pNewSafety)
virtual G4VPhysicalVolume *	ResetHierarchyAndLocate (const G4ThreeVector &point, const G4ThreeVector &direction, const G4TouchableHistory &h)
virtual G4VPhysicalVolume *	LocateGlobalPointAndSetup (const G4ThreeVector &point, const G4ThreeVector *direction=nullptr, const G4bool pRelativeSearch=true, const G4bool ignoreDirection=true)
virtual void	LocateGlobalPointWithinVolume (const G4ThreeVector &position)
void	LocateGlobalPointAndUpdateTouchableHandle (const G4ThreeVector &position, const G4ThreeVector &direction, G4TouchableHandle &oldTouchableToUpdate, const G4bool RelativeSearch=true)
void	LocateGlobalPointAndUpdateTouchable (const G4ThreeVector &position, const G4ThreeVector &direction, G4VTouchable *touchableToUpdate, const G4bool RelativeSearch=true)
void	LocateGlobalPointAndUpdateTouchable (const G4ThreeVector &position, G4VTouchable *touchableToUpdate, const G4bool RelativeSearch=true)
void	SetGeometricallyLimitedStep ()
virtual G4double	ComputeSafety (const G4ThreeVector &globalpoint, const G4double pProposedMaxLength=DBL_MAX, const G4bool keepState=true)
G4VPhysicalVolume *	GetWorldVolume () const
void	SetWorldVolume (G4VPhysicalVolume *pWorld)
G4TouchableHistory *	CreateTouchableHistory () const
G4TouchableHistory *	CreateTouchableHistory (const G4NavigationHistory *h) const
virtual G4TouchableHandle	CreateTouchableHistoryHandle () const
virtual G4ThreeVector	GetLocalExitNormal (G4bool *valid)
virtual G4ThreeVector	GetLocalExitNormalAndCheck (const G4ThreeVector &point, G4bool *valid)
virtual G4ThreeVector	GetGlobalExitNormal (const G4ThreeVector &point, G4bool *valid)
G4int	GetVerboseLevel () const
void	SetVerboseLevel (G4int level)
G4bool	IsActive () const
void	Activate (G4bool flag)
G4bool	EnteredDaughterVolume () const
G4bool	ExitedMotherVolume () const
void	CheckMode (G4bool mode)
G4bool	IsCheckModeActive () const
void	SetPushVerbosity (G4bool mode)
void	PrintState () const
const G4AffineTransform &	GetGlobalToLocalTransform () const
const G4AffineTransform	GetLocalToGlobalTransform () const
G4AffineTransform	GetMotherToDaughterTransform (G4VPhysicalVolume *dVolume, G4int dReplicaNo, EVolume dVolumeType)
void	ResetStackAndState ()
G4int	SeverityOfZeroStepping (G4int *noZeroSteps) const
G4ThreeVector	GetCurrentLocalCoordinate () const
G4ThreeVector	NetTranslation () const
G4RotationMatrix	NetRotation () const
void	EnableBestSafety (G4bool value=false)
G4VExternalNavigation *	GetExternalNavigation () const
void	SetExternalNavigation (G4VExternalNavigation *externalNav)
G4VoxelNavigation &	GetVoxelNavigator ()
void	SetVoxelNavigation (G4VoxelNavigation *voxelNav)
G4Navigator *	Clone () const
G4ThreeVector	GetLastStepEndPoint () const
void	InformLastStep (G4double lastStep, G4bool entersDaughtVol, G4bool exitsMotherVol)

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

Protected Attributes
G4double	kCarTolerance
G4double	fMinStep
G4double	fSqTol
G4NavigationHistory	fHistory
G4ThreeVector	fStepEndPoint
G4ThreeVector	fLastStepEndPointLocal
G4int	fVerbose = 0
G4bool	fEnteredDaughter
G4bool	fExitedMother
G4bool	fWasLimitedByGeometry = false

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

Detailed Description

G4Navigator is a class for use by the tracking management, able to obtain/calculate dynamic tracking time information such as the distance to the next volume, or to find the physical volume containing a given point in the world reference system. The navigator maintains a transformation history and other information to optimise the tracking time performance.

Definition at line 75 of file G4Navigator.hh.

Constructor & Destructor Documentation

G4Navigator() [1/2]

G4Navigator::G4Navigator

(

)

Constructor - initialisers and setup.

Definition at line 54 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();
  fpvoxelNav    = new G4VoxelNavigation();
  fpSafetyCalculator = new G4SafetyCalculator( *this, fHistory );
  fpSafetyCalculator->SetExternalNavigation(fpExternalNav);
}

Referenced by Clone(), G4MultiNavigator::G4MultiNavigator(), G4Navigator(), G4MultiNavigator::GetNavigator(), G4MultiNavigator::operator<<, operator=(), G4MultiNavigator::PrintLimited(), G4MultiNavigator::ResetHierarchyAndLocate(), and G4MultiNavigator::~G4MultiNavigator().

G4Navigator() [2/2]

G4Navigator::G4Navigator ( const G4Navigator & )

delete

Copy constructor & assignment operator not allowed.

~G4Navigator()

G4Navigator::~G4Navigator ( )

virtual

Destructor.

Definition at line 89 of file G4Navigator.cc.

{
  delete fpVoxelSafety;
  delete fpExternalNav;
  delete fpvoxelNav;
  delete fpSafetyCalculator;
}

Member Function Documentation

Activate()

void G4Navigator::Activate ( G4bool flag )

inline

Activate/inactivate the navigator.

Referenced by G4TransportationManager::ActivateNavigator().

CharacteriseDaughters()

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

inlineprotected

Characterises the daughters of given logical volume.

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

CheckMode()

void G4Navigator::CheckMode ( G4bool mode )

inline

Run navigation in "check-mode", therefore using additional verifications and more strict correctness conditions.

Note

Is effective only with G4VERBOSE set.

Referenced by G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck().

CheckNextStep()

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

Same as ComputeStep() above, but does not affect/modify the state of the Navigator.

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

CheckOverlapsIterative()

G4bool G4Navigator::CheckOverlapsIterative ( G4VPhysicalVolume * vol )

protected

Utility method to trigger overlaps check on a volume with reported overlaps ordered by relevance. Used in ComputeStep() when loopings with zero step are detected.

Definition at line 1986 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 != 0, numOverlaps);
    trialLength *= 0.1;
    if ( trialLength <= 1.0e-5 ) { numOverlaps= 1;}
  }
  return foundOverlap;
}

Referenced by ComputeStep().

Clone()

G4Navigator * G4Navigator::Clone ( ) const

inline

Cloning feature for use in MT applications to clone the navigator, including external sub-navigator.

Note

Client has responsibility for ownership of the returned allocated pointer.

Returns

A pointer to the cloned navigator object.

ComputeLocalAxis()

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

inlineprotected

Returns the local direction of the specified vector in the reference system of the volume that was found by LocalGlobalPointAndSetup(). The Local Coordinates of point in world coordinate system.

Referenced by ComputeStep().

ComputeLocalPoint()

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

inlineprotected

Returns position vector in local coordinate system, given a position vector in world coordinate system.

Referenced by ComputeStep(), and LocateGlobalPointWithinVolume().

ComputeSafety()

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

virtual

Calculates the isotropic distance to the nearest boundary from the specified point in the global coordinate system.

Note

The geometry must be closed.

Parameters

[in]	globalpoint	The point in global coordinates system. The point must be within the current volume.
[in]	pProposedMaxLength	The proposed maximum length is used to avoid volume safety calculations.
[in]	keepState	Flag to instruct keeping the state (default true) to ensure minimum side effects from the call.

Returns

Length from current point to closest boundary surface. The value returned is usually an underestimate.

Reimplemented in G4ErrorPropagationNavigator, and G4MultiNavigator.

Definition at line 1780 of file G4Navigator.cc.

{
  G4VPhysicalVolume  *motherPhysical = fHistory.GetTopVolume();
  G4double safety = 0.0;
 
  G4double distEndpointSq = (pGlobalpoint-fStepEndPoint).mag2(); 
  G4bool stayedOnEndpoint = distEndpointSq < sqr(kCarTolerance); 
  G4bool endpointOnSurface = fEnteredDaughter || fExitedMother;
 
  G4bool onSurface = endpointOnSurface && stayedOnEndpoint;
  if( ! onSurface )
  {
    safety= fpSafetyCalculator->SafetyInCurrentVolume(pGlobalpoint, motherPhysical, pMaxLength);
    // offload to G4SafetyCalculator - avoids need to save / reload state
 
    // Remember last safety origin & value
    //
    fPreviousSftOrigin = pGlobalpoint;
    fPreviousSafety =    safety;
    // We overwrite the Safety 'sphere' - keeping old behaviour
  }
 
  return safety;
}

Referenced by G4ErrorPropagationNavigator::ComputeSafety().

ComputeStep()

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

virtual

Calculates the distance to the next boundary intersected along the specified NORMALISED vector direction and from the specified point in the global coordinate system. LocateGlobalPointAndSetup() or LocateGlobalPointWithinVolume() must have been called with the same global point prior to this call. The isotropic distance to the nearest boundary is also calculated (usually an underestimate). The current proposed Step length is used to avoid intersection calculations: if it can be determined that the nearest boundary is >pCurrentProposedStepLength away, kInfinity is returned together with the computed isotropic safety distance.

Note

Geometry must be closed.

Parameters

[in]	pGlobalPoint	The point in global coordinates system.
[in]	pDirection	The normalised vector direction.
[in]	pCurrentProposedStepLength	Current proposed step length.
[in,out]	newSafety	New safety.

Returns

Length from current point to next boundary surface along pDirection.

Reimplemented in G4ErrorPropagationNavigator, and G4MultiNavigator.

Definition at line 751 of file G4Navigator.cc.

{
#ifdef G4DEBUG_NAVIGATION
  static G4ThreadLocal G4int sNavCScalls = 0;
  ++sNavCScalls;
#endif
 
  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
 
#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 );
    }
  }
  if ( fHistory.GetTopVolumeType()!=kReplica )
  {
    switch( CharacteriseDaughters(motherLogical) )
    {
      case kNormal:
        if ( motherLogical->GetVoxelHeader() != nullptr )
        {
          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 );
            //
            // 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
    //
    fExiting = fExitedMother;
    Step = freplicaNav.ComputeStep(pGlobalpoint,
                                   pDirection,
                                   fLastLocatedPointLocal,
                                   localDirection,
                                   pCurrentProposedStepLength,
                                   pNewSafety,
                                   fHistory,
                                   fValidExitNormal,
                                   fCalculatedExitNormal,
                                   fExitNormal,
                                   fExiting,
                                   fEntering,
                                   &fBlockedPhysicalVolume,
                                   fBlockedReplicaNo);
  }
 
  // 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 != nullptr ? fLastMotherPhys->GetName() : G4String("") )
                << "'" << 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 )
    {
      // Convention: fExitNormal is in the 'grand-mother' coordinate system
      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 != nullptr )
        {
          fChangedGrandMotherRefFrame = true;           
          fGrandMotherExitNormal = (*mRot).inverse() * exitNormalMotherFrame;
        }
        else
        {
          fGrandMotherExitNormal = exitNormalMotherFrame;
        }
 
        // Do not set fValidExitNormal -- this signifies
        // that the solid is convex!
      }
      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
      }
    }
 
    if ( fHistory.GetTopVolumeType() != kReplica )
    {
      fCalculatedExitNormal = true;
    }
 
    // Now transform it to the global reference frame !!
    //
    if( fValidExitNormal || fCalculatedExitNormal )
    {
      auto  depth = (G4int)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
 
  fLastTriedStepComputation = true;
 
  return Step;
}

Referenced by CheckNextStep(), and G4ErrorPropagationNavigator::ComputeStep().

CreateTouchableHistory() [1/2]

G4TouchableHistory * G4Navigator::CreateTouchableHistory ( ) const

inline

Touchable creation method.

Note

Caller has deletion responsibility.

Returns

A pointer to the allocated touchable history.

Referenced by G4MultiNavigator::CreateTouchableHistoryHandle(), and CreateTouchableHistoryHandle().

CreateTouchableHistory() [2/2]

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

inline

Touchable creation method, given a history.

Note

Caller has deletion responsibility.

Parameters

[in]

h

Pointer to a navigation history to copy from.

Returns

A pointer to the allocated touchable history.

CreateTouchableHistoryHandle()

G4TouchableHandle G4Navigator::CreateTouchableHistoryHandle ( ) const

virtual

Returns a reference counted handle to a touchable history.

Reimplemented in G4MultiNavigator.

Definition at line 1811 of file G4Navigator.cc.

{
  return { CreateTouchableHistory() };
}

Referenced by G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck().

EnableBestSafety()

void G4Navigator::EnableBestSafety ( G4bool value = false )

inline

Enables best-possible evaluation of isotropic safety.

EnteredDaughterVolume()

G4bool G4Navigator::EnteredDaughterVolume ( ) const

inline

The purpose of this function is to inform the caller if the track is entering a daughter volume while exiting from the current volume.

Note

It is not guaranteed to work if SetGeometricallyLimitedStep() was not called when it should have been called.

Returns

True only in case when the Step has caused the track to arrive at a boundary of a daughter. False, in all other cases.

Referenced by GetLocalExitNormal().

ExitedMotherVolume()

G4bool G4Navigator::ExitedMotherVolume ( ) const

inline

Verify if the step has exited the mother volume.

GetCurrentLocalCoordinate()

G4ThreeVector G4Navigator::GetCurrentLocalCoordinate ( ) const

inline

Returns the local coordinate of the point in the reference system of its containing volume that was found by LocalGlobalPointAndSetup(). The local coordinate of the last located track.

GetDaughtersRegularStructureId()

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

inlineprotected

Gets regular structure ID of first daughter.

Referenced by ComputeStep(), and LocateGlobalPointAndSetup().

GetExternalNavigation()

G4VExternalNavigation * G4Navigator::GetExternalNavigation ( ) const

inline

Accessor & modifier for custom external navigation.

GetGlobalExitNormal()

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

virtual

Obtains the Normal vector to a surface (in global coordinates) pointing out of previous volume and into current volume The method takes full care about how to calculate the normal, but if the surfaces are not convex it will return valid=false.

Note

Can only be called if the Navigator's last Step has crossed a volume geometrical boundary.

Normals are not available for replica volumes (i.e. valid=false).

Parameters

[in]	point	Point in global coordinates system to compare to.
[in,out]	valid	Flag indicating if normal is valid.

Returns

A Exit Surface Normal vector and validity too.

Reimplemented in G4ErrorPropagationNavigator, and G4MultiNavigator.

Definition at line 1609 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 != nullptr )
       {
         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 != nullptr )
       {
         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;
}

Referenced by G4ErrorPropagationNavigator::GetGlobalExitNormal(), G4XrayReflection::GetMeanFreePath(), and G4MicroElecSurface::PostStepDoIt().

GetGlobalToLocalTransform()

const G4AffineTransform & G4Navigator::GetGlobalToLocalTransform ( ) const

inline

Obtains the transformations Global/Local (and inverse).

Note

Clients of these methods must copy the data if they need to keep it.

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

GetLastStepEndPoint()

G4ThreeVector G4Navigator::GetLastStepEndPoint ( ) const

inline

Gets endpoint of last step.

GetLocalExitNormal()

G4ThreeVector G4Navigator::GetLocalExitNormal ( G4bool * valid )

virtual

Obtains the Normal vector to a surface (in local coordinates) pointing out of previous volume and into current volume Convention: the local normal is in the coordinate system of the final volume. The method takes full care about how to calculate this normal, but if the surfaces are not convex it will return valid=false.

Note

Can only be called if the Navigator's last Step has crossed a volume geometrical boundary.

Normals are not available for replica volumes (i.e. valid=false).

Parameters

[in,out]

valid

Flag indicating if normal is valid.

Returns

A Exit Surface Normal vector and validity too.

Reimplemented in G4MultiNavigator.

Definition at line 1357 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!=nullptr) ) 
    { 
      candidateLogical = fBlockedPhysicalVolume->GetLogicalVolume();
      if( candidateLogical != nullptr ) 
      {
        // 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;
}

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

GetLocalExitNormalAndCheck()

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

virtual

Obtains the Normal vector to a surface (in local coordinates) pointing out of previous volume and into current volume, and checks the current point against expected 'local' value. Convention: the local normal is in the coordinate system of the final volume. The method takes full care about how to calculate this normal, but if the surfaces are not convex it will return valid=false.

Note

Can only be called if the Navigator's last Step has crossed a volume geometrical boundary.

Normals are not available for replica volumes (i.e. valid=false).

Parameters

[in]	point	Point in global coordinates system to compare to.
[in,out]	valid	Flag indicating if normal is valid.

Returns

A Exit Surface Normal vector and validity too.

Reimplemented in G4MultiNavigator.

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

Referenced by GetGlobalExitNormal().

GetLocalToGlobalTransform()

const G4AffineTransform G4Navigator::GetLocalToGlobalTransform ( ) const

inline

Referenced by G4RayTrajectory::AppendStep().

GetMotherToDaughterTransform()

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

Obtains mother to daughter transformation.

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

Referenced by GetLocalExitNormal().

GetVerboseLevel()

G4int G4Navigator::GetVerboseLevel ( ) const

inline

Verbosity control.

Note

If level>0 && G4VERBOSE, printout can occur.

Referenced by GetGlobalExitNormal().

GetVoxelNavigator()

G4VoxelNavigation & G4Navigator::GetVoxelNavigator ( )

inline

Gets/sets alternative navigator for voxel volumes.

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

GetWorldVolume()

G4VPhysicalVolume * G4Navigator::GetWorldVolume ( ) const

inline

Returns the current world (topmost) volume.

Referenced by G4TransportationManager::ActivateNavigator(), G4TransportationManager::DeActivateNavigator(), G4TransportationManager::DeRegisterNavigator(), G4GeometrySampler::G4GeometrySampler(), G4ImportanceConfigurator::G4ImportanceConfigurator(), G4MultiNavigator::G4MultiNavigator(), G4TransportationManager::GetParallelWorld(), G4TDNAOneStepThermalizationModel< MODEL >::Initialise(), G4FastSimHitMaker::make(), GFlashHitMaker::make(), G4MultiNavigator::PrepareNavigators(), G4MultiNavigator::PrintLimited(), G4IStore::SetWorldVolume(), and G4WeightWindowStore::SetWorldVolume().

InformLastStep()

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

Derived navigators which rely on LocateGlobalPointAndSetup() need to inform size of step, to maintain logic about arriving on boundary for challenging cases. Required in order to cope with multiple trials at boundaries => Locate with use direction rather than simple, fast logic.

Definition at line 2098 of file G4Navigator.cc.

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

IsActive()

G4bool G4Navigator::IsActive ( ) const

inline

Verify if the navigator is active.

IsCheckModeActive()

G4bool G4Navigator::IsCheckModeActive ( ) const

inline

Set/unset verbosity for pushed tracks (default is true).

Referenced by G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck().

LocateGlobalPointAndSetup()

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

virtual

Searches the geometrical hierarchy for the volumes deepest in hierarchy containing the point in the global coordinate space. Two main cases are: i) If pRelativeSearch=false it makes use of no previous/state information. Returns the physical volume containing the point, with all previous mothers correctly set up. ii) If pRelativeSearch is set to true, the search begin is the geometrical hierarchy at the location of the last located point, or the endpoint of previous Step if SetGeometricallyLimitedStep() has been called immediately before. The direction is used (to check if a volume is entered) if either

• the argument ignoreDirection is false, or
• the Navigator has determined that it is on an edge shared by two or more volumes (this is state information).

  Note

  In order to call this the geometry MUST be closed.

  Parameters

  [in]	point	The point in global coordinates system.
  [in]	direction	The normalised vector direction.
  [in]	pRelativeSearch	Flag to specify where search starts from.
  [in]	ignoreDirection	Flag to specify if to use direction or not.

  Returns

  The pointer to the physical volume where point is located.

Reimplemented in G4MultiNavigator.

Definition at line 132 of file G4Navigator.cc.

{
  G4bool notKnownContained = true, noResult;
  G4VPhysicalVolume *targetPhysical;
  G4LogicalVolume *targetLogical;
  G4VSolid *targetSolid = nullptr;
  G4ThreeVector localPoint, globalDirection;
  EInside insideCode;
 
  G4bool considerDirection = (pGlobalDirection != nullptr) && ((!ignoreDirection) || fLocatedOnEdge);
 
  fLastTriedStepComputation = false;   
  fChangedGrandMotherRefFrame = false;  // For local exit normal
   
  if( considerDirection )
  {
    globalDirection=*pGlobalDirection;
  }
 
#ifdef G4VERBOSE
  if( fVerbose > 2 )
  {
    G4long 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;
 
  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() != 0 )
        {
          fBlockedPhysicalVolume = fHistory.GetTopVolume();
          fBlockedReplicaNo = fHistory.GetTopReplicaNo();
          fHistory.BackLevel();
        }
        else
        {
          fLastLocatedPointLocal = localPoint;
          fLocatedOutsideWorld = true;
          fBlockedPhysicalVolume = nullptr;   // 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 )
        {
          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);
       }
    }
 
    // Point is inside current volume, break out of the loop
    if ( insideCode == kInside ) { break; }
 
    // Point is outside current volume, move up a level in the hierarchy
    if ( insideCode == kOutside )
    {
      ++noLevelsExited;
 
      // Exiting world volume
      if ( fHistory.GetDepth() == 0 )
      {
        fLocatedOutsideWorld = true;
        fLastLocatedPointLocal = localPoint;
        return nullptr;
      }
 
      fBlockedPhysicalVolume = fHistory.GetTopVolume();
      fBlockedReplicaNo = fHistory.GetTopReplicaNo();
      fHistory.BackLevel();
      fExiting = false;
 
      if( noLevelsExited > 1 )
      {
        // The first transformation was done by the sub-navigator
        //
        if(const auto *mRot = fBlockedPhysicalVolume->GetRotation())
        {
          fGrandMotherExitNormal *= (*mRot).inverse();
          fChangedGrandMotherRefFrame = true;
        }
      }
      continue;
    }
 
    // Point is on the surface of a volume
    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;
      }
    }
 
    // Point is on a surface, but no longer exiting, break out of the loop
    if ( !isExiting ) { break; }
 
    ++noLevelsExited;
 
    // Point is on the outer surface, leaving world volume
    if ( fHistory.GetDepth() == 0 )
    {
      fLocatedOutsideWorld = true;
      fLastLocatedPointLocal = localPoint;
      return nullptr;
    }
 
    // Point is still on a surface, but exited a volume not necessarily convex
    fValidExitNormal = false;
    fBlockedPhysicalVolume = fHistory.GetTopVolume();
    fBlockedReplicaNo = fHistory.GetTopReplicaNo();
    fHistory.BackLevel();
 
    if( noLevelsExited > 1 )
    {
      // The first transformation was done by the sub-navigator
      //
      const G4RotationMatrix* mRot =
        fBlockedPhysicalVolume->GetRotation();
      if( mRot != nullptr )
      {
        fGrandMotherExitNormal *= (*mRot).inverse();
        fChangedGrandMotherRefFrame = true;
      }
    }
  }  // 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 == nullptr) { break; }
    targetLogical = targetPhysical->GetLogicalVolume();
    switch( CharacteriseDaughters(targetLogical) )
    {
      case kNormal:
        if ( targetLogical->GetVoxelHeader() != nullptr )  // 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 )
    {
      // 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 != nullptr )
        { 
          // 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 )
  {
    G4long oldcoutPrec = G4cout.precision(8);
    G4String curPhysVol_Name("None");
    if (targetPhysical != nullptr)  { 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;
}

Referenced by ComputeStep(), G4TheRayTracer::CreateBitMap(), G4VFieldModel::DescribeYourselfTo(), G4TrajectoryDrawByOriginVolume::Draw(), G4TrajectoryOriginVolumeFilter::Evaluate(), G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck(), and ResetHierarchyAndLocate().

LocateGlobalPointAndUpdateTouchable() [1/2]

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

inline

Same as the method above LocateGlobalPointAndUpdateTouchableHandle(), except that a pointer to G4VTouchable is used for updating the touchable.

LocateGlobalPointAndUpdateTouchable() [2/2]

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

inline

Same as the method above LocateGlobalPointAndUpdateTouchable(), except that direction is not specified.

LocateGlobalPointAndUpdateTouchableHandle()

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

inline

It first searches the geometrical hierarchy like the above method LocateGlobalPointAndSetup(), then it uses the volume found and its navigation history to update the touchable handle.

Parameters

[in]	position	The point in global coordinates system.
[in]	direction	The normalised vector direction.
[in,out]	oldTouchableToUpdate	Touchable handle to update.
[in]	RelativeSearch	Flag to specify where search starts from.

LocateGlobalPointWithinVolume()

void G4Navigator::LocateGlobalPointWithinVolume ( const G4ThreeVector & position )

virtual

Notifies the Navigator that a track has moved to the new Global point 'position', that is known to be within the current safety. No check is performed to ensure that it is within the volume. This method can be called instead of LocateGlobalPointAndSetup() ONLY if the caller is certain that the new global point (position) is inside the same volume as the previous position. Usually this can be guaranteed only if the point is within safety.

Parameters

[in]

position

The position point in global coordinates system.

Reimplemented in G4MultiNavigator.

Definition at line 602 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();
 
   switch( CharacteriseDaughters(motherLogical) )
   {
       case kNormal:
         GetVoxelNavigator().RelocateWithinVolume( motherPhysical, fLastLocatedPointLocal );
         break;
       case kParameterised:
         fparamNav.RelocateWithinVolume( motherPhysical, 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
}

Referenced by G4VIntersectionLocator::AdjustmentOfFoundIntersection(), ComputeStep(), G4BrentLocator::EstimateIntersectionPoint(), G4MultiLevelLocator::EstimateIntersectionPoint(), G4SimpleLocator::EstimateIntersectionPoint(), and G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck().

NetRotation()

G4RotationMatrix G4Navigator::NetRotation ( ) const

inline

NetTranslation()

G4ThreeVector G4Navigator::NetTranslation ( ) const

inline

Computes and returns the local->global translation/rotation of current volume.

operator=()

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

delete

PrintState()

void G4Navigator::PrintState

(

)

const

Prints the internal state of the Navigator (for debugging). The level of detail is according to the verbosity.

Definition at line 1820 of file G4Navigator.cc.

{
  G4long 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==nullptr)
    {
      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);
}

Referenced by ComputeStep(), and LocateGlobalPointAndSetup().

ResetHierarchyAndLocate()

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

virtual

Resets the geometrical hierarchy and searches for the volumes deepest in the hierarchy containing the point in the global coordinates space. The direction is used to check if a volume is entered. The search begin is the geometrical hierarchy at the location of the last located point, or the endpoint of the previous Step if SetGeometricallyLimitedStep() has been called immediately before.

Note

: In order to call this the geometry MUST be closed.

Parameters

[in]	point	The point in global coordinates system.
[in]	direction	The normalised vector direction.
[in]	h	The touchable history to be used for initialisation.

Returns

The pointer to the physical volume where point is located.

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

Referenced by G4MultiNavigator::ResetHierarchyAndLocate().

ResetStackAndState()

void G4Navigator::ResetStackAndState ( )

inline

Resets stack and minimum or navigator state machine necessary for reset as needed by LocalGlobalPointAndSetup().

Note

Does not perform clears, resizes, or reset fLastLocatedPointLocal.

Referenced by G4Navigator(), and LocateGlobalPointAndSetup().

ResetState()

void G4Navigator::ResetState ( )

protectedvirtual

Utility method to reset the navigator state machine.

Reimplemented in G4MultiNavigator.

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

Referenced by ResetHierarchyAndLocate().

RestoreSavedState()

void G4Navigator::RestoreSavedState ( )

protected

Copy aspects of the state, to enable a non-state changing call to ComputeStep().

Definition at line 697 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 != 0);
  
  fLocatedOutsideWorld = fSaveState.sLocatedOutsideWorld;
  fLastLocatedPointLocal = fSaveState.sLastLocatedPointLocal;
  fEnteredDaughter = fSaveState.sEnteredDaughter;
  fExitedMother = fSaveState.sExitedMother;
  fWasLimitedByGeometry = fSaveState.sWasLimitedByGeometry;
  
  // The 'expected' behaviour is to restore these too (fix 2014.05.26)
  fPreviousSftOrigin = fSaveState.sPreviousSftOrigin;
  fPreviousSafety = fSaveState.sPreviousSafety;
}

Referenced by CheckNextStep().

SetExternalNavigation()

void G4Navigator::SetExternalNavigation

(

G4VExternalNavigation *

externalNav

)

Definition at line 2113 of file G4Navigator.cc.

{
  fpExternalNav = externalNav;
  fpSafetyCalculator->SetExternalNavigation(externalNav);
}

SetGeometricallyLimitedStep()

void G4Navigator::SetGeometricallyLimitedStep ( )

inline

Informs the navigator that the previous Step calculated by the geometry was taken in its entirety.

SetPushVerbosity()

void G4Navigator::SetPushVerbosity ( G4bool mode )

inline

SetSavedState()

void G4Navigator::SetSavedState ( )

protected

Saves the state: fValidExitNormal, fExitNormal, fExiting, fEntering, fBlockedPhysicalVolume, fBlockedReplicaNo, fLastStepWasZero, fLastLocatedPointLocal, fLocatedOutsideWorld, fEnteredDaughter, fExitedMother, fPreviousSftOrigin, fPreviousSafety.

Definition at line 663 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 = static_cast<G4int>(fLastStepWasZero);
  
  fSaveState.sLocatedOutsideWorld = fLocatedOutsideWorld;
  fSaveState.sLastLocatedPointLocal = fLastLocatedPointLocal;
  fSaveState.sEnteredDaughter = fEnteredDaughter;
  fSaveState.sExitedMother = fExitedMother;
  fSaveState.sWasLimitedByGeometry = fWasLimitedByGeometry;
 
  // Even the safety sphere - if you want to change it do it explicitly!
  //
  fSaveState.sPreviousSftOrigin = fPreviousSftOrigin;
  fSaveState.sPreviousSafety = fPreviousSafety;
}

Referenced by CheckNextStep().

SetupHierarchy()

void G4Navigator::SetupHierarchy ( )

protectedvirtual

Renavigates & resets hierarchy described by the current history: Resets volumes and recomputes transforms and/or solids of replicated/parameterised volumes.

Reimplemented in G4MultiNavigator.

Definition at line 1302 of file G4Navigator.cc.

{
  const auto  depth = (G4int)fHistory.GetDepth();
  for ( auto i = 1; i <= depth; ++i )
  {
    switch ( fHistory.GetVolumeType(i) )
    {
      case kNormal:
      case kExternal:
        break;
      case kReplica:
        freplicaNav.ComputeTransformation(fHistory.GetReplicaNo(i), fHistory.GetVolume(i));
        break;
      case kParameterised:
        G4VPhysicalVolume* current = fHistory.GetVolume(i);
        G4int replicaNo = fHistory.GetReplicaNo(i);
        G4VPVParameterisation* pParam = current->GetParameterisation();
        G4VSolid* 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;
    }
  }
}

Referenced by ResetHierarchyAndLocate().

SetVerboseLevel()

void G4Navigator::SetVerboseLevel ( G4int level )

inline

Referenced by GetGlobalExitNormal().

SetVoxelNavigation()

void G4Navigator::SetVoxelNavigation

(

G4VoxelNavigation *

voxelNav

)

Definition at line 2088 of file G4Navigator.cc.

{
  delete fpvoxelNav;
  fpvoxelNav = voxelNav;
}

SetWorldVolume()

void G4Navigator::SetWorldVolume ( G4VPhysicalVolume * pWorld )

inline

Sets the world (topmost) volume. This must be positioned at the origin (0,0,0) and unrotated.

Referenced by G4MultiNavigator::G4MultiNavigator(), G4VisManager::G4VisSubThread(), G4TransportationManager::GetNavigator(), G4TransportationManager::GetNavigator(), and G4MultiNavigator::PrepareNavigators().

SeverityOfZeroStepping()

G4int G4Navigator::SeverityOfZeroStepping ( G4int * noZeroSteps ) const

inline

Reports on severity of error and number of zero steps, in case Navigator is stuck and is returning zero steps. Values: 1 (small problem), 5 (correcting), 9 (ready to abandon), 10 (abandoned)

Parameters

[in,out]

noZeroSteps

Returns the number of zero steps in case pointer is not null.

Returns

The error severity.

VolumeType()

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

inlineprotected

Characterises the type of volume - normal/replicated/parameterised.

Friends And Related Symbol Documentation

operator<<

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

friend

Definition at line 2013 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
 
  G4long 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==nullptr)
    {
      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==nullptr )
      { 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;
}

Member Data Documentation

fEnteredDaughter

G4bool G4Navigator::fEnteredDaughter

protected

A memory of whether in this Step a daughter volume is entered (set in Compute & Locate). After Compute: it expects to enter a daughter After Locate: it has entered a daughter.

Definition at line 560 of file G4Navigator.hh.

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

fExitedMother

G4bool G4Navigator::fExitedMother

protected

A similar memory whether the Step exited current "mother" volume completely, not entering daughter.

Definition at line 564 of file G4Navigator.hh.

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

fHistory

G4NavigationHistory G4Navigator::fHistory

protected

Transformation and history of the current path through the geometrical hierarchy.

Definition at line 543 of file G4Navigator.hh.

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

fLastStepEndPointLocal

G4ThreeVector G4Navigator::fLastStepEndPointLocal

protected

Position of the end-point of the last call to ComputeStep() in last local coordinates.

Definition at line 551 of file G4Navigator.hh.

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

fMinStep

G4double G4Navigator::fMinStep

protected

Definition at line 536 of file G4Navigator.hh.

Referenced by ComputeStep(), and G4Navigator().

fSqTol

G4double G4Navigator::fSqTol

protected

Definition at line 536 of file G4Navigator.hh.

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

fStepEndPoint

G4ThreeVector G4Navigator::fStepEndPoint

protected

Endpoint of last ComputeStep(). Can be used for optimisation (e.g. when computing safety).

Definition at line 547 of file G4Navigator.hh.

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

fVerbose

G4int G4Navigator::fVerbose = 0

protected

Verbosity level [if > 0, printout can occur].

Definition at line 554 of file G4Navigator.hh.

Referenced by CheckOverlapsIterative(), G4MultiNavigator::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().

fWasLimitedByGeometry

G4bool G4Navigator::fWasLimitedByGeometry = false

protected

Set true if last Step was limited by geometry.

Definition at line 567 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 536 of file G4Navigator.hh.

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

---

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

• G4Navigator.hh
• G4Navigator.cc