Logo ROOT   6.08/07
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 #ifndef ROOT_TObject
16 #include "TObject.h"
17 #endif
18 
19 #ifndef ROOT_TGeoNodeCache
20 #include "TGeoCache.h"
21 #endif
22 
23 ////////////////////////////////////////////////////////////////////////////
24 // //
25 // TGeoNavigator - Class containing the implementation of all navigation //
26 // methods.
27 // //
28 ////////////////////////////////////////////////////////////////////////////
29 
30 class TGeoManager;
31 class TGeoNode;
32 class TGeoVolume;
33 class TGeoMatrix;
34 class TGeoHMatrix;
35 
36 
37 class TGeoNavigator : public TObject
38 {
39 
40 protected:
43  TGeoNode *FindInCluster(Int_t *cluster, Int_t nc);
44  Int_t GetTouchedCluster(Int_t start, Double_t *point, Int_t *check_list,
45  Int_t ncheck, Int_t *result);
47  void SafetyOverlaps();
48 
49 private :
50  Double_t fStep; //! step to be done from current point and direction
51  Double_t fSafety; //! safety radius from current point
52  Double_t fLastSafety; //! last computed safety radius
53  Double_t fNormal[3]; //! cosine of incident angle on current checked surface
54  Double_t fCldir[3]; //! unit vector to current closest shape
55  Double_t fCldirChecked[3]; //! unit vector to current checked shape
56  Double_t fPoint[3]; //! current point
57  Double_t fDirection[3]; //! current direction
58  Double_t fLastPoint[3]; //! last point for which safety was computed
59  Int_t fThreadId; //! thread id for this navigator
60  Int_t fLevel; //! current geometry level;
61  Int_t fNmany; //! number of overlapping nodes on current branch
62  Int_t fNextDaughterIndex; //! next daughter index after FindNextBoundary
63  Int_t fOverlapSize; //! current size of fOverlapClusters
64  Int_t fOverlapMark; //! current recursive position in fOverlapClusters
65  Int_t *fOverlapClusters; //! internal array for overlaps
66  Bool_t fSearchOverlaps; //! flag set when an overlapping cluster is searched
67  Bool_t fCurrentOverlapping; //! flags the type of the current node
68  Bool_t fStartSafe; //! flag a safe start for point classification
69  Bool_t fIsEntering; //! flag if current step just got into a new node
70  Bool_t fIsExiting; //! flag that current track is about to leave current node
71  Bool_t fIsStepEntering; //! flag that next geometric step will enter new volume
72  Bool_t fIsStepExiting; //! flag that next geometric step will exit current volume
73  Bool_t fIsOutside; //! flag that current point is outside geometry
74  Bool_t fIsOnBoundary; //! flag that current point is on some boundary
75  Bool_t fIsSameLocation; //! flag that a new point is in the same node as previous
76  Bool_t fIsNullStep; //! flag that last geometric step was null
77  TGeoManager *fGeometry; //! current geometry
78  TGeoNodeCache *fCache; //! cache of states
79  TGeoVolume *fCurrentVolume; //! current volume
80  TGeoNode *fCurrentNode; //! current node
81  TGeoNode *fTopNode; //! top physical node
82  TGeoNode *fLastNode; //! last searched node
83  TGeoNode *fNextNode; //! next node that will be crossed
84  TGeoNode *fForcedNode; //! current point is supposed to be inside this node
85  TGeoCacheState *fBackupState; //! backup state
86  TGeoHMatrix *fCurrentMatrix; //! current stored global matrix
87  TGeoHMatrix *fGlobalMatrix; //! current pointer to cached global matrix
88  TGeoHMatrix *fDivMatrix; //! current local matrix of the selected division cell
89  TString fPath; //! path to current node
90 
91 public :
92  TGeoNavigator();
94  virtual ~TGeoNavigator();
95 
96  void BuildCache(Bool_t dummy=kFALSE, Bool_t nodeid=kFALSE);
97  Bool_t cd(const char *path="");
98  Bool_t CheckPath(const char *path) const;
99  void CdNode(Int_t nodeid);
100  void CdDown(Int_t index);
101  void CdDown(TGeoNode *node);
102  void CdUp();
103  void CdTop();
104  void CdNext();
105  void GetBranchNames(Int_t *names) const;
106  void GetBranchNumbers(Int_t *copyNumbers, Int_t *volumeNumbers) const;
107  void GetBranchOnlys(Int_t *isonly) const;
108  Int_t GetNmany() const {return fNmany;}
109  //--- geometry queries
110  TGeoNode *CrossBoundaryAndLocate(Bool_t downwards, TGeoNode *skipnode);
111  TGeoNode *FindNextBoundary(Double_t stepmax=TGeoShape::Big(),const char *path="", Bool_t frombdr=kFALSE);
112  TGeoNode *FindNextDaughterBoundary(Double_t *point, Double_t *dir, Int_t &idaughter, Bool_t compmatrix=kFALSE);
114  TGeoNode *FindNode(Bool_t safe_start=kTRUE);
118  TGeoNode *InitTrack(const Double_t *point, const Double_t *dir);
120  void ResetState();
121  void ResetAll();
122  Double_t Safety(Bool_t inside=kFALSE);
123  TGeoNode *SearchNode(Bool_t downwards=kFALSE, const TGeoNode *skipnode=0);
124  TGeoNode *Step(Bool_t is_geom=kTRUE, Bool_t cross=kTRUE);
125  const Double_t *GetLastPoint() const {return fLastPoint;}
128  Int_t GetSafeLevel() const;
129  Double_t GetSafeDistance() const {return fSafety;}
131  Double_t GetStep() const {return fStep;}
132  Int_t GetThreadId() const {return fThreadId;}
133  void InspectState() const;
134  Bool_t IsSafeStep(Double_t proposed, Double_t &newsafety) const;
138  Bool_t IsStartSafe() const {return fStartSafe;}
139  void SetStartSafe(Bool_t flag=kTRUE) {fStartSafe=flag;}
140  void SetStep(Double_t step) {fStep=step;}
143  Bool_t IsEntering() const {return fIsEntering;}
144  Bool_t IsExiting() const {return fIsExiting;}
147  Bool_t IsOutside() const {return fIsOutside;}
149  Bool_t IsNullStep() const {return fIsNullStep;}
150  void SetCheckingOverlaps(Bool_t flag=kTRUE) {fSearchOverlaps = flag;}
151  void SetOutside(Bool_t flag=kTRUE) {fIsOutside = flag;}
152  //--- modeler state getters/setters
153  void DoBackupState();
154  void DoRestoreState();
155  Int_t GetNodeId() const {return fCache->GetNodeId();}
157  TGeoNode *GetNextNode() const {return fNextNode;}
158  TGeoNode *GetMother(Int_t up=1) const {return fCache->GetMother(up);}
159  TGeoHMatrix *GetMotherMatrix(Int_t up=1) const {return fCache->GetMotherMatrix(up);}
161  TGeoHMatrix *GetCurrentMatrix() const {return fCache->GetCurrentMatrix();}
163  Int_t GetCurrentNodeId() const {return fCache->GetCurrentNodeId();}
164  const Double_t *GetCurrentPoint() const {return fPoint;}
165  const Double_t *GetCurrentDirection() const {return fDirection;}
166  TGeoVolume *GetCurrentVolume() const {return fCurrentNode->GetVolume();}
167  const Double_t *GetCldirChecked() const {return fCldirChecked;}
168  const Double_t *GetCldir() const {return fCldir;}
170 // Double_t GetNormalChecked() const {return fNormalChecked;}
171  const Double_t *GetNormal() const {return fNormal;}
172  Int_t GetLevel() const {return fLevel;}
173  const char *GetPath() const;
174  Int_t GetStackLevel() const {return fCache->GetStackLevel();}
175  void SetCurrentPoint(const Double_t *point) {memcpy(fPoint,point,3*sizeof(Double_t));}
177  fPoint[0]=x; fPoint[1]=y; fPoint[2]=z;}
179  fLastPoint[0]=x; fLastPoint[1]=y; fLastPoint[2]=z;}
180  void SetCurrentDirection(const Double_t *dir) {memcpy(fDirection,dir,3*sizeof(Double_t));}
182  fDirection[0]=nx; fDirection[1]=ny; fDirection[2]=nz;}
183 // void SetNormalChecked(Double_t norm) {fNormalChecked=norm;}
184  void SetCldirChecked(Double_t *dir) {memcpy(fCldirChecked, dir, 3*sizeof(Double_t));}
185  void SetLastSafetyForPoint(Double_t safe, const Double_t *point) {fLastSafety=safe; memcpy(fLastPoint,point,3*sizeof(Double_t));}
186  void SetLastSafetyForPoint(Double_t safe, Double_t x, Double_t y, Double_t z) {fLastSafety=safe; fLastPoint[0]=x; fLastPoint[1]=y, fLastPoint[2]=z;}
187 
188  //--- point/vector reference frame conversion
189  void LocalToMaster(const Double_t *local, Double_t *master) const {fCache->LocalToMaster(local, master);}
190  void LocalToMasterVect(const Double_t *local, Double_t *master) const {fCache->LocalToMasterVect(local, master);}
191  void LocalToMasterBomb(const Double_t *local, Double_t *master) const {fCache->LocalToMasterBomb(local, master);}
192  void MasterToLocal(const Double_t *master, Double_t *local) const {fCache->MasterToLocal(master, local);}
193  void MasterToLocalVect(const Double_t *master, Double_t *local) const {fCache->MasterToLocalVect(master, local);}
194  void MasterToLocalBomb(const Double_t *master, Double_t *local) const {fCache->MasterToLocalBomb(master, local);}
195  void MasterToTop(const Double_t *master, Double_t *top) const;
196  void TopToMaster(const Double_t *top, Double_t *master) const;
197  TGeoNodeCache *GetCache() const {return fCache;}
198 // void SetCache(const TGeoNodeCache *cache) {fCache = (TGeoNodeCache*)cache;}
199  //--- stack manipulation
200  Int_t PushPath(Int_t startlevel=0) {return fCache->PushState(fCurrentOverlapping, startlevel, fNmany);}
201  Bool_t PopPath() {fCurrentOverlapping=fCache->PopState(fNmany); fCurrentNode=fCache->GetNode(); fLevel=fCache->GetLevel();fGlobalMatrix=fCache->GetCurrentMatrix();return fCurrentOverlapping;}
202  Bool_t PopPath(Int_t index) {fCurrentOverlapping=fCache->PopState(fNmany,index); fCurrentNode=fCache->GetNode(); fLevel=fCache->GetLevel();fGlobalMatrix=fCache->GetCurrentMatrix();return fCurrentOverlapping;}
203  Int_t PushPoint(Int_t startlevel=0) {return fCache->PushState(fCurrentOverlapping, startlevel,fNmany,fPoint);}
204  Bool_t PopPoint() {fCurrentOverlapping=fCache->PopState(fNmany,fPoint); fCurrentNode=fCache->GetNode(); fLevel=fCache->GetLevel(); fGlobalMatrix=fCache->GetCurrentMatrix();return fCurrentOverlapping;}
205  Bool_t PopPoint(Int_t index) {fCurrentOverlapping=fCache->PopState(fNmany,index, fPoint); fCurrentNode=fCache->GetNode(); fLevel=fCache->GetLevel(); fGlobalMatrix=fCache->GetCurrentMatrix();return fCurrentOverlapping;}
206  void PopDummy(Int_t ipop=9999) {fCache->PopDummy(ipop);}
207 
208  ClassDef(TGeoNavigator, 0) // geometry navigator class
209 };
210 
211 #ifndef ROOT_TObjArray
212 #include "TObjArray.h"
213 #endif
214 
215 ////////////////////////////////////////////////////////////////////////////
216 // //
217 // TGeoNavigatorArray - Class representing an array of navigators working //
218 // in a single thread. //
219 // //
220 ////////////////////////////////////////////////////////////////////////////
221 
223 {
224 private:
225  TGeoNavigator *fCurrentNavigator; // Current navigator
226  TGeoManager *fGeoManager; // Manager to which it applies
227 
230 
231 public:
232  TGeoNavigatorArray() : TObjArray(), fCurrentNavigator(0), fGeoManager(0) {}
233  TGeoNavigatorArray(TGeoManager *mgr) : TObjArray(), fCurrentNavigator(0), fGeoManager(mgr) {SetOwner();}
234  virtual ~TGeoNavigatorArray() {}
235 
236  TGeoNavigator *AddNavigator();
237  inline TGeoNavigator *GetCurrentNavigator() const {return fCurrentNavigator;}
238  TGeoNavigator *SetCurrentNavigator(Int_t inav) {return (fCurrentNavigator=(TGeoNavigator*)At(inav));}
239 
240  ClassDef(TGeoNavigatorArray, 0) // An array of navigators
241 };
242 #endif
243 
Int_t fNmany
current geometry level;
Definition: TGeoNavigator.h:61
const int nx
Definition: kalman.C:16
Int_t GetCurrentNodeId() const
Returns a fixed ID for current physical node.
Definition: TGeoCache.cxx:260
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:39
void PopDummy(Int_t ipop=9999)
Definition: TGeoCache.h:128
TGeoNodeCache * fCache
current geometry
Definition: TGeoNavigator.h:78
The manager class for any TGeo geometry.
Definition: TGeoManager.h:38
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:77
const Double_t * GetNormal() const
Int_t fOverlapMark
current size of fOverlapClusters
Definition: TGeoNavigator.h:64
Double_t fSafety
step to be done from current point and direction
Definition: TGeoNavigator.h:51
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:80
TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes.
Definition: TGeoVolume.h:61
Int_t GetSafeLevel() const
Go upwards the tree until a non-overlapping node.
Int_t GetNodeId() const
Get unique node id.
Definition: TGeoCache.cxx:269
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:74
Basic string class.
Definition: TString.h:137
Matrix class used for computing global transformations Should NOT be used for node definition...
Definition: TGeoMatrix.h:410
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:88
TGeoNodeCache * GetCache() const
const Bool_t kFALSE
Definition: Rtypes.h:92
const Double_t * GetCurrentPoint() const
Double_t fCldir[3]
cosine of incident angle on current checked surface
Definition: TGeoNavigator.h:54
Double_t fDirection[3]
current point
Definition: TGeoNavigator.h:57
TGeoNode * fLastNode
top physical node
Definition: TGeoNavigator.h:82
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:431
Int_t fNextDaughterIndex
number of overlapping nodes on current branch
Definition: TGeoNavigator.h:62
TGeoHMatrix * fCurrentMatrix
backup state
Definition: TGeoNavigator.h:86
Double_t fNormal[3]
last computed safety radius
Definition: TGeoNavigator.h:53
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:415
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:254
Double_t fStep
Definition: TGeoNavigator.h:50
Int_t GetThreadId() const
void PopDummy(Int_t ipop=9999)
const int ny
Definition: kalman.C:17
Bool_t fIsNullStep
flag that a new point is in the same node as previous
Definition: TGeoNavigator.h:76
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:57
Bool_t PopState(Int_t &nmany, Double_t *point=0)
Pop next state/point from heap.
Definition: TGeoCache.cxx:366
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
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:87
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:407
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:55
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:73
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:66
TGeoManager * fGeoManager
Double_t fLastSafety
safety radius from current point
Definition: TGeoNavigator.h:52
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:71
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)
Int_t fLevel
thread id for this navigator
Definition: TGeoNavigator.h:60
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:56
TGeoNode * GetNode() const
Definition: TGeoCache.h:107
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:83
TString fPath
current local matrix of the selected division cell
Definition: TGeoNavigator.h:89
TGeoNode * GetMother(Int_t up=1) const
Definition: TGeoCache.h:105
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:69
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:79
void LocalToMasterVect(const Double_t *local, Double_t *master) const
Bool_t fIsSameLocation
flag that current point is on some boundary
Definition: TGeoNavigator.h:75
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:539
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:353
Int_t fThreadId
last point for which safety was computed
Definition: TGeoNavigator.h:59
TGeoNavigatorArray(TGeoManager *mgr)
static Double_t Big()
Definition: TGeoShape.h:90
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:423
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:58
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:72
Class providing navigation API for TGeo geometries.
Definition: TGeoNavigator.h:37
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:51
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:439
Int_t GetNodeId() const
Class storing the state of the cache at a given moment.
Definition: TGeoCache.h:28
Int_t GetStackLevel() const
Definition: TGeoCache.h:114
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:399
Int_t fOverlapSize
next daughter index after FindNextBoundary
Definition: TGeoNavigator.h:63
double result[121]
Bool_t fIsExiting
flag if current step just got into a new node
Definition: TGeoNavigator.h:70
TGeoNode * fForcedNode
next node that will be crossed
Definition: TGeoNavigator.h:84
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...
const Bool_t kTRUE
Definition: Rtypes.h:91
Bool_t fStartSafe
flags the type of the current node
Definition: TGeoNavigator.h:68
TGeoVolume * GetVolume() const
Definition: TGeoNode.h:106
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:103
Int_t * fOverlapClusters
current recursive position in fOverlapClusters
Definition: TGeoNavigator.h:65
Int_t GetLevel() const
Definition: TGeoCache.h:112
TGeoNode * fTopNode
current node
Definition: TGeoNavigator.h:81
TGeoCacheState * fBackupState
current point is supposed to be inside this node
Definition: TGeoNavigator.h:85
Bool_t fCurrentOverlapping
flag set when an overlapping cluster is searched
Definition: TGeoNavigator.h:67
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:106