lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
minicalosim-spawning
geant4/source/processes/electromagnetic/dna/management/include/G4ITNavigator2.hh
T
Gabriele Cosmo 860a2b92bf Import Geant4 11.2.0 source tree
2023-12-08 10:43:34 +01:00

647 lines
26 KiB
C++
Raw Permalink Blame History

//
// ********************************************************************
// * 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.
Reference in New Issue View Git Blame Copy Permalink