Logo ROOT  
Reference Guide
TGeoVolume.h
Go to the documentation of this file.
1// @(#)root/geom:$Id$
2// Author: Andrei Gheata 30/05/02
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11// Author : date : Wed 24 Oct 2001 01:39:36 PM CEST
12
13#ifndef ROOT_TGeoVolume
14#define ROOT_TGeoVolume
15
16
17#include "TNamed.h"
18#include "TGeoAtt.h"
19#include "TAttLine.h"
20#include "TAttFill.h"
21#include "TAtt3D.h"
22#include "TObjArray.h"
23#include "TGeoMedium.h"
24#include "TGeoShape.h"
25#include <mutex>
26#include <vector>
27
28// forward declarations
29class TH2F;
30class TGeoNode;
31class TGeoMatrix;
33class TGeoVoxelFinder;
34class TGeoManager;
35class TGeoExtension;
36
37////////////////////////////////////////////////////////////////////////////
38// //
39// TGeoVolume - base class representing a single volume having a shape //
40// and a medium. //
41// //
42////////////////////////////////////////////////////////////////////////////
43
44class TGeoVolume : public TNamed,
45 public TGeoAtt,
46 public TAttLine,
47 public TAttFill,
48 public TAtt3D
49{
50protected :
51 TObjArray *fNodes; // array of nodes inside this volume
52 TGeoShape *fShape; // shape
53 TGeoMedium *fMedium; // tracking medium
54 static TGeoMedium *fgDummyMedium; //! dummy medium
55 TGeoPatternFinder *fFinder; // finder object for divisions
56 TGeoVoxelFinder *fVoxels; // finder object for bounding boxes
57 TGeoManager *fGeoManager; //! pointer to TGeoManager owning this volume
58
59 TObject *fField; //! just a hook for now
60 TString fOption; //! option - if any
61 Int_t fNumber; // volume serial number in the list of volumes
62 Int_t fNtotal; // total number of physical nodes
63 Int_t fRefCount; // reference counter
64 TGeoExtension *fUserExtension; //! Transient user-defined extension to volumes
65 TGeoExtension *fFWExtension; //! Transient framework-defined extension to volumes
66
67private:
68 TGeoVolume(const TGeoVolume&) = delete;
69 TGeoVolume& operator=(const TGeoVolume&) = delete;
70
71public:
72 virtual void ClearThreadData() const;
73 virtual void CreateThreadData(Int_t nthreads);
74
75public:
83 kVoxelsXYZ = BIT(20), // not used
84 kVoxelsCyl = BIT(21), // not used
87 kVolumeOC = BIT(21) // overlapping candidates
88 };
89 // constructors
90 TGeoVolume();
91 TGeoVolume(const char *name, const TGeoShape *shape, const TGeoMedium *med=0);
92
93 // destructor
94 virtual ~TGeoVolume();
95 // methods
96 virtual void cd(Int_t inode) const;
97 void Browse(TBrowser *b);
98 Double_t Capacity() const;
99 void CheckShapes();
100 void ClearNodes() {fNodes = 0;}
101 void ClearShape();
102 void CleanAll();
103 virtual TGeoVolume *CloneVolume() const;
104 void CloneNodesAndConnect(TGeoVolume *newmother) const;
105 void CheckGeometry(Int_t nrays=1, Double_t startx=0, Double_t starty=0, Double_t startz=0) const;
106 void CheckOverlaps(Double_t ovlp=0.1, Option_t *option="") const; // *MENU*
107 void CheckShape(Int_t testNo, Int_t nsamples=10000, Option_t *option=""); // *MENU*
108 Int_t CountNodes(Int_t nlevels=1000, Int_t option=0);
109 Bool_t Contains(const Double_t *point) const {return fShape->Contains(point);}
110 static void CreateDummyMedium();
111 static TGeoMedium *DummyMedium();
112 virtual Bool_t IsAssembly() const;
113 virtual Bool_t IsFolder() const;
115 virtual Bool_t IsVolumeMulti() const {return kFALSE;}
116 virtual void AddNode(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat=0, Option_t *option=""); // most general case
117 void AddNodeOffset(TGeoVolume *vol, Int_t copy_no, Double_t offset=0, Option_t *option="");
118 virtual void AddNodeOverlap(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat=0, Option_t *option="");
119
120 virtual TGeoVolume *Divide(const char *divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed=0, Option_t *option="");
121 virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
122 virtual void Draw(Option_t *option=""); // *MENU*
123 virtual void DrawOnly(Option_t *option=""); // *MENU*
124 TH2F *LegoPlot(Int_t ntheta=20, Double_t themin=0., Double_t themax=180.,
125 Int_t nphi=60, Double_t phimin=0., Double_t phimax=360.,
126 Double_t rmin=0., Double_t rmax=9999999, Option_t *option=""); // *MENU*
127 virtual void Paint(Option_t *option="");
128 virtual void Print(Option_t *option="") const; // *MENU*
129 void PrintNodes() const;
130 void PrintVoxels() const; // *MENU*
131 void ReplayCreation(const TGeoVolume *other);
133 void SetFWExtension(TGeoExtension *ext);
134 Int_t GetRefCount() const {return fRefCount;}
139 void Grab() {fRefCount++;}
140 void Release() {fRefCount--; if (fRefCount==0) delete this;}
141 virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
142
151 Bool_t IsTopVolume() const;
152 Bool_t IsValid() const {return fShape->IsValid();}
153 virtual Bool_t IsVisible() const {return TGeoAtt::IsVisible();}
158 Bool_t IsAllInvisible() const;
159 Bool_t IsRaytracing() const;
160 static TGeoVolume *Import(const char *filename, const char *name="", Option_t *option="");
161 Int_t Export(const char *filename, const char *name="", Option_t *option="");
162 TGeoNode *FindNode(const char *name) const;
163 void FindOverlaps() const;
165 virtual Int_t GetCurrentNodeIndex() const {return -1;}
166 virtual Int_t GetNextNodeIndex() const {return -1;}
168 Int_t GetNdaughters() const;
169 Int_t GetNtotal() const {return fNtotal;}
170 virtual Int_t GetByteCount() const;
174 TObject *GetField() const {return fField;}
176 TGeoVoxelFinder *GetVoxels() const;
177 const char *GetIconName() const {return fShape->GetName();}
178 Int_t GetIndex(const TGeoNode *node) const;
179 TGeoNode *GetNode(const char *name) const;
181 Int_t GetNodeIndex(const TGeoNode *node, Int_t *check_list, Int_t ncheck) const;
182 Int_t GetNumber() const {return fNumber;}
183 virtual char *GetObjectInfo(Int_t px, Int_t py) const;
184 Bool_t GetOptimalVoxels() const;
185 Option_t *GetOption() const { return fOption.Data(); }
186 char *GetPointerName() const;
188 TGeoShape *GetShape() const {return fShape;}
189 void GrabFocus(); // *MENU*
190 void Gsord(Int_t /*iaxis*/) {;}
191 Bool_t IsStyleDefault() const;
192 void InspectMaterial() const; // *MENU*
193 void InspectShape() const {fShape->InspectShape();} // *MENU*
194 virtual TGeoVolume *MakeCopyVolume(TGeoShape *newshape);
195 void MakeCopyNodes(const TGeoVolume *other);
196 TGeoVolume *MakeReflectedVolume(const char *newname="") const;
197 Bool_t OptimizeVoxels(); // *MENU*
198 void RandomPoints(Int_t npoints=1000000, Option_t *option=""); // *MENU*
199 void RandomRays(Int_t nrays=10000, Double_t startx=0, Double_t starty=0, Double_t startz=0, const char *target_vol=0, Bool_t check_norm=kFALSE); // *MENU*
200 void Raytrace(Bool_t flag=kTRUE); // *TOGGLE* *GETTER=IsRaytracing
201 void RegisterYourself(Option_t *option="");
202 void RemoveNode(TGeoNode *node);
203 TGeoNode *ReplaceNode(TGeoNode *nodeorig, TGeoShape *newshape=0, TGeoMatrix *newpos=0, TGeoMedium *newmed=0);
204 void SaveAs(const char *filename,Option_t *option="") const; // *MENU*
205 virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
206 void SelectVolume(Bool_t clear = kFALSE);
209 void SetAsTopVolume(); // *TOGGLE* *GETTER=IsTopVolume
216 void SetShape(const TGeoShape *shape);
217 void SetTransparency(Char_t transparency=0) {if (fMedium) fMedium->GetMaterial()->SetTransparency(transparency);} // *MENU*
218 void SetField(TObject *field) {fField = field;}
219 void SetOption(const char *option);
221 virtual void SetVisibility(Bool_t vis=kTRUE); // *TOGGLE* *GETTER=IsVisible
222 virtual void SetVisContainers(Bool_t flag=kTRUE); // *TOGGLE* *GETTER=IsVisContainers
223 virtual void SetVisLeaves(Bool_t flag=kTRUE); // *TOGGLE* *GETTER=IsVisLeaves
224 virtual void SetVisOnly(Bool_t flag=kTRUE); // *TOGGLE* *GETTER=IsVisOnly
225 virtual void SetLineColor(Color_t lcolor);
226 virtual void SetLineStyle(Style_t lstyle);
227 virtual void SetLineWidth(Width_t lwidth);
229 virtual void SetMedium(TGeoMedium *medium) {fMedium = medium;}
230 void SetVoxelFinder(TGeoVoxelFinder *finder) {fVoxels = finder;}
231 void SetFinder(TGeoPatternFinder *finder) {fFinder = finder;}
232 void SetNumber(Int_t number) {fNumber = number;}
233 void SetNtotal(Int_t ntotal) {fNtotal = ntotal;}
234 void SortNodes();
235 void UnmarkSaved();
236 Bool_t Valid() const;
237 void VisibleDaughters(Bool_t vis=kTRUE); // *TOGGLE* *GETTER=IsVisibleDaughters
238 void InvisibleAll(Bool_t flag=kTRUE); // *TOGGLE* *GETTER=IsAllInvisible
239 void Voxelize(Option_t *option);
240 Double_t Weight(Double_t precision=0.01, Option_t *option="va"); // *MENU*
241 Double_t WeightA() const;
242
243 ClassDef(TGeoVolume, 6) // geometry volume descriptor
244};
245
246////////////////////////////////////////////////////////////////////////////
247// //
248// TGeoVolumeMulti - class storing a list of volumes that have to //
249// be handled together at build time //
250// //
251////////////////////////////////////////////////////////////////////////////
252
254{
255private:
256 TObjArray *fVolumes; // list of volumes
257 TGeoVolumeMulti *fDivision; // division of this volume
258 Int_t fNumed; // medium number for divisions
259 Int_t fNdiv; // number of divisions
260 Int_t fAxis; // axis of division
261 Double_t fStart; // division start offset
262 Double_t fStep; // division step
263 Bool_t fAttSet; // flag attributes set
264
267
268public:
270 TGeoVolumeMulti(const char* name, TGeoMedium *med=0);
271 virtual ~TGeoVolumeMulti();
272
273 void AddVolume(TGeoVolume *vol);
274 TGeoVolume *GetVolume(Int_t id) const {return (TGeoVolume*)fVolumes->At(id);}
275 virtual void AddNode(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat, Option_t *option=""); // most general case
276 virtual void AddNodeOverlap(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat, Option_t *option="");
277 virtual TGeoVolume *Divide(const char *divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed=0, Option_t *option="");
278 TGeoShape *GetLastShape() const;
280 Int_t GetAxis() const {return fNdiv;}
281 Int_t GetNdiv() const {return fNdiv;}
282 Double_t GetStart() const {return fStart;}
283 Double_t GetStep() const {return fStep;}
284 virtual Bool_t IsVolumeMulti() const {return kTRUE;}
285 virtual TGeoVolume *MakeCopyVolume(TGeoShape *newshape);
286 virtual void SetLineColor(Color_t lcolor);
287 virtual void SetLineStyle(Style_t lstyle);
288 virtual void SetLineWidth(Width_t lwidth);
289 virtual void SetMedium(TGeoMedium *medium);
290 virtual void SetVisibility(Bool_t vis=kTRUE);
291
292 ClassDef(TGeoVolumeMulti, 3) // class to handle multiple volumes in one step
293};
294
295////////////////////////////////////////////////////////////////////////////
296// //
297// TGeoVolumeAssembly - special assembly of volumes. The assembly has no //
298// medium and its shape is the union of all component shapes //
299// //
300////////////////////////////////////////////////////////////////////////////
301
303{
304public:
306 {
307 Int_t fCurrent; //! index of current selected node
308 Int_t fNext; //! index of next node to be entered
309
310 ThreadData_t();
312 };
313
315 virtual void ClearThreadData() const;
316 virtual void CreateThreadData(Int_t nthreads);
317
318protected:
319 mutable std::vector<ThreadData_t*> fThreadData; //! Thread specific data vector
320 mutable Int_t fThreadSize; //! Thread vector size
321 mutable std::mutex fMutex; //! Mutex for concurrent operations
322
323private:
326
327public:
329 TGeoVolumeAssembly(const char *name);
330 virtual ~TGeoVolumeAssembly();
331
332 virtual void AddNode(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat=0, Option_t *option="");
333 virtual void AddNodeOverlap(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat, Option_t *option);
334 virtual TGeoVolume *CloneVolume() const;
335 virtual TGeoVolume *Divide(const char *divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed=0, Option_t *option="");
336 TGeoVolume *Divide(TGeoVolume *cell, TGeoPatternFinder *pattern, Option_t *option="spacedout");
337 virtual void DrawOnly(Option_t *) {;}
338 virtual Int_t GetCurrentNodeIndex() const;
339 virtual Int_t GetNextNodeIndex() const;
340 virtual Bool_t IsAssembly() const {return kTRUE;}
341 virtual Bool_t IsVisible() const {return kFALSE;}
343 void SetCurrentNodeIndex(Int_t index);
344 void SetNextNodeIndex(Int_t index);
345
346 ClassDef(TGeoVolumeAssembly, 2) // an assembly of volumes
347};
348
349inline Int_t TGeoVolume::GetNdaughters() const {if (!fNodes) return 0; return (fNodes->GetEntriesFast());}
350
351#endif
352
#define b(i)
Definition: RSha256.hxx:100
int Int_t
Definition: RtypesCore.h:45
char Char_t
Definition: RtypesCore.h:33
const Bool_t kFALSE
Definition: RtypesCore.h:101
short Width_t
Definition: RtypesCore.h:91
bool Bool_t
Definition: RtypesCore.h:63
double Double_t
Definition: RtypesCore.h:59
short Color_t
Definition: RtypesCore.h:92
short Style_t
Definition: RtypesCore.h:89
const Bool_t kTRUE
Definition: RtypesCore.h:100
const char Option_t
Definition: RtypesCore.h:66
#define ClassDef(name, id)
Definition: Rtypes.h:325
#define BIT(n)
Definition: Rtypes.h:85
char name[80]
Definition: TGX11.cxx:110
Use this attribute class when an object should have 3D capabilities.
Definition: TAtt3D.h:19
Fill Area Attributes class.
Definition: TAttFill.h:19
Line Attributes class.
Definition: TAttLine.h:18
Using a TBrowser one can browse all ROOT objects.
Definition: TBrowser.h:37
Visualization and tracking attributes for volumes and nodes.
Definition: TGeoAtt.h:18
Bool_t IsActive() const
Definition: TGeoAtt.h:85
void SetActivity(Bool_t flag=kTRUE)
Definition: TGeoAtt.h:79
Bool_t IsActiveDaughters() const
Definition: TGeoAtt.h:86
Bool_t IsVisible() const
Definition: TGeoAtt.h:88
Bool_t IsVisOnly() const
Definition: TGeoAtt.h:93
Bool_t IsVisLeaves() const
Definition: TGeoAtt.h:92
void SetActiveDaughters(Bool_t flag=kTRUE)
Definition: TGeoAtt.h:80
Bool_t IsVisDaughters() const
Definition: TGeoAtt.h:89
Bool_t IsVisContainers() const
Definition: TGeoAtt.h:91
virtual void SetVisibility(Bool_t vis=kTRUE)
Set visibility for this object.
Definition: TGeoAtt.cxx:105
ABC for user objects attached to TGeoVolume or TGeoNode.
Definition: TGeoExtension.h:20
The manager class for any TGeo geometry.
Definition: TGeoManager.h:45
Base class describing materials.
Definition: TGeoMaterial.h:36
Char_t GetTransparency() const
Definition: TGeoMaterial.h:119
void SetTransparency(Char_t transparency=0)
Definition: TGeoMaterial.h:140
Geometrical transformation package.
Definition: TGeoMatrix.h:41
Media are used to store properties related to tracking and which are useful only when using geometry ...
Definition: TGeoMedium.h:24
TGeoMaterial * GetMaterial() const
Definition: TGeoMedium.h:52
A node represent a volume positioned inside another.They store links to both volumes and to the TGeoM...
Definition: TGeoNode.h:41
Base finder class for patterns.
Base abstract class for all shapes.
Definition: TGeoShape.h:26
Bool_t IsValid() const
Definition: TGeoShape.h:140
Bool_t IsRunTimeShape() const
Definition: TGeoShape.h:139
virtual void InspectShape() const =0
virtual const char * GetName() const
Get the shape name.
Definition: TGeoShape.cxx:248
virtual Bool_t Contains(const Double_t *point) const =0
Volume assemblies.
Definition: TGeoVolume.h:303
static TGeoVolumeAssembly * MakeAssemblyFromVolume(TGeoVolume *vol)
Make a clone of volume VOL but which is an assembly.
TGeoVolumeAssembly & operator=(const TGeoVolumeAssembly &)=delete
virtual Int_t GetCurrentNodeIndex() const
TGeoVolumeAssembly(const TGeoVolumeAssembly &)=delete
Mutex for concurrent operations.
virtual TGeoVolume * Divide(const char *divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed=0, Option_t *option="")
Division makes no sense for assemblies.
virtual void ClearThreadData() const
virtual Bool_t IsVisible() const
Definition: TGeoVolume.h:341
virtual void DrawOnly(Option_t *)
draw only this volume
Definition: TGeoVolume.h:337
virtual Int_t GetNextNodeIndex() const
virtual void AddNodeOverlap(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat, Option_t *option)
Add an overlapping node - not allowed for assemblies.
std::vector< ThreadData_t * > fThreadData
Definition: TGeoVolume.h:319
virtual ~TGeoVolumeAssembly()
Destructor. The assembly is owner of its "shape".
std::mutex fMutex
Thread vector size.
Definition: TGeoVolume.h:321
virtual Bool_t IsAssembly() const
Returns true if the volume is an assembly or a scaled assembly.
Definition: TGeoVolume.h:340
virtual void AddNode(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat=0, Option_t *option="")
Add a component to the assembly.
Int_t fThreadSize
Thread specific data vector.
Definition: TGeoVolume.h:320
void SetNextNodeIndex(Int_t index)
virtual TGeoVolume * CloneVolume() const
Clone this volume.
void SetCurrentNodeIndex(Int_t index)
TGeoVolumeAssembly()
Default constructor.
virtual void CreateThreadData(Int_t nthreads)
ThreadData_t & GetThreadData() const
Volume families.
Definition: TGeoVolume.h:254
virtual void SetVisibility(Bool_t vis=kTRUE)
Set visibility for all components.
virtual TGeoVolume * MakeCopyVolume(TGeoShape *newshape)
Make a copy of this volume build a volume with same name, shape and medium.
Double_t fStart
Definition: TGeoVolume.h:261
void AddVolume(TGeoVolume *vol)
Add a volume with valid shape to the list of volumes.
virtual Bool_t IsVolumeMulti() const
Definition: TGeoVolume.h:284
virtual void SetLineStyle(Style_t lstyle)
Set the line style for all components.
virtual void AddNodeOverlap(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat, Option_t *option="")
Add a new node to the list of nodes, This node is possibly overlapping with other daughters of the vo...
Int_t GetAxis() const
Definition: TGeoVolume.h:280
TGeoVolume * GetVolume(Int_t id) const
Definition: TGeoVolume.h:274
virtual ~TGeoVolumeMulti()
Destructor.
TGeoVolumeMulti & operator=(const TGeoVolumeMulti &)=delete
virtual TGeoVolume * Divide(const char *divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed=0, Option_t *option="")
division of multiple volumes
Double_t fStep
Definition: TGeoVolume.h:262
Double_t GetStart() const
Definition: TGeoVolume.h:282
virtual void SetLineColor(Color_t lcolor)
Set the line color for all components.
TGeoVolumeMulti * fDivision
Definition: TGeoVolume.h:257
TGeoVolumeMulti()
dummy constructor
virtual void AddNode(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat, Option_t *option="")
Add a new node to the list of nodes.
TGeoVolumeMulti(const TGeoVolumeMulti &)=delete
TGeoShape * GetLastShape() const
Returns the last shape.
Double_t GetStep() const
Definition: TGeoVolume.h:283
Int_t GetNvolumes() const
Definition: TGeoVolume.h:279
virtual void SetMedium(TGeoMedium *medium)
Set medium for a multiple volume.
TObjArray * fVolumes
Definition: TGeoVolume.h:256
virtual void SetLineWidth(Width_t lwidth)
Set the line width for all components.
Int_t GetNdiv() const
Definition: TGeoVolume.h:281
TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes.
Definition: TGeoVolume.h:49
virtual Int_t GetNextNodeIndex() const
Definition: TGeoVolume.h:166
Double_t WeightA() const
Analytical computation of the weight.
Bool_t IsCylVoxels() const
Definition: TGeoVolume.h:149
void AddNodeOffset(TGeoVolume *vol, Int_t copy_no, Double_t offset=0, Option_t *option="")
Add a division node to the list of nodes.
Definition: TGeoVolume.cxx:971
virtual void cd(Int_t inode) const
Actualize matrix of node indexed <inode>
Definition: TGeoVolume.cxx:923
virtual void ClearThreadData() const
Definition: TGeoVolume.cxx:424
virtual ~TGeoVolume()
Destructor.
Definition: TGeoVolume.cxx:502
virtual void Print(Option_t *option="") const
Print volume info.
Bool_t IsVisContainers() const
Definition: TGeoVolume.h:155
void SetVoxelFinder(TGeoVoxelFinder *finder)
Definition: TGeoVolume.h:230
void RemoveNode(TGeoNode *node)
Remove an existing daughter.
Int_t GetNodeIndex(const TGeoNode *node, Int_t *check_list, Int_t ncheck) const
Get the index of a daughter within check_list by providing the node pointer.
void RandomRays(Int_t nrays=10000, Double_t startx=0, Double_t starty=0, Double_t startz=0, const char *target_vol=0, Bool_t check_norm=kFALSE)
Random raytracing method.
Bool_t Valid() const
Check if the shape of this volume is valid.
TGeoNode * GetNode(Int_t i) const
Definition: TGeoVolume.h:180
TGeoExtension * GetUserExtension() const
Definition: TGeoVolume.h:135
Bool_t IsAllInvisible() const
Return TRUE if volume and all daughters are invisible.
Definition: TGeoVolume.cxx:753
Bool_t IsXYZVoxels() const
Definition: TGeoVolume.h:150
Int_t fNtotal
Definition: TGeoVolume.h:62
void MakeCopyNodes(const TGeoVolume *other)
make a new list of nodes and copy all nodes of other volume inside
TGeoNode * ReplaceNode(TGeoNode *nodeorig, TGeoShape *newshape=0, TGeoMatrix *newpos=0, TGeoMedium *newmed=0)
Replace an existing daughter with a new volume having the same name but possibly a new shape,...
void SetUserExtension(TGeoExtension *ext)
Connect user-defined extension to the volume.
TGeoExtension * GrabFWExtension() const
Get a copy of the framework extension pointer.
void SetNumber(Int_t number)
Definition: TGeoVolume.h:232
void ClearNodes()
Definition: TGeoVolume.h:100
void Raytrace(Bool_t flag=kTRUE)
Draw this volume with current settings and perform raytracing in the pad.
TGeoVolume()
dummy constructor
Definition: TGeoVolume.cxx:448
TGeoMedium * GetMedium() const
Definition: TGeoVolume.h:173
virtual Bool_t IsFolder() const
Return TRUE if volume contains nodes.
Definition: TGeoVolume.cxx:792
void CloneNodesAndConnect(TGeoVolume *newmother) const
Clone the array of nodes.
Int_t GetRefCount() const
Definition: TGeoVolume.h:134
Bool_t IsActiveDaughters() const
Definition: TGeoVolume.h:144
Bool_t IsSelected() const
Definition: TGeoVolume.h:148
void SortNodes()
sort nodes by decreasing volume of the bounding box.
Bool_t FindMatrixOfDaughterVolume(TGeoVolume *vol) const
Find a daughter node having VOL as volume and fill TGeoManager::fHMatrix with its global matrix.
void Voxelize(Option_t *option)
build the voxels for this volume
void Gsord(Int_t)
Definition: TGeoVolume.h:190
TGeoManager * GetGeoManager() const
Definition: TGeoVolume.h:171
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py)
compute the closest distance of approach from point px,py to this volume
Double_t Capacity() const
Computes the capacity of this [cm^3] as the capacity of its shape.
Definition: TGeoVolume.cxx:553
Bool_t IsRunTime() const
Definition: TGeoVolume.h:114
virtual TGeoVolume * MakeCopyVolume(TGeoShape *newshape)
make a copy of this volume build a volume with same name, shape and medium
Bool_t IsReplicated() const
Definition: TGeoVolume.h:147
void ReplayCreation(const TGeoVolume *other)
Recreate the content of the other volume without pointer copying.
Double_t Weight(Double_t precision=0.01, Option_t *option="va")
Estimate the weight of a volume (in kg) with SIGMA(M)/M better than PRECISION.
Int_t fNumber
option - if any
Definition: TGeoVolume.h:61
virtual void CreateThreadData(Int_t nthreads)
Definition: TGeoVolume.cxx:432
virtual Int_t GetByteCount() const
get the total size in bytes for this volume
Bool_t Contains(const Double_t *point) const
Definition: TGeoVolume.h:109
Bool_t OptimizeVoxels()
Perform an extensive sampling to find which type of voxelization is most efficient.
void SetCylVoxels(Bool_t flag=kTRUE)
Definition: TGeoVolume.h:213
void SetCurrentPoint(Double_t x, Double_t y, Double_t z)
Set the current tracking point.
virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py)
Execute mouse actions on this volume.
virtual void SetVisLeaves(Bool_t flag=kTRUE)
Set visibility for leaves.
void Browse(TBrowser *b)
How to browse a volume.
Definition: TGeoVolume.cxx:519
TGeoManager * fGeoManager
Definition: TGeoVolume.h:57
TH2F * LegoPlot(Int_t ntheta=20, Double_t themin=0., Double_t themax=180., Int_t nphi=60, Double_t phimin=0., Double_t phimax=360., Double_t rmin=0., Double_t rmax=9999999, Option_t *option="")
Generate a lego plot fot the top volume, according to option.
TGeoExtension * GetFWExtension() const
Definition: TGeoVolume.h:136
void SetActivity(Bool_t flag=kTRUE)
Definition: TGeoVolume.h:207
TGeoVoxelFinder * fVoxels
Definition: TGeoVolume.h:56
TGeoMaterial * GetMaterial() const
Definition: TGeoVolume.h:172
virtual Bool_t IsVolumeMulti() const
Definition: TGeoVolume.h:115
TGeoExtension * GrabUserExtension() const
Get a copy of the user extension pointer.
@ kVolumeClone
Definition: TGeoVolume.h:85
@ kVolumeOverlap
Definition: TGeoVolume.h:80
@ kVolumeReplicated
Definition: TGeoVolume.h:77
@ kVolumeSelected
Definition: TGeoVolume.h:78
@ kVolumeMulti
Definition: TGeoVolume.h:82
@ kVolumeImportNodes
Definition: TGeoVolume.h:81
@ kVolumeAdded
Definition: TGeoVolume.h:86
Int_t CountNodes(Int_t nlevels=1000, Int_t option=0)
Count total number of subnodes starting from this volume, nlevels down.
Definition: TGeoVolume.cxx:702
void GrabFocus()
Move perspective view focus to this volume.
void UnmarkSaved()
Reset SavePrimitive bits.
virtual TGeoVolume * CloneVolume() const
Clone this volume.
void SetFinder(TGeoPatternFinder *finder)
Definition: TGeoVolume.h:231
Int_t GetNdaughters() const
Definition: TGeoVolume.h:349
Bool_t IsValid() const
Definition: TGeoVolume.h:152
virtual void SetLineStyle(Style_t lstyle)
Set the line style.
void Grab()
Definition: TGeoVolume.h:139
char * GetPointerName() const
Provide a pointer name containing uid.
void CheckGeometry(Int_t nrays=1, Double_t startx=0, Double_t starty=0, Double_t startz=0) const
Shoot nrays with random directions from starting point (startx, starty, startz) in the reference fram...
Definition: TGeoVolume.cxx:568
void SelectVolume(Bool_t clear=kFALSE)
Select this volume as matching an arbitrary criteria.
TObjArray * GetNodes()
Definition: TGeoVolume.h:167
virtual char * GetObjectInfo(Int_t px, Int_t py) const
Get volume info for the browser.
void SetTransparency(Char_t transparency=0)
Definition: TGeoVolume.h:217
Option_t * GetOption() const
Definition: TGeoVolume.h:185
void ClearShape()
Clear the shape of this volume from the list held by the current manager.
Definition: TGeoVolume.cxx:640
void SetFWExtension(TGeoExtension *ext)
Connect framework defined extension to the volume.
void VisibleDaughters(Bool_t vis=kTRUE)
set visibility for daughters
void Release()
Definition: TGeoVolume.h:140
void FindOverlaps() const
loop all nodes marked as overlaps and find overlapping brothers
TGeoNode * GetNode(const char *name) const
get the pointer to a daughter node
virtual void SetVisibility(Bool_t vis=kTRUE)
set visibility of this volume
void RandomPoints(Int_t npoints=1000000, Option_t *option="")
Draw random points in the bounding box of this volume.
void CheckShapes()
check for negative parameters in shapes.
Definition: TGeoVolume.cxx:648
void SetNtotal(Int_t ntotal)
Definition: TGeoVolume.h:233
virtual void Paint(Option_t *option="")
paint volume
Bool_t GetOptimalVoxels() const
Returns true if cylindrical voxelization is optimal.
void InvisibleAll(Bool_t flag=kTRUE)
Make volume and each of it daughters (in)visible.
Definition: TGeoVolume.cxx:764
Bool_t IsVisibleDaughters() const
Definition: TGeoVolume.h:154
TString fOption
just a hook for now
Definition: TGeoVolume.h:60
void SaveAs(const char *filename, Option_t *option="") const
Save geometry having this as top volume as a C++ macro.
Int_t GetIndex(const TGeoNode *node) const
get index number for a given daughter
void SetNodes(TObjArray *nodes)
Definition: TGeoVolume.h:214
TGeoPatternFinder * GetFinder() const
Definition: TGeoVolume.h:175
void PrintVoxels() const
Print the voxels for this volume.
TGeoExtension * fUserExtension
Definition: TGeoVolume.h:64
virtual void SetMedium(TGeoMedium *medium)
Definition: TGeoVolume.h:229
TGeoVoxelFinder * GetVoxels() const
Getter for optimization structure.
void SetAttVisibility(Bool_t vis)
Definition: TGeoVolume.h:220
void SetShape(const TGeoShape *shape)
set the shape associated with this volume
static TGeoMedium * DummyMedium()
Definition: TGeoVolume.cxx:440
TObject * fField
pointer to TGeoManager owning this volume
Definition: TGeoVolume.h:59
Int_t GetNumber() const
Definition: TGeoVolume.h:182
void CleanAll()
Clean data of the volume.
Definition: TGeoVolume.cxx:631
void SetActiveDaughters(Bool_t flag=kTRUE)
Definition: TGeoVolume.h:208
Bool_t IsTopVolume() const
True if this is the top volume of the geometry.
Definition: TGeoVolume.cxx:812
TGeoMedium * fMedium
Definition: TGeoVolume.h:53
TGeoShape * GetShape() const
Definition: TGeoVolume.h:188
void SetInvisible()
Definition: TGeoVolume.h:228
void InspectMaterial() const
Inspect the material for this volume.
Definition: TGeoVolume.cxx:829
void PrintNodes() const
print nodes
static TGeoMedium * fgDummyMedium
Definition: TGeoVolume.h:54
void RegisterYourself(Option_t *option="")
Register the volume and all materials/media/matrices/shapes to the manager.
virtual void AddNodeOverlap(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat=0, Option_t *option="")
Add a TGeoNode to the list of nodes.
Definition: TGeoVolume.cxx:996
virtual void Draw(Option_t *option="")
draw top volume according to option
TGeoVolume & operator=(const TGeoVolume &)=delete
virtual void SetVisOnly(Bool_t flag=kTRUE)
Set visibility for leaves.
TGeoVolume(const TGeoVolume &)=delete
Transient framework-defined extension to volumes.
virtual TGeoVolume * Divide(const char *divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed=0, Option_t *option="")
Division a la G3.
Bool_t IsRaytracing() const
Check if the painter is currently ray-tracing the content of this volume.
Definition: TGeoVolume.cxx:821
virtual Int_t GetCurrentNodeIndex() const
Definition: TGeoVolume.h:165
TGeoShape * fShape
Definition: TGeoVolume.h:52
void SetField(TObject *field)
Definition: TGeoVolume.h:218
static TGeoVolume * Import(const char *filename, const char *name="", Option_t *option="")
Import a volume from a file.
Definition: TGeoVolume.cxx:837
Bool_t IsStyleDefault() const
check if the visibility and attributes are the default ones
Definition: TGeoVolume.cxx:800
static void CreateDummyMedium()
Create a dummy medium.
Definition: TGeoVolume.cxx:412
TGeoExtension * fFWExtension
Transient user-defined extension to volumes.
Definition: TGeoVolume.h:65
void SetAsTopVolume()
Set this volume as the TOP one (the whole geometry starts from here)
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save a primitive as a C++ statement(s) on output stream "out".
void SetAdded()
Definition: TGeoVolume.h:210
Bool_t IsVisLeaves() const
Definition: TGeoVolume.h:156
virtual void SetVisContainers(Bool_t flag=kTRUE)
Set visibility for containers.
void SetReplicated()
Definition: TGeoVolume.h:211
virtual void SetLineWidth(Width_t lwidth)
Set the line width.
TObject * GetField() const
Definition: TGeoVolume.h:174
TGeoPatternFinder * fFinder
dummy medium
Definition: TGeoVolume.h:55
Int_t Export(const char *filename, const char *name="", Option_t *option="")
Export this volume to a file.
Definition: TGeoVolume.cxx:887
virtual void DrawOnly(Option_t *option="")
draw only this volume
virtual void SetLineColor(Color_t lcolor)
Set the line color.
void SetOption(const char *option)
Set the current options (none implemented)
Bool_t IsVisOnly() const
Definition: TGeoVolume.h:157
const char * GetIconName() const
Returns mime type name of object.
Definition: TGeoVolume.h:177
virtual Bool_t IsAssembly() const
Returns true if the volume is an assembly or a scaled assembly.
TGeoVolume * MakeReflectedVolume(const char *newname="") const
Make a copy of this volume which is reflected with respect to XY plane.
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
Char_t GetTransparency() const
Definition: TGeoVolume.h:187
Bool_t IsActive() const
Definition: TGeoVolume.h:143
TObjArray * fNodes
Definition: TGeoVolume.h:51
virtual Bool_t IsVisible() const
Definition: TGeoVolume.h:153
Bool_t IsAdded() const
Definition: TGeoVolume.h:145
Int_t GetNtotal() const
Definition: TGeoVolume.h:169
void InspectShape() const
Definition: TGeoVolume.h:193
TGeoNode * FindNode(const char *name) const
search a daughter inside the list of nodes
void CheckOverlaps(Double_t ovlp=0.1, Option_t *option="") const
Overlap checking tool.
Definition: TGeoVolume.cxx:589
void SetOverlappingCandidate(Bool_t flag)
Definition: TGeoVolume.h:215
Bool_t IsOverlappingCandidate() const
Definition: TGeoVolume.h:146
Int_t fRefCount
Definition: TGeoVolume.h:63
void CheckShape(Int_t testNo, Int_t nsamples=10000, Option_t *option="")
Tests for checking the shape navigation algorithms. See TGeoShape::CheckShape()
Definition: TGeoVolume.cxx:623
Finder class handling voxels.
2-D histogram with a float per channel (see TH1 documentation)}
Definition: TH2.h:251
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
An array of TObjects.
Definition: TObjArray.h:37
Int_t GetEntriesFast() const
Definition: TObjArray.h:64
TObject * UncheckedAt(Int_t i) const
Definition: TObjArray.h:90
TObject * At(Int_t idx) const
Definition: TObjArray.h:166
Mother of all ROOT objects.
Definition: TObject.h:37
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:187
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:696
Basic string class.
Definition: TString.h:136
const char * Data() const
Definition: TString.h:369
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
static const std::string pattern("pattern")
ThreadData_t()
index of next node to be entered
Int_t fNext
index of current selected node
Definition: TGeoVolume.h:308