lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 11.2.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2023-12-08 10:43:34 +01:00
parent dd1f179cda
commit 860a2b92bf
3962 changed files with 139318 additions and 164259 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/geometry/navigation/History
+31
View File
@@ -6,6 +6,37 @@ It must **not** be used as a substitute for writing good git commit messages!
-------------------------------------------------------------------------------
## 2023-11-17 Gabriele Cosmo (geomnav-V11-01-08)
- Fixed "/geometry/test/check_parallel" UI command in G4GeometryMessenger.
## 2023-11-06 Gabriele Cosmo (geomnav-V11-01-07)
- Fixed uninitialised data in G4SafetyCalculator.
Addressing a reported Coverity defect.
## 2023-11-04 Gabriele Cosmo (geomnav-V11-01-06)
- Some code cleanup in G4Navigator and code formatting.
## 2023-10-30 John Apostolakis (geomnav-V11-01-05)
- Add new G4SafetyCalculator class, auxiliary to G4Navigator.
Use this in G4Navigator in ComputeSafety() to avoid saving/restoring state.
## 2023-10-12 Guilherme Amadio (geomnav-V11-01-04)
- Add new G4VNavigation common navigation interface.
- Add RelocateWithinVolume method to G4VoxelNavigation
and G4ParameterisedNavigation.
- Update existing navigators to make use of new common interface.
## 2023-09-04 Gabriele Cosmo (geomnav-V11-01-03)
- In G4Navigator, use G4TouchableHandle in place of G4TouchableHistoryHandle
which is now deprecated. Same in G4MultiNavigator, G4DrawVoxels and
G4VIntersectionLocator.
## 2023-08-31 Gabriele Cosmo (geomnav-V11-01-02)
- Removed references to unused classes G4GRSSolid and G4GRSVolume
in G4Navigator.
- Removed use of forward declarations to G4VTouchable in phantom
parameterisation classes.
## 2023-06-13 Gabriele Cosmo (geomnav-V11-01-01)
- Applied clang-tidy fixes (readability, modernization, performance, ...).
source/geometry/navigation/include/G4MultiNavigator.hh
+2 -2
View File
@@ -42,7 +42,7 @@
#include "G4ThreeVector.hh"
#include "G4Navigator.hh"
#include "G4TouchableHistoryHandle.hh"
#include "G4TouchableHandle.hh"
#include "G4NavigationHistory.hh"
@@ -112,7 +112,7 @@ class G4MultiNavigator : public G4Navigator
// in any geometry from the specified point in the global coordinate
// system. The geometry must be closed.
G4TouchableHistoryHandle CreateTouchableHistoryHandle() const override;
G4TouchableHandle CreateTouchableHistoryHandle() const override;
// Returns a reference counted handle to a touchable history.
G4ThreeVector GetLocalExitNormal( G4bool* obtained ) override; // const
source/geometry/navigation/include/G4Navigator.hh
+385 -401
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// class G4Navigator
// G4Navigator
//
// Class description:
//
@@ -37,10 +37,9 @@
// - 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
#define G4NAVIGATOR_HH 1
#include "geomdefs.hh"
@@ -49,10 +48,7 @@
#include "G4RotationMatrix.hh"
#include "G4LogicalVolume.hh" // Used in inline methods
#include "G4GRSVolume.hh" // " "
#include "G4GRSSolid.hh" // " "
#include "G4TouchableHandle.hh" // " "
#include "G4TouchableHistoryHandle.hh"
#include "G4NavigationHistory.hh"
#include "G4NormalNavigation.hh"
@@ -65,481 +61,469 @@
#include <iostream>
class G4VPhysicalVolume;
#define ALTERNATIVE_VOXEL_NAV 1
class G4SafetyCalculator;
class G4Navigator
{
public: // with description
public:
friend std::ostream& operator << (std::ostream &os, const G4Navigator &n);
friend std::ostream& operator << (std::ostream &os, const G4Navigator &n);
G4Navigator();
// Constructor - initialisers and setup.
G4Navigator();
// Constructor - initialisers and setup.
G4Navigator(const G4Navigator&) = delete;
G4Navigator& operator=(const G4Navigator&) = delete;
// Copy constructor & assignment operator not allowed.
G4Navigator(const G4Navigator&) = delete;
G4Navigator& operator=(const G4Navigator&) = delete;
// Copy constructor & assignment operator not allowed.
virtual ~G4Navigator();
// Destructor. No actions.
virtual ~G4Navigator();
// Destructor. No actions.
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.
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.
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);
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.
// 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.
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 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.)
//
// Important Note: In order to call this the geometry MUST be closed.
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.
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 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,
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 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.
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 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.
inline G4VPhysicalVolume* GetWorldVolume() const;
// Return the current world (`topmost') volume.
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 void SetWorldVolume(G4VPhysicalVolume* pWorld);
// Set the world (`topmost') volume. This must be positioned at
// origin (0,0,0) and unrotated.
inline G4GRSVolume* CreateGRSVolume() const;
inline G4GRSSolid* CreateGRSSolid() const;
inline G4TouchableHistory* CreateTouchableHistory() const;
inline G4TouchableHistory* CreateTouchableHistory(const G4NavigationHistory*) const;
// `Touchable' creation methods: caller has deletion responsibility.
inline G4TouchableHistory* CreateTouchableHistory() const;
inline G4TouchableHistory* CreateTouchableHistory(const G4NavigationHistory*) const;
// `Touchable' creation methods: caller has deletion responsibility.
virtual G4TouchableHistoryHandle CreateTouchableHistoryHandle() const;
// Returns a reference counted handle to a touchable history.
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.
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 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 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 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).
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.
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.
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
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 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)
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)
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 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 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.
inline void EnableBestSafety( G4bool value = false );
// Enable best-possible evaluation of isotropic safety.
inline G4VExternalNavigation* GetExternalNavigation() const;
inline void SetExternalNavigation(G4VExternalNavigation* externalNav);
// Accessor & modifier for custom external navigation.
inline G4VExternalNavigation* GetExternalNavigation() const;
void SetExternalNavigation(G4VExternalNavigation* externalNav);
// Accessor & modifier for custom external navigation.
inline G4Navigator* Clone() const;
// Cloning feature for use in MT applications to clone
// navigator, including external sub-navigator.
// Client has responsibility for ownership of returned allocated pointer.
inline G4VoxelNavigation& GetVoxelNavigator();
void SetVoxelNavigation(G4VoxelNavigation* voxelNav);
// Alternative navigator for voxel volumes.
inline G4ThreeVector GetLastStepEndPoint() const { return fStepEndPoint;}
// Get endpoint of last step
inline G4Navigator* Clone() const;
// Cloning feature for use in MT applications to clone
// navigator, including external sub-navigator.
// Client has responsibility for ownership of returned allocated pointer.
void InformLastStep(G4double lastStep, G4bool entersDaughtVol, G4bool exitsMotherVol );
// Derived navigators which rely on LocateGlobalPointAndSetup
// need to inform size of step -- to maintain logic about
// arriving on boundary for challenging cases.
// Required in order to cope with multile trials at boundaries
// => Locate with use direction rather than simple, fast logic
inline G4ThreeVector GetLastStepEndPoint() const { return fStepEndPoint;}
// Get endpoint of last step.
protected: // with description
void InformLastStep(G4double lastStep,
G4bool entersDaughtVol,
G4bool exitsMotherVol );
// Derived navigators which rely on LocateGlobalPointAndSetup() need to
// inform size of step, to maintain logic about arriving on boundary
// for challenging cases.
// Required in order to cope with multiple trials at boundaries
// => Locate with use direction rather than simple, fast logic.
void SetSavedState();
// ( fValidExitNormal, fExitNormal, fExiting, fEntering,
// fBlockedPhysicalVolume, fBlockedReplicaNo, fLastStepWasZero);
// Extended to include:
// ( fLastLocatedPointLocal, fLocatedOutsideWorld;
// fEnteredDaughter, fExitedMother
// fPreviousSftOrigin, sPreviousSafety) Safety Sphere.
protected:
void RestoreSavedState();
// Copy aspects of the state, to enable a non-state changing
// call to ComputeStep().
void SetSavedState();
// ( fValidExitNormal, fExitNormal, fExiting, fEntering,
// fBlockedPhysicalVolume, fBlockedReplicaNo, fLastStepWasZero);
// Extended to include:
// ( fLastLocatedPointLocal, fLocatedOutsideWorld;
// fEnteredDaughter, fExitedMother
// fPreviousSftOrigin, sPreviousSafety) Safety Sphere.
void RestoreSavedState();
// Copy aspects of the state, to enable a non-state changing
// call to ComputeStep().
virtual void ResetState();
// Utility method to reset the navigator state machine.
virtual void ResetState();
// Utility method to reset the navigator state machine.
inline G4ThreeVector ComputeLocalPoint(const G4ThreeVector& rGlobPoint) const;
// Return position vector in local coordinate system, given a position
// vector in world coordinate system.
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.
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.
inline EVolume VolumeType(const G4VPhysicalVolume *pVol) const;
// Characterise `type' of volume - normal/replicated/parameterised.
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 EVolume CharacteriseDaughters(const G4LogicalVolume *pLog) const;
// Characterise daughter of logical volume.
inline G4int GetDaughtersRegularStructureId(const G4LogicalVolume *pLv) const;
// Get regular structure ID of first daughter
inline G4int GetDaughtersRegularStructureId(const G4LogicalVolume *pLv) 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.
virtual void SetupHierarchy();
// Renavigate & reset hierarchy described by current history:
// o Reset volumes and recompute transforms and/or solids of
// replicated/parameterised volumes.
G4bool CheckOverlapsIterative(G4VPhysicalVolume* vol);
// 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);
// 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.
#ifdef ALTERNATIVE_VOXEL_NAV
public:
void SetVoxelNavigation(G4VoxelNavigation *voxelNav);
// Alternative navigator for voxel volumes -- for use in integrating
// VecGeom Navigation
#endif
private:
inline G4VoxelNavigation& GetVoxelNavigator();
private:
private:
void ComputeStepLog(const G4ThreeVector& pGlobalpoint,
G4double moveLenSq) const;
// Log and checks for steps larger than the tolerance.
void ComputeStepLog(const G4ThreeVector& pGlobalpoint,
G4double moveLenSq) const;
// Log and checks for steps larger than the tolerance
protected:
protected: // without description
G4double kCarTolerance, fMinStep, fSqTol;
// Cached tolerances.
G4double kCarTolerance, fMinStep, fSqTol;
// Cached tolerances.
//
// BEGIN State information
//
//
// BEGIN State information
//
G4NavigationHistory fHistory;
// Transformation and history of the current path
// through the geometrical hierarchy.
G4NavigationHistory fHistory;
// Transformation and history of the current path
// through the geometrical hierarchy.
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.
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.
G4int fVerbose = 0;
// Verbose(ness) level [if > 0, printout can occur].
G4int fVerbose = 0;
// Verbose(ness) level [if > 0, printout can occur].
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 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 fExitedMother;
// A similar memory whether the Step exited current "mother" volume
// completely, not entering daughter.
G4bool fWasLimitedByGeometry = false;
// Set true if last Step was limited by geometry.
G4bool fWasLimitedByGeometry = false;
// Set true if last Step was limited by geometry.
private:
private:
G4ThreeVector fLastLocatedPointLocal;
// Position of the last located point relative to its containing volume.
// This is coupled with the bool member fLocatedOutsideWorld;
G4ThreeVector fLastLocatedPointLocal;
// Position of the last located point relative to its containing volume.
// This is coupled with the bool member fLocatedOutsideWorld;
G4ThreeVector fExitNormal; // Leaving volume normal, in the
// volume containing the exited
// volume's coordinate system
// This is closely coupled with G4bool fValidExitNormal - which
// signals whether we have a (valid) normal for volume we're leaving
G4ThreeVector fExitNormal;
// 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 fGrandMotherExitNormal; // Leaving volume normal, in its
// own coordinate system
G4ThreeVector fExitNormalGlobalFrame; // Leaving volume normal, in the
// global coordinate system
G4ThreeVector fGrandMotherExitNormal;
// Leaving volume normal, in its own coordinate system.
G4ThreeVector fExitNormalGlobalFrame;
// Leaving volume normal, in the global coordinate system.
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
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.
G4VPhysicalVolume* fLastMotherPhys = nullptr;
// Memory of the mother volume during previous step.
// Intended use: inform user in case of stuck track.
G4VPhysicalVolume* fLastMotherPhys = nullptr;
// Memory of the mother volume during previous step.
// Intended use: inform user in case of stuck track.
G4VPhysicalVolume* fBlockedPhysicalVolume;
G4int fBlockedReplicaNo;
// 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;
// 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).
// 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
//
G4int fNumberZeroSteps;
// Number of preceding moves that were Zero. Reset to 0 after finite step
G4int fActionThreshold_NoZeroSteps = 10;
// After this many failed/zero steps, act (push etc)
G4int fAbandonThreshold_NoZeroSteps = 25;
// After this many failed/zero steps, abandon track
G4int fNumberZeroSteps;
// 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 fActionThreshold_NoZeroSteps = 10;
// After this many failed/zero steps, act (push etc).
G4int fAbandonThreshold_NoZeroSteps = 25;
// After this many failed/zero steps, abandon track.
G4bool fActive = false;
// States if the navigator is activated or not.
G4bool fActive = false;
// States if the navigator is activated or not.
G4bool fLastTriedStepComputation = false;
// 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 fLastTriedStepComputation = 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 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
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.
G4bool fValidExitNormal; // Set true if have leaving volume normal
G4bool fLastStepWasZero;
// Whether the last ComputeStep moved Zero. Used to check for edges.
G4bool fLocatedOnEdge;
// Whether the Navigator has detected an edge
G4bool fLocatedOutsideWorld;
// Whether the last call to Locate methods left the world
G4bool fValidExitNormal;
// Set true if have leaving volume normal.
G4bool fLastStepWasZero;
// Whether the last ComputeStep moved Zero. Used to check for edges.
G4bool fLocatedOnEdge;
// Whether the Navigator has detected an edge.
G4bool fLocatedOutsideWorld;
// Whether the last call to Locate methods left the world.
G4bool fChangedGrandMotherRefFrame; // Whether frame is changed
G4bool fCalculatedExitNormal; // Has it been computed since
// the last call to ComputeStep
// Covers both Global and GrandMother
//
// END State information
//
G4bool fChangedGrandMotherRefFrame;
// Whether frame is changed.
G4bool fCalculatedExitNormal;
// Has it been computed since the last call to ComputeStep().
// Covers both Global and GrandMother.
// Optional State information (created/used as needed)
//
// 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;
// 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;
// Potentially relevant
//
G4bool sLocatedOutsideWorld;
G4ThreeVector sLastLocatedPointLocal;
G4bool sEnteredDaughter, sExitedMother;
G4ThreeVector sPreviousSftOrigin;
G4double sPreviousSafety;
} fSaveState;
private:
// BEGIN -- Tracking Invariants
// ===========================================
G4VPhysicalVolume* fTopPhysical = nullptr;
// A link to the topmost physical volume in the detector.
// Must be positioned at the origin and unrotated.
// BEGIN -- Tracking Invariants
// ===========================================
// Helpers/Utility classes
//
G4NormalNavigation fnormalNav;
#ifdef ALTERNATIVE_VOXEL_NAV
G4VoxelNavigation* fpvoxelNav;
#else
G4VoxelNavigation fvoxelNav;
#endif
G4ParameterisedNavigation fparamNav;
G4ReplicaNavigation freplicaNav;
G4RegularNavigation fregularNav;
G4VExternalNavigation* fpExternalNav = nullptr;
G4VoxelSafety* fpVoxelSafety;
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 fPushed = false, fWarnPush = true;
// Push flags [if true, means a stuck particle has been pushed].
// Helpers/Utility classes
//
G4NormalNavigation fnormalNav;
G4VoxelNavigation* fpvoxelNav;
G4ParameterisedNavigation fparamNav;
G4ReplicaNavigation freplicaNav;
G4RegularNavigation fregularNav;
G4VExternalNavigation* fpExternalNav = nullptr;
G4VoxelSafety* fpVoxelSafety;
G4SafetyCalculator* fpSafetyCalculator = nullptr;
// End -- Tracking Invariants
// Utility information
//
G4bool fCheck = false;
// Check-mode flag [if true, more strict checks are performed].
G4bool fPushed = false, fWarnPush = true;
// Push flags [if true, means a stuck particle has been pushed].
// End -- Tracking Invariants
};
#include "G4Navigator.icc"
source/geometry/navigation/include/G4Navigator.icc
+5 -48
View File
@@ -23,9 +23,9 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// class G4Navigator Inline implementation
// G4Navigator class Inline implementation
//
// ********************************************************************
// --------------------------------------------------------------------
// ********************************************************************
// GetCurrentLocalCoordinate
@@ -215,36 +215,6 @@ G4RotationMatrix G4Navigator::NetRotation() const
return fHistory.GetTopTransform().InverseNetRotation();
}
// ********************************************************************
// CreateGRSVolume
//
// `Touchable' creation method: caller has deletion responsibility
// ********************************************************************
//
inline
G4GRSVolume* G4Navigator::CreateGRSVolume() const
{
const G4AffineTransform& tf = fHistory.GetTopTransform();
return new G4GRSVolume(fHistory.GetTopVolume(),
tf.InverseNetRotation(),
tf.InverseNetTranslation());
}
// ********************************************************************
// CreateGRSSolid
//
// `Touchable' creation method: caller has deletion responsibility
// ********************************************************************
//
inline
G4GRSSolid* G4Navigator::CreateGRSSolid() const
{
const G4AffineTransform& tf = fHistory.GetTopTransform();
return new G4GRSSolid(fHistory.GetTopVolume()->GetLogicalVolume()->GetSolid(),
tf.InverseNetRotation(),
tf.InverseNetTranslation());
}
// ********************************************************************
// CreateTouchableHistory
//
@@ -478,12 +448,9 @@ G4int G4Navigator::SeverityOfZeroStepping( G4int* noZeroSteps ) const
// ********************************************************************
//
inline
G4VoxelNavigation& G4Navigator::GetVoxelNavigator() {
#ifdef ALTERNATIVE_VOXEL_NAV
return *fpvoxelNav;
#else
return fvoxelNav;
#endif
G4VoxelNavigation& G4Navigator::GetVoxelNavigator()
{
return *fpvoxelNav;
}
// ********************************************************************
@@ -505,16 +472,6 @@ G4VExternalNavigation* G4Navigator::GetExternalNavigation() const
return fpExternalNav;
}
// ********************************************************************
// SetExternalNavigation
// ********************************************************************
//
inline
void G4Navigator::SetExternalNavigation(G4VExternalNavigation* externalNav)
{
fpExternalNav = externalNav;
}
// ********************************************************************
// Clone
// ********************************************************************
source/geometry/navigation/include/G4NormalNavigation.hh
+7 -13
View File
@@ -38,6 +38,7 @@
#include <iomanip>
#include "G4VNavigation.hh"
#include "G4NavigationHistory.hh"
#include "G4VPhysicalVolume.hh"
@@ -48,7 +49,7 @@
class G4NavigationLogger;
class G4NormalNavigation
class G4NormalNavigation : public G4VNavigation
{
public: // with description
@@ -64,7 +65,7 @@ class G4NormalNavigation
const G4ThreeVector &globalPoint,
const G4ThreeVector* globalDirection,
const G4bool pLocatedOnEdge,
G4ThreeVector &localPoint);
G4ThreeVector &localPoint) final;
// Search positioned volumes in mother at current top level of history
// for volume containing globalPoint. Do not test the blocked volume.
// If a containing volume is found, `stack' the new volume and return
@@ -82,25 +83,18 @@ class G4NormalNavigation
G4bool &exiting,
G4bool &entering,
G4VPhysicalVolume *(*pBlockedPhysical),
G4int &blockedReplicaNo );
G4int &blockedReplicaNo ) final;
G4double ComputeSafety( const G4ThreeVector &globalpoint,
const G4NavigationHistory &history,
const G4double pMaxLength=DBL_MAX );
const G4double pMaxLength=DBL_MAX ) final;
G4int GetVerboseLevel() const;
void SetVerboseLevel(G4int level);
virtual G4int GetVerboseLevel() const final;
virtual void SetVerboseLevel(G4int level) final;
// Get/Set Verbose(ness) level.
// [if level>0 && G4VERBOSE, printout can occur]
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.
private:
G4bool fCheck = false;
G4NavigationLogger* fLogger;
};
source/geometry/navigation/include/G4NormalNavigation.icc
-10
View File
@@ -27,16 +27,6 @@
//
// --------------------------------------------------------------------
// ********************************************************************
// CheckMode
// ********************************************************************
//
inline
void G4NormalNavigation::CheckMode(G4bool mode)
{
fCheck = mode;
}
// ********************************************************************
// LevelLocate
// ********************************************************************
source/geometry/navigation/include/G4ParameterisedNavigation.hh
+3
View File
@@ -85,6 +85,9 @@ class G4ParameterisedNavigation : public G4VoxelNavigation
const G4NavigationHistory& history,
const G4double pProposedMaxLength=DBL_MAX ) override;
void RelocateWithinVolume( G4VPhysicalVolume* motherPhysical,
const G4ThreeVector& localPoint ) override;
private:
G4double ComputeVoxelSafety( const G4ThreeVector& localPoint,
source/geometry/navigation/include/G4PartialPhantomParameterisation.hh
+1 -1
View File
@@ -44,9 +44,9 @@
#include "G4Types.hh"
#include "G4PhantomParameterisation.hh"
#include "G4AffineTransform.hh"
#include "G4VTouchable.hh"
class G4VPhysicalVolume;
class G4VTouchable;
class G4VSolid;
class G4Material;
source/geometry/navigation/include/G4PhantomParameterisation.hh
+1 -1
View File
@@ -43,9 +43,9 @@
#include "G4Types.hh"
#include "G4VPVParameterisation.hh"
#include "G4AffineTransform.hh"
#include "G4VTouchable.hh"
class G4VPhysicalVolume;
class G4VTouchable;
class G4VSolid;
class G4Material;
source/geometry/navigation/include/G4RegularNavigation.hh
+5 -11
View File
@@ -41,13 +41,14 @@
#include "G4Types.hh"
#include "G4ThreeVector.hh"
#include "G4VNavigation.hh"
class G4NormalNavigation;
class G4VPhysicalVolume;
class G4Navigator;
class G4NavigationHistory;
class G4RegularNavigation
class G4RegularNavigation : public G4VNavigation
{
public: // with description
@@ -60,7 +61,7 @@ class G4RegularNavigation
const G4ThreeVector& globalPoint,
const G4ThreeVector* globalDirection,
const G4bool pLocatedOnEdge,
G4ThreeVector& localPoint );
G4ThreeVector& localPoint ) final;
// Locate point using its position with respect to regular
// parameterisation container volume.
@@ -74,7 +75,7 @@ class G4RegularNavigation
G4bool& exiting,
G4bool& entering,
G4VPhysicalVolume *(*pBlockedPhysical),
G4int& blockedReplicaNo );
G4int& blockedReplicaNo ) final;
// Method never called because to be called the daughter has to be a
// 'regular' volume. This would only happen if the track is in the
// mother of voxels volume. But the voxels fill completely their mother,
@@ -100,7 +101,7 @@ class G4RegularNavigation
G4double ComputeSafety( const G4ThreeVector& localPoint,
const G4NavigationHistory& history,
const G4double pProposedMaxLength = DBL_MAX );
const G4double pProposedMaxLength = DBL_MAX ) final;
// Method never called because to be called the daughter has to be a
// 'regular' volume. This would only happen if the track is in the
// mother of voxels volume. But the voxels fill completely their mother,
@@ -108,18 +109,11 @@ class G4RegularNavigation
public: // without description
// Set and Get methods
void SetVerboseLevel(G4int level) { fverbose = level; }
void CheckMode(G4bool mode) { fcheck = mode; }
void SetNormalNavigation( G4NormalNavigation* fnormnav )
{ fnormalNav = fnormnav; }
private:
G4int fverbose = 0;
G4bool fcheck = false;
G4NormalNavigation* fnormalNav = nullptr;
G4double kCarTolerance;
G4double fMinStep;
source/geometry/navigation/include/G4ReplicaNavigation.hh
+2 -2
View File
@@ -107,8 +107,8 @@ class G4ReplicaNavigation
G4double ComputeSafety( const G4ThreeVector& globalPoint,
const G4ThreeVector& localPoint,
G4NavigationHistory& history,
const G4double pProposedMaxLength = DBL_MAX );
const G4NavigationHistory& history,
const G4double pProposedMaxLength = DBL_MAX ) const;
EInside BackLocate( G4NavigationHistory &history,
const G4ThreeVector& globalPoint,
source/geometry/navigation/include/G4SafetyCalculator.hh
+204
View File
@@ -0,0 +1,204 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// G4SafetyCalculator
//
// Class description:
//
// A class that provides an estimate of the isotropic safety - the
// minimum distance from a global point to the nearest boundary
// of the current volume or the nearest daughter volumes.
// This estimate can be an underestimate, either because a solid
// provides an underestimate (for speed) or in order to avoid
// substantial additional computations.
//
// Obtains from the navigator the current transformation history.
// Author: John Apostolakis, CERN - February 2023
// --------------------------------------------------------------------
#ifndef G4SafetyCalculator_HH
#define G4SafetyCalculator_HH 1
#include "geomdefs.hh"
#include "G4ThreeVector.hh"
#include "G4AffineTransform.hh"
#include "G4RotationMatrix.hh"
#include "G4LogicalVolume.hh" // Used in inline methods
#include "G4TouchableHistoryHandle.hh"
#include "G4NavigationHistory.hh"
#include "G4NormalNavigation.hh"
#include "G4VoxelNavigation.hh"
#include "G4ParameterisedNavigation.hh"
#include "G4ReplicaNavigation.hh"
#include "G4RegularNavigation.hh"
#include "G4VExternalNavigation.hh"
#include "G4VoxelSafety.hh"
#include <iostream>
class G4VPhysicalVolume;
class G4SafetyCalculator
{
public:
G4SafetyCalculator( const G4Navigator& navigator,
const G4NavigationHistory& navHistory );
// Constructor - initialisers and setup.
G4SafetyCalculator(const G4SafetyCalculator&) = delete;
G4SafetyCalculator& operator=(const G4SafetyCalculator&) = delete;
// Copy constructor & assignment operator not allowed.
~G4SafetyCalculator() = default;
// Destructor. No actions.
G4double SafetyInCurrentVolume(const G4ThreeVector& globalpoint,
G4VPhysicalVolume* physicalVolume,
const G4double pProposedMaxLength = DBL_MAX,
G4bool verbose = false );
// Calculate the isotropic distance to the nearest boundary from the
// specified point in the global coordinate system.
// The globalpoint utilised *must* be located exactly within the
// current volume (it also must *not* be in a daughter volume).
// The value returned can be an underestimate (and typically will be
// if complex volumes are involved).
// The calculation will not look beyond the proposed maximum length
// to avoid extra volume safety calculations. The geometry must be closed.
G4VExternalNavigation* GetExternalNavigation() const;
void SetExternalNavigation(G4VExternalNavigation* externalNav);
// Accessor & modifier for custom external navigation.
void CompareSafetyValues( G4double oldSafety,
G4double newValue,
G4VPhysicalVolume* motherPhysical,
const G4ThreeVector &globalPoint,
G4bool keepState,
G4double maxLength,
G4bool enteredVolume,
G4bool exitedVolume );
// Compare estimates of the safety, and report if difference(s) found.
protected:
void QuickLocateWithinVolume(const G4ThreeVector& pointLocal,
G4VPhysicalVolume* motherPhysical);
// Prepare state of sub-navigators by informing them of current point.
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.
inline EVolume CharacteriseDaughters(const G4LogicalVolume* pLog) const;
// Characterise daughter of logical volume.
inline G4int GetDaughtersRegularStructureId(const G4LogicalVolume* pLv) const;
// Get regular structure ID of first daughter.
private:
// BEGIN -- Tracking Invariants part 1
//
const G4Navigator& fNavigator;
// Associated navigator. Needed for details of current state,
// for optimisation
const G4NavigationHistory& fNavHistory;
// Associated navigator's navigation history. Transformation and history
// of the current path through the geometrical hierarchy.
//
// END -- Tracking Invariants part 1
G4double fkCarTolerance;
// Cached tolerance.
// BEGIN State information
//
G4ThreeVector fPreviousSftOrigin;
G4double fPreviousSafety = 0.0;
// 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.
// Helpers/Utility classes - their state can change
//
G4NormalNavigation fnormalNav;
G4VoxelNavigation fvoxelNav;
G4ParameterisedNavigation fparamNav;
G4ReplicaNavigation freplicaNav;
G4RegularNavigation fregularNav;
G4VExternalNavigation* fpExternalNav = nullptr;
G4VoxelSafety fVoxelSafety;
};
// Auxiliary inline methods -- copied from G4Navigator
// Return local coordinates given point in the world coord system.
//
inline G4ThreeVector
G4SafetyCalculator::ComputeLocalPoint(const G4ThreeVector& pGlobalPoint) const
{
return fNavHistory.GetTopTransform().TransformPoint(pGlobalPoint);
}
// Returns local direction given vector direction in world coord system.
//
inline G4ThreeVector
G4SafetyCalculator::ComputeLocalAxis(const G4ThreeVector& pVec) const
{
return fNavHistory.GetTopTransform().TransformAxis(pVec);
}
inline EVolume
G4SafetyCalculator::CharacteriseDaughters(const G4LogicalVolume* pLog) const
{
return pLog->CharacteriseDaughters();
}
inline G4int
G4SafetyCalculator::GetDaughtersRegularStructureId(const G4LogicalVolume* pLog) const
{
G4int regId = 0;
G4VPhysicalVolume *pVol;
if ( pLog->GetNoDaughters() == 1 )
{
pVol = pLog->GetDaughter(0);
regId = pVol->GetRegularStructureId();
}
return regId;
}
#endif
source/geometry/navigation/include/G4VExternalNavigation.hh
+5 -57
View File
@@ -35,13 +35,14 @@
#ifndef G4VEXTERNALNAVIGATION_HH
#define G4VEXTERNALNAVIGATION_HH
#include "G4NavigationHistory.hh"
#include "G4VPhysicalVolume.hh"
#include "G4LogicalVolume.hh"
#include "G4VSolid.hh"
#include "G4NavigationHistory.hh"
#include "G4ThreeVector.hh"
#include "G4VNavigation.hh"
#include "G4VPhysicalVolume.hh"
#include "G4VSolid.hh"
class G4VExternalNavigation
class G4VExternalNavigation : public G4VNavigation
{
public: // with description
@@ -50,45 +51,6 @@ class G4VExternalNavigation
virtual ~G4VExternalNavigation();
// Destructor
virtual G4bool LevelLocate( G4NavigationHistory& history,
const G4VPhysicalVolume* blockedVol,
const G4int blockedNum,
const G4ThreeVector& globalPoint,
const G4ThreeVector* globalDirection,
const G4bool pLocatedOnEdge,
G4ThreeVector& localPoint) = 0;
// Search positioned volumes in mother at current top level of history
// for volume containing globalPoint. Do not test the blocked volume.
// If a containing volume is found, `stack' the new volume and return
// true, else return false (the point lying in the mother but not any
// of the daughters). localPoint = global point in local system on entry,
// point in new system on exit.
virtual G4double ComputeStep( const G4ThreeVector& localPoint,
const G4ThreeVector& localDirection,
const G4double currentProposedStepLength,
G4double& newSafety,
G4NavigationHistory& history,
G4bool& validExitNormal,
G4ThreeVector& exitNormal,
G4bool& exiting,
G4bool& entering,
G4VPhysicalVolume** pBlockedPhysical,
G4int& blockedReplicaNo ) = 0;
// Compute the length of a step to the next boundary.
// Ignore the (input) pBlockedPhysical volume (with replica/parameterisation
// number 'blockedReplica')
// Identify the next candidate volume (if a daughter of current volume),
// and return it in pBlockedPhysical, blockedReplicaNo
// In/Out Navigation history: to be update for volume of next intersection.
// In/out 'newsafety' is the known isotropic safety of the initial point:
// an earlier (likely crude) estimate on input,
// to be updated with new estimate for the same (start) point.
virtual G4double ComputeSafety( const G4ThreeVector& globalpoint,
const G4NavigationHistory& history,
const G4double pMaxLength = DBL_MAX ) = 0;
virtual G4VExternalNavigation* Clone() = 0;
@@ -105,20 +67,6 @@ class G4VExternalNavigation
// Update any relevant internal state to take account that
// - the location has been moved to 'localPoint'
// - it remains in the current (mother) physical volume 'motherPhysical'
inline G4int GetVerboseLevel() const { return fVerbose; }
inline void SetVerboseLevel(G4int level) { fVerbose = level; }
// Get/Set verbosity level.
inline void CheckMode(G4bool mode) { fCheck = mode; }
// Run navigation in "check-mode", therefore using additional
// verifications and more strict correctness conditions.
// Should be effective only with G4VERBOSE set.
protected:
G4bool fCheck = false;
G4int fVerbose = 0;
};
#endif
source/geometry/navigation/include/G4VNavigation.hh
+151
View File
@@ -0,0 +1,151 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// class G4VNavigation
//
// Class description:
//
// Navigation interface common between all navigator types.
// Author: G. Amadio - CERN, March 2022
// --------------------------------------------------------------------
#ifndef G4VNAVIGATION_HH
#define G4VNAVIGATION_HH
#include "G4ThreeVector.hh"
class G4LogicalVolume;
class G4VPhysicalVolume;
class G4NavigationHistory;
/**
* @brief G4VNavigation class holds the common navigation interface
* for all geometry navigator types.
*/
class G4VNavigation
{
public:
/** Virtual Destructor. */
virtual ~G4VNavigation() {}
/**
* Search positioned volumes in mother at current top level of @p history
* for volume containing @p globalPoint. Do not test against @p blockedVol.
* If a containing volume is found, push it onto navigation history state.
* @param[in,out] history Navigation history.
* @param[in,out] blockedVol Blocked volume that should be ignored in queries.
* @param[in,out] blockedNum Copy number for blocked replica volumes.
* @param[in,out] globalPoint Global point
* @param[in,out] globalDirection Pointer to global direction or null pointer.
* @param[in,out] localPoint = global point in local system on entry, point
* in new system on exit.
* @returns Whether a containing volume has been found.
*/
virtual G4bool LevelLocate(G4NavigationHistory& history,
const G4VPhysicalVolume* blockedVol,
const G4int blockedNum,
const G4ThreeVector& globalPoint,
const G4ThreeVector* globalDirection,
const G4bool pLocatedOnEdge,
G4ThreeVector& localPoint) = 0;
/**
* Compute the length of a step to the next boundary.
* Do not test against @p pBlockedPhysical. Identify the next candidate volume
* (if a daughter of current volume), and return it in pBlockedPhysical,
* blockedReplicaNo.
* @param[in] localPoint Local point
* @param[in] localDirection Pointer to local direction or null pointer.
* @param[in] currentProposedStepLength Current proposed step length.
* @param[in,out] newSafety New safety.
* @param[in,out] history Navigation history.
* @param[in,out] validExitNormal Flag to indicate whether exit normal is
* valid or not.
* @param[in,out] exitNormal Exit normal.
* @param[in,out] entering Flag to indicate whether we are entering a volume.
* @param[in,out] exiting Flag to indicate whether we are exiting a volume.
* @param[in,out] pBlockedPhysical Blocked physical volume that should be
* ignored in queries.
* @param[in,out] blockedReplicaNo Copy number for blocked replica volumes.
* @returns Length from current point to next boundary surface along @p
* localDirection.
*/
virtual G4double ComputeStep(const G4ThreeVector& localPoint,
const G4ThreeVector& localDirection,
const G4double currentProposedStepLength,
G4double& newSafety,
G4NavigationHistory& history,
G4bool& validExitNormal,
G4ThreeVector& exitNormal,
G4bool& exiting,
G4bool& entering,
G4VPhysicalVolume*(*pBlockedPhysical),
G4int& blockedReplicaNo) = 0;
/**
* Compute the distance to the closest surface.
* @param[in] globalPoint Global point.
* @param[in] history Navigation history.
* @param[in] pMaxLength Maximum step length beyond which volumes need not be
* checked.
* @returns Length from current point to closest surface.
*/
virtual G4double ComputeSafety(const G4ThreeVector& globalpoint,
const G4NavigationHistory& history,
const G4double pMaxLength = DBL_MAX) = 0;
/**
* Update internal navigation state to take into account that location
* has been moved, but remains within the @p motherPhysical volume.
* @param[in] motherPhysical Current physical volume.
* @param[in] localPoint Local point.
*/
virtual void RelocateWithinVolume(G4VPhysicalVolume* /* motherPhysical */,
const G4ThreeVector& /* localPoint */)
{
/* do nothing by default */
}
/** Get current verbosity level */
virtual G4int GetVerboseLevel() const { return fVerbose; }
/** Set current verbosity level */
virtual void SetVerboseLevel(G4int level) { fVerbose = level; }
/**
* Set check mode.
* When enabled, forces navigator to run in "check mode", hence using
* additional verifications and stricter condictions for ensuring correctness.
* Effective only when G4VERBOSE is enabled.
*/
void CheckMode(G4bool mode) { fCheck = mode; }
protected:
G4int fVerbose = 0;
G4bool fCheck = false;
};
#endif
source/geometry/navigation/include/G4VoxelNavigation.hh
+10 -12
View File
@@ -37,6 +37,7 @@
#define G4VOXELNAVIGATION_HH
#include "geomdefs.hh"
#include "G4VNavigation.hh"
#include "G4NavigationHistory.hh"
#include "G4NavigationLogger.hh"
#include "G4AffineTransform.hh"
@@ -60,7 +61,7 @@ class G4VoxelSafety;
#include "G4SmartVoxelNode.hh"
#include "G4SmartVoxelHeader.hh"
class G4VoxelNavigation
class G4VoxelNavigation : public G4VNavigation
{
public: // with description
@@ -76,7 +77,7 @@ class G4VoxelNavigation
const G4ThreeVector& globalPoint,
const G4ThreeVector* globalDirection,
const G4bool pLocatedOnEdge,
G4ThreeVector& localPoint );
G4ThreeVector& localPoint ) override;
virtual G4double ComputeStep( const G4ThreeVector& globalPoint,
const G4ThreeVector& globalDirection,
@@ -88,22 +89,20 @@ class G4VoxelNavigation
G4bool& exiting,
G4bool& entering,
G4VPhysicalVolume* (*pBlockedPhysical),
G4int& blockedReplicaNo );
G4int& blockedReplicaNo ) override;
virtual G4double ComputeSafety( const G4ThreeVector& globalpoint,
const G4NavigationHistory& history,
const G4double pMaxLength = DBL_MAX );
const G4double pMaxLength = DBL_MAX ) override;
inline G4int GetVerboseLevel() const;
void SetVerboseLevel(G4int level);
virtual void RelocateWithinVolume( G4VPhysicalVolume* motherPhysical,
const G4ThreeVector& localPoint ) override;
virtual G4int GetVerboseLevel() const override;
virtual void SetVerboseLevel(G4int level) override;
// Get/Set Verbose(ness) level.
// [if level>0 && G4VERBOSE, printout can occur]
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 void EnableBestSafety( G4bool flag = false );
// Enable best-possible evaluation of isotropic safety
@@ -182,7 +181,6 @@ class G4VoxelNavigation
G4double fHalfTolerance;
// Surface tolerance
G4bool fCheck = false;
G4bool fBestSafety = false;
G4NavigationLogger* fLogger;
source/geometry/navigation/include/G4VoxelNavigation.icc
-10
View File
@@ -163,16 +163,6 @@ G4int G4VoxelNavigation::GetVerboseLevel() const
return fLogger->GetVerboseLevel();
}
// ********************************************************************
// CheckMode
// ********************************************************************
//
inline
void G4VoxelNavigation::CheckMode(G4bool mode)
{
fCheck = mode;
}
// ********************************************************************
// EnableBestSafety
// ********************************************************************
source/geometry/navigation/sources.cmake
+5 -2
View File
@@ -32,6 +32,7 @@ geant4_add_module(G4navigation
G4RegularNavigationHelper.hh
G4ReplicaNavigation.hh
G4ReplicaNavigation.icc
G4SafetyCalculator.hh
G4SafetyHelper.hh
G4SimpleLocator.hh
G4TransportationManager.hh
@@ -39,6 +40,7 @@ geant4_add_module(G4navigation
G4VExternalNavigation.hh
G4VIntersectionLocator.hh
G4VIntersectionLocator.icc
G4VNavigation.hh
G4VoxelNavigation.hh
G4VoxelNavigation.icc
G4VoxelSafety.hh
@@ -65,6 +67,7 @@ geant4_add_module(G4navigation
G4RegularNavigation.cc
G4RegularNavigationHelper.cc
G4ReplicaNavigation.cc
G4SafetyCalculator.cc
G4SafetyHelper.cc
G4SimpleLocator.cc
G4TransportationManager.cc
@@ -74,5 +77,5 @@ geant4_add_module(G4navigation
G4VoxelSafety.cc)
geant4_module_link_libraries(G4navigation
PUBLIC G4geometrymng G4magneticfield G4volumes G4graphics_reps G4globman G4intercoms G4hepgeometry
PRIVATE G4materials)
PUBLIC G4geometrymng G4magneticfield G4graphics_reps G4globman G4intercoms G4hepgeometry
PRIVATE G4volumes G4materials)
source/geometry/navigation/src/G4DrawVoxels.cc
+2 -2
View File
@@ -38,7 +38,7 @@
#include "G4VVisManager.hh"
#include "G4Colour.hh"
#include "G4TransportationManager.hh"
#include "G4TouchableHistoryHandle.hh"
#include "G4TouchableHandle.hh"
#define voxel_width 0
@@ -203,7 +203,7 @@ void G4DrawVoxels::DrawVoxels(const G4LogicalVolume* lv) const
// (the drawing is directly in the world volume while the axis
// are relative to the mother volume of lv's daughter.)
G4TouchableHistoryHandle aTouchable =
G4TouchableHandle aTouchable =
G4TransportationManager::GetTransportationManager()->
GetNavigatorForTracking()->CreateTouchableHistoryHandle();
G4AffineTransform globTransform =
source/geometry/navigation/src/G4GeometryMessenger.cc
+5 -2
View File
@@ -179,8 +179,8 @@ G4GeometryMessenger::G4GeometryMessenger(G4TransportationManager* tman)
G4GeometryMessenger::~G4GeometryMessenger()
{
delete verCmd; delete recCmd; delete rslCmd;
delete resCmd; delete rcsCmd; delete rcdCmd; delete errCmd;
delete tolCmd;
delete resCmd; delete rcsCmd; delete rcdCmd;
delete errCmd; delete parCmd; delete tolCmd;
delete verbCmd; delete pchkCmd; delete chkCmd;
delete geodir; delete navdir; delete testdir;
for(auto* tvolume: tvolumes) {
@@ -258,6 +258,9 @@ G4GeometryMessenger::SetNewValue( G4UIcommand* command, G4String newValues )
else if (command == rcdCmd) {
recDepth = rcdCmd->GetNewIntValue( newValues );
}
else if (command == parCmd) {
checkParallelWorlds = parCmd->GetNewBoolValue( newValues );
}
else if (command == errCmd) {
Init();
for(auto* tvolume: tvolumes)
source/geometry/navigation/src/G4MultiNavigator.cc
+1 -2
View File
@@ -442,8 +442,7 @@ G4double G4MultiNavigator::ComputeSafety( const G4ThreeVector& position,
// -----------------------------------------------------------------------
G4TouchableHistoryHandle
G4MultiNavigator::CreateTouchableHistoryHandle() const
G4TouchableHandle G4MultiNavigator::CreateTouchableHistoryHandle() const
{
G4Exception( "G4MultiNavigator::CreateTouchableHistoryHandle()",
"GeomNav0001", FatalException,
source/geometry/navigation/src/G4Navigator.cc
+34 -148
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// class G4Navigator Implementation
// G4Navigator class Implementation
//
// Original author: Paul Kent, July 95/96
// Responsible 1996-present: John Apostolakis, Gabriele Cosmo
@@ -39,6 +39,7 @@
#include "G4VPhysicalVolume.hh"
#include "G4VoxelSafety.hh"
#include "G4SafetyCalculator.hh"
// Constant determining how precise normals should be (how close to unit
// vectors). If exceeded, warnings will be issued.
@@ -76,9 +77,9 @@ G4Navigator::G4Navigator()
fLastStepEndPointLocal = G4ThreeVector( kInfinity, kInfinity, kInfinity );
fpVoxelSafety = new G4VoxelSafety();
#ifdef ALTERNATIVE_VOXEL_NAV
fpvoxelNav = new G4VoxelNavigation();
#endif
fpSafetyCalculator = new G4SafetyCalculator( *this, fHistory );
fpSafetyCalculator->SetExternalNavigation(fpExternalNav);
}
// ********************************************************************
@@ -89,9 +90,8 @@ G4Navigator::~G4Navigator()
{
delete fpVoxelSafety;
delete fpExternalNav;
#ifdef ALTERNATIVE_VOXEL_NAV
delete fpvoxelNav;
#endif
delete fpSafetyCalculator;
}
// ********************************************************************
@@ -619,23 +619,14 @@ G4Navigator::LocateGlobalPointWithinVolume(const G4ThreeVector& pGlobalpoint)
//
G4VPhysicalVolume* motherPhysical = fHistory.GetTopVolume();
G4LogicalVolume* motherLogical = motherPhysical->GetLogicalVolume();
G4SmartVoxelHeader* pVoxelHeader = motherLogical->GetVoxelHeader();
switch( CharacteriseDaughters(motherLogical) )
{
case kNormal:
if ( pVoxelHeader != nullptr )
{
GetVoxelNavigator().VoxelLocate( pVoxelHeader, fLastLocatedPointLocal );
}
GetVoxelNavigator().RelocateWithinVolume( motherPhysical, fLastLocatedPointLocal );
break;
case kParameterised:
if( GetDaughtersRegularStructureId(motherLogical) != 1 )
{
// Resets state & returns voxel node
//
fparamNav.ParamVoxelLocate( pVoxelHeader, fLastLocatedPointLocal );
}
fparamNav.RelocateWithinVolume( motherPhysical, fLastLocatedPointLocal );
break;
case kReplica:
// Nothing to do
@@ -1605,7 +1596,6 @@ G4Navigator::GetLocalExitNormalAndCheck(
return GetLocalExitNormal( pValid );
}
// ********************************************************************
// GetGlobalExitNormal
//
@@ -1787,151 +1777,38 @@ G4Navigator::GetGlobalExitNormal(const G4ThreeVector& IntersectPointGlobal,
//
G4double G4Navigator::ComputeSafety( const G4ThreeVector& pGlobalpoint,
const G4double pMaxLength,
const G4bool keepState)
const G4bool )
{
#ifdef G4DEBUG_NAVIGATION
G4int oldcoutPrec = G4cout.precision(8);
if( fVerbose > 0 )
{
G4cout << "*** G4Navigator::ComputeSafety: ***" << G4endl
<< " Called at point: " << pGlobalpoint << G4endl;
G4VPhysicalVolume *motherPhysical = fHistory.GetTopVolume();
G4cout << " Volume = " << motherPhysical->GetName()
<< " - Maximum length = " << pMaxLength << G4endl;
if( fVerbose >= 4 )
{
G4cout << " ----- Upon entering Compute Safety:" << G4endl;
PrintState();
}
}
#endif
G4VPhysicalVolume *motherPhysical = fHistory.GetTopVolume();
G4double safety = 0.0;
G4double distEndpointSq = (pGlobalpoint-fStepEndPoint).mag2();
G4bool stayedOnEndpoint = distEndpointSq < sqr(kCarTolerance);
G4bool endpointOnSurface = fEnteredDaughter || fExitedMother;
if( endpointOnSurface && stayedOnEndpoint )
G4bool onSurface = endpointOnSurface && stayedOnEndpoint;
if( ! onSurface )
{
#ifdef G4DEBUG_NAVIGATION
if( fVerbose >= 2 )
{
G4cout << " G4Navigator::ComputeSafety() finds that point - "
<< pGlobalpoint << " - is on surface " << G4endl;
if( fEnteredDaughter ) { G4cout << " entered new daughter volume"; }
if( fExitedMother ) { G4cout << " and exited previous volume."; }
G4cout << G4endl;
G4cout << " EndPoint was = " << fStepEndPoint << G4endl;
G4cout << " ---- Exiting ComputeSafety " << G4endl;
PrintState();
G4cout << " Returned value of Safety is zero " << G4endl;
G4cout.precision(oldcoutPrec);
}
#endif
return 0.0;
}
safety= fpSafetyCalculator->SafetyInCurrentVolume(pGlobalpoint, motherPhysical, pMaxLength);
// offload to G4SafetyCalculator - avoids need to save / reload state
G4double newSafety = 0.0;
if (keepState) { SetSavedState(); }
// Pseudo-relocate to this point (updates voxel information only)
//
LocateGlobalPointWithinVolume( pGlobalpoint );
// --->> DANGER: Side effects on sub-navigator voxel information <<---
// Could be replaced again by 'granular' calls to sub-navigator
// locates (similar side-effects, but faster.
// Solutions:
// 1) Re-locate (to where?)
// 2) Insure that the methods using (G4ComputeStep?)
// does a relocation (if information is disturbed only ?)
#ifdef G4DEBUG_NAVIGATION
if( fVerbose >= 2 )
{
G4cout << " G4Navigator::ComputeSafety() relocates-in-volume to point: "
<< pGlobalpoint << G4endl;
}
#endif
G4VPhysicalVolume* motherPhysical = fHistory.GetTopVolume();
G4LogicalVolume* motherLogical = motherPhysical->GetLogicalVolume();
G4SmartVoxelHeader* pVoxelHeader = motherLogical->GetVoxelHeader();
G4ThreeVector localPoint = ComputeLocalPoint(pGlobalpoint);
if ( fHistory.GetTopVolumeType() != kReplica )
{
switch(CharacteriseDaughters(motherLogical))
{
case kNormal:
if ( pVoxelHeader != nullptr )
{
newSafety = fpVoxelSafety->ComputeSafety(localPoint,
*motherPhysical, pMaxLength);
// = VoxelNav().ComputeSafety(localPoint,fHistory,pMaxLength); // - Old method
}
else
{
newSafety=fnormalNav.ComputeSafety(localPoint,fHistory,pMaxLength);
}
break;
case kParameterised:
if( GetDaughtersRegularStructureId(motherLogical) != 1 )
{
newSafety=fparamNav.ComputeSafety(localPoint,fHistory,pMaxLength);
}
else // Regular structure
{
newSafety=fregularNav.ComputeSafety(localPoint,fHistory,pMaxLength);
}
break;
case kReplica:
G4Exception("G4Navigator::ComputeSafety()", "GeomNav0001",
FatalException, "Not applicable for replicated volumes.");
break;
case kExternal:
newSafety = fpExternalNav->ComputeSafety(localPoint, fHistory,
pMaxLength);
break;
}
}
else
{
newSafety = freplicaNav.ComputeSafety(pGlobalpoint, localPoint,
fHistory, pMaxLength);
}
if (keepState)
{
RestoreSavedState();
// This now overwrites the values of the Safety 'sphere' (correction)
}
// Remember last safety origin & value
//
// We overwrite the Safety 'sphere' - keeping old behaviour
fPreviousSftOrigin = pGlobalpoint;
fPreviousSafety = newSafety;
#ifdef G4DEBUG_NAVIGATION
if( fVerbose > 1 )
{
G4cout << " ---- Exiting ComputeSafety " << G4endl;
if( fVerbose > 2 ) { PrintState(); }
G4cout << " Returned value of Safety = " << newSafety << G4endl;
fPreviousSafety = safety;
// We overwrite the Safety 'sphere' - keeping old behaviour
}
G4cout.precision(oldcoutPrec);
#endif
return newSafety;
return safety;
}
// ********************************************************************
// CreateTouchableHistoryHandle
// ********************************************************************
//
G4TouchableHistoryHandle G4Navigator::CreateTouchableHistoryHandle() const
G4TouchableHandle G4Navigator::CreateTouchableHistoryHandle() const
{
return { CreateTouchableHistory() };
return G4TouchableHandle( CreateTouchableHistory() );
}
// ********************************************************************
@@ -2202,9 +2079,8 @@ std::ostream& operator << (std::ostream &os,const G4Navigator &n)
return os;
}
#ifdef ALTERNATIVE_VOXEL_NAV
// ********************************************************************
// SetVoxelNavigation -- alternative navigator for Voxel geom
// SetVoxelNavigation: alternative navigator for voxelised geometry
// ********************************************************************
//
void G4Navigator::SetVoxelNavigation(G4VoxelNavigation* voxelNav)
@@ -2212,13 +2088,13 @@ void G4Navigator::SetVoxelNavigation(G4VoxelNavigation* voxelNav)
delete fpvoxelNav;
fpvoxelNav = voxelNav;
}
#endif
// ********************************************************************
// InformLastStep: Derived navigators can inform of its step
// - used to update fLastStepWasZero
// InformLastStep: derived navigators can inform of its step
// used to update fLastStepWasZero
// ********************************************************************
void G4Navigator::InformLastStep(G4double lastStep, G4bool entersDaughtVol, G4bool exitsMotherVol )
void G4Navigator::InformLastStep(G4double lastStep, G4bool entersDaughtVol,
G4bool exitsMotherVol)
{
G4bool zeroStep = ( lastStep == 0.0 );
fLocatedOnEdge = fLastStepWasZero && zeroStep;
@@ -2227,3 +2103,13 @@ void G4Navigator::InformLastStep(G4double lastStep, G4bool entersDaughtVol, G4b
fExiting = exitsMotherVol;
fEntering = entersDaughtVol;
}
// ********************************************************************
// SetExternalNavigation
// ********************************************************************
//
void G4Navigator::SetExternalNavigation(G4VExternalNavigation* externalNav)
{
fpExternalNav = externalNav;
fpSafetyCalculator->SetExternalNavigation(externalNav);
}
source/geometry/navigation/src/G4ParameterisedNavigation.cc
+15
View File
@@ -49,6 +49,8 @@
#include "G4AuxiliaryNavServices.hh"
#include <cassert>
// ********************************************************************
// Constructor
// ********************************************************************
@@ -683,3 +685,16 @@ G4ParameterisedNavigation::LevelLocate( G4NavigationHistory& history,
}
return false;
}
void G4ParameterisedNavigation::RelocateWithinVolume( G4VPhysicalVolume* motherPhysical,
const G4ThreeVector& localPoint )
{
auto motherLogical = motherPhysical->GetLogicalVolume();
/* this should only be called on parameterized volumes, which always satisfy the conditions below */
assert(motherPhysical->GetRegularStructureId() != 1);
assert(motherLogical->GetNoDaughters() == 1);
if ( auto pVoxelHeader = motherLogical->GetVoxelHeader() )
ParamVoxelLocate( pVoxelHeader, localPoint );
}
source/geometry/navigation/src/G4ReplicaNavigation.cc
+2 -2
View File
@@ -1154,8 +1154,8 @@ G4ReplicaNavigation::ComputeStep(const G4ThreeVector& globalPoint,
G4double
G4ReplicaNavigation::ComputeSafety(const G4ThreeVector& globalPoint,
const G4ThreeVector& localPoint,
G4NavigationHistory& history,
const G4double )
const G4NavigationHistory& history,
const G4double ) const
{
G4VPhysicalVolume *repPhysical, *motherPhysical;
G4VPhysicalVolume *samplePhysical, *blockedExitedVol = nullptr;
source/geometry/navigation/src/G4SafetyCalculator.cc
+284
View File
@@ -0,0 +1,284 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// G4SafetyCalculator class Implementation
//
// Author: John Apostolakis, CERN - February 2023
// --------------------------------------------------------------------
#include "G4SafetyCalculator.hh"
#include "G4Navigator.hh"
#include "G4GeometryTolerance.hh"
G4SafetyCalculator::
G4SafetyCalculator( const G4Navigator& navigator,
const G4NavigationHistory& navHistory )
: fNavigator(navigator), fNavHistory(navHistory)
{
fkCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
}
// ********************************************************************
// ComputeSafety
//
// It assumes that it will be
// i) called at the Point in the same volume as the EndPoint of the
// ComputeStep.
// ii) after (or at the end of) ComputeStep OR after the relocation.
// ********************************************************************
//
G4double G4SafetyCalculator::
SafetyInCurrentVolume( const G4ThreeVector& pGlobalpoint,
G4VPhysicalVolume* physicalVolume,
const G4double pMaxLength,
G4bool /* verbose */ )
{
G4double safety = 0.0;
G4ThreeVector stepEndPoint = fNavigator.GetLastStepEndPoint();
G4ThreeVector localPoint = ComputeLocalPoint(pGlobalpoint);
G4double distEndpointSq = (pGlobalpoint-stepEndPoint).mag2();
G4bool stayedOnEndpoint = distEndpointSq < sqr(fkCarTolerance);
G4bool endpointOnSurface = fNavigator.EnteredDaughterVolume()
|| fNavigator.ExitedMotherVolume();
G4VPhysicalVolume* motherPhysical = fNavHistory.GetTopVolume();
if( motherPhysical != physicalVolume )
{
std::ostringstream msg;
msg << " Current (navigation) phys-volume: " << motherPhysical
<< " name= " << motherPhysical->GetName() << G4endl
<< " Request made for phys-volume: " << physicalVolume
<< " name= " << physicalVolume->GetName() << G4endl;
G4Exception("G4SafetyCalculator::SafetyInCurrentVolume", "GeomNav0001",
FatalException, msg,
"This method must be called only in the Current volume.");
}
if( !(endpointOnSurface && stayedOnEndpoint) )
{
G4LogicalVolume* motherLogical = motherPhysical->GetLogicalVolume();
G4SmartVoxelHeader* pVoxelHeader = motherLogical->GetVoxelHeader();
// Pseudo-relocate to this point (updates voxel information only)
//
QuickLocateWithinVolume( localPoint, motherPhysical );
//*********************
// switch(CharacteriseDaughters(motherLogical))
auto dtype= CharacteriseDaughters(motherLogical);
switch(dtype)
{
case kNormal:
if ( pVoxelHeader )
{
// New way: best safety
safety = fVoxelSafety.ComputeSafety(localPoint,
*motherPhysical, pMaxLength);
}
else
{
safety=fnormalNav.ComputeSafety(localPoint,fNavHistory,pMaxLength);
}
break;
case kParameterised:
if( GetDaughtersRegularStructureId(motherLogical) != 1 )
{
safety=fparamNav.ComputeSafety(localPoint,fNavHistory,pMaxLength);
}
else // Regular structure
{
safety=fregularNav.ComputeSafety(localPoint,fNavHistory,pMaxLength);
}
break;
case kReplica:
safety = freplicaNav.ComputeSafety(pGlobalpoint, localPoint,
fNavHistory, pMaxLength);
break;
case kExternal:
safety = fpExternalNav->ComputeSafety(localPoint, fNavHistory,
pMaxLength);
break;
}
// Remember last safety origin & value
//
fPreviousSftOrigin = pGlobalpoint;
fPreviousSafety = safety;
}
return safety;
}
// ********************************************************************
// QuickLocateWithinVolume
//
// -> the state information of this Navigator and its subNavigators
// is updated in order to start the next step at pGlobalpoint
// -> no check is performed whether pGlobalpoint is inside the
// original volume (this must be the case).
//
// Note: a direction could be added to the arguments, to aid in future
// optional checking (via the old code below, flagged by OLD_LOCATE).
// [ This would be done only in verbose mode ]
//
// Adapted simplied from G4Navigator::LocateGlobalPointWithinVolume()
// ********************************************************************
//
void G4SafetyCalculator::
QuickLocateWithinVolume( const G4ThreeVector& pointLocal,
G4VPhysicalVolume* motherPhysical )
{
// For the case of Voxel (or Parameterised) volume the respective
// sub-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
//
G4LogicalVolume* motherLogical = motherPhysical->GetLogicalVolume();
G4SmartVoxelHeader* pVoxelHeader = motherLogical->GetVoxelHeader();
switch( CharacteriseDaughters(motherLogical) )
{
case kNormal:
if ( pVoxelHeader )
{
fvoxelNav.VoxelLocate( pVoxelHeader, pointLocal );
}
break;
case kParameterised:
if( GetDaughtersRegularStructureId(motherLogical) != 1 )
{
// Resets state & returns voxel node
//
fparamNav.ParamVoxelLocate( pVoxelHeader, pointLocal );
}
break;
case kReplica:
// Nothing to do
break;
case kExternal:
fpExternalNav->RelocateWithinVolume( motherPhysical,
pointLocal );
break;
}
}
// ********************************************************************
// Accessor for custom external navigation.
// ********************************************************************
G4VExternalNavigation* G4SafetyCalculator::GetExternalNavigation() const
{
return fpExternalNav;
}
// ********************************************************************
// Modifier for custom external navigation.
// ********************************************************************
void G4SafetyCalculator::SetExternalNavigation(G4VExternalNavigation* eNav)
{
fpExternalNav = eNav;
}
// ********************************************************************
// CompareSafetyValues
// ********************************************************************
void G4SafetyCalculator::
CompareSafetyValues( G4double oldSafety,
G4double newValue,
G4VPhysicalVolume* motherPhysical,
const G4ThreeVector& globalPoint,
G4bool keepState,
G4double maxLength,
G4bool enteredDaughterVol,
G4bool exitedMotherVol )
{
constexpr G4double reportThreshold= 3.0e-14;
// At least warn if rel-error exceeds it
constexpr G4double errorThreshold= 1.0e-08;
// Fatal if relative error is larger
constexpr G4double epsilonLen= 1.0e-20;
// Baseline minimal value for divisor
const G4double oldSafetyPlus = std::fabs(oldSafety)+epsilonLen;
if( std::fabs( newValue - oldSafety) > reportThreshold * oldSafetyPlus )
{
G4ExceptionSeverity severity= FatalException;
std::ostringstream msg;
G4double diff= (newValue-oldSafety);
G4double relativeDiff= diff / oldSafetyPlus;
msg << " New (G4SafetyCalculator) value *disagrees* by relative diff " << relativeDiff
<< " in physical volume '" << motherPhysical->GetName() << "' "
<< "copy-no = " << motherPhysical->GetCopyNo();
if( enteredDaughterVol ) { msg << " ( Just Entered new daughter volume. ) "; }
if( exitedMotherVol ) { msg << " ( Just Exited previous volume. ) "; }
msg << G4endl;
msg << " Safeties: old= " << std::setprecision(12) << oldSafety
<< " trial " << newValue
<< " new-old= " << std::setprecision(7) << diff << G4endl;
if( std::fabs(diff) < errorThreshold * ( std::fabs(oldSafety)+1.0e-20 ) )
{
msg << " (tiny difference) ";
severity= JustWarning;
}
else
{
msg << " (real difference) ";
severity= FatalException;
// Extra information -- for big errors
msg << " NOTE: keepState = " << keepState << G4endl;
msg << " Location - Global coordinates: " << globalPoint
<< " volume= '" << motherPhysical->GetName() << "'"
<< " copy-no= " << motherPhysical->GetCopyNo() << G4endl;
msg << " Argument maxLength= " << maxLength << G4endl;
std::size_t depth= fNavHistory.GetDepth();
msg << " Navigation History: depth = " << depth << G4endl;
for( G4int i=1; i<(G4int)depth; ++i )
{
msg << " d= " << i << " " << std::setw(32)
<< fNavHistory.GetVolume(i)->GetName()
<< " copyNo= " << fNavHistory.GetReplicaNo(i);
msg << G4endl;
}
}
#ifdef G4DEBUG_NAVIGATION
G4double redo= SafetyInCurrentVolume(globalPoint, motherPhysical,
maxLength, true);
msg << " Redoing estimator: value = " << std::setprecision(16) << redo
<< " diff/last= " << std::setprecision(7) << redo - newValue
<< " diff/old= " << redo - oldSafety << G4endl;
#endif
G4Exception("G4SafetyCalculator::CompareSafetyValues()", "GeomNav1007",
severity, msg);
}
}
source/geometry/navigation/src/G4VIntersectionLocator.cc
+2 -1
View File
@@ -36,6 +36,7 @@
#include "G4AutoDelete.hh"
#include "G4SystemOfUnits.hh"
#include "G4VIntersectionLocator.hh"
#include "G4TouchableHandle.hh"
#include "G4GeometryTolerance.hh"
///////////////////////////////////////////////////////////////////////////
@@ -686,7 +687,7 @@ LocateGlobalPointWithinVolumeAndCheck( const G4ThreeVector& position )
// Identify the current volume
G4TouchableHistoryHandle startTH= nav->CreateTouchableHistoryHandle();
G4TouchableHandle startTH= nav->CreateTouchableHistoryHandle();
G4VPhysicalVolume* motherPhys = startTH->GetVolume();
G4VSolid* motherSolid = startTH->GetSolid();
G4AffineTransform transform = nav->GetGlobalToLocalTransform();
source/geometry/navigation/src/G4VoxelNavigation.cc
+14 -2
View File
@@ -28,14 +28,15 @@
// Author: P.Kent, 1996
//
// --------------------------------------------------------------------
#include <ostream>
#include "G4VoxelNavigation.hh"
#include "G4GeometryTolerance.hh"
#include "G4VoxelSafety.hh"
#include "G4AuxiliaryNavServices.hh"
#include <cassert>
#include <ostream>
// ********************************************************************
// Constructor
// ********************************************************************
@@ -761,6 +762,17 @@ G4VoxelNavigation::ComputeSafety(const G4ThreeVector& localPoint,
return ourSafety;
}
void G4VoxelNavigation::RelocateWithinVolume( G4VPhysicalVolume* motherPhysical,
const G4ThreeVector& localPoint )
{
auto motherLogical = motherPhysical->GetLogicalVolume();
assert(motherLogical != nullptr);
if ( auto pVoxelHeader = motherLogical->GetVoxelHeader() )
VoxelLocate( pVoxelHeader, localPoint );
}
// ********************************************************************
// SetVerboseLevel
// ********************************************************************