/usr/include/root/TGeoManager.h is in libroot-geom-dev 5.34.19+dfsg-1.2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 | // @(#)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;
class TGeoParallelWorld;
////////////////////////////////////////////////////////////////////////////
// //
// 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[1024]; // 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<Long_t, TGeoNavigatorArray *> NavigatorsMap_t;
typedef NavigatorsMap_t::iterator NavigatorsMapIt_t;
typedef std::map<Long_t, Int_t> 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
Bool_t fUsePWNav; // Activate usage of parallel world in navigation
TGeoParallelWorld *fParallelWorld; // Parallel world
//--- 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, Option_t *option="");
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 (index<fNtracks)?(TVirtualGeoTrack*)fTracks->At(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-1;}
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);}
//--- parallel world navigation
TGeoParallelWorld *CreateParallelWorld(const char *name);
TGeoParallelWorld *GetParallelWorld() const {return fParallelWorld;}
void SetUseParallelWorldNav(Bool_t flag);
Bool_t IsParallelWorldNav() const {return fUsePWNav;}
ClassDef(TGeoManager, 14) // geometry manager
};
R__EXTERN TGeoManager *gGeoManager;
#endif
|