library: libTMVA
#include "MethodPDERS.h"

TMVA::MethodPDERS

class description - header file - source file - inheritance tree (.pdf)

class TMVA::MethodPDERS : public TMVA::MethodBase

Inheritance Chart:
TObject
<-
TMVA::MethodBase
<-
TMVA::MethodPDERS
 
    private:

      Float_t GetError(Float_t countS, Float_t countB, Float_t sumW2S, Float_t sumW2B) const
         void InitPDERS()
      Float_t RScalc(TMVA::Event* e)
         void SetVolumeElement()

    protected:

      TMVA::BinarySearchTree* GetBinaryTreeBkg() const
      TMVA::BinarySearchTree* GetBinaryTreeSig() const
                     Double_t KernelEstimate(TMVA::Event&, vector<TMVA::Event*,allocator<TMVA::Event*> >&, TMVA::Volume&)

    public:

                                MethodPDERS(TString jobName, vector<TString>* theVariables, TTree* theTree = 0, TString theOption = Adaptive:100:200:50:0.99, TDirectory* theTargetDir = 0)
                                MethodPDERS(vector<TString>* theVariables, TString theWeightFile, TDirectory* theTargetDir = NULL)
                                MethodPDERS(const TMVA::MethodPDERS&)
                        virtual ~MethodPDERS()
                 static TClass* Class()
               virtual Double_t GetMvaValue(TMVA::Event* e)
                       Double_t GetVolumeContentForRoot(Double_t)
                static Double_t IGetVolumeContentForRoot(Double_t)
                virtual TClass* IsA() const
             TMVA::MethodPDERS& operator=(const TMVA::MethodPDERS&)
                   virtual void ReadWeightsFromFile()
                   virtual void ShowMembers(TMemberInspector& insp, char* parent)
                   virtual void Streamer(TBuffer& b)
                           void StreamerNVirtual(TBuffer& b)
      static TMVA::MethodPDERS* ThisPDERS()
                   virtual void Train()
                   virtual void WriteHistosToFile()
                   virtual void WriteWeightsToFile()

Data Members

    private:

      TMVA::MethodPDERS::VolumeRangeMode fVRangeMode            
                 TMVA::BinarySearchTree* fBinaryTreeS           
                 TMVA::BinarySearchTree* fBinaryTreeB           
                        vector<Float_t>* fDelta                 
                        vector<Float_t>* fShift                 
                                 Float_t fScaleS                
                                 Float_t fScaleB                
                                 Float_t fDeltaFrac             
                                 Float_t fNEventsMin            
                                 Float_t fNEventsMax            
                                 Float_t fMaxVIterations        
                                 Float_t fInitialScale          
                                  TFile* fFin                   
                                  Bool_t fInitializedVolumeEle  
               static TMVA::MethodPDERS* fgThisPDERS            

    protected:

      TMVA::Volume* fHelpVolume  
              Int_t fFcnCall     

    public:

      static const TMVA::MethodPDERS::VolumeRangeMode kMinMax    
      static const TMVA::MethodPDERS::VolumeRangeMode kRMS       
      static const TMVA::MethodPDERS::VolumeRangeMode kAdaptive

Class Description

_______________________________________________________________________
This is a generalization of the above Likelihood methods to Nvar dimensions, where Nvar is the number of input variables used in the MVA. If the multi-dimensional probability density functions (PDFs) for signal and background were known, this method contains the entire physical information, and is therefore optimal. Usually, kernel estimation methods are used to approximate the PDFs using the events from the training sample.

A very simple probability density estimator (PDE) has been suggested in hep-ex/0211019. The PDE for a given test event is obtained from counting the (normalized) number of signal and background (training) events that occur in the "vicinity" of the test event. The volume that describes "vicinity" is user-defined. A search method based on binary-trees is used to effectively reduce the selection time for the range search. Three different volume definitions are optional:

The adaptive range search is used by default. 


 MethodPDERS( TString jobName, vector<TString>* theVariables,                                TTree* theTree, TString theOption, TDirectory* theTargetDir )


 standard constructor for the PDERS method
 format and syntax of option string: "VolumeRangeMode:options"
 where:
    VolumeRangeMode - all methods defined in private enum "VolumeRangeMode"
    options         - deltaFrac in case of VolumeRangeMode=MinMax/RMS
                    - nEventsMin/Max, maxVIterations, scale for VolumeRangeMode=Adaptive

 MethodPDERS also has an implementation of a simple kernel estimater
 (adaptive Gaussian); at present this cannot yet be switched on via options;
 you must change it in the source file via the flag:
 TMVA_MethodPDERS_UseKernelEstimate



 MethodPDERS( vector<TString> *theVariables,                                TString theWeightFile,                                TDirectory* theTargetDir )


 construct MethodPDERS through from file



void InitPDERS( void )


 default initialisation routine called by all constructors



 ~MethodPDERS( void )


 destructor



void Train( void )


 this is a dummy training: the preparation work to do is the construction
 of the binary tree as a pointer chain. It is easier to directly save the
 trainingTree in the weight file, and to rebuild the binary tree in the
 test phase from scratch



Double_t GetMvaValue( TMVA::Event *e )


 init the size of a volume element using a defined fraction of the
 volume containing the entire events



void SetVolumeElement( void )


 defines volume dimensions



Double_t IGetVolumeContentForRoot( Double_t scale )


 Interface to RootFinder



Double_t GetVolumeContentForRoot( Double_t scale )


 count number of events in rescaled volume



Float_t RScalc( TMVA::Event *e )


 computes event weight by counting number of signal and background
 events (of reference sample) that are found within given volume
 defined by the event



Double_t KernelEstimate( TMVA::Event& event,                                            vector<TMVA::Event*>& events, TMVA::Volume& v )


 returns Gaussian kernel estimate for event in given volume



Float_t GetError( Float_t countS, Float_t countB,                                     Float_t sumW2S, Float_t sumW2B )


 statistical error estimate for RS estimator



void WriteWeightsToFile( void )


 write training sample (TTree) to file



void ReadWeightsFromFile( void )


 read training sample from file



void WriteHistosToFile( void )


 write special monitoring histograms to file - not implemented for PDERS



 MethodPDERS( TString jobName,                   vector<TString>* theVariables,                   TTree* theTree = 0,                   TString theOption = "Adaptive:100:200:50:0.99",                   TDirectory* theTargetDir = 0 )




MethodPDERS* ThisPDERS( void )


 static pointer to this object



BinarySearchTree* GetBinaryTreeSig( void )


 accessors



BinarySearchTree* GetBinaryTreeBkg( void )







Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

Last update: root/tmva $Id: MethodPDERS.cxx,v 1.3 2006/05/23 19:35:06 brun Exp $

Copyright  (c) 2005:                                                            *









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.