TGeoNode

class TGeoNode : public TNamed, public TGeoAtt

    public:

                         virtual ~TGeoNode()
                    virtual void Browse(TBrowser* b)
                    virtual void cd() const
                            void CheckShapes()
                  static TClass* Class()
                    virtual void Draw(Option_t* option)
                            void DrawOnly(Option_t* option)
                            void DrawOverlaps()
                            void FillIdArray(Int_t& ifree, Int_t& nodeid, Int_t* array) const
                           Int_t FindNode(const TGeoNode* node, Int_t level)
                   virtual Int_t GetByteCount() const
                           Int_t GetColour() const
                       TGeoNode* GetDaughter(Int_t ind) const
      virtual TGeoPatternFinder* GetFinder() const
                   virtual Int_t GetIndex() const
             virtual TGeoMatrix* GetMatrix() const
                     TGeoMedium* GetMedium() const
                     TGeoVolume* GetMotherVolume() const
                           Int_t GetNdaughters() const
                      TObjArray* GetNodes() const
                           Int_t GetNumber() const
                   virtual Int_t GetOptimalVoxels() const
                          Int_t* GetOverlaps(Int_t& novlp) const
                     TGeoVolume* GetVolume() const
                            void InspectNode() const
                 virtual TClass* IsA() const
                  virtual Bool_t IsFolder() const
                          Bool_t IsOffset() const
                          Bool_t IsOnScreen() const
                          Bool_t IsOverlapping() const
                          Bool_t IsVirtual() const
                          Bool_t IsVisDaughters() const
                          Bool_t IsVisible() const
                    virtual void LocalToMaster(const Double_t* local, Double_t* master) const
                    virtual void LocalToMasterVect(const Double_t* local, Double_t* master) const
                    virtual void ls(Option_t* option) const
               virtual TGeoNode* MakeCopyNode() const
                    virtual void MasterToLocal(const Double_t* master, Double_t* local) const
                    virtual void MasterToLocalVect(const Double_t* master, Double_t* local) const
                       TGeoNode& operator=(const TGeoNode&)
                    virtual void Paint(Option_t* option)
                            void PrintCandidates() const
                            void PrintOverlaps() const
                        Double_t Safety(Double_t* point, Bool_t in = kTRUE) const
                            void SaveAttributes(ofstream& out)
                            void SetAllInvisible()
                            void SetCurrentPoint(Double_t x, Double_t y, Double_t z)
                            void SetInvisible()
                            void SetMotherVolume(const TGeoVolume* mother)
                            void SetNumber(Int_t number)
                            void SetOverlapping()
                            void SetOverlaps(Int_t* ovlp, Int_t novlp)
                            void SetVirtual()
                    virtual void SetVisibility(Bool_t vis = kTRUE)
                            void SetVolume(const TGeoVolume* volume)
                    virtual void ShowMembers(TMemberInspector& insp, char* parent)
                    virtual void Streamer(TBuffer& b)
                            void StreamerNVirtual(TBuffer& b)
                            void VisibleDaughters(Bool_t vis = kTRUE)

Data Members

    protected:

      TGeoVolume* fVolume    volume associated with this
      TGeoVolume* fMother    mother volume
            Int_t fNumber    copy number
            Int_t fNovlp     number of overlaps
           Int_t* fOverlaps  [fNovlp] list of indices for overlapping brothers

    public:

      static const enum TGeoNode:: kGeoNodeMatrix   
      static const enum TGeoNode:: kGeoNodeOffset   
      static const enum TGeoNode:: kGeoNodeVC       
      static const enum TGeoNode:: kGeoNodeOverlap  

Class Description

 TGeoNode
_________
   A node represent a volume positioned inside another.They store links to both
 volumes and to the TGeoMatrix representing the relative positioning. Node are
 never instanciated directly by users, but created as a result of volume operations.
 Adding a volume named A with a given user ID inside a volume B will create a node
 node named A_ID. This will be added to the list of nodes stored by B. Also,
 when applying a division operation in N slices to a volume A, a list of nodes
 B_1, B_2, ..., B_N is also created. A node B_i does not represent a unique
 object in the geometry because its container A might be at its turn positioned
 as node inside several other volumes. Only when a complete branch of nodes
 is fully defined up to the top node in the geometry, a given path like:
       /TOP_1/.../A_3/B_7 will represent an unique object. Its global transformation
 matrix can be computed as the pile-up of all local transformations in its
 branch. We will therefore call "logical graph" the hierarchy defined by nodes
 and volumes. The expansion of the logical graph by all possible paths defines
 a tree sructure where all nodes are unique "touchable" objects. We will call
 this the "physical tree". Unlike the logical graph, the physical tree can
 become a huge structure with several milions of nodes in case of complex
 geometries, therefore it is not always a good idea to keep it transient
 in memory. Since a the logical and physical structures are correlated, the
 modeller rather keeps track only of the current branch, updating the current
 global matrix at each change of the level in geometry. The current physical node
 is not an object that can be asked for at a given moment, but rather represented
 by the combination: current node + current global matrix. However, physical nodes
 have unique ID's that can be retreived for a given modeler state. These can be
 fed back to the modeler in order to force a physical node to become current.
 The advantage of this comes from the fact that all navigation queries check
 first the current node, therefore knowing the location of a point in the
 geometry can be saved as a starting state for later use.

   Nodes can be declared as "overlapping" in case they do overlap with other
 nodes inside the same container or extrude this container. Non-overlapping
 nodes can be created with:

      TGeoVolume::AddNode(TGeoVolume *daughter, Int_t copy_No, TGeoMatrix *matr);

 The creation of overapping nodes can be done with a similar prototype:

      TGeoVolume::AddNodeOverlap(same arguments);

 When closing the geometry, overlapping nodes perform a check of possible
 overlaps with their neighbours. These are stored and checked all the time
 during navigation, therefore navigation is slower when embedding such nodes
 into geometry.

   Node have visualization attributes as volume have. When undefined by users,
 painting a node on a pad will take the corresponding volume attributes.

 Destructor

 check if this node is drawn. Assumes that this node is current

 check for wrong parameters in shapes

 draw only this node independently of its vis options

 draw current node according to option

 Fill array with node id. Recursive on node branch.

 save attributes for this node

 Convert the point coordinates from mother reference to local reference system

 Convert a vector from mother reference to local reference system

 Convert the point coordinates from local reference system to mother reference

 Convert a vector from local reference system to mother reference

 Print the path (A/B/C/...) to this node on stdout

 Paint this node and its content according to visualization settings.

 print daughters candidates for containing current point
   cd();

 print possible overlapping nodes

 computes the closest distance from given point to this shape

 set the list of overlaps for this node (ovlp must be created with operator new)

Inline Functions

                      void cd() const
                     Int_t GetByteCount() const
                 TGeoNode* GetDaughter(Int_t ind) const
               TGeoMatrix* GetMatrix() const
                     Int_t GetColour() const
                     Int_t GetIndex() const
        TGeoPatternFinder* GetFinder() const
               TGeoMedium* GetMedium() const
               TGeoVolume* GetMotherVolume() const
                     Int_t GetNdaughters() const
                TObjArray* GetNodes() const
                     Int_t GetNumber() const
                    Int_t* GetOverlaps(Int_t& novlp) const
               TGeoVolume* GetVolume() const
                     Int_t GetOptimalVoxels() const
                    Bool_t IsFolder() const
                    Bool_t IsOffset() const
                    Bool_t IsOverlapping() const
                    Bool_t IsVirtual() const
                    Bool_t IsVisible() const
                    Bool_t IsVisDaughters() const
                 TGeoNode* MakeCopyNode() const
                      void SetCurrentPoint(Double_t x, Double_t y, Double_t z)
                      void SetVolume(const TGeoVolume* volume)
                      void SetNumber(Int_t number)
                      void SetOverlapping()
                      void SetVirtual()
                      void SetInvisible()
                      void SetAllInvisible()
                      void SetMotherVolume(const TGeoVolume* mother)
                   TClass* Class()
                   TClass* IsA() const
                      void ShowMembers(TMemberInspector& insp, char* parent)
                      void Streamer(TBuffer& b)
                      void StreamerNVirtual(TBuffer& b)
                 TGeoNode& operator=(const TGeoNode&)