BinaryTree.cxx

Go to the documentation of this file.

// @(#)root/tmva $Id$
// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss, Eckhard von Toerne

/**********************************************************************************
 * Project: TMVA - a Root-integrated toolkit for multivariate data analysis       *
 * Package: TMVA                                                                  *
 * Class  : TMVA::BinaryTree                                                      *
 * Web    : http://tmva.sourceforge.net                                           *
 *                                                                                *
 * Description:                                                                   *
 *      Implementation (see header file for description)                          *
 *                                                                                *
 * Authors (alphabetical):                                                        *
 *      Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland              *
 *      Joerg Stelzer   <stelzer@cern.ch>        - DESY, Germany                  *
 *      Helge Voss      <Helge.Voss@cern.ch>     - MPI-K Heidelberg, Germany      *
 *      Kai Voss        <Kai.Voss@cern.ch>       - U. of Victoria, Canada         *
 *      Eckhard v. Toerne  <evt@uni-bonn.de>          - U of Bonn, Germany        *
 *                                                                                *
 * Copyright (c) 2005-2011:                                                       *
 *      CERN, Switzerland                                                         *
 *      U. of Victoria, Canada                                                    *
 *      MPI-K Heidelberg, Germany                                                 *
 *      U. of Bonn, Germany                                                       *
 *                                                                                *
 * Redistribution and use in source and binary forms, with or without             *
 * modification, are permitted according to the terms listed in LICENSE           *
 * (http://tmva.sourceforge.net/LICENSE)                                          *
 **********************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// BinaryTree                                                           //
//                                                                      //
// Base class for BinarySearch and Decision Trees                       //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include <string>
#include <stdexcept>

#include "TMVA/BinaryTree.h"
#include "TMVA/MsgLogger.h"
#include "TMVA/Event.h"
#include "TMVA/Node.h"
#include "TMVA/Tools.h"
#include "TMVA/Types.h"

ClassImp(TMVA::BinaryTree)

////////////////////////////////////////////////////////////////////////////////
/// constructor for a yet "empty" tree. Needs to be filled afterwards

TMVA::BinaryTree::BinaryTree( void )
   : fRoot  ( NULL ),
     fNNodes( 0 ),
     fDepth ( 0 )
{
}

////////////////////////////////////////////////////////////////////////////////
///destructor (deletes the nodes and "events" if owned by the tree

TMVA::BinaryTree::~BinaryTree( void )
{
   this->DeleteNode( fRoot );
   fRoot=0;
}

////////////////////////////////////////////////////////////////////////////////
/// protected, recursive, function used by the class destructor and when Pruning

void TMVA::BinaryTree::DeleteNode( TMVA::Node* node )
{
   if (node != NULL) { //If the node is not NULL...
      this->DeleteNode(node->GetLeft());  //Delete its left node.
      this->DeleteNode(node->GetRight()); //Delete its right node.

      delete node;                // Delete the node in memory
   }
}

////////////////////////////////////////////////////////////////////////////////
/// get left daughter node current node "n"

TMVA::Node* TMVA::BinaryTree::GetLeftDaughter( Node *n)
{
   return (Node*) n->GetLeft();
}

////////////////////////////////////////////////////////////////////////////////
/// get right daughter node current node "n"

TMVA::Node* TMVA::BinaryTree::GetRightDaughter( Node *n)
{
   return (Node*) n->GetRight();
}

////////////////////////////////////////////////////////////////////////////////
/// return the number of nodes in the tree. (make a new count --> takes time)

UInt_t TMVA::BinaryTree::CountNodes(TMVA::Node *n)
{
   if (n == NULL){ //default, start at the tree top, then descend recursively
      n = (Node*)this->GetRoot();
      if (n == NULL) return 0 ;
   }

   UInt_t countNodes=1;

   if (this->GetLeftDaughter(n) != NULL){
      countNodes += this->CountNodes( this->GetLeftDaughter(n) );
   }
   if (this->GetRightDaughter(n) != NULL) {
      countNodes += this->CountNodes( this->GetRightDaughter(n) );
   }

   return fNNodes = countNodes;
}

////////////////////////////////////////////////////////////////////////////////
/// recursively print the tree

void TMVA::BinaryTree::Print(std::ostream & os) const
{
   this->GetRoot()->PrintRec(os);
   os << "-1" << std::endl;
}

////////////////////////////////////////////////////////////////////////////////
/// add attributes to XML

void* TMVA::BinaryTree::AddXMLTo(void* parent) const {
   void* bdt = gTools().AddChild(parent, "BinaryTree");
   gTools().AddAttr( bdt, "type" , ClassName() );
   this->GetRoot()->AddXMLTo(bdt);
   return bdt;
}

////////////////////////////////////////////////////////////////////////////////
/// read attributes from XML

void TMVA::BinaryTree::ReadXML(void* node, UInt_t tmva_Version_Code ) {
   this->DeleteNode( fRoot );
   fRoot= CreateNode();

   void* trnode = gTools().GetChild(node);
   fRoot->ReadXML(trnode, tmva_Version_Code);

   this->SetTotalTreeDepth();
}


////////////////////////////////////////////////////////////////////////////////
/// print the tree recursinvely using the << operator

std::ostream& TMVA::operator<< (std::ostream& os, const TMVA::BinaryTree& tree)
{
   tree.Print(os);
   return os; // Return the output stream.
}

////////////////////////////////////////////////////////////////////////////////
/// Read the binary tree from an input stream.
/// The input stream format depends on the tree type,
/// it is defined be the node of the tree

void TMVA::BinaryTree::Read(std::istream & istr, UInt_t tmva_Version_Code )
{
   Node * currentNode = GetRoot();
   Node* parent = 0;

   if(currentNode==0) {
      currentNode=CreateNode();
      SetRoot(currentNode);
   }

   while(1) {
      if ( ! currentNode->ReadDataRecord(istr, tmva_Version_Code) ) {
         delete currentNode;
         this->SetTotalTreeDepth();
         return;
      }

      // find parent node
      while( parent!=0 && parent->GetDepth() != currentNode->GetDepth()-1) parent=parent->GetParent();

      if (parent!=0) { // link new node to parent
         currentNode->SetParent(parent);
         if (currentNode->GetPos()=='l') parent->SetLeft(currentNode);
         if (currentNode->GetPos()=='r') parent->SetRight(currentNode);
      }

      parent = currentNode; // latest node read might be parent of new one

      currentNode = CreateNode(); // create a new node to be read next
   }
}

////////////////////////////////////////////////////////////////////////////////
/// read the tree from an std::istream

std::istream& TMVA::operator>> (std::istream& istr, TMVA::BinaryTree& tree)
{
   tree.Read(istr);
   return istr;
}
////////////////////////////////////////////////////////////////////////////////
/// descend a tree to find all its leaf nodes, fill max depth reached in the
/// tree at the same time.

void TMVA::BinaryTree::SetTotalTreeDepth( Node *n)
{
   if (n == NULL){ //default, start at the tree top, then descend recursively
      n = (Node*) this->GetRoot();
      if (n == NULL) {
         Log() << kFATAL << "SetTotalTreeDepth: started with undefined ROOT node" <<Endl;
         return ;
      }
   }
   if (this->GetLeftDaughter(n) != NULL){
      this->SetTotalTreeDepth( this->GetLeftDaughter(n) );
   }
   if (this->GetRightDaughter(n) != NULL) {
      this->SetTotalTreeDepth( this->GetRightDaughter(n) );
   }
   if (n->GetDepth() > this->GetTotalTreeDepth()) this->SetTotalTreeDepth(n->GetDepth());

   return;
}

////////////////////////////////////////////////////////////////////////////////

TMVA::MsgLogger& TMVA::BinaryTree::Log() const {
  TTHREAD_TLS_DECL_ARG(MsgLogger,logger,"BinaryTree");
  return logger;
}