class TMVA::MethodBase: public TMVA::IMethod, public TMVA::Configurable

 destructor

 setup of methods

 process all options
 the "CheckForUnusedOptions" is done in an independent call, since it may be overridden by derived class
 (sometimes, eg, fitters are used which can only be implemented during training phase)

 check may be overridden by derived class
 (sometimes, eg, fitters are used which can only be implemented during training phase)

 default initialization called by all constructors

 define the options (their key words) that can be set in the option string
 here the options valid for ALL MVA methods are declared.
 know options: VariableTransform=None,Decorrelated,PCA  to use transformed variables
                                                        instead of the original ones
               VariableTransformType=Signal,Background  which decorrelation matrix to use
                                                        in the method. Only the Likelihood
                                                        Method can make proper use of independent
                                                        transformations of signal and background
               fNbinsMVAPdf   = 50 Number of bins used to create a PDF of MVA
               fNsmoothMVAPdf =  2 Number of times a histogram is smoothed before creating the PDF
               fHasMVAPdfs         create PDFs for the MVA outputs
               V                   for Verbose output (!V) for non verbos
               H                   for Help message

 the option string is decoded, for availabel options see "DeclareOptions"

 prepare tree branch with the method's discriminating variable

 prepare tree branch with the method's discriminating variable

 prepare tree branch with the method's discriminating variable

 calculate <sum-of-deviation-squared> of regression output versus "true" value from test sample

   bias = average deviation
   dev  = average absolute deviation
   rms  = rms of deviation

 initialization

 general method used in writing the header of the weight files where
 the used variables, variable transformation type etc. is specified

 xml writing

 general method used in writing the header of the weight files where
 the used variables, variable transformation type etc. is specified

 write reference MVA distributions (and other information)
 to a ROOT type weight file

 write reference MVA distributions (and other information)
 to a ROOT type weight file

 write options and weights to file
 note that each one text file for the main configuration information
 and one ROOT file for ROOT objects are created

 Function to write options and weights to file

 read the header from the weight files of the different MVA methods

 write the list of variables (name, min, max) for a given data
 transformation method to the stream

 Read the variables (name, min, max) for a given data
 transformation method from the stream. In the stream we only
 expect the limits which will be set

 write variable info to XML

 write target info to XML

 read variable info from XML

 read target info from XML

 returns the ROOT directory where info/histograms etc of the
 corresponding MVA method instance are stored

 returns the ROOT directory where all instances of the
 corresponding MVA method are stored

 set directory of weight file

 set the weight file name (depreciated)

 retrieve weight file name

 writes all MVA evaluation histograms to file

 write special monitoring histograms to file
 dummy implementation here -----------------

 reads one line from the input stream
 checks for certain keywords and interprets
 the line if keywords are found

 Create PDFs of the MVA output variables

 compute likelihood ratio

 compute rarity:
 R(x) = Integrate_[-oo..x] { PDF(x') dx' }
 where PDF(x) is the PDF of the classifier's signal or background distribution

 fill background efficiency (resp. rejection) versus signal efficiency plots
 returns signal efficiency at background efficiency indicated in theString

 compute significance of mean difference
 significance = |<S> - <B>|/Sqrt(RMS_S2 + RMS_B2)

 compute "separation" defined as
 <s2> = (1/2) Int_-oo..+oo { (S(x) - B(x))^2/(S(x) + B(x)) dx }

 compute "separation" defined as
 <s2> = (1/2) Int_-oo..+oo { (S(x)2 - B(x)2)/(S(x) + B(x)) dx }

 calculate the area (integral) under the ROC curve as a
 overall quality measure of the classification

 plot significance, S/Sqrt(S^2 + B^2), curve for given number
 of signal and background events; returns cut for maximum significance
 also returned via reference is the maximum significance

 calculates rms,mean, xmin, xmax of the event variable
 this can be either done for the variables as they are or for
 normalised variables (in the range of 0-1) if "norm" is set to kTRUE

 create reader class for method (classification only at present)

 prints out method-specific help method

 interface for RootFinder

 returns efficiency as function of cut

 ---------- main training and testing methods ------------------------------
 prepare tree branch with the method's discriminating variable

 store and retrieve time used for training

 store and retrieve time used for testing

 classifier response - some methods may return a per-event error estimate (unless: *err = -1)

 options treatment

 regression response

 create ranking

 perfrom extra actions during the boosting at different stages

 the actual "weights"

 ---------- public accessors -----------------------------------------------
 classifier naming (a lot of names ... aren't they ;-)

 build classifier name in Test tree
 MVA prefix (e.g., "TMVA_")

 number of input variable used by classifier

 internal names and expressions of input variables

 normalisation and limit accessors

 sets the minimum requirement on the MVA output to declare an event signal-like

 sets the minimum requirement on the MVA output to declare an event signal-like

 the TMVA version can be obtained and checked using
    if (GetTrainingTMVAVersionCode()>TMVA_VERSION(3,7,2)) {...}
 or
    if (GetTrainingROOTVersionCode()>ROOT_VERSION(5,15,5)) {...}

 ---------- event accessors ------------------------------------------------
 returns reference to data set

 event reference and update

 ---------- public auxiliary methods ---------------------------------------
 this method is used to decide whether an event is signal- or background-like
 the reference cut "xC" is taken to be where
 Int_[-oo,xC] { PDF_S(x) dx } = Int_[xC,+oo] { PDF_B(x) dx }

 are input variables normalised ?

 set number of input variables (only used by MethodCuts, could perhaps be removed)
      void SetNvar( Int_t n ) { fNvar = n; }
 verbose and help flags

 ---------- protected event and tree accessors -----------------------------
 names of input variables (if the original names are expressions, they are
 transformed into regexps)

 ---------- protected auxiliary methods ------------------------------------
 make ROOT-independent C++ class for classifier response (classifier-specific implementation)

 header and auxiliary classes

 static pointer to this object - required for ROOT finder (to be solved differently)

 if TRUE, write weights only to text files

 access to event information that needs method-specific information

 ---------- private acccessors ---------------------------------------------
 reset required for RootFinder