Geant4  10.02
G4Navigator.hh
Go to the documentation of this file.
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 //
27 // $Id: G4Navigator.hh 81577 2014-06-03 10:13:36Z gcosmo $
28 //
29 //
30 // class G4Navigator
31 //
32 // Class description:
33 //
34 // A class for use by the tracking management, able to obtain/calculate
35 // dynamic tracking time information such as the distance to the next volume,
36 // or to find the physical volume containing a given point in the world
37 // reference system. The navigator maintains a transformation history and
38 // other information to optimise the tracking time performance.
39 
40 // History:
41 // - Created. Paul Kent, Jul 95/96
42 // - Zero step protections J.A. / G.C., Nov 2004
43 // - Added check mode G. Cosmo, Mar 2004
44 // - Made Navigator Abstract G. Cosmo, Nov 2003
45 // *********************************************************************
46 
47 #ifndef G4NAVIGATOR_HH
48 #define G4NAVIGATOR_HH
49 
50 #include "geomdefs.hh"
51 
52 #include "G4ThreeVector.hh"
53 #include "G4AffineTransform.hh"
54 #include "G4RotationMatrix.hh"
55 
56 #include "G4LogicalVolume.hh" // Used in inline methods
57 #include "G4GRSVolume.hh" // " "
58 #include "G4GRSSolid.hh" // " "
59 #include "G4TouchableHandle.hh" // " "
61 
62 #include "G4NavigationHistory.hh"
63 #include "G4NormalNavigation.hh"
64 #include "G4VoxelNavigation.hh"
66 #include "G4ReplicaNavigation.hh"
67 #include "G4RegularNavigation.hh"
68 
69 #include <iostream>
70 
71 class G4VPhysicalVolume;
72 
74 {
75  public: // with description
76 
77  friend std::ostream& operator << (std::ostream &os, const G4Navigator &n);
78 
79  G4Navigator();
80  // Constructor - initialisers and setup.
81 
82  virtual ~G4Navigator();
83  // Destructor. No actions.
84 
85  virtual G4double ComputeStep(const G4ThreeVector &pGlobalPoint,
86  const G4ThreeVector &pDirection,
87  const G4double pCurrentProposedStepLength,
88  G4double &pNewSafety);
89  // Calculate the distance to the next boundary intersected
90  // along the specified NORMALISED vector direction and
91  // from the specified point in the global coordinate
92  // system. LocateGlobalPointAndSetup or LocateGlobalPointWithinVolume
93  // must have been called with the same global point prior to this call.
94  // The isotropic distance to the nearest boundary is also
95  // calculated (usually an underestimate). The current
96  // proposed Step length is used to avoid intersection
97  // calculations: if it can be determined that the nearest
98  // boundary is >pCurrentProposedStepLength away, kInfinity
99  // is returned together with the computed isotropic safety
100  // distance. Geometry must be closed.
101 
102  G4double CheckNextStep(const G4ThreeVector &pGlobalPoint,
103  const G4ThreeVector &pDirection,
104  const G4double pCurrentProposedStepLength,
105  G4double &pNewSafety);
106  // Same as above, but do not disturb the state of the Navigator.
107 
108  virtual
110  const G4ThreeVector &direction,
111  const G4TouchableHistory &h);
112 
113  // Resets the geometrical hierarchy and search for the volumes deepest
114  // in the hierarchy containing the point in the global coordinate space.
115  // The direction is used to check if a volume is entered.
116  // The search begin is the geometrical hierarchy at the location of the
117  // last located point, or the endpoint of the previous Step if
118  // SetGeometricallyLimitedStep() has been called immediately before.
119  //
120  // Important Note: In order to call this the geometry MUST be closed.
121 
122  virtual
124  const G4ThreeVector* direction=0,
125  const G4bool pRelativeSearch=true,
126  const G4bool ignoreDirection=true);
127  // Search the geometrical hierarchy for the volumes deepest in the hierarchy
128  // containing the point in the global coordinate space. Two main cases are:
129  // i) If pRelativeSearch=false it makes use of no previous/state
130  // information. Returns the physical volume containing the point,
131  // with all previous mothers correctly set up.
132  // ii) If pRelativeSearch is set to true, the search begin is the
133  // geometrical hierarchy at the location of the last located point,
134  // or the endpoint of the previous Step if SetGeometricallyLimitedStep()
135  // has been called immediately before.
136  // The direction is used (to check if a volume is entered) if either
137  // - the argument ignoreDirection is false, or
138  // - the Navigator has determined that it is on an edge shared by two or
139  // more volumes. (This is state information.)
140  //
141  // Important Note: In order to call this the geometry MUST be closed.
142 
143  virtual
145  // Notify the Navigator that a track has moved to the new Global point
146  // 'position', that is known to be within the current safety.
147  // No check is performed to ensure that it is within the volume.
148  // This method can be called instead of LocateGlobalPointAndSetup ONLY if
149  // the caller is certain that the new global point (position) is inside the
150  // same volume as the previous position. Usually this can be guaranteed
151  // only if the point is within safety.
152 
154  const G4ThreeVector& position,
155  const G4ThreeVector& direction,
156  G4TouchableHandle& oldTouchableToUpdate,
157  const G4bool RelativeSearch = true);
158  // First, search the geometrical hierarchy like the above method
159  // LocateGlobalPointAndSetup(). Then use the volume found and its
160  // navigation history to update the touchable.
161 
163  const G4ThreeVector& position,
164  const G4ThreeVector& direction,
165  G4VTouchable* touchableToUpdate,
166  const G4bool RelativeSearch = true);
167  // First, search the geometrical hierarchy like the above method
168  // LocateGlobalPointAndSetup(). Then use the volume found and its
169  // navigation history to update the touchable.
170 
172  const G4ThreeVector& position,
173  G4VTouchable* touchableToUpdate,
174  const G4bool RelativeSearch = true);
175  // Same as the method above but missing direction.
176 
177  inline void SetGeometricallyLimitedStep();
178  // Inform the navigator that the previous Step calculated
179  // by the geometry was taken in its entirety.
180 
181  virtual G4double ComputeSafety(const G4ThreeVector &globalpoint,
182  const G4double pProposedMaxLength = DBL_MAX,
183  const G4bool keepState = true);
184  // Calculate the isotropic distance to the nearest boundary from the
185  // specified point in the global coordinate system.
186  // The globalpoint utilised must be within the current volume.
187  // The value returned is usually an underestimate.
188  // The proposed maximum length is used to avoid volume safety
189  // calculations. The geometry must be closed.
190  // To ensure minimum side effects from the call, keepState
191  // must be true.
192 
194  const G4ThreeVector &pGlobalPoint,
195  const G4ThreeVector &pDirection,
196  const G4double CurrentProposedStepLength,
197  G4double *prDistance,
198  G4double *prNewSafety=0) const;
199  // Trial method for checking potential displacement for MS
200  // Check new Globalpoint, to see whether it is in current volume
201  // (mother) and not in potential entering daughter.
202  // If in mother, check distance to boundary along pDirection.
203  // If in entering daughter, check distance back to boundary.
204  // NOTE:
205  // Can be called only after ComputeStep is called - before ReLocation
206  // Deals only with current volume (and potentially entered)
207 
208  inline G4VPhysicalVolume* GetWorldVolume() const;
209  // Return the current world (`topmost') volume.
210 
211  inline void SetWorldVolume(G4VPhysicalVolume* pWorld);
212  // Set the world (`topmost') volume. This must be positioned at
213  // origin (0,0,0) and unrotated.
214 
215  inline G4GRSVolume* CreateGRSVolume() const;
216  inline G4GRSSolid* CreateGRSSolid() const;
219  // `Touchable' creation methods: caller has deletion responsibility.
220 
222  // Returns a reference counted handle to a touchable history.
223 
224  virtual G4ThreeVector GetLocalExitNormal(G4bool* valid);
226  G4bool* valid);
227  virtual G4ThreeVector GetGlobalExitNormal(const G4ThreeVector& point,
228  G4bool* valid);
229  // Return Exit Surface Normal and validity too.
230  // Can only be called if the Navigator's last Step has crossed a
231  // volume geometrical boundary.
232  // It returns the Normal to the surface pointing out of the volume that
233  // was left behind and/or into the volume that was entered.
234  // Convention:
235  // The *local* normal is in the coordinate system of the *final* volume.
236  // Restriction:
237  // Normals are not available for replica volumes (returns valid= false)
238  // These methods takes full care about how to calculate this normal,
239  // but if the surfaces are not convex it will return valid=false.
240 
241  inline G4int GetVerboseLevel() const;
242  inline void SetVerboseLevel(G4int level);
243  // Get/Set Verbose(ness) level.
244  // [if level>0 && G4VERBOSE, printout can occur]
245 
246  inline G4bool IsActive() const;
247  // Verify if the navigator is active.
248  inline void Activate(G4bool flag);
249  // Activate/inactivate the navigator.
250 
251  inline G4bool EnteredDaughterVolume() const;
252  // The purpose of this function is to inform the caller if the track is
253  // entering a daughter volume while exiting from the current volume.
254  // This method returns
255  // - True only in case 1) above, that is when the Step has caused
256  // the track to arrive at a boundary of a daughter.
257  // - False in cases 2), 3) and 4), i.e. in all other cases.
258  // This function is not guaranteed to work if SetGeometricallyLimitedStep()
259  // was not called when it should have been called.
260  inline G4bool ExitedMotherVolume() const;
261  // Verify if the step has exited the mother volume.
262 
263  inline void CheckMode(G4bool mode);
264  // Run navigation in "check-mode", therefore using additional
265  // verifications and more strict correctness conditions.
266  // Is effective only with G4VERBOSE set.
267  inline G4bool IsCheckModeActive() const;
268  inline void SetPushVerbosity(G4bool mode);
269  // Set/unset verbosity for pushed tracks (default is true).
270 
271  void PrintState() const;
272  // Print the internal state of the Navigator (for debugging).
273  // The level of detail is according to the verbosity.
274 
275  inline const G4AffineTransform& GetGlobalToLocalTransform() const;
276  inline const G4AffineTransform GetLocalToGlobalTransform() const;
277  // Obtain the transformations Global/Local (and inverse).
278  // Clients of these methods must copy the data if they need to keep it.
279 
281  G4int dReplicaNo,
282  EVolume dVolumeType );
283  // Obtain mother to daughter transformation
284 
285  inline void ResetStackAndState();
286  // Reset stack and minimum or navigator state machine necessary for reset
287  // as needed by LocalGlobalPointAndSetup.
288  // [Does not perform clears, resizes, or reset fLastLocatedPointLocal]
289 
290  inline G4int SeverityOfZeroStepping( G4int* noZeroSteps ) const;
291  // Report on severity of error and number of zero steps,
292  // in case Navigator is stuck and is returning zero steps.
293  // Values: 1 (small problem), 5 (correcting),
294  // 9 (ready to abandon), 10 (abandoned)
295 
297  // Return the local coordinate of the point in the reference system
298  // of its containing volume that was found by LocalGlobalPointAndSetup.
299  // The local coordinate of the last located track.
300 
301  inline G4ThreeVector NetTranslation() const;
302  inline G4RotationMatrix NetRotation() const;
303  // Compute+return the local->global translation/rotation of current volume.
304 
305  inline void EnableBestSafety( G4bool value= false );
306  // Enable best-possible evaluation of isotropic safety
307 
308  protected: // with description
309 
310  void SetSavedState();
311  // ( fValidExitNormal, fExitNormal, fExiting, fEntering,
312  // fBlockedPhysicalVolume, fBlockedReplicaNo, fLastStepWasZero);
313  // Extended to include:
314  // ( fLastLocatedPointLocal, fLocatedOutsideWorld;
315  // fEnteredDaughter, fExitedMother
316  // fPreviousSftOrigin, sPreviousSafety) Safety Sphere.
317 
318  void RestoreSavedState();
319  // Copy aspects of the state, to enable a non-state changing
320  // call to ComputeStep().
321 
322  virtual void ResetState();
323  // Utility method to reset the navigator state machine.
324 
325  inline G4ThreeVector ComputeLocalPoint(const G4ThreeVector& rGlobPoint) const;
326  // Return position vector in local coordinate system, given a position
327  // vector in world coordinate system.
328 
329  inline G4ThreeVector ComputeLocalAxis(const G4ThreeVector& pVec) const;
330  // Return the local direction of the specified vector in the reference
331  // system of the volume that was found by LocalGlobalPointAndSetup.
332  // The Local Coordinates of point in world coordinate system.
333 
334  inline EVolume VolumeType(const G4VPhysicalVolume *pVol) const;
335  // Characterise `type' of volume - normal/replicated/parameterised.
336 
337  inline EVolume CharacteriseDaughters(const G4LogicalVolume *pLog) const;
338  // Characterise daughter of logical volume.
339 
340  inline G4int GetDaughtersRegularStructureId(const G4LogicalVolume *pLog) const;
341  // Get regular structure ID of first daughter
342 
343  virtual void SetupHierarchy();
344  // Renavigate & reset hierarchy described by current history
345  // o Reset volumes
346  // o Recompute transforms and/or solids of replicated/parameterised
347  // volumes.
348 
349  private:
350 
351  G4Navigator(const G4Navigator&);
353  // Private copy-constructor and assignment operator.
354 
355  void ComputeStepLog(const G4ThreeVector& pGlobalpoint,
356  G4double moveLenSq) const;
357  // Log and checks for steps larger than the tolerance
358 
359  protected: // without description
360 
362  // Geometrical tolerance for surface thickness of shapes.
363 
364  //
365  // BEGIN State information
366  //
367 
369  // Transformation and history of the current path
370  // through the geometrical hierarchy.
371 
373  // A memory of whether in this Step a daughter volume is entered
374  // (set in Compute & Locate).
375  // After Compute: it expects to enter a daughter
376  // After Locate: it has entered a daughter
377 
379  // A similar memory whether the Step exited current "mother" volume
380  // completely, not entering daughter.
381 
383  // Set true if last Step was limited by geometry.
384 
386  // Endpoint of last ComputeStep
387  // can be used for optimisation (e.g. when computing safety).
389  // Position of the end-point of the last call to ComputeStep
390  // in last Local coordinates.
391 
393  // Verbose(ness) level [if > 0, printout can occur].
394 
395  private:
396 
398  // States if the navigator is activated or not.
399 
401  // Whether ComputeStep was called since the last call to a Locate method
402  // Uses: - distinguish parts of state which differ before/after calls
403  // to ComputeStep or one of the Locate methods;
404  // - avoid two consecutive calls to compute-step (illegal).
405 
407  // Entering/Exiting volumes blocking/setup
408  // o If exiting
409  // volume ptr & replica number (set & used by Locate..())
410  // used for blocking on redescent of geometry
411  // o If entering
412  // volume ptr & replica number (set by ComputeStep(),used by
413  // Locate..()) of volume for `automatic' entry
414 
417 
419  // Position of the last located point relative to its containing volume.
421  // Whether the last call to Locate methods left the world
422 
423  G4bool fValidExitNormal; // Set true if have leaving volume normal
424  G4ThreeVector fExitNormal; // Leaving volume normal, in the
425  // volume containing the exited
426  // volume's coordinate system
427  G4ThreeVector fGrandMotherExitNormal; // Leaving volume normal, in its
428  // own coordinate system
429  G4bool fChangedGrandMotherRefFrame; // Whether frame is changed
430 
431  G4ThreeVector fExitNormalGlobalFrame; // Leaving volume normal, in the
432  // global coordinate system
433  G4bool fCalculatedExitNormal; // Has it been computed since
434  // the last call to ComputeStep
435  // Covers both Global and GrandMother
436 
437  // Count zero steps - as one or two can occur due to changing momentum at
438  // a boundary or at an edge common between volumes
439  // - several are likely a problem in the geometry
440  // description or in the navigation
441  //
443  // Whether the last ComputeStep moved Zero. Used to check for edges.
444 
446  // Whether the Navigator has detected an edge
448  // Number of preceding moves that were Zero. Reset to 0 after finite step
450  // After this many failed/zero steps, act (push etc)
452  // After this many failed/zero steps, abandon track
453 
456  // Memory of last safety origin & value. Used in ComputeStep to ensure
457  // that origin of current Step is in the same volume as the point of the
458  // last relocation
459 
460  //
461  // END State information
462  //
463 
464  // Save key state information (NOT the navigation history stack)
465  //
467  {
475 
476  // Potentially relevant
477  //
483  } fSaveState;
484 
485  // Tracking Invariants
486  //
488  // A link to the topmost physical volume in the detector.
489  // Must be positioned at the origin and unrotated.
490 
491  // Utility information
492  //
494  // Check-mode flag [if true, more strict checks are performed].
496  // Push flags [if true, means a stuck particle has been pushed].
497 
498  // Helpers/Utility classes
499  //
506 };
507 
508 #include "G4Navigator.icc"
509 
510 #endif
511 
512 
513 // NOTES:
514 //
515 // The following methods provide detailed information when a Step has
516 // arrived at a geometrical boundary. They distinguish between the different
517 // causes that can result in the track leaving its current volume.
518 //
519 // Four cases are possible:
520 //
521 // 1) The particle has reached a boundary of a daughter of the current volume:
522 // (this could cause the relocation to enter the daughter itself
523 // or a potential granddaughter or further descendant)
524 //
525 // 2) The particle has reached a boundary of the current
526 // volume, exiting into a mother (regardless the level
527 // at which it is located in the tree):
528 //
529 // 3) The particle has reached a boundary of the current
530 // volume, exiting into a volume which is not in its
531 // parental hierarchy:
532 //
533 // 4) The particle is not on a boundary between volumes:
534 // the function returns an exception, and the caller is
535 // reccomended to compare the G4touchables associated
536 // to the preStepPoint and postStepPoint to handle this case.
537 //
538 // G4bool EnteredDaughterVolume()
539 // G4bool IsExitNormalValid()
540 // G4ThreeVector GetLocalExitNormal()
541 //
542 // The expected usefulness of these methods is to allow the caller to
543 // determine how to compute the surface normal at the volume boundary. The two
544 // possibilities are to obtain the normal from:
545 //
546 // i) the solid associated with the volume of the initial point of the Step.
547 // This is valid for cases 2 and 3.
548 // (Note that the initial point is generally the PreStepPoint of a Step).
549 // or
550 //
551 // ii) the solid of the final point, ie of the volume after the relocation.
552 // This is valid for case 1.
553 // (Note that the final point is generally the PreStepPoint of a Step).
554 //
555 // This way the caller can always get a valid normal, pointing outside
556 // the solid for which it is computed, that can be used at his own
557 // discretion.
G4GRSVolume * CreateGRSVolume() const
G4ReplicaNavigation freplicaNav
Definition: G4Navigator.hh:503
G4bool fWarnPush
Definition: G4Navigator.hh:495
G4ParameterisedNavigation fparamNav
Definition: G4Navigator.hh:502
friend std::ostream & operator<<(std::ostream &os, const G4Navigator &n)
G4bool fValidExitNormal
Definition: G4Navigator.hh:423
G4VoxelNavigation fvoxelNav
Definition: G4Navigator.hh:501
G4VPhysicalVolume * fBlockedPhysicalVolume
Definition: G4Navigator.hh:415
G4RotationMatrix NetRotation() const
virtual void ResetState()
G4bool fLastTriedStepComputation
Definition: G4Navigator.hh:400
G4VPhysicalVolume * fTopPhysical
Definition: G4Navigator.hh:487
G4VoxelSafety * fpVoxelSafety
Definition: G4Navigator.hh:505
G4bool fCheck
Definition: G4Navigator.hh:493
CLHEP::Hep3Vector G4ThreeVector
CLHEP::HepRotation G4RotationMatrix
G4ThreeVector GetCurrentLocalCoordinate() const
G4ThreeVector fLastStepEndPointLocal
Definition: G4Navigator.hh:388
G4bool IsCheckModeActive() const
G4int GetVerboseLevel() const
G4ThreeVector fGrandMotherExitNormal
Definition: G4Navigator.hh:427
G4ThreeVector ComputeLocalAxis(const G4ThreeVector &pVec) const
G4bool fPushed
Definition: G4Navigator.hh:495
virtual G4TouchableHistoryHandle CreateTouchableHistoryHandle() const
void ResetStackAndState()
G4int fNumberZeroSteps
Definition: G4Navigator.hh:447
G4VPhysicalVolume * spBlockedPhysicalVolume
Definition: G4Navigator.hh:471
virtual G4double ComputeStep(const G4ThreeVector &pGlobalPoint, const G4ThreeVector &pDirection, const G4double pCurrentProposedStepLength, G4double &pNewSafety)
Definition: G4Navigator.cc:744
G4int fVerbose
Definition: G4Navigator.hh:392
G4bool IsActive() const
void PrintState() const
G4int fAbandonThreshold_NoZeroSteps
Definition: G4Navigator.hh:451
G4bool fEnteredDaughter
Definition: G4Navigator.hh:372
G4bool fLocatedOnEdge
Definition: G4Navigator.hh:445
const G4AffineTransform GetLocalToGlobalTransform() const
int G4int
Definition: G4Types.hh:78
G4bool fLastStepWasZero
Definition: G4Navigator.hh:442
virtual G4VPhysicalVolume * ResetHierarchyAndLocate(const G4ThreeVector &point, const G4ThreeVector &direction, const G4TouchableHistory &h)
Definition: G4Navigator.cc:92
G4ThreeVector fExitNormalGlobalFrame
Definition: G4Navigator.hh:431
virtual G4ThreeVector GetLocalExitNormalAndCheck(const G4ThreeVector &point, G4bool *valid)
void LocateGlobalPointAndUpdateTouchableHandle(const G4ThreeVector &position, const G4ThreeVector &direction, G4TouchableHandle &oldTouchableToUpdate, const G4bool RelativeSearch=true)
void SetVerboseLevel(G4int level)
G4bool fWasLimitedByGeometry
Definition: G4Navigator.hh:382
void SetGeometricallyLimitedStep()
G4NormalNavigation fnormalNav
Definition: G4Navigator.hh:500
G4bool fEntering
Definition: G4Navigator.hh:406
#define position
Definition: xmlparse.cc:622
G4Navigator & operator=(const G4Navigator &)
virtual G4ThreeVector GetLocalExitNormal(G4bool *valid)
void LocateGlobalPointAndUpdateTouchable(const G4ThreeVector &position, const G4ThreeVector &direction, G4VTouchable *touchableToUpdate, const G4bool RelativeSearch=true)
G4ThreeVector fPreviousSftOrigin
Definition: G4Navigator.hh:454
G4double CheckNextStep(const G4ThreeVector &pGlobalPoint, const G4ThreeVector &pDirection, const G4double pCurrentProposedStepLength, G4double &pNewSafety)
bool G4bool
Definition: G4Types.hh:79
G4NavigationHistory fHistory
Definition: G4Navigator.hh:368
G4bool fExitedMother
Definition: G4Navigator.hh:378
void Activate(G4bool flag)
virtual G4bool RecheckDistanceToCurrentBoundary(const G4ThreeVector &pGlobalPoint, const G4ThreeVector &pDirection, const G4double CurrentProposedStepLength, G4double *prDistance, G4double *prNewSafety=0) const
G4bool EnteredDaughterVolume() const
G4int fBlockedReplicaNo
Definition: G4Navigator.hh:416
const G4int n
EVolume CharacteriseDaughters(const G4LogicalVolume *pLog) const
G4ThreeVector fLastLocatedPointLocal
Definition: G4Navigator.hh:418
G4double fPreviousSafety
Definition: G4Navigator.hh:455
G4bool fLocatedOutsideWorld
Definition: G4Navigator.hh:420
void SetSavedState()
Definition: G4Navigator.cc:656
G4bool fActive
Definition: G4Navigator.hh:397
G4ThreeVector ComputeLocalPoint(const G4ThreeVector &rGlobPoint) const
G4double kCarTolerance
Definition: G4Navigator.hh:361
G4TouchableHistory * CreateTouchableHistory() const
G4AffineTransform GetMotherToDaughterTransform(G4VPhysicalVolume *dVolume, G4int dReplicaNo, EVolume dVolumeType)
virtual G4ThreeVector GetGlobalExitNormal(const G4ThreeVector &point, G4bool *valid)
G4bool fExiting
Definition: G4Navigator.hh:406
G4int GetDaughtersRegularStructureId(const G4LogicalVolume *pLog) const
void SetWorldVolume(G4VPhysicalVolume *pWorld)
G4GRSSolid * CreateGRSSolid() const
const G4AffineTransform & GetGlobalToLocalTransform() const
virtual G4VPhysicalVolume * LocateGlobalPointAndSetup(const G4ThreeVector &point, const G4ThreeVector *direction=0, const G4bool pRelativeSearch=true, const G4bool ignoreDirection=true)
Definition: G4Navigator.cc:122
struct G4Navigator::G4SaveNavigatorState fSaveState
void EnableBestSafety(G4bool value=false)
void SetPushVerbosity(G4bool mode)
G4bool ExitedMotherVolume() const
G4bool fCalculatedExitNormal
Definition: G4Navigator.hh:433
G4ThreeVector fStepEndPoint
Definition: G4Navigator.hh:385
void CheckMode(G4bool mode)
G4ThreeVector fExitNormal
Definition: G4Navigator.hh:424
G4int SeverityOfZeroStepping(G4int *noZeroSteps) const
G4int fActionThreshold_NoZeroSteps
Definition: G4Navigator.hh:449
G4bool fChangedGrandMotherRefFrame
Definition: G4Navigator.hh:429
EVolume
Definition: geomdefs.hh:68
double G4double
Definition: G4Types.hh:76
G4ThreeVector NetTranslation() const
virtual G4double ComputeSafety(const G4ThreeVector &globalpoint, const G4double pProposedMaxLength=DBL_MAX, const G4bool keepState=true)
G4RegularNavigation fregularNav
Definition: G4Navigator.hh:504
#define DBL_MAX
Definition: templates.hh:83
virtual void SetupHierarchy()
G4VPhysicalVolume * GetWorldVolume() const
EVolume VolumeType(const G4VPhysicalVolume *pVol) const
virtual void LocateGlobalPointWithinVolume(const G4ThreeVector &position)
Definition: G4Navigator.cc:579
void ComputeStepLog(const G4ThreeVector &pGlobalpoint, G4double moveLenSq) const
void RestoreSavedState()
Definition: G4Navigator.cc:690
virtual ~G4Navigator()
Definition: G4Navigator.cc:82