Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
TGeoManager.h
Go to the documentation of this file.
1 // @(#)root/geom:$Id$
2 // Author: Andrei Gheata 25/10/01
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_TGeoManager
13 #define ROOT_TGeoManager
14 
15 #include <mutex>
16 #include <thread>
17 
18 #include "TObjArray.h"
19 #include "TGeoNavigator.h"
20 
21 // forward declarations
22 class TVirtualGeoTrack;
23 class TGeoNode;
24 class TGeoPhysicalNode;
25 class TGeoPNEntry;
26 class TGeoVolume;
27 class TGeoVolumeMulti;
28 class TGeoMatrix;
29 class TGeoHMatrix;
30 class TGeoMaterial;
31 class TGeoMedium;
32 class TGeoShape;
33 class TVirtualGeoPainter;
34 class THashList;
35 class TGeoParallelWorld;
36 class TGeoRegion;
37 class TGDMLMatrix;
38 class TGeoOpticalSurface;
39 class TGeoSkinSurface;
40 class TGeoBorderSurface;
41 
42 class TGeoManager : public TNamed
43 {
44 public:
45  enum EDefaultUnits {
46  kG4Units = 0,
47  kRootUnits = 1
48  };
49 
50 protected:
51  static std::mutex fgMutex; //! mutex for navigator booking in MT mode
52  static Bool_t fgLock; //! Lock preventing a second geometry to be loaded
53  static Int_t fgVerboseLevel; //! Verbosity level for Info messages (no IO).
54  static Int_t fgMaxLevel; //! Maximum level in geometry
55  static Int_t fgMaxDaughters; //! Maximum number of daughters
56  static Int_t fgMaxXtruVert; //! Maximum number of Xtru vertices
57  static UInt_t fgExportPrecision; //! Precision to be used in ASCII exports
58  static EDefaultUnits fgDefaultUnits; //! Default units in GDML if not explicit in some tags
59 
60  TGeoManager(const TGeoManager&);
61  TGeoManager& operator=(const TGeoManager&);
62 
63 private :
64  Double_t fPhimin; //! lowest range for phi cut
65  Double_t fPhimax; //! highest range for phi cut
66  Double_t fTmin; //! lower time limit for tracks drawing
67  Double_t fTmax; //! upper time limit for tracks drawing
68  Int_t fNNodes; // total number of physical nodes
69  TString fPath; //! path to current node
70  TString fParticleName; //! particles to be drawn
71  Double_t fVisDensity; // transparency threshold by density
72  Int_t fExplodedView; // exploded view mode
73  Int_t fVisOption; // global visualization option
74  Int_t fVisLevel; // maximum visualization depth
75  Int_t fNsegments; // number of segments to approximate circles
76  Int_t fNtracks; // number of tracks
77  Int_t fMaxVisNodes; // maximum number of visible nodes
78  TVirtualGeoTrack *fCurrentTrack; //! current track
79  Int_t fNpdg; // number of different pdg's stored
80  Int_t fPdgId[1024]; // pdg conversion table
81  Bool_t fClosed; //! flag that geometry is closed
82  Bool_t fLoopVolumes; //! flag volume lists loop
83  Bool_t fStreamVoxels; // flag to allow voxelization I/O
84  Bool_t fIsGeomReading; //! flag set when reading geometry
85  Bool_t fIsGeomCleaning; //! flag to notify that the manager is being destructed
86  Bool_t fPhiCut; // flag for phi cuts
87  Bool_t fTimeCut; // time cut for tracks
88  Bool_t fDrawExtra; //! flag that the list of physical nodes has to be drawn
89  Bool_t fMatrixTransform; //! flag for using GL matrix
90  Bool_t fMatrixReflection; //! flag for GL reflections
91  Bool_t fActivity; //! switch ON/OFF volume activity (default OFF - all volumes active))
92  Bool_t fIsNodeSelectable; //! flag that nodes are the selected objects in pad rather than volumes
93  TVirtualGeoPainter *fPainter; //! current painter
94 
95  TObjArray *fMatrices; //-> list of local transformations
96  TObjArray *fShapes; //-> list of shapes
97  TObjArray *fVolumes; //-> list of volumes
98  TObjArray *fPhysicalNodes; //-> list of physical nodes
99  TObjArray *fGShapes; //! list of runtime shapes
100  TObjArray *fGVolumes; //! list of runtime volumes
101  TObjArray *fTracks; //-> list of tracks attached to geometry
102  TObjArray *fPdgNames; //-> list of pdg names for tracks
103  TObjArray *fGDMLMatrices; //-> list of matrices read from GDML
104  TObjArray *fOpticalSurfaces; //-> list of optical surfaces read from GDML
105  TObjArray *fSkinSurfaces; //-> list of skin surfaces read from GDML
106  TObjArray *fBorderSurfaces; //-> list of border surfaces read from GDML
107  TList *fMaterials; //-> list of materials
108  TList *fMedia; //-> list of tracking media
109  TObjArray *fNodes; //-> current branch of nodes
110  TObjArray *fOverlaps; //-> list of geometrical overlaps
111  TObjArray *fRegions; //-> list of regions
112  UChar_t *fBits; //! bits used for voxelization
113  // Map of navigator arrays per thread
114  typedef std::map<std::thread::id, TGeoNavigatorArray *> NavigatorsMap_t;
115  typedef NavigatorsMap_t::iterator NavigatorsMapIt_t;
116  typedef std::map<std::thread::id, Int_t> ThreadsMap_t;
117  typedef ThreadsMap_t::const_iterator ThreadsMapIt_t;
118  // Map of constant properties
119  typedef std::map<std::string, Double_t> ConstPropMap_t;
120 
121  NavigatorsMap_t fNavigators; //! Map between thread id's and navigator arrays
122  static ThreadsMap_t *fgThreadId; //! Thread id's map
123  static Int_t fgNumThreads; //! Number of registered threads
124  static Bool_t fgLockNavigators; //! Lock existing navigators
125  TGeoNavigator *fCurrentNavigator; //! current navigator
126  TGeoVolume *fCurrentVolume; //! current volume
127  TGeoVolume *fTopVolume; //! top level volume in geometry
128  TGeoNode *fTopNode; //! top physical node
129  TGeoVolume *fMasterVolume; // master volume
130  TGeoHMatrix *fGLMatrix; // matrix to be used for view transformations
131  TObjArray *fUniqueVolumes; //-> list of unique volumes
132  TGeoShape *fClippingShape; //! clipping shape for raytracing
133  TGeoElementTable *fElementTable; //! table of elements
134 
135  Int_t *fNodeIdArray; //! array of node id's
136  Int_t fNLevel; // maximum accepted level in geometry
137  TGeoVolume *fPaintVolume; //! volume currently painted
138  TGeoVolume *fUserPaintVolume; //!
139  THashList *fHashVolumes; //! hash list of volumes providing fast search
140  THashList *fHashGVolumes; //! hash list of group volumes providing fast search
141  THashList *fHashPNE; //-> hash list of physical node entries
142  mutable TObjArray *fArrayPNE; //! array of physical node entries
143  Int_t fSizePNEId; // size of the array of unique ID's for PN entries
144  Int_t fNPNEId; // number of PN entries having a unique ID
145  Int_t *fKeyPNEId; //[fSizePNEId] array of uid values for PN entries
146  Int_t *fValuePNEId; //[fSizePNEId] array of pointers to PN entries with ID's
147  Int_t fMaxThreads; //! Max number of threads
148  Bool_t fMultiThread; //! Flag for multi-threading
149  Int_t fRaytraceMode; //! Raytrace mode: 0=normal, 1=pass through, 2=transparent
150  Bool_t fUsePWNav; // Activate usage of parallel world in navigation
151  TGeoParallelWorld *fParallelWorld; // Parallel world
152  ConstPropMap_t fProperties; // Map of user-defined constant properties
153 //--- private methods
154  Bool_t IsLoopingVolumes() const {return fLoopVolumes;}
155  void Init();
156  Bool_t InitArrayPNE() const;
157  Bool_t InsertPNEId(Int_t uid, Int_t ientry);
158  void SetLoopVolumes(Bool_t flag=kTRUE) {fLoopVolumes=flag;}
159  void UpdateElements();
160  void Voxelize(Option_t *option = 0);
161 
162 public:
163  // constructors
164  TGeoManager();
165  TGeoManager(const char *name, const char *title);
166  // destructor
167  virtual ~TGeoManager();
168  //--- adding geometrical objects
169  Int_t AddMaterial(const TGeoMaterial *material);
170  Int_t AddOverlap(const TNamed *ovlp);
171  Int_t AddRegion(TGeoRegion *region);
172  Int_t AddTransformation(const TGeoMatrix *matrix);
173  Int_t AddShape(const TGeoShape *shape);
174  Int_t AddTrack(Int_t id, Int_t pdgcode, TObject *particle=0);
175  Int_t AddTrack(TVirtualGeoTrack *track);
176  Int_t AddVolume(TGeoVolume *volume);
177  TGeoNavigator *AddNavigator();
178  Bool_t AddProperty(const char *property, Double_t value);
179  Double_t GetProperty(const char *name, Bool_t *error = nullptr) const;
180  Double_t GetProperty(size_t i, TString &name, Bool_t *error = nullptr) const;
181  Int_t GetNproperties() const { return fProperties.size(); }
182  void ClearOverlaps();
183  void RegisterMatrix(const TGeoMatrix *matrix);
184  void SortOverlaps();
185  //--- browsing and tree navigation
186  void Browse(TBrowser *b);
187  void SetVisibility(TObject *obj, Bool_t vis);
188  virtual Bool_t cd(const char *path=""); // *MENU*
189  Bool_t CheckPath(const char *path) const;
190  void CdNode(Int_t nodeid);
191  void CdDown(Int_t index);
192  void CdUp();
193  void CdTop();
194  void CdNext();
195  void GetBranchNames(Int_t *names) const;
196  void GetBranchNumbers(Int_t *copyNumbers, Int_t *volumeNumbers) const;
197  void GetBranchOnlys(Int_t *isonly) const;
198  Int_t GetNmany() const {return GetCurrentNavigator()->GetNmany();}
199  const char *GetPdgName(Int_t pdg) const;
200  void SetPdgName(Int_t pdg, const char *name);
201  Bool_t IsFolder() const { return kTRUE; }
202  //--- visualization settings
203  virtual void Edit(Option_t *option=""); // *MENU*
204  void BombTranslation(const Double_t *tr, Double_t *bombtr);
205  void UnbombTranslation(const Double_t *tr, Double_t *bombtr);
206  void ClearAttributes(); // *MENU*
207  void DefaultAngles(); // *MENU*
208  void DefaultColors(); // *MENU*
209  TGeoShape *GetClippingShape() const {return fClippingShape;}
210  Int_t GetNsegments() const;
211  TVirtualGeoPainter *GetGeomPainter();
212  TVirtualGeoPainter *GetPainter() const {return fPainter;}
213  Int_t GetBombMode() const {return fExplodedView;}
214  void GetBombFactors(Double_t &bombx, Double_t &bomby, Double_t &bombz, Double_t &bombr) const;
215  Int_t GetMaxVisNodes() const {return fMaxVisNodes;}
216  Bool_t GetTminTmax(Double_t &tmin, Double_t &tmax) const;
217  Double_t GetTmax() const {return fTmax;}
218  TGeoVolume *GetPaintVolume() const {return fPaintVolume;}
219  TGeoVolume *GetUserPaintVolume() const {return fUserPaintVolume;}
220  Double_t GetVisDensity() const {return fVisDensity;}
221  Int_t GetVisLevel() const;
222  Int_t GetVisOption() const;
223  Bool_t IsInPhiRange() const;
224  Bool_t IsDrawingExtra() const {return fDrawExtra;}
225  Bool_t IsNodeSelectable() const {return fIsNodeSelectable;}
226  Bool_t IsVisLeaves() const {return (fVisOption==1)?kTRUE:kFALSE;}
227  void ModifiedPad() const;
228  void OptimizeVoxels(const char *filename="tgeovox.C"); // *MENU*
229  void SetClipping(Bool_t flag=kTRUE) {SetClippingShape(((flag)?fClippingShape:0));} // *MENU*
230  void SetClippingShape(TGeoShape *clip);
231  void SetExplodedView(Int_t iopt=0); // *MENU*
232  void SetPhiRange(Double_t phimin=0., Double_t phimax=360.);
233  void SetNsegments(Int_t nseg); // *MENU*
234  Bool_t SetCurrentNavigator(Int_t index);
235  void SetBombFactors(Double_t bombx=1.3, Double_t bomby=1.3, Double_t bombz=1.3, Double_t bombr=1.3); // *MENU*
236  void SetPaintVolume(TGeoVolume *vol) {fPaintVolume = vol;}
237  void SetUserPaintVolume(TGeoVolume *vol) {fUserPaintVolume = vol;}
238  void SetTopVisible(Bool_t vis=kTRUE);
239  void SetTminTmax(Double_t tmin=0, Double_t tmax=999);
240  void SetDrawExtraPaths(Bool_t flag=kTRUE) {fDrawExtra=flag;}
241  void SetNodeSelectable(Bool_t flag=kTRUE) {fIsNodeSelectable=flag;}
242  void SetVisDensity(Double_t dens=0.01); // *MENU*
243  void SetVisLevel(Int_t level=3); // *MENU*
244  void SetVisOption(Int_t option=0);
245  void ViewLeaves(Bool_t flag=kTRUE); // *TOGGLE* *GETTER=IsVisLeaves
246  void SaveAttributes(const char *filename="tgeoatt.C"); // *MENU*
247  void RestoreMasterVolume(); // *MENU*
248  void SetMaxVisNodes(Int_t maxnodes=10000); // *MENU*
249  //--- geometry checking
250  void AnimateTracks(Double_t tmin=0, Double_t tmax=5E-8, Int_t nframes=200, Option_t *option="/*"); // *MENU*
251  void CheckBoundaryErrors(Int_t ntracks=1000000, Double_t radius=-1.); // *MENU*
252  void CheckBoundaryReference(Int_t icheck=-1);
253  void CheckGeometryFull(Int_t ntracks=1000000, Double_t vx=0., Double_t vy=0., Double_t vz=0., Option_t *option="ob"); // *MENU*
254  void CheckGeometry(Option_t *option="");
255  void CheckOverlaps(Double_t ovlp=0.1, Option_t *option=""); // *MENU*
256  void CheckPoint(Double_t x=0,Double_t y=0, Double_t z=0, Option_t *option=""); // *MENU*
257  void CheckShape(TGeoShape *shape, Int_t testNo, Int_t nsamples, Option_t *option);
258  void ConvertReflections();
259  void DrawCurrentPoint(Int_t color=2); // *MENU*
260  void DrawTracks(Option_t *option=""); // *MENU*
261  void SetParticleName(const char *pname) {fParticleName=pname;}
262  const char *GetParticleName() const {return fParticleName.Data();}
263  void DrawPath(const char *path, Option_t *option="");
264  void PrintOverlaps() const; // *MENU*
265  void RandomPoints(const TGeoVolume *vol, Int_t npoints=10000, Option_t *option="");
266  void RandomRays(Int_t nrays=1000, Double_t startx=0, Double_t starty=0, Double_t startz=0, const char *target_vol=0, Bool_t check_norm=kFALSE);
267  TGeoNode *SamplePoints(Int_t npoints, Double_t &dist, Double_t epsil=1E-5,
268  const char *g3path="");
269  void SetNmeshPoints(Int_t npoints=1000);
270  void SetCheckedNode(TGeoNode *node);
271  void Test(Int_t npoints=1000000, Option_t *option=""); // *MENU*
272  void TestOverlaps(const char* path=""); // *MENU*
273  Double_t Weight(Double_t precision=0.01, Option_t *option="va"); // *MENU*
274 
275  //--- GEANT3-like geometry creation
276  TGeoVolume *Division(const char *name, const char *mother, Int_t iaxis, Int_t ndiv,
277  Double_t start, Double_t step, Int_t numed=0, Option_t *option="");
278  void Matrix(Int_t index, Double_t theta1, Double_t phi1,
279  Double_t theta2, Double_t phi2,
280  Double_t theta3, Double_t phi3);
281  TGeoMaterial *Material(const char *name, Double_t a, Double_t z, Double_t dens, Int_t uid, Double_t radlen=0, Double_t intlen=0);
282  TGeoMaterial *Mixture(const char *name, Float_t *a, Float_t *z, Double_t dens,
283  Int_t nelem, Float_t *wmat, Int_t uid);
284  TGeoMaterial *Mixture(const char *name, Double_t *a, Double_t *z, Double_t dens,
285  Int_t nelem, Double_t *wmat, Int_t uid);
286  TGeoMedium *Medium(const char *name, Int_t numed, Int_t nmat, Int_t isvol,
287  Int_t ifield, Double_t fieldm, Double_t tmaxfd,
288  Double_t stemax, Double_t deemax, Double_t epsil,
289  Double_t stmin);
290  void Node(const char *name, Int_t nr, const char *mother,
291  Double_t x, Double_t y, Double_t z, Int_t irot,
292  Bool_t isOnly, Float_t *upar, Int_t npar=0);
293  void Node(const char *name, Int_t nr, const char *mother,
294  Double_t x, Double_t y, Double_t z, Int_t irot,
295  Bool_t isOnly, Double_t *upar, Int_t npar=0);
296  TGeoVolume *Volume(const char *name, const char *shape, Int_t nmed,
297  Float_t *upar, Int_t npar=0);
298  TGeoVolume *Volume(const char *name, const char *shape, Int_t nmed,
299  Double_t *upar, Int_t npar=0);
300  void SetVolumeAttribute(const char *name, const char *att, Int_t val);
301  //--- geometry building
302  void BuildDefaultMaterials();
303  void CloseGeometry(Option_t *option="d");
304  Bool_t IsClosed() const {return fClosed;}
305  TGeoVolume *MakeArb8(const char *name, TGeoMedium *medium,
306  Double_t dz, Double_t *vertices=0);
307  TGeoVolume *MakeBox(const char *name, TGeoMedium *medium,
308  Double_t dx, Double_t dy, Double_t dz);
309  TGeoVolume *MakeCone(const char *name, TGeoMedium *medium,
310  Double_t dz, Double_t rmin1, Double_t rmax1,
311  Double_t rmin2, Double_t rmax2);
312  TGeoVolume *MakeCons(const char *name, TGeoMedium *medium,
313  Double_t dz, Double_t rmin1, Double_t rmax1,
314  Double_t rmin2, Double_t rmax2,
315  Double_t phi1, Double_t phi2);
316  TGeoVolume *MakeCtub(const char *name, TGeoMedium *medium,
317  Double_t rmin, Double_t rmax, Double_t dz, Double_t phi1, Double_t phi2,
318  Double_t lx, Double_t ly, Double_t lz, Double_t tx, Double_t ty, Double_t tz);
319  TGeoVolume *MakeEltu(const char *name, TGeoMedium *medium,
320  Double_t a, Double_t b, Double_t dz);
321  TGeoVolume *MakeGtra(const char *name, TGeoMedium *medium,
322  Double_t dz, Double_t theta, Double_t phi, Double_t twist, Double_t h1,
323  Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Double_t bl2,
324  Double_t tl2, Double_t alpha2);
325  TGeoVolume *MakePara(const char *name, TGeoMedium *medium,
326  Double_t dx, Double_t dy, Double_t dz,
327  Double_t alpha, Double_t theta, Double_t phi);
328  TGeoVolume *MakePcon(const char *name, TGeoMedium *medium,
329  Double_t phi, Double_t dphi, Int_t nz);
330  TGeoVolume *MakeParaboloid(const char *name, TGeoMedium *medium,
331  Double_t rlo, Double_t rhi, Double_t dz);
332  TGeoVolume *MakeHype(const char *name, TGeoMedium *medium,
333  Double_t rin, Double_t stin, Double_t rout, Double_t stout, Double_t dz);
334  TGeoVolume *MakePgon(const char *name, TGeoMedium *medium,
335  Double_t phi, Double_t dphi, Int_t nedges, Int_t nz);
336  TGeoVolume *MakeSphere(const char *name, TGeoMedium *medium,
337  Double_t rmin, Double_t rmax,
338  Double_t themin=0, Double_t themax=180,
339  Double_t phimin=0, Double_t phimax=360);
340  TGeoVolume *MakeTorus(const char *name, TGeoMedium *medium, Double_t r,
341  Double_t rmin, Double_t rmax, Double_t phi1=0, Double_t dphi=360);
342  TGeoVolume *MakeTrap(const char *name, TGeoMedium *medium,
343  Double_t dz, Double_t theta, Double_t phi, Double_t h1,
344  Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Double_t bl2,
345  Double_t tl2, Double_t alpha2);
346  TGeoVolume *MakeTrd1(const char *name, TGeoMedium *medium,
347  Double_t dx1, Double_t dx2, Double_t dy, Double_t dz);
348  TGeoVolume *MakeTrd2(const char *name, TGeoMedium *medium,
349  Double_t dx1, Double_t dx2, Double_t dy1, Double_t dy2,
350  Double_t dz);
351  TGeoVolume *MakeTube(const char *name, TGeoMedium *medium,
352  Double_t rmin, Double_t rmax, Double_t dz);
353  TGeoVolume *MakeTubs(const char *name, TGeoMedium *medium,
354  Double_t rmin, Double_t rmax, Double_t dz,
355  Double_t phi1, Double_t phi2);
356  TGeoVolume *MakeXtru(const char *name, TGeoMedium *medium,
357  Int_t nz);
358 
359  TGeoPNEntry *SetAlignableEntry(const char *unique_name, const char *path, Int_t uid=-1);
360  TGeoPNEntry *GetAlignableEntry(const char *name) const;
361  TGeoPNEntry *GetAlignableEntry(Int_t index) const;
362  TGeoPNEntry *GetAlignableEntryByUID(Int_t uid) const;
363  Int_t GetNAlignable(Bool_t with_uid=kFALSE) const;
364  TGeoPhysicalNode *MakeAlignablePN(const char *name);
365  TGeoPhysicalNode *MakeAlignablePN(TGeoPNEntry *entry);
366  TGeoPhysicalNode *MakePhysicalNode(const char *path=0);
367  void ClearPhysicalNodes(Bool_t mustdelete=kFALSE);
368  void RefreshPhysicalNodes(Bool_t lock=kTRUE);
369  TVirtualGeoTrack *MakeTrack(Int_t id, Int_t pdgcode, TObject *particle);
370  TGeoVolumeAssembly *MakeVolumeAssembly(const char *name);
371  TGeoVolumeMulti *MakeVolumeMulti(const char *name, TGeoMedium *medium);
372  void SetTopVolume(TGeoVolume *vol);
373 
374  //--- geometry queries
375  TGeoNode *CrossBoundaryAndLocate(Bool_t downwards, TGeoNode *skipnode);
376  TGeoNode *FindNextBoundary(Double_t stepmax=TGeoShape::Big(),const char *path="", Bool_t frombdr=kFALSE);
377  TGeoNode *FindNextDaughterBoundary(Double_t *point, Double_t *dir, Int_t &idaughter, Bool_t compmatrix=kFALSE);
378  TGeoNode *FindNextBoundaryAndStep(Double_t stepmax=TGeoShape::Big(), Bool_t compsafe=kFALSE);
379  TGeoNode *FindNode(Bool_t safe_start=kTRUE);
380  TGeoNode *FindNode(Double_t x, Double_t y, Double_t z);
381  Double_t *FindNormal(Bool_t forward=kTRUE);
382  Double_t *FindNormalFast();
383  TGeoNode *InitTrack(const Double_t *point, const Double_t *dir);
384  TGeoNode *InitTrack(Double_t x, Double_t y, Double_t z, Double_t nx, Double_t ny, Double_t nz);
385  void ResetState();
386  Double_t Safety(Bool_t inside=kFALSE);
387  TGeoNode *SearchNode(Bool_t downwards=kFALSE, const TGeoNode *skipnode=0);
388  TGeoNode *Step(Bool_t is_geom=kTRUE, Bool_t cross=kTRUE);
389  void DisableInactiveVolumes() {fActivity=kTRUE;}
390  void EnableInactiveVolumes() {fActivity=kFALSE;}
391  void SetCurrentTrack(Int_t i) {fCurrentTrack = (TVirtualGeoTrack*)fTracks->At(i);}
392  void SetCurrentTrack(TVirtualGeoTrack *track) {fCurrentTrack=track;}
393  Int_t GetNtracks() const {return fNtracks;}
394  TVirtualGeoTrack *GetCurrentTrack() {return fCurrentTrack;}
395  TVirtualGeoTrack *GetLastTrack() {return (TVirtualGeoTrack*)((fNtracks>0)?fTracks->At(fNtracks-1):NULL);}
396  const Double_t *GetLastPoint() const {return GetCurrentNavigator()->GetLastPoint();}
397  TVirtualGeoTrack *GetTrack(Int_t index) {return (index<fNtracks)?(TVirtualGeoTrack*)fTracks->At(index):0;}
398  Int_t GetTrackIndex(Int_t id) const;
399  TVirtualGeoTrack *GetTrackOfId(Int_t id) const;
400  TVirtualGeoTrack *FindTrackWithId(Int_t id) const;
401  TVirtualGeoTrack *GetParentTrackOfId(Int_t id) const;
402  Int_t GetVirtualLevel();
403  Bool_t GotoSafeLevel();
404  Int_t GetSafeLevel() const;
405  Double_t GetSafeDistance() const {return GetCurrentNavigator()->GetSafeDistance();}
406  Double_t GetLastSafety() const {return GetCurrentNavigator()->GetLastSafety();}
407  Double_t GetStep() const {return GetCurrentNavigator()->GetStep();}
408  void InspectState() const;
409  Bool_t IsAnimatingTracks() const {return fIsGeomReading;}
410  Bool_t IsCheckingOverlaps() const {return GetCurrentNavigator()->IsCheckingOverlaps();}
411  Bool_t IsMatrixTransform() const {return fMatrixTransform;}
412  Bool_t IsMatrixReflection() const {return fMatrixReflection;}
413  Bool_t IsSameLocation(Double_t x, Double_t y, Double_t z, Bool_t change=kFALSE);
414  Bool_t IsSameLocation() const {return GetCurrentNavigator()->IsSameLocation();}
415  Bool_t IsSamePoint(Double_t x, Double_t y, Double_t z) const;
416  Bool_t IsStartSafe() const {return GetCurrentNavigator()->IsStartSafe();}
417  void SetCheckingOverlaps(Bool_t flag=kTRUE) {GetCurrentNavigator()->SetCheckingOverlaps(flag);}
418  void SetStartSafe(Bool_t flag=kTRUE) {GetCurrentNavigator()->SetStartSafe(flag);}
419  void SetMatrixTransform(Bool_t on=kTRUE) {fMatrixTransform = on;}
420  void SetMatrixReflection(Bool_t flag=kTRUE) {fMatrixReflection = flag;}
421  void SetStep(Double_t step) {GetCurrentNavigator()->SetStep(step);}
422  Bool_t IsCurrentOverlapping() const {return GetCurrentNavigator()->IsCurrentOverlapping();}
423  Bool_t IsEntering() const {return GetCurrentNavigator()->IsEntering();}
424  Bool_t IsExiting() const {return GetCurrentNavigator()->IsExiting();}
425  Bool_t IsStepEntering() const {return GetCurrentNavigator()->IsStepEntering();}
426  Bool_t IsStepExiting() const {return GetCurrentNavigator()->IsStepExiting();}
427  Bool_t IsOutside() const {return GetCurrentNavigator()->IsOutside();}
428  Bool_t IsOnBoundary() const {return GetCurrentNavigator()->IsOnBoundary();}
429  Bool_t IsNullStep() const {return GetCurrentNavigator()->IsNullStep();}
430  Bool_t IsActivityEnabled() const {return fActivity;}
431  void SetOutside(Bool_t flag=kTRUE) {GetCurrentNavigator()->SetOutside(flag);}
432 
433 
434  //--- cleaning
435  void CleanGarbage();
436  void ClearShape(const TGeoShape *shape);
437  void ClearTracks() {fTracks->Delete(); fNtracks=0;}
438  void ClearNavigators();
439  void RemoveMaterial(Int_t index);
440  void RemoveNavigator(const TGeoNavigator *nav);
441  void ResetUserData();
442 
443 
444  //--- utilities
445  Int_t CountNodes(const TGeoVolume *vol=0, Int_t nlevels=10000, Int_t option=0);
446  void CountLevels();
447  virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
448  static Int_t Parse(const char* expr, TString &expr1, TString &expr2, TString &expr3);
449  Int_t ReplaceVolume(TGeoVolume *vorig, TGeoVolume *vnew);
450  Int_t TransformVolumeToAssembly(const char *vname);
451  UChar_t *GetBits() {return fBits;}
452  virtual Int_t GetByteCount(Option_t *option=0);
453  void SetAllIndex();
454  static Int_t GetMaxDaughters();
455  static Int_t GetMaxLevels();
456  static Int_t GetMaxXtruVert();
457  Int_t GetMaxThreads() const {return fMaxThreads-1;}
458  void SetMaxThreads(Int_t nthreads);
459  Int_t GetRTmode() const {return fRaytraceMode;}
460  void SetRTmode(Int_t mode); // *MENU*
461  Bool_t IsMultiThread() const {return fMultiThread;}
462  static void SetNavigatorsLock(Bool_t flag);
463  static Int_t ThreadId();
464  static Int_t GetNumThreads();
465  static void ClearThreadsMap();
466  void ClearThreadData() const;
467  void CreateThreadData() const;
468 
469  //--- I/O
470  virtual Int_t Export(const char *filename, const char *name="", Option_t *option="vg");
471  static void LockGeometry();
472  static void UnlockGeometry();
473  static Int_t GetVerboseLevel();
474  static void SetVerboseLevel(Int_t vl);
475  static TGeoManager *Import(const char *filename, const char *name="", Option_t *option="");
476  static Bool_t IsLocked();
477  static void SetExportPrecision(UInt_t prec) {fgExportPrecision = prec;}
478  static UInt_t GetExportPrecision() {return fgExportPrecision;}
479  static void SetDefaultG4Units() {fgDefaultUnits = kG4Units;}
480  static void SetDefaultRootUnits() {fgDefaultUnits = kRootUnits;}
481  static EDefaultUnits GetDefaultUnits();
482  Bool_t IsStreamingVoxels() const {return fStreamVoxels;}
483  Bool_t IsCleaning() const {return fIsGeomCleaning;}
484 
485  //--- list getters
486  TObjArray *GetListOfNodes() {return fNodes;}
487  TObjArray *GetListOfPhysicalNodes() {return fPhysicalNodes;}
488  TObjArray *GetListOfOverlaps() {return fOverlaps;}
489  TObjArray *GetListOfMatrices() const {return fMatrices;}
490  TList *GetListOfMaterials() const {return fMaterials;}
491  TList *GetListOfMedia() const {return fMedia;}
492  TObjArray *GetListOfVolumes() const {return fVolumes;}
493  TObjArray *GetListOfGVolumes() const {return fGVolumes;}
494  TObjArray *GetListOfShapes() const {return fShapes;}
495  TObjArray *GetListOfGShapes() const {return fGShapes;}
496  TObjArray *GetListOfUVolumes() const {return fUniqueVolumes;}
497  TObjArray *GetListOfTracks() const {return fTracks;}
498  TObjArray *GetListOfGDMLMatrices() const {return fGDMLMatrices;}
499  TObjArray *GetListOfOpticalSurfaces() const {return fOpticalSurfaces;}
500  TObjArray *GetListOfSkinSurfaces() const {return fSkinSurfaces;}
501  TObjArray *GetListOfBorderSurfaces() const {return fBorderSurfaces;}
502  TObjArray *GetListOfRegions() const {return fRegions;}
503  TGeoNavigatorArray *GetListOfNavigators() const;
504  TGeoElementTable *GetElementTable();
505 
506  //--- modeler state getters/setters
507  void DoBackupState();
508  void DoRestoreState();
509  TGeoNode *GetNode(Int_t level) const {return (TGeoNode*)fNodes->UncheckedAt(level);}
510  Int_t GetNodeId() const {return GetCurrentNavigator()->GetNodeId();}
511  TGeoNode *GetNextNode() const {return GetCurrentNavigator()->GetNextNode();}
512  TGeoNode *GetMother(Int_t up=1) const {return GetCurrentNavigator()->GetMother(up);}
513  TGeoHMatrix *GetMotherMatrix(Int_t up=1) const {return GetCurrentNavigator()->GetMotherMatrix(up);}
514  TGeoHMatrix *GetHMatrix();
515  TGeoHMatrix *GetCurrentMatrix() const {return GetCurrentNavigator()->GetCurrentMatrix();}
516  TGeoHMatrix *GetGLMatrix() const {return fGLMatrix;}
517  TGeoNavigator *GetCurrentNavigator() const;
518  TGeoNode *GetCurrentNode() const {return GetCurrentNavigator()->GetCurrentNode();}
519  Int_t GetCurrentNodeId() const;
520  const Double_t *GetCurrentPoint() const {return GetCurrentNavigator()->GetCurrentPoint();}
521  const Double_t *GetCurrentDirection() const {return GetCurrentNavigator()->GetCurrentDirection();}
522  TGeoVolume *GetCurrentVolume() const {return GetCurrentNavigator()->GetCurrentVolume();}
523  const Double_t *GetCldirChecked() const {return GetCurrentNavigator()->GetCldirChecked();}
524  const Double_t *GetCldir() const {return GetCurrentNavigator()->GetCldir();}
525  const Double_t *GetNormal() const {return GetCurrentNavigator()->GetNormal();}
526  Int_t GetLevel() const {return GetCurrentNavigator()->GetLevel();}
527  Int_t GetMaxLevel() const {return fNLevel;}
528  const char *GetPath() const;
529  Int_t GetStackLevel() const {return GetCurrentNavigator()->GetStackLevel();}
530  TGeoVolume *GetMasterVolume() const {return fMasterVolume;}
531  TGeoVolume *GetTopVolume() const {return fTopVolume;}
532  TGeoNode *GetTopNode() const {return fTopNode;}
533  TGeoPhysicalNode *GetPhysicalNode(Int_t i) const {return (TGeoPhysicalNode*)fPhysicalNodes->UncheckedAt(i);}
534  void SetCurrentPoint(Double_t *point) {GetCurrentNavigator()->SetCurrentPoint(point);}
535  void SetCurrentPoint(Double_t x, Double_t y, Double_t z) {GetCurrentNavigator()->SetCurrentPoint(x,y,z);}
536  void SetLastPoint(Double_t x, Double_t y, Double_t z) {GetCurrentNavigator()->SetLastPoint(x,y,z);}
537  void SetCurrentDirection(Double_t *dir) {GetCurrentNavigator()->SetCurrentDirection(dir);}
538  void SetCurrentDirection(Double_t nx, Double_t ny, Double_t nz) {GetCurrentNavigator()->SetCurrentDirection(nx,ny,nz);}
539  void SetCldirChecked(Double_t *dir) {GetCurrentNavigator()->SetCldirChecked(dir);}
540 
541  //--- point/vector reference frame conversion
542  void LocalToMaster(const Double_t *local, Double_t *master) const {GetCurrentNavigator()->LocalToMaster(local, master);}
543  void LocalToMasterVect(const Double_t *local, Double_t *master) const {GetCurrentNavigator()->LocalToMasterVect(local, master);}
544  void LocalToMasterBomb(const Double_t *local, Double_t *master) const {GetCurrentNavigator()->LocalToMasterBomb(local, master);}
545  void MasterToLocal(const Double_t *master, Double_t *local) const {GetCurrentNavigator()->MasterToLocal(master, local);}
546  void MasterToLocalVect(const Double_t *master, Double_t *local) const {GetCurrentNavigator()->MasterToLocalVect(master, local);}
547  void MasterToLocalBomb(const Double_t *master, Double_t *local) const {GetCurrentNavigator()->MasterToLocalBomb(master, local);}
548  void MasterToTop(const Double_t *master, Double_t *top) const;
549  void TopToMaster(const Double_t *top, Double_t *master) const;
550 
551  //--- general use getters/setters
552  TGeoMaterial *FindDuplicateMaterial(const TGeoMaterial *mat) const;
553  TGeoVolume *FindVolumeFast(const char*name, Bool_t multi=kFALSE);
554  TGeoMaterial *GetMaterial(const char *matname) const;
555  TGeoMaterial *GetMaterial(Int_t id) const;
556  TGeoMedium *GetMedium(const char *medium) const;
557  TGeoMedium *GetMedium(Int_t numed) const;
558  Int_t GetMaterialIndex(const char *matname) const;
559 
560  //--- GDML object accessors
561  TGDMLMatrix *GetGDMLMatrix(const char *name) const;
562  void AddGDMLMatrix(TGDMLMatrix *mat);
563  TGeoOpticalSurface *GetOpticalSurface(const char *name) const;
564  void AddOpticalSurface(TGeoOpticalSurface *optsurf);
565  TGeoSkinSurface *GetSkinSurface(const char *name) const;
566  void AddSkinSurface(TGeoSkinSurface *surf);
567  TGeoBorderSurface *GetBorderSurface(const char *name) const;
568  void AddBorderSurface(TGeoBorderSurface *surf);
569 
570 // TGeoShape *GetShape(const char *name) const;
571  TGeoVolume *GetVolume(const char*name) const;
572  TGeoVolume *GetVolume(Int_t uid) const {return (TGeoVolume*)fUniqueVolumes->At(uid);}
573  int GetNregions() const {return fRegions->GetEntriesFast();}
574  TGeoRegion *GetRegion(int i) {return (TGeoRegion*)fRegions->At(i);}
575  Int_t GetUID(const char *volname) const;
576  Int_t GetNNodes() {if (!fNNodes) CountNodes(); return fNNodes;}
577  TGeoNodeCache *GetCache() const {return GetCurrentNavigator()->GetCache();}
578 // void SetCache(const TGeoNodeCache *cache) {fCache = (TGeoNodeCache*)cache;}
579  void SetAnimateTracks(Bool_t flag=kTRUE) {fIsGeomReading=flag;}
580  virtual ULong_t SizeOf(const TGeoNode *node, Option_t *option); // size of the geometry in memory
581  void SelectTrackingMedia();
582 
583  //--- stack manipulation
584  Int_t PushPath(Int_t startlevel=0) {return GetCurrentNavigator()->PushPath(startlevel);}
585  Bool_t PopPath() {return GetCurrentNavigator()->PopPath();}
586  Bool_t PopPath(Int_t index) {return GetCurrentNavigator()->PopPath(index);}
587  Int_t PushPoint(Int_t startlevel=0) {return GetCurrentNavigator()->PushPoint(startlevel);}
588  Bool_t PopPoint() {return GetCurrentNavigator()->PopPoint();}
589  Bool_t PopPoint(Int_t index) {return GetCurrentNavigator()->PopPoint(index);}
590  void PopDummy(Int_t ipop=9999) {return GetCurrentNavigator()->PopDummy(ipop);}
591 
592  //--- parallel world navigation
593  TGeoParallelWorld *CreateParallelWorld(const char *name);
594  TGeoParallelWorld *GetParallelWorld() const {return fParallelWorld;}
595  void SetUseParallelWorldNav(Bool_t flag);
596  Bool_t IsParallelWorldNav() const {return fUsePWNav;}
597 
598  ClassDef(TGeoManager, 17) // geometry manager
599 };
600 
601 R__EXTERN TGeoManager *gGeoManager;
602 
603 #endif
604