Logo ROOT  
Reference Guide
TGeoParallelWorld.cxx
Go to the documentation of this file.
1 // Author: Andrei Gheata 17/02/04
2 
3 /*************************************************************************
4  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
5  * All rights reserved. *
6  * *
7  * For the licensing terms see $ROOTSYS/LICENSE. *
8  * For the list of contributors see $ROOTSYS/README/CREDITS. *
9  *************************************************************************/
10 
11 /** \class TGeoParallelWorld
12 \ingroup Geometry_classes
13 Base class for a flat parallel geometry.
14 
15  The parallel geometry can be composed by both normal volumes added
16 using the AddNode interface (not implemented yet) or by physical nodes
17 which will use as position their actual global matrix with respect to the top
18 volume of the main geometry.
19 
20  All these nodes are added as daughters to the "top" volume of
21 the parallel world which acts as a navigation helper in this parallel
22 world. The parallel world has to be closed before calling any navigation
23 method.
24 */
25 
26 #include "TGeoParallelWorld.h"
27 #include "TObjString.h"
28 #include "TGeoManager.h"
29 #include "TGeoVolume.h"
30 #include "TGeoVoxelFinder.h"
31 #include "TGeoMatrix.h"
32 #include "TGeoPhysicalNode.h"
33 #include "TGeoNavigator.h"
34 
36 
37 ////////////////////////////////////////////////////////////////////////////////
38 /// Default constructor
39 
41  : TNamed(name,""),
42  fGeoManager(mgr),
43  fPaths(new TObjArray(256)),
44  fUseOverlaps(kFALSE),
45  fIsClosed(kFALSE),
46  fVolume(0),
47  fLastState(0),
48  fPhysical(new TObjArray(256))
49 {
50 }
51 
52 ////////////////////////////////////////////////////////////////////////////////
53 /// Destructor
54 
56 {
57  if (fPhysical) {fPhysical->Delete(); delete fPhysical;}
58  if (fPaths) {fPaths->Delete(); delete fPaths;}
59  delete fVolume;
60 }
61 
62 ////////////////////////////////////////////////////////////////////////////////
63 /// Add a node normally to this world. Overlapping nodes not allowed
64 
65 void TGeoParallelWorld::AddNode(const char *path)
66 {
67  if (fIsClosed) Fatal("AddNode", "Cannot add nodes to a closed parallel geometry");
68  if (!fGeoManager->CheckPath(path)) {
69  Error("AddNode", "Path %s not valid.\nCannot add to parallel world!", path);
70  return;
71  }
72  fPaths->Add(new TObjString(path));
73 }
74 
75 ////////////////////////////////////////////////////////////////////////////////
76 /// To use this optimization, the user should declare the full list of volumes
77 /// which may overlap with any of the physical nodes of the parallel world. Better
78 /// be done before misalignment
79 
81 {
82  if (activate) fUseOverlaps = kTRUE;
84 }
85 
86 ////////////////////////////////////////////////////////////////////////////////
87 /// To use this optimization, the user should declare the full list of volumes
88 /// which may overlap with any of the physical nodes of the parallel world. Better
89 /// be done before misalignment
90 
91 void TGeoParallelWorld::AddOverlap(const char *volname, Bool_t activate)
92 {
93  if (activate) fUseOverlaps = kTRUE;
95  TGeoVolume *vol;
96  while ((vol=(TGeoVolume*)next())) {
97  if (!strcmp(vol->GetName(), volname)) vol->SetOverlappingCandidate(kTRUE);
98  }
99 }
100 
101 ////////////////////////////////////////////////////////////////////////////////
102 /// Print the overlaps which were detected during real tracking
103 
105 {
107  TGeoVolume *vol;
108  Int_t noverlaps = 0;
109  while ((vol=(TGeoVolume*)next())) {
110  if (vol->IsOverlappingCandidate()) {
111  if (noverlaps==0) Info("PrintDetectedOverlaps", "List of detected volumes overlapping with the PW");
112  noverlaps++;
113  printf("volume: %s at index: %d\n", vol->GetName(), vol->GetNumber());
114  }
115  }
116  return noverlaps;
117 }
118 
119 ////////////////////////////////////////////////////////////////////////////////
120 /// Reset overlapflag for all volumes in geometry
121 
123 {
125  TGeoVolume *vol;
126  while ((vol=(TGeoVolume*)next())) vol->SetOverlappingCandidate(kFALSE);
127 }
128 
129 ////////////////////////////////////////////////////////////////////////////////
130 /// The main geometry must be closed.
131 
133 {
134  if (fIsClosed) return kTRUE;
135  if (!fGeoManager->IsClosed()) Fatal("CloseGeometry", "Main geometry must be closed first");
136  if (!fPaths || !fPaths->GetEntriesFast()) {
137  Error("CloseGeometry", "List of paths is empty");
138  return kFALSE;
139  }
141  fIsClosed = kTRUE;
142  Info("CloseGeometry", "Parallel world %s contains %d prioritised objects", GetName(), fPaths->GetEntriesFast());
143  Int_t novlp = 0;
145  TGeoVolume *vol;
146  while ((vol=(TGeoVolume*)next())) if (vol->IsOverlappingCandidate()) novlp++;
147  Info("CloseGeometry", "Number of declared overlaps: %d", novlp);
148  if (fUseOverlaps) Info("CloseGeometry", "Parallel world will use declared overlaps");
149  else Info("CloseGeometry", "Parallel world will detect overlaps with other volumes");
150  return kTRUE;
151 }
152 
153 ////////////////////////////////////////////////////////////////////////////////
154 /// Refresh the node pointers and re-voxelize. To be called mandatory in case
155 /// re-alignment happened.
156 
158 {
159  delete fVolume;
162  // Loop physical nodes and add them to the navigation helper volume
163  if (fPhysical) {fPhysical->Delete(); delete fPhysical;}
165  TGeoPhysicalNode *pnode;
166  TObjString *objs;
167  TIter next(fPaths);
168  Int_t copy = 0;
169  while ((objs = (TObjString*)next())) {
170  pnode = new TGeoPhysicalNode(objs->GetName());
171  fPhysical->AddAt(pnode, copy);
172  fVolume->AddNode(pnode->GetVolume(), copy++, new TGeoHMatrix(*pnode->GetMatrix()));
173  }
174  // Voxelize the volume
176  fVolume->Voxelize("ALL");
177 }
178 
179 ////////////////////////////////////////////////////////////////////////////////
180 /// Finds physical node containing the point
181 
183 {
184  if (!fIsClosed) Fatal("FindNode", "Parallel geometry must be closed first");
186  // Fast return if not in an overlapping candidate
187  TGeoVoxelFinder *voxels = fVolume->GetVoxels();
188  Int_t id;
189  Int_t ncheck = 0;
190  Int_t nd = fVolume->GetNdaughters();
191  // get the list of nodes passing thorough the current voxel
192  TGeoNodeCache *cache = nav->GetCache();
193  TGeoStateInfo &info = *cache->GetMakePWInfo(nd);
194  Int_t *check_list = voxels->GetCheckList(point, ncheck, info);
195 // cache->ReleaseInfo(); // no hierarchical use
196  if (!check_list) return 0;
197  // loop all nodes in voxel
198  TGeoNode *node;
199  Double_t local[3];
200  for (id=0; id<ncheck; id++) {
201  node = fVolume->GetNode(check_list[id]);
202  node->MasterToLocal(point, local);
203  if (node->GetVolume()->Contains(local)) {
204  // We found a node containing the point
206  return fLastState;
207  }
208  }
209  return 0;
210 }
211 
212 ////////////////////////////////////////////////////////////////////////////////
213 /// Same functionality as TGeoNavigator::FindNextDaughterBoundary for the
214 /// parallel world
215 
217  Double_t &step, Double_t stepmax)
218 {
219  if (!fIsClosed) Fatal("FindNextBoundary", "Parallel geometry must be closed first");
220  TGeoPhysicalNode *pnode = 0;
222  // Fast return if not in an overlapping candidate
223  if (fUseOverlaps && !nav->GetCurrentVolume()->IsOverlappingCandidate()) return 0;
224 // TIter next(fPhysical);
225  // Ignore the request if the current state in the main geometry matches the
226  // last touched physical node in the parallel geometry
227  if (fLastState && fLastState->IsMatchingState(nav)) return 0;
228 // while ((pnode = (TGeoPhysicalNode*)next())) {
229 // if (pnode->IsMatchingState(nav)) return 0;
230 // }
231  step = stepmax;
232  TGeoVoxelFinder *voxels = fVolume->GetVoxels();
233  Int_t idaughter = -1; // nothing crossed
234  Int_t nd = fVolume->GetNdaughters();
235  Int_t i;
236  TGeoNode *current;
237  Double_t lpoint[3], ldir[3];
238 // const Double_t tolerance = TGeoShape::Tolerance();
239  if (nd<5) {
240  // loop over daughters
241  for (i=0; i<nd; i++) {
242  current = fVolume->GetNode(i);
243  // validate only within stepmax
244  if (voxels->IsSafeVoxel(point, i, stepmax)) continue;
245  current->MasterToLocal(point, lpoint);
246  current->MasterToLocalVect(dir, ldir);
247  Double_t snext = current->GetVolume()->GetShape()->DistFromOutside(lpoint, ldir, 3, step);
248  if (snext < step) {
249  step = snext;
250  idaughter = i;
251  }
252  }
253  if (idaughter>=0) {
254  pnode = (TGeoPhysicalNode*)fPhysical->At(idaughter);
255  return pnode;
256  }
257  step = TGeoShape::Big();
258  return 0;
259  }
260  // Get current voxel
261  Int_t ncheck = 0;
262  Int_t sumchecked = 0;
263  Int_t *vlist = 0;
264  TGeoNodeCache *cache = nav->GetCache();
265  TGeoStateInfo &info = *cache->GetMakePWInfo(nd);
266 // TGeoStateInfo &info = *cache->GetInfo();
267 // cache->ReleaseInfo(); // no hierarchical use
268  voxels->SortCrossedVoxels(point, dir, info);
269  while ((sumchecked<nd) && (vlist=voxels->GetNextVoxel(point, dir, ncheck, info))) {
270  for (i=0; i<ncheck; i++) {
271  pnode = (TGeoPhysicalNode*)fPhysical->At(vlist[i]);
272  if (pnode->IsMatchingState(nav)) {
273  step = TGeoShape::Big();
274  return 0;
275  }
276  current = fVolume->GetNode(vlist[i]);
277  current->MasterToLocal(point, lpoint);
278  current->MasterToLocalVect(dir, ldir);
279  Double_t snext = current->GetVolume()->GetShape()->DistFromOutside(lpoint, ldir, 3, step);
280  if (snext < step - 1.E-8) {
281  step = snext;
282  idaughter = vlist[i];
283  }
284  }
285  if (idaughter>=0) {
286  pnode = (TGeoPhysicalNode*)fPhysical->At(idaughter);
287  // mark the overlap
290 // printf("object %s overlapping with pn: %s\n", fGeoManager->GetPath(), pnode->GetName());
291  }
292  return pnode;
293  }
294  }
295  step = TGeoShape::Big();
296  return 0;
297 }
298 
299 ////////////////////////////////////////////////////////////////////////////////
300 /// Compute safety for the parallel world
301 
303 {
305  // Fast return if the state matches the last one recorded
306  if (fLastState && fLastState->IsMatchingState(nav)) return TGeoShape::Big();
307  // Fast return if not in an overlapping candidate
309  Double_t local[3];
310  Double_t safe = safmax;
311  Double_t safnext;
312  TGeoPhysicalNode *pnode = 0;
313  const Double_t tolerance = TGeoShape::Tolerance();
314  Int_t nd = fVolume->GetNdaughters();
315  TGeoNode *current;
316  TGeoVoxelFinder *voxels = fVolume->GetVoxels();
317  //---> check fast unsafe voxels
318  Double_t *boxes = voxels->GetBoxes();
319  for (Int_t id=0; id<nd; id++) {
320  Int_t ist = 6*id;
321  Double_t dxyz = 0.;
322  Double_t dxyz0 = TMath::Abs(point[0]-boxes[ist+3])-boxes[ist];
323  if (dxyz0 > safe) continue;
324  Double_t dxyz1 = TMath::Abs(point[1]-boxes[ist+4])-boxes[ist+1];
325  if (dxyz1 > safe) continue;
326  Double_t dxyz2 = TMath::Abs(point[2]-boxes[ist+5])-boxes[ist+2];
327  if (dxyz2 > safe) continue;
328  if (dxyz0>0) dxyz+=dxyz0*dxyz0;
329  if (dxyz1>0) dxyz+=dxyz1*dxyz1;
330  if (dxyz2>0) dxyz+=dxyz2*dxyz2;
331  if (dxyz >= safe*safe) continue;
332  pnode = (TGeoPhysicalNode*)fPhysical->At(id);
333  // Return if inside the current node
334  if (pnode->IsMatchingState(nav)) return TGeoShape::Big();
335  current = fVolume->GetNode(id);
336  current->MasterToLocal(point, local);
337  // Safety to current node
338  safnext = current->Safety(local, kFALSE);
339  if (safnext < tolerance) return 0.;
340  if (safnext < safe) safe = safnext;
341  }
342  return safe;
343 }
344 
345 ////////////////////////////////////////////////////////////////////////////////
346 /// Check overlaps within a tolerance value.
347 
349 {
350  fVolume->CheckOverlaps(ovlp);
351 }
352 
353 ////////////////////////////////////////////////////////////////////////////////
354 /// Draw the parallel world
355 
357 {
358  fVolume->Draw(option);
359 }
360 
TGeoParallelWorld::fLastState
TGeoPhysicalNode * fLastState
helper volume
Definition: TGeoParallelWorld.h:29
TGeoManager::CheckPath
Bool_t CheckPath(const char *path) const
Check if a geometry path is valid without changing the state of the current navigator.
Definition: TGeoManager.cxx:1562
TGeoParallelWorld::TGeoParallelWorld
TGeoParallelWorld()
Definition: TGeoParallelWorld.h:37
TGeoPhysicalNode::IsMatchingState
Bool_t IsMatchingState(TGeoNavigator *nav) const
Checks if a given navigator state matches this physical node.
Definition: TGeoPhysicalNode.cxx:515
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:100
TGeoPhysicalNode
Physical nodes are the actual 'touchable' objects in the geometry, representing a path of positioned ...
Definition: TGeoPhysicalNode.h:37
TGeoVoxelFinder::GetCheckList
virtual Int_t * GetCheckList(const Double_t *point, Int_t &nelem, TGeoStateInfo &td)
get the list of daughter indices for which point is inside their bbox
Definition: TGeoVoxelFinder.cxx:1205
TObjArray::Delete
virtual void Delete(Option_t *option="")
Remove all objects from the array AND delete all heap based objects.
Definition: TObjArray.cxx:356
TGeoManager::IsClosed
Bool_t IsClosed() const
Definition: TGeoManager.h:305
TGeoVolume::GetShape
TGeoShape * GetShape() const
Definition: TGeoVolume.h:188
TObjArray
An array of TObjects.
Definition: TObjArray.h:37
TGeoManager::GetCurrentNavigator
TGeoNavigator * GetCurrentNavigator() const
Returns current navigator for the calling thread.
Definition: TGeoManager.cxx:738
TGeoVolume::GetNdaughters
Int_t GetNdaughters() const
Definition: TGeoVolume.h:349
TGeoParallelWorld::~TGeoParallelWorld
virtual ~TGeoParallelWorld()
Destructor.
Definition: TGeoParallelWorld.cxx:55
Option_t
const char Option_t
Definition: RtypesCore.h:66
TGeoShape::DistFromOutside
virtual Double_t DistFromOutside(const Double_t *point, const Double_t *dir, Int_t iact=1, Double_t step=TGeoShape::Big(), Double_t *safe=0) const =0
TGeoParallelWorld::ResetOverlaps
void ResetOverlaps() const
Reset overlapflag for all volumes in geometry.
Definition: TGeoParallelWorld.cxx:122
TGeoNavigator::GetCache
TGeoNodeCache * GetCache() const
Definition: TGeoNavigator.h:193
TGeoManager::GetListOfVolumes
TObjArray * GetListOfVolumes() const
Definition: TGeoManager.h:493
TGeoVoxelFinder::IsSafeVoxel
Bool_t IsSafeVoxel(const Double_t *point, Int_t inode, Double_t minsafe) const
Computes squared distance from POINT to the voxel(s) containing node INODE.
Definition: TGeoVoxelFinder.cxx:227
TGeoVolume::Voxelize
void Voxelize(Option_t *option)
build the voxels for this volume
Definition: TGeoVolume.cxx:2302
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
TObjArray::Remove
virtual TObject * Remove(TObject *obj)
Remove object from array.
Definition: TObjArray.cxx:719
TObjString.h
TGeoParallelWorld::fIsClosed
Bool_t fIsClosed
Definition: TGeoParallelWorld.h:27
TObject::Info
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:867
TObject::Error
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:893
TGeoParallelWorld::PrintDetectedOverlaps
Int_t PrintDetectedOverlaps() const
Print the overlaps which were detected during real tracking.
Definition: TGeoParallelWorld.cxx:104
TGeoParallelWorld::fPaths
TObjArray * fPaths
Definition: TGeoParallelWorld.h:25
TGeoNode::GetVolume
TGeoVolume * GetVolume() const
Definition: TGeoNode.h:97
TObject::Fatal
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition: TObject.cxx:921
TGeoVoxelFinder::GetNextVoxel
virtual Int_t * GetNextVoxel(const Double_t *point, const Double_t *dir, Int_t &ncheck, TGeoStateInfo &td)
get the list of new candidates for the next voxel crossed by current ray printf("### GetNextVoxel\n")...
Definition: TGeoVoxelFinder.cxx:1366
TGeoVolume.h
TGeoParallelWorld
Base class for a flat parallel geometry.
Definition: TGeoParallelWorld.h:22
TGeoVolume::AddNode
virtual void AddNode(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat=0, Option_t *option="")
Add a TGeoNode to the list of nodes.
Definition: TGeoVolume.cxx:932
TGeoPhysicalNode.h
TGeoParallelWorld::AddNode
void AddNode(const char *path)
Add a node normally to this world. Overlapping nodes not allowed.
Definition: TGeoParallelWorld.cxx:65
TGeoParallelWorld::FindNode
TGeoPhysicalNode * FindNode(Double_t point[3])
Finds physical node containing the point.
Definition: TGeoParallelWorld.cxx:182
TMath::Abs
Short_t Abs(Short_t d)
Definition: TMathBase.h:120
TGeoNodeCache
Special pool of reusable nodes.
Definition: TGeoCache.h:58
TGeoVolume::Contains
Bool_t Contains(const Double_t *point) const
Definition: TGeoVolume.h:109
TObjArray::At
TObject * At(Int_t idx) const
Definition: TObjArray.h:166
TGeoNode::MasterToLocal
virtual void MasterToLocal(const Double_t *master, Double_t *local) const
Convert the point coordinates from mother reference to local reference system.
Definition: TGeoNode.cxx:518
TGeoNavigator::GetCurrentVolume
TGeoVolume * GetCurrentVolume() const
Definition: TGeoNavigator.h:162
TGeoNode
A node represent a volume positioned inside another.They store links to both volumes and to the TGeoM...
Definition: TGeoNode.h:41
TObjString::GetName
const char * GetName() const
Returns name of object.
Definition: TObjString.h:38
TGeoParallelWorld::FindNextBoundary
TGeoPhysicalNode * FindNextBoundary(Double_t point[3], Double_t dir[3], Double_t &step, Double_t stepmax=1.E30)
Same functionality as TGeoNavigator::FindNextDaughterBoundary for the parallel world.
Definition: TGeoParallelWorld.cxx:216
TGeoParallelWorld::AddOverlap
void AddOverlap(TGeoVolume *vol, Bool_t activate=kTRUE)
To use this optimization, the user should declare the full list of volumes which may overlap with any...
Definition: TGeoParallelWorld.cxx:80
bool
TObjArray::Add
void Add(TObject *obj)
Definition: TObjArray.h:74
id
XFontStruct * id
Definition: TGX11.cxx:109
TObjString
Collectable string class.
Definition: TObjString.h:28
TGeoPhysicalNode::GetMatrix
TGeoHMatrix * GetMatrix(Int_t level=-1) const
Return global matrix for node at LEVEL.
Definition: TGeoPhysicalNode.cxx:369
TGeoParallelWorld::fVolume
TGeoVolume * fVolume
Closed flag.
Definition: TGeoParallelWorld.h:28
TGeoStateInfo
Statefull info for the current geometry level.
Definition: TGeoStateInfo.h:21
TGeoParallelWorld::CheckOverlaps
void CheckOverlaps(Double_t ovlp=0.001)
Check overlaps within a tolerance value.
Definition: TGeoParallelWorld.cxx:348
TGeoParallelWorld::fPhysical
TObjArray * fPhysical
Last PN touched.
Definition: TGeoParallelWorld.h:30
TGeoParallelWorld::Draw
void Draw(Option_t *option)
Draw the parallel world.
Definition: TGeoParallelWorld.cxx:356
TGeoHMatrix
Matrix class used for computing global transformations Should NOT be used for node definition.
Definition: TGeoMatrix.h:421
TGeoShape::ComputeBBox
virtual void ComputeBBox()=0
TGeoVoxelFinder::SortCrossedVoxels
virtual void SortCrossedVoxels(const Double_t *point, const Double_t *dir, TGeoStateInfo &td)
get the list in the next voxel crossed by a ray
Definition: TGeoVoxelFinder.cxx:1071
TGeoParallelWorld::RefreshPhysicalNodes
void RefreshPhysicalNodes()
Refresh the node pointers and re-voxelize.
Definition: TGeoParallelWorld.cxx:157
TObjArray::GetEntriesFast
Int_t GetEntriesFast() const
Definition: TObjArray.h:64
TGeoVolume::Draw
virtual void Draw(Option_t *option="")
draw top volume according to option
Definition: TGeoVolume.cxx:1146
TNamed
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:101
TGeoNode::GetNumber
Int_t GetNumber() const
Definition: TGeoNode.h:95
TGeoVolume::SetOverlappingCandidate
void SetOverlappingCandidate(Bool_t flag)
Definition: TGeoVolume.h:215
TGeoNavigator.h
TGeoVoxelFinder.h
TGeoVolume::GetNumber
Int_t GetNumber() const
Definition: TGeoVolume.h:182
TGeoMatrix.h
TGeoPhysicalNode::GetVolume
TGeoVolume * GetVolume(Int_t level=-1) const
Return volume associated with node at LEVEL in the branch.
Definition: TGeoPhysicalNode.cxx:389
TGeoParallelWorld::CloseGeometry
Bool_t CloseGeometry()
The main geometry must be closed.
Definition: TGeoParallelWorld.cxx:132
TGeoManager.h
TObjArray::AddAt
virtual void AddAt(TObject *obj, Int_t idx)
Add object at position ids.
Definition: TObjArray.cxx:254
TGeoNavigator
Class providing navigation API for TGeo geometries.
Definition: TGeoNavigator.h:34
TGeoVolume::GetVoxels
TGeoVoxelFinder * GetVoxels() const
Getter for optimization structure.
Definition: TGeoVolume.cxx:1687
Double_t
double Double_t
Definition: RtypesCore.h:59
TGeoVolume::CheckOverlaps
void CheckOverlaps(Double_t ovlp=0.1, Option_t *option="") const
Overlap checking tool.
Definition: TGeoVolume.cxx:589
TGeoVolume::GetNode
TGeoNode * GetNode(const char *name) const
get the pointer to a daughter node
Definition: TGeoVolume.cxx:2060
TGeoParallelWorld.h
TGeoParallelWorld::fGeoManager
TGeoManager * fGeoManager
Definition: TGeoParallelWorld.h:24
TGeoParallelWorld::fUseOverlaps
Bool_t fUseOverlaps
Definition: TGeoParallelWorld.h:26
name
char name[80]
Definition: TGX11.cxx:110
TIter
Definition: TCollection.h:233
TGeoShape::Tolerance
static Double_t Tolerance()
Definition: TGeoShape.h:91
TGeoVoxelFinder::GetBoxes
Double_t * GetBoxes() const
Definition: TGeoVoxelFinder.h:106
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
TGeoShape::Big
static Double_t Big()
Definition: TGeoShape.h:88
TGeoNode::MasterToLocalVect
virtual void MasterToLocalVect(const Double_t *master, Double_t *local) const
Convert a vector from mother reference to local reference system.
Definition: TGeoNode.cxx:526
TGeoVoxelFinder
Finder class handling voxels.
Definition: TGeoVoxelFinder.h:21
TGeoVolume::IsOverlappingCandidate
Bool_t IsOverlappingCandidate() const
Definition: TGeoVolume.h:146
TGeoManager
The manager class for any TGeo geometry.
Definition: TGeoManager.h:45
TGeoVolume
TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes.
Definition: TGeoVolume.h:49
TGeoParallelWorld::Safety
Double_t Safety(Double_t point[3], Double_t safmax=1.E30)
Compute safety for the parallel world.
Definition: TGeoParallelWorld.cxx:302
TGeoVolumeAssembly
Volume assemblies.
Definition: TGeoVolume.h:303
snext
#define snext(osub1, osub2)
Definition: triangle.c:1167
int
TGeoNode::Safety
Double_t Safety(const Double_t *point, Bool_t in=kTRUE) const
computes the closest distance from given point to this shape
Definition: TGeoNode.cxx:630
TGeoNodeCache::GetMakePWInfo
TGeoStateInfo * GetMakePWInfo(Int_t nd)
Get the PW info, if none create one.
Definition: TGeoCache.cxx:154