// @(#)root/geom:$Id$
// Author: Andrei Gheata   30/05/02

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
// Author :                  date : Wed 24 Oct 2001 01:39:36 PM CEST

#ifndef ROOT_TGeoVolume
#define ROOT_TGeoVolume


#ifndef ROOT_TGeoAtt
#include "TGeoAtt.h"
#endif

#ifndef ROOT_TAttLine
#include "TAttLine.h"
#endif

#ifndef ROOT_TAttFill
#include "TAttFill.h"
#endif

#ifndef ROOT_TAtt3D
#include "TAtt3D.h"
#endif

#ifndef ROOT_TObjArray
#include "TObjArray.h"
#endif

#ifndef ROOT_TGeoMedium
#include "TGeoMedium.h"
#endif

#ifndef ROOT_TGeoShape
#include "TGeoShape.h"
#endif

// forward declarations
class TH2F;
class TGeoNode;
class TGeoMatrix;
class TGeoPatternFinder;
class TGeoVoxelFinder;
class TGeoManager;
class TGeoExtension;

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TGeoVolume - base class representing a single volume having a shape    //
//   and a medium.                                                        //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

class TGeoVolume : public TNamed,
                   public TGeoAtt,
                   public TAttLine,
                   public TAttFill,
                   public TAtt3D
{
protected :
   TObjArray         *fNodes;          // array of nodes inside this volume
   TGeoShape         *fShape;          // shape
   TGeoMedium        *fMedium;         // tracking medium
   static TGeoMedium *fgDummyMedium;   //! dummy 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
   Int_t              fRefCount;       // reference counter
   TGeoExtension     *fUserExtension;  //! Transient user-defined extension to volumes
   TGeoExtension     *fFWExtension;    //! Transient framework-defined extension to volumes

   TGeoVolume(const TGeoVolume&);
   TGeoVolume& operator=(const TGeoVolume&);

public:
   virtual void  ClearThreadData() const;
   virtual void  CreateThreadData(Int_t nthreads);

public:
   enum EGeoVolumeTypes {
      kVolumeReplicated =  BIT(14),
      kVolumeSelected =    BIT(15),
      kVolumeDiv     =     BIT(16),
      kVolumeOverlap =     BIT(17),
      kVolumeImportNodes = BIT(18),
      kVolumeMulti   =     BIT(19),
      kVoxelsXYZ     =     BIT(20), // not used
      kVoxelsCyl     =     BIT(21), // not used
      kVolumeClone   =     BIT(22),
      kVolumeAdded   =     BIT(23),
      kVolumeOC      =     BIT(21)  // overlapping candidates
   };
   // constructors
   TGeoVolume();
   TGeoVolume(const char *name, const TGeoShape *shape, const TGeoMedium *med=0);

   // destructor
   virtual ~TGeoVolume();
   // methods
   virtual void    cd(Int_t inode) const;
   void            Browse(TBrowser *b);
   Double_t        Capacity() const;
   void            CheckShapes();
   void            ClearNodes() {fNodes = 0;}
   void            ClearShape();
   void            CleanAll();
   virtual TGeoVolume *CloneVolume() const;
   void            CloneNodesAndConnect(TGeoVolume *newmother) 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; // *MENU*
   void            CheckShape(Int_t testNo, Int_t nsamples=10000, Option_t *option=""); // *MENU*
   Int_t           CountNodes(Int_t nlevels=1000, Int_t option=0);
   Bool_t          Contains(const Double_t *point) const {return fShape->Contains(point);}
   static void     CreateDummyMedium();
   static TGeoMedium *DummyMedium();
   virtual Bool_t  IsAssembly() const;
   virtual Bool_t  IsFolder() const;
   Bool_t          IsRunTime() const {return fShape->IsRunTimeShape();}
   virtual Bool_t  IsVolumeMulti() const {return kFALSE;}
   virtual void    AddNode(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat=0, Option_t *option="");       // most general case
   void            AddNodeOffset(TGeoVolume *vol, Int_t copy_no, Double_t offset=0, Option_t *option="");
   virtual void    AddNodeOverlap(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat=0, Option_t *option="");

   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 Int_t   DistancetoPrimitive(Int_t px, Int_t py);
   virtual void    Draw(Option_t *option=""); // *MENU*
   virtual void    DrawOnly(Option_t *option=""); // *MENU*
   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=""); // *MENU*
   virtual void    Paint(Option_t *option="");
   virtual void    Print(Option_t *option="") const; // *MENU*
   void            PrintNodes() const;
   void            PrintVoxels() const; // *MENU*
   void            ReplayCreation(const TGeoVolume *other);
   void            SetUserExtension(TGeoExtension *ext);
   void            SetFWExtension(TGeoExtension *ext);
   Int_t           GetRefCount() const      {return fRefCount;}
   TGeoExtension  *GetUserExtension() const {return fUserExtension;}
   TGeoExtension  *GetFWExtension() const   {return fFWExtension;}
   TGeoExtension  *GrabUserExtension() const;
   TGeoExtension  *GrabFWExtension() const;
   void            Grab()                   {fRefCount++;}
   void            Release()                {fRefCount--; if (fRefCount==0) delete this;}
   virtual void    ExecuteEvent(Int_t event, Int_t px, Int_t py);

   Bool_t          IsActive() const {return TGeoAtt::IsActive();}
   Bool_t          IsActiveDaughters() const {return TGeoAtt::IsActiveDaughters();}
   Bool_t          IsAdded()     const {return TObject::TestBit(kVolumeAdded);}
   Bool_t          IsOverlappingCandidate() const {return TObject::TestBit(kVolumeOC);}
   Bool_t          IsReplicated() const {return TObject::TestBit(kVolumeReplicated);}
   Bool_t          IsSelected() const  {return TObject::TestBit(kVolumeSelected);}
   Bool_t          IsCylVoxels() const {return TObject::TestBit(kVoxelsCyl);}
   Bool_t          IsXYZVoxels() const {return TObject::TestBit(kVoxelsXYZ);}
   Bool_t          IsTopVolume() const;
   Bool_t          IsValid() const {return fShape->IsValid();}
   virtual Bool_t  IsVisible() const {return TGeoAtt::IsVisible();}
   Bool_t          IsVisibleDaughters() const {return TGeoAtt::IsVisDaughters();}
   Bool_t          IsVisContainers() const {return TGeoAtt::IsVisContainers();}
   Bool_t          IsVisLeaves() const {return TGeoAtt::IsVisLeaves();}
   Bool_t          IsVisOnly() const {return TGeoAtt::IsVisOnly();}
   Bool_t          IsAllInvisible() const;
   Bool_t          IsRaytracing() const;
   static TGeoVolume *Import(const char *filename, const char *name="", Option_t *option="");
   Int_t           Export(const char *filename, const char *name="", Option_t *option="");
   TGeoNode       *FindNode(const char *name) const;
   void            FindOverlaps() const;
   Bool_t          FindMatrixOfDaughterVolume(TGeoVolume *vol) const;
   virtual Int_t   GetCurrentNodeIndex() const {return -1;}
   virtual Int_t   GetNextNodeIndex() const {return -1;}
   TObjArray      *GetNodes() {return fNodes;}
   Int_t           GetNdaughters() const;
   Int_t           GetNtotal() const {return fNtotal;}
   virtual Int_t   GetByteCount() const;
   TGeoManager    *GetGeoManager() const {return fGeoManager;}
   TGeoMaterial   *GetMaterial() const               {return GetMedium()->GetMaterial();}
   TGeoMedium     *GetMedium() const                 {return (fMedium)?fMedium:DummyMedium();}
   TObject        *GetField() const                  {return fField;}
   TGeoPatternFinder *GetFinder() const              {return fFinder;}
   TGeoVoxelFinder   *GetVoxels() const;
   const char     *GetIconName() const               {return fShape->GetName();}
   Int_t           GetIndex(const TGeoNode *node) const;
   TGeoNode       *GetNode(const char *name) const;
   TGeoNode       *GetNode(Int_t i) const {return (TGeoNode*)fNodes->UncheckedAt(i);}
   Int_t           GetNodeIndex(const TGeoNode *node, Int_t *check_list, Int_t ncheck) const;
   Int_t           GetNumber() const {return fNumber;}
   virtual char   *GetObjectInfo(Int_t px, Int_t py) const;
   Bool_t          GetOptimalVoxels() const;
   Option_t       *GetOption() const { return fOption.Data(); }
   char           *GetPointerName() const;
   Char_t          GetTransparency() const {return (fMedium==0)?0:(fMedium->GetMaterial()->GetTransparency());}
   TGeoShape      *GetShape() const                  {return fShape;}
   void            GrabFocus(); // *MENU*
   void            Gsord(Int_t /*iaxis*/)                {;}
   Bool_t          IsStyleDefault() const;
   void            InspectMaterial() const; // *MENU*
   void            InspectShape() const {fShape->InspectShape();} // *MENU*
   virtual TGeoVolume *MakeCopyVolume(TGeoShape *newshape);
   void            MakeCopyNodes(const TGeoVolume *other);
   TGeoVolume     *MakeReflectedVolume(const char *newname="") const;
   Bool_t          OptimizeVoxels(); // *MENU*
   void            RandomPoints(Int_t npoints=1000000, Option_t *option=""); // *MENU*
   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*
   void            Raytrace(Bool_t flag=kTRUE); // *TOGGLE* *GETTER=IsRaytracing
   void            RegisterYourself(Option_t *option="");
   void            RemoveNode(TGeoNode *node);
   TGeoNode       *ReplaceNode(TGeoNode *nodeorig, TGeoShape *newshape=0, TGeoMatrix *newpos=0, TGeoMedium *newmed=0);
   void            SaveAs(const char *filename,Option_t *option="") const; // *MENU*
   virtual void    SavePrimitive(std::ostream &out, Option_t *option = "");
   void            SelectVolume(Bool_t clear = kFALSE);
   void            SetActivity(Bool_t flag=kTRUE) {TGeoAtt::SetActivity(flag);}
   void            SetActiveDaughters(Bool_t flag=kTRUE) {TGeoAtt::SetActiveDaughters(flag);}
   void            SetAsTopVolume(); // *TOGGLE* *GETTER=IsTopVolume
   void            SetAdded()      {TObject::SetBit(kVolumeAdded);}
   void            SetReplicated() {TObject::SetBit(kVolumeReplicated);}
   void            SetCurrentPoint(Double_t x, Double_t y, Double_t z);
   void            SetCylVoxels(Bool_t flag=kTRUE) {TObject::SetBit(kVoxelsCyl, flag); TObject::SetBit(kVoxelsXYZ, !flag);}
   void            SetNodes(TObjArray *nodes) {fNodes = nodes; TObject::SetBit(kVolumeImportNodes);}
   void            SetOverlappingCandidate(Bool_t flag) {TObject::SetBit(kVolumeOC,flag);}
   void            SetShape(const TGeoShape *shape);
   void            SetTransparency(Char_t transparency=0) {if (fMedium) fMedium->GetMaterial()->SetTransparency(transparency);} // *MENU*
   void            SetField(TObject *field)          {fField = field;}
   void            SetOption(const char *option);
   void            SetAttVisibility(Bool_t vis) {TGeoAtt::SetVisibility(vis);}
   virtual void    SetVisibility(Bool_t vis=kTRUE); // *TOGGLE* *GETTER=IsVisible
   virtual void    SetVisContainers(Bool_t flag=kTRUE); // *TOGGLE* *GETTER=IsVisContainers
   virtual void    SetVisLeaves(Bool_t flag=kTRUE); // *TOGGLE* *GETTER=IsVisLeaves
   virtual void    SetVisOnly(Bool_t flag=kTRUE); // *TOGGLE* *GETTER=IsVisOnly
   virtual void    SetLineColor(Color_t lcolor);
   virtual void    SetLineStyle(Style_t lstyle);
   virtual void    SetLineWidth(Width_t lwidth);
   void            SetInvisible() {SetVisibility(kFALSE);}
   virtual void    SetMedium(TGeoMedium *medium) {fMedium = medium;}
   void            SetVoxelFinder(TGeoVoxelFinder *finder) {fVoxels = finder;}
   void            SetFinder(TGeoPatternFinder *finder) {fFinder = finder;}
   void            SetNumber(Int_t number) {fNumber = number;}
   void            SetNtotal(Int_t ntotal) {fNtotal = ntotal;}
   void            SortNodes();
   void            UnmarkSaved();
   Bool_t          Valid() const;
   void            VisibleDaughters(Bool_t vis=kTRUE); // *TOGGLE* *GETTER=IsVisibleDaughters
   void            InvisibleAll(Bool_t flag=kTRUE); // *TOGGLE* *GETTER=IsAllInvisible
   void            Voxelize(Option_t *option);
   Double_t        Weight(Double_t precision=0.01, Option_t *option="va"); // *MENU*
   Double_t        WeightA() const;

   ClassDef(TGeoVolume, 6)              // geometry volume descriptor
};

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TGeoVolumeMulti - class storing a list of volumes that have to         //
//   be handled togeather at build time                                   //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

class TGeoVolumeMulti : public TGeoVolume
{
private:
   TObjArray       *fVolumes;      // list of volumes
   TGeoVolumeMulti *fDivision;     // division of this volume
   Int_t            fNumed;        // medium number for divisions
   Int_t            fNdiv;         // number of divisions
   Int_t            fAxis;         // axis of division
   Double_t         fStart;        // division start offset
   Double_t         fStep;         // division step
   Bool_t           fAttSet;       // flag attributes set

protected:
   TGeoVolumeMulti(const TGeoVolumeMulti&);
   TGeoVolumeMulti& operator=(const TGeoVolumeMulti&);

public:
   TGeoVolumeMulti();
   TGeoVolumeMulti(const char* name, TGeoMedium *med=0);
   virtual ~TGeoVolumeMulti();

   void            AddVolume(TGeoVolume *vol);
   TGeoVolume     *GetVolume(Int_t id) const {return (TGeoVolume*)fVolumes->At(id);}
   virtual void    AddNode(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat, Option_t *option="");       // most general case
   virtual void    AddNodeOverlap(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat, Option_t *option="");
   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="");
   TGeoShape      *GetLastShape() const;
   Int_t           GetNvolumes() const {return fVolumes->GetEntriesFast();}
   Int_t           GetAxis() const {return fNdiv;}
   Int_t           GetNdiv() const {return fNdiv;}
   Double_t        GetStart() const {return fStart;}
   Double_t        GetStep() const {return fStep;}
   virtual Bool_t  IsVolumeMulti() const {return kTRUE;}
   virtual TGeoVolume *MakeCopyVolume(TGeoShape *newshape);
   virtual void    SetLineColor(Color_t lcolor);
   virtual void    SetLineStyle(Style_t lstyle);
   virtual void    SetLineWidth(Width_t lwidth);
   virtual void    SetMedium(TGeoMedium *medium);
   virtual void    SetVisibility(Bool_t vis=kTRUE);


   ClassDef(TGeoVolumeMulti, 3)     // class to handle multiple volumes in one step
};

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TGeoVolumeAssembly - special assembly of volumes. The assembly has no  //
//   medium and its shape is the union of all component shapes            //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

class TGeoVolumeAssembly : public TGeoVolume
{
public:
   struct ThreadData_t
   {
      Int_t           fCurrent;           //! index of current selected node
      Int_t           fNext;              //! index of next node to be entered

      ThreadData_t();
      ~ThreadData_t();
   };

   ThreadData_t& GetThreadData()   const;
   virtual void  ClearThreadData() const;
   virtual void  CreateThreadData(Int_t nthreads);

protected:
   mutable std::vector<ThreadData_t*> fThreadData; //! Thread specific data vector
   mutable Int_t                      fThreadSize; //! Thread vector size

public:
   TGeoVolumeAssembly();
   TGeoVolumeAssembly(const char *name);
   virtual ~TGeoVolumeAssembly();

   virtual void    AddNode(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat=0, Option_t *option="");
   virtual void    AddNodeOverlap(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat, Option_t *option);
   virtual TGeoVolume *CloneVolume() const;
   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="");
   TGeoVolume     *Divide(TGeoVolume *cell, TGeoPatternFinder *pattern, Option_t *option="spacedout");
   virtual void    DrawOnly(Option_t *) {;}
   virtual Int_t   GetCurrentNodeIndex() const;
   virtual Int_t   GetNextNodeIndex() const;
   virtual Bool_t  IsAssembly() const {return kTRUE;}
   virtual Bool_t  IsVisible() const {return kFALSE;}
   static TGeoVolumeAssembly *MakeAssemblyFromVolume(TGeoVolume *vol);
   void            SetCurrentNodeIndex(Int_t index);
   void            SetNextNodeIndex(Int_t index);

   ClassDef(TGeoVolumeAssembly, 2)   // an assembly of volumes
};

inline Int_t TGeoVolume::GetNdaughters() const {if (!fNodes) return 0; return (fNodes->GetEntriesFast());}

#endif

 TGeoVolume.h:1
 TGeoVolume.h:2
 TGeoVolume.h:3
 TGeoVolume.h:4
 TGeoVolume.h:5
 TGeoVolume.h:6
 TGeoVolume.h:7
 TGeoVolume.h:8
 TGeoVolume.h:9
 TGeoVolume.h:10
 TGeoVolume.h:11
 TGeoVolume.h:12
 TGeoVolume.h:13
 TGeoVolume.h:14
 TGeoVolume.h:15
 TGeoVolume.h:16
 TGeoVolume.h:17
 TGeoVolume.h:18
 TGeoVolume.h:19
 TGeoVolume.h:20
 TGeoVolume.h:21
 TGeoVolume.h:22
 TGeoVolume.h:23
 TGeoVolume.h:24
 TGeoVolume.h:25
 TGeoVolume.h:26
 TGeoVolume.h:27
 TGeoVolume.h:28
 TGeoVolume.h:29
 TGeoVolume.h:30
 TGeoVolume.h:31
 TGeoVolume.h:32
 TGeoVolume.h:33
 TGeoVolume.h:34
 TGeoVolume.h:35
 TGeoVolume.h:36
 TGeoVolume.h:37
 TGeoVolume.h:38
 TGeoVolume.h:39
 TGeoVolume.h:40
 TGeoVolume.h:41
 TGeoVolume.h:42
 TGeoVolume.h:43
 TGeoVolume.h:44
 TGeoVolume.h:45
 TGeoVolume.h:46
 TGeoVolume.h:47
 TGeoVolume.h:48
 TGeoVolume.h:49
 TGeoVolume.h:50
 TGeoVolume.h:51
 TGeoVolume.h:52
 TGeoVolume.h:53
 TGeoVolume.h:54
 TGeoVolume.h:55
 TGeoVolume.h:56
 TGeoVolume.h:57
 TGeoVolume.h:58
 TGeoVolume.h:59
 TGeoVolume.h:60
 TGeoVolume.h:61
 TGeoVolume.h:62
 TGeoVolume.h:63
 TGeoVolume.h:64
 TGeoVolume.h:65
 TGeoVolume.h:66
 TGeoVolume.h:67
 TGeoVolume.h:68
 TGeoVolume.h:69
 TGeoVolume.h:70
 TGeoVolume.h:71
 TGeoVolume.h:72
 TGeoVolume.h:73
 TGeoVolume.h:74
 TGeoVolume.h:75
 TGeoVolume.h:76
 TGeoVolume.h:77
 TGeoVolume.h:78
 TGeoVolume.h:79
 TGeoVolume.h:80
 TGeoVolume.h:81
 TGeoVolume.h:82
 TGeoVolume.h:83
 TGeoVolume.h:84
 TGeoVolume.h:85
 TGeoVolume.h:86
 TGeoVolume.h:87
 TGeoVolume.h:88
 TGeoVolume.h:89
 TGeoVolume.h:90
 TGeoVolume.h:91
 TGeoVolume.h:92
 TGeoVolume.h:93
 TGeoVolume.h:94
 TGeoVolume.h:95
 TGeoVolume.h:96
 TGeoVolume.h:97
 TGeoVolume.h:98
 TGeoVolume.h:99
 TGeoVolume.h:100
 TGeoVolume.h:101
 TGeoVolume.h:102
 TGeoVolume.h:103
 TGeoVolume.h:104
 TGeoVolume.h:105
 TGeoVolume.h:106
 TGeoVolume.h:107
 TGeoVolume.h:108
 TGeoVolume.h:109
 TGeoVolume.h:110
 TGeoVolume.h:111
 TGeoVolume.h:112
 TGeoVolume.h:113
 TGeoVolume.h:114
 TGeoVolume.h:115
 TGeoVolume.h:116
 TGeoVolume.h:117
 TGeoVolume.h:118
 TGeoVolume.h:119
 TGeoVolume.h:120
 TGeoVolume.h:121
 TGeoVolume.h:122
 TGeoVolume.h:123
 TGeoVolume.h:124
 TGeoVolume.h:125
 TGeoVolume.h:126
 TGeoVolume.h:127
 TGeoVolume.h:128
 TGeoVolume.h:129
 TGeoVolume.h:130
 TGeoVolume.h:131
 TGeoVolume.h:132
 TGeoVolume.h:133
 TGeoVolume.h:134
 TGeoVolume.h:135
 TGeoVolume.h:136
 TGeoVolume.h:137
 TGeoVolume.h:138
 TGeoVolume.h:139
 TGeoVolume.h:140
 TGeoVolume.h:141
 TGeoVolume.h:142
 TGeoVolume.h:143
 TGeoVolume.h:144
 TGeoVolume.h:145
 TGeoVolume.h:146
 TGeoVolume.h:147
 TGeoVolume.h:148
 TGeoVolume.h:149
 TGeoVolume.h:150
 TGeoVolume.h:151
 TGeoVolume.h:152
 TGeoVolume.h:153
 TGeoVolume.h:154
 TGeoVolume.h:155
 TGeoVolume.h:156
 TGeoVolume.h:157
 TGeoVolume.h:158
 TGeoVolume.h:159
 TGeoVolume.h:160
 TGeoVolume.h:161
 TGeoVolume.h:162
 TGeoVolume.h:163
 TGeoVolume.h:164
 TGeoVolume.h:165
 TGeoVolume.h:166
 TGeoVolume.h:167
 TGeoVolume.h:168
 TGeoVolume.h:169
 TGeoVolume.h:170
 TGeoVolume.h:171
 TGeoVolume.h:172
 TGeoVolume.h:173
 TGeoVolume.h:174
 TGeoVolume.h:175
 TGeoVolume.h:176
 TGeoVolume.h:177
 TGeoVolume.h:178
 TGeoVolume.h:179
 TGeoVolume.h:180
 TGeoVolume.h:181
 TGeoVolume.h:182
 TGeoVolume.h:183
 TGeoVolume.h:184
 TGeoVolume.h:185
 TGeoVolume.h:186
 TGeoVolume.h:187
 TGeoVolume.h:188
 TGeoVolume.h:189
 TGeoVolume.h:190
 TGeoVolume.h:191
 TGeoVolume.h:192
 TGeoVolume.h:193
 TGeoVolume.h:194
 TGeoVolume.h:195
 TGeoVolume.h:196
 TGeoVolume.h:197
 TGeoVolume.h:198
 TGeoVolume.h:199
 TGeoVolume.h:200
 TGeoVolume.h:201
 TGeoVolume.h:202
 TGeoVolume.h:203
 TGeoVolume.h:204
 TGeoVolume.h:205
 TGeoVolume.h:206
 TGeoVolume.h:207
 TGeoVolume.h:208
 TGeoVolume.h:209
 TGeoVolume.h:210
 TGeoVolume.h:211
 TGeoVolume.h:212
 TGeoVolume.h:213
 TGeoVolume.h:214
 TGeoVolume.h:215
 TGeoVolume.h:216
 TGeoVolume.h:217
 TGeoVolume.h:218
 TGeoVolume.h:219
 TGeoVolume.h:220
 TGeoVolume.h:221
 TGeoVolume.h:222
 TGeoVolume.h:223
 TGeoVolume.h:224
 TGeoVolume.h:225
 TGeoVolume.h:226
 TGeoVolume.h:227
 TGeoVolume.h:228
 TGeoVolume.h:229
 TGeoVolume.h:230
 TGeoVolume.h:231
 TGeoVolume.h:232
 TGeoVolume.h:233
 TGeoVolume.h:234
 TGeoVolume.h:235
 TGeoVolume.h:236
 TGeoVolume.h:237
 TGeoVolume.h:238
 TGeoVolume.h:239
 TGeoVolume.h:240
 TGeoVolume.h:241
 TGeoVolume.h:242
 TGeoVolume.h:243
 TGeoVolume.h:244
 TGeoVolume.h:245
 TGeoVolume.h:246
 TGeoVolume.h:247
 TGeoVolume.h:248
 TGeoVolume.h:249
 TGeoVolume.h:250
 TGeoVolume.h:251
 TGeoVolume.h:252
 TGeoVolume.h:253
 TGeoVolume.h:254
 TGeoVolume.h:255
 TGeoVolume.h:256
 TGeoVolume.h:257
 TGeoVolume.h:258
 TGeoVolume.h:259
 TGeoVolume.h:260
 TGeoVolume.h:261
 TGeoVolume.h:262
 TGeoVolume.h:263
 TGeoVolume.h:264
 TGeoVolume.h:265
 TGeoVolume.h:266
 TGeoVolume.h:267
 TGeoVolume.h:268
 TGeoVolume.h:269
 TGeoVolume.h:270
 TGeoVolume.h:271
 TGeoVolume.h:272
 TGeoVolume.h:273
 TGeoVolume.h:274
 TGeoVolume.h:275
 TGeoVolume.h:276
 TGeoVolume.h:277
 TGeoVolume.h:278
 TGeoVolume.h:279
 TGeoVolume.h:280
 TGeoVolume.h:281
 TGeoVolume.h:282
 TGeoVolume.h:283
 TGeoVolume.h:284
 TGeoVolume.h:285
 TGeoVolume.h:286
 TGeoVolume.h:287
 TGeoVolume.h:288
 TGeoVolume.h:289
 TGeoVolume.h:290
 TGeoVolume.h:291
 TGeoVolume.h:292
 TGeoVolume.h:293
 TGeoVolume.h:294
 TGeoVolume.h:295
 TGeoVolume.h:296
 TGeoVolume.h:297
 TGeoVolume.h:298
 TGeoVolume.h:299
 TGeoVolume.h:300
 TGeoVolume.h:301
 TGeoVolume.h:302
 TGeoVolume.h:303
 TGeoVolume.h:304
 TGeoVolume.h:305
 TGeoVolume.h:306
 TGeoVolume.h:307
 TGeoVolume.h:308
 TGeoVolume.h:309
 TGeoVolume.h:310
 TGeoVolume.h:311
 TGeoVolume.h:312
 TGeoVolume.h:313
 TGeoVolume.h:314
 TGeoVolume.h:315
 TGeoVolume.h:316
 TGeoVolume.h:317
 TGeoVolume.h:318
 TGeoVolume.h:319
 TGeoVolume.h:320
 TGeoVolume.h:321
 TGeoVolume.h:322
 TGeoVolume.h:323
 TGeoVolume.h:324
 TGeoVolume.h:325
 TGeoVolume.h:326
 TGeoVolume.h:327
 TGeoVolume.h:328
 TGeoVolume.h:329
 TGeoVolume.h:330
 TGeoVolume.h:331
 TGeoVolume.h:332
 TGeoVolume.h:333
 TGeoVolume.h:334
 TGeoVolume.h:335
 TGeoVolume.h:336
 TGeoVolume.h:337
 TGeoVolume.h:338
 TGeoVolume.h:339
 TGeoVolume.h:340
 TGeoVolume.h:341
 TGeoVolume.h:342
 TGeoVolume.h:343
 TGeoVolume.h:344
 TGeoVolume.h:345
 TGeoVolume.h:346
 TGeoVolume.h:347
 TGeoVolume.h:348
 TGeoVolume.h:349
 TGeoVolume.h:350
 TGeoVolume.h:351
 TGeoVolume.h:352
 TGeoVolume.h:353
 TGeoVolume.h:354
 TGeoVolume.h:355
 TGeoVolume.h:356
 TGeoVolume.h:357
 TGeoVolume.h:358
 TGeoVolume.h:359
 TGeoVolume.h:360
 TGeoVolume.h:361
 TGeoVolume.h:362
 TGeoVolume.h:363
 TGeoVolume.h:364
 TGeoVolume.h:365