class TMVA::BinarySearchTree: public TMVA::BinaryTree


BinarySearchTree

A simple Binary search tree including a volume search method

Function Members (Methods)

public:
virtual~BinarySearchTree()
TMVA::BinarySearchTreeBinarySearchTree()
TMVA::BinarySearchTreeBinarySearchTree(const TMVA::BinarySearchTree& b)
voidCalcStatistics(TMVA::Node* n = 0)
static TClass*Class()
voidClear(TMVA::Node* n = 0)
UInt_tTMVA::BinaryTree::CountNodes(TMVA::Node* n = NULL)
virtual TMVA::Node*CreateNode()
virtual TMVA::Node*CreateNode(const vector<TMVA::VariableInfo>* vI)
Double_tFill(vector<TMVA::Event*> theTree, Int_t theType = -1)
Double_tFill(const TMVA::MethodBase& callingMethod, TTree* theTree, Int_t theType)
Double_tFill(vector<TMVA::Event*>, vector<Int_t> theVars, Int_t theType = -1)
TMVA::Node*TMVA::BinaryTree::GetLeftDaughter(TMVA::Node* n)
UInt_tTMVA::BinaryTree::GetNNodes() const
UInt_tGetPeriode() const
TMVA::Node*TMVA::BinaryTree::GetRightDaughter(TMVA::Node* n)
TMVA::Node*TMVA::BinaryTree::GetRoot() const
Double_tGetSumOfWeights() const
UInt_tTMVA::BinaryTree::GetTotalTreeDepth() const
voidInsert(const TMVA::Event*)
virtual TClass*IsA() const
Float_tMax(TMVA::Types::ESBType sb, UInt_t var)
Float_tMean(TMVA::Types::ESBType sb, UInt_t var)
Float_tMin(TMVA::Types::ESBType sb, UInt_t var)
voidNormalizeTree()
voidTMVA::BinaryTree::Print(ostream& os) const
voidTMVA::BinaryTree::Read(istream& istr)
Float_tRMS(TMVA::Types::ESBType sb, UInt_t var)
TMVA::BinarySearchTreeNode*Search(TMVA::Event* event) const
Double_tSearchVolume(TMVA::Volume*, vector<const TMVA::BinarySearchTreeNode*>* events = 0)
Int_tSearchVolumeWithMaxLimit(TMVA::Volume*, vector<const TMVA::BinarySearchTreeNode*>* events = 0, Int_t = -1)
voidSetNormalize(Bool_t norm)
voidSetPeriode(Int_t p)
voidTMVA::BinaryTree::SetRoot(TMVA::Node* r)
voidTMVA::BinaryTree::SetTotalTreeDepth(Int_t depth)
voidTMVA::BinaryTree::SetTotalTreeDepth(TMVA::Node* n = NULL)
virtual voidShowMembers(TMemberInspector& insp, char* parent)
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
protected:
voidTMVA::BinaryTree::DeleteNode(TMVA::Node*)
private:
voidInsert(const TMVA::Event*, TMVA::Node*)
Bool_tInVolume(const vector<Float_t>&, TMVA::Volume*) const
voidNormalizeTree(vector<pair<double,const TMVA::Event*>,allocator<pair<double,const TMVA::Event*> > >::iterator, vector<pair<double,const TMVA::Event*>,allocator<pair<double,const TMVA::Event*> > >::iterator, UInt_t)
TMVA::BinarySearchTreeNode*Search(TMVA::Event*, TMVA::Node*) const
Double_tSearchVolume(TMVA::Node*, TMVA::Volume*, Int_t, vector<const TMVA::BinarySearchTreeNode*>* events)

Data Members

protected:
UInt_tTMVA::BinaryTree::fDepthmaximal depth in tree reached
TMVA::MsgLoggerTMVA::BinaryTree::fLoggermessage loggera
Int_tTMVA::BinaryTree::fNNodestotal number of nodes in the tree (counted)
private:
Bool_tfCanNormalizethe tree can be normalised
UInt_tfCurrentDepthinternal variable, counting the depth of the tree during insertion
vector<Float_t>fMax[2]RMS for signal and background for each variable
vector<Float_t>fMeans[2]mean for signal and background for each variable
vector<Float_t>fMin[2]RMS for signal and background for each variable
Double_tfNEventsW[2]Number of events per class, taking into account event weights
vector<std::pair<Double_t,const TMVA::Event*> >fNormalizeTreeTable
UInt_tfPeriodperiode (number of event variables)
vector<Float_t>fRMS[2]RMS for signal and background for each variable
Bool_tfStatisticsIsValidflag if last stat calculation is still valid, set to false if new node is insert
vector<Double_t>fSum[2]Sum for signal and background for each variable
Double_tfSumOfWeightsTotal number of events (weigthed) counted during filling
vector<Double_t>fSumSq[2]Squared Sum for signal and background for each variable

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

BinarySearchTree(const TMVA::BinarySearchTree& b)
 default constructor
BinarySearchTree(const TMVA::BinarySearchTree& b)
 copy constructor that creates a true copy, i.e. a completely independent tree
~BinarySearchTree( void )
 destructor
void Insert(const TMVA::Event* )
 insert a new "event" in the binary tree
void Insert(const TMVA::Event* , TMVA::Node* )
 private internal function to insert a event (node) at the proper position
TMVA::BinarySearchTreeNode* Search(TMVA::Event* event) const
search the tree to find the node matching "event"
TMVA::BinarySearchTreeNode* Search(TMVA::Event* , TMVA::Node* ) const
 Private, recursive, function for searching.
Double_t GetSumOfWeights( void )
return the sum of event (node) weights
Double_t Fill( const MethodBase& callingMethod, TTree* theTree, Int_t theType )
 create the search tree from the events in the DataSet
 NOTE: the tree given as argument MUST NOT contain transformed variables,
 otherwise double transformation would occur
Double_t Fill( std::vector<Event*> theTree, std::vector<Int_t> theVars, Int_t theType )
 create the search tree from the event collection
 using ONLY the variables specified in "theVars"
Double_t Fill(vector<TMVA::Event*> theTree, Int_t theType = -1)
 create the search tree from the events in a TTree
 using ALL the variables specified included in the Event
void NormalizeTree( std::vector< pair<Double_t, const TMVA::Event*> >::iterator leftBound, std::vector< pair<Double_t, const TMVA::Event*> >::iterator rightBound, UInt_t actDim )
void NormalizeTree()
 Normalisation of tree
void Clear(TMVA::Node* n = 0)
 clear nodes
Double_t SearchVolume(TMVA::Volume* , vector<const TMVA::BinarySearchTreeNode*>* events = 0)
 search the whole tree and add up all weigths of events that
 lie within the given voluem
Double_t SearchVolume(TMVA::Node* , TMVA::Volume* , Int_t , vector<const TMVA::BinarySearchTreeNode*>* events)
 recursively walk through the daughter nodes and add up all weigths of events that
 lie within the given volume
Bool_t InVolume(const vector<Float_t>& , TMVA::Volume* ) const
 test if the data points are in the given volume
void CalcStatistics(TMVA::Node* n = 0)
 calculate basic statistics (mean, rms for each variable)
Int_t SearchVolumeWithMaxLimit(TMVA::Volume* , vector<const TMVA::BinarySearchTreeNode*>* events = 0, Int_t = -1)
 recursively walk through the daughter nodes and add up all weigths of events that
 lie within the given volume a maximum number of events can be given
Node * CreateNode(const vector<TMVA::VariableInfo>* vI)
{ return new BinarySearchTreeNode(); }
Node * CreateNode(const vector<TMVA::VariableInfo>* vI)
void SetPeriode(Int_t p)
set the periode (number of variables)
{ fPeriod = p; }
UInt_t GetPeriode( void )
{ return fPeriod; }
Float_t Mean(TMVA::Types::ESBType sb, UInt_t var)
 access to mean for signal and background for each variable
{ return fMeans[sb==Types::kSignal?0:1][var]; }
Float_t RMS(TMVA::Types::ESBType sb, UInt_t var)
 access to RMS for signal and background for each variable
{ return fRMS[sb==Types::kSignal?0:1][var]; }
Float_t Min(TMVA::Types::ESBType sb, UInt_t var)
 access to Minimum for signal and background for each variable
{ return fMin[sb==Types::kSignal?0:1][var]; }
Float_t Max(TMVA::Types::ESBType sb, UInt_t var)
 access to Maximum for signal and background for each variable
{ return fMax[sb==Types::kSignal?0:1][var]; }
void SetNormalize(Bool_t norm)
{ fCanNormalize = norm; }

Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss
Last change: root/tmva $Id: BinarySearchTree.h 23334 2008-04-19 18:38:57Z 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.