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

File indexing completed on 2025-01-18 09:58:33

 //
 // ********************************************************************
 // * 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.          *
 // ********************************************************************
 //
 //
 // Original author: Paul Kent, July 95/96
 //
 /// \brief { Class description:
 ///
 /// G4ITNavigator is a duplicate version of G4Navigator started from Geant4.9.5
 /// initially written by Paul Kent and colleagues.
 /// The only difference resides in the way the information is saved and managed
 ///
 /// 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.}
 //
 // Contact : Mathieu Karamitros (kara (AT) cenbg . in2p3 . fr)
 //
 // WARNING : This class is released as a prototype.
 // It might strongly evolve or even disappear in the next releases.
 //
 // We would be very happy hearing from you, send us your feedback! :)
 //
 // History:
 // - Created.                                  Paul Kent,     Jul 95/96
 // - Zero step protections                     J.A. / G.C.,   Nov  2004
 // - Added check mode                          G. Cosmo,      Mar  2004
 // - Made Navigator Abstract                   G. Cosmo,      Nov  2003
 // - G4ITNavigator created                     M.K.,          Nov  2012
 // *********************************************************************
 
 #ifndef G4ITNAVIGATOR_HH
 #define G4ITNAVIGATOR_HH
 
 #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 <iostream>
 #include "G4TrackState.hh"
 #include <memory>
 
 class G4VPhysicalVolume;
 
 struct G4ITNavigatorState_Lock2
 {
   virtual ~G4ITNavigatorState_Lock2() = default;
 protected:
   G4ITNavigatorState_Lock2() = default;
 };
 
 class G4ITNavigator2
 {
 public:
   static const G4int fMaxNav = 8; // rename to kMaxNoNav ??
 
 public:
   // with description
 
   friend std::ostream& operator <<(std::ostream &os, const G4ITNavigator2 &n);
 
   G4ITNavigator2();
   // Constructor - initialisers and setup.
 
   virtual ~G4ITNavigator2();
   // Destructor. No actions.
 
   G4ITNavigator2(const G4ITNavigator2&) = delete;
   G4ITNavigator2& operator=(const G4ITNavigator2&) = delete;
 
   // !>
   G4ITNavigatorState_Lock2* GetNavigatorState();
   void SetNavigatorState(G4ITNavigatorState_Lock2*);
   void NewNavigatorState();
   void NewNavigatorState(const G4TouchableHistory &h);
   void ResetNavigatorState();
   G4VPhysicalVolume* NewNavigatorStateAndLocate(const G4ThreeVector &p,
                                                 const G4ThreeVector &direction);
   void CheckNavigatorState() const;
 
   inline std::shared_ptr<G4ITNavigatorState_Lock2> GetSnapshotOfState();
   inline void ResetFromSnapshot(std::shared_ptr<G4ITNavigatorState_Lock2>);
   // <!
 
   virtual G4double ComputeStep(const G4ThreeVector &pGlobalPoint,
                                const G4ThreeVector &pDirection,
                                const G4double pCurrentProposedStepLength,
                                      G4double  &pNewSafety);
   // Calculate 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. Geometry must be closed.
 
   G4double CheckNextStep(const G4ThreeVector &pGlobalPoint,
                          const G4ThreeVector &pDirection,
                          const G4double pCurrentProposedStepLength,
                                G4double &pNewSafety);
   // Same as above, but do not disturb the state of the Navigator.
 
   virtual G4VPhysicalVolume* ResetHierarchyAndLocate(const G4ThreeVector &point,
                                                      const G4ThreeVector &direction,
                                                      const G4TouchableHistory &h);
 
   // Resets the geometrical hierarchy and search for the volumes deepest
   // in the hierarchy containing the point in the global coordinate 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.
   //
   // Important Note: In order to call this the geometry MUST be closed.
 
   virtual
   G4VPhysicalVolume* LocateGlobalPointAndSetup(const G4ThreeVector& point,
                                              const G4ThreeVector* direction=nullptr,
                                              const G4bool pRelativeSearch=true,
                                              const G4bool ignoreDirection=true);
     // Search the geometrical hierarchy for the volumes deepest in the 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 the 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.)
     // 
     // Important Note: In order to call this the geometry MUST be closed.
 
   //----------------------------------------------------------------------------
   EInside InsideCurrentVolume(const G4ThreeVector& globalPoint) const;
 
   void GetRandomInCurrentVolume(G4ThreeVector& rndmPoint) const;
   //----------------------------------------------------------------------------
 
   virtual
   void LocateGlobalPointWithinVolume(const G4ThreeVector& position);
     // Notify 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.
 
   inline void LocateGlobalPointAndUpdateTouchableHandle(
                 const G4ThreeVector&       position,
                 const G4ThreeVector&       direction,
                       G4TouchableHandle&   oldTouchableToUpdate,
                 const G4bool               RelativeSearch = true);
     // First, search the geometrical hierarchy like the above method
     // LocateGlobalPointAndSetup(). Then use the volume found and its
     // navigation history to update the touchable.
 
   inline void LocateGlobalPointAndUpdateTouchable(
                 const G4ThreeVector&       position,
                 const G4ThreeVector&       direction,
                       G4VTouchable*        touchableToUpdate,
                 const G4bool               RelativeSearch = true);
     // First, search the geometrical hierarchy like the above method
     // LocateGlobalPointAndSetup(). Then use the volume found and its
     // navigation history to update the touchable.
 
   inline void LocateGlobalPointAndUpdateTouchable(
                 const G4ThreeVector&       position,
                       G4VTouchable*        touchableToUpdate,
                 const G4bool               RelativeSearch = true);
     // Same as the method above but missing direction.
 
   inline void SetGeometricallyLimitedStep();
     // Inform the navigator that the previous Step calculated
     // by the geometry was taken in its entirety.
 
   virtual G4double ComputeSafety(const G4ThreeVector &globalpoint,
                                  const G4double pProposedMaxLength = DBL_MAX,
                                  const G4bool keepState = true);
     // Calculate the isotropic distance to the nearest boundary from the
     // specified point in the global coordinate system. 
     // The globalpoint utilised must be within the current volume.
     // The value returned is usually an underestimate.  
     // The proposed maximum length is used to avoid volume safety
     //  calculations.  The geometry must be closed.
     // To ensure minimum side effects from the call, keepState
     //  must be true.
   
    virtual G4bool RecheckDistanceToCurrentBoundary(
                                const G4ThreeVector &pGlobalPoint,
                                const G4ThreeVector &pDirection,
                                const G4double  CurrentProposedStepLength,
                                      G4double *prDistance,
                                      G4double *prNewSafety=nullptr) const;
     // Trial method for checking potential displacement for MS
     // Check new Globalpoint, to see whether it is in current volume
     // (mother) and not in potential entering daughter.
     // If in mother, check distance to boundary along pDirection.
     // If in entering daughter, check distance back to boundary. 
     // NOTE:
     // Can be called only after ComputeStep is called - before ReLocation
     // Deals only with current volume (and potentially entered)
 
   inline G4VPhysicalVolume* GetWorldVolume() const;
     // Return the current  world (`topmost') volume.
 
   inline void SetWorldVolume(G4VPhysicalVolume* pWorld);
     // Set the world (`topmost') volume. This must be positioned at
     // origin (0,0,0) and unrotated.
 
   inline G4TouchableHistory* CreateTouchableHistory() const;
   inline G4TouchableHistory* CreateTouchableHistory(const G4NavigationHistory*) const;
     // `Touchable' creation methods: caller has deletion responsibility.
 
   virtual G4TouchableHandle CreateTouchableHistoryHandle() const;
     // Returns a reference counted handle to a touchable history.
 
   virtual G4ThreeVector GetLocalExitNormal(G4bool* valid);
   virtual G4ThreeVector GetLocalExitNormalAndCheck(const G4ThreeVector& point,
                                                          G4bool* valid);
   virtual G4ThreeVector GetGlobalExitNormal(const G4ThreeVector& point,
                                                   G4bool* valid);
     // Return Exit Surface Normal and validity too.
     // Can only be called if the Navigator's last Step has crossed a
     // volume geometrical boundary.
     // It returns the Normal to the surface pointing out of the volume that
     // was left behind and/or into the volume that was entered.
     // Convention:
     //   The *local* normal is in the coordinate system of the *final* volume.
     // Restriction:
     //   Normals are not available for replica volumes (returns valid= false)
     // These methods takes full care about how to calculate this normal,
     // but if the surfaces are not convex it will return valid=false.
 
   inline G4int GetVerboseLevel() const;
   inline void  SetVerboseLevel(G4int level);
     // Get/Set Verbose(ness) level.
     // [if level>0 && G4VERBOSE, printout can occur]
 
   inline G4bool IsActive() const;
     // Verify if the navigator is active.
   inline void  Activate(G4bool flag);
     // Activate/inactivate the navigator.
 
   inline G4bool EnteredDaughterVolume() const;
     // The purpose of this function is to inform the caller if the track is
     // entering a daughter volume while exiting from the current volume.
     // This method returns 
     // - True only in case 1) above, that is when the Step has caused
     //   the track to arrive at a boundary of a daughter.
     // - False in cases 2), 3) and 4), i.e. in all other cases.
     // This function is not guaranteed to work if SetGeometricallyLimitedStep()
     // was not called when it should have been called.
   inline G4bool ExitedMotherVolume() const;
   // Verify if the step has exited the mother volume.
 
   inline void   CheckMode(G4bool mode);
     // Run navigation in "check-mode", therefore using additional
     // verifications and more strict correctness conditions.
     // Is effective only with G4VERBOSE set.
   inline G4bool IsCheckModeActive() const;
   inline void   SetPushVerbosity(G4bool mode);
     // Set/unset verbosity for pushed tracks (default is true).
 
   void PrintState() const;
     // Print the internal state of the Navigator (for debugging).
     // The level of detail is according to the verbosity.
 
   inline const G4AffineTransform& GetGlobalToLocalTransform() const;
   inline const G4AffineTransform  GetLocalToGlobalTransform() const;
     // Obtain the transformations Global/Local (and inverse).
     // Clients of these methods must copy the data if they need to keep it.
 
   G4AffineTransform GetMotherToDaughterTransform(G4VPhysicalVolume* dVolume, 
                                                  G4int dReplicaNo,
                                                  EVolume dVolumeType );
     // Obtain mother to daughter transformation
 
   inline void ResetStackAndState();
     // Reset stack and minimum or navigator state machine necessary for reset
     // as needed by LocalGlobalPointAndSetup.
     // [Does not perform clears, resizes, or reset fLastLocatedPointLocal]
 
   inline G4int SeverityOfZeroStepping( G4int* noZeroSteps ) const;
   // Report 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)
 
   /*
    void SetSavedState();
    // ( fValidExitNormal, fExitNormal, fExiting, fEntering,
    //   fBlockedPhysicalVolume, fBlockedReplicaNo, fLastStepWasZero);
    void RestoreSavedState();
    // Copy aspects of the state, to enable a non-state changing
    //  call to ComputeStep
    */
   inline G4ThreeVector GetCurrentLocalCoordinate() const;
     // Return 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 NetTranslation() const;
   inline G4RotationMatrix NetRotation() const;
   // Compute+return the local->global translation/rotation of current volume.
 
   inline void EnableBestSafety( G4bool value= false );
   // Enable best-possible evaluation of isotropic safety
 
 protected:// with description
 
   inline G4ThreeVector ComputeLocalPoint(const G4ThreeVector& rGlobPoint) const;
   // Return position vector in local coordinate system, given a position
   // vector in world coordinate system.
 
   inline G4ThreeVector ComputeLocalAxis(const G4ThreeVector& pVec) const;
   // Return 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.
 
   virtual void ResetState();
   // Utility method to reset the navigator state machine.
 
   inline EVolume VolumeType(const G4VPhysicalVolume *pVol) const;
   // Characterise `type' of volume - normal/replicated/parameterised.
 
   inline EVolume CharacteriseDaughters(const G4LogicalVolume *pLog) const;
   // Characterise daughter of logical volume.
 
   inline G4int GetDaughtersRegularStructureId(const G4LogicalVolume *pLog) const;
   // Get regular structure ID of first daughter
 
   virtual void SetupHierarchy();
   // Renavigate & reset hierarchy described by current history
   // o Reset volumes
   // o Recompute transforms and/or solids of replicated/parameterised
   //   volumes.
 
 private:
 
   void ComputeStepLog(const G4ThreeVector& pGlobalpoint,
   G4double moveLenSq) const;
   // Log and checks for steps larger than the tolerance
 
 protected:// without description
 
   G4double kCarTolerance;
   // Geometrical tolerance for surface thickness of shapes.
 
   G4int fVerbose{0};
   // Verbose(ness) level  [if > 0, printout can occur].
 
 private:
 
   G4bool fActive;
   // States if the navigator is activated or not.
 
   G4int fActionThreshold_NoZeroSteps;
   // After this many failed/zero steps, act (push etc)
   G4int fAbandonThreshold_NoZeroSteps;
   // After this many failed/zero steps, abandon track
 
 protected:
 public:
   struct G4SaveNavigatorState;
 
   //
   // BEGIN State information
   //
   struct G4NavigatorState : public G4ITNavigatorState_Lock2
   {
     G4NavigatorState();
     G4NavigatorState(const G4NavigatorState&);
     ~G4NavigatorState() override
     { ;}
 
     G4NavigatorState& operator=(const G4NavigatorState& );
     G4NavigatorState& operator=(const G4SaveNavigatorState& );
 
     void ResetState();
     void ResetStack();
     void ResetStackAndState();
 
     G4NavigationHistory fHistory;
     // Transformation and history of the current path
     // through the geometrical hierarchy.
 
     G4bool fEnteredDaughter;
     // 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 fExitedMother;
     // A similar memory whether the Step exited current "mother" volume
     // completely, not entering daughter.
 
     G4bool fWasLimitedByGeometry;
     // Set true if last Step was limited by geometry.
 
     G4ThreeVector fStepEndPoint;
     // Endpoint of last ComputeStep
     // can be used for optimisation (e.g. when computing safety).
     G4ThreeVector fLastStepEndPointLocal;
     // Position of the end-point of the last call to ComputeStep
     // in last Local coordinates.
 
     G4bool fPushed;
     // Push flags  [if true, means a stuck particle has been pushed].
 
   private:
     friend class G4ITNavigator2;
     // The friend class would allow G4Navigator to access the private members
     // of G4NavigatorState but not the classes inheriting from G4Navigator
 
     friend struct G4SaveNavigatorState;
     friend std::ostream& operator << (std::ostream &os,const G4ITNavigator2 &n);
 
     G4bool fLastTriedStepComputation;
     // Whether ComputeStep was called since the last call to a Locate method
     // 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 fEntering,fExiting;
     // 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
 
     G4VPhysicalVolume *fBlockedPhysicalVolume;
     G4int fBlockedReplicaNo;
 
     G4ThreeVector fLastLocatedPointLocal;
     // Position of the last located point relative to its containing volume.
     G4bool fLocatedOutsideWorld;
     // Whether the last call to Locate methods left the world
 
     G4bool fValidExitNormal;// Set true if have leaving volume normal
     G4ThreeVector fExitNormal;// Leaving volume normal, in the
     // volume containing the exited
     // volume's coordinate system
     G4ThreeVector fGrandMotherExitNormal;// Leaving volume normal, in its
     // own coordinate system
     G4bool fChangedGrandMotherRefFrame;// Whether frame is changed
 
     G4ThreeVector fExitNormalGlobalFrame;// Leaving volume normal, in the
     // global coordinate system
     G4bool fCalculatedExitNormal;// Has it been computed since
     // the last call to ComputeStep
     // Covers both Global and GrandMother
 
     // Count zero steps - as one or two can occur due to changing momentum at
     //                    a boundary or at an edge common between volumes
     //                  - several are likely a problem in the geometry
     //                    description or in the navigation
     //
     G4bool fLastStepWasZero;
     // Whether the last ComputeStep moved Zero. Used to check for edges.
 
     G4bool fLocatedOnEdge;
     // Whether the Navigator has detected an edge
     G4int fNumberZeroSteps;
     // Number of preceding moves that were Zero. Reset to 0 after finite step
 
     G4ThreeVector fPreviousSftOrigin;
     G4double fPreviousSafety;
     // 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
 
     //
     // END State information
     //
   };
 
   G4NavigatorState* fpNavigatorState;
 
   // Save key state information (NOT the navigation history stack)
   //
   struct G4SaveNavigatorState
   {
     G4SaveNavigatorState();
     G4SaveNavigatorState(G4NavigatorState*);
     virtual ~G4SaveNavigatorState()
     { ;}
     G4ThreeVector sExitNormal;
     G4bool sValidExitNormal;
     G4bool sEntering, sExiting;
     G4VPhysicalVolume* spBlockedPhysicalVolume;
     G4int sBlockedReplicaNo;
     G4int sLastStepWasZero;
 
     // !>
 //    G4bool sLocatedOnEdge;
 //    G4bool sPushed;
 //    G4int sNumberZeroSteps;
     // <!
 
     //  Potentially relevant
     //
     G4bool sLocatedOutsideWorld;
     G4ThreeVector sLastLocatedPointLocal;
     G4bool sEnteredDaughter, sExitedMother;
     G4bool sWasLimitedByGeometry;
 
     G4ThreeVector sPreviousSftOrigin;
     G4double sPreviousSafety;
   };
 
   // G4SaveNavigatorState* fpSaveState;
 
   // Tracking Invariants
   //
   G4VPhysicalVolume *fTopPhysical{nullptr};
   // A link to the topmost physical volume in the detector.
   // Must be positioned at the origin and unrotated.
 
   // Utility information
   //
   G4bool fCheck{false};
   // Check-mode flag  [if true, more strict checks are performed].
 
   G4bool fWarnPush{true};
   // Push flag  [for verbose].
 
   // Helpers/Utility classes
   //
   G4NormalNavigation fnormalNav;
   G4VoxelNavigation fvoxelNav;
   G4ParameterisedNavigation fparamNav;
   G4ReplicaNavigation freplicaNav;
   G4RegularNavigation fregularNav;
   G4VoxelSafety *fpVoxelSafety;
 };
 
 RegisterTrackState(G4ITNavigator2, G4NavigatorState)
 
 #define CheckNavigatorStateIsValid() \
 if(fpNavigatorState == 0) \
 { \
     G4ExceptionDescription exceptionDescription; \
     exceptionDescription << "The navigator state is NULL. "; \
     exceptionDescription << "Either NewNavigatorStateAndLocate was not called "; \
     exceptionDescription << "or the provided navigator state was already NULL."; \
     G4Exception((G4String("G4Navigator")+G4String(__FUNCTION__)).c_str(),\
                 "NavigatorStateNotValid",FatalException,exceptionDescription); \
 }
 
 #include "G4ITNavigator2.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