Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
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:
37  TGeoNavigator(const TGeoNavigator&);
38  TGeoNavigator& operator=(const TGeoNavigator&);
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);
42  TGeoNode *CrossDivisionCell();
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();
89  TGeoNavigator(TGeoManager* geom);
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);
109  TGeoNode *FindNextBoundaryAndStep(Double_t stepmax=TGeoShape::Big(), Bool_t compsafe=kFALSE);
110  TGeoNode *FindNode(Bool_t safe_start=kTRUE);
111  TGeoNode *FindNode(Double_t x, Double_t y, Double_t z);
112  Double_t *FindNormal(Bool_t forward=kTRUE);
113  Double_t *FindNormalFast();
114  TGeoNode *InitTrack(const Double_t *point, const Double_t *dir);
115  TGeoNode *InitTrack(Double_t x, Double_t y, Double_t z, Double_t nx, Double_t ny, Double_t nz);
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;}
122  Int_t GetVirtualLevel();
123  Bool_t GotoSafeLevel();
124  Int_t GetSafeLevel() const;
125  Double_t GetSafeDistance() const {return fSafety;}
126  Double_t GetLastSafety() const {return fLastSafety;}
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;
131  Bool_t IsSameLocation(Double_t x, Double_t y, Double_t z, Bool_t change=kFALSE);
132  Bool_t IsSameLocation() const {return fIsSameLocation;}
133  Bool_t IsSamePoint(Double_t x, Double_t y, Double_t z) 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;}
137  Bool_t IsCheckingOverlaps() const {return fSearchOverlaps;}
138  Bool_t IsCurrentOverlapping() const {return fCurrentOverlapping;}
139  Bool_t IsEntering() const {return fIsEntering;}
140  Bool_t IsExiting() const {return fIsExiting;}
141  Bool_t IsStepEntering() const {return fIsStepEntering;}
142  Bool_t IsStepExiting() const {return fIsStepExiting;}
143  Bool_t IsOutside() const {return fIsOutside;}
144  Bool_t IsOnBoundary() const {return fIsOnBoundary;}
145  Bool_t IsNullStep() const {return fIsNullStep;}
146  void SetCheckingOverlaps(Bool_t flag=kTRUE) {fSearchOverlaps = flag;}
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();}
152  Int_t GetNextDaughterIndex() const {return fNextDaughterIndex;}
153  TGeoNode *GetNextNode() const {return fNextNode;}
154  TGeoNode *GetMother(Int_t up=1) const {return fCache->GetMother(up);}
155  TGeoHMatrix *GetMotherMatrix(Int_t up=1) const {return fCache->GetMotherMatrix(up);}
156  TGeoHMatrix *GetHMatrix();
157  TGeoHMatrix *GetCurrentMatrix() const {return fCache->GetCurrentMatrix();}
158  TGeoNode *GetCurrentNode() const {return fCurrentNode;}
159  Int_t GetCurrentNodeId() const {return fCache->GetCurrentNodeId();}
160  const Double_t *GetCurrentPoint() const {return fPoint;}
161  const Double_t *GetCurrentDirection() const {return fDirection;}
162  TGeoVolume *GetCurrentVolume() const {return fCurrentNode->GetVolume();}
163  const Double_t *GetCldirChecked() const {return fCldirChecked;}
164  const Double_t *GetCldir() const {return fCldir;}
165  TGeoHMatrix *GetDivMatrix() const {return fDivMatrix;}
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;
170  Int_t GetStackLevel() const {return fCache->GetStackLevel();}
171  void SetCurrentPoint(const Double_t *point) {memcpy(fPoint,point,3*sizeof(Double_t));}
172  void SetCurrentPoint(Double_t x, Double_t y, Double_t z) {
173  fPoint[0]=x; fPoint[1]=y; fPoint[2]=z;}
174  void SetLastPoint(Double_t x, Double_t y, Double_t 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));}
177  void SetCurrentDirection(Double_t nx, Double_t ny, Double_t nz) {
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));}
182  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;}
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);}
197  Bool_t PopPath() {fCurrentOverlapping=fCache->PopState(fNmany); fCurrentNode=fCache->GetNode(); fLevel=fCache->GetLevel();fGlobalMatrix=fCache->GetCurrentMatrix();return fCurrentOverlapping;}
198  Bool_t PopPath(Int_t index) {fCurrentOverlapping=fCache->PopState(fNmany,index); fCurrentNode=fCache->GetNode(); fLevel=fCache->GetLevel();fGlobalMatrix=fCache->GetCurrentMatrix();return fCurrentOverlapping;}
199  Int_t PushPoint(Int_t startlevel=0) {return fCache->PushState(fCurrentOverlapping, startlevel,fNmany,fPoint);}
200  Bool_t PopPoint() {fCurrentOverlapping=fCache->PopState(fNmany,fPoint); fCurrentNode=fCache->GetNode(); fLevel=fCache->GetLevel(); fGlobalMatrix=fCache->GetCurrentMatrix();return fCurrentOverlapping;}
201  Bool_t PopPoint(Int_t index) {fCurrentOverlapping=fCache->PopState(fNmany,index, fPoint); fCurrentNode=fCache->GetNode(); fLevel=fCache->GetLevel(); fGlobalMatrix=fCache->GetCurrentMatrix();return fCurrentOverlapping;}
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 
216 class TGeoNavigatorArray : public TObjArray
217 {
218 private:
219  TGeoNavigator *fCurrentNavigator; // Current navigator
220  TGeoManager *fGeoManager; // Manager to which it applies
221 
222  TGeoNavigatorArray(const TGeoNavigatorArray&);
223  TGeoNavigatorArray& operator=(const TGeoNavigatorArray&);
224 
225 public:
226  TGeoNavigatorArray() : TObjArray(), fCurrentNavigator(0), fGeoManager(0) {}
227  TGeoNavigatorArray(TGeoManager *mgr) : TObjArray(), fCurrentNavigator(0), fGeoManager(mgr) {SetOwner();}
228  virtual ~TGeoNavigatorArray() {}
229 
230  TGeoNavigator *AddNavigator();
231  inline TGeoNavigator *GetCurrentNavigator() const {return fCurrentNavigator;}
232  TGeoNavigator *SetCurrentNavigator(Int_t inav) {return (fCurrentNavigator=(TGeoNavigator*)At(inav));}
233 
234  ClassDef(TGeoNavigatorArray, 0) // An array of navigators
235 };
236 #endif
237