TMVA_MethodFisher

class TMVA_MethodFisher : public TMVA_MethodBase

    private:

      void GetCov_BetweenClass()
      void GetCov_Full()
      void GetCov_WithinClass()
      void GetDiscrimPower()
      void GetFisherCoeff()
      void GetMean()
      void Init()
      void InitFisher()
      void PrintCoefficients()

    public:

                                              TMVA_MethodFisher(TString jobName, vector<TString>* theVariables, TTree* theTree = 0, TString theOption = Fisher, TDirectory* theTargetDir = 0)
                                              TMVA_MethodFisher(vector<TString>* theVariables, TString theWeightFile, TDirectory* theTargetDir = NULL)
                                              TMVA_MethodFisher(const TMVA_MethodFisher&)
                                      virtual ~TMVA_MethodFisher()
                               static TClass* Class()
      virtual TMVA_MethodFisher::FisherMethod GetMethod()
                             virtual Double_t GetMvaValue(TMVA_Event* e)
                              virtual TClass* IsA() const
                           TMVA_MethodFisher& operator=(const TMVA_MethodFisher&)
                                 virtual void ReadWeightsFromFile()
                                 virtual void ShowMembers(TMemberInspector& insp, char* parent)
                                 virtual void Streamer(TBuffer& b)
                                         void StreamerNVirtual(TBuffer& b)
                                 virtual void Train()
                                 virtual void WriteHistosToFile()
                                 virtual void WriteWeightsToFile()

Data Members

    private:

                                TH1D* fHistPDF[25]       histograms containing the pdfs
                                Int_t fNbins             
                                Int_t fAverageEvtPerBin  average events per bin. Used to calculate nbins
                                Int_t fNevt              
                                Int_t fNsig              
                                Int_t fNbgd              
                             TMatrixT<float>* fSig               
                             TMatrixT<float>* fBgd               
                             TMatrixT<float>* fMeanMatx          
                             TMatrixT<float>* fBetw              
                             TMatrixT<float>* fWith              
                             TMatrixT<float>* fCov               
                    vector<Double_t>* fDiscrimPow        
                    vector<Double_t>* fFisherCoeff       
                             Double_t fF0                
      TMVA_MethodFisher::FisherMethod fFisherMethod      

    public:

      static const TMVA_MethodFisher::FisherMethod kFisher       
      static const TMVA_MethodFisher::FisherMethod kMahalanobis  

Class Description

 Analysis of Fisher discriminant (Fisher or Mahalanobis approach)

_______________________________________________________________________

--------------------------------------------------------------

 should never be called without existing trainingTree

 the matrix of covariance 'within class' reflects the dispersion of the
 events relative to the center of gravity of their own class

 the matrix of covariance 'between class' reflects the dispersion of the
 events of a class relative to the global center of gravity of all the class
 hence the separation between classes

 Fisher = Sum { [coeff]*[variables] }

 let Xs be the array of the mean values of variables for signal evts
 let Xb be the array of the mean values of variables for backgd evts
 let InvWith be the inverse matrix of the 'within class' correlation matrix

 then the array of Fisher coefficients is
 [coeff] =sqrt(fNsig*fNbgd)/fNevt*transpose{Xs-Xb}*InvWith

small values of "fWith" indicates little compactness of sig & of backgd
big values of "fBetw" indicates large separation between sig & backgd

we want signal & backgd classes as compact and separated as possible
the discriminating power is then defined as the ration "fBetw/fWith"

 display Fisher coefficients and discriminating power for each variable
 check maximum length of variable name

 write coefficients to file

 read coefficients from file

Inline Functions

        TMVA_MethodFisher::FisherMethod GetMethod()
                                TClass* Class()
                                TClass* IsA() const
                                   void ShowMembers(TMemberInspector& insp, char* parent)
                                   void Streamer(TBuffer& b)
                                   void StreamerNVirtual(TBuffer& b)
                      TMVA_MethodFisher TMVA_MethodFisher(const TMVA_MethodFisher&)
                     TMVA_MethodFisher& operator=(const TMVA_MethodFisher&)