// @(#)root/geom:$Id$ // Author: Andrei Gheata 25/10/01 /************************************************************************* * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. * * All rights reserved. * * * * For the licensing terms see $ROOTSYS/LICENSE. * * For the list of contributors see $ROOTSYS/README/CREDITS. * *************************************************************************/ #ifndef ROOT_TGeoManager #define ROOT_TGeoManager #ifndef ROOT_TObjArray #include "TObjArray.h" #endif #ifndef ROOT_TGeoNavigator #include "TGeoNavigator.h" #endif // forward declarations class TVirtualGeoTrack; class TGeoNode; class TGeoPhysicalNode; class TGeoPNEntry; class TGeoVolume; class TGeoVolumeMulti; class TGeoMatrix; class TGeoHMatrix; class TGeoMaterial; class TGeoMedium; class TGeoShape; class TVirtualGeoPainter; class THashList; //////////////////////////////////////////////////////////////////////////// // // // TGeoManager - The manager class for any TGeo geometry. Provides user // // interface for geometry creation, navigation, state querying, // // visualization, IO, geometry checking and other utilities. // // // //////////////////////////////////////////////////////////////////////////// class TGeoManager : public TNamed { protected: static Bool_t fgLock; //! Lock preventing a second geometry to be loaded static Int_t fgVerboseLevel; //! Verbosity level for Info messages (no IO). static Int_t fgMaxLevel; //! Maximum level in geometry static Int_t fgMaxDaughters; //! Maximum number of daughters static Int_t fgMaxXtruVert; //! Maximum number of Xtru vertices TGeoManager(const TGeoManager&); TGeoManager& operator=(const TGeoManager&); private : Double_t fPhimin; //! lowest range for phi cut Double_t fPhimax; //! highest range for phi cut Double_t fTmin; //! lower time limit for tracks drawing Double_t fTmax; //! upper time limit for tracks drawing Int_t fNNodes; // total number of physical nodes TString fPath; //! path to current node TString fParticleName; //! particles to be drawn Double_t fVisDensity; // transparency threshold by density Int_t fExplodedView; // exploded view mode Int_t fVisOption; // global visualization option Int_t fVisLevel; // maximum visualization depth Int_t fNsegments; // number of segments to approximate circles Int_t fNtracks; // number of tracks Int_t fMaxVisNodes; // maximum number of visible nodes TVirtualGeoTrack *fCurrentTrack; //! current track Int_t fNpdg; // number of different pdg's stored Int_t fPdgId[256]; // pdg conversion table Bool_t fClosed; //! flag that geometry is closed Bool_t fLoopVolumes; //! flag volume lists loop Bool_t fStreamVoxels; // flag to allow voxelization I/O Bool_t fIsGeomReading; //! flag set when reading geometry Bool_t fIsGeomCleaning; //! flag to notify that the manager is being destructed Bool_t fPhiCut; // flag for phi cuts Bool_t fTimeCut; // time cut for tracks Bool_t fDrawExtra; //! flag that the list of physical nodes has to be drawn Bool_t fMatrixTransform; //! flag for using GL matrix Bool_t fMatrixReflection; //! flag for GL reflections Bool_t fActivity; //! switch ON/OFF volume activity (default OFF - all volumes active)) Bool_t fIsNodeSelectable; //! flag that nodes are the selected objects in pad rather than volumes TVirtualGeoPainter *fPainter; //! current painter TObjArray *fMatrices; //-> list of local transformations TObjArray *fShapes; //-> list of shapes TObjArray *fVolumes; //-> list of volumes TObjArray *fPhysicalNodes; //-> list of physical nodes TObjArray *fGShapes; //! list of runtime shapes TObjArray *fGVolumes; //! list of runtime volumes TObjArray *fTracks; //-> list of tracks attached to geometry TObjArray *fPdgNames; //-> list of pdg names for tracks // TObjArray *fNavigators; //! list of navigators TList *fMaterials; //-> list of materials TList *fMedia; //-> list of tracking media TObjArray *fNodes; //-> current branch of nodes TObjArray *fOverlaps; //-> list of geometrical overlaps UChar_t *fBits; //! bits used for voxelization // Map of navigatorr arrays per thread typedef std::map NavigatorsMap_t; typedef NavigatorsMap_t::iterator NavigatorsMapIt_t; typedef std::map ThreadsMap_t; typedef ThreadsMap_t::const_iterator ThreadsMapIt_t; NavigatorsMap_t fNavigators; //! Map between thread id's and navigator arrays static ThreadsMap_t *fgThreadId; //! Thread id's map static Int_t fgNumThreads; //! Number of registered threads static Bool_t fgLockNavigators; //! Lock existing navigators TGeoNavigator *fCurrentNavigator; //! current navigator TGeoVolume *fCurrentVolume; //! current volume TGeoVolume *fTopVolume; //! top level volume in geometry TGeoNode *fTopNode; //! top physical node TGeoVolume *fMasterVolume; // master volume TGeoHMatrix *fGLMatrix; // matrix to be used for view transformations TObjArray *fUniqueVolumes; //-> list of unique volumes TGeoShape *fClippingShape; //! clipping shape for raytracing TGeoElementTable *fElementTable; //! table of elements Int_t *fNodeIdArray; //! array of node id's Int_t fNLevel; // maximum accepted level in geometry TGeoVolume *fPaintVolume; //! volume currently painted THashList *fHashVolumes; //! hash list of volumes providing fast search THashList *fHashGVolumes; //! hash list of group volumes providing fast search THashList *fHashPNE; //-> hash list of phisical node entries mutable TObjArray *fArrayPNE; //! array of phisical node entries Int_t fSizePNEId; // size of the array of unique ID's for PN entries Int_t fNPNEId; // number of PN entries having a unique ID Int_t *fKeyPNEId; //[fSizePNEId] array of uid values for PN entries Int_t *fValuePNEId; //[fSizePNEId] array of pointers to PN entries with ID's Int_t fMaxThreads; //! Max number of threads Bool_t fMultiThread; //! Flag for multi-threading //--- private methods Bool_t IsLoopingVolumes() const {return fLoopVolumes;} void Init(); Bool_t InitArrayPNE() const; Bool_t InsertPNEId(Int_t uid, Int_t ientry); void SetLoopVolumes(Bool_t flag=kTRUE) {fLoopVolumes=flag;} void UpdateElements(); void Voxelize(Option_t *option = 0); public: // constructors TGeoManager(); TGeoManager(const char *name, const char *title); // destructor virtual ~TGeoManager(); //--- adding geometrical objects Int_t AddMaterial(const TGeoMaterial *material); Int_t AddOverlap(const TNamed *ovlp); Int_t AddTransformation(const TGeoMatrix *matrix); Int_t AddShape(const TGeoShape *shape); Int_t AddTrack(Int_t id, Int_t pdgcode, TObject *particle=0); Int_t AddTrack(TVirtualGeoTrack *track); Int_t AddVolume(TGeoVolume *volume); TGeoNavigator *AddNavigator(); void ClearOverlaps(); void RegisterMatrix(const TGeoMatrix *matrix); void SortOverlaps(); //--- browsing and tree navigation void Browse(TBrowser *b); void SetVisibility(TObject *obj, Bool_t vis); virtual Bool_t cd(const char *path=""); // *MENU* Bool_t CheckPath(const char *path) const; void CdNode(Int_t nodeid); void CdDown(Int_t index); void CdUp(); void CdTop(); void CdNext(); void GetBranchNames(Int_t *names) const; void GetBranchNumbers(Int_t *copyNumbers, Int_t *volumeNumbers) const; void GetBranchOnlys(Int_t *isonly) const; Int_t GetNmany() const {return GetCurrentNavigator()->GetNmany();} const char *GetPdgName(Int_t pdg) const; void SetPdgName(Int_t pdg, const char *name); Bool_t IsFolder() const { return kTRUE; } //--- visualization settings virtual void Edit(Option_t *option=""); // *MENU* void BombTranslation(const Double_t *tr, Double_t *bombtr); void UnbombTranslation(const Double_t *tr, Double_t *bombtr); void ClearAttributes(); // *MENU* void DefaultAngles(); // *MENU* void DefaultColors(); // *MENU* TGeoShape *GetClippingShape() const {return fClippingShape;} Int_t GetNsegments() const; TVirtualGeoPainter *GetGeomPainter(); TVirtualGeoPainter *GetPainter() const {return fPainter;} Int_t GetBombMode() const {return fExplodedView;} void GetBombFactors(Double_t &bombx, Double_t &bomby, Double_t &bombz, Double_t &bombr) const; Int_t GetMaxVisNodes() const {return fMaxVisNodes;} Bool_t GetTminTmax(Double_t &tmin, Double_t &tmax) const; Double_t GetTmax() const {return fTmax;} TGeoVolume *GetPaintVolume() const {return fPaintVolume;} Double_t GetVisDensity() const {return fVisDensity;} Int_t GetVisLevel() const; Int_t GetVisOption() const; Bool_t IsInPhiRange() const; Bool_t IsDrawingExtra() const {return fDrawExtra;} Bool_t IsNodeSelectable() const {return fIsNodeSelectable;} Bool_t IsVisLeaves() const {return (fVisOption==1)?kTRUE:kFALSE;} void ModifiedPad() const; void OptimizeVoxels(const char *filename="tgeovox.C"); // *MENU* void SetClipping(Bool_t flag=kTRUE) {SetClippingShape(((flag)?fClippingShape:0));} // *MENU* void SetClippingShape(TGeoShape *clip); void SetExplodedView(Int_t iopt=0); // *MENU* void SetPhiRange(Double_t phimin=0., Double_t phimax=360.); void SetNsegments(Int_t nseg); // *MENU* Bool_t SetCurrentNavigator(Int_t index); void SetBombFactors(Double_t bombx=1.3, Double_t bomby=1.3, Double_t bombz=1.3, Double_t bombr=1.3); // *MENU* void SetPaintVolume(TGeoVolume *vol) {fPaintVolume = vol;} void SetTopVisible(Bool_t vis=kTRUE); void SetTminTmax(Double_t tmin=0, Double_t tmax=999); void SetDrawExtraPaths(Bool_t flag=kTRUE) {fDrawExtra=flag;} void SetNodeSelectable(Bool_t flag=kTRUE) {fIsNodeSelectable=flag;} void SetVisDensity(Double_t dens=0.01); // *MENU* void SetVisLevel(Int_t level=3); // *MENU* void SetVisOption(Int_t option=0); void ViewLeaves(Bool_t flag=kTRUE); // *TOGGLE* *GETTER=IsVisLeaves void SaveAttributes(const char *filename="tgeoatt.C"); // *MENU* void RestoreMasterVolume(); // *MENU* void SetMaxVisNodes(Int_t maxnodes=10000); // *MENU* //--- geometry checking void AnimateTracks(Double_t tmin=0, Double_t tmax=5E-8, Int_t nframes=200, Option_t *option="/*"); // *MENU* void CheckBoundaryErrors(Int_t ntracks=1000000, Double_t radius=-1.); // *MENU* void CheckBoundaryReference(Int_t icheck=-1); void CheckGeometryFull(Int_t ntracks=1000000, Double_t vx=0., Double_t vy=0., Double_t vz=0., Option_t *option="ob"); // *MENU* void CheckGeometry(Option_t *option=""); void CheckOverlaps(Double_t ovlp=0.1, Option_t *option=""); // *MENU* void CheckPoint(Double_t x=0,Double_t y=0, Double_t z=0, Option_t *option=""); // *MENU* void CheckShape(TGeoShape *shape, Int_t testNo, Int_t nsamples, Option_t *option); void ConvertReflections(); void DrawCurrentPoint(Int_t color=2); // *MENU* void DrawTracks(Option_t *option=""); // *MENU* void SetParticleName(const char *pname) {fParticleName=pname;} const char *GetParticleName() const {return fParticleName.Data();} void DrawPath(const char *path); void PrintOverlaps() const; // *MENU* void RandomPoints(const TGeoVolume *vol, Int_t npoints=10000, Option_t *option=""); 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); TGeoNode *SamplePoints(Int_t npoints, Double_t &dist, Double_t epsil=1E-5, const char *g3path=""); void SetNmeshPoints(Int_t npoints=1000); void SetCheckedNode(TGeoNode *node); void Test(Int_t npoints=1000000, Option_t *option=""); // *MENU* void TestOverlaps(const char* path=""); // *MENU* Double_t Weight(Double_t precision=0.01, Option_t *option="va"); // *MENU* //--- GEANT3-like geometry creation TGeoVolume *Division(const char *name, const char *mother, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed=0, Option_t *option=""); void Matrix(Int_t index, Double_t theta1, Double_t phi1, Double_t theta2, Double_t phi2, Double_t theta3, Double_t phi3); 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); TGeoMaterial *Mixture(const char *name, Float_t *a, Float_t *z, Double_t dens, Int_t nelem, Float_t *wmat, Int_t uid); TGeoMaterial *Mixture(const char *name, Double_t *a, Double_t *z, Double_t dens, Int_t nelem, Double_t *wmat, Int_t uid); TGeoMedium *Medium(const char *name, Int_t numed, Int_t nmat, Int_t isvol, Int_t ifield, Double_t fieldm, Double_t tmaxfd, Double_t stemax, Double_t deemax, Double_t epsil, Double_t stmin); void Node(const char *name, Int_t nr, const char *mother, Double_t x, Double_t y, Double_t z, Int_t irot, Bool_t isOnly, Float_t *upar, Int_t npar=0); void Node(const char *name, Int_t nr, const char *mother, Double_t x, Double_t y, Double_t z, Int_t irot, Bool_t isOnly, Double_t *upar, Int_t npar=0); TGeoVolume *Volume(const char *name, const char *shape, Int_t nmed, Float_t *upar, Int_t npar=0); TGeoVolume *Volume(const char *name, const char *shape, Int_t nmed, Double_t *upar, Int_t npar=0); void SetVolumeAttribute(const char *name, const char *att, Int_t val); //--- geometry building void BuildDefaultMaterials(); void CloseGeometry(Option_t *option="d"); Bool_t IsClosed() const {return fClosed;} TGeoVolume *MakeArb8(const char *name, TGeoMedium *medium, Double_t dz, Double_t *vertices=0); TGeoVolume *MakeBox(const char *name, TGeoMedium *medium, Double_t dx, Double_t dy, Double_t dz); TGeoVolume *MakeCone(const char *name, TGeoMedium *medium, Double_t dz, Double_t rmin1, Double_t rmax1, Double_t rmin2, Double_t rmax2); TGeoVolume *MakeCons(const char *name, TGeoMedium *medium, Double_t dz, Double_t rmin1, Double_t rmax1, Double_t rmin2, Double_t rmax2, Double_t phi1, Double_t phi2); TGeoVolume *MakeCtub(const char *name, TGeoMedium *medium, Double_t rmin, Double_t rmax, Double_t dz, Double_t phi1, Double_t phi2, Double_t lx, Double_t ly, Double_t lz, Double_t tx, Double_t ty, Double_t tz); TGeoVolume *MakeEltu(const char *name, TGeoMedium *medium, Double_t a, Double_t b, Double_t dz); TGeoVolume *MakeGtra(const char *name, TGeoMedium *medium, Double_t dz, Double_t theta, Double_t phi, Double_t twist, Double_t h1, Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Double_t bl2, Double_t tl2, Double_t alpha2); TGeoVolume *MakePara(const char *name, TGeoMedium *medium, Double_t dx, Double_t dy, Double_t dz, Double_t alpha, Double_t theta, Double_t phi); TGeoVolume *MakePcon(const char *name, TGeoMedium *medium, Double_t phi, Double_t dphi, Int_t nz); TGeoVolume *MakeParaboloid(const char *name, TGeoMedium *medium, Double_t rlo, Double_t rhi, Double_t dz); TGeoVolume *MakeHype(const char *name, TGeoMedium *medium, Double_t rin, Double_t stin, Double_t rout, Double_t stout, Double_t dz); TGeoVolume *MakePgon(const char *name, TGeoMedium *medium, Double_t phi, Double_t dphi, Int_t nedges, Int_t nz); TGeoVolume *MakeSphere(const char *name, TGeoMedium *medium, Double_t rmin, Double_t rmax, Double_t themin=0, Double_t themax=180, Double_t phimin=0, Double_t phimax=360); TGeoVolume *MakeTorus(const char *name, TGeoMedium *medium, Double_t r, Double_t rmin, Double_t rmax, Double_t phi1=0, Double_t dphi=360); TGeoVolume *MakeTrap(const char *name, TGeoMedium *medium, Double_t dz, Double_t theta, Double_t phi, Double_t h1, Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Double_t bl2, Double_t tl2, Double_t alpha2); TGeoVolume *MakeTrd1(const char *name, TGeoMedium *medium, Double_t dx1, Double_t dx2, Double_t dy, Double_t dz); TGeoVolume *MakeTrd2(const char *name, TGeoMedium *medium, Double_t dx1, Double_t dx2, Double_t dy1, Double_t dy2, Double_t dz); TGeoVolume *MakeTube(const char *name, TGeoMedium *medium, Double_t rmin, Double_t rmax, Double_t dz); TGeoVolume *MakeTubs(const char *name, TGeoMedium *medium, Double_t rmin, Double_t rmax, Double_t dz, Double_t phi1, Double_t phi2); TGeoVolume *MakeXtru(const char *name, TGeoMedium *medium, Int_t nz); TGeoPNEntry *SetAlignableEntry(const char *unique_name, const char *path, Int_t uid=-1); TGeoPNEntry *GetAlignableEntry(const char *name) const; TGeoPNEntry *GetAlignableEntry(Int_t index) const; TGeoPNEntry *GetAlignableEntryByUID(Int_t uid) const; Int_t GetNAlignable(Bool_t with_uid=kFALSE) const; TGeoPhysicalNode *MakeAlignablePN(const char *name); TGeoPhysicalNode *MakeAlignablePN(TGeoPNEntry *entry); TGeoPhysicalNode *MakePhysicalNode(const char *path=0); void ClearPhysicalNodes(Bool_t mustdelete=kFALSE); void RefreshPhysicalNodes(Bool_t lock=kTRUE); TVirtualGeoTrack *MakeTrack(Int_t id, Int_t pdgcode, TObject *particle); TGeoVolumeAssembly *MakeVolumeAssembly(const char *name); TGeoVolumeMulti *MakeVolumeMulti(const char *name, TGeoMedium *medium); void SetTopVolume(TGeoVolume *vol); //--- geometry queries TGeoNode *CrossBoundaryAndLocate(Bool_t downwards, TGeoNode *skipnode); TGeoNode *FindNextBoundary(Double_t stepmax=TGeoShape::Big(),const char *path="", Bool_t frombdr=kFALSE); TGeoNode *FindNextDaughterBoundary(Double_t *point, Double_t *dir, Int_t &idaughter, Bool_t compmatrix=kFALSE); TGeoNode *FindNextBoundaryAndStep(Double_t stepmax=TGeoShape::Big(), Bool_t compsafe=kFALSE); TGeoNode *FindNode(Bool_t safe_start=kTRUE); TGeoNode *FindNode(Double_t x, Double_t y, Double_t z); Double_t *FindNormal(Bool_t forward=kTRUE); Double_t *FindNormalFast(); TGeoNode *InitTrack(const Double_t *point, const Double_t *dir); TGeoNode *InitTrack(Double_t x, Double_t y, Double_t z, Double_t nx, Double_t ny, Double_t nz); void ResetState(); Double_t Safety(Bool_t inside=kFALSE); TGeoNode *SearchNode(Bool_t downwards=kFALSE, const TGeoNode *skipnode=0); TGeoNode *Step(Bool_t is_geom=kTRUE, Bool_t cross=kTRUE); void DisableInactiveVolumes() {fActivity=kTRUE;} void EnableInactiveVolumes() {fActivity=kFALSE;} void SetCurrentTrack(Int_t i) {fCurrentTrack = (TVirtualGeoTrack*)fTracks->At(i);} void SetCurrentTrack(TVirtualGeoTrack *track) {fCurrentTrack=track;} Int_t GetNtracks() const {return fNtracks;} TVirtualGeoTrack *GetCurrentTrack() {return fCurrentTrack;} TVirtualGeoTrack *GetLastTrack() {return (TVirtualGeoTrack*)((fNtracks>0)?fTracks->At(fNtracks-1):NULL);} const Double_t *GetLastPoint() const {return GetCurrentNavigator()->GetLastPoint();} TVirtualGeoTrack *GetTrack(Int_t index) {return (indexAt(index):0;} Int_t GetTrackIndex(Int_t id) const; TVirtualGeoTrack *GetTrackOfId(Int_t id) const; TVirtualGeoTrack *FindTrackWithId(Int_t id) const; TVirtualGeoTrack *GetParentTrackOfId(Int_t id) const; Int_t GetVirtualLevel(); Bool_t GotoSafeLevel(); Int_t GetSafeLevel() const; Double_t GetSafeDistance() const {return GetCurrentNavigator()->GetSafeDistance();} Double_t GetLastSafety() const {return GetCurrentNavigator()->GetLastSafety();} Double_t GetStep() const {return GetCurrentNavigator()->GetStep();} void InspectState() const; Bool_t IsAnimatingTracks() const {return fIsGeomReading;} Bool_t IsCheckingOverlaps() const {return GetCurrentNavigator()->IsCheckingOverlaps();} Bool_t IsMatrixTransform() const {return fMatrixTransform;} Bool_t IsMatrixReflection() const {return fMatrixReflection;} Bool_t IsSameLocation(Double_t x, Double_t y, Double_t z, Bool_t change=kFALSE); Bool_t IsSameLocation() const {return GetCurrentNavigator()->IsSameLocation();} Bool_t IsSamePoint(Double_t x, Double_t y, Double_t z) const; Bool_t IsStartSafe() const {return GetCurrentNavigator()->IsStartSafe();} void SetCheckingOverlaps(Bool_t flag=kTRUE) {GetCurrentNavigator()->SetCheckingOverlaps(flag);} void SetStartSafe(Bool_t flag=kTRUE) {GetCurrentNavigator()->SetStartSafe(flag);} void SetMatrixTransform(Bool_t on=kTRUE) {fMatrixTransform = on;} void SetMatrixReflection(Bool_t flag=kTRUE) {fMatrixReflection = flag;} void SetStep(Double_t step) {GetCurrentNavigator()->SetStep(step);} Bool_t IsCurrentOverlapping() const {return GetCurrentNavigator()->IsCurrentOverlapping();} Bool_t IsEntering() const {return GetCurrentNavigator()->IsEntering();} Bool_t IsExiting() const {return GetCurrentNavigator()->IsExiting();} Bool_t IsStepEntering() const {return GetCurrentNavigator()->IsStepEntering();} Bool_t IsStepExiting() const {return GetCurrentNavigator()->IsStepExiting();} Bool_t IsOutside() const {return GetCurrentNavigator()->IsOutside();} Bool_t IsOnBoundary() const {return GetCurrentNavigator()->IsOnBoundary();} Bool_t IsNullStep() const {return GetCurrentNavigator()->IsNullStep();} Bool_t IsActivityEnabled() const {return fActivity;} void SetOutside(Bool_t flag=kTRUE) {GetCurrentNavigator()->SetOutside(flag);} //--- cleaning void CleanGarbage(); void ClearShape(const TGeoShape *shape); void ClearTracks() {fTracks->Delete(); fNtracks=0;} void ClearNavigators(); void RemoveMaterial(Int_t index); void RemoveNavigator(const TGeoNavigator *nav); void ResetUserData(); //--- utilities Int_t CountNodes(const TGeoVolume *vol=0, Int_t nlevels=10000, Int_t option=0); void CountLevels(); virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py); static Int_t Parse(const char* expr, TString &expr1, TString &expr2, TString &expr3); Int_t ReplaceVolume(TGeoVolume *vorig, TGeoVolume *vnew); Int_t TransformVolumeToAssembly(const char *vname); UChar_t *GetBits() {return fBits;} virtual Int_t GetByteCount(Option_t *option=0); void SetAllIndex(); static Int_t GetMaxDaughters(); static Int_t GetMaxLevels(); static Int_t GetMaxXtruVert(); Int_t GetMaxThreads() const {return fMaxThreads;} void SetMaxThreads(Int_t nthreads); void SetMultiThread(Bool_t flag=kTRUE) {fMultiThread = flag;} Bool_t IsMultiThread() const {return fMultiThread;} static void SetNavigatorsLock(Bool_t flag); static Int_t ThreadId(); static Int_t GetNumThreads(); static void ClearThreadsMap(); void ClearThreadData() const; void CreateThreadData() const; //--- I/O virtual Int_t Export(const char *filename, const char *name="", Option_t *option="vg"); static void LockGeometry(); static void UnlockGeometry(); static Int_t GetVerboseLevel(); static void SetVerboseLevel(Int_t vl); static TGeoManager *Import(const char *filename, const char *name="", Option_t *option=""); static Bool_t IsLocked(); Bool_t IsStreamingVoxels() const {return fStreamVoxels;} Bool_t IsCleaning() const {return fIsGeomCleaning;} //--- list getters TObjArray *GetListOfNodes() {return fNodes;} TObjArray *GetListOfPhysicalNodes() {return fPhysicalNodes;} TObjArray *GetListOfOverlaps() {return fOverlaps;} TObjArray *GetListOfMatrices() const {return fMatrices;} TList *GetListOfMaterials() const {return fMaterials;} TList *GetListOfMedia() const {return fMedia;} TObjArray *GetListOfVolumes() const {return fVolumes;} TObjArray *GetListOfGVolumes() const {return fGVolumes;} TObjArray *GetListOfShapes() const {return fShapes;} TObjArray *GetListOfGShapes() const {return fGShapes;} TObjArray *GetListOfUVolumes() const {return fUniqueVolumes;} TObjArray *GetListOfTracks() const {return fTracks;} TGeoNavigatorArray *GetListOfNavigators() const; TGeoElementTable *GetElementTable(); //--- modeler state getters/setters void DoBackupState(); void DoRestoreState(); TGeoNode *GetNode(Int_t level) const {return (TGeoNode*)fNodes->UncheckedAt(level);} Int_t GetNodeId() const {return GetCurrentNavigator()->GetNodeId();} TGeoNode *GetNextNode() const {return GetCurrentNavigator()->GetNextNode();} TGeoNode *GetMother(Int_t up=1) const {return GetCurrentNavigator()->GetMother(up);} TGeoHMatrix *GetMotherMatrix(Int_t up=1) const {return GetCurrentNavigator()->GetMotherMatrix(up);} TGeoHMatrix *GetHMatrix(); TGeoHMatrix *GetCurrentMatrix() const {return GetCurrentNavigator()->GetCurrentMatrix();} TGeoHMatrix *GetGLMatrix() const {return fGLMatrix;} TGeoNavigator *GetCurrentNavigator() const; TGeoNode *GetCurrentNode() const {return GetCurrentNavigator()->GetCurrentNode();} Int_t GetCurrentNodeId() const; const Double_t *GetCurrentPoint() const {return GetCurrentNavigator()->GetCurrentPoint();} const Double_t *GetCurrentDirection() const {return GetCurrentNavigator()->GetCurrentDirection();} TGeoVolume *GetCurrentVolume() const {return GetCurrentNavigator()->GetCurrentVolume();} const Double_t *GetCldirChecked() const {return GetCurrentNavigator()->GetCldirChecked();} const Double_t *GetCldir() const {return GetCurrentNavigator()->GetCldir();} const Double_t *GetNormal() const {return GetCurrentNavigator()->GetNormal();} Int_t GetLevel() const {return GetCurrentNavigator()->GetLevel();} Int_t GetMaxLevel() const {return fNLevel;} const char *GetPath() const; Int_t GetStackLevel() const {return GetCurrentNavigator()->GetStackLevel();} TGeoVolume *GetMasterVolume() const {return fMasterVolume;} TGeoVolume *GetTopVolume() const {return fTopVolume;} TGeoNode *GetTopNode() const {return fTopNode;} TGeoPhysicalNode *GetPhysicalNode(Int_t i) const {return (TGeoPhysicalNode*)fPhysicalNodes->UncheckedAt(i);} void SetCurrentPoint(Double_t *point) {GetCurrentNavigator()->SetCurrentPoint(point);} void SetCurrentPoint(Double_t x, Double_t y, Double_t z) {GetCurrentNavigator()->SetCurrentPoint(x,y,z);} void SetLastPoint(Double_t x, Double_t y, Double_t z) {GetCurrentNavigator()->SetLastPoint(x,y,z);} void SetCurrentDirection(Double_t *dir) {GetCurrentNavigator()->SetCurrentDirection(dir);} void SetCurrentDirection(Double_t nx, Double_t ny, Double_t nz) {GetCurrentNavigator()->SetCurrentDirection(nx,ny,nz);} void SetCldirChecked(Double_t *dir) {GetCurrentNavigator()->SetCldirChecked(dir);} //--- point/vector reference frame conversion void LocalToMaster(const Double_t *local, Double_t *master) const {GetCurrentNavigator()->LocalToMaster(local, master);} void LocalToMasterVect(const Double_t *local, Double_t *master) const {GetCurrentNavigator()->LocalToMasterVect(local, master);} void LocalToMasterBomb(const Double_t *local, Double_t *master) const {GetCurrentNavigator()->LocalToMasterBomb(local, master);} void MasterToLocal(const Double_t *master, Double_t *local) const {GetCurrentNavigator()->MasterToLocal(master, local);} void MasterToLocalVect(const Double_t *master, Double_t *local) const {GetCurrentNavigator()->MasterToLocalVect(master, local);} void MasterToLocalBomb(const Double_t *master, Double_t *local) const {GetCurrentNavigator()->MasterToLocalBomb(master, local);} void MasterToTop(const Double_t *master, Double_t *top) const; void TopToMaster(const Double_t *top, Double_t *master) const; //--- general use getters/setters TGeoMaterial *FindDuplicateMaterial(const TGeoMaterial *mat) const; TGeoVolume *FindVolumeFast(const char*name, Bool_t multi=kFALSE); TGeoMaterial *GetMaterial(const char *matname) const; TGeoMaterial *GetMaterial(Int_t id) const; TGeoMedium *GetMedium(const char *medium) const; TGeoMedium *GetMedium(Int_t numed) const; Int_t GetMaterialIndex(const char *matname) const; // TGeoShape *GetShape(const char *name) const; TGeoVolume *GetVolume(const char*name) const; TGeoVolume *GetVolume(Int_t uid) const {return (TGeoVolume*)fUniqueVolumes->At(uid);} Int_t GetUID(const char *volname) const; Int_t GetNNodes() {if (!fNNodes) CountNodes(); return fNNodes;} TGeoNodeCache *GetCache() const {return GetCurrentNavigator()->GetCache();} // void SetCache(const TGeoNodeCache *cache) {fCache = (TGeoNodeCache*)cache;} void SetAnimateTracks(Bool_t flag=kTRUE) {fIsGeomReading=flag;} virtual ULong_t SizeOf(const TGeoNode *node, Option_t *option); // size of the geometry in memory void SelectTrackingMedia(); //--- stack manipulation Int_t PushPath(Int_t startlevel=0) {return GetCurrentNavigator()->PushPath(startlevel);} Bool_t PopPath() {return GetCurrentNavigator()->PopPath();} Bool_t PopPath(Int_t index) {return GetCurrentNavigator()->PopPath(index);} Int_t PushPoint(Int_t startlevel=0) {return GetCurrentNavigator()->PushPoint(startlevel);} Bool_t PopPoint() {return GetCurrentNavigator()->PopPoint();} Bool_t PopPoint(Int_t index) {return GetCurrentNavigator()->PopPoint(index);} void PopDummy(Int_t ipop=9999) {return GetCurrentNavigator()->PopDummy(ipop);} ClassDef(TGeoManager, 12) // geometry manager }; R__EXTERN TGeoManager *gGeoManager; #endif