library: libTMVA
#include "DecisionTreeNode.h"

TMVA::DecisionTreeNode

class description - header file - source file
viewCVS header - viewCVS source

class TMVA::DecisionTreeNode: public TMVA::Node

Inheritance Inherited Members Includes Libraries
Class Charts

Function Members (Methods)

Display options:
Show inherited
Show non-public
public:
virtual~DecisionTreeNode()
static TClass*Class()
voidClearNodeAndAllDaughters()
Int_tTMVA::Node::CountMeAndAllDaughters() const
TMVA::DecisionTreeNodeDecisionTreeNode()
TMVA::DecisionTreeNodeDecisionTreeNode(TMVA::Node* p, char pos)
TMVA::DecisionTreeNodeDecisionTreeNode(const TMVA::DecisionTreeNode& n, TMVA::DecisionTreeNode* parent = NULL)
intTMVA::Node::GetCount()
Bool_tGetCutType() const
Double_tGetCutValue() const
UInt_tTMVA::Node::GetDepth() const
TMVA::Node*TMVA::Node::GetLeft() const
Double_tGetNBkgEvents() const
Double_tGetNEvents() const
Int_tGetNodeType() const
Double_tGetNSigEvents() const
TMVA::Node*TMVA::Node::GetParent() const
TMVA::BinaryTree*TMVA::Node::GetParentTree() const
charTMVA::Node::GetPos() const
Double_tGetPurity() const
TMVA::Node*TMVA::Node::GetRight() const
Short_tGetSelector() const
Double_tGetSeparationGain() const
Double_tGetSeparationIndex() const
ULong_tGetSequence() const
Double_tGetSoverSB() const
virtual Bool_tGoesLeft(const TMVA::Event&) const
virtual Bool_tGoesRight(const TMVA::Event&) const
voidIncrementNBkgEvents(Double_t b)
voidIncrementNEvents(Double_t nev)
voidIncrementNSigEvents(Double_t s)
virtual TClass*IsA() const
TMVA::DecisionTreeNode&operator=(const TMVA::DecisionTreeNode&)
virtual voidPrint(ostream& os) const
virtual voidPrintRec(ostream& os) const
virtual voidReadRec(istream& is, char& pos, UInt_t& depth, TMVA::Node* parent = NULL)
voidSetCutType(Bool_t t)
voidSetCutValue(Double_t c)
voidTMVA::Node::SetDepth(const UInt_t d)
voidTMVA::Node::SetLeft(TMVA::Node* l)
voidSetNBkgEvents(Double_t b)
voidSetNEvents(Double_t nev)
voidSetNodeType(Int_t t)
voidSetNSigEvents(Double_t s)
voidTMVA::Node::SetParent(TMVA::Node* p)
voidTMVA::Node::SetParentTree(TMVA::BinaryTree* t)
voidTMVA::Node::SetPos(const char s)
voidTMVA::Node::SetRight(TMVA::Node* r)
voidSetSelector(const Short_t i)
voidSetSeparationGain(Double_t sep)
voidSetSeparationIndex(Double_t sep)
voidSetSequence(ULong_t s)
virtual voidShowMembers(TMemberInspector& insp, char* parent)
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)

Data Members

private:
Double_tfCutValuecut value appplied on this node to discriminate bkg against sig
Bool_tfCutTypetrue: if event variable > cutValue ==> signal , false otherwise
Short_tfSelectorindex of variable used in node selection (decision tree)
Double_tfNSigEventssum of weights of signal event in the node
Double_tfNBkgEventssum of weights of backgr event in the node
Double_tfNEventsnumber of events in that entered the node (during training)
Double_tfSeparationIndexmeasure of "purity" (separation between S and B) AT this node
Double_tfSeparationGainmeasure of "purity", separation, or information gained BY this nodes selection
Int_tfNodeTypeType of node: -1 == Bkg-leaf, 1 == Signal-leaf, 0 = internal
ULong_tfSequencebit coded left right sequence to reach the node

Class Description

                                                                      
 Node for the Decision Tree                                           

 The node specifies ONE variable out of the given set of selection variable
 that is used to split the sample which "arrives" at the node, into a left
 (background-enhanced) and a right (signal-enhanced) sample.
_______________________________________________________________________
DecisionTreeNode()
 constructor of an essentially "empty" node floating in space
DecisionTreeNode(TMVA::Node* p, char pos)
 constructor of a daughter node as a daughter of 'p'
DecisionTreeNode(const TMVA::DecisionTreeNode &n, DecisionTreeNode* parent)
 copy constructor of a node. It will result in an explicit copy of
 the node and recursively all it's daughters
Bool_t GoesRight(const TMVA::Event & e)
 test event if it decends the tree at this node to the right
Bool_t GoesLeft(const TMVA::Event & e)
 test event if it decends the tree at this node to the left
Double_t GetSoverSB( void )
 return the S/(S+B) for the node
Double_t GetPurity( void )
 return the purity of the node. that means  S/(S+B) for signal nodes 
 and B/(S+B) for nodes classified as background
void Print(ostream& os)
print the node
void PrintRec(ostream& os)
recursively print the node and its daughters (--> print the 'tree')
void ReadRec(istream& is, char &pos, UInt_t &depth, TMVA::Node* parent )
recursively read the node and its daughters (--> read the 'tree')
void ClearNodeAndAllDaughters()
 clear the nodes (their S/N, Nevents etc), just keep the structure of the tree
virtual ~DecisionTreeNode()
{}
void SetSelector( const Short_t i)
 set index of variable used for discrimination at this node
 return index of variable used for discrimination at this node
{ fSelector = i; }
Short_t GetSelector()
{ return fSelector; }
void SetCutType( Bool_t t )
 set true: if event variable > cutValue ==> signal , false otherwise
 return kTRUE: Cuts select signal, kFALSE: Cuts select bkg
{ fCutType = t; }
Bool_t GetCutType( void )
{ return fCutType; }
void SetNodeType( Int_t t )
 set node type: 1 signal node, -1 bkg leave, 0 intermediate Node
 return node type: 1 signal node, -1 bkg leave, 0 intermediate Node
{ fNodeType = t;}
Int_t GetNodeType( void )
{ return fNodeType; }
void SetNSigEvents( Double_t s )
 set the sum of the signal weights in the node
{ fNSigEvents = s; }
void SetNBkgEvents( Double_t b )
 set the sum of the backgr weights in the node
{ fNBkgEvents = b; }
void SetNEvents( Double_t nev )
 set the number of events that entered the node (during training)
{ fNEvents =nev ; }
void IncrementNSigEvents( Double_t s )
 increment the sum of the signal weights in the node
{ fNSigEvents += s; }
void IncrementNBkgEvents( Double_t b )
 increment the sum of the backgr weights in the node
{ fNBkgEvents += b; }
void IncrementNEvents( Double_t nev )
 increment the number of events that entered the node (during training)
{ fNEvents +=nev ; }
Double_t GetNSigEvents( void )
 return the sum of the signal weights in the node
{ return fNSigEvents; }
Double_t GetNBkgEvents( void )
 return the sum of the backgr weights in the node
{ return fNBkgEvents; }
Double_t GetNEvents( void )
 return  the number of events that entered the node (during training)
{ return fNEvents; }
void SetSeparationIndex( Double_t sep )
 set the choosen index, measure of "purity" (separation between S and B) AT this node
 return the separation index AT this node
{ fSeparationIndex =sep ; }
Double_t GetSeparationIndex( void )
{ return fSeparationIndex; }
void SetSeparationGain( Double_t sep )
 set the separation, or information gained BY this nodes selection
 return the gain in separation obtained by this nodes selection
{ fSeparationGain =sep ; }
Double_t GetSeparationGain( void )
{ return fSeparationGain; }
ULong_t GetSequence()
{return fSequence;}
void SetSequence(ULong_t s)
{fSequence=s;}

Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss
Last update: root/tmva $Id: DecisionTreeNode.cxx,v 1.11 2006/11/20 15:35:28 brun Exp $

ROOT page - Class index - Class Hierarchy - Top of the page
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.