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

 standard constructur

 constructor used for Testing + Application of the MVA,
 only (no training), using given WeightFiles

 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"

 create variable transformations

 options that are used ONLY for the READER to ensure backward compatibility
   they are hence without any effect (the reader is only reading the training
   options that HAD been used at the training of the .xml weightfile at hand

 call the Optimzier with the set of paremeters and ranges that
 are meant to be tuned.

 set the tuning parameters accoding to the argument
 This is just a dummy .. have a look at the MethodBDT how you could
 perhaps implment the same thing for the other Classifiers..

 prepare tree branch with the method's discriminating variable

 prepare tree branch with the method's discriminating variable

 uses a pre-set cut on the MVA output (SetSignalReferenceCut and SetSignalReferenceCutOrientation)
 for a quick determination if an event would be selected as signal or background

 uses a pre-set cut on the MVA output (SetSignalReferenceCut and SetSignalReferenceCutOrientation)
 for a quick determination if an event with this mva output value would tbe selected as signal or background

 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

 test multiclass classification

 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 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

 for reading from memory

 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 spectator info to XML

 write class info to XML

 write target info to XML

 read variable info from XML

 read spectator info from XML

 read number of classes 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

 the simple one, automatically calcualtes the mvaVal and uses the
 SAME sig/bkg ratio as given in the training sample (typically 50/50
 .. (NormMode=EqualNumEvents) but can be different)

 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) - B(x))^2/(S(x) + B(x)) dx }

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

 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

 returns the event collection (i.e. the dataset) TRANSFORMED using the
   classifiers specific Variable Transformation (e.g. Decorr or Decorr:Gauss:Decorr)

 calculates the TMVA version string from the training version code on the fly

 calculates the ROOT version string from the training version code on the fly

 return a pointer the base class of this method

 reset required for RootFinder

 default constructur

 store and retrieve time used for training

 store and retrieve time used for testing

 options treatment

 reset the Method --> As if it was not yet trained, just instantiated
      virtual void     Reset()          = 0;
for the moment, I provide a dummy (that would not work) default, just to make
 compilation/running w/o parameter optimisation still possible

 classifier response:
 some methods may return a per-event error estimate
 error calculation is skipped if err==0

 regression response

 multiclass classification response

 create ranking

 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 reference and update
 NOTE: these Event accessors make sure that you get the events transformed according to the
        particular clasifiers transformation chosen

 setter method for suppressing writing to XML and writing of standalone classes

 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

 if TRUE, write weights only to text files

 access to event information that needs method-specific information

 This is a workaround for OSx where static thread_local data members are
 not supported. The C++ solution would indeed be the following: