library: libGeom #include "TGeoManager.h" |
TGeoManager
class description - header file - source file
viewCVS header - viewCVS source
class TGeoManager: public TNamed
Function Members (Methods)
Display options:
public:
| TGeoManager() |
| TGeoManager(const char* name, const char* title) |
virtual | ~TGeoManager() |
void | TObject::AbstractMethod(const char* method) const |
Int_t | AddMaterial(const TGeoMaterial* material) |
Int_t | AddOverlap(const TNamed* ovlp) |
Int_t | AddShape(const TGeoShape* shape) |
Int_t | AddTrack(Int_t id, Int_t pdgcode, TObject* particle = 0) |
Int_t | AddTransformation(const TGeoMatrix* matrix) |
Int_t | AddVolume(TGeoVolume* volume) |
void | AnimateTracks(Double_t tmin = 0, Double_t tmax = 5E-8, Int_t nframes = 200, Option_t* option = "/*") |
virtual void | TObject::AppendPad(Option_t* option = "") |
void | BombTranslation(const Double_t* tr, Double_t* bombtr) |
virtual void | Browse(TBrowser* b) |
void | BuildDefaultMaterials() |
virtual Bool_t | cd(const char* path = "") |
void | CdDown(Int_t index) |
void | CdNode(Int_t nodeid) |
void | CdTop() |
void | CdUp() |
void | CheckGeometry(Option_t* option = "") |
void | CheckOverlaps(Double_t ovlp = 0.1, Option_t* option = "") |
Bool_t | CheckPath(const char* path) const |
void | CheckPoint(Double_t x = 0, Double_t y = 0, Double_t z = 0, Option_t* option = "") |
static TClass* | Class() |
virtual const char* | TObject::ClassName() const |
void | CleanGarbage() |
virtual void | TNamed::Clear(Option_t* option = "") |
void | ClearAttributes() |
void | ClearOverlaps() |
void | ClearPhysicalNodes(Bool_t mustdelete = kFALSE) |
void | ClearShape(const TGeoShape* shape) |
void | ClearTracks() |
virtual TObject* | TNamed::Clone(const char* newname = "") const |
void | CloseGeometry(Option_t* option = "d") |
virtual Int_t | TNamed::Compare(const TObject* obj) const |
void | ConvertReflections() |
virtual void | TNamed::Copy(TObject& named) const |
Int_t | CountNodes(const TGeoVolume* vol = 0, Int_t nlevels = 10000, Int_t option = 0) |
TGeoNode* | CrossBoundaryAndLocate(Bool_t downwards, TGeoNode* skipnode) |
void | DefaultAngles() |
void | DefaultColors() |
virtual void | TObject::Delete(Option_t* option = "") |
void | DisableInactiveVolumes() |
virtual Int_t | TObject::DistancetoPrimitive(Int_t px, Int_t py) |
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 = "") |
virtual void | TObject::Draw(Option_t* option = "") |
virtual void | TObject::DrawClass() const |
virtual TObject* | TObject::DrawClone(Option_t* option = "") const |
void | DrawCurrentPoint(Int_t color = 2) |
void | DrawPath(const char* path) |
void | DrawTracks(Option_t* option = "") |
virtual void | TObject::Dump() const |
virtual void | Edit(Option_t* option = "") |
void | EnableInactiveVolumes() |
virtual void | TObject::Error(const char* method, const char* msgfmt) const |
virtual void | TObject::Execute(const char* method, const char* params, Int_t* error = 0) |
virtual void | TObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0) |
virtual void | ExecuteEvent(Int_t event, Int_t px, Int_t py) |
virtual Int_t | Export(const char* filename, const char* name = "", Option_t* option = "v") |
virtual void | TObject::Fatal(const char* method, const char* msgfmt) const |
virtual void | TNamed::FillBuffer(char*& buffer) |
TGeoMaterial* | FindDuplicateMaterial(const TGeoMaterial* mat) const |
TGeoNode* | FindNextBoundary(Double_t stepmax = TGeoShape::Big(), const char* path = "") |
TGeoNode* | FindNextBoundaryAndStep(Double_t stepmax = TGeoShape::Big(), Bool_t compsafe = kFALSE) |
TGeoNode* | FindNextDaughterBoundary(Double_t* point, Double_t* dir, Int_t& idaughter, Bool_t compmatrix = 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() |
virtual TObject* | TObject::FindObject(const char* name) const |
virtual TObject* | TObject::FindObject(const TObject* obj) const |
TGeoVolume* | FindVolumeFast(const char* name, Bool_t multi = kFALSE) |
TGeoPNEntry* | GetAlignableEntry(const char* name) const |
TGeoPNEntry* | GetAlignableEntry(Int_t index) const |
UChar_t* | GetBits() |
void | GetBombFactors(Double_t& bombx, Double_t& bomby, Double_t& bombz, Double_t& bombr) const |
Int_t | GetBombMode() const |
void | GetBranchNames(Int_t* names) const |
void | GetBranchNumbers(Int_t* copyNumbers, Int_t* volumeNumbers) const |
void | GetBranchOnlys(Int_t* isonly) const |
virtual Int_t | GetByteCount(Option_t* option = "0") |
TGeoNodeCache* | GetCache() const |
Double_t* | GetCldir() const |
Double_t* | GetCldirChecked() const |
TGeoShape* | GetClippingShape() const |
Double_t* | GetCurrentDirection() const |
TGeoHMatrix* | GetCurrentMatrix() const |
TGeoNode* | GetCurrentNode() const |
Int_t | GetCurrentNodeId() const |
Double_t* | GetCurrentPoint() const |
TVirtualGeoTrack* | GetCurrentTrack() |
TGeoVolume* | GetCurrentVolume() const |
Double_t* | GetDblBuffer(Int_t length) |
virtual Option_t* | TObject::GetDrawOption() const |
static Long_t | TObject::GetDtorOnly() |
TGeoElementTable* | GetElementTable() const |
TVirtualGeoPainter* | GetGeomPainter() |
TGeoHMatrix* | GetGLMatrix() const |
TGeoHMatrix* | GetHMatrix() |
virtual const char* | TObject::GetIconName() const |
Int_t* | GetIntBuffer(Int_t length) |
const Double_t* | GetLastPoint() const |
TVirtualGeoTrack* | GetLastTrack() |
Int_t | GetLevel() const |
TObjArray* | GetListOfGVolumes() const |
TList* | GetListOfMaterials() const |
TObjArray* | GetListOfMatrices() const |
TList* | GetListOfMedia() const |
TObjArray* | GetListOfNodes() |
TObjArray* | GetListOfOverlaps() |
TObjArray* | GetListOfPhysicalNodes() |
TObjArray* | GetListOfShapes() const |
TObjArray* | GetListOfTracks() const |
TObjArray* | GetListOfUVolumes() const |
TObjArray* | GetListOfVolumes() const |
TGeoVolume* | GetMasterVolume() const |
TGeoMaterial* | GetMaterial(const char* matname) const |
TGeoMaterial* | GetMaterial(Int_t id) const |
Int_t | GetMaterialIndex(const char* matname) const |
Int_t | GetMaxVisNodes() const |
TGeoMedium* | GetMedium(const char* medium) const |
TGeoMedium* | GetMedium(Int_t numed) const |
TGeoNode* | GetMother(Int_t up = 1) const |
TGeoHMatrix* | GetMotherMatrix(Int_t up = 1) const |
Int_t | GetNAlignable() const |
virtual const char* | TNamed::GetName() const |
TGeoNode* | GetNextNode() const |
Int_t | GetNmany() const |
Int_t | GetNNodes() |
TGeoNode* | GetNode(Int_t level) const |
Int_t | GetNodeId() const |
const Double_t* | GetNormal() const |
Int_t | GetNsegments() const |
Int_t | GetNtracks() const |
virtual char* | TObject::GetObjectInfo(Int_t px, Int_t py) const |
static Bool_t | TObject::GetObjectStat() |
virtual Option_t* | TObject::GetOption() const |
TVirtualGeoPainter* | GetPainter() const |
TGeoVolume* | GetPaintVolume() const |
TVirtualGeoTrack* | GetParentTrackOfId(Int_t id) const |
const char* | GetParticleName() const |
const char* | GetPath() const |
const char* | GetPdgName(Int_t pdg) const |
TGeoPhysicalNode* | GetPhysicalNode(Int_t i) const |
Double_t | GetSafeDistance() const |
Int_t | GetSafeLevel() const |
Int_t | GetStackLevel() const |
Double_t | GetStep() const |
virtual const char* | TNamed::GetTitle() const |
Double_t | GetTmax() const |
Bool_t | GetTminTmax(Double_t& tmin, Double_t& tmax) const |
TGeoNode* | GetTopNode() const |
TGeoVolume* | GetTopVolume() const |
TVirtualGeoTrack* | GetTrack(Int_t index) |
Int_t | GetTrackIndex(Int_t id) const |
TVirtualGeoTrack* | GetTrackOfId(Int_t id) const |
Int_t | GetUID(const char* volname) const |
virtual UInt_t | TObject::GetUniqueID() const |
Int_t | GetVirtualLevel() |
Double_t | GetVisDensity() const |
Int_t | GetVisLevel() const |
Int_t | GetVisOption() const |
TGeoVolume* | GetVolume(const char* name) const |
TGeoVolume* | GetVolume(Int_t uid) const |
Bool_t | GotoSafeLevel() |
virtual Bool_t | TObject::HandleTimer(TTimer* timer) |
virtual ULong_t | TNamed::Hash() const |
static TGeoManager* | Import(const char* filename, const char* name = "", Option_t* option = "") |
virtual void | TObject::Info(const char* method, const char* msgfmt) const |
virtual Bool_t | TObject::InheritsFrom(const char* classname) const |
virtual Bool_t | TObject::InheritsFrom(const TClass* cl) const |
TGeoNode* | InitTrack(Double_t* point, Double_t* dir) |
TGeoNode* | InitTrack(Double_t x, Double_t y, Double_t z, Double_t nx, Double_t ny, Double_t nz) |
virtual void | TObject::Inspect() const |
void | InspectState() const |
void | TObject::InvertBit(UInt_t f) |
virtual TClass* | IsA() const |
Bool_t | IsActivityEnabled() const |
Bool_t | IsAnimatingTracks() const |
Bool_t | IsCheckingOverlaps() const |
Bool_t | IsClosed() const |
Bool_t | IsCurrentOverlapping() const |
Bool_t | IsDrawingExtra() const |
Bool_t | IsEntering() const |
virtual Bool_t | TObject::IsEqual(const TObject* obj) const |
Bool_t | IsExiting() const |
virtual Bool_t | IsFolder() const |
Bool_t | IsInPhiRange() const |
static Bool_t | IsLocked() |
Bool_t | IsMatrixReflection() const |
Bool_t | IsMatrixTransform() const |
Bool_t | IsNodeSelectable() const |
Bool_t | IsNullStep() const |
Bool_t | IsOnBoundary() const |
Bool_t | TObject::IsOnHeap() const |
Bool_t | IsOutside() const |
Bool_t | IsSameLocation() const |
Bool_t | IsSameLocation(Double_t x, Double_t y, Double_t z, Bool_t change = kFALSE) |
Bool_t | IsSamePoint(Double_t x, Double_t y, Double_t z) const |
virtual Bool_t | TNamed::IsSortable() const |
Bool_t | IsStartSafe() const |
Bool_t | IsStepEntering() const |
Bool_t | IsStepExiting() const |
Bool_t | IsStreamingVoxels() const |
Bool_t | IsVisLeaves() const |
Bool_t | TObject::IsZombie() const |
void | LocalToMaster(const Double_t* local, Double_t* master) const |
void | LocalToMasterBomb(const Double_t* local, Double_t* master) const |
void | LocalToMasterVect(const Double_t* local, Double_t* master) const |
static void | LockGeometry() |
virtual void | TNamed::ls(Option_t* option = "") const |
TGeoPhysicalNode* | MakeAlignablePN(const char* name) |
TGeoPhysicalNode* | MakeAlignablePN(TGeoPNEntry* entry) |
TGeoVolume* | MakeArb8(const char* name, const TGeoMedium* medium, Double_t dz, Double_t* vertices = 0) |
TGeoVolume* | MakeBox(const char* name, const TGeoMedium* medium, Double_t dx, Double_t dy, Double_t dz) |
TGeoVolume* | MakeCone(const char* name, const TGeoMedium* medium, Double_t dz, Double_t rmin1, Double_t rmax1, Double_t rmin2, Double_t rmax2) |
TGeoVolume* | MakeCons(const char* name, const 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, const 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, const TGeoMedium* medium, Double_t a, Double_t b, Double_t dz) |
TGeoVolume* | MakeGtra(const char* name, const 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* | MakeHype(const char* name, const TGeoMedium* medium, Double_t rin, Double_t stin, Double_t rout, Double_t stout, Double_t dz) |
TGeoVolume* | MakePara(const char* name, const TGeoMedium* medium, Double_t dx, Double_t dy, Double_t dz, Double_t alpha, Double_t theta, Double_t phi) |
TGeoVolume* | MakeParaboloid(const char* name, const TGeoMedium* medium, Double_t rlo, Double_t rhi, Double_t dz) |
TGeoVolume* | MakePcon(const char* name, const TGeoMedium* medium, Double_t phi, Double_t dphi, Int_t nz) |
TGeoVolume* | MakePgon(const char* name, const TGeoMedium* medium, Double_t phi, Double_t dphi, Int_t nedges, Int_t nz) |
TGeoPhysicalNode* | MakePhysicalNode(const char* path = "0") |
TGeoVolume* | MakeSphere(const char* name, const 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, const TGeoMedium* medium, Double_t r, Double_t rmin, Double_t rmax, Double_t phi1 = 0, Double_t dphi = 360) |
TVirtualGeoTrack* | MakeTrack(Int_t id, Int_t pdgcode, TObject* particle) |
TGeoVolume* | MakeTrap(const char* name, const 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, const TGeoMedium* medium, Double_t dx1, Double_t dx2, Double_t dy, Double_t dz) |
TGeoVolume* | MakeTrd2(const char* name, const TGeoMedium* medium, Double_t dx1, Double_t dx2, Double_t dy1, Double_t dy2, Double_t dz) |
TGeoVolume* | MakeTube(const char* name, const TGeoMedium* medium, Double_t rmin, Double_t rmax, Double_t dz) |
TGeoVolume* | MakeTubs(const char* name, const TGeoMedium* medium, Double_t rmin, Double_t rmax, Double_t dz, Double_t phi1, Double_t phi2) |
TGeoVolumeAssembly* | MakeVolumeAssembly(const char* name) |
TGeoVolumeMulti* | MakeVolumeMulti(const char* name, const TGeoMedium* medium) |
TGeoVolume* | MakeXtru(const char* name, const TGeoMedium* medium, Int_t nz) |
void | MasterToLocal(const Double_t* master, Double_t* local) const |
void | MasterToLocalBomb(const Double_t* master, Double_t* local) const |
void | MasterToLocalVect(const Double_t* master, Double_t* local) const |
void | MasterToTop(const Double_t* master, Double_t* top) const |
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) |
void | Matrix(Int_t index, Double_t theta1, Double_t phi1, Double_t theta2, Double_t phi2, Double_t theta3, Double_t phi3) |
void | TObject::MayNotUse(const char* method) const |
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) |
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) |
void | ModifiedPad() const |
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) |
virtual Bool_t | TObject::Notify() |
static void | TObject::operator delete(void* ptr) |
static void | TObject::operator delete(void* ptr, void* vp) |
static void | TObject::operator delete[](void* ptr) |
static void | TObject::operator delete[](void* ptr, void* vp) |
void* | TObject::operator new(size_t sz) |
void* | TObject::operator new(size_t sz, void* vp) |
void* | TObject::operator new[](size_t sz) |
void* | TObject::operator new[](size_t sz, void* vp) |
void | OptimizeVoxels(const char* filename = "tgeovox.C") |
virtual void | TObject::Paint(Option_t* option = "") |
static Int_t | Parse(const char* expr, TString& expr1, TString& expr2, TString& expr3) |
virtual void | TObject::Pop() |
void | PopDummy(Int_t ipop = 9999) |
Bool_t | PopPath() |
Bool_t | PopPath(Int_t index) |
Bool_t | PopPoint() |
Bool_t | PopPoint(Int_t index) |
virtual void | TNamed::Print(Option_t* option = "") const |
void | PrintOverlaps() const |
Int_t | PushPath(Int_t startlevel = 0) |
Int_t | PushPoint(Int_t startlevel = 0) |
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) |
virtual Int_t | TObject::Read(const char* name) |
virtual void | TObject::RecursiveRemove(TObject* obj) |
void | RegisterMatrix(const TGeoMatrix* matrix) |
void | RemoveMaterial(Int_t index) |
Int_t | ReplaceVolume(TGeoVolume* vorig, TGeoVolume* vnew) |
void | TObject::ResetBit(UInt_t f) |
void | ResetState() |
void | ResetUserData() |
void | RestoreMasterVolume() |
Double_t | Safety(Bool_t inside = kFALSE) |
TGeoNode* | SamplePoints(Int_t npoints, Double_t& dist, Double_t epsil = 1E-5, const char* g3path = "") |
virtual void | TObject::SaveAs(const char* filename = "", Option_t* option = "") const |
void | SaveAttributes(const char* filename = "tgeoatt.C") |
virtual void | TObject::SavePrimitive(ostream& out, Option_t* option = "") |
TGeoNode* | SearchNode(Bool_t downwards = kFALSE, const TGeoNode* skipnode = 0) |
void | SelectTrackingMedia() |
TGeoPNEntry* | SetAlignableEntry(const char* unique_name, const char* path) |
void | SetAllIndex() |
void | SetAnimateTracks(Bool_t flag = kTRUE) |
void | TObject::SetBit(UInt_t f) |
void | TObject::SetBit(UInt_t f, Bool_t set) |
void | SetBombFactors(Double_t bombx = 1.3, Double_t bomby = 1.3, Double_t bombz = 1.3, Double_t bombr = 1.3) |
void | SetCache(const TGeoNodeCache* cache) |
void | SetCheckingOverlaps(Bool_t flag = kTRUE) |
void | SetCldirChecked(Double_t* dir) |
void | SetClipping(Bool_t flag = kTRUE) |
void | SetClippingShape(TGeoShape* clip) |
void | SetCurrentDirection(Double_t* dir) |
void | SetCurrentDirection(Double_t nx, Double_t ny, Double_t nz) |
void | SetCurrentPoint(Double_t* point) |
void | SetCurrentPoint(Double_t x, Double_t y, Double_t z) |
void | SetCurrentTrack(Int_t i) |
void | SetCurrentTrack(TVirtualGeoTrack* track) |
void | SetDrawExtraPaths(Bool_t flag = kTRUE) |
virtual void | TObject::SetDrawOption(Option_t* option = "") |
static void | TObject::SetDtorOnly(void* obj) |
void | SetExplodedView(Int_t iopt = 0) |
void | SetLastPoint(Double_t x, Double_t y, Double_t z) |
void | SetMatrixReflection(Bool_t flag = kTRUE) |
void | SetMatrixTransform(Bool_t on = kTRUE) |
void | SetMaxVisNodes(Int_t maxnodes = 10000) |
virtual void | TNamed::SetName(const char* name) |
virtual void | TNamed::SetNameTitle(const char* name, const char* title) |
void | SetNodeSelectable(Bool_t flag = kTRUE) |
void | SetNsegments(Int_t nseg) |
static void | TObject::SetObjectStat(Bool_t stat) |
void | SetOutside(Bool_t flag = kTRUE) |
void | SetPaintVolume(TGeoVolume* vol) |
void | SetParticleName(const char* pname) |
void | SetPdgName(Int_t pdg, const char* name) |
void | SetPhiRange(Double_t phimin = 0., Double_t phimax = 360.) |
void | SetStartSafe(Bool_t flag = kTRUE) |
void | SetStep(Double_t step) |
virtual void | TNamed::SetTitle(const char* title = "") |
void | SetTminTmax(Double_t tmin = 0, Double_t tmax = 999) |
void | SetTopVisible(Bool_t vis = kTRUE) |
void | SetTopVolume(TGeoVolume* vol) |
virtual void | TObject::SetUniqueID(UInt_t uid) |
void | SetVisDensity(Double_t dens = 0.01) |
void | SetVisibility(TObject* obj, Bool_t vis) |
void | SetVisLevel(Int_t level = 3) |
void | SetVisOption(Int_t option = 0) |
void | SetVolumeAttribute(const char* name, const char* att, Int_t val) |
virtual void | ShowMembers(TMemberInspector& insp, char* parent) |
virtual Int_t | TNamed::Sizeof() const |
virtual ULong_t | SizeOf(const TGeoNode* node, Option_t* option) |
void | SortOverlaps() |
TGeoNode* | Step(Bool_t is_geom = kTRUE, Bool_t cross = kTRUE) |
virtual void | Streamer(TBuffer& b) |
void | StreamerNVirtual(TBuffer& b) |
virtual void | TObject::SysError(const char* method, const char* msgfmt) const |
void | Test(Int_t npoints = 1000000, Option_t* option = "") |
Bool_t | TObject::TestBit(UInt_t f) const |
Int_t | TObject::TestBits(UInt_t f) const |
void | TestOverlaps(const char* path = "") |
void | TopToMaster(const Double_t* top, Double_t* master) const |
Int_t | TransformVolumeToAssembly(const char* vname) |
void | UnbombTranslation(const Double_t* tr, Double_t* bombtr) |
static void | UnlockGeometry() |
void | UpdateCurrentPosition(Double_t* nextpoint) |
virtual void | TObject::UseCurrentStyle() |
void | ViewLeaves(Bool_t flag = kTRUE) |
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) |
virtual void | TObject::Warning(const char* method, const char* msgfmt) const |
Double_t | Weight(Double_t precision = 0.01, Option_t* option = "va") |
virtual Int_t | TObject::Write(const char* name = "0", Int_t option = 0, Int_t bufsize = 0) |
virtual Int_t | TObject::Write(const char* name = "0", Int_t option = 0, Int_t bufsize = 0) const |
Data Members
private:
Double_t | fStep | ! step to be done from current point and direction |
Double_t | fSafety | ! safety radius from current point |
Double_t | fLastSafety | ! last computed safety radius |
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 | fLevel | ! current geometry level; |
Int_t | fNNodes | total number of physical nodes |
TString | fPath | ! path to current node |
TString | fParticleName | ! particles to be drawn |
Double_t | fNormal[3] | ! cosine of incident angle on current checked surface |
Double_t* | fCldir | ! unit vector to current closest shape |
Double_t* | fCldirChecked | ! unit vector to current checked shape |
Double_t* | fPoint | ![3] current point |
Double_t* | fDirection | ![3] current direction |
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 | fSearchOverlaps | ! flag set when an overlapping cluster is searched |
Bool_t | fCurrentOverlapping | ! flags the type of the current node |
Bool_t | fLoopVolumes | ! flag volume lists loop |
Bool_t | fStartSafe | ! flag a safe start for point classification |
Bool_t | fIsEntering | ! flag if current step just got into a new node |
Bool_t | fIsExiting | ! flag that current track is about to leave current node |
Bool_t | fIsStepEntering | ! flag that next geometric step will enter new volume |
Bool_t | fIsStepExiting | ! flaag that next geometric step will exit current volume |
Bool_t | fIsOutside | ! flag that current point is outside geometry |
Bool_t | fIsOnBoundary | ! flag that current point is on some boundary |
Bool_t | fIsSameLocation | ! flag that a new point is in the same node as previous |
Bool_t | fIsNullStep | ! flag that last geometric step was null |
Bool_t | fStreamVoxels | flag to allow voxelization I/O |
Bool_t | fIsGeomReading | ! flag set when reading geometry |
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 |
TGeoNodeCache* | fCache | ! cache for physical nodes |
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 |
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 |
TGeoVolume* | fCurrentVolume | ! current volume |
TGeoVolume* | fTopVolume | ! top level volume in geometry |
TGeoNode* | fCurrentNode | ! current node |
TGeoNode* | fTopNode | ! top physical node |
TGeoNode* | fLastNode | ! last searched node |
TGeoNode* | fNextNode | ! next node that will be crossed |
TGeoVolume* | fMasterVolume | master volume |
TGeoHMatrix* | fCurrentMatrix | ! current global matrix |
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 | fIntSize | ! int buffer size |
Int_t | fDblSize | ! dbl buffer size |
Int_t | fOverlapSize | ! current size of fOverlapClusters |
Int_t | fOverlapMark | ! current recursive position in fOverlapClusters |
Int_t* | fIntBuffer | ! transient int buffer |
Int_t* | fOverlapClusters | ! internal array for overlaps |
Int_t | fNLevel | maximum accepted level in geometry |
Int_t | fNmany | ! number of overlapping nodes on current branch |
Double_t* | fDblBuffer | ! transient dbl buffer |
Double_t | fLastPoint[3] | ! last point for which safety was computed |
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 |
General architecture
--------------------
The new ROOT geometry package is a tool designed for building, browsing,
tracking and visualizing a detector geometry. The code is independent from
other external MC for simulation, therefore it does not contain any
constraints related to physics. However, the package defines a number of
hooks for tracking, such as media, materials, magnetic field or track state flags,
in order to allow interfacing to tracking MC's. The final goal is to be
able to use the same geometry for several purposes, such as tracking,
reconstruction or visualization, taking advantage of the ROOT features
related to bookkeeping, I/O, histograming, browsing and GUI's.
The geometrical modeler is the most important component of the package and
it provides answers to the basic questions like "Where am I ?" or "How far
from the next boundary ?", but also to more complex ones like "How far from
the closest surface ?" or "Which is the next crossing along a helix ?".
The architecture of the modeler is a combination between a GEANT-like
containment scheme and a normal CSG binary tree at the level of shapes. An
important common feature of all detector geometry descriptions is the
mother-daughter concept. This is the most natural approach when tracking
is concerned and imposes a set of constraints to the way geometry is defined.
Constructive solid geometry composition is used only in order to create more
complex shapes from an existing set of primitives through boolean operations.
This feature is not implemented yet but in future full definition of boolean
expressions will be supported.
Practically every geometry defined in GEANT style can be mapped by the modeler.
The basic components used for building the logical hierarchy of the geometry
are called "volumes" and "nodes". Volumes (sometimes called "solids") are fully
defined geometrical objects having a given shape and medium and possibly
containing a list of nodes. Nodes represent just positioned instances of volumes
inside a container volume and they are not directly defined by user. They are
automatically created as a result of adding one volume inside other or dividing
a volume. The geometrical transformation hold by nodes is always defined with
respect to their mother (relative positioning). Reflection matrices are allowed.
All volumes have to be fully aware of their containees when the geometry is
closed. They will build aditional structures (voxels) in order to fasten-up
the search algorithms. Finally, nodes can be regarded as bidirectional links
between containers and containees objects.
The structure defined in this way is a graph structure since volumes are
replicable (same volume can become daughter node of several other volumes),
every volume becoming a branch in this graph. Any volume in the logical graph
can become the actual top volume at run time (see TGeoManager::SetTopVolume()).
All functionalities of the modeler will behave in this case as if only the
corresponding branch starting from this volume is the registered geometry.
/*
*/
A given volume can be positioned several times in the geometry. A volume
can be divided according default or user-defined patterns, creating automatically
the list of division nodes inside. The elementary volumes created during the
dividing process follow the same scheme as usual volumes, therefore it is possible
to position further geometrical structures inside or to divide them further more
(see TGeoVolume::Divide()).
The primitive shapes supported by the package are basically the GEANT3
shapes (see class TGeoShape), arbitrary wedges with eight vertices on two parallel
planes. All basic primitives inherits from class TGeoBBox since the bounding box
of a solid is essential for the tracking algorithms. They also implement the
virtual methods defined in the virtual class TGeoShape (point and segment
classification). User-defined primitives can be direcly plugged into the modeler
provided that they override these methods. Composite shapes will be soon supported
by the modeler. In order to build a TGeoCompositeShape, one will have to define
first the primitive components. The object that handle boolean
operations among components is called TGeoBoolCombinator and it has to be
constructed providing a string boolean expression between the components names.
Example for building a simple geometry :
-----------------------------------------
______________________________________________________________________________
void rootgeom()
{
//--- Definition of a simple geometry
gSystem->Load("libGeom");
TGeoManager *geom = new TGeoManager("simple1", "Simple geometry");
//--- define some materials
TGeoMaterial *matVacuum = new TGeoMaterial("Vacuum", 0,0,0);
TGeoMaterial *matAl = new TGeoMaterial("Al", 26.98,13,2.7);
//--- define some media
TGeoMedium *med;
TGeoMedium *Vacuum = new TGeoMedium(1, matVacuum);
TGeoMedium *Al = new TGeoMedium(2, matAl);
//--- define the transformations
TGeoTranslation *tr1 = new TGeoTranslation(20., 0, 0.);
TGeoTranslation *tr2 = new TGeoTranslation(10., 0., 0.);
TGeoTranslation *tr3 = new TGeoTranslation(10., 20., 0.);
TGeoTranslation *tr4 = new TGeoTranslation(5., 10., 0.);
TGeoTranslation *tr5 = new TGeoTranslation(20., 0., 0.);
TGeoTranslation *tr6 = new TGeoTranslation(-5., 0., 0.);
TGeoTranslation *tr7 = new TGeoTranslation(7.5, 7.5, 0.);
TGeoRotation *rot1 = new TGeoRotation("rot1", 90., 0., 90., 270., 0., 0.);
TGeoCombiTrans *combi1 = new TGeoCombiTrans(7.5, -7.5, 0., rot1);
TGeoTranslation *tr8 = new TGeoTranslation(7.5, -5., 0.);
TGeoTranslation *tr9 = new TGeoTranslation(7.5, 20., 0.);
TGeoTranslation *tr10 = new TGeoTranslation(85., 0., 0.);
TGeoTranslation *tr11 = new TGeoTranslation(35., 0., 0.);
TGeoTranslation *tr12 = new TGeoTranslation(-15., 0., 0.);
TGeoTranslation *tr13 = new TGeoTranslation(-65., 0., 0.);
TGeoTranslation *tr14 = new TGeoTranslation(0,0,-100);
TGeoCombiTrans *combi2 = new TGeoCombiTrans(0,0,100,
new TGeoRotation("rot2",90,180,90,90,180,0));
TGeoCombiTrans *combi3 = new TGeoCombiTrans(100,0,0,
new TGeoRotation("rot3",90,270,0,0,90,180));
TGeoCombiTrans *combi4 = new TGeoCombiTrans(-100,0,0,
new TGeoRotation("rot4",90,90,0,0,90,0));
TGeoCombiTrans *combi5 = new TGeoCombiTrans(0,100,0,
new TGeoRotation("rot5",0,0,90,180,90,270));
TGeoCombiTrans *combi6 = new TGeoCombiTrans(0,-100,0,
new TGeoRotation("rot6",180,0,90,180,90,90));
//--- make the top container volume
Double_t worldx = 110.;
Double_t worldy = 50.;
Double_t worldz = 5.;
TGeoVolume *top = geom->MakeBox("TOP", Vacuum, 270., 270., 120.);
geom->SetTopVolume(top); // mandatory !
//--- build other container volumes
TGeoVolume *replica = geom->MakeBox("REPLICA", Vacuum,120,120,120);
replica->SetVisibility(kFALSE);
TGeoVolume *rootbox = geom->MakeBox("ROOT", Vacuum, 110., 50., 5.);
rootbox->SetVisibility(kFALSE); // this will hold word 'ROOT'
//--- make letter 'R'
TGeoVolume *R = geom->MakeBox("R", Vacuum, 25., 25., 5.);
R->SetVisibility(kFALSE);
TGeoVolume *bar1 = geom->MakeBox("bar1", Al, 5., 25, 5.);
bar1->SetLineColor(kRed);
R->AddNode(bar1, 1, tr1);
TGeoVolume *bar2 = geom->MakeBox("bar2", Al, 5., 5., 5.);
bar2->SetLineColor(kRed);
R->AddNode(bar2, 1, tr2);
R->AddNode(bar2, 2, tr3);
TGeoVolume *tub1 = geom->MakeTubs("tub1", Al, 5., 15., 5., 90., 270.);
tub1->SetLineColor(kRed);
R->AddNode(tub1, 1, tr4);
TGeoVolume *bar3 = geom->MakeArb8("bar3", Al, 5.);
bar3->SetLineColor(kRed);
TGeoArb8 *arb = (TGeoArb8*)bar3->GetShape();
arb->SetVertex(0, 15., -5.);
arb->SetVertex(1, 5., -5.);
arb->SetVertex(2, -10., -25.);
arb->SetVertex(3, 0., -25.);
arb->SetVertex(4, 15., -5.);
arb->SetVertex(5, 5., -5.);
arb->SetVertex(6, -10., -25.);
arb->SetVertex(7, 0., -25.);
R->AddNode(bar3, 1, gGeoIdentity);
//--- make letter 'O'
TGeoVolume *O = geom->MakeBox("O", Vacuum, 25., 25., 5.);
O->SetVisibility(kFALSE);
TGeoVolume *bar4 = geom->MakeBox("bar4", Al, 5., 7.5, 5.);
bar4->SetLineColor(kYellow);
O->AddNode(bar4, 1, tr5);
O->AddNode(bar4, 2, tr6);
TGeoVolume *tub2 = geom->MakeTubs("tub1", Al, 7.5, 17.5, 5., 0., 180.);
tub2->SetLineColor(kYellow);
O->AddNode(tub2, 1, tr7);
O->AddNode(tub2, 2, combi1);
//--- make letter 'T'
TGeoVolume *T = geom->MakeBox("T", Vacuum, 25., 25., 5.);
T->SetVisibility(kFALSE);
TGeoVolume *bar5 = geom->MakeBox("bar5", Al, 5., 20., 5.);
bar5->SetLineColor(kBlue);
T->AddNode(bar5, 1, tr8);
TGeoVolume *bar6 = geom->MakeBox("bar6", Al, 17.5, 5., 5.);
bar6->SetLineColor(kBlue);
T->AddNode(bar6, 1, tr9);
//--- add letters to 'ROOT' container
rootbox->AddNode(R, 1, tr10);
rootbox->AddNode(O, 1, tr11);
rootbox->AddNode(O, 2, tr12);
rootbox->AddNode(T, 1, tr13);
//--- add word 'ROOT' on each face of a cube
replica->AddNode(rootbox, 1, tr14);
replica->AddNode(rootbox, 2, combi2);
replica->AddNode(rootbox, 3, combi3);
replica->AddNode(rootbox, 4, combi4);
replica->AddNode(rootbox, 5, combi5);
replica->AddNode(rootbox, 6, combi6);
//--- add four replicas of this cube to top volume
top->AddNode(replica, 1, new TGeoTranslation(-150, -150, 0));
top->AddNode(replica, 2, new TGeoTranslation(150, -150, 0));
top->AddNode(replica, 3, new TGeoTranslation(150, 150, 0));
top->AddNode(replica, 4, new TGeoTranslation(-150, 150, 0));
//--- close the geometry
geom->CloseGeometry();
//--- draw the ROOT box
geom->SetVisLevel(4);
top->Draw();
if (gPad) gPad->x3d();
}
______________________________________________________________________________
/*
*/
TGeoManager - the manager class for the geometry package.
---------------------------------------------------------
TGeoManager class is embedding all the API needed for building and tracking
a geometry. It defines a global pointer (gGeoManager) in order to be fully
accessible from external code. The mechanism of handling multiple geometries
at the same time will be soon implemented.
TGeoManager is the owner of all geometry objects defined in a session,
therefore users must not try to control their deletion. It contains lists of
media, materials, transformations, shapes and volumes. Logical nodes (positioned
volumes) are created and destroyed by the TGeoVolume class. Physical
nodes and their global transformations are subjected to a caching mechanism
due to the sometimes very large memory requirements of logical graph expansion.
The caching mechanism is triggered by the total number of physical instances
of volumes and the cache manager is a client of TGeoManager. The manager class
also controls the painter client. This is linked with ROOT graphical libraries
loaded on demand in order to control visualization actions.
Rules for building a valid geometry
-----------------------------------
A given geometry can be built in various ways, but there are mandatory steps
that have to be followed in order to be validated by the modeler. There are
general rules : volumes needs media and shapes in order to be created,
both container an containee volumes must be created before linking them together,
and the relative transformation matrix must be provided. All branches must
have an upper link point otherwise they will not be considered as part of the
geometry. Visibility or tracking properties of volumes can be provided both
at build time or after geometry is closed, but global visualization settings
(see TGeoPainter class) should not be provided at build time, otherwise the
drawing package will be loaded. There is also a list of specific rules :
positioned daughters should not extrude their mother or intersect with sisters
unless this is specified (see TGeoVolume::AddNodeOverlap()), the top volume
(containing all geometry tree) must be specified before closing the geometry
and must not be positioned - it represents the global reference frame. After
building the full geometry tree, the geometry must be closed
(see TGeoManager::CloseGeometry()). Voxelization can be redone per volume after
this process.
Below is the general scheme of the manager class.
/*
*/
An interactive session
------------------------
Provided that a geometry was successfully built and closed (for instance the
previous example $ROOTSYS/tutorials/geom/rootgeom.C ), the manager class will register
itself to ROOT and the logical/physical structures will become immediately browsable.
The ROOT browser will display starting from the geometry folder : the list of
transformations and media, the top volume and the top logical node. These last
two can be fully expanded, any intermediate volume/node in the browser being subject
of direct access context menu operations (right mouse button click). All user
utilities of classes TGeoManager, TGeoVolume and TGeoNode can be called via the
context menu.
/*
*/
--- Drawing the geometry
Any logical volume can be drawn via TGeoVolume::Draw() member function.
This can be direcly accessed from the context menu of the volume object
directly from the browser.
There are several drawing options that can be set with
TGeoManager::SetVisOption(Int_t opt) method :
opt=0 - only the content of the volume is drawn, N levels down (default N=3).
This is the default behavior. The number of levels to be drawn can be changed
via TGeoManager::SetVisLevel(Int_t level) method.
/*
*/
opt=1 - the final leaves (e.g. daughters with no containment) of the branch
starting from volume are drawn down to the current number of levels.
WARNING : This mode is memory consuming
depending of the size of geometry, so drawing from top level within this mode
should be handled with care for expensive geometries. In future there will be
a limitation on the maximum number of nodes to be visualized.
/*
*/
opt=2 - only the clicked volume is visualized. This is automatically set by
TGeoVolume::DrawOnly() method
opt=3 - only a given path is visualized. This is automatically set by
TGeoVolume::DrawPath(const char *path) method
The current view can be exploded in cartesian, cylindrical or spherical
coordinates :
TGeoManager::SetExplodedView(Int_t opt). Options may be :
- 0 - default (no bombing)
- 1 - cartesian coordinates. The bomb factor on each axis can be set with
TGeoManager::SetBombX(Double_t bomb) and corresponding Y and Z.
- 2 - bomb in cylindrical coordinates. Only the bomb factors on Z and R
are considered
/*
*/
- 3 - bomb in radial spherical coordinate : TGeoManager::SetBombR()
Volumes themselves support different visualization settings :
- TGeoVolume::SetVisibility() : set volume visibility.
- TGeoVolume::VisibleDaughters() : set daughters visibility.
All these actions automatically updates the current view if any.
--- Checking the geometry
Several checking methods are accessible from the volume context menu. They
generally apply only to the visible parts of the drawn geometry in order to
ease geometry checking, and their implementation is in the TGeoChecker class
from the painting package.
1. Checking a given point.
Can be called from TGeoManager::CheckPoint(Double_t x, Double_t y, Double_t z).
This method is drawing the daughters of the volume containing the point one
level down, printing the path to the deepest physical node holding this point.
It also computes the closest distance to any boundary. The point will be drawn
in red.
/*
*/
2. Shooting random points.
Can be called from TGeoVolume::RandomPoints() (context menu function) and
it will draw this volume with current visualization settings. Random points
are generated in the bounding box of the top drawn volume. The points are
classified and drawn with the color of their deepest container. Only points
in visible nodes will be drawn.
/*
*/
3. Raytracing.
Can be called from TGeoVolume::RandomRays() (context menu of volumes) and
will shoot rays from a given point in the local reference frame with random
directions. The intersections with displayed nodes will appear as segments
having the color of the touched node. Drawn geometry will be then made invisible
in order to enhance rays.
/*
*/
TGeoManager(const char *name, const char *title)
Constructor.
void Init()
Initialize manager class.
Int_t ReplaceVolume(TGeoVolume *vorig, TGeoVolume *vnew)
Replaces all occurences of VORIG with VNEW in the geometry tree. The volume VORIG
is not replaced from the list of volumes, but all node referencing it will reference
VNEW instead. Returns number of occurences changed.
TGeoVolume * Division(const char *name, const char *mother, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed, Option_t *option)
Create a new volume by dividing an existing one (GEANT3 like)
Divides MOTHER into NDIV divisions called NAME
along axis IAXIS starting at coordinate value START
and having size STEP. The created volumes will have tracking
media ID=NUMED (if NUMED=0 -> same media as MOTHER)
The behavior of the division operation can be triggered using OPTION :
OPTION (case insensitive) :
N - divide all range in NDIV cells (same effect as STEP<=0) (GSDVN in G3)
NX - divide range starting with START in NDIV cells (GSDVN2 in G3)
S - divide all range with given STEP. NDIV is computed and divisions will be centered
in full range (same effect as NDIV<=0) (GSDVS, GSDVT in G3)
SX - same as DVS, but from START position. (GSDVS2, GSDVT2 in G3)
void Matrix(Int_t index, Double_t theta1, Double_t phi1, Double_t theta2, Double_t phi2, Double_t theta3, Double_t phi3)
Create rotation matrix named 'mat<index>'.
index rotation matrix number
theta1 polar angle for axis X
phi1 azimuthal angle for axis X
theta2 polar angle for axis Y
phi2 azimuthal angle for axis Y
theta3 polar angle for axis Z
phi3 azimuthal angle for axis Z
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)
Create tracking medium
numed tracking medium number assigned
name tracking medium name
nmat material number
isvol sensitive volume flag
ifield magnetic field
fieldm max. field value (kilogauss)
tmaxfd max. angle due to field (deg/step)
stemax max. step allowed
deemax max. fraction of energy lost in a step
epsil tracking precision (cm)
stmin min. step due to continuous processes (cm)
ifield = 0 if no magnetic field; ifield = -1 if user decision in guswim;
ifield = 1 if tracking performed with g3rkuta; ifield = 2 if tracking
performed with g3helix; ifield = 3 if tracking performed with g3helx3.
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)
Create a node called <name_nr> pointing to the volume called <name>
as daughter of the volume called <mother> (gspos). The relative matrix is
made of : a translation (x,y,z) and a rotation matrix named <matIROT>.
In case npar>0, create the volume to be positioned in mother, according
its actual parameters (gsposp).
NAME Volume name
NUMBER Copy number of the volume
MOTHER Mother volume name
X X coord. of the volume in mother ref. sys.
Y Y coord. of the volume in mother ref. sys.
Z Z coord. of the volume in mother ref. sys.
IROT Rotation matrix number w.r.t. mother ref. sys.
ISONLY ONLY/MANY flag
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)
Create a node called <name_nr> pointing to the volume called <name>
as daughter of the volume called <mother> (gspos). The relative matrix is
made of : a translation (x,y,z) and a rotation matrix named <matIROT>.
In case npar>0, create the volume to be positioned in mother, according
its actual parameters (gsposp).
NAME Volume name
NUMBER Copy number of the volume
MOTHER Mother volume name
X X coord. of the volume in mother ref. sys.
Y Y coord. of the volume in mother ref. sys.
Z Z coord. of the volume in mother ref. sys.
IROT Rotation matrix number w.r.t. mother ref. sys.
ISONLY ONLY/MANY flag
TGeoVolume * Volume(const char *name, const char *shape, Int_t nmed, Float_t *upar, Int_t npar)
Create a volume in GEANT3 style.
NAME Volume name
SHAPE Volume type
NMED Tracking medium number
NPAR Number of shape parameters
UPAR Vector containing shape parameters
TGeoVolume * Volume(const char *name, const char *shape, Int_t nmed, Double_t *upar, Int_t npar)
Create a volume in GEANT3 style.
NAME Volume name
SHAPE Volume type
NMED Tracking medium number
NPAR Number of shape parameters
UPAR Vector containing shape parameters
void SetAllIndex()
Assigns uid's for all materials,media and matrices.
void ClearAttributes()
Reset all attributes to default ones. Default attributes for visualization
are those defined before closing the geometry.
void CloseGeometry(Option_t *option)
Closing geometry implies checking the geometry validity, fixing shapes
with negative parameters (run-time shapes)building the cache manager,
voxelizing all volumes, counting the total number of physical nodes and
registring the manager class to the browser.
void CleanGarbage()
Clean temporary volumes and shapes from garbage collection.
void CdNode(Int_t nodeid)
Change current path to point to the node having this id.
Node id has to be in range : 0 to fNNodes-1 (no check for performance reasons)
void CdTop()
Make top level node the current node. Updates the cache accordingly.
Determine the overlapping state of current node.
void CdUp()
Go one level up in geometry. Updates cache accordingly.
Determine the overlapping state of current node.
void CdDown(Int_t index)
Make a daughter of current node current. Can be called only with a valid
daughter index (no check). Updates cache accordingly.
Bool_t cd(const char *path)
Browse the tree of nodes starting from fTopNode according to pathname.
Changes the path accordingly.
Bool_t CheckPath(const char *path)
Check if a geometry path is valid without changing the state of the manager.
void ConvertReflections()
Convert all reflections in geometry to normal rotations + reflected shapes.
void Test(Int_t npoints, Option_t *option)
Check time of finding "Where am I" for n points.
void TestOverlaps(const char* path)
Geometry overlap checker based on sampling.
void SetPdgName(Int_t pdg, const char *name)
Set a name for a particle having a given pdg.
Int_t GetVirtualLevel()
Find level of virtuality of current overlapping node (number of levels
up having the same tracking media.
TGeoNode * FindInCluster(Int_t *cluster, Int_t nc)
Find a node inside a cluster of overlapping nodes. Current node must
be on top of all the nodes in cluster. Always nc>1.
Int_t GetTouchedCluster(Int_t start, Double_t *point, Int_t *check_list, Int_t ncheck, Int_t *result)
Make the cluster of overlapping nodes in a voxel, containing point in reference
of the mother. Returns number of nodes containing the point. Nodes should not be
offsets.
void DefaultColors()
Set default volume colors according to A of material
Double_t Safety(Bool_t inside)
Compute safe distance from the current point. This represent the distance
from POINT to the closest boundary.
void SafetyOverlaps()
Compute safe distance from the current point within an overlapping node
void SetVisOption(Int_t option)
set drawing mode :
option=0 (default) all nodes drawn down to vislevel
option=1 leaves and nodes at vislevel drawn
option=2 path is drawn
option=4 visibility changed
void ViewLeaves(Bool_t flag)
Set visualization option (leaves only OR all volumes)
void SetVisDensity(Double_t density)
Set density threshold. Volumes with densities lower than this become
transparent.
void SetVisLevel(Int_t level)
set default level down to which visualization is performed
void SortOverlaps()
Sort overlaps by decreasing overlap distance. Extrusions comes first.
void OptimizeVoxels(const char *filename)
Optimize voxelization type for all volumes. Save best choice in a macro.
Int_t Parse(const char *expr, TString &expr1, TString &expr2, TString &expr3)
Parse a string boolean expression and do a syntax check. Find top
level boolean operator and returns its type. Fill the two
substrings to which this operator applies. The returned integer is :
-1 : parse error
0 : no boolean operator
1 : union - represented as '+' in expression
2 : difference (subtraction) - represented as '-' in expression
3 : intersection - represented as '*' in expression.
Paranthesys should be used to avoid ambiguites. For instance :
A+B-C will be interpreted as (A+B)-C which is not the same as A+(B-C)
eliminate not needed paranthesys
void SaveAttributes(const char *filename)
Save current attributes in a macro
TGeoNode * FindNextBoundaryAndStep(Double_t stepmax, Bool_t compsafe)
Compute distance to next boundary within STEPMAX. If no boundary is found,
propagate current point along current direction with fStep=STEPMAX. Otherwise
propagate with fStep=SNEXT (distance to boundary) and locate/return the next
node.
TGeoNode * FindNextBoundary(Double_t stepmax, const char *path)
Find distance to next boundary and store it in fStep. Returns node to which this
boundary belongs. If PATH is specified, compute only distance to the node to which
PATH points. If STEPMAX is specified, compute distance only in case fSafety is smaller
than this value. STEPMAX represent the step to be made imposed by other reasons than
geometry (usually physics processes). Therefore in this case this method provides the
answer to the question : "Is STEPMAX a safe step ?" returning a NULL node and filling
fStep with a big number.
Double_t * FindNormal(Bool_t forward)
Computes normal vector to the next surface that will be or was already
crossed when propagating on a straight line from a given point/direction.
Returns the normal vector cosines in the MASTER coordinate system. The dot
product of the normal and the current direction is positive defined.
void InspectState()
Inspects path and all flags for the current state.
const char * GetPath()
Get path to the current node in the form /node0/node1/...
TGeoVolume * GetVolume(const char *name)
Search for a named volume. All trailing blanks stripped.
Int_t GetUID(const char *volname)
Retreive unique id for a volume name. Return -1 if name not found.
TGeoMedium * GetMedium(const char *medium)
Search for a named tracking medium. All trailing blanks stripped.
void ResetUserData()
Sets all pointers TGeoVolume::fField to NULL. User data becomes decoupled
from geometry. Deletion has to be managed by users.
TGeoVolume * MakeCtub(const char *name, const 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)
Make in one step a volume pointing to a tube segment shape with given medium
TGeoVolume * MakeTrap(const char *name, const 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)
Make in one step a volume pointing to a trapezoid shape with given medium.
TGeoVolume * MakeGtra(const char *name, const 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)
Make in one step a volume pointing to a twisted trapezoid shape with given medium.
TGeoPNEntry * SetAlignableEntry(const char *unique_name, const char *path)
Creates an aligneable object with unique name corresponding to a path
and adds it to the list of alignables.
TGeoPhysicalNode * MakePhysicalNode(const char *path)
Makes a physical node corresponding to a path. If PATH is not specified,
makes physical node matching current modeller state.
void ClearPhysicalNodes(Bool_t mustdelete)
Clear the current list of physical nodes, so that we can start over with a new list.
If MUSTDELETE is true, delete previous nodes.
void SetNsegments(Int_t nseg)
Set number of segments for approximating circles in drawing.
TGeoNode * Step(Bool_t is_geom, Bool_t cross)
Make a rectiliniar step of length fStep from current point (fPoint) on current
direction (fDirection). If the step is imposed by geometry, is_geom flag
must be true (default). The cross flag specifies if the boundary should be
crossed in case of a geometry step (default true). Returns new node after step.
Set also on boundary condition.
void SetTopVolume(TGeoVolume *vol)
Set the top volume and corresponding node as starting point of the geometry.
Double_t Weight(Double_t precision, Option_t *option)
Estimate weight of volume VOL with a precision SIGMA(W)/W better than PRECISION.
Option can be "v" - verbose (default)
ULong_t SizeOf(const TGeoNode * , Option_t * )
computes the total size in bytes of the branch starting with node.
The option can specify if all the branch has to be parsed or only the node
Int_t Export(const char *filename, const char *name, Option_t *option)
Export this geometry to a file
-Case 1: root file or root/xml file
if filename end with ".root". The key will be named name
By default the geometry is saved without the voxelisation info.
Use option 'v" to save the voxelisation info.
if filename end with ".xml" a root/xml file is produced.
-Case 2: C++ script
if filename end with ".C"
-Case 3: gdml file
if filename end with ".gdml"
NOTE that to use this option, the PYTHONPATH must be defined like
export PYTHONPATH=$ROOTSYS/lib:$ROOTSYS/gdml
void LockGeometry()
Lock current geometry so that no other geometry can be imported.
TGeoManager * Import(const char *filename, const char *name, Option_t * )
static function
Import a geometry from a gdml or ROOT file
-Case 1: gdml
if filename ends with ".gdml" the foreign geometry described with gdml
is imported executing some python scripts in $ROOTSYS/gdml.
NOTE that to use this option, the PYTHONPATH must be defined like
export PYTHONPATH=$ROOTSYS/lib:$ROOTSYS/gdml
-Case 2: root file (.root) or root/xml file (.xml)
Import in memory from filename the geometry with key=name.
if name="" (default), the first TGeoManager object in the file is returned.
Note that this function deletes the current gGeoManager (if one)
before importing the new object.
void UpdateElements()
Update element flags when geometry is loaded from a file.
void SetTminTmax(Double_t tmin, Double_t tmax)
Set time cut interval for drawing tracks. If called with no arguments, time
cut will be disabled.
Author: Andrei Gheata 25/10/01
Last update: root/geom:$Name: $:$Id: TGeoManager.cxx,v 1.168 2006/12/12 13:52:23 couet Exp $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
ROOT page - Class index - Class Hierarchy - Top of the page
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.