Logo ROOT   6.21/01
Reference Guide
TGeoNavigator.h
Go to the documentation of this file.
1 // @(#)root/geom:$Id$
2 // Author: Mihaela Gheata 30/05/07
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #ifndef ROOT_TGeoNavigator
13 #define ROOT_TGeoNavigator
14 
15 #include "TObject.h"
16 
17 #include "TGeoCache.h"
18 
19 ////////////////////////////////////////////////////////////////////////////
20 // //
21 // TGeoNavigator - Class containing the implementation of all navigation //
22 // methods.
23 // //
24 ////////////////////////////////////////////////////////////////////////////
25 
26 class TGeoManager;
27 class TGeoNode;
28 class TGeoVolume;
29 class TGeoMatrix;
30 class TGeoHMatrix;
31 
32 
33 class TGeoNavigator : public TObject
34 {
35 
36 protected:
39  TGeoNode *FindInCluster(Int_t *cluster, Int_t nc);
40  Int_t GetTouchedCluster(Int_t start, Double_t *point, Int_t *check_list,
41  Int_t ncheck, Int_t *result);
43  void SafetyOverlaps();
44 
45 private :
46  Double_t fStep; //! step to be done from current point and direction
47  Double_t fSafety; //! safety radius from current point
48  Double_t fLastSafety; //! last computed safety radius
49  Double_t fNormal[3]; //! cosine of incident angle on current checked surface
50  Double_t fCldir[3]; //! unit vector to current closest shape
51  Double_t fCldirChecked[3]; //! unit vector to current checked shape
52  Double_t fPoint[3]; //! current point
53  Double_t fDirection[3]; //! current direction
54  Double_t fLastPoint[3]; //! last point for which safety was computed
55  Int_t fThreadId; //! thread id for this navigator
56  Int_t fLevel; //! current geometry level;
57  Int_t fNmany; //! number of overlapping nodes on current branch
58  Int_t fNextDaughterIndex; //! next daughter index after FindNextBoundary
59  Int_t fOverlapSize; //! current size of fOverlapClusters
60  Int_t fOverlapMark; //! current recursive position in fOverlapClusters
61  Int_t *fOverlapClusters; //! internal array for overlaps
62  Bool_t fSearchOverlaps; //! flag set when an overlapping cluster is searched
63  Bool_t fCurrentOverlapping; //! flags the type of the current node
64  Bool_t fStartSafe; //! flag a safe start for point classification
65  Bool_t fIsEntering; //! flag if current step just got into a new node
66  Bool_t fIsExiting; //! flag that current track is about to leave current node
67  Bool_t fIsStepEntering; //! flag that next geometric step will enter new volume
68  Bool_t fIsStepExiting; //! flag that next geometric step will exit current volume
69  Bool_t fIsOutside; //! flag that current point is outside geometry
70  Bool_t fIsOnBoundary; //! flag that current point is on some boundary
71  Bool_t fIsSameLocation; //! flag that a new point is in the same node as previous
72  Bool_t fIsNullStep; //! flag that last geometric step was null
73  TGeoManager *fGeometry; //! current geometry
74  TGeoNodeCache *fCache; //! cache of states
75  TGeoVolume *fCurrentVolume; //! current volume
76  TGeoNode *fCurrentNode; //! current node
77  TGeoNode *fTopNode; //! top physical node
78  TGeoNode *fLastNode; //! last searched node
79  TGeoNode *fNextNode; //! next node that will be crossed
80  TGeoNode *fForcedNode; //! current point is supposed to be inside this node
81  TGeoCacheState *fBackupState; //! backup state
82  TGeoHMatrix *fCurrentMatrix; //! current stored global matrix
83  TGeoHMatrix *fGlobalMatrix; //! current pointer to cached global matrix
84  TGeoHMatrix *fDivMatrix; //! current local matrix of the selected division cell
85  TString fPath; //! path to current node
86 
87 public :
88  TGeoNavigator();
90  virtual ~TGeoNavigator();
91 
92  void BuildCache(Bool_t dummy=kFALSE, Bool_t nodeid=kFALSE);
93  Bool_t cd(const char *path="");
94  Bool_t CheckPath(const char *path) const;
95  void CdNode(Int_t nodeid);
96  void CdDown(Int_t index);
97  void CdDown(TGeoNode *node);
98  void CdUp();
99  void CdTop();
100  void CdNext();
101  void GetBranchNames(Int_t *names) const;
102  void GetBranchNumbers(Int_t *copyNumbers, Int_t *volumeNumbers) const;
103  void GetBranchOnlys(Int_t *isonly) const;
104  Int_t GetNmany() const {return fNmany;}
105  //--- geometry queries
106  TGeoNode *CrossBoundaryAndLocate(Bool_t downwards, TGeoNode *skipnode);
107  TGeoNode *FindNextBoundary(Double_t stepmax=TGeoShape::Big(),const char *path="", Bool_t frombdr=kFALSE);
108  TGeoNode *FindNextDaughterBoundary(Double_t *point, Double_t *dir, Int_t &idaughter, Bool_t compmatrix=kFALSE);
110  TGeoNode *FindNode(Bool_t safe_start=kTRUE);
114  TGeoNode *InitTrack(const Double_t *point, const Double_t *dir);
116  void ResetState();
117  void ResetAll();
118  Double_t Safety(Bool_t inside=kFALSE);
119  TGeoNode *SearchNode(Bool_t downwards=kFALSE, const TGeoNode *skipnode=0);
120  TGeoNode *Step(Bool_t is_geom=kTRUE, Bool_t cross=kTRUE);
121  const Double_t *GetLastPoint() const {return fLastPoint;}
124  Int_t GetSafeLevel() const;
125  Double_t GetSafeDistance() const {return fSafety;}
127  Double_t GetStep() const {return fStep;}
128  Int_t GetThreadId() const {return fThreadId;}
129  void InspectState() const;
130  Bool_t IsSafeStep(Double_t proposed, Double_t &newsafety) const;
134  Bool_t IsStartSafe() const {return fStartSafe;}
135  void SetStartSafe(Bool_t flag=kTRUE) {fStartSafe=flag;}
136  void SetStep(Double_t step) {fStep=step;}
139  Bool_t IsEntering() const {return fIsEntering;}
140  Bool_t IsExiting() const {return fIsExiting;}
143  Bool_t IsOutside() const {return fIsOutside;}
145  Bool_t IsNullStep() const {return fIsNullStep;}
147  void SetOutside(Bool_t flag=kTRUE) {fIsOutside = flag;}
148  //--- modeler state getters/setters
149  void DoBackupState();
150  void DoRestoreState();
151  Int_t GetNodeId() const {return fCache->GetNodeId();}
153  TGeoNode *GetNextNode() const {return fNextNode;}
154  TGeoNode *GetMother(Int_t up=1) const {return fCache->GetMother(up);}
160  const Double_t *GetCurrentPoint() const {return fPoint;}
161  const Double_t *GetCurrentDirection() const {return fDirection;}
163  const Double_t *GetCldirChecked() const {return fCldirChecked;}
164  const Double_t *GetCldir() const {return fCldir;}
166 // Double_t GetNormalChecked() const {return fNormalChecked;}
167  const Double_t *GetNormal() const {return fNormal;}
168  Int_t GetLevel() const {return fLevel;}
169  const char *GetPath() const;
171  void SetCurrentPoint(const Double_t *point) {memcpy(fPoint,point,3*sizeof(Double_t));}
173  fPoint[0]=x; fPoint[1]=y; fPoint[2]=z;}
175  fLastPoint[0]=x; fLastPoint[1]=y; fLastPoint[2]=z;}
176  void SetCurrentDirection(const Double_t *dir) {memcpy(fDirection,dir,3*sizeof(Double_t));}
178  fDirection[0]=nx; fDirection[1]=ny; fDirection[2]=nz;}
179 // void SetNormalChecked(Double_t norm) {fNormalChecked=norm;}
180  void SetCldirChecked(Double_t *dir) {memcpy(fCldirChecked, dir, 3*sizeof(Double_t));}
181  void SetLastSafetyForPoint(Double_t safe, const Double_t *point) {fLastSafety=safe; memcpy(fLastPoint,point,3*sizeof(Double_t));}
183 
184  //--- point/vector reference frame conversion
185  void LocalToMaster(const Double_t *local, Double_t *master) const {fCache->LocalToMaster(local, master);}
186  void LocalToMasterVect(const Double_t *local, Double_t *master) const {fCache->LocalToMasterVect(local, master);}
187  void LocalToMasterBomb(const Double_t *local, Double_t *master) const {fCache->LocalToMasterBomb(local, master);}
188  void MasterToLocal(const Double_t *master, Double_t *local) const {fCache->MasterToLocal(master, local);}
189  void MasterToLocalVect(const Double_t *master, Double_t *local) const {fCache->MasterToLocalVect(master, local);}
190  void MasterToLocalBomb(const Double_t *master, Double_t *local) const {fCache->MasterToLocalBomb(master, local);}
191  void MasterToTop(const Double_t *master, Double_t *top) const;
192  void TopToMaster(const Double_t *top, Double_t *master) const;
193  TGeoNodeCache *GetCache() const {return fCache;}
194 // void SetCache(const TGeoNodeCache *cache) {fCache = (TGeoNodeCache*)cache;}
195  //--- stack manipulation
196  Int_t PushPath(Int_t startlevel=0) {return fCache->PushState(fCurrentOverlapping, startlevel, fNmany);}
199  Int_t PushPoint(Int_t startlevel=0) {return fCache->PushState(fCurrentOverlapping, startlevel,fNmany,fPoint);}
202  void PopDummy(Int_t ipop=9999) {fCache->PopDummy(ipop);}
203 
204  ClassDef(TGeoNavigator, 0) // geometry navigator class
205 };
206 
207 #include "TObjArray.h"
208 
209 ////////////////////////////////////////////////////////////////////////////
210 // //
211 // TGeoNavigatorArray - Class representing an array of navigators working //
212 // in a single thread. //
213 // //
214 ////////////////////////////////////////////////////////////////////////////
215 
217 {
218 private:
219  TGeoNavigator *fCurrentNavigator; // Current navigator
220  TGeoManager *fGeoManager; // Manager to which it applies
221 
224 
225 public:
228  virtual ~TGeoNavigatorArray() {}
229 
233 
234  ClassDef(TGeoNavigatorArray, 0) // An array of navigators
235 };
236 #endif
237 
Int_t fNmany
current geometry level;
Definition: TGeoNavigator.h:57
Int_t GetCurrentNodeId() const
Returns a fixed ID for current physical node.
Definition: TGeoCache.cxx:264
const Double_t * GetLastPoint() const
void GetBranchNames(Int_t *names) const
Fill volume names of current branch into an array.
Bool_t IsEntering() const
TGeoNode * CrossBoundaryAndLocate(Bool_t downwards, TGeoNode *skipnode)
Cross next boundary and locate within current node The current point must be on the boundary of fCurr...
Bool_t GotoSafeLevel()
Go upwards the tree until a non-overlapping node.
An array of TObjects.
Definition: TObjArray.h:37
void PopDummy(Int_t ipop=9999)
Definition: TGeoCache.h:124
TGeoNodeCache * fCache
current geometry
Definition: TGeoNavigator.h:74
The manager class for any TGeo geometry.
Definition: TGeoManager.h:42
TGeoNode * GetNextNode() const
Bool_t IsCurrentOverlapping() const
void SetCldirChecked(Double_t *dir)
void SetOutside(Bool_t flag=kTRUE)
TGeoNode * InitTrack(const Double_t *point, const Double_t *dir)
Initialize current point and current direction vector (normalized) in MARS.
Bool_t PopPath(Int_t index)
Geometrical transformation package.
Definition: TGeoMatrix.h:40
TGeoNavigator()
path to current node
TGeoManager * fGeometry
flag that last geometric step was null
Definition: TGeoNavigator.h:73
const Double_t * GetNormal() const
Int_t fOverlapMark
current size of fOverlapClusters
Definition: TGeoNavigator.h:60
Double_t fSafety
step to be done from current point and direction
Definition: TGeoNavigator.h:47
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
Int_t GetNmany() const
void GetBranchOnlys(Int_t *isonly) const
Fill node copy numbers of current branch into an array.
TGeoNode * fCurrentNode
current volume
Definition: TGeoNavigator.h:76
TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes.
Definition: TGeoVolume.h:42
Int_t GetSafeLevel() const
Go upwards the tree until a non-overlapping node.
Int_t GetNodeId() const
Get unique node id.
Definition: TGeoCache.cxx:273
Double_t GetLastSafety() const
void TopToMaster(const Double_t *top, Double_t *master) const
Convert coordinates from top volume frame to master.
Bool_t IsStepEntering() const
Bool_t fIsOnBoundary
flag that current point is outside geometry
Definition: TGeoNavigator.h:70
Basic string class.
Definition: TString.h:131
Matrix class used for computing global transformations Should NOT be used for node definition...
Definition: TGeoMatrix.h:420
TGeoNode * FindInCluster(Int_t *cluster, Int_t nc)
Find a node inside a cluster of overlapping nodes.
void SetLastSafetyForPoint(Double_t safe, const Double_t *point)
int Int_t
Definition: RtypesCore.h:41
Double_t GetSafeDistance() const
void MasterToLocalBomb(const Double_t *master, Double_t *local) const
bool Bool_t
Definition: RtypesCore.h:59
TGeoHMatrix * fDivMatrix
current pointer to cached global matrix
Definition: TGeoNavigator.h:84
TGeoNodeCache * GetCache() const
const Double_t * GetCurrentPoint() const
Double_t fCldir[3]
cosine of incident angle on current checked surface
Definition: TGeoNavigator.h:50
TObject * At(Int_t idx) const
Definition: TObjArray.h:166
Double_t fDirection[3]
current point
Definition: TGeoNavigator.h:53
TGeoNode * fLastNode
top physical node
Definition: TGeoNavigator.h:78
void LocalToMasterBomb(const Double_t *local, Double_t *master) const
Local point converted to master frame defined by current matrix and rescaled with bomb factor...
Definition: TGeoCache.cxx:435
Int_t fNextDaughterIndex
number of overlapping nodes on current branch
Definition: TGeoNavigator.h:58
TGeoHMatrix * fCurrentMatrix
backup state
Definition: TGeoNavigator.h:82
Double_t fNormal[3]
last computed safety radius
Definition: TGeoNavigator.h:49
void InspectState() const
Inspects path and all flags for the current state.
void DoRestoreState()
Restore a backed-up state without affecting the cache stack.
virtual ~TGeoNavigatorArray()
void CdNode(Int_t nodeid)
Change current path to point to the node having this id.
void MasterToTop(const Double_t *master, Double_t *top) const
Convert coordinates from master volume frame to top.
void LocalToMasterVect(const Double_t *local, Double_t *master) const
Local vector converted to master frame defined by current matrix.
Definition: TGeoCache.cxx:419
TGeoNavigator & operator=(const TGeoNavigator &)
assignment operator
Double_t x[n]
Definition: legend1.C:17
TGeoNode * FindNextDaughterBoundary(Double_t *point, Double_t *dir, Int_t &idaughter, Bool_t compmatrix=kFALSE)
Computes as fStep the distance to next daughter of the current volume.
#define ClassDef(name, id)
Definition: Rtypes.h:326
Double_t fStep
Definition: TGeoNavigator.h:46
Int_t GetThreadId() const
void PopDummy(Int_t ipop=9999)
Bool_t fIsNullStep
flag that a new point is in the same node as previous
Definition: TGeoNavigator.h:72
TGeoVolume * GetCurrentVolume() const
TGeoNavigator * GetCurrentNavigator() const
void SetStartSafe(Bool_t flag=kTRUE)
Bool_t CheckPath(const char *path) const
Check if a geometry path is valid without changing the state of the navigator.
Special pool of reusable nodes.
Definition: TGeoCache.h:53
Bool_t PopState(Int_t &nmany, Double_t *point=0)
Pop next state/point from heap.
Definition: TGeoCache.cxx:370
void ResetState()
Reset current state flags.
void SetStep(Double_t step)
TGeoNode * SearchNode(Bool_t downwards=kFALSE, const TGeoNode *skipnode=0)
Returns the deepest node containing fPoint, which must be set a priori.
void CdTop()
Make top level node the current node.
void LocalToMasterBomb(const Double_t *local, Double_t *master) const
Bool_t IsSameLocation() const
void GetBranchNumbers(Int_t *copyNumbers, Int_t *volumeNumbers) const
Fill node copy numbers of current branch into an array.
TGeoNode * FindNextBoundaryAndStep(Double_t stepmax=TGeoShape::Big(), Bool_t compsafe=kFALSE)
Compute distance to next boundary within STEPMAX.
TGeoHMatrix * GetCurrentMatrix() const
TGeoNavigator * AddNavigator()
Add a new navigator to the array.
Bool_t PopPath()
void SetLastSafetyForPoint(Double_t safe, Double_t x, Double_t y, Double_t z)
void BuildCache(Bool_t dummy=kFALSE, Bool_t nodeid=kFALSE)
Builds the cache for physical nodes and global matrices.
Bool_t cd(const char *path="")
Browse the tree of nodes starting from top node according to pathname.
void SetCurrentPoint(const Double_t *point)
Double_t Safety(Bool_t inside=kFALSE)
Compute safe distance from the current point.
Int_t GetNextDaughterIndex() const
void LocalToMaster(const Double_t *local, Double_t *master) const
const Double_t * GetCurrentDirection() const
const Double_t * GetCldirChecked() const
Bool_t IsStartSafe() const
TGeoNavigator * fCurrentNavigator
const Double_t * GetCldir() const
TGeoHMatrix * fGlobalMatrix
current stored global matrix
Definition: TGeoNavigator.h:83
void MasterToLocal(const Double_t *master, Double_t *local) const
Point in master frame defined by current matrix converted to local one.
Definition: TGeoCache.cxx:411
Int_t GetVirtualLevel()
Find level of virtuality of current overlapping node (number of levels up having the same tracking me...
Double_t fCldirChecked[3]
unit vector to current closest shape
Definition: TGeoNavigator.h:51
void MasterToLocalVect(const Double_t *master, Double_t *local) const
Double_t * FindNormal(Bool_t forward=kTRUE)
Computes normal vector to the next surface that will be or was already crossed when propagating on a ...
Bool_t fIsOutside
flag that next geometric step will exit current volume
Definition: TGeoNavigator.h:69
Double_t GetStep() const
void CdDown(Int_t index)
Make a daughter of current node current.
Bool_t IsStepExiting() const
void SafetyOverlaps()
Compute safe distance from the current point within an overlapping node.
Bool_t IsOutside() const
Bool_t fSearchOverlaps
internal array for overlaps
Definition: TGeoNavigator.h:62
TGeoManager * fGeoManager
Double_t fLastSafety
safety radius from current point
Definition: TGeoNavigator.h:48
void SetLastPoint(Double_t x, Double_t y, Double_t z)
Int_t GetStackLevel() const
Bool_t fIsStepEntering
flag that current track is about to leave current node
Definition: TGeoNavigator.h:67
TGeoHMatrix * GetDivMatrix() const
void SetCurrentPoint(Double_t x, Double_t y, Double_t z)
virtual ~TGeoNavigator()
Destructor.
void SetCurrentDirection(Double_t nx, Double_t ny, Double_t nz)
Bool_t PopPoint(Int_t index)
const Bool_t kFALSE
Definition: RtypesCore.h:88
Int_t fLevel
thread id for this navigator
Definition: TGeoNavigator.h:56
Bool_t IsExiting() const
Int_t PushPath(Int_t startlevel=0)
Bool_t PopPoint()
Double_t fPoint[3]
unit vector to current checked shape
Definition: TGeoNavigator.h:52
TGeoNode * GetNode() const
Definition: TGeoCache.h:103
Bool_t IsSamePoint(Double_t x, Double_t y, Double_t z) const
Check if a new point with given coordinates is the same as the last located one.
TGeoNode * fNextNode
last searched node
Definition: TGeoNavigator.h:79
TGeoNavigatorArray & operator=(const TGeoNavigatorArray &)
TString fPath
current local matrix of the selected division cell
Definition: TGeoNavigator.h:85
TGeoNode * GetMother(Int_t up=1) const
Definition: TGeoCache.h:101
void SetCurrentDirection(const Double_t *dir)
void CdUp()
Go one level up in geometry.
TGeoNavigator * SetCurrentNavigator(Int_t inav)
Int_t PushPoint(Int_t startlevel=0)
Bool_t IsNullStep() const
double Double_t
Definition: RtypesCore.h:55
Bool_t fIsEntering
flag a safe start for point classification
Definition: TGeoNavigator.h:65
TGeoNode * FindNextBoundary(Double_t stepmax=TGeoShape::Big(), const char *path="", Bool_t frombdr=kFALSE)
Find distance to next boundary and store it in fStep.
TGeoVolume * fCurrentVolume
cache of states
Definition: TGeoNavigator.h:75
void LocalToMasterVect(const Double_t *local, Double_t *master) const
Bool_t fIsSameLocation
flag that current point is on some boundary
Definition: TGeoNavigator.h:71
static RooMathCoreReg dummy
Double_t y[n]
Definition: legend1.C:17
Int_t GetTouchedCluster(Int_t start, Double_t *point, Int_t *check_list, Int_t ncheck, Int_t *result)
Make the cluster of overlapping nodes in a voxel, containing point in reference of the mother...
TGeoNode * GetMother(Int_t up=1) const
void forward(const LAYERDATA &prevLayerData, LAYERDATA &currLayerData)
apply the weights (and functions) in forward direction of the DNN
Definition: NeuralNet.icc:546
Int_t PushState(Bool_t ovlp, Int_t ntmany=0, Int_t startlevel=0, Double_t *point=0)
Push current state into heap.
Definition: TGeoCache.cxx:357
Int_t fThreadId
last point for which safety was computed
Definition: TGeoNavigator.h:55
TGeoNavigatorArray(TGeoManager *mgr)
static Double_t Big()
Definition: TGeoShape.h:88
Int_t GetLevel() const
void ResetAll()
Reset the navigator.
Bool_t IsSafeStep(Double_t proposed, Double_t &newsafety) const
In case a previous safety value was computed, check if the safety region is still safe for the curren...
void MasterToLocalVect(const Double_t *master, Double_t *local) const
Vector in master frame defined by current matrix converted to local one.
Definition: TGeoCache.cxx:427
TGeoHMatrix * GetHMatrix()
Return stored current matrix (global matrix of the next touched node).
Mother of all ROOT objects.
Definition: TObject.h:37
Double_t fLastPoint[3]
current direction
Definition: TGeoNavigator.h:54
you should not use this method at all Int_t Int_t z
Definition: TRolke.cxx:630
Bool_t fIsStepExiting
flag that next geometric step will enter new volume
Definition: TGeoNavigator.h:68
Class providing navigation API for TGeo geometries.
Definition: TGeoNavigator.h:33
void CdNext()
Do a cd to the node found next by FindNextBoundary.
void SetCheckingOverlaps(Bool_t flag=kTRUE)
A node represent a volume positioned inside another.They store links to both volumes and to the TGeoM...
Definition: TGeoNode.h:39
TGeoHMatrix * GetMotherMatrix(Int_t up=1) const
void MasterToLocalBomb(const Double_t *master, Double_t *local) const
Point in master frame defined by current matrix converted to local one and rescaled with bomb factor...
Definition: TGeoCache.cxx:443
Int_t GetNodeId() const
Class storing the state of the cache at a given moment.
Definition: TGeoCache.h:24
Int_t GetStackLevel() const
Definition: TGeoCache.h:110
TGeoNode * GetCurrentNode() const
TGeoNode * FindNode(Bool_t safe_start=kTRUE)
Returns deepest node containing current point.
void LocalToMaster(const Double_t *local, Double_t *master) const
Local point converted to master frame defined by current matrix.
Definition: TGeoCache.cxx:403
Int_t fOverlapSize
next daughter index after FindNextBoundary
Definition: TGeoNavigator.h:59
Bool_t fIsExiting
flag if current step just got into a new node
Definition: TGeoNavigator.h:66
TGeoNode * fForcedNode
next node that will be crossed
Definition: TGeoNavigator.h:80
Int_t GetCurrentNodeId() const
Bool_t IsOnBoundary() const
void DoBackupState()
Backup the current state without affecting the cache stack.
Double_t * FindNormalFast()
Computes fast normal to next crossed boundary, assuming that the current point is close enough to the...
Bool_t fStartSafe
flags the type of the current node
Definition: TGeoNavigator.h:64
const Bool_t kTRUE
Definition: RtypesCore.h:87
TGeoVolume * GetVolume() const
Definition: TGeoNode.h:97
const char * GetPath() const
Get path to the current node in the form /node0/node1/...
Bool_t IsCheckingOverlaps() const
TGeoNode * CrossDivisionCell()
Cross a division cell.
void MasterToLocal(const Double_t *master, Double_t *local) const
TGeoHMatrix * GetCurrentMatrix() const
Definition: TGeoCache.h:99
Int_t * fOverlapClusters
current recursive position in fOverlapClusters
Definition: TGeoNavigator.h:61
Int_t GetLevel() const
Definition: TGeoCache.h:108
TGeoNode * fTopNode
current node
Definition: TGeoNavigator.h:77
TGeoCacheState * fBackupState
current point is supposed to be inside this node
Definition: TGeoNavigator.h:81
Bool_t fCurrentOverlapping
flag set when an overlapping cluster is searched
Definition: TGeoNavigator.h:63
TGeoNode * Step(Bool_t is_geom=kTRUE, Bool_t cross=kTRUE)
Make a rectiliniar step of length fStep from current point (fPoint) on current direction (fDirection)...
TGeoHMatrix * GetMotherMatrix(Int_t up=1) const
Definition: TGeoCache.h:102