Node.h

Go to the documentation of this file.

// @(#)root/tmva $Id$
// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss
 
/**********************************************************************************
 * Project: TMVA - a Root-integrated toolkit for multivariate data analysis       *
 * Package: TMVA                                                                  *
 * Classes: Node                                                                  *
 *                                             *
 *                                                                                *
 * Description:                                                                   *
 *      Node for the BinarySearch or Decision Trees                               *
 *                                                                                *
 * Authors (alphabetical):                                                        *
 *      Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland              *
 *      Helge Voss      <Helge.Voss@cern.ch>     - MPI-K Heidelberg, Germany      *
 *      Kai Voss        <Kai.Voss@cern.ch>       - U. of Victoria, Canada         *
 *                                                                                *
 * Copyright (c) 2005:                                                            *
 *      CERN, Switzerland                                                         *
 *      U. of Victoria, Canada                                                    *
 *      MPI-K Heidelberg, Germany                                                 *
 *                                                                                *
 * Redistribution and use in source and binary forms, with or without             *
 * modification, are permitted according to the terms listed in LICENSE           *
 * (see tmva/doc/LICENSE)                                          *
 **********************************************************************************/
 
#ifndef ROOT_TMVA_Node
#define ROOT_TMVA_Node
 
//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Node                                                                 //
//                                                                      //
// Node base class for the BinarySearch or Decision Trees Nodes         //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
 
#include <iosfwd>
#include <string>
#include <sstream>
 
#include "Rtypes.h"
#include "TMVA/Version.h"
 
namespace TMVA {
 
   class Node;
   class Event;
   class BinaryTree;
 
   std::ostream& operator<<( std::ostream& os, const Node& node );
   std::ostream& operator<<( std::ostream& os, const Node* node );
 
   // a class used to identify a Node; (needed for recursive reading from text file)
   // (currently it is NOT UNIQUE... but could eventually made it
   // a node in the tree structure
   class Node {
 
      // output operator for a node
      friend std::ostream& operator << (std::ostream& os, const Node& node);
      // output operator with a pointer to the node (which still prints the node itself)
      friend std::ostream& operator << (std::ostream& os, const Node* node);
 
   public:
 
      // constructor of a node
      Node();
 
      // constructor of a daughter node as a daughter of 'p'
      Node( Node* p, char pos );
 
      // copy constructor
      Node( const Node &n );
 
      // destructor
      virtual ~Node();
 
      virtual Node* CreateNode() const = 0;
 
      // test event if i{ descends the tree at this node to the right
      virtual Bool_t GoesRight( const Event& ) const = 0;
      // test event if it descends the tree at this node to the left
 
      virtual Bool_t GoesLeft ( const Event& ) const = 0;
      // test event if it is equal to the event that "makes the node" (just for the "search tree"
 
      // return pointer to the left/right daughter or parent node
      inline virtual Node* GetLeft  () const { return fLeft;   }
      inline virtual Node* GetRight () const { return fRight;  }
      inline virtual Node* GetParent() const { return fParent; }
 
      // set pointer to the left/right daughter or parent node
      inline virtual void SetLeft  (Node* l) { fLeft   = l;}
      inline virtual void SetRight (Node* r) { fRight  = r;}
      inline virtual void SetParent(Node* p) { fParent = p;}
 
      //recursively go through the part of the tree below this node and count all daughters
      Int_t  CountMeAndAllDaughters() const;
 
      // printout of the node
      virtual void Print( std::ostream& os ) const = 0;
 
      // recursive printout of the node and it daughters
      virtual void PrintRec ( std::ostream& os ) const = 0;
 
      void* AddXMLTo(void* parent) const;
      void  ReadXML(void* node, UInt_t tmva_Version_Code = TMVA_VERSION_CODE );
      virtual void AddAttributesToNode(void* node) const = 0;
      virtual void AddContentToNode(std::stringstream& s) const = 0;
 
      // Set depth, layer of the where the node is within the tree, seen from the top (root)
      void SetDepth(UInt_t d){fDepth=d;}
 
      // Return depth, layer of the where the node is within the tree, seen from the top (root)
      UInt_t GetDepth() const {return fDepth;}
 
      // set node position, i.e, the node is a left (l) or right (r) daughter
      void SetPos(char s) {fPos=s;}
 
      // Return the node position, i.e, the node is a left (l) or right (r) daughter
      char GetPos() const {return fPos;}
 
      // Return the pointer to the Parent tree to which the Node belongs
      virtual TMVA::BinaryTree* GetParentTree() const {return fParentTree;}
 
      // set the pointer to the Parent Tree to which the Node belongs
      virtual void SetParentTree(TMVA::BinaryTree* t) {fParentTree = t;}
 
      int GetCount();
 
      virtual Bool_t ReadDataRecord( std::istream&, UInt_t tmva_Version_Code = TMVA_VERSION_CODE ) = 0;
      virtual void ReadAttributes(void* node, UInt_t tmva_Version_Code = TMVA_VERSION_CODE  ) = 0;
      virtual void ReadContent(std::stringstream& s) =0;
 
   protected:
 
      Node*   fParent;              ///< the previous (parent) node
      Node*   fLeft;                ///< pointers to the two "daughter" nodes
      Node*   fRight;               ///< pointers to the two "daughter" nodes
 
      char    fPos;                 ///< position, i.e. it is a left (l) or right (r) daughter
      UInt_t  fDepth;               ///< depth of the node within the tree (seen from root node)
 
      BinaryTree*  fParentTree;     ///< pointer to the parent tree to which the Node belongs
   private:
 
      static Int_t fgCount;         ///< counter of all nodes present.. for debug.. to spot memory leaks...
 
   public:
      ClassDef(Node,0); // Node for the BinarySearch or Decision Trees
   };
 
} // namespace TMVA
 
#endif