library: libGeom
#include "TGeoVolume.h"

TGeoVolumeMulti


class description - header file - source file
viewCVS header - viewCVS source

class TGeoVolumeMulti: public TGeoVolume

Inheritance Inherited Members Includes Libraries
Class Charts

Function Members (Methods)

Display options:
Show inherited
Show non-public
public:
TGeoVolumeMulti()
TGeoVolumeMulti(const char* name, const TGeoMedium* med = 0)
virtual~TGeoVolumeMulti()
voidTObject::AbstractMethod(const char* method) const
virtual voidAddNode(const TGeoVolume* vol, Int_t copy_no, TGeoMatrix* mat, Option_t* option = "")
voidTGeoVolume::AddNodeOffset(const TGeoVolume* vol, Int_t copy_no, Double_t offset = 0, Option_t* option = "")
virtual voidAddNodeOverlap(const TGeoVolume* vol, Int_t copy_no, TGeoMatrix* mat, Option_t* option = "")
voidAddVolume(TGeoVolume* vol)
virtual voidTObject::AppendPad(Option_t* option = "")
virtual voidTGeoVolume::Browse(TBrowser* b)
Double_tTGeoVolume::Capacity() const
virtual voidTGeoVolume::cd(Int_t inode) const
voidTGeoVolume::CheckGeometry(Int_t nrays = 1, Double_t startx = 0, Double_t starty = 0, Double_t startz = 0) const
voidTGeoVolume::CheckOverlaps(Double_t ovlp = 0.1, Option_t* option = "") const
voidTGeoVolume::CheckShapes()
static TClass*Class()
virtual const char*TObject::ClassName() const
voidTGeoVolume::CleanAll()
virtual voidTNamed::Clear(Option_t* option = "")
voidTGeoVolume::ClearNodes()
voidTGeoVolume::ClearShape()
virtual TObject*TNamed::Clone(const char* newname = "") const
voidTGeoVolume::CloneNodesAndConnect(TGeoVolume* newmother) const
virtual TGeoVolume*TGeoVolume::CloneVolume() const
virtual Int_tTNamed::Compare(const TObject* obj) const
Bool_tTGeoVolume::Contains(Double_t* point) const
virtual voidTNamed::Copy(TObject& named) const
Int_tTGeoVolume::CountNodes(Int_t nlevels = 1000, Int_t option = 0)
virtual voidTObject::Delete(Option_t* option = "")
Int_tTAttLine::DistancetoLine(Int_t px, Int_t py, Double_t xp1, Double_t yp1, Double_t xp2, Double_t yp2)
virtual Int_tTGeoVolume::DistancetoPrimitive(Int_t px, Int_t py)
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 = "")
virtual voidTGeoVolume::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() const
virtual TObject*TObject::DrawClone(Option_t* option = "") const
virtual voidTGeoVolume::DrawOnly(Option_t* option = "")
virtual voidTObject::Dump() const
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTGeoVolume::ExecuteEvent(Int_t event, Int_t px, Int_t py)
Int_tTGeoVolume::Export(const char* filename, const char* name = "", Option_t* option = "")
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual voidTNamed::FillBuffer(char*& buffer)
Bool_tTGeoVolume::FindMatrixOfDaughterVolume(TGeoVolume* vol) const
TGeoNode*TGeoVolume::FindNode(const char* name) const
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
voidTGeoVolume::FindOverlaps() const
Int_tGetAxis() const
virtual Int_tTGeoVolume::GetByteCount() const
virtual Int_tTGeoVolume::GetCurrentNodeIndex() const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
TObject*TGeoVolume::GetField() const
virtual Color_tTAttFill::GetFillColor() const
virtual Style_tTAttFill::GetFillStyle() const
TGeoPatternFinder*TGeoVolume::GetFinder() const
TGeoManager*TGeoVolume::GetGeoManager() const
virtual const char*TGeoVolume::GetIconName() const
Int_tTGeoVolume::GetIndex(const TGeoNode* node) const
TGeoShape*GetLastShape() const
virtual Color_tTAttLine::GetLineColor() const
virtual Style_tTAttLine::GetLineStyle() const
virtual Width_tTAttLine::GetLineWidth() const
TGeoMaterial*TGeoVolume::GetMaterial() const
TGeoMedium*TGeoVolume::GetMedium() const
virtual const char*TNamed::GetName() const
Int_tTGeoVolume::GetNdaughters() const
Int_tGetNdiv() const
virtual Int_tTGeoVolume::GetNextNodeIndex() const
TGeoNode*TGeoVolume::GetNode(const char* name) const
TGeoNode*TGeoVolume::GetNode(Int_t i) const
Int_tTGeoVolume::GetNodeIndex(const TGeoNode* node, Int_t* check_list, Int_t ncheck) const
TObjArray*TGeoVolume::GetNodes()
Int_tTGeoVolume::GetNtotal() const
Int_tTGeoVolume::GetNumber() const
Int_tGetNvolumes() const
virtual char*TGeoVolume::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
Bool_tTGeoVolume::GetOptimalVoxels() const
virtual Option_t*TGeoVolume::GetOption() const
char*TGeoVolume::GetPointerName() const
TGeoShape*TGeoVolume::GetShape() const
Double_tGetStart() const
Double_tGetStep() const
virtual const char*TNamed::GetTitle() const
Char_tTGeoVolume::GetTransparency() const
virtual UInt_tTObject::GetUniqueID() const
TGeoVolume*GetVolume(Int_t id) const
TGeoVoxelFinder*TGeoVolume::GetVoxels() const
voidTGeoVolume::GrabFocus()
voidTGeoVolume::Gsord(Int_t)
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTNamed::Hash() const
static TGeoVolume*TGeoVolume::Import(const char* filename, const char* name = "", Option_t* option = "")
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidTObject::Inspect() const
voidTGeoVolume::InspectMaterial() const
voidTGeoVolume::InspectShape() const
voidTObject::InvertBit(UInt_t f)
voidTGeoVolume::InvisibleAll(Bool_t flag = kTRUE)
virtual TClass*IsA() const
Bool_tTGeoVolume::IsActive() const
Bool_tTGeoVolume::IsActiveDaughters() const
Bool_tTGeoVolume::IsAdded() const
Bool_tTGeoVolume::IsAllInvisible() const
virtual Bool_tTGeoVolume::IsAssembly() const
Bool_tTGeoVolume::IsCylVoxels() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTGeoVolume::IsFolder() const
Bool_tTObject::IsOnHeap() const
Bool_tTGeoVolume::IsRaytracing() const
Bool_tTGeoVolume::IsReplicated() const
Bool_tTGeoVolume::IsRunTime() const
Bool_tTGeoVolume::IsSelected() const
virtual Bool_tTNamed::IsSortable() const
Bool_tTGeoVolume::IsStyleDefault() const
Bool_tTGeoVolume::IsTopVolume() const
virtual Bool_tTAttFill::IsTransparent() const
Bool_tTGeoVolume::IsValid() const
Bool_tTGeoAtt::IsVisBranch() const
Bool_tTGeoVolume::IsVisContainers() const
Bool_tTGeoAtt::IsVisDaughters() const
virtual Bool_tTGeoVolume::IsVisible() const
Bool_tTGeoVolume::IsVisibleDaughters() const
Bool_tTGeoVolume::IsVisLeaves() const
Bool_tTGeoVolume::IsVisOnly() const
Bool_tTGeoAtt::IsVisRaytrace() const
Bool_tTGeoAtt::IsVisStreamed() const
Bool_tTGeoAtt::IsVisTouched() const
virtual Bool_tIsVolumeMulti() const
Bool_tTGeoVolume::IsXYZVoxels() const
Bool_tTObject::IsZombie() const
TH2F*TGeoVolume::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 = "")
virtual voidTNamed::ls(Option_t* option = "") const
voidTGeoVolume::MakeCopyNodes(const TGeoVolume* other)
virtual TGeoVolume*MakeCopyVolume(TGeoShape* newshape)
TGeoVolume*TGeoVolume::MakeReflectedVolume(const char* newname = "") const
voidTObject::MayNotUse(const char* method) const
virtual voidTAttLine::Modify()
virtual Bool_tTObject::Notify()
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::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)
Bool_tTGeoVolume::OptimizeVoxels()
virtual voidTGeoVolume::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidTNamed::Print(Option_t* option = "") const
voidTGeoVolume::PrintNodes() const
voidTGeoVolume::PrintVoxels() const
voidTGeoVolume::RandomPoints(Int_t npoints = 1000000, Option_t* option = "")
voidTGeoVolume::RandomRays(Int_t nrays = 10000, Double_t startx = 0, Double_t starty = 0, Double_t startz = 0)
voidTGeoVolume::Raytrace(Bool_t flag = kTRUE)
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTGeoVolume::RegisterYourself(Option_t* option = "")
voidTGeoVolume::RemoveNode(TGeoNode* node)
TGeoNode*TGeoVolume::ReplaceNode(TGeoNode* nodeorig, TGeoShape* newshape = 0, TGeoMatrix* newpos = 0, TGeoMedium* newmed = 0)
voidTGeoAtt::ResetAttBit(UInt_t f)
virtual voidTAttFill::ResetAttFill(Option_t* option = "")
virtual voidTAttLine::ResetAttLine(Option_t* option = "")
voidTObject::ResetBit(UInt_t f)
virtual voidTGeoVolume::SaveAs(const char* filename, Option_t* option = "") const
virtual voidTAttFill::SaveFillAttributes(ostream& out, const char* name, Int_t coldef = 1, Int_t stydef = 1001)
virtual voidTAttLine::SaveLineAttributes(ostream& out, const char* name, Int_t coldef = 1, Int_t stydef = 1, Int_t widdef = 1)
virtual voidTGeoVolume::SavePrimitive(ostream& out, Option_t* option = "")
voidTGeoVolume::SelectVolume(Bool_t clear = kFALSE)
voidTGeoVolume::SetActiveDaughters(Bool_t flag = kTRUE)
voidTGeoVolume::SetActivity(Bool_t flag = kTRUE)
voidTGeoVolume::SetAdded()
voidTGeoVolume::SetAsTopVolume()
voidTGeoAtt::SetAttBit(UInt_t f)
voidTGeoAtt::SetAttBit(UInt_t f, Bool_t set)
voidTGeoVolume::SetAttVisibility(Bool_t vis)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidTGeoVolume::SetCurrentPoint(Double_t x, Double_t y, Double_t z)
voidTGeoVolume::SetCylVoxels(Bool_t flag = kTRUE)
virtual voidTObject::SetDrawOption(Option_t* option = "")
static voidTObject::SetDtorOnly(void* obj)
voidTGeoVolume::SetField(const TObject* field)
virtual voidTAttFill::SetFillAttributes()
virtual voidTAttFill::SetFillColor(Color_t fcolor)
virtual voidTAttFill::SetFillStyle(Style_t fstyle)
voidTGeoVolume::SetFinder(const TGeoPatternFinder* finder)
voidTGeoVolume::SetInvisible()
virtual voidTAttLine::SetLineAttributes()
virtual voidSetLineColor(Color_t lcolor)
virtual voidSetLineStyle(Style_t lstyle)
virtual voidSetLineWidth(Width_t lwidth)
virtual voidSetMedium(const TGeoMedium* medium)
virtual voidTNamed::SetName(const char* name)
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
voidTGeoVolume::SetNodes(TObjArray* nodes)
voidTGeoVolume::SetNtotal(Int_t ntotal)
voidTGeoVolume::SetNumber(Int_t number)
static voidTObject::SetObjectStat(Bool_t stat)
voidTGeoAtt::SetOptimization(Option_t* option)
voidTGeoVolume::SetOption(const char* option)
voidTGeoVolume::SetReplicated()
voidTGeoVolume::SetShape(const TGeoShape* shape)
virtual voidTNamed::SetTitle(const char* title = "")
voidTGeoVolume::SetTransparency(Char_t transparency = 0)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidTGeoAtt::SetVisBranch()
virtual voidTGeoVolume::SetVisContainers(Bool_t flag = kTRUE)
voidTGeoAtt::SetVisDaughters(Bool_t vis = kTRUE)
virtual voidSetVisibility(Bool_t vis = kTRUE)
virtual voidTGeoVolume::SetVisLeaves(Bool_t flag = kTRUE)
virtual voidTGeoVolume::SetVisOnly(Bool_t flag = kTRUE)
voidTGeoAtt::SetVisRaytrace(Bool_t flag = kTRUE)
voidTGeoAtt::SetVisStreamed(Bool_t vis = kTRUE)
voidTGeoAtt::SetVisTouched(Bool_t vis = kTRUE)
voidTGeoVolume::SetVoxelFinder(const TGeoVoxelFinder* finder)
virtual voidShowMembers(TMemberInspector& insp, char* parent)
virtual Int_tTNamed::Sizeof() const
virtual voidTAtt3D::Sizeof3D() const
voidTGeoVolume::SortNodes()
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTGeoAtt::TestAttBit(UInt_t f) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
voidTGeoVolume::UnmarkSaved()
virtual voidTObject::UseCurrentStyle()
Bool_tTGeoVolume::Valid() const
voidTGeoVolume::VisibleDaughters(Bool_t vis = kTRUE)
voidTGeoVolume::Voxelize(Option_t* option)
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
Double_tTGeoVolume::Weight(Double_t precision = 0.01, Option_t* option = "va")
Double_tTGeoVolume::WeightA() const
virtual Int_tTObject::Write(const char* name = "0", Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = "0", Int_t option = 0, Int_t bufsize = 0) const
protected:
TGeoVolumeMulti(const TGeoVolumeMulti&)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidTObject::MakeZombie()
TGeoVolumeMulti&operator=(const TGeoVolumeMulti&)

Data Members

public:
enum TGeoVolume::EGeoVolumeTypes { kVolumeReplicated
kVolumeSelected
kVolumeDiv
kVolumeOverlap
kVolumeImportNodes
kVolumeMulti
kVoxelsXYZ
kVoxelsCyl
kVolumeClone
kVolumeAdded
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
enum TGeoAtt::[unnamed] { kBitMask
};
enum TGeoAtt::EGeoVisibilityAtt { kVisOverride
kVisNone
kVisThis
kVisDaughters
kVisOneLevel
kVisStreamed
kVisTouched
kVisOnScreen
kVisContainers
kVisOnly
kVisBranch
kVisRaytrace
};
enum TGeoAtt::EGeoActivityAtt { kActOverride
kActNone
kActThis
kActDaughters
};
enum TGeoAtt::EGeoOptimizationAtt { kUseBoundingBox
kUseVoxels
kUseGsord
};
enum TGeoAtt::EGeoSavePrimitiveAtt { kSavePrimitiveAtt
kSaveNodesAtt
};
protected:
TObjArray*TGeoVolume::fNodesarray of nodes inside this volume
TGeoShape*TGeoVolume::fShapeshape
TGeoMedium*TGeoVolume::fMediumtracking medium
TGeoPatternFinder*TGeoVolume::fFinderfinder object for divisions
TGeoVoxelFinder*TGeoVolume::fVoxelsfinder object for bounding boxes
TGeoManager*TGeoVolume::fGeoManager! pointer to TGeoManager owning this volume
TObject*TGeoVolume::fField! just a hook for now
TStringTGeoVolume::fOption! option - if any
Int_tTGeoVolume::fNumbervolume serial number in the list of volumes
Int_tTGeoVolume::fNtotaltotal number of physical nodes
TStringTNamed::fNameobject identifier
TStringTNamed::fTitleobject title
UInt_tTGeoAtt::fGeoAttoption flags
Color_tTAttLine::fLineColorline color
Style_tTAttLine::fLineStyleline style
Width_tTAttLine::fLineWidthline width
Color_tTAttFill::fFillColorfill area color
Style_tTAttFill::fFillStylefill area style
private:
TObjArray*fVolumeslist of volumes
TGeoVolumeMulti*fDivisiondivision of this volume
Int_tfNumedmedium number for divisions
Int_tfNdivnumber of divisions
Int_tfAxisaxis of division
Double_tfStartdivision start offset
Double_tfStepdivision step
Bool_tfAttSetflag attributes set

Class Description

   TGeoVolume - the base class representing solids. 

   Volumes are the basic objects used in building the geometrical hierarchy.
 They represent unpositioned objects but store all information about the
 placement of the other volumes they may contain. Therefore a volume can
 be replicated several times in the geometry. In order to create a volume, one
 has to put togeather a shape and a medium which are already defined. Volumes
 have to be named by users at creation time. Every different name may represent a 
 an unique volume object, but may also represent more general a family (class)
 of volume objects having the same shape type and medium, but possibly
 different shape parameters. It is the user's task to provide different names
 for different volume families in order to avoid ambiguities at tracking time.
 A generic family rather than a single volume is created only in two cases : 
 when a generic shape is provided to the volume constructor or when a division
 operation is applied. Each volume in the geometry stores an unique
 ID corresponding to its family. In order to ease-up their creation, the manager
 class is providing an API that allows making a shape and a volume in a single step.

   Volumes are objects that can be visualized, therefore having visibility,
 colour, line and fill attributes that can be defined or modified any time after
 the volume creation. It is advisable however to define these properties just
 after the first creation of a volume namespace, since in case of volume families
 any new member created by the modeler inherits these properties. 

    In order to provide navigation features, volumes have to be able to find
 the proper container of any point defined in the local reference frame. This
 can be the volume itself, one of its positioned daughter volumes or none if 
 the point is actually outside. On the other hand, volumes have to provide also
 other navigation methods such as finding the distances to its shape boundaries
 or which daughter will be crossed first. The implementation of these features
 is done at shape level, but the local mother-daughters management is handled
 by volumes that builds additional optimisation structures upon geometry closure.
 In order to have navigation features properly working one has to follow the
 general rules for building a valid geometry (see TGeoManager class).

   Now let's make a simple volume representing a copper wire. We suppose that
 a medium is already created (see TGeoMedium class on how to create media). 
 We will create a TUBE shape for our wire, having Rmin=0cm, Rmax=0.01cm
 and a half-length dZ=1cm :

   TGeoTube *tube = new TGeoTube("wire_tube", 0, 0.01, 1);

 One may ommit the name for the shape if no retreiving by name is further needed
 during geometry building. The same shape can be shared by different volumes 
 having different names and materials. Now let's make the volume for our wire.
 The prototype for volumes constructor looks like :

   TGeoVolume::TGeoVolume(const char *name, TGeoShape *shape, TGeoMedium *med)

 Since TGeoTube derives brom the base shape class, we can provide it to the volume
 constructor :

   TGeoVolume *wire_co = new TGeoVolume("WIRE_CO", tube, ptrCOPPER);

 Do not bother to delete neither the media, shapes or volumes that you have
 created since all will be automatically cleaned on exit by the manager class.
 If we would have taken a look inside TGeoManager::MakeTube() method, we would
 have been able to create our wire with a single line :

   TGeoVolume *wire_co = gGeoManager->MakeTube("WIRE_CO", ptrCOPPER, 0, 0.01, 1);

 The same applies for all primitive shapes, for which there can be found
 corresponding MakeSHAPE() methods. Their usage is much more convenient unless 
 a shape has to be shared between more volumes. Let's make now an aluminium wire 
 having the same shape, supposing that we have created the copper wire with the 
 line above :

   TGeoVolume *wire_al = new TGeoVolume("WIRE_AL", wire_co->GetShape(), ptrAL);

 Now that we have learned how to create elementary volumes, let's see how we
 can create a geometrical hierarchy.


   Positioning volumes
 -----------------------

   When creating a volume one does not specify if this will contain or not other
 volumes. Adding daughters to a volume implies creating those and adding them 
 one by one to the list of daughters. Since the volume has to know the position 
 of all its daughters, we will have to supply at the same time a geometrical 
 transformation with respect to its local reference frame for each of them.
 The objects referencing a volume and a transformation are called NODES and
 their creation is fully handled by the modeler. They represent the link 
 elements in the hierarchy of volumes. Nodes are unique and distinct geometrical
 objects ONLY from their container point of view. Since volumes can be replicated
 in the geometry, the same node may be found on different branches.

/* */

   An important observation is that volume objects are owned by the TGeoManager
 class. This stores a list of all volumes in the geometry, that is cleaned
 upon destruction.

   Let's consider positioning now our wire in the middle of a gas chamber. We 
 need first to define the gas chamber :

   TGeoVolume *chamber = gGeoManager->MakeTube("CHAMBER", ptrGAS, 0, 1, 1);
 
 Now we can put the wire inside :

   chamber->AddNode(wire_co, 1);

 If we inspect now the chamber volume in a browser, we will notice that it has 
 one daughter. Of course the gas has some container also, but let's keep it like 
 that for the sake of simplicity. The full prototype of AddNode() is :

   TGeoVolume::AddNode(TGeoVolume *daughter, Int_t usernumber, 
                       TGeoMatrix *matrix=gGeoIdentity)

 Since we did not supplied the third argument, the wire will be positioned with
 an identity transformation inside the chamber. One will notice that the inner
 radii of the wire and chamber are both zero - therefore, aren't the two volumes
 overlapping ? The answer is no, the modeler is even relaying on the fact that
 any daughter is fully contained by its mother. On the other hand, neither of
 the nodes positioned inside a volume should overlap with each other. We will
 see that there are allowed some exceptions to those rules.

 Overlapping volumes
 --------------------

   Positioning volumes that does not overlap their neighbours nor extrude
 their container is sometimes quite strong contrain. Some parts of the geometry
 might overlap naturally, e.g. two crossing tubes. The modeller supports such
 cases only if the overlapping nodes are declared by the user. In order to do
 that, one should use TGeoVolume::AddNodeOverlap() instead of TGeoVolume::AddNode().
   When 2 or more positioned volumes are overlapping, not all of them have to
 be declared so, but at least one. A point inside an overlapping region equally
 belongs to all overlapping nodes, but the way these are defined can enforce
 the modeler to give priorities.
   The general rule is that the deepest node in the hierarchy containing a point
 have the highest priority. For the same geometry level, non-overlapping is
 prioritized over overlapping. In order to illustrate this, we will consider 
 few examples. We will designate non-overlapping nodes as ONLY and the others
 MANY as in GEANT3, where this concept was introduced:
   1. The part of a MANY node B extruding its container A will never be "seen" 
 during navigation, as if B was in fact the result of the intersection of A and B.
   2. If we have two nodes A (ONLY) and B (MANY) inside the same container, all
 points in the overlapping region of A and B will be designated as belonging to A.
   3. If A an B in the above case were both MANY, points in the overlapping 
 part will be designated to the one defined first. Both nodes must have the 
 same medium.
   4. The silces of a divided MANY will be as well MANY.

 One needs to know that navigation inside geometry parts MANY nodes is much 
 slower. Any overlapping part can be defined based on composite shapes - this
 is always recommended. 
TGeoVolumeMulti()
 dummy constructor
TGeoVolumeMulti(const char *name, const TGeoMedium *med)
 default constructor
TGeoVolumeMulti(const TGeoVolumeMulti& vm)
copy constructor
TGeoVolumeMulti& operator=(const TGeoVolumeMulti& vm)
assignment operator
~TGeoVolumeMulti()
 Destructor
void AddVolume(TGeoVolume *vol)
 Add a volume with valid shape to the list of volumes. Copy all existing nodes
 to this volume
void AddNode(const TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat, Option_t *option)
 Add a new node to the list of nodes. This is the usual method for adding
 daughters inside the container volume.
void AddNodeOverlap(const 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 volume or extruding the volume.
TGeoVolume * Divide(const char *divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed, const char *option)
 division of multiple volumes
TGeoVolume * MakeCopyVolume(TGeoShape *newshape)
 make a copy of this volume
    printf("   Making a copy of %s\n", GetName());
void SetLineColor(Color_t lcolor)
 Set the line color for all components.
void SetLineStyle(Style_t lstyle)
 Set the line style for all components.
void SetLineWidth(Width_t lwidth)
 Set the line width for all components.
void SetMedium(const TGeoMedium *med)
 Set medium for a multiple volume.
void SetVisibility(Bool_t vis)
 Set visibility for all components.
Bool_t IsVolumeMulti()
{return kFALSE;}
TGeoVolume * GetVolume(Int_t id)
{return (TGeoVolume*)fVolumes->At(id);}
TGeoShape * GetLastShape()
{return GetVolume(fVolumes->GetEntriesFast()-1)->GetShape();}
Int_t GetNvolumes()
{return fVolumes->GetEntriesFast();}
Int_t GetAxis()
{return fNdiv;}
Int_t GetNdiv()
{return fNdiv;}
Double_t GetStart()
{return fStart;}
Double_t GetStep()
{return fStep;}

Author: Andrei Gheata 30/05/02
Last update: root/geom:$Name: $:$Id: TGeoVolume.cxx,v 1.96 2006/12/06 15:09:11 brun 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.