#include <G4ErrorPropagationNavigator.hh>

Inheritance diagram for G4ErrorPropagationNavigator:

Public Member Functions
void	Activate (G4bool flag)

void	CheckMode (G4bool mode)

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

G4Navigator *	Clone () const

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

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

G4GRSSolid *	CreateGRSSolid () const

G4GRSVolume *	CreateGRSVolume () const

G4TouchableHistory *	CreateTouchableHistory () const

G4TouchableHistory *	CreateTouchableHistory (const G4NavigationHistory *) const

virtual G4TouchableHistoryHandle	CreateTouchableHistoryHandle () const

void	EnableBestSafety (G4bool value=false)

G4bool	EnteredDaughterVolume () const

G4bool	ExitedMotherVolume () const

	G4ErrorPropagationNavigator ()

G4ThreeVector	GetCurrentLocalCoordinate () const

G4VExternalNavigation *	GetExternalNavigation () const

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

const G4AffineTransform &	GetGlobalToLocalTransform () const

G4ThreeVector	GetLastStepEndPoint () const

virtual G4ThreeVector	GetLocalExitNormal (G4bool *valid)

virtual G4ThreeVector	GetLocalExitNormalAndCheck (const G4ThreeVector &point, G4bool *valid)

const G4AffineTransform	GetLocalToGlobalTransform () const

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

G4int	GetVerboseLevel () const

G4VPhysicalVolume *	GetWorldVolume () const

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

G4bool	IsActive () const

G4bool	IsCheckModeActive () const

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

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

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

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

virtual void	LocateGlobalPointWithinVolume (const G4ThreeVector &position)

G4RotationMatrix	NetRotation () const

G4ThreeVector	NetTranslation () const

void	PrintState () const

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

void	ResetStackAndState ()

void	SetExternalNavigation (G4VExternalNavigation *externalNav)

void	SetGeometricallyLimitedStep ()

void	SetPushVerbosity (G4bool mode)

void	SetVerboseLevel (G4int level)

void	SetVoxelNavigation (G4VoxelNavigation *voxelNav)

void	SetWorldVolume (G4VPhysicalVolume *pWorld)

G4int	SeverityOfZeroStepping (G4int *noZeroSteps) const

G4double	TargetSafetyFromPoint (const G4ThreeVector &pGlobalpoint)

	~G4ErrorPropagationNavigator ()

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

G4bool	CheckOverlapsIterative (G4VPhysicalVolume *vol)

G4ThreeVector	ComputeLocalAxis (const G4ThreeVector &pVec) const

G4ThreeVector	ComputeLocalPoint (const G4ThreeVector &rGlobPoint) const

G4int	GetDaughtersRegularStructureId (const G4LogicalVolume *pLv) const

virtual void	ResetState ()

void	RestoreSavedState ()

void	SetSavedState ()

virtual void	SetupHierarchy ()

EVolume	VolumeType (const G4VPhysicalVolume *pVol) const

Protected Attributes
G4bool	fEnteredDaughter

G4bool	fExitedMother

G4NavigationHistory	fHistory

G4ThreeVector	fLastStepEndPointLocal

G4double	fMinStep

G4double	fSqTol

G4ThreeVector	fStepEndPoint

G4int	fVerbose = 0

G4bool	fWasLimitedByGeometry = false

G4double	kCarTolerance

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

G4VoxelNavigation &	GetVoxelNavigator ()

Private Attributes
G4int	fAbandonThreshold_NoZeroSteps = 25

G4int	fActionThreshold_NoZeroSteps = 10

G4bool	fActive = false

G4VPhysicalVolume *	fBlockedPhysicalVolume

G4int	fBlockedReplicaNo

G4bool	fCalculatedExitNormal

G4bool	fChangedGrandMotherRefFrame

G4bool	fCheck = false

G4bool	fEntering

G4bool	fExiting

G4ThreeVector	fExitNormal

G4ThreeVector	fExitNormalGlobalFrame

G4ThreeVector	fGrandMotherExitNormal

G4ThreeVector	fLastLocatedPointLocal

G4VPhysicalVolume *	fLastMotherPhys = nullptr

G4bool	fLastStepWasZero

G4bool	fLastTriedStepComputation = false

G4bool	fLocatedOnEdge

G4bool	fLocatedOutsideWorld

G4NormalNavigation	fnormalNav

G4int	fNumberZeroSteps

G4ParameterisedNavigation	fparamNav

G4VExternalNavigation *	fpExternalNav = nullptr

G4double	fPreviousSafety

G4ThreeVector	fPreviousSftOrigin

G4bool	fPushed = false

G4VoxelNavigation *	fpvoxelNav

G4VoxelSafety *	fpVoxelSafety

G4RegularNavigation	fregularNav

G4ReplicaNavigation	freplicaNav

struct G4Navigator::G4SaveNavigatorState	fSaveState

G4VPhysicalVolume *	fTopPhysical = nullptr

G4bool	fValidExitNormal

G4bool	fWarnPush = true

Detailed Description

Definition at line 44 of file G4ErrorPropagationNavigator.hh.

Constructor & Destructor Documentation

◆ G4ErrorPropagationNavigator()

G4ErrorPropagationNavigator::G4ErrorPropagationNavigator ( )

Definition at line 44 of file G4ErrorPropagationNavigator.cc.

  : G4Navigator()
{
}

◆ ~G4ErrorPropagationNavigator()

G4ErrorPropagationNavigator::~G4ErrorPropagationNavigator ( )

Definition at line 51 of file G4ErrorPropagationNavigator.cc.

52{

53}

Member Function Documentation

◆ Activate()

void G4Navigator::Activate ( G4bool flag )

inlineinherited

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

◆ CharacteriseDaughters()

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

inlineprotectedinherited

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

◆ CheckMode()

void G4Navigator::CheckMode ( G4bool mode )

inlineinherited

Referenced by G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck().

◆ CheckNextStep()

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

inherited

Definition at line 1255 of file G4Navigator.cc.

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

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

Referenced by G4SafetyHelper::CheckNextStep().

◆ CheckOverlapsIterative()

G4bool G4Navigator::CheckOverlapsIterative ( G4VPhysicalVolume * vol )

protectedinherited

Definition at line 2130 of file G4Navigator.cc.

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

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

Referenced by G4Navigator::ComputeStep().

◆ Clone()

G4Navigator * G4Navigator::Clone ( ) const

inlineinherited

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

◆ ComputeLocalAxis()

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

inlineprotectedinherited

Referenced by G4Navigator::ComputeStep().

◆ ComputeLocalPoint()

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

inlineprotectedinherited

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

◆ ComputeSafety()

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

virtual

Reimplemented from G4Navigator.

Definition at line 153 of file G4ErrorPropagationNavigator.cc.

{
  G4double safetyGeom = G4Navigator::ComputeSafety(pGlobalPoint,
                                                  pMaxLength, keepState);
 
  G4double safetyTarget = TargetSafetyFromPoint( pGlobalPoint ); 
 
  return std::min(safetyGeom, safetyTarget); 
}

References G4Navigator::ComputeSafety(), G4INCL::Math::min(), and TargetSafetyFromPoint().

◆ ComputeStep()

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

virtual

Reimplemented from G4Navigator.

Definition at line 57 of file G4ErrorPropagationNavigator.cc.

{
  G4double safetyGeom = DBL_MAX;
   
  G4double Step = G4Navigator::ComputeStep(pGlobalPoint, pDirection,
                                           pCurrentProposedStepLength,
                                           safetyGeom);
  
  G4ErrorPropagatorData* g4edata
    = G4ErrorPropagatorData::GetErrorPropagatorData();
 
  if ( g4edata != nullptr )
  {
    const G4ErrorTarget* target = g4edata->GetTarget();
    if( target != nullptr )
    {
      G4double StepPlane=target->GetDistanceFromPoint(pGlobalPoint,pDirection);
 
      if( StepPlane < 0. ) // Negative means target is crossed,
      {                    // will not be found
        StepPlane = DBL_MAX; 
      }
#ifdef G4VERBOSE
      if( G4ErrorPropagatorData::verbose() >= 4 )
      {
        G4cout << "G4ErrorPropagationNavigator::ComputeStep()" << G4endl
               << "  Target step: " << StepPlane
               << ", Transportation step: " << Step << G4endl;
        target->Dump( "G4ErrorPropagationNavigator::ComputeStep Target " );
      }
#endif
 
      if( StepPlane < Step )
      {
#ifdef G4VERBOSE
        if( G4ErrorPropagatorData::verbose() >= 2 )
        {
          G4cout << "G4ErrorPropagationNavigator::ComputeStep()" << G4endl
                 << "  TargetCloserThanBoundary: " << StepPlane << " < "
                 << Step << G4endl;
        }
#endif
        Step = StepPlane;
        g4edata->SetState(G4ErrorState_TargetCloserThanBoundary);
      }
      else
      {
        g4edata->SetState(G4ErrorState_Propagating);
      }
    }
  }
  G4double safetyTarget = TargetSafetyFromPoint(pGlobalPoint);
 
  // Avoid call to G4Navigator::ComputeSafety - which could have side effects
  //
  pNewSafety = std::min(safetyGeom, safetyTarget); 
 
#ifdef G4VERBOSE
  if( G4ErrorPropagatorData::verbose() >= 3 )
  {
    G4cout << "G4ErrorPropagationNavigator::ComputeStep()" << G4endl
           << "  Step: " << Step << ", ComputeSafety: " << pNewSafety
           << G4endl;
  }
#endif
 
  return Step;
}

References G4Navigator::ComputeStep(), DBL_MAX, G4ErrorTarget::Dump(), G4cout, G4endl, G4ErrorState_Propagating, G4ErrorState_TargetCloserThanBoundary, G4ErrorTarget::GetDistanceFromPoint(), G4ErrorPropagatorData::GetErrorPropagatorData(), G4ErrorPropagatorData::GetTarget(), G4INCL::Math::min(), G4ErrorPropagatorData::SetState(), TargetSafetyFromPoint(), and G4ErrorPropagatorData::verbose().

◆ ComputeStepLog()

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

privateinherited

Definition at line 2027 of file G4Navigator.cc.

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

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

Referenced by G4Navigator::ComputeStep().

◆ CreateGRSSolid()

G4GRSSolid * G4Navigator::CreateGRSSolid ( ) const

inlineinherited

◆ CreateGRSVolume()

G4GRSVolume * G4Navigator::CreateGRSVolume ( ) const

inlineinherited

◆ CreateTouchableHistory() [1/2]

G4TouchableHistory * G4Navigator::CreateTouchableHistory ( ) const

inlineinherited

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

◆ CreateTouchableHistory() [2/2]

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

inlineinherited

◆ CreateTouchableHistoryHandle()

G4TouchableHistoryHandle G4Navigator::CreateTouchableHistoryHandle ( ) const

virtualinherited

Reimplemented in G4MultiNavigator.

Definition at line 1955 of file G4Navigator.cc.

{
  return G4TouchableHistoryHandle( CreateTouchableHistory() );
}

References G4Navigator::CreateTouchableHistory().

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

◆ EnableBestSafety()

void G4Navigator::EnableBestSafety ( G4bool value = false )

inlineinherited

◆ EnteredDaughterVolume()

G4bool G4Navigator::EnteredDaughterVolume ( ) const

inlineinherited

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

◆ ExitedMotherVolume()

G4bool G4Navigator::ExitedMotherVolume ( ) const

inlineinherited

Referenced by G4Transportation::PostStepDoIt().

◆ GetCurrentLocalCoordinate()

G4ThreeVector G4Navigator::GetCurrentLocalCoordinate ( ) const

inlineinherited

◆ GetDaughtersRegularStructureId()

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

inlineprotectedinherited

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

◆ GetExternalNavigation()

G4VExternalNavigation * G4Navigator::GetExternalNavigation ( ) const

inlineinherited

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

◆ GetGlobalExitNormal()

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

virtual

Reimplemented from G4Navigator.

Definition at line 168 of file G4ErrorPropagationNavigator.cc.

{
  G4ErrorPropagatorData* g4edata
        = G4ErrorPropagatorData::GetErrorPropagatorData();
  const G4ErrorTarget* target = nullptr;
 
  G4ThreeVector normal(0.0, 0.0, 0.0);
  G4double      distance= 0;
  
  // Determine which 'geometry' limited the step
  if ( g4edata != nullptr )
  {
    target = g4edata->GetTarget();
    if( target != nullptr )
    {
      distance = target->GetDistanceFromPoint(point);
    }
  }
  
  if( distance > kCarTolerance || (target == nullptr) )
    // Not reached the target or if a target does not exist,
    // this seems the best we can do
  {
    normal = G4Navigator::GetGlobalExitNormal(point, valid);
  }
  else
  {
    switch( target->GetType() )
    {
      case G4ErrorTarget_GeomVolume:
        // The volume is in the 'real' mass geometry
        normal = G4Navigator::GetGlobalExitNormal(point, valid);
        break;
      case G4ErrorTarget_TrkL:
        normal = G4ThreeVector( 0.0, 0.0, 0.0);
        *valid = false;
        G4Exception("G4ErrorPropagationNavigator::GetGlobalExitNormal",
                    "Geometry1003",
                    JustWarning, "Unexpected value of Target type");
        break;
      case G4ErrorTarget_PlaneSurface:
      case G4ErrorTarget_CylindricalSurface:
        const G4ErrorSurfaceTarget* surfaceTarget=
          static_cast<const G4ErrorSurfaceTarget*>(target);
        normal = surfaceTarget->GetTangentPlane(point).normal().unit();
        *valid = true;
        break;
 
//      default:
//        normal= G4ThreeVector( 0.0, 0.0, 0.0 );
//        *valid = false;
//        G4Exception("G4ErrorPropagationNavigator::GetGlobalExitNormal",
//                    "Geometry:003",
//                    FatalException, "Impossible value of Target type");
//        break;
    }
  }
  return normal;
}

References G4ErrorTarget_CylindricalSurface, G4ErrorTarget_GeomVolume, G4ErrorTarget_PlaneSurface, G4ErrorTarget_TrkL, G4Exception(), G4ErrorTarget::GetDistanceFromPoint(), G4ErrorPropagatorData::GetErrorPropagatorData(), G4Navigator::GetGlobalExitNormal(), G4ErrorSurfaceTarget::GetTangentPlane(), G4ErrorPropagatorData::GetTarget(), G4ErrorTarget::GetType(), JustWarning, G4Navigator::kCarTolerance, HepGeom::Plane3D< T >::normal(), and CLHEP::normal().

◆ GetGlobalToLocalTransform()

const G4AffineTransform & G4Navigator::GetGlobalToLocalTransform ( ) const

inlineinherited

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

◆ GetLastStepEndPoint()

G4ThreeVector G4Navigator::GetLastStepEndPoint ( ) const

inlineinherited

Definition at line 304 of file G4Navigator.hh.

304{ return fStepEndPoint;}

G4Navigator::fStepEndPoint

G4ThreeVector fStepEndPoint

Definition: G4Navigator.hh:388

References G4Navigator::fStepEndPoint.

◆ GetLocalExitNormal()

G4ThreeVector G4Navigator::GetLocalExitNormal ( G4bool * valid )

virtualinherited

Reimplemented in G4MultiNavigator.

Definition at line 1389 of file G4Navigator.cc.

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

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

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

◆ GetLocalExitNormalAndCheck()

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

virtualinherited

Reimplemented in G4MultiNavigator.

Definition at line 1606 of file G4Navigator.cc.

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

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

Referenced by G4Navigator::GetGlobalExitNormal().

◆ GetLocalToGlobalTransform()

const G4AffineTransform G4Navigator::GetLocalToGlobalTransform ( ) const

inlineinherited

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

◆ GetMotherToDaughterTransform()

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

inherited

Definition at line 1555 of file G4Navigator.cc.

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

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

Referenced by G4Navigator::GetLocalExitNormal().

◆ GetVerboseLevel()

G4int G4Navigator::GetVerboseLevel ( ) const

inlineinherited

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

◆ GetVoxelNavigator()

G4VoxelNavigation & G4Navigator::GetVoxelNavigator ( )

inlineprivateinherited

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

◆ GetWorldVolume()

G4VPhysicalVolume * G4Navigator::GetWorldVolume ( ) const

inlineinherited

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

◆ InformLastStep()

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

inherited

Definition at line 2240 of file G4Navigator.cc.

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

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

◆ IsActive()

G4bool G4Navigator::IsActive ( ) const

inlineinherited

Referenced by export_G4Navigator().

◆ IsCheckModeActive()

G4bool G4Navigator::IsCheckModeActive ( ) const

inlineinherited

Referenced by G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck().

◆ LocateGlobalPointAndSetup()

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

virtualinherited

Reimplemented in G4MultiNavigator.

Definition at line 132 of file G4Navigator.cc.

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

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

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

◆ LocateGlobalPointAndUpdateTouchable() [1/2]

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

inlineinherited

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

◆ LocateGlobalPointAndUpdateTouchable() [2/2]

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

inlineinherited

◆ LocateGlobalPointAndUpdateTouchableHandle()

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

inlineinherited

◆ LocateGlobalPointWithinVolume()

void G4Navigator::LocateGlobalPointWithinVolume ( const G4ThreeVector & position )

virtualinherited

Reimplemented in G4MultiNavigator.

Definition at line 614 of file G4Navigator.cc.

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

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

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

◆ NetRotation()

G4RotationMatrix G4Navigator::NetRotation ( ) const

inlineinherited

◆ NetTranslation()

G4ThreeVector G4Navigator::NetTranslation ( ) const

inlineinherited

◆ PrintState()

void G4Navigator::PrintState ( ) const

inherited

Definition at line 1964 of file G4Navigator.cc.

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

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

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

◆ ResetHierarchyAndLocate()

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

virtualinherited

Reimplemented in G4MultiNavigator.

Definition at line 102 of file G4Navigator.cc.

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

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

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

◆ ResetStackAndState()

void G4Navigator::ResetStackAndState ( )

inlineinherited

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

◆ ResetState()

void G4Navigator::ResetState ( )

protectedvirtualinherited

Reimplemented in G4MultiNavigator.

Definition at line 1288 of file G4Navigator.cc.

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

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

Referenced by G4Navigator::ResetHierarchyAndLocate().

◆ RestoreSavedState()

void G4Navigator::RestoreSavedState ( )

protectedinherited

Definition at line 716 of file G4Navigator.cc.

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

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

◆ SetExternalNavigation()

void G4Navigator::SetExternalNavigation ( G4VExternalNavigation * externalNav )

inlineinherited

◆ SetGeometricallyLimitedStep()

void G4Navigator::SetGeometricallyLimitedStep ( )

inlineinherited

Referenced by G4Transportation::PostStepDoIt().

◆ SetPushVerbosity()

void G4Navigator::SetPushVerbosity ( G4bool mode )

inlineinherited

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

◆ SetSavedState()

void G4Navigator::SetSavedState ( )

protectedinherited

Definition at line 682 of file G4Navigator.cc.

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

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

◆ SetupHierarchy()

void G4Navigator::SetupHierarchy ( )

protectedvirtualinherited

Reimplemented in G4MultiNavigator.

Definition at line 1329 of file G4Navigator.cc.

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

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

Referenced by G4Navigator::ResetHierarchyAndLocate().

◆ SetVerboseLevel()

void G4Navigator::SetVerboseLevel ( G4int level )

inlineinherited

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

◆ SetVoxelNavigation()

void G4Navigator::SetVoxelNavigation ( G4VoxelNavigation * voxelNav )

inherited

◆ SetWorldVolume()

void G4Navigator::SetWorldVolume ( G4VPhysicalVolume * pWorld )

inlineinherited

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

◆ SeverityOfZeroStepping()

G4int G4Navigator::SeverityOfZeroStepping ( G4int * noZeroSteps ) const

inlineinherited

◆ TargetSafetyFromPoint()

G4double G4ErrorPropagationNavigator::TargetSafetyFromPoint ( const G4ThreeVector & pGlobalpoint )

Definition at line 132 of file G4ErrorPropagationNavigator.cc.

{
  G4double safety = DBL_MAX;
 
  G4ErrorPropagatorData* g4edata
    = G4ErrorPropagatorData::GetErrorPropagatorData();
 
  if ( g4edata != nullptr )
  {
    const G4ErrorTarget* target = g4edata->GetTarget();
    if( target != nullptr )
    {
       safety = target->GetDistanceFromPoint(pGlobalpoint);
    }
  }
  return safety;
}