EIC code displayed by LXR master/​include/​Geant4/​G4Navigator.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-09-25 09:13:35

 //
 // ********************************************************************
 // * License and Disclaimer                                           *
 // *                                                                  *
 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
 // * conditions of the Geant4 Software License,  included in the file *
 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
 // * include a list of copyright holders.                             *
 // *                                                                  *
 // * Neither the authors of this software system, nor their employing *
 // * institutes,nor the agencies providing financial support for this *
 // * work  make  any representation or  warranty, express or implied, *
 // * regarding  this  software system or assume any liability for its *
 // * use.  Please see the license in the file  LICENSE  and URL above *
 // * for the full disclaimer and the limitation of liability.         *
 // *                                                                  *
 // * This  code  implementation is the result of  the  scientific and *
 // * technical work of the GEANT4 collaboration.                      *
 // * By using,  copying,  modifying or  distributing the software (or *
 // * any work based  on the software)  you  agree  to acknowledge its *
 // * use  in  resulting  scientific  publications,  and indicate your *
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
 //
 // G4Navigator
 //
 // Class description:
 //
 // 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.
 
 // Original author: Paul Kent (CERN), July 1995-1996
 //
 // - Made Navigator Abstract                   G. Cosmo,      Nov  2003
 // - Added check mode                          G. Cosmo,      Mar  2004
 // - Zero step protections                     J.A. / G.C.,   Nov  2004
 // --------------------------------------------------------------------
 #ifndef G4NAVIGATOR_HH
 #define G4NAVIGATOR_HH 1
 
 #include "geomdefs.hh"
 
 #include "G4ThreeVector.hh"
 #include "G4AffineTransform.hh"
 #include "G4RotationMatrix.hh"
 
 #include "G4LogicalVolume.hh"             // Used in inline methods
 #include "G4TouchableHandle.hh"           //    "         "
 
 #include "G4NavigationHistory.hh"
 #include "G4NormalNavigation.hh"
 #include "G4VoxelNavigation.hh"
 #include "G4ParameterisedNavigation.hh"
 #include "G4ReplicaNavigation.hh"
 #include "G4RegularNavigation.hh"
 #include "G4VExternalNavigation.hh"
 
 #include <iostream>
 
 class G4VPhysicalVolume;
 class G4SafetyCalculator;
 
 /**
  * @brief 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.
  */
 
 class G4Navigator
 {
   public:
 
     friend std::ostream& operator << (std::ostream &os, const G4Navigator &n);
 
     /**
      * Constructor - initialisers and setup.
      */
     G4Navigator();
 
     /**
      * Copy constructor & assignment operator not allowed.
      */
     G4Navigator(const G4Navigator&) = delete;
     G4Navigator& operator=(const G4Navigator&) = delete;
 
     /**
      * Destructor.
      */
     virtual ~G4Navigator();
 
     /**
      * 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.
      *  @param[in] pGlobalPoint The point in global coordinates system.
      *  @param[in] pDirection The normalised vector direction.
      *  @param[in] pCurrentProposedStepLength Current proposed step length.
      *  @param[in,out] newSafety New safety.
      *  @returns Length from current point to next boundary surface along
      *           @p pDirection.
      */
     virtual G4double ComputeStep(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.
      */
     G4double CheckNextStep(const G4ThreeVector& pGlobalPoint,
                            const G4ThreeVector& pDirection,
                            const G4double pCurrentProposedStepLength,
                                  G4double& pNewSafety); 
 
     /**
      * 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.
      *  @param[in] point The point in global coordinates system.
      *  @param[in] direction The normalised vector direction.
      *  @param[in] h The touchable history to be used for initialisation.
      *  @returns The pointer to the physical volume where point is located.
      */
     virtual
     G4VPhysicalVolume* ResetHierarchyAndLocate(const G4ThreeVector& point,
                                                const G4ThreeVector& direction,
                                                const G4TouchableHistory& h);
 
     /**
      * 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.
      *  @param[in] point The point in global coordinates system.
      *  @param[in] direction The normalised vector direction.
      *  @param[in] pRelativeSearch Flag to specify where search starts from.
      *  @param[in] ignoreDirection Flag to specify if to use direction or not.
      *  @returns The pointer to the physical volume where point is located.
      */
     virtual
     G4VPhysicalVolume* LocateGlobalPointAndSetup(const G4ThreeVector& point,
                                        const G4ThreeVector* direction = nullptr,
                                        const G4bool pRelativeSearch = true,
                                        const G4bool ignoreDirection = true);
 
     /**
      * 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.
      *  @param[in] position The position point in global coordinates system.
      */
     virtual
     void LocateGlobalPointWithinVolume(const G4ThreeVector& position);
 
     /**
      * 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.
      *  @param[in] position The point in global coordinates system.
      *  @param[in] direction The normalised vector direction.
      *  @param[in,out] oldTouchableToUpdate Touchable handle to update.
      *  @param[in] RelativeSearch Flag to specify where search starts from.
      */
     inline void LocateGlobalPointAndUpdateTouchableHandle(
                   const G4ThreeVector&       position,
                   const G4ThreeVector&       direction,
                         G4TouchableHandle&   oldTouchableToUpdate,
                   const G4bool               RelativeSearch = true);
     /**
      * Same as the method above LocateGlobalPointAndUpdateTouchableHandle(),
      * except that a pointer to G4VTouchable is used for updating the touchable.
      */
     inline void LocateGlobalPointAndUpdateTouchable(
                   const G4ThreeVector&       position,
                   const G4ThreeVector&       direction,
                         G4VTouchable*        touchableToUpdate,
                   const G4bool               RelativeSearch = true);
 
     /**
      * Same as the method above LocateGlobalPointAndUpdateTouchable(),
      * except that direction is not specified.
      */
     inline void LocateGlobalPointAndUpdateTouchable(
                   const G4ThreeVector&       position,
                         G4VTouchable*        touchableToUpdate,
                   const G4bool               RelativeSearch = true);
 
     /**
      * Informs the navigator that the previous Step calculated by the
      * geometry was taken in its entirety.
      */
     inline void SetGeometricallyLimitedStep();
 
     /**
      * Calculates the isotropic distance to the nearest boundary from the
      * specified point in the global coordinate system. 
      *  @note The geometry must be closed.
      *  @param[in] globalpoint The point in global coordinates system.
      *             The point must be within the current volume.
      *  @param[in] pProposedMaxLength The proposed maximum length is used
      *             to avoid volume safety calculations.
      *  @param[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.  
      */
     virtual G4double ComputeSafety(const G4ThreeVector& globalpoint,
                                    const G4double pProposedMaxLength = DBL_MAX,
                                    const G4bool keepState = true);
 
     /**
      * Returns the current  world (topmost) volume.
      */
     inline G4VPhysicalVolume* GetWorldVolume() const;
 
     /**
      * Sets the world (topmost) volume. This must be positioned at the
      * origin (0,0,0) and unrotated.
      */
     inline void SetWorldVolume(G4VPhysicalVolume* pWorld);
 
     /**
      * Touchable creation method.
      *  @note Caller has deletion responsibility.
      *  @returns A pointer to the allocated touchable history.
      */
     inline G4TouchableHistory* CreateTouchableHistory() const;
 
     /**
      * Touchable creation method, given a history.
      *  @note Caller has deletion responsibility.
      *  @param[in] h Pointer to a navigation history to copy from.
      *  @returns A pointer to the allocated touchable history.
      */
     inline G4TouchableHistory* CreateTouchableHistory(const G4NavigationHistory* h) const;
 
     /**
      * Returns a reference counted handle to a touchable history.
      */
     virtual G4TouchableHandle CreateTouchableHistoryHandle() const;
 
     /**
      * 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.
      *  @note Normals are not available for replica volumes (i.e. valid=false).
      *  @param[in,out] valid Flag indicating if normal is valid.
      *  @returns A Exit Surface Normal vector and validity too.
      */
     virtual G4ThreeVector GetLocalExitNormal(G4bool* valid);
 
     /**
      * 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.
      *  @note Normals are not available for replica volumes (i.e. valid=false).
      *  @param[in] point Point in global coordinates system to compare to.
      *  @param[in,out] valid Flag indicating if normal is valid.
      *  @returns A Exit Surface Normal vector and validity too.
      */
     virtual G4ThreeVector GetLocalExitNormalAndCheck(const G4ThreeVector& point,
                                                            G4bool* valid);
     /**
      * 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.
      *  @note Normals are not available for replica volumes (i.e. valid=false).
      *  @param[in] point Point in global coordinates system to compare to.
      *  @param[in,out] valid Flag indicating if normal is valid.
      *  @returns A Exit Surface Normal vector and validity too.
      */
     virtual G4ThreeVector GetGlobalExitNormal(const G4ThreeVector& point,
                                                     G4bool* valid);
 
     /**
      * Verbosity control.
      *  @note If level>0 && G4VERBOSE, printout can occur.
      */
     inline G4int GetVerboseLevel() const;
     inline void  SetVerboseLevel(G4int level);
 
     /**
      * Verify if the navigator is active.
      */
     inline G4bool IsActive() const;
 
     /**
      * Activate/inactivate the navigator.
      */
     inline void  Activate(G4bool flag);
 
     /**
      * 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.
      */
     inline G4bool EnteredDaughterVolume() const;
 
     /**
      * Verify if the step has exited the mother volume.
      */
     inline G4bool ExitedMotherVolume() const;
 
     /**
      * Run navigation in "check-mode", therefore using additional verifications
      * and more strict correctness conditions.
      *  @note Is effective only with G4VERBOSE set.
      */
     inline void CheckMode(G4bool mode);
 
     /**
      * Set/unset verbosity for pushed tracks (default is true).
      */
     inline G4bool IsCheckModeActive() const;
     inline void SetPushVerbosity(G4bool mode);
 
     /**
      * Prints the internal state of the Navigator (for debugging).
      * The level of detail is according to the verbosity.
      */
     void PrintState() const;
 
     /**
      * Obtains the transformations Global/Local (and inverse).
      *  @note Clients of these methods must copy the data
      *        if they need to keep it.
      */
     inline const G4AffineTransform& GetGlobalToLocalTransform() const;
     inline const G4AffineTransform  GetLocalToGlobalTransform() const;
 
     /**
      * Obtains mother to daughter transformation.
      */
     G4AffineTransform GetMotherToDaughterTransform(G4VPhysicalVolume* dVolume, 
                                                    G4int dReplicaNo,
                                                    EVolume dVolumeType );
 
     /**
      * Resets stack and minimum or navigator state machine necessary for reset
      * as needed by LocalGlobalPointAndSetup().
      *  @note Does not perform clears, resizes, or reset fLastLocatedPointLocal.
      */
     inline void ResetStackAndState();
 
     /**
      * 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)
      *  @param[in,out] noZeroSteps Returns the number of zero steps in case
      *                 pointer is not null.
      *  @returns The error severity.
      */
     inline G4int SeverityOfZeroStepping( G4int* noZeroSteps ) const; 
 
     /**
      * 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.
      */
     inline G4ThreeVector GetCurrentLocalCoordinate() const;
 
     /**
      * Computes and returns the local->global translation/rotation
      * of current volume.
      */
     inline G4ThreeVector NetTranslation() const;
     inline G4RotationMatrix NetRotation() const;
 
     /**
      * Enables best-possible evaluation of isotropic safety.
      */
     inline void EnableBestSafety( G4bool value = false );
 
     /**
      * Accessor & modifier for custom external navigation.
      */
     inline G4VExternalNavigation* GetExternalNavigation() const;
     void SetExternalNavigation(G4VExternalNavigation* externalNav);
    
     /**
      * Gets/sets alternative navigator for voxel volumes.
      */
     inline G4VoxelNavigation& GetVoxelNavigator();
     void SetVoxelNavigation(G4VoxelNavigation* voxelNav);
 
     /**
      * 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.
      */
     inline G4Navigator* Clone() const;
 
     /**
      * Gets endpoint of last step.
      */
     inline G4ThreeVector GetLastStepEndPoint() const;
 
     /**
      * 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.
      */
     void InformLastStep(G4double lastStep,
                         G4bool entersDaughtVol,
                         G4bool exitsMotherVol );
 
   protected:
 
     /**
      * Saves the state: fValidExitNormal, fExitNormal, fExiting, fEntering,
      * fBlockedPhysicalVolume, fBlockedReplicaNo, fLastStepWasZero,
      * fLastLocatedPointLocal, fLocatedOutsideWorld, fEnteredDaughter,
      * fExitedMother, fPreviousSftOrigin, fPreviousSafety.
      */
     void SetSavedState();
 
     /**
      * Copy aspects of the state, to enable a non-state changing
      * call to ComputeStep().
      */
     void RestoreSavedState();
   
     /**
      * Utility method to reset the navigator state machine.
      */
     virtual void ResetState();
 
     /**
      * Returns position vector in local coordinate system, given a position
      * vector in world coordinate system.
      */
     inline G4ThreeVector ComputeLocalPoint(const G4ThreeVector& rGlobP) const;
 
     /**
      * 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.
      */
     inline G4ThreeVector ComputeLocalAxis(const G4ThreeVector& pVec) const;
 
     /**
      * Characterises the type of volume - normal/replicated/parameterised.
      */
     inline EVolume VolumeType(const G4VPhysicalVolume *pVol) const;
 
     /**
      * Characterises the daughters of given logical volume.
      */
     inline EVolume CharacteriseDaughters(const G4LogicalVolume *pLog) const;
 
     /**
      * Gets regular structure ID of first daughter.
      */
     inline G4int GetDaughtersRegularStructureId(const G4LogicalVolume *pLv) const;
 
     /**
      * Renavigates & resets hierarchy described by the current history:
      * Resets volumes and recomputes transforms and/or solids of
      * replicated/parameterised volumes.
      */
     virtual void SetupHierarchy();
 
     /**
      * 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.
      */
     G4bool CheckOverlapsIterative(G4VPhysicalVolume* vol);
 
   private:
 
     /**
      * Logs and checks for steps larger than the tolerance.
      */
     void ComputeStepLog(const G4ThreeVector& pGlobalpoint,
                               G4double moveLenSq) const;
 
   protected:
 
     G4double kCarTolerance, fMinStep, fSqTol;  // Cached tolerances.
 
     // BEGIN State information ------------------------------------------------
     //
 
     /** Transformation and history of the current path
         through the geometrical hierarchy. */
     G4NavigationHistory fHistory;
 
     /** Endpoint of last ComputeStep().
         Can be used for optimisation (e.g. when computing safety). */
     G4ThreeVector fStepEndPoint;
 
     /** Position of the end-point of the last call to ComputeStep()
         in last local coordinates. */
     G4ThreeVector fLastStepEndPointLocal; 
 
     /** Verbosity level  [if > 0, printout can occur]. */
     G4int fVerbose = 0;
    
     /** 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. */
     G4bool fEnteredDaughter;
 
     /** A similar memory whether the Step exited current "mother" volume
         completely, not entering daughter. */
     G4bool fExitedMother;
 
     /** Set true if last Step was limited by geometry. */
     G4bool fWasLimitedByGeometry = false;
 
   private:
 
     /** Position of the last located point relative to its containing volume.
         This is coupled with the Boolean member 'fLocatedOutsideWorld'. */
     G4ThreeVector fLastLocatedPointLocal;
 
     /** Leaving volume normal, in the volume containing the exited
         volume's coordinate system.
         This is closely coupled with 'fValidExitNormal', which signals whether
         we have a (valid) normal for volume we're leaving. */
     G4ThreeVector fExitNormal;
    
     /** Leaving volume normal, in its own coordinate system. */
     G4ThreeVector fGrandMotherExitNormal;
 
     /** Leaving volume normal, in the global coordinate system. */
     G4ThreeVector fExitNormalGlobalFrame;
 
     /** Memory of last safety origin & value. Used in ComputeStep() to ensure
         that origin of current Step is in the same volume as the point of the
         last relocation. */
     G4ThreeVector fPreviousSftOrigin;
     G4double fPreviousSafety; 
 
     /** Memory of the mother volume during previous step.
         Intended use: inform user in case of stuck track. */
     G4VPhysicalVolume* fLastMotherPhys = nullptr;
    
     /** Identifies the volume and copy / replica number that is blocked
         (after exiting -- because the exit direction is along the exit normal)
         or a candidate for entry (after compute step). */
     G4VPhysicalVolume* fBlockedPhysicalVolume;
     G4int fBlockedReplicaNo;
    
     /** Count zero steps, as one or two can occur due to changing momentum at
         a boundary or at an edge common between volumes; several zero steps
         are likely a problem in the geometry description or in the navigation.
         Number of preceding moves that were Zero.
         Reset to 0 after finite step. */
     G4int fNumberZeroSteps;
 
     /** After this many failed/zero steps, act (push etc). */
     G4int fActionThreshold_NoZeroSteps = 10;  
 
     /** After this many failed/zero steps, abandon track. */
     G4int fAbandonThreshold_NoZeroSteps = 25; 
 
     /** States if the navigator is activated or not. */
     G4bool fActive = false;
 
     /** Whether ComputeStep() was called since the last call to a Locate().
         Uses: distinguish parts of state which differ before/after calls
         to ComputeStep() or one of the Locate() methods; avoid two consecutive
         calls to compute-step (illegal). */
     G4bool fLastTriedStepComputation = false; 
 
     /** Entering/Exiting volumes blocking/setup.
         o If exiting, volume ptr & replica number (set & used by Locate..())
           used for blocking on redescent of geometry;
         o If entering, volume ptr & replica number (set by ComputeStep(),
           used by Locate..()) of volume for 'automatic' entry. */
     G4bool fEntering, fExiting;
    
     /** Set true if have leaving volume normal. */
     G4bool fValidExitNormal;
 
     /** Whether the last ComputeStep moved Zero. Used to check for edges. */
     G4bool fLastStepWasZero;
 
     /** Whether the Navigator has detected an edge. */
     G4bool fLocatedOnEdge;       
 
     /** Whether the last call to Locate methods left the world. */
     G4bool fLocatedOutsideWorld;
    
     /** Whether frame is changed. */
     G4bool  fChangedGrandMotherRefFrame;
 
     /** Has it been computed since the last call to ComputeStep().
         Covers both Global and GrandMother. */
     G4bool  fCalculatedExitNormal;
 
     //
     // END State information --------------------------------------------------
 
     // Optional State information (created/used as needed)
     // 
    
     // Save key state information (NOT the navigation history stack)
     //
     struct G4SaveNavigatorState
     { 
        G4ThreeVector sExitNormal;  
        G4bool sValidExitNormal;    
        G4bool sEntering, sExiting;
        G4VPhysicalVolume* spBlockedPhysicalVolume;
        G4int sBlockedReplicaNo;  
        G4int sLastStepWasZero; 
        G4bool sWasLimitedByGeometry;
 
        //  Potentially relevant
        //
        G4bool sLocatedOutsideWorld;
        G4ThreeVector sLastLocatedPointLocal; 
        G4bool sEnteredDaughter, sExitedMother;
        G4ThreeVector sPreviousSftOrigin;
        G4double sPreviousSafety; 
     } fSaveState; 
 
     // ========================================================================
     // BEGIN -- Tracking Invariants
 
     /** A link to the topmost physical volume in the detector.
         Must be positioned at the origin and unrotated. */
     G4VPhysicalVolume* fTopPhysical = nullptr;
 
     // Helpers/Utility classes
 
     G4NormalNavigation fnormalNav;
     G4VoxelNavigation* fpvoxelNav;
     G4ParameterisedNavigation fparamNav;
     G4ReplicaNavigation freplicaNav;
     G4RegularNavigation fregularNav;
     G4VExternalNavigation* fpExternalNav = nullptr;
     G4VoxelSafety* fpVoxelSafety;
     G4SafetyCalculator* fpSafetyCalculator = nullptr;
 
     // Utility information
 
     /** Check-mode flag  [if true, more strict checks are performed]. */
     G4bool fCheck = false;
 
     /** Push flags  [if true, means a stuck particle has been pushed]. */
     G4bool fPushed = false, fWarnPush = true;
 
     // End -- Tracking Invariants
     // ========================================================================
 };
 
 #include "G4Navigator.icc"
 
 #endif
 
 
 // NOTES:
 //
 // The following methods provide detailed information when a Step has
 // arrived at a geometrical boundary.  They distinguish between the different
 // causes that can result in the track leaving its current volume.
 //
 // Four cases are possible:
 //
 // 1) The particle has reached a boundary of a daughter of the current volume:
 //     (this could cause the relocation to enter the daughter itself
 //     or a potential granddaughter or further descendant)
 //     
 // 2) The particle has reached a boundary of the current
 //     volume, exiting into a mother (regardless the level
 //     at which it is located in the tree):
 //
 // 3) The particle has reached a boundary of the current
 //     volume, exiting into a volume which is not in its
 //     parental hierarchy:
 //
 // 4) The particle is not on a boundary between volumes:
 //     the function returns an exception, and the caller is
 //     reccomended to compare the G4touchables associated
 //     to the preStepPoint and postStepPoint to handle this case.
 //
 //   G4bool        EnteredDaughterVolume()
 //   G4bool        IsExitNormalValid()
 //   G4ThreeVector GetLocalExitNormal()
 //
 // The expected usefulness of these methods is to allow the caller to
 // determine how to compute the surface normal at the volume boundary. The two
 // possibilities are to obtain the normal from:
 //
 //   i) the solid associated with the volume of the initial point of the Step.
 //      This is valid for cases 2 and 3.  
 //      (Note that the initial point is generally the PreStepPoint of a Step).
 //   or
 // 
 //  ii) the solid of the final point, ie of the volume after the relocation.
 //      This is valid for case 1.
 //      (Note that the final point is generally the PreStepPoint of a Step).
 //
 // This way the caller can always get a valid normal, pointing outside
 // the solid for which it is computed, that can be used at his own
 // discretion.

This page was automatically generated by the 2.3.7 LXR engine. The LXR team