ROOT_528-00b_version: include/TGeoManager.h Source File

00001 // @(#)root/geom:$Id: TGeoManager.h 35047 2010-08-27 14:38:41Z agheata $
00002 // Author: Andrei Gheata   25/10/01
00003 
00004 /*************************************************************************
00005  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
00006  * All rights reserved.                                                  *
00007  *                                                                       *
00008  * For the licensing terms see $ROOTSYS/LICENSE.                         *
00009  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
00010  *************************************************************************/
00011 
00012 #ifndef ROOT_TGeoManager
00013 #define ROOT_TGeoManager
00014 
00015 #ifndef ROOT_TObjArray
00016 #include "TObjArray.h"
00017 #endif
00018 #ifndef ROOT_TGeoNavigator
00019 #include "TGeoNavigator.h"
00020 #endif
00021 
00022 // forward declarations
00023 class TVirtualGeoTrack;
00024 class TGeoNode;
00025 class TGeoPhysicalNode;
00026 class TGeoPNEntry;
00027 class TGeoVolume;
00028 class TGeoVolumeMulti;
00029 class TGeoMatrix;
00030 class TGeoHMatrix;
00031 class TGeoMaterial;
00032 class TGeoMedium;
00033 class TGeoShape;
00034 class TVirtualGeoPainter;
00035 class THashList;
00036 
00037 ////////////////////////////////////////////////////////////////////////////
00038 //                                                                        //
00039 // TGeoManager - The manager class for any TGeo geometry. Provides user   //
00040 //    interface for geometry creation, navigation, state querying,        //
00041 //    visualization, IO, geometry checking and other utilities.           //
00042 //                                                                        //
00043 ////////////////////////////////////////////////////////////////////////////
00044 
00045 class TGeoManager : public TNamed
00046 {
00047 protected:
00048    static Bool_t         fgLock;            //! Lock preventing a second geometry to be loaded
00049    static Int_t          fgVerboseLevel;    //! Verbosity level for Info messages (no IO).
00050 
00051    TGeoManager(const TGeoManager&); 
00052    TGeoManager& operator=(const TGeoManager&); 
00053 
00054 private :
00055    Double_t              fPhimin;           //! lowest range for phi cut
00056    Double_t              fPhimax;           //! highest range for phi cut
00057    Double_t              fTmin;             //! lower time limit for tracks drawing
00058    Double_t              fTmax;             //! upper time limit for tracks drawing
00059    Int_t                 fNNodes;           // total number of physical nodes
00060    TString               fPath;             //! path to current node
00061    TString               fParticleName;     //! particles to be drawn
00062    Double_t              fVisDensity;       // transparency threshold by density
00063    Int_t                 fExplodedView;     // exploded view mode
00064    Int_t                 fVisOption;        // global visualization option
00065    Int_t                 fVisLevel;         // maximum visualization depth
00066    Int_t                 fNsegments;        // number of segments to approximate circles
00067    Int_t                 fNtracks;          // number of tracks
00068    Int_t                 fMaxVisNodes;      // maximum number of visible nodes
00069    TVirtualGeoTrack     *fCurrentTrack;     //! current track
00070    Int_t                 fNpdg;             // number of different pdg's stored
00071    Int_t                 fPdgId[256];       // pdg conversion table
00072    Bool_t                fClosed;           //! flag that geometry is closed
00073    Bool_t                fLoopVolumes;      //! flag volume lists loop
00074    Bool_t                fStreamVoxels;     // flag to allow voxelization I/O
00075    Bool_t                fIsGeomReading;    //! flag set when reading geometry
00076    Bool_t                fPhiCut;           // flag for phi cuts
00077    Bool_t                fTimeCut;          // time cut for tracks
00078    Bool_t                fDrawExtra;        //! flag that the list of physical nodes has to be drawn
00079    Bool_t                fMatrixTransform;  //! flag for using GL matrix
00080    Bool_t                fMatrixReflection; //! flag for GL reflections
00081    Bool_t                fActivity;         //! switch ON/OFF volume activity (default OFF - all volumes active))
00082    Bool_t                fIsNodeSelectable; //! flag that nodes are the selected objects in pad rather than volumes
00083    TVirtualGeoPainter   *fPainter;          //! current painter
00084 
00085    TObjArray            *fMatrices;         //-> list of local transformations
00086    TObjArray            *fShapes;           //-> list of shapes
00087    TObjArray            *fVolumes;          //-> list of volumes
00088    TObjArray            *fPhysicalNodes;    //-> list of physical nodes
00089    TObjArray            *fGShapes;          //! list of runtime shapes
00090    TObjArray            *fGVolumes;         //! list of runtime volumes
00091    TObjArray            *fTracks;           //-> list of tracks attached to geometry
00092    TObjArray            *fPdgNames;         //-> list of pdg names for tracks
00093    TObjArray            *fNavigators;       //! list of navigators
00094    TList                *fMaterials;        //-> list of materials
00095    TList                *fMedia;            //-> list of tracking media
00096    TObjArray            *fNodes;            //-> current branch of nodes
00097    TObjArray            *fOverlaps;         //-> list of geometrical overlaps
00098    UChar_t              *fBits;             //! bits used for voxelization
00099    TGeoNavigator        *fCurrentNavigator; //! current navigator
00100    TGeoVolume           *fCurrentVolume;    //! current volume
00101    TGeoVolume           *fTopVolume;        //! top level volume in geometry
00102    TGeoNode             *fTopNode;          //! top physical node
00103    TGeoVolume           *fMasterVolume;     // master volume
00104    TGeoHMatrix          *fGLMatrix;         // matrix to be used for view transformations
00105    TObjArray            *fUniqueVolumes;    //-> list of unique volumes
00106    TGeoShape            *fClippingShape;    //! clipping shape for raytracing
00107    TGeoElementTable     *fElementTable;     //! table of elements
00108 
00109    Int_t                *fNodeIdArray;      //! array of node id's
00110    Int_t                 fIntSize;          //! int buffer size
00111    Int_t                 fDblSize;          //! dbl buffer size
00112    Int_t                *fIntBuffer;        //! transient int buffer
00113    Int_t                 fNLevel;           // maximum accepted level in geometry
00114    Double_t             *fDblBuffer;        //! transient dbl buffer
00115    TGeoVolume           *fPaintVolume;      //! volume currently painted
00116    THashList            *fHashVolumes;      //! hash list of volumes providing fast search
00117    THashList            *fHashGVolumes;     //! hash list of group volumes providing fast search
00118    THashList            *fHashPNE;          //-> hash list of phisical node entries
00119    mutable TObjArray    *fArrayPNE;         //! array of phisical node entries
00120    Int_t                 fSizePNEId;        // size of the array of unique ID's for PN entries
00121    Int_t                 fNPNEId;           // number of PN entries having a unique ID
00122    Int_t                *fKeyPNEId;         //[fSizePNEId] array of uid values for PN entries
00123    Int_t                *fValuePNEId;       //[fSizePNEId] array of pointers to PN entries with ID's
00124 //--- private methods
00125 
00126    Bool_t                IsLoopingVolumes() const     {return fLoopVolumes;}
00127    void                  Init();
00128    Bool_t                InitArrayPNE() const;
00129    Bool_t                InsertPNEId(Int_t uid, Int_t ientry);
00130    void                  SetLoopVolumes(Bool_t flag=kTRUE) {fLoopVolumes=flag;}
00131    void                  UpdateElements();
00132    void                  Voxelize(Option_t *option = 0);
00133 
00134 public:
00135    // constructors
00136    TGeoManager();
00137    TGeoManager(const char *name, const char *title);
00138    // destructor
00139    virtual ~TGeoManager();
00140    //--- adding geometrical objects
00141    Int_t                  AddMaterial(const TGeoMaterial *material);
00142    Int_t                  AddOverlap(const TNamed *ovlp);
00143    Int_t                  AddTransformation(const TGeoMatrix *matrix);
00144    Int_t                  AddShape(const TGeoShape *shape);
00145    Int_t                  AddTrack(Int_t id, Int_t pdgcode, TObject *particle=0);
00146    Int_t                  AddTrack(TVirtualGeoTrack *track);
00147    Int_t                  AddVolume(TGeoVolume *volume);
00148    Int_t                  AddNavigator(TGeoNavigator *navigator);
00149    void                   ClearOverlaps();
00150    void                   RegisterMatrix(const TGeoMatrix *matrix);
00151    void                   SortOverlaps();
00152    //--- browsing and tree navigation
00153    void                   Browse(TBrowser *b);
00154    void                   SetVisibility(TObject *obj, Bool_t vis);
00155    virtual Bool_t         cd(const char *path=""); // *MENU*
00156    Bool_t                 CheckPath(const char *path) const;
00157    void                   CdNode(Int_t nodeid);
00158    void                   CdDown(Int_t index);
00159    void                   CdUp();
00160    void                   CdTop();
00161    void                   CdNext();
00162    void                   GetBranchNames(Int_t *names) const;
00163    void                   GetBranchNumbers(Int_t *copyNumbers, Int_t *volumeNumbers) const;
00164    void                   GetBranchOnlys(Int_t *isonly) const;
00165    Int_t                  GetNmany() const {return fCurrentNavigator->GetNmany();}
00166    const char            *GetPdgName(Int_t pdg) const;
00167    void                   SetPdgName(Int_t pdg, const char *name);
00168    Bool_t                 IsFolder() const { return kTRUE; }
00169    //--- visualization settings
00170    virtual void           Edit(Option_t *option="");  // *MENU*
00171    void                   BombTranslation(const Double_t *tr, Double_t *bombtr);
00172    void                   UnbombTranslation(const Double_t *tr, Double_t *bombtr);
00173    void                   ClearAttributes(); // *MENU*
00174    void                   DefaultAngles();   // *MENU*
00175    void                   DefaultColors();   // *MENU*
00176    TGeoShape             *GetClippingShape() const {return fClippingShape;}
00177    Int_t                  GetNsegments() const;
00178    TVirtualGeoPainter    *GetGeomPainter();
00179    TVirtualGeoPainter    *GetPainter() const {return fPainter;}
00180    Int_t                  GetBombMode() const  {return fExplodedView;}
00181    void                   GetBombFactors(Double_t &bombx, Double_t &bomby, Double_t &bombz, Double_t &bombr) const;
00182    Int_t                  GetMaxVisNodes() const {return fMaxVisNodes;}
00183    Bool_t                 GetTminTmax(Double_t &tmin, Double_t &tmax) const;
00184    Double_t               GetTmax() const {return fTmax;}
00185    TGeoVolume            *GetPaintVolume() const {return fPaintVolume;}
00186    Double_t               GetVisDensity() const  {return fVisDensity;}
00187    Int_t                  GetVisLevel() const;
00188    Int_t                  GetVisOption() const;
00189    Bool_t                 IsInPhiRange() const;
00190    Bool_t                 IsDrawingExtra() const {return fDrawExtra;}
00191    Bool_t                 IsNodeSelectable() const {return fIsNodeSelectable;}
00192    Bool_t                 IsVisLeaves() const {return (fVisOption==1)?kTRUE:kFALSE;}
00193    void                   ModifiedPad() const;
00194    void                   OptimizeVoxels(const char *filename="tgeovox.C"); // *MENU*
00195    void                   SetClipping(Bool_t flag=kTRUE) {SetClippingShape(((flag)?fClippingShape:0));} // *MENU*
00196    void                   SetClippingShape(TGeoShape *clip);
00197    void                   SetExplodedView(Int_t iopt=0); // *MENU*
00198    void                   SetPhiRange(Double_t phimin=0., Double_t phimax=360.);
00199    void                   SetNsegments(Int_t nseg); // *MENU*
00200    Bool_t                 SetCurrentNavigator(Int_t index);
00201    void                   SetBombFactors(Double_t bombx=1.3, Double_t bomby=1.3, Double_t bombz=1.3, Double_t bombr=1.3); // *MENU*
00202    void                   SetPaintVolume(TGeoVolume *vol) {fPaintVolume = vol;}
00203    void                   SetTopVisible(Bool_t vis=kTRUE);
00204    void                   SetTminTmax(Double_t tmin=0, Double_t tmax=999);
00205    void                   SetDrawExtraPaths(Bool_t flag=kTRUE) {fDrawExtra=flag;}
00206    void                   SetNodeSelectable(Bool_t flag=kTRUE) {fIsNodeSelectable=flag;}
00207    void                   SetVisDensity(Double_t dens=0.01); // *MENU*
00208    void                   SetVisLevel(Int_t level=3);   // *MENU*
00209    void                   SetVisOption(Int_t option=0);
00210    void                   ViewLeaves(Bool_t flag=kTRUE); // *TOGGLE* *GETTER=IsVisLeaves
00211    void                   SaveAttributes(const char *filename="tgeoatt.C"); // *MENU*
00212    void                   RestoreMasterVolume(); // *MENU*
00213    void                   SetMaxVisNodes(Int_t maxnodes=10000); // *MENU*
00214    //--- geometry checking
00215    void                   AnimateTracks(Double_t tmin=0, Double_t tmax=5E-8, Int_t nframes=200, Option_t *option="/*"); // *MENU*
00216    void                   CheckBoundaryErrors(Int_t ntracks=1000000, Double_t radius=-1.); // *MENU*
00217    void                   CheckBoundaryReference(Int_t icheck=-1);
00218    void                   CheckGeometryFull(Int_t ntracks=1000000, Double_t vx=0., Double_t vy=0., Double_t vz=0., Option_t *option="ob"); // *MENU*
00219    void                   CheckGeometry(Option_t *option="");
00220    void                   CheckOverlaps(Double_t ovlp=0.1, Option_t *option=""); // *MENU*
00221    void                   CheckPoint(Double_t x=0,Double_t y=0, Double_t z=0, Option_t *option=""); // *MENU*
00222    void                   ConvertReflections();
00223    void                   DrawCurrentPoint(Int_t color=2); // *MENU*
00224    void                   DrawTracks(Option_t *option=""); // *MENU*
00225    void                   SetParticleName(const char *pname) {fParticleName=pname;}
00226    const char            *GetParticleName() const {return fParticleName.Data();}
00227    void                   DrawPath(const char *path);
00228    void                   PrintOverlaps() const; // *MENU*
00229    void                   RandomPoints(const TGeoVolume *vol, Int_t npoints=10000, Option_t *option="");
00230    void                   RandomRays(Int_t nrays=1000, Double_t startx=0, Double_t starty=0, Double_t startz=0);
00231    TGeoNode              *SamplePoints(Int_t npoints, Double_t &dist, Double_t epsil=1E-5,
00232                                        const char *g3path="");
00233    void                   SetNmeshPoints(Int_t npoints=1000);
00234    void                   SetCheckedNode(TGeoNode *node);                                    
00235    void                   Test(Int_t npoints=1000000, Option_t *option=""); // *MENU*
00236    void                   TestOverlaps(const char* path=""); // *MENU*
00237    Double_t               Weight(Double_t precision=0.01, Option_t *option="va"); // *MENU*
00238 
00239    //--- GEANT3-like geometry creation
00240    TGeoVolume            *Division(const char *name, const char *mother, Int_t iaxis, Int_t ndiv,
00241                                          Double_t start, Double_t step, Int_t numed=0, Option_t *option="");
00242    void                   Matrix(Int_t index, Double_t theta1, Double_t phi1,
00243                                        Double_t theta2, Double_t phi2,
00244                                        Double_t theta3, Double_t phi3);
00245    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);
00246    TGeoMaterial          *Mixture(const char *name, Float_t *a, Float_t *z, Double_t dens,
00247                                         Int_t nelem, Float_t *wmat, Int_t uid);
00248    TGeoMaterial          *Mixture(const char *name, Double_t *a, Double_t *z, Double_t dens,
00249                                         Int_t nelem, Double_t *wmat, Int_t uid);
00250    TGeoMedium            *Medium(const char *name, Int_t numed, Int_t nmat, Int_t isvol,
00251                                        Int_t ifield, Double_t fieldm, Double_t tmaxfd,
00252                                        Double_t stemax, Double_t deemax, Double_t epsil,
00253                                        Double_t stmin);
00254    void                   Node(const char *name, Int_t nr, const char *mother,
00255                                      Double_t x, Double_t y, Double_t z, Int_t irot,
00256                                      Bool_t isOnly, Float_t *upar, Int_t npar=0);
00257    void                   Node(const char *name, Int_t nr, const char *mother,
00258                                      Double_t x, Double_t y, Double_t z, Int_t irot,
00259                                      Bool_t isOnly, Double_t *upar, Int_t npar=0);
00260    TGeoVolume            *Volume(const char *name, const char *shape, Int_t nmed,
00261                                        Float_t *upar, Int_t npar=0);
00262    TGeoVolume            *Volume(const char *name, const char *shape, Int_t nmed,
00263                                        Double_t *upar, Int_t npar=0);
00264    void                   SetVolumeAttribute(const char *name, const char *att, Int_t val);
00265    //--- geometry building
00266    void                   BuildDefaultMaterials();
00267    void                   CloseGeometry(Option_t *option="d");
00268    Bool_t                 IsClosed() const {return fClosed;}
00269    TGeoVolume            *MakeArb8(const char *name, TGeoMedium *medium,
00270                                      Double_t dz, Double_t *vertices=0);
00271    TGeoVolume            *MakeBox(const char *name, TGeoMedium *medium,
00272                                      Double_t dx, Double_t dy, Double_t dz);
00273    TGeoVolume            *MakeCone(const char *name, TGeoMedium *medium,
00274                                       Double_t dz, Double_t rmin1, Double_t rmax1,
00275                                       Double_t rmin2, Double_t rmax2);
00276    TGeoVolume            *MakeCons(const char *name, TGeoMedium *medium,
00277                                       Double_t dz, Double_t rmin1, Double_t rmax1,
00278                                       Double_t rmin2, Double_t rmax2,
00279                                       Double_t phi1, Double_t phi2);
00280    TGeoVolume            *MakeCtub(const char *name, TGeoMedium *medium,
00281                                       Double_t rmin, Double_t rmax, Double_t dz, Double_t phi1, Double_t phi2,
00282                                       Double_t lx, Double_t ly, Double_t lz, Double_t tx, Double_t ty, Double_t tz);
00283    TGeoVolume            *MakeEltu(const char *name, TGeoMedium *medium,
00284                                       Double_t a, Double_t b, Double_t dz);
00285    TGeoVolume            *MakeGtra(const char *name, TGeoMedium *medium,
00286                                    Double_t dz, Double_t theta, Double_t phi, Double_t twist, Double_t h1,
00287                                    Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Double_t bl2,
00288                                    Double_t tl2, Double_t alpha2);
00289    TGeoVolume            *MakePara(const char *name, TGeoMedium *medium,
00290                                      Double_t dx, Double_t dy, Double_t dz,
00291                                      Double_t alpha, Double_t theta, Double_t phi);
00292    TGeoVolume            *MakePcon(const char *name, TGeoMedium *medium,
00293                                       Double_t phi, Double_t dphi, Int_t nz);
00294    TGeoVolume            *MakeParaboloid(const char *name, TGeoMedium *medium,
00295                                       Double_t rlo, Double_t rhi, Double_t dz);
00296    TGeoVolume            *MakeHype(const char *name, TGeoMedium *medium,
00297                                       Double_t rin, Double_t stin, Double_t rout, Double_t stout, Double_t dz);
00298    TGeoVolume            *MakePgon(const char *name, TGeoMedium *medium,
00299                                       Double_t phi, Double_t dphi, Int_t nedges, Int_t nz);
00300    TGeoVolume            *MakeSphere(const char *name, TGeoMedium *medium,
00301                                      Double_t rmin, Double_t rmax,
00302                                      Double_t themin=0, Double_t themax=180,
00303                                      Double_t phimin=0, Double_t phimax=360);
00304    TGeoVolume            *MakeTorus(const char *name, TGeoMedium *medium, Double_t r,
00305                                     Double_t rmin, Double_t rmax, Double_t phi1=0, Double_t dphi=360);
00306    TGeoVolume            *MakeTrap(const char *name, TGeoMedium *medium,
00307                                    Double_t dz, Double_t theta, Double_t phi, Double_t h1,
00308                                    Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Double_t bl2,
00309                                    Double_t tl2, Double_t alpha2);
00310    TGeoVolume            *MakeTrd1(const char *name, TGeoMedium *medium,
00311                                       Double_t dx1, Double_t dx2, Double_t dy, Double_t dz);
00312    TGeoVolume            *MakeTrd2(const char *name, TGeoMedium *medium,
00313                                       Double_t dx1, Double_t dx2, Double_t dy1, Double_t dy2,
00314                                       Double_t dz);
00315    TGeoVolume            *MakeTube(const char *name, TGeoMedium *medium,
00316                                       Double_t rmin, Double_t rmax, Double_t dz);
00317    TGeoVolume            *MakeTubs(const char *name, TGeoMedium *medium,
00318                                       Double_t rmin, Double_t rmax, Double_t dz,
00319                                       Double_t phi1, Double_t phi2);
00320    TGeoVolume            *MakeXtru(const char *name, TGeoMedium *medium,
00321                                    Int_t nz);
00322 
00323    TGeoPNEntry           *SetAlignableEntry(const char *unique_name, const char *path, Int_t uid=-1);
00324    TGeoPNEntry           *GetAlignableEntry(const char *name) const;   
00325    TGeoPNEntry           *GetAlignableEntry(Int_t index) const;
00326    TGeoPNEntry           *GetAlignableEntryByUID(Int_t uid) const;
00327    Int_t                  GetNAlignable(Bool_t with_uid=kFALSE) const;
00328    TGeoPhysicalNode      *MakeAlignablePN(const char *name);
00329    TGeoPhysicalNode      *MakeAlignablePN(TGeoPNEntry *entry);
00330    TGeoPhysicalNode      *MakePhysicalNode(const char *path=0);
00331    void                   ClearPhysicalNodes(Bool_t mustdelete=kFALSE);
00332    void                   RefreshPhysicalNodes(Bool_t lock=kTRUE);
00333    TVirtualGeoTrack      *MakeTrack(Int_t id, Int_t pdgcode, TObject *particle);
00334    TGeoVolumeAssembly    *MakeVolumeAssembly(const char *name);
00335    TGeoVolumeMulti       *MakeVolumeMulti(const char *name, TGeoMedium *medium);
00336    void                   SetTopVolume(TGeoVolume *vol);
00337 
00338    //--- geometry queries
00339    TGeoNode              *CrossBoundaryAndLocate(Bool_t downwards, TGeoNode *skipnode);
00340    TGeoNode              *FindNextBoundary(Double_t stepmax=TGeoShape::Big(),const char *path="", Bool_t frombdr=kFALSE);
00341    TGeoNode              *FindNextDaughterBoundary(Double_t *point, Double_t *dir, Int_t &idaughter, Bool_t compmatrix=kFALSE);
00342    TGeoNode              *FindNextBoundaryAndStep(Double_t stepmax=TGeoShape::Big(), Bool_t compsafe=kFALSE);
00343    TGeoNode              *FindNode(Bool_t safe_start=kTRUE);
00344    TGeoNode              *FindNode(Double_t x, Double_t y, Double_t z);
00345    Double_t              *FindNormal(Bool_t forward=kTRUE);
00346    Double_t              *FindNormalFast();
00347    TGeoNode              *InitTrack(const Double_t *point, const Double_t *dir);
00348    TGeoNode              *InitTrack(Double_t x, Double_t y, Double_t z, Double_t nx, Double_t ny, Double_t nz);
00349    void                   ResetState();
00350    Double_t               Safety(Bool_t inside=kFALSE);
00351    TGeoNode              *SearchNode(Bool_t downwards=kFALSE, const TGeoNode *skipnode=0);
00352    TGeoNode              *Step(Bool_t is_geom=kTRUE, Bool_t cross=kTRUE);
00353    void                   DisableInactiveVolumes() {fActivity=kTRUE;}
00354    void                   EnableInactiveVolumes()  {fActivity=kFALSE;}
00355    void                   SetCurrentTrack(Int_t i) {fCurrentTrack = (TVirtualGeoTrack*)fTracks->At(i);}
00356    void                   SetCurrentTrack(TVirtualGeoTrack *track) {fCurrentTrack=track;}
00357    Int_t                  GetNtracks() const {return fNtracks;}
00358    TVirtualGeoTrack      *GetCurrentTrack() {return fCurrentTrack;}
00359    TVirtualGeoTrack      *GetLastTrack() {return (TVirtualGeoTrack*)((fNtracks>0)?fTracks->At(fNtracks-1):NULL);}
00360    const Double_t        *GetLastPoint() const {return fCurrentNavigator->GetLastPoint();}
00361    TVirtualGeoTrack      *GetTrack(Int_t index)         {return (index<fNtracks)?(TVirtualGeoTrack*)fTracks->At(index):0;}
00362    Int_t                  GetTrackIndex(Int_t id) const;
00363    TVirtualGeoTrack      *GetTrackOfId(Int_t id) const;
00364    TVirtualGeoTrack      *FindTrackWithId(Int_t id) const;
00365    TVirtualGeoTrack      *GetParentTrackOfId(Int_t id) const;
00366    Int_t                  GetVirtualLevel();
00367    Bool_t                 GotoSafeLevel();
00368    Int_t                  GetSafeLevel() const;
00369    Double_t               GetSafeDistance() const      {return fCurrentNavigator->GetSafeDistance();}
00370    Double_t               GetLastSafety() const        {return fCurrentNavigator->GetLastSafety();}
00371    Double_t               GetStep() const              {return fCurrentNavigator->GetStep();}
00372    void                   InspectState() const;
00373    Bool_t                 IsAnimatingTracks() const    {return fIsGeomReading;}
00374    Bool_t                 IsCheckingOverlaps() const   {return fCurrentNavigator->IsCheckingOverlaps();}
00375    Bool_t                 IsMatrixTransform() const    {return fMatrixTransform;}
00376    Bool_t                 IsMatrixReflection() const   {return fMatrixReflection;}
00377    Bool_t                 IsSameLocation(Double_t x, Double_t y, Double_t z, Bool_t change=kFALSE);
00378    Bool_t                 IsSameLocation() const {return fCurrentNavigator->IsSameLocation();}
00379    Bool_t                 IsSamePoint(Double_t x, Double_t y, Double_t z) const;
00380    Bool_t                 IsStartSafe() const {return fCurrentNavigator->IsStartSafe();}
00381    void                   SetCheckingOverlaps(Bool_t flag=kTRUE) {fCurrentNavigator->SetCheckingOverlaps(flag);}
00382    void                   SetStartSafe(Bool_t flag=kTRUE)   {fCurrentNavigator->SetStartSafe(flag);}
00383    void                   SetMatrixTransform(Bool_t on=kTRUE) {fMatrixTransform = on;}
00384    void                   SetMatrixReflection(Bool_t flag=kTRUE) {fMatrixReflection = flag;}
00385    void                   SetStep(Double_t step) {fCurrentNavigator->SetStep(step);}
00386    Bool_t                 IsCurrentOverlapping() const {return fCurrentNavigator->IsCurrentOverlapping();}
00387    Bool_t                 IsEntering() const           {return fCurrentNavigator->IsEntering();}
00388    Bool_t                 IsExiting() const            {return fCurrentNavigator->IsExiting();}
00389    Bool_t                 IsStepEntering() const       {return fCurrentNavigator->IsStepEntering();}
00390    Bool_t                 IsStepExiting() const        {return fCurrentNavigator->IsStepExiting();}
00391    Bool_t                 IsOutside() const            {return fCurrentNavigator->IsOutside();}
00392    Bool_t                 IsOnBoundary() const         {return fCurrentNavigator->IsOnBoundary();}
00393    Bool_t                 IsNullStep() const           {return fCurrentNavigator->IsNullStep();}
00394    Bool_t                 IsActivityEnabled() const    {return fActivity;}
00395    void                   SetOutside(Bool_t flag=kTRUE) {fCurrentNavigator->SetOutside(flag);}
00396    
00397 
00398    //--- cleaning
00399    void                   CleanGarbage();
00400    void                   ClearShape(const TGeoShape *shape);
00401    void                   ClearTracks() {fTracks->Delete(); fNtracks=0;}
00402    void                   RemoveMaterial(Int_t index);
00403    void                   ResetUserData();
00404 
00405 
00406    //--- utilities
00407    Int_t                  CountNodes(const TGeoVolume *vol=0, Int_t nlevels=10000, Int_t option=0);
00408    virtual void           ExecuteEvent(Int_t event, Int_t px, Int_t py);
00409    static Int_t           Parse(const char* expr, TString &expr1, TString &expr2, TString &expr3);
00410    Int_t                  ReplaceVolume(TGeoVolume *vorig, TGeoVolume *vnew);
00411    Int_t                  TransformVolumeToAssembly(const char *vname);
00412    UChar_t               *GetBits() {return fBits;}
00413    virtual Int_t          GetByteCount(Option_t *option=0);
00414    Int_t                 *GetIntBuffer(Int_t length);
00415    Double_t              *GetDblBuffer(Int_t length);
00416    void                   SetAllIndex();
00417 
00418    //--- I/O
00419    virtual Int_t          Export(const char *filename, const char *name="", Option_t *option="v");
00420    static  void           LockGeometry();
00421    static  void           UnlockGeometry();
00422    static  Int_t          GetVerboseLevel();
00423    static  void           SetVerboseLevel(Int_t vl);
00424    static TGeoManager    *Import(const char *filename, const char *name="", Option_t *option="");
00425    static Bool_t          IsLocked();
00426    Bool_t                 IsStreamingVoxels() const {return fStreamVoxels;}
00427 
00428    //--- list getters
00429    TObjArray             *GetListOfNodes()              {return fNodes;}
00430    TObjArray             *GetListOfPhysicalNodes()      {return fPhysicalNodes;}
00431    TObjArray             *GetListOfOverlaps()           {return fOverlaps;}
00432    TObjArray             *GetListOfMatrices() const     {return fMatrices;}
00433    TList                 *GetListOfMaterials() const    {return fMaterials;}
00434    TList                 *GetListOfMedia() const        {return fMedia;}
00435    TObjArray             *GetListOfVolumes() const      {return fVolumes;}
00436    TObjArray             *GetListOfGVolumes() const     {return fGVolumes;}
00437    TObjArray             *GetListOfShapes() const       {return fShapes;}
00438    TObjArray             *GetListOfGShapes() const      {return fGShapes;}
00439    TObjArray             *GetListOfUVolumes() const     {return fUniqueVolumes;}
00440    TObjArray             *GetListOfTracks() const       {return fTracks;}
00441    TObjArray             *GetListOfNavigators() const   {return fNavigators;}
00442    TGeoElementTable      *GetElementTable();
00443 
00444    //--- modeler state getters/setters
00445    void                   DoBackupState();
00446    void                   DoRestoreState();
00447    TGeoNode              *GetNode(Int_t level) const  {return (TGeoNode*)fNodes->UncheckedAt(level);}
00448    Int_t                  GetNodeId() const           {return fCurrentNavigator->GetNodeId();}
00449    TGeoNode              *GetNextNode() const         {return fCurrentNavigator->GetNextNode();}
00450    TGeoNode              *GetMother(Int_t up=1) const {return fCurrentNavigator->GetMother(up);}
00451    TGeoHMatrix           *GetMotherMatrix(Int_t up=1) const {return fCurrentNavigator->GetMotherMatrix(up);}
00452    TGeoHMatrix           *GetHMatrix();
00453    TGeoHMatrix           *GetCurrentMatrix() const    {return fCurrentNavigator->GetCurrentMatrix();}
00454    TGeoHMatrix           *GetGLMatrix() const         {return fGLMatrix;}
00455    TGeoNavigator         *GetCurrentNavigator() const {return fCurrentNavigator;} 
00456    TGeoNode              *GetCurrentNode() const      {return fCurrentNavigator->GetCurrentNode();}
00457    Int_t                  GetCurrentNodeId() const;
00458    const Double_t        *GetCurrentPoint() const     {return fCurrentNavigator->GetCurrentPoint();}
00459    const Double_t        *GetCurrentDirection() const {return fCurrentNavigator->GetCurrentDirection();}
00460    TGeoVolume            *GetCurrentVolume() const {return fCurrentNavigator->GetCurrentVolume();}
00461    const Double_t        *GetCldirChecked() const  {return fCurrentNavigator->GetCldirChecked();}
00462    const Double_t        *GetCldir() const         {return fCurrentNavigator->GetCldir();}
00463    const Double_t        *GetNormal() const        {return fCurrentNavigator->GetNormal();}
00464    Int_t                  GetLevel() const         {return fCurrentNavigator->GetLevel();}
00465    Int_t                  GetMaxLevel() const      {return fNLevel;}
00466    const char            *GetPath() const;
00467    Int_t                  GetStackLevel() const    {return fCurrentNavigator->GetStackLevel();}
00468    TGeoVolume            *GetMasterVolume() const  {return fMasterVolume;}
00469    TGeoVolume            *GetTopVolume() const     {return fTopVolume;}
00470    TGeoNode              *GetTopNode() const       {return fTopNode;}
00471    TGeoPhysicalNode      *GetPhysicalNode(Int_t i) const {return (TGeoPhysicalNode*)fPhysicalNodes->UncheckedAt(i);}
00472    void                   SetCurrentPoint(Double_t *point) {fCurrentNavigator->SetCurrentPoint(point);}
00473    void                   SetCurrentPoint(Double_t x, Double_t y, Double_t z) {fCurrentNavigator->SetCurrentPoint(x,y,z);}
00474    void                   SetLastPoint(Double_t x, Double_t y, Double_t z) {fCurrentNavigator->SetLastPoint(x,y,z);}
00475    void                   SetCurrentDirection(Double_t *dir) {fCurrentNavigator->SetCurrentDirection(dir);}
00476    void                   SetCurrentDirection(Double_t nx, Double_t ny, Double_t nz) {fCurrentNavigator->SetCurrentDirection(nx,ny,nz);}
00477    void                   SetCldirChecked(Double_t *dir) {fCurrentNavigator->SetCldirChecked(dir);}
00478 
00479    //--- point/vector reference frame conversion
00480    void                   LocalToMaster(const Double_t *local, Double_t *master) const {fCurrentNavigator->LocalToMaster(local, master);}
00481    void                   LocalToMasterVect(const Double_t *local, Double_t *master) const {fCurrentNavigator->LocalToMasterVect(local, master);}
00482    void                   LocalToMasterBomb(const Double_t *local, Double_t *master) const {fCurrentNavigator->LocalToMasterBomb(local, master);}
00483    void                   MasterToLocal(const Double_t *master, Double_t *local) const {fCurrentNavigator->MasterToLocal(master, local);}
00484    void                   MasterToLocalVect(const Double_t *master, Double_t *local) const {fCurrentNavigator->MasterToLocalVect(master, local);}
00485    void                   MasterToLocalBomb(const Double_t *master, Double_t *local) const {fCurrentNavigator->MasterToLocalBomb(master, local);}
00486    void                   MasterToTop(const Double_t *master, Double_t *top) const;
00487    void                   TopToMaster(const Double_t *top, Double_t *master) const;
00488 
00489    //--- general use getters/setters
00490    TGeoMaterial          *FindDuplicateMaterial(const TGeoMaterial *mat) const;
00491    TGeoVolume            *FindVolumeFast(const char*name, Bool_t multi=kFALSE);
00492    TGeoMaterial          *GetMaterial(const char *matname) const;
00493    TGeoMaterial          *GetMaterial(Int_t id) const;
00494    TGeoMedium            *GetMedium(const char *medium) const;
00495    TGeoMedium            *GetMedium(Int_t numed) const;
00496    Int_t                  GetMaterialIndex(const char *matname) const;
00497 //   TGeoShape             *GetShape(const char *name) const;
00498    TGeoVolume            *GetVolume(const char*name) const;
00499    TGeoVolume            *GetVolume(Int_t uid) const {return (TGeoVolume*)fUniqueVolumes->At(uid);}
00500    Int_t                  GetUID(const char *volname) const;
00501    Int_t                  GetNNodes() {if (!fNNodes) CountNodes(); return fNNodes;}
00502    TGeoNodeCache         *GetCache() const         {return fCurrentNavigator->GetCache();}
00503 //   void                   SetCache(const TGeoNodeCache *cache) {fCache = (TGeoNodeCache*)cache;}
00504    void                   SetAnimateTracks(Bool_t flag=kTRUE) {fIsGeomReading=flag;}
00505    virtual ULong_t        SizeOf(const TGeoNode *node, Option_t *option); // size of the geometry in memory
00506    void                   SelectTrackingMedia();
00507 
00508    //--- stack manipulation
00509    Int_t                  PushPath(Int_t startlevel=0) {return fCurrentNavigator->PushPath(startlevel);}
00510    Bool_t                 PopPath() {return fCurrentNavigator->PopPath();}
00511    Bool_t                 PopPath(Int_t index) {return fCurrentNavigator->PopPath(index);}
00512    Int_t                  PushPoint(Int_t startlevel=0) {return fCurrentNavigator->PushPoint(startlevel);}
00513    Bool_t                 PopPoint() {return fCurrentNavigator->PopPoint();}
00514    Bool_t                 PopPoint(Int_t index) {return fCurrentNavigator->PopPoint(index);}
00515    void                   PopDummy(Int_t ipop=9999) {return fCurrentNavigator->PopDummy(ipop);}
00516 
00517    ClassDef(TGeoManager, 12)          // geometry manager
00518 };
00519 
00520 R__EXTERN TGeoManager *gGeoManager;
00521 
00522 #endif
00523