TGeoVolume

class TGeoVolume : public TNamed, public TGeoAtt, public TAttLine, public TAttFill, public TAtt3D

    public:

                          TGeoVolume()
                          TGeoVolume(const char* name, const TGeoShape* shape, const TGeoMedium* med = 0)
                          TGeoVolume(const TGeoVolume&)
                  virtual ~TGeoVolume()
             virtual void AddNode(const TGeoVolume* vol, Int_t copy_no, TGeoMatrix* mat = 0, Option_t* option)
                     void AddNodeOffset(const TGeoVolume* vol, Int_t copy_no, Double_t offset = 0, Option_t* option)
             virtual void AddNodeOverlap(const TGeoVolume* vol, Int_t copy_no, TGeoMatrix* mat = 0, Option_t* option)
             virtual void Browse(TBrowser* b)
             virtual void cd(Int_t inode) const
                     void CheckGeometry(Int_t nrays = 1, Double_t startx = 0, Double_t starty = 0, Double_t startz = 0) const
                     void CheckOverlaps(Double_t ovlp = 0.1, Option_t* option) const
                     void CheckShapes()
           static TClass* Class()
                     void CleanAll()
                     void ClearNodes()
                     void ClearShape()
              TGeoVolume* CloneVolume() const
                   Bool_t Contains(Double_t* point) const
                    Int_t CountNodes(Int_t nlevels = 1000, Int_t option = 0)
            virtual Int_t 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 void Draw(Option_t* option)
             virtual void DrawOnly(Option_t* option)
             virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py)
                   Bool_t FindMatrixOfDaughterVolume(TGeoVolume* vol) const
                TGeoNode* FindNode(const char* name) const
                     void FindOverlaps() const
            virtual Int_t GetByteCount() const
                 TObject* GetField() const
       TGeoPatternFinder* GetFinder() const
             TGeoManager* GetGeoManager() const
                    Int_t GetIndex(const TGeoNode* node) const
            TGeoMaterial* GetMaterial() const
              TGeoMedium* GetMedium() const
                    Int_t GetNdaughters() const
                TGeoNode* GetNode(const char* name) const
                TGeoNode* GetNode(Int_t i) const
                    Int_t GetNodeIndex(const TGeoNode* node, Int_t* check_list, Int_t ncheck) const
               TObjArray* GetNodes()
                    Int_t GetNtotal() const
                    Int_t GetNumber() const
            virtual char* GetObjectInfo(Int_t px, Int_t py) const
                   Bool_t GetOptimalVoxels() const
        virtual Option_t* GetOption() const
                    char* GetPointerName() const
               TGeoShape* GetShape() const
                   Char_t GetTransparency() const
         TGeoVoxelFinder* GetVoxels() const
                     void GrabFocus()
                     void Gsord(Int_t)
                     void InspectMaterial() const
                     void InspectShape() const
                     void InvisibleAll(Bool_t flag = kTRUE)
          virtual TClass* IsA() const
                   Bool_t IsAllInvisible() const
           virtual Bool_t IsAssembly() const
                   Bool_t IsCylVoxels() const
           virtual Bool_t IsFolder() const
                   Bool_t IsRaytracing() const
                   Bool_t IsRunTime() const
                   Bool_t IsStyleDefault() const
                   Bool_t IsTopVolume() const
                   Bool_t IsValid() const
                   Bool_t IsVisible() const
                   Bool_t IsVisibleDaughters() const
           virtual Bool_t IsVolumeMulti() const
                   Bool_t IsXYZVoxels() const
                    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)
                     void MakeCopyNodes(const TGeoVolume* other)
      virtual TGeoVolume* MakeCopyVolume(TGeoShape* newshape)
              TGeoVolume& operator=(const TGeoVolume&)
                   Bool_t OptimizeVoxels()
             virtual void Paint(Option_t* option)
                     void PrintNodes() const
                     void PrintVoxels() const
                     void RandomPoints(Int_t npoints = 1000000, Option_t* option)
                     void RandomRays(Int_t nrays = 10000, Double_t startx = 0, Double_t starty = 0, Double_t startz = 0)
                     void Raytrace(Bool_t flag = kTRUE)
                     void SaveAs(const char* filename)
             virtual void SavePrimitive(ofstream& out, Option_t* option)
                     void SetAsTopVolume()
                     void SetCurrentPoint(Double_t x, Double_t y, Double_t z)
                     void SetCylVoxels(Bool_t flag = kTRUE)
                     void SetField(const TObject* field)
                     void SetFinder(const TGeoPatternFinder* finder)
                     void SetInvisible()
             virtual void SetLineColor(Color_t lcolor)
             virtual void SetLineStyle(Style_t lstyle)
             virtual void SetLineWidth(Width_t lwidth)
             virtual void SetMedium(const TGeoMedium* medium)
                     void SetNodes(TObjArray* nodes)
                     void SetNtotal(Int_t ntotal)
                     void SetNumber(Int_t number)
                     void SetOption(const char* option)
                     void SetShape(const TGeoShape* shape)
                     void SetTransparency(Char_t transparency = 0)
             virtual void SetVisibility(Bool_t vis = kTRUE)
                     void SetVoxelFinder(const TGeoVoxelFinder* finder)
             virtual void ShowMembers(TMemberInspector& insp, char* parent)
                     void SortNodes()
             virtual void Streamer(TBuffer& b)
                     void StreamerNVirtual(TBuffer& b)
                     void UnmarkSaved()
                   Bool_t Valid() const
                     void VisibleDaughters(Bool_t vis = kTRUE)
                     void Voxelize(Option_t* option)
                 Double_t Weight(Double_t precision = 0.01, Option_t* option = "v")

Data Members

    protected:

              TObjArray* fNodes       array of nodes inside this volume
              TGeoShape* fShape       shape
             TGeoMedium* fMedium      tracking medium
      TGeoPatternFinder* fFinder      finder object for divisions
        TGeoVoxelFinder* fVoxels      finder object for bounding boxes
            TGeoManager* fGeoManager  ! pointer to TGeoManager owning this volume
                TObject* fField       ! just a hook for now
                 TString fOption      ! option - if any
                   Int_t fNumber      volume serial number in the list of volumes
                   Int_t fNtotal      total number of physical nodes

    public:

      static const TGeoVolume::EGeoVolumeTypes kVolumeDiv          
      static const TGeoVolume::EGeoVolumeTypes kVolumeOverlap      
      static const TGeoVolume::EGeoVolumeTypes kVolumeImportNodes  
      static const TGeoVolume::EGeoVolumeTypes kVolumeMulti        
      static const TGeoVolume::EGeoVolumeTypes kVoxelsXYZ          
      static const TGeoVolume::EGeoVolumeTypes kVoxelsCyl          
      static const TGeoVolume::EGeoVolumeTypes kVolumeClone        

Class Description

 dummy constructor

 default constructor

 Destructor

 How to browse a volume

 Shoot nrays with random directions from starting point (startx, starty, startz)
 in the reference frame of this volume. Track each ray until exiting geometry, then
 shoot backwards from exiting point and compare boundary crossing points.

 Overlap checking tool. Check for illegal overlaps within a limit OVLP.

 check for negative parameters in shapes.
 THIS METHOD LEAVES SOME GARBAGE NODES -> memory leak, to be fixed
   printf("---Checking daughters of volume %s\n", GetName());

 Count total number of subnodes starting from this volume, nlevels down
 option = 0 (default) - count only once per volume
 option = 1           - count every time
 option = 2           - count volumes on visible branches

 Return TRUE if volume contains nodes

 check if the visibility and attributes are the default ones

 True if this is the top volume of the geometry

 Actualize matrix of node indexed <inode>

 Add a TGeoNode to the list of nodes. This is the usual method for adding
 daughters inside the container volume.

 Add a division node to the list of nodes. The method is called by
 TGeoVolume::Divide() for creating the division nodes.

 Add a TGeoNode to the list of nodes. This is the usual method for adding
 daughters inside the container volume.

 Division a la G3. The volume will be divided along IAXIS (see shape classes), in NDIV
 slices, from START with given STEP. The division volumes will have medium number NUMED.
 If NUMED=0 they will get the medium number of the divided volume (this). If NDIV<=0,
 all range of IAXIS will be divided and the resulting number of divisions will be centered on
 IAXIS. If STEP<=0, the real STEP will be computed as the full range of IAXIS divided by NDIV.
 Options (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)

 compute the closest distance of approach from point px,py to this volume

 draw top volume according to option

 draw only this volume

 Perform an exensive sampling to find which type of voxelization is
 most efficient.

 paint volume

 print nodes

 Generate a lego plot fot the top volume, according to option.

 Draw random points in the bounding box of this volume.

 Random raytracing method.

 Draw this volume with current settings and perform raytracing in the pad.

  Save geometry having this as top volume as a C++ macro.

 Save a primitive as a C++ statement(s) on output stream "out".

 Reset SavePrimitive bits.

 Execute mouse actions on this volume.

 search a daughter inside the list of nodes

 get index number for a given daughter

--- Returns true if cylindrical voxelization is optimal.

 Provide a pointer name containing uid.

 Move perspective view focus to this volume

 make a new list of nodes and copy all nodes of other volume inside

 make a copy of this volume
    printf("   Making a copy of %s\n", GetName());

 set the shape associated with this volume

 sort nodes by decreasing volume of the bounding box. ONLY nodes comes first,
 then overlapping nodes and finally division nodes.

 Stream an object of class TGeoVolume.

 set the current options

 get the pointer to a daughter node

 get the total size in bytes for this volume

 loop all nodes marked as overlaps and find overlaping brothers

 set visibility of this volume

 Find a daughter node having VOL as volume and fill TGeoManager::fHMatrix
 with its global matrix.

 set visibility for daughters

 build the voxels for this volume

 Estimate the weight of a volume with SIGMA(M)/M better than PRECISION.
 Option can be : v - verbose (default)

Inline Functions

                      void ClearNodes()
                    Bool_t Contains(Double_t* point) const
                    Bool_t IsAssembly() const
                    Bool_t IsRunTime() const
                    Bool_t IsVolumeMulti() const
                    Bool_t IsCylVoxels() const
                    Bool_t IsXYZVoxels() const
                    Bool_t IsValid() const
                    Bool_t IsVisible() const
                    Bool_t IsVisibleDaughters() const
                    Bool_t IsAllInvisible() const
                TObjArray* GetNodes()
                     Int_t GetNdaughters() const
                     Int_t GetNtotal() const
              TGeoManager* GetGeoManager() const
             TGeoMaterial* GetMaterial() const
               TGeoMedium* GetMedium() const
                  TObject* GetField() const
        TGeoPatternFinder* GetFinder() const
          TGeoVoxelFinder* GetVoxels() const
                 TGeoNode* GetNode(Int_t i) const
                     Int_t GetNumber() const
                 Option_t* GetOption() const
                    Char_t GetTransparency() const
                TGeoShape* GetShape() const
                      void Gsord(Int_t)
                      void InspectShape() const
                      void SetCylVoxels(Bool_t flag = kTRUE)
                      void SetNodes(TObjArray* nodes)
                      void SetTransparency(Char_t transparency = 0)
                      void SetField(const TObject* field)
                      void SetInvisible()
                      void SetMedium(const TGeoMedium* medium)
                      void SetVoxelFinder(const TGeoVoxelFinder* finder)
                      void SetFinder(const TGeoPatternFinder* finder)
                      void SetNumber(Int_t number)
                      void SetNtotal(Int_t ntotal)
                      void InvisibleAll(Bool_t flag = kTRUE)
                   TClass* Class()
                   TClass* IsA() const
                      void ShowMembers(TMemberInspector& insp, char* parent)
                      void StreamerNVirtual(TBuffer& b)
                TGeoVolume TGeoVolume(const TGeoVolume&)
               TGeoVolume& operator=(const TGeoVolume&)