Geant4  10.01.p02
G4ITNavigator2.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 // $Id: G4ITNavigator.hh 79045 2014-02-12 13:57:26Z matkara $
27 //
28 // Original author: Paul Kent, July 95/96
29 //
41 //
42 // Contact : Mathieu Karamitros (kara (AT) cenbg . in2p3 . fr)
43 //
44 // WARNING : This class is released as a prototype.
45 // It might strongly evolve or even disapear in the next releases.
46 //
47 // We would be very happy hearing from you, send us your feedback! :)
48 //
49 // History:
50 // - Created. Paul Kent, Jul 95/96
51 // - Zero step protections J.A. / G.C., Nov 2004
52 // - Added check mode G. Cosmo, Mar 2004
53 // - Made Navigator Abstract G. Cosmo, Nov 2003
54 // - G4ITNavigator created M.K., Nov 2012
55 // *********************************************************************
56 
57 #ifndef G4ITNAVIGATOR_HH
58 #define G4ITNAVIGATOR_HH
59 
60 #include "geomdefs.hh"
61 
62 #include "G4ThreeVector.hh"
63 #include "G4AffineTransform.hh"
64 #include "G4RotationMatrix.hh"
65 
66 #include "G4LogicalVolume.hh" // Used in inline methods
67 #include "G4GRSVolume.hh" // " "
68 #include "G4GRSSolid.hh" // " "
69 #include "G4TouchableHandle.hh" // " "
71 
72 #include "G4NavigationHistory.hh"
73 #include "G4NormalNavigation.hh"
74 #include "G4VoxelNavigation.hh"
76 #include "G4ReplicaNavigation.hh"
77 #include "G4RegularNavigation.hh"
78 
79 #include <iostream>
80 #include "G4TrackState.hh"
81 
82 class G4VPhysicalVolume;
83 
85 {
87  {
88  ;
89  }
90 protected:
92  {
93  ;
94  }
96  {
97  ;
98  }
99 };
100 
102 {
103 public:
104  static const G4int fMaxNav = 8; // rename to kMaxNoNav ??
105 
106 public:
107  // with description
108 
109  friend std::ostream& operator <<(std::ostream &os, const G4ITNavigator2 &n);
110 
111  G4ITNavigator2();
112  // Constructor - initialisers and setup.
113 
114  virtual ~G4ITNavigator2();
115  // Destructor. No actions.
116 
117  // !>
120  void NewNavigatorState();
121  void NewNavigatorState(const G4TouchableHistory &h);
122  void ResetNavigatorState();
124  const G4ThreeVector &direction);
125  void CheckNavigatorState() const;
126  // <!
127 
128  virtual G4double ComputeStep(const G4ThreeVector &pGlobalPoint,
129  const G4ThreeVector &pDirection,
130  const G4double pCurrentProposedStepLength,
131  G4double &pNewSafety);
132  // Calculate the distance to the next boundary intersected
133  // along the specified NORMALISED vector direction and
134  // from the specified point in the global coordinate
135  // system. LocateGlobalPointAndSetup or LocateGlobalPointWithinVolume
136  // must have been called with the same global point prior to this call.
137  // The isotropic distance to the nearest boundary is also
138  // calculated (usually an underestimate). The current
139  // proposed Step length is used to avoid intersection
140  // calculations: if it can be determined that the nearest
141  // boundary is >pCurrentProposedStepLength away, kInfinity
142  // is returned together with the computed isotropic safety
143  // distance. Geometry must be closed.
144 
145  G4double CheckNextStep(const G4ThreeVector &pGlobalPoint,
146  const G4ThreeVector &pDirection,
147  const G4double pCurrentProposedStepLength,
148  G4double &pNewSafety);
149  // Same as above, but do not disturb the state of the Navigator.
150 
152  const G4ThreeVector &direction,
153  const G4TouchableHistory &h);
154 
155  // Resets the geometrical hierarchy and search for the volumes deepest
156  // in the hierarchy containing the point in the global coordinate space.
157  // The direction is used to check if a volume is entered.
158  // The search begin is the geometrical hierarchy at the location of the
159  // last located point, or the endpoint of the previous Step if
160  // SetGeometricallyLimitedStep() has been called immediately before.
161  //
162  // Important Note: In order to call this the geometry MUST be closed.
163 
164  virtual
166  const G4ThreeVector* direction=0,
167  const G4bool pRelativeSearch=true,
168  const G4bool ignoreDirection=true);
169  // Search the geometrical hierarchy for the volumes deepest in the hierarchy
170  // containing the point in the global coordinate space. Two main cases are:
171  // i) If pRelativeSearch=false it makes use of no previous/state
172  // information. Returns the physical volume containing the point,
173  // with all previous mothers correctly set up.
174  // ii) If pRelativeSearch is set to true, the search begin is the
175  // geometrical hierarchy at the location of the last located point,
176  // or the endpoint of the previous Step if SetGeometricallyLimitedStep()
177  // has been called immediately before.
178  // The direction is used (to check if a volume is entered) if either
179  // - the argument ignoreDirection is false, or
180  // - the Navigator has determined that it is on an edge shared by two or
181  // more volumes. (This is state information.)
182  //
183  // Important Note: In order to call this the geometry MUST be closed.
184 
185  virtual
187  // Notify the Navigator that a track has moved to the new Global point
188  // 'position', that is known to be within the current safety.
189  // No check is performed to ensure that it is within the volume.
190  // This method can be called instead of LocateGlobalPointAndSetup ONLY if
191  // the caller is certain that the new global point (position) is inside the
192  // same volume as the previous position. Usually this can be guaranteed
193  // only if the point is within safety.
194 
196  const G4ThreeVector& position,
197  const G4ThreeVector& direction,
198  G4TouchableHandle& oldTouchableToUpdate,
199  const G4bool RelativeSearch = true);
200  // First, search the geometrical hierarchy like the above method
201  // LocateGlobalPointAndSetup(). Then use the volume found and its
202  // navigation history to update the touchable.
203 
205  const G4ThreeVector& position,
206  const G4ThreeVector& direction,
207  G4VTouchable* touchableToUpdate,
208  const G4bool RelativeSearch = true);
209  // First, search the geometrical hierarchy like the above method
210  // LocateGlobalPointAndSetup(). Then use the volume found and its
211  // navigation history to update the touchable.
212 
214  const G4ThreeVector& position,
215  G4VTouchable* touchableToUpdate,
216  const G4bool RelativeSearch = true);
217  // Same as the method above but missing direction.
218 
219  inline void SetGeometricallyLimitedStep();
220  // Inform the navigator that the previous Step calculated
221  // by the geometry was taken in its entirety.
222 
223  virtual G4double ComputeSafety(const G4ThreeVector &globalpoint,
224  const G4double pProposedMaxLength = DBL_MAX,
225  const G4bool keepState = true);
226  // Calculate the isotropic distance to the nearest boundary from the
227  // specified point in the global coordinate system.
228  // The globalpoint utilised must be within the current volume.
229  // The value returned is usually an underestimate.
230  // The proposed maximum length is used to avoid volume safety
231  // calculations. The geometry must be closed.
232  // To ensure minimum side effects from the call, keepState
233  // must be true.
234 
236  const G4ThreeVector &pGlobalPoint,
237  const G4ThreeVector &pDirection,
238  const G4double CurrentProposedStepLength,
239  G4double *prDistance,
240  G4double *prNewSafety=0) const;
241  // Trial method for checking potential displacement for MS
242  // Check new Globalpoint, to see whether it is in current volume
243  // (mother) and not in potential entering daughter.
244  // If in mother, check distance to boundary along pDirection.
245  // If in entering daughter, check distance back to boundary.
246  // NOTE:
247  // Can be called only after ComputeStep is called - before ReLocation
248  // Deals only with current volume (and potentially entered)
249 
250  inline G4VPhysicalVolume* GetWorldVolume() const;
251  // Return the current world (`topmost') volume.
252 
253  inline void SetWorldVolume(G4VPhysicalVolume* pWorld);
254  // Set the world (`topmost') volume. This must be positioned at
255  // origin (0,0,0) and unrotated.
256 
257  inline G4GRSVolume* CreateGRSVolume() const;
258  inline G4GRSSolid* CreateGRSSolid() const;
261  // `Touchable' creation methods: caller has deletion responsibility.
262 
264  // Returns a reference counted handle to a touchable history.
265 
266  virtual G4ThreeVector GetLocalExitNormal(G4bool* valid);
268  G4bool* valid);
269  virtual G4ThreeVector GetGlobalExitNormal(const G4ThreeVector& point,
270  G4bool* valid);
271  // Return Exit Surface Normal and validity too.
272  // Can only be called if the Navigator's last Step has crossed a
273  // volume geometrical boundary.
274  // It returns the Normal to the surface pointing out of the volume that
275  // was left behind and/or into the volume that was entered.
276  // Convention:
277  // The *local* normal is in the coordinate system of the *final* volume.
278  // Restriction:
279  // Normals are not available for replica volumes (returns valid= false)
280  // These methods takes full care about how to calculate this normal,
281  // but if the surfaces are not convex it will return valid=false.
282 
283  inline G4int GetVerboseLevel() const;
284  inline void SetVerboseLevel(G4int level);
285  // Get/Set Verbose(ness) level.
286  // [if level>0 && G4VERBOSE, printout can occur]
287 
288  inline G4bool IsActive() const;
289  // Verify if the navigator is active.
290  inline void Activate(G4bool flag);
291  // Activate/inactivate the navigator.
292 
293  inline G4bool EnteredDaughterVolume() const;
294  // The purpose of this function is to inform the caller if the track is
295  // entering a daughter volume while exiting from the current volume.
296  // This method returns
297  // - True only in case 1) above, that is when the Step has caused
298  // the track to arrive at a boundary of a daughter.
299  // - False in cases 2), 3) and 4), i.e. in all other cases.
300  // This function is not guaranteed to work if SetGeometricallyLimitedStep()
301  // was not called when it should have been called.
302  inline G4bool ExitedMotherVolume() const;
303  // Verify if the step has exited the mother volume.
304 
305  inline void CheckMode(G4bool mode);
306  // Run navigation in "check-mode", therefore using additional
307  // verifications and more strict correctness conditions.
308  // Is effective only with G4VERBOSE set.
309  inline G4bool IsCheckModeActive() const;
310  inline void SetPushVerbosity(G4bool mode);
311  // Set/unset verbosity for pushed tracks (default is true).
312 
313  void PrintState() const;
314  // Print the internal state of the Navigator (for debugging).
315  // The level of detail is according to the verbosity.
316 
317  inline const G4AffineTransform& GetGlobalToLocalTransform() const;
318  inline const G4AffineTransform GetLocalToGlobalTransform() const;
319  // Obtain the transformations Global/Local (and inverse).
320  // Clients of these methods must copy the data if they need to keep it.
321 
323  G4int dReplicaNo,
324  EVolume dVolumeType );
325  // Obtain mother to daughter transformation
326 
327  inline void ResetStackAndState();
328  // Reset stack and minimum or navigator state machine necessary for reset
329  // as needed by LocalGlobalPointAndSetup.
330  // [Does not perform clears, resizes, or reset fLastLocatedPointLocal]
331 
332  inline G4int SeverityOfZeroStepping( G4int* noZeroSteps ) const;
333  // Report on severity of error and number of zero steps,
334  // in case Navigator is stuck and is returning zero steps.
335  // Values: 1 (small problem), 5 (correcting),
336  // 9 (ready to abandon), 10 (abandoned)
337 
338  /*
339  void SetSavedState();
340  // ( fValidExitNormal, fExitNormal, fExiting, fEntering,
341  // fBlockedPhysicalVolume, fBlockedReplicaNo, fLastStepWasZero);
342  void RestoreSavedState();
343  // Copy aspects of the state, to enable a non-state changing
344  // call to ComputeStep
345  */
347  // Return the local coordinate of the point in the reference system
348  // of its containing volume that was found by LocalGlobalPointAndSetup.
349  // The local coordinate of the last located track.
350 
351  inline G4ThreeVector NetTranslation() const;
352  inline G4RotationMatrix NetRotation() const;
353  // Compute+return the local->global translation/rotation of current volume.
354 
355  inline void EnableBestSafety( G4bool value= false );
356  // Enable best-possible evaluation of isotropic safety
357 
358 protected:// with description
359 
360  inline G4ThreeVector ComputeLocalPoint(const G4ThreeVector& rGlobPoint) const;
361  // Return position vector in local coordinate system, given a position
362  // vector in world coordinate system.
363 
364  inline G4ThreeVector ComputeLocalAxis(const G4ThreeVector& pVec) const;
365  // Return the local direction of the specified vector in the reference
366  // system of the volume that was found by LocalGlobalPointAndSetup.
367  // The Local Coordinates of point in world coordinate system.
368 
369  virtual void ResetState();
370  // Utility method to reset the navigator state machine.
371 
372  inline EVolume VolumeType(const G4VPhysicalVolume *pVol) const;
373  // Characterise `type' of volume - normal/replicated/parameterised.
374 
375  inline EVolume CharacteriseDaughters(const G4LogicalVolume *pLog) const;
376  // Characterise daughter of logical volume.
377 
378  inline G4int GetDaughtersRegularStructureId(const G4LogicalVolume *pLog) const;
379  // Get regular structure ID of first daughter
380 
381  virtual void SetupHierarchy();
382  // Renavigate & reset hierarchy described by current history
383  // o Reset volumes
384  // o Recompute transforms and/or solids of replicated/parameterised
385  // volumes.
386 
387 private:
388 
391  // Private copy-constructor and assignment operator.
392 
393  void ComputeStepLog(const G4ThreeVector& pGlobalpoint,
394  G4double moveLenSq) const;
395  // Log and checks for steps larger than the tolerance
396 
397 protected:// without description
398 
400  // Geometrical tolerance for surface thickness of shapes.
401 
403  // Verbose(ness) level [if > 0, printout can occur].
404 
405 private:
406 
408  // States if the navigator is activated or not.
409 
411  // After this many failed/zero steps, act (push etc)
413  // After this many failed/zero steps, abandon track
414 
415 protected:
416 public:
417  struct G4SaveNavigatorState;
418 
419  //
420  // BEGIN State information
421  //
423  {
427  { ;}
428 
431 
432  void ResetState();
433  void ResetStack();
434  void ResetStackAndState();
435 
437  // Transformation and history of the current path
438  // through the geometrical hierarchy.
439 
441  // A memory of whether in this Step a daughter volume is entered
442  // (set in Compute & Locate).
443  // After Compute: it expects to enter a daughter
444  // After Locate: it has entered a daughter
445 
447  // A similar memory whether the Step exited current "mother" volume
448  // completely, not entering daughter.
449 
451  // Set true if last Step was limited by geometry.
452 
454  // Endpoint of last ComputeStep
455  // can be used for optimisation (e.g. when computing safety).
457  // Position of the end-point of the last call to ComputeStep
458  // in last Local coordinates.
459 
461  // Push flags [if true, means a stuck particle has been pushed].
462 
463  private:
464  friend class G4ITNavigator2;
465  // The friend class would allow G4Navigator to access the private members
466  // of G4NavigatorState but not the classes inheriting from G4Navigator
467 
468  friend struct G4SaveNavigatorState;
469  friend std::ostream& operator << (std::ostream &os,const G4ITNavigator2 &n);
470 
472  // Whether ComputeStep was called since the last call to a Locate method
473  // Uses: - distinguish parts of state which differ before/after calls
474  // to ComputeStep or one of the Locate methods;
475  // - avoid two consecutive calls to compute-step (illegal).
476 
478  // Entering/Exiting volumes blocking/setup
479  // o If exiting
480  // volume ptr & replica number (set & used by Locate..())
481  // used for blocking on redescent of geometry
482  // o If entering
483  // volume ptr & replica number (set by ComputeStep(),used by
484  // Locate..()) of volume for `automatic' entry
485 
488 
490  // Position of the last located point relative to its containing volume.
492  // Whether the last call to Locate methods left the world
493 
494  G4bool fValidExitNormal;// Set true if have leaving volume normal
495  G4ThreeVector fExitNormal;// Leaving volume normal, in the
496  // volume containing the exited
497  // volume's coordinate system
498  G4ThreeVector fGrandMotherExitNormal;// Leaving volume normal, in its
499  // own coordinate system
500  G4bool fChangedGrandMotherRefFrame;// Whether frame is changed
501 
502  G4ThreeVector fExitNormalGlobalFrame;// Leaving volume normal, in the
503  // global coordinate system
504  G4bool fCalculatedExitNormal;// Has it been computed since
505  // the last call to ComputeStep
506  // Covers both Global and GrandMother
507 
508  // Count zero steps - as one or two can occur due to changing momentum at
509  // a boundary or at an edge common between volumes
510  // - several are likely a problem in the geometry
511  // description or in the navigation
512  //
514  // Whether the last ComputeStep moved Zero. Used to check for edges.
515 
517  // Whether the Navigator has detected an edge
519  // Number of preceding moves that were Zero. Reset to 0 after finite step
520 
523  // Memory of last safety origin & value. Used in ComputeStep to ensure
524  // that origin of current Step is in the same volume as the point of the
525  // last relocation
526 
527  //
528  // END State information
529  //
530  };
531 
533 
534  // Save key state information (NOT the navigation history stack)
535  //
537  {
541  { ;}
548 
549  // !>
550 // G4bool sLocatedOnEdge;
551 // G4bool sPushed;
552 // G4int sNumberZeroSteps;
553  // <!
554 
555  // Potentially relevant
556  //
561 
564  };
565 
566  // G4SaveNavigatorState* fpSaveState;
567 
568  // Tracking Invariants
569  //
571  // A link to the topmost physical volume in the detector.
572  // Must be positioned at the origin and unrotated.
573 
574  // Utility information
575  //
577  // Check-mode flag [if true, more strict checks are performed].
578 
580  // Push flag [for verbose].
581 
582  // Helpers/Utility classes
583  //
590 };
591 
593 
594 #define CheckNavigatorStateIsValid() \
595 if(fpNavigatorState == 0) \
596 { \
597  G4ExceptionDescription exceptionDescription; \
598  exceptionDescription << "The navigator state is NULL. "; \
599  exceptionDescription << "Either NewNavigatorStateAndLocate was not called "; \
600  exceptionDescription << "or the provided navigator state was already NULL."; \
601  G4Exception((G4String("G4Navigator")+G4String(__FUNCTION__)).c_str(),\
602  "NavigatorStateNotValid",FatalException,exceptionDescription); \
603 }
604 
605 #include "G4ITNavigator2.icc"
606 
607 #endif
608 
609 // NOTES:
610 //
611 // The following methods provide detailed information when a Step has
612 // arrived at a geometrical boundary. They distinguish between the different
613 // causes that can result in the track leaving its current volume.
614 //
615 // Four cases are possible:
616 //
617 // 1) The particle has reached a boundary of a daughter of the current volume:
618 // (this could cause the relocation to enter the daughter itself
619 // or a potential granddaughter or further descendant)
620 //
621 // 2) The particle has reached a boundary of the current
622 // volume, exiting into a mother (regardless the level
623 // at which it is located in the tree):
624 //
625 // 3) The particle has reached a boundary of the current
626 // volume, exiting into a volume which is not in its
627 // parental hierarchy:
628 //
629 // 4) The particle is not on a boundary between volumes:
630 // the function returns an exception, and the caller is
631 // reccomended to compare the G4touchables associated
632 // to the preStepPoint and postStepPoint to handle this case.
633 //
634 // G4bool EnteredDaughterVolume()
635 // G4bool IsExitNormalValid()
636 // G4ThreeVector GetLocalExitNormal()
637 //
638 // The expected usefulness of these methods is to allow the caller to
639 // determine how to compute the surface normal at the volume boundary. The two
640 // possibilities are to obtain the normal from:
641 //
642 // i) the solid associated with the volume of the initial point of the Step.
643 // This is valid for cases 2 and 3.
644 // (Note that the initial point is generally the PreStepPoint of a Step).
645 // or
646 //
647 // ii) the solid of the final point, ie of the volume after the relocation.
648 // This is valid for case 1.
649 // (Note that the final point is generally the PreStepPoint of a Step).
650 //
651 // This way the caller can always get a valid normal, pointing outside
652 // the solid for which it is computed, that can be used at his own
653 // discretion.
RegisterTrackState(G4ITSafetyHelper, G4ITSafetyHelper::State) inline void G4ITSafetyHelper
void LocateGlobalPointAndUpdateTouchableHandle(const G4ThreeVector &position, const G4ThreeVector &direction, G4TouchableHandle &oldTouchableToUpdate, const G4bool RelativeSearch=true)
G4ITNavigatorState_Lock2 * GetNavigatorState()
G4VPhysicalVolume * spBlockedPhysicalVolume
virtual void SetupHierarchy()
virtual G4double ComputeStep(const G4ThreeVector &pGlobalPoint, const G4ThreeVector &pDirection, const G4double pCurrentProposedStepLength, G4double &pNewSafety)
CLHEP::Hep3Vector G4ThreeVector
CLHEP::HepRotation G4RotationMatrix
void CheckNavigatorState() const
G4VoxelSafety * fpVoxelSafety
void Activate(G4bool flag)
void ResetNavigatorState()
void ResetStackAndState()
friend std::ostream & operator<<(std::ostream &os, const G4ITNavigator2 &n)
G4TouchableHistory * CreateTouchableHistory() const
G4VPhysicalVolume * fTopPhysical
G4double CheckNextStep(const G4ThreeVector &pGlobalPoint, const G4ThreeVector &pDirection, const G4double pCurrentProposedStepLength, G4double &pNewSafety)
G4bool IsCheckModeActive() const
G4NavigatorState * fpNavigatorState
G4VPhysicalVolume * NewNavigatorStateAndLocate(const G4ThreeVector &p, const G4ThreeVector &direction)
void SetWorldVolume(G4VPhysicalVolume *pWorld)
virtual ~G4ITNavigator2()
int G4int
Definition: G4Types.hh:78
G4int fAbandonThreshold_NoZeroSteps
void SetGeometricallyLimitedStep()
static const G4int fMaxNav
G4GRSVolume * CreateGRSVolume() const
G4GRSSolid * CreateGRSSolid() const
G4NavigatorState & operator=(const G4NavigatorState &)
G4ThreeVector ComputeLocalAxis(const G4ThreeVector &pVec) const
#define position
Definition: xmlparse.cc:605
G4RotationMatrix NetRotation() const
virtual void LocateGlobalPointWithinVolume(const G4ThreeVector &position)
bool G4bool
Definition: G4Types.hh:79
virtual G4VPhysicalVolume * LocateGlobalPointAndSetup(const G4ThreeVector &point, const G4ThreeVector *direction=0, const G4bool pRelativeSearch=true, const G4bool ignoreDirection=true)
G4ITNavigatorState_Lock2(const G4ITNavigatorState_Lock2 &)
G4RegularNavigation fregularNav
G4NormalNavigation fnormalNav
EVolume VolumeType(const G4VPhysicalVolume *pVol) const
G4ReplicaNavigation freplicaNav
G4double kCarTolerance
const G4int n
virtual G4ThreeVector GetGlobalExitNormal(const G4ThreeVector &point, G4bool *valid)
void EnableBestSafety(G4bool value=false)
friend std::ostream & operator<<(std::ostream &os, const G4ITNavigator2 &n)
G4ParameterisedNavigation fparamNav
virtual G4bool RecheckDistanceToCurrentBoundary(const G4ThreeVector &pGlobalPoint, const G4ThreeVector &pDirection, const G4double CurrentProposedStepLength, G4double *prDistance, G4double *prNewSafety=0) const
G4int fActionThreshold_NoZeroSteps
void PrintState() const
G4bool ExitedMotherVolume() const
G4ThreeVector NetTranslation() const
G4ThreeVector ComputeLocalPoint(const G4ThreeVector &rGlobPoint) const
G4VoxelNavigation fvoxelNav
virtual G4ThreeVector GetLocalExitNormal(G4bool *valid)
void SetNavigatorState(G4ITNavigatorState_Lock2 *)
void ComputeStepLog(const G4ThreeVector &pGlobalpoint, G4double moveLenSq) const
const G4AffineTransform & GetGlobalToLocalTransform() const
G4int GetDaughtersRegularStructureId(const G4LogicalVolume *pLog) const
virtual G4double ComputeSafety(const G4ThreeVector &globalpoint, const G4double pProposedMaxLength=DBL_MAX, const G4bool keepState=true)
G4VPhysicalVolume * GetWorldVolume() const
G4int GetVerboseLevel() const
G4bool EnteredDaughterVolume() const
void CheckMode(G4bool mode)
G4ITNavigator2 & operator=(const G4ITNavigator2 &)
virtual G4ThreeVector GetLocalExitNormalAndCheck(const G4ThreeVector &point, G4bool *valid)
virtual void ResetState()
EVolume
Definition: geomdefs.hh:68
virtual G4VPhysicalVolume * ResetHierarchyAndLocate(const G4ThreeVector &point, const G4ThreeVector &direction, const G4TouchableHistory &h)
G4ThreeVector GetCurrentLocalCoordinate() const
double G4double
Definition: G4Types.hh:76
void NewNavigatorState()
void SetVerboseLevel(G4int level)
G4bool IsActive() const
void LocateGlobalPointAndUpdateTouchable(const G4ThreeVector &position, const G4ThreeVector &direction, G4VTouchable *touchableToUpdate, const G4bool RelativeSearch=true)
#define DBL_MAX
Definition: templates.hh:83
void SetPushVerbosity(G4bool mode)
const G4AffineTransform GetLocalToGlobalTransform() const
G4VPhysicalVolume * fBlockedPhysicalVolume
G4int SeverityOfZeroStepping(G4int *noZeroSteps) const
virtual G4TouchableHistoryHandle CreateTouchableHistoryHandle() const
EVolume CharacteriseDaughters(const G4LogicalVolume *pLog) const
G4AffineTransform GetMotherToDaughterTransform(G4VPhysicalVolume *dVolume, G4int dReplicaNo, EVolume dVolumeType)