class TMVA::DecisionTreeNode: public TMVA::Node


DecisionTreeNode

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


Function Members (Methods)

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_tGetNBkgEvents_unweighted() const
Double_tGetNEvents() const
Double_tGetNEvents_unweighted() const
Int_tGetNodeType() const
Double_tGetNSigEvents() const
Double_tGetNSigEvents_unweighted() 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
virtual Bool_tGoesLeft(const TMVA::Event&) const
virtual Bool_tGoesRight(const TMVA::Event&) const
voidIncrementNBkgEvents(Double_t b)
voidIncrementNBkgEvents_unweighted()
voidIncrementNEvents(Double_t nev)
voidIncrementNEvents_unweighted()
voidIncrementNSigEvents(Double_t s)
voidIncrementNSigEvents_unweighted()
virtual TClass*IsA() const
TMVA::DecisionTreeNode&operator=(const TMVA::DecisionTreeNode&)
virtual voidPrint(ostream& os) const
virtual voidPrintRec(ostream& os) const
voidSetCutType(Bool_t t)
voidSetCutValue(Double_t c)
voidTMVA::Node::SetDepth(UInt_t d)
voidTMVA::Node::SetLeft(TMVA::Node* l)
voidSetNBkgEvents(Double_t b)
voidSetNBkgEvents_unweighted(Double_t b)
voidSetNEvents(Double_t nev)
voidSetNEvents_unweighted(Double_t nev)
voidSetNodeType(Int_t t)
voidSetNSigEvents(Double_t s)
voidSetNSigEvents_unweighted(Double_t s)
voidTMVA::Node::SetParent(TMVA::Node* p)
voidTMVA::Node::SetParentTree(TMVA::BinaryTree* t)
voidTMVA::Node::SetPos(char s)
voidTMVA::Node::SetRight(TMVA::Node* r)
voidSetSelector(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)
private:
virtual Bool_tReadDataRecord(istream& is)

Data Members

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

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

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& ) const
 test event if it decends the tree at this node to the right
Bool_t GoesLeft(const TMVA::Event& ) const
 test event if it decends the tree at this node to the left
Double_t GetPurity( void )
 return the S/(S+B) (purity) for the node
 REM: even if nodes with purity 0.01 are very PURE background nodes, they still
      get a small value of the purity.
void Print(ostream& os) const
print the node
void PrintRec(ostream& os) const
recursively print the node and its daughters (--> print the 'tree')
Bool_t ReadDataRecord(istream& is)
 Read the data block
void ClearNodeAndAllDaughters()
 clear the nodes (their S/N, Nevents etc), just keep the structure of the tree
virtual ~DecisionTreeNode()
{}
void SetSelector(Short_t i)
 set index of variable used for discrimination at this node
{ fSelector = i; }
Short_t GetSelector()
{ return fSelector; }
void SetCutValue(Double_t c)
 set the cut value applied at this node
{ fCutValue = c; }
Double_t GetCutValue( void )
{ return fCutValue; }
void SetCutType(Bool_t t)
 set true: if event variable > cutValue ==> signal , false otherwise
{ 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
{ 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 SetNSigEvents_unweighted(Double_t s)
 set the sum of the unweighted signal events in the node
{ fNSigEvents_unweighted = s; }
void SetNBkgEvents_unweighted(Double_t b)
 set the sum of the unweighted backgr events in the node
{ fNBkgEvents_unweighted = b; }
void SetNEvents_unweighted(Double_t nev)
 set the number of unweighted events that entered the node (during training)
{ fNEvents_unweighted =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 ; }
void IncrementNSigEvents_unweighted( )
 increment the sum of the signal weights in the node
{ fNSigEvents_unweighted += 1; }
void IncrementNBkgEvents_unweighted( )
 increment the sum of the backgr weights in the node
{ fNBkgEvents_unweighted += 1; }
void IncrementNEvents_unweighted( )
 increment the number of events that entered the node (during training)
{ fNEvents_unweighted +=1 ; }
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; }
Double_t GetNSigEvents_unweighted( void )
 return the sum of unweighted signal weights in the node
{ return fNSigEvents_unweighted; }
Double_t GetNBkgEvents_unweighted( void )
 return the sum of unweighted backgr weights in the node
{ return fNBkgEvents_unweighted; }
Double_t GetNEvents_unweighted( void )
 return  the number of unweighted events that entered the node (during training)
{ return fNEvents_unweighted; }
void SetSeparationIndex(Double_t sep)
 set the choosen index, measure of "purity" (separation between S and B) 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
{ 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 change: root/tmva $Id: DecisionTreeNode.h 21079 2007-11-27 20:08:49Z brun $
Last generated: 2008-06-25 08:48
Copyright (c) 2005: *

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.