ROOT logo
ROOT » TMVA » TMVA::MethodCuts

class TMVA::MethodCuts: public TMVA::MethodBase, public TMVA::IFitterTarget

Multivariate optimisation of signal efficiency for given background efficiency, applying rectangular minimum and maximum requirements.

Also implemented is a "decorrelate/diagonlized cuts approach", which improves over the uncorrelated cuts ansatz by transforming linearly the input variables into a diagonal space, using the square-root of the covariance matrix.

Other optimisation criteria, such as maximising the signal significance- squared, S^2/(S+B), with S and B being the signal and background yields, correspond to a particular point in the optimised background rejection versus signal efficiency curve. This working point requires the knowledge of the expected yields, which is not the case in general. Note also that for rare signals, Poissonian statistics should be used, which modifies the significance criterion.

The rectangular cut of a volume in the variable space is performed using a binary tree to sort the training events. This provides a significant reduction in computing time (up to several orders of magnitudes, depending on the complexity of the problem at hand).

Technically, optimisation is achieved in TMVA by two methods:

  1. Monte Carlo generation using uniform priors for the lower cut value, and the cut width, thrown within the variable ranges.
  2. A Genetic Algorithm (GA) searches for the optimal ("fittest") cut sample. The GA is configurable by many external settings through the option string. For difficult cases (such as many variables), some tuning may be necessary to achieve satisfying results

Attempts to use Minuit fits (Simplex ot Migrad) instead have not shown superior results, and often failed due to convergence at local minima.

The tests we have performed so far showed that in generic applications, the GA is superior to MC sampling, and hence GA is the default method. It is worthwhile trying both anyway. Decorrelated (or "diagonalized") Cuts

See class description for Method Likelihood for a detailed explanation.


Function Members (Methods)

voidTObject::AbstractMethod(const char* method) const
voidTMVA::Configurable::AddOptionsXMLTo(void* parent) const
voidTMVA::MethodBase::AddOutput(TMVA::Types::ETreeType type, TMVA::Types::EAnalysisType analysisType)
virtual voidAddWeightsXMLTo(void* parent) const
virtual voidTObject::AppendPad(Option_t* option = "")
TDirectory*TMVA::MethodBase::BaseDir() const
virtual voidTObject::Browse(TBrowser* b)
voidTMVA::Configurable::CheckForUnusedOptions() const
virtual voidCheckSetup()
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
virtual Int_tTObject::Compare(const TObject* obj) const
TMVA::ConfigurableTMVA::Configurable::Configurable(const TString& theOption = "")
virtual voidTObject::Copy(TObject& object) const
virtual const TMVA::Ranking*CreateRanking()
TMVA::DataSet*TMVA::MethodBase::Data() const
TMVA::DataSetInfo&TMVA::MethodBase::DataInfo() const
virtual voidTMVA::MethodBase::DeclareCompatibilityOptions()
virtual voidDeclareOptions()
virtual voidTObject::Delete(Option_t* option = "")MENU
voidTMVA::MethodBase::DisableWriting(Bool_t setter)
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
Bool_tTMVA::MethodBase::DoRegression() const
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTObject::Dump() constMENU
static TMVA::MethodCuts*DynamicCast(TMVA::IMethod* method)
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual Double_tEstimatorFunction(vector<Double_t>&)
Double_tEstimatorFunction(Int_t ievt1, Int_t ievt2)
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
TMVA::Types::EAnalysisTypeTMVA::MethodBase::GetAnalysisType() const
const char*TMVA::Configurable::GetConfigDescription() const
const char*TMVA::Configurable::GetConfigName() const
Double_tGetCuts(Double_t effS, vector<Double_t>& cutMin, vector<Double_t>& cutMax) const
Double_tGetCuts(Double_t effS, Double_t* cutMin, Double_t* cutMax) const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual Double_tGetEfficiency(const TString&, TMVA::Types::ETreeType, Double_t&)
const TMVA::Event*TMVA::MethodBase::GetEvent() const
const TMVA::Event*TMVA::MethodBase::GetEvent(const TMVA::Event* ev) const
const TMVA::Event*TMVA::MethodBase::GetEvent(Long64_t ievt) const
const TMVA::Event*TMVA::MethodBase::GetEvent(Long64_t ievt, TMVA::Types::ETreeType type) const
const vector<TMVA::Event*>&TMVA::MethodBase::GetEventCollection(TMVA::Types::ETreeType type)
virtual const char*TObject::GetIconName() const
const TString&TMVA::MethodBase::GetInputLabel(Int_t i) const
const TString&TMVA::MethodBase::GetInputTitle(Int_t i) const
const TString&TMVA::MethodBase::GetInputVar(Int_t i) const
const TString&TMVA::MethodBase::GetJobName() const
virtual Double_tTMVA::MethodBase::GetMaximumSignificance(Double_t SignalEvents, Double_t BackgroundEvents, Double_t& optimal_significance_value) const
Double_tTMVA::MethodBase::GetMean(Int_t ivar) const
const TString&TMVA::MethodBase::GetMethodName() const
TMVA::Types::EMVATMVA::MethodBase::GetMethodType() const
TStringTMVA::MethodBase::GetMethodTypeName() const
virtual Double_tGetMvaValue(Double_t* err = 0)
virtual const char*TMVA::MethodBase::GetName() const
UInt_tTMVA::MethodBase::GetNEvents() const
UInt_tTMVA::MethodBase::GetNTargets() const
UInt_tTMVA::MethodBase::GetNvar() const
UInt_tTMVA::MethodBase::GetNVariables() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
const TString&TMVA::Configurable::GetOptions() const
virtual Double_tTMVA::MethodBase::GetProba(Double_t mvaVal, Double_t ap_sig)
const TStringTMVA::MethodBase::GetProbaName() const
virtual Double_tGetRarity(Double_t, TMVA::Types::ESBType) const
virtual const vector<Float_t>&TMVA::MethodBase::GetRegressionValues()
Double_tTMVA::MethodBase::GetRMS(Int_t ivar) const
virtual Double_tTMVA::MethodBase::GetROCIntegral(TMVA::PDF* pdfS = 0, TMVA::PDF* pdfB = 0) const
virtual Double_tGetSeparation(TH1*, TH1*) const
virtual Double_tGetSeparation(TMVA::PDF* = 0, TMVA::PDF* = 0) const
Double_tTMVA::MethodBase::GetSignalReferenceCut() const
virtual Double_tGetSignificance() const
const TMVA::Event*TMVA::MethodBase::GetTestingEvent(Long64_t ievt) const
Double_tTMVA::MethodBase::GetTestTime() const
const TString&TMVA::MethodBase::GetTestvarName() const
virtual const char*TObject::GetTitle() const
virtual Double_tGetTrainingEfficiency(const TString&)
const TMVA::Event*TMVA::MethodBase::GetTrainingEvent(Long64_t ievt) const
UInt_tTMVA::MethodBase::GetTrainingROOTVersionCode() const
TStringTMVA::MethodBase::GetTrainingROOTVersionString() const
UInt_tTMVA::MethodBase::GetTrainingTMVAVersionCode() const
TStringTMVA::MethodBase::GetTrainingTMVAVersionString() const
Double_tTMVA::MethodBase::GetTrainTime() const
const TMVA::TransformationHandler&TMVA::MethodBase::GetTransformationHandler() const
virtual UInt_tTObject::GetUniqueID() const
TStringTMVA::MethodBase::GetWeightFileName() const
Double_tTMVA::MethodBase::GetXmax(Int_t ivar) const
Double_tTMVA::MethodBase::GetXmin(Int_t ivar) const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual Bool_tHasAnalysisType(TMVA::Types::EAnalysisType type, UInt_t numberClasses, UInt_t numberTargets)
virtual ULong_tTObject::Hash() const
Bool_tTMVA::MethodBase::HasMVAPdfs() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTMVA::MethodBase::IsSignalLike()
virtual Bool_tTObject::IsSortable() const
Bool_tTObject::IsZombie() const
virtual voidTObject::ls(Option_t* option = "") const
virtual voidTMVA::MethodBase::MakeClass(const TString& classFileName = TString("")) const
voidTObject::MayNotUse(const char* method) const
TDirectory*TMVA::MethodBase::MethodBaseDir() const
TMVA::MethodCutsMethodCuts(TMVA::DataSetInfo& theData, const TString& theWeightFile, TDirectory* theTargetDir = NULL)
TMVA::MethodCutsMethodCuts(const TString& jobName, const TString& methodTitle, TMVA::DataSetInfo& theData, const TString& theOption = "MC:150:10000:", TDirectory* theTargetFile = 0)
virtual Bool_tTMVA::MethodBase::MonitorBoost(TMVA::MethodBoost*)
virtual Bool_tTObject::Notify()
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
TMVA::IMethod&TMVA::IMethod::operator=(const TMVA::IMethod&)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTMVA::Configurable::ParseOptions()
virtual voidTObject::Pop()
virtual voidTObject::Print(Option_t* option = "") const
voidPrintCuts(Double_t effS) const
virtual voidTMVA::MethodBase::PrintHelpMessage() const
voidTMVA::Configurable::PrintOptions() const
virtual voidProcessOptions()
virtual voidTMVA::IFitterTarget::ProgressNotifier(TString, TString)
virtual Int_tTObject::Read(const char* name)
voidTMVA::Configurable::ReadOptionsFromStream(istream& istr)
voidTMVA::Configurable::ReadOptionsFromXML(void* node)
virtual voidReadWeightsFromStream(istream& i)
virtual voidReadWeightsFromXML(void* wghtnode)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
virtual voidTMVA::MethodBase::SetAnalysisType(TMVA::Types::EAnalysisType type)
voidTMVA::MethodBase::SetBaseDir(TDirectory* methodDir)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidTMVA::Configurable::SetConfigDescription(const char* d)
voidTMVA::Configurable::SetConfigName(const char* n)
virtual voidTMVA::MethodBase::SetCurrentEvent(Long64_t ievt) const
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidTMVA::MethodBase::SetMethodBaseDir(TDirectory* methodDir)
voidTMVA::MethodBase::SetMethodDir(TDirectory* methodDir)
voidTMVA::Configurable::SetMsgType(TMVA::EMsgType t)
static voidTObject::SetObjectStat(Bool_t stat)
voidTMVA::Configurable::SetOptions(const TString& s)
voidTMVA::MethodBase::SetSignalReferenceCut(Double_t cut)
voidSetTestSignalEfficiency(Double_t effS)
voidTMVA::MethodBase::SetTestTime(Double_t testTime)
voidTMVA::MethodBase::SetTestvarName(const TString& v = "")
voidTMVA::MethodBase::SetTrainTime(Double_t trainTime)
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidShowMembers(TMemberInspector& insp, char* parent)
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTestClassification()
virtual voidTMVA::MethodBase::TestRegression(Double_t& bias, Double_t& biasT, Double_t& dev, Double_t& devT, Double_t& rms, Double_t& rmsT, Double_t& mInf, Double_t& mInfT, Double_t& corr, TMVA::Types::ETreeType type)
virtual voidTrain()
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
virtual voidTMVA::MethodBase::WriteEvaluationHistosToFile(TMVA::Types::ETreeType treetype)
virtual voidWriteMonitoringHistosToFile() const
voidTMVA::Configurable::WriteOptionsToStream(ostream& o, const TString& prefix) const
voidTMVA::MethodBase::WriteStateToFile() const
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidTMVA::Configurable::EnableLooseOptions(Bool_t b = kTRUE)
virtual voidGetHelpMessage() const
const TString&TMVA::MethodBase::GetInternalVarName(Int_t ivar) const
const TString&TMVA::MethodBase::GetOriginalVarName(Int_t ivar) const
const TString&TMVA::Configurable::GetReferenceFile() const
static TMVA::MethodBase*TMVA::MethodBase::GetThisBase()
Float_tTMVA::MethodBase::GetTWeight(const TMVA::Event* ev) const
const TString&TMVA::MethodBase::GetWeightFileDir() const
Bool_tTMVA::MethodBase::HasTrainingTree() const
Bool_tTMVA::MethodBase::Help() const
Bool_tTMVA::MethodBase::IgnoreEventsWithNegWeightsInTraining() const
Bool_tTMVA::MethodBase::IsConstructedFromWeightFile() const
Bool_tTMVA::MethodBase::IsNormalised() const
TMVA::MsgLogger&TMVA::Configurable::Log() const
Bool_tTMVA::Configurable::LooseOptionCheckingEnabled() const
virtual voidMakeClassSpecific(ostream&, const TString&) const
virtual voidTMVA::MethodBase::MakeClassSpecificHeader(ostream&, const TString& = "") const
voidTMVA::MethodBase::SetNormalised(Bool_t norm)
voidTMVA::MethodBase::SetWeightFileDir(TString fileDir)
voidTMVA::MethodBase::Statistics(TMVA::Types::ETreeType treeType, const TString& theVarName, Double_t&, Double_t&, Double_t&, Double_t&, Double_t&, Double_t&)
Bool_tTMVA::MethodBase::TxtWeightsOnly() const
Bool_tTMVA::MethodBase::Verbose() const
voidGetEffsfromPDFs(Double_t* cutMin, Double_t* cutMax, Double_t& effS, Double_t& effB)
voidGetEffsfromSelection(Double_t* cutMin, Double_t* cutMax, Double_t& effS, Double_t& effB)
virtual voidInit()
voidMatchCutsToPars(vector<Double_t>&, Double_t*, Double_t*)
voidMatchCutsToPars(vector<Double_t>&, Double_t**, Double_t**, Int_t ibin)
voidMatchParsToCuts(const vector<Double_t>&, Double_t*, Double_t*)
voidMatchParsToCuts(Double_t*, Double_t*, Double_t*)

Data Members

enum EFitMethodType { kUseMonteCarlo
enum EEffMethod { kUseEventSelection
enum EFitParameters { kNotEnforced
enum TMVA::MethodBase::EWeightFileType { kROOT
enum TMVA::MethodBase::ECutOrientation { kNegative
enum TObject::EStatusBits { kCanDelete
enum TObject::[unnamed] { kIsOnHeap
Bool_tTMVA::MethodBase::fSetupCompletedis method setup
const TMVA::Event*TMVA::MethodBase::fTmpEvent! temporary event when testing on a different DataSet than the own one
static const Double_tfgMaxAbsCutVal
TMVA::Types::EAnalysisTypeTMVA::MethodBase::fAnalysisTypemethod-mode : true --> regression, false --> classification
UInt_tTMVA::MethodBase::fBackgroundClassindex of the Background-class
vector<TString>*TMVA::MethodBase::fInputVarsvector of input variables used in MVA
Int_tTMVA::MethodBase::fNbinsnumber of bins in representative histograms
Int_tTMVA::MethodBase::fNbinsHnumber of bins in evaluation histograms
TMVA::Ranking*TMVA::MethodBase::fRankingpointer to ranking object (created by derived classifiers)
vector<Float_t>*TMVA::MethodBase::fRegressionReturnValholds the return-value for the regression
UInt_tTMVA::MethodBase::fSignalClassindex of the Signal-class
TString*fAllVarsIwhat to do with variables
Double_t**fCutMaxmaximum requirement
Double_t**fCutMinminimum requirement
vector<Interval*>fCutRangeallowed ranges for cut optimisation
Double_t*fCutRangeMaxmaximum of allowed cut range
Double_t*fCutRangeMinminimum of allowed cut range
TH1*fEffBvsSLocalintermediate eff. background versus eff signal histo
TMVA::MethodCuts::EEffMethodfEffMethodchosen efficiency calculation method
TStringfEffMethodSchosen efficiency calculation method (string)
Double_tfEffRefreference efficiency
Double_tfEffSMaxused to test optimized signal efficiency
Double_tfEffSMinused to test optimized signal efficiency
TMVA::MethodCuts::EFitMethodTypefFitMethodchosen fit method
TStringfFitMethodSchosen fit method (string)
vector<EFitParameters>*fFitParamsvector for series of fit methods
vector<Double_t>*fMeanBmeans of variables (background)
vector<Double_t>*fMeanSmeans of variables (signal)
Bool_tfNegEffWarningflag risen in case of negative efficiency warning
Int_tfNparnumber of parameters in fit (default: 2*Nvar)
TRandom*fRandomrandom generator for MC optimisation method
vector<Int_t>*fRangeSignused to match cuts to fit parameters (and vice versa)
vector<Double_t>*fRmsBRMSs of variables (background)
vector<Double_t>*fRmsSRMSs of variables (signal)
Double_tfTestSignalEffused to test optimized signal efficiency
Double_t*fTmpCutMaxtemporary maximum requirement
Double_t*fTmpCutMintemporary minimum requirement
vector<TH1*>*fVarHistBreference histograms (background)
vector<TH1*>*fVarHistB_smoothsmoothed reference histograms (background)
vector<TH1*>*fVarHistSreference histograms (signal)
vector<TH1*>*fVarHistS_smoothsmoothed reference histograms (signal)
vector<PDF*>*fVarPdfBreference PDFs (background)
vector<PDF*>*fVarPdfSreference PDFs (signal)

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

MethodCuts(const TString& jobName, const TString& methodTitle, TMVA::DataSetInfo& theData, const TString& theOption = "MC:150:10000:", TDirectory* theTargetFile = 0)
 standard constructor
MethodCuts(TMVA::DataSetInfo& theData, const TString& theWeightFile, TDirectory* theTargetDir = NULL)
 construction from weight file
Bool_t HasAnalysisType(TMVA::Types::EAnalysisType type, UInt_t numberClasses, UInt_t numberTargets)
 Cuts can only handle classification with 2 classes
void Init( void )
 default initialisation called by all constructors
~MethodCuts( void )
void DeclareOptions()
 define the options (their key words) that can be set in the option string
 know options:
 Method             <string> Minimisation method
    available values are:        MC Monte Carlo <default>
                                 GA Genetic Algorithm
                                 SA Simulated annealing

 EffMethod          <string> Efficiency selection method
    available values are:        EffSel <default>

 VarProp            <string> Property of variable 1 for the MC method (taking precedence over the
    globale setting. The same values as for the global option are available. Variables 1..10 can be
    set this way

 CutRangeMin/Max    <float>  user-defined ranges in which cuts are varied
void ProcessOptions()
 process user options
 sanity check, do not allow the input variables to be normalised, because this
 only creates problems when interpreting the cuts
Double_t GetMvaValue(Double_t* err = 0)
 cut evaluation: returns 1.0 if event passed, 0.0 otherwise
void PrintCuts(Double_t effS) const
 print cuts
Double_t GetCuts( Double_t effS, Double_t* cutMin, Double_t* cutMax )
 retrieve cut values for given signal efficiency
 assume vector of correct size !!
Double_t GetCuts( Double_t effS, std::vector<Double_t>& cutMin, std::vector<Double_t>& cutMax )
 retrieve cut values for given signal efficiency
void Train( void )
 training method: here the cuts are optimised for the training sample
void TestClassification()
 nothing to test
Double_t EstimatorFunction(Int_t ievt1, Int_t ievt2)
 for full event scan
Double_t EstimatorFunction(vector<Double_t>& )
 returns estimator for "cut fitness" used by GA
Double_t ComputeEstimator(vector<Double_t>& )
 returns estimator for "cut fitness" used by GA
 there are two requirements:
 1) the signal efficiency must be equal to the required one in the
    efficiency scan
 2) the background efficiency must be as small as possible
 the requirement 1) has priority over 2)
void MatchParsToCuts( const std::vector<Double_t> & pars, Double_t* cutMin, Double_t* cutMax )
 translates parameters into cuts
void MatchCutsToPars(vector<Double_t>& , Double_t** , Double_t** , Int_t ibin)
 translate the cuts into parameters (obsolete function)
void MatchCutsToPars(vector<Double_t>& , Double_t* , Double_t* )
 translates cuts into parameters
void GetEffsfromPDFs(Double_t* cutMin, Double_t* cutMax, Double_t& effS, Double_t& effB)
 compute signal and background efficiencies from PDFs
 for given cut sample
void GetEffsfromSelection(Double_t* cutMin, Double_t* cutMax, Double_t& effS, Double_t& effB)
 compute signal and background efficiencies from event counting
 for given cut sample
void CreateVariablePDFs( void )
 for PDF method: create efficiency reference histograms and PDFs
void ReadWeightsFromStream(istream& i)
 read the cuts from stream
void AddWeightsXMLTo(void* parent) const
 create XML description for LD classification and regression
 (for arbitrary number of output classes/targets)
void ReadWeightsFromXML(void* wghtnode)
 read coefficients from xml weight file
void WriteMonitoringHistosToFile( void )
 write histograms and PDFs to file for monitoring purposes
Double_t GetTrainingEfficiency(const TString& )
 - overloaded function to create background efficiency (rejection) versus
   signal efficiency plot (first call of this function)
 - the function returns the signal efficiency at background efficiency
   indicated in theString

 "theString" must have two entries:
 [0]: "Efficiency"
 [1]: the value of background efficiency at which the signal efficiency
      is to be returned
Double_t GetEfficiency(const TString& , TMVA::Types::ETreeType , Double_t& )
 - overloaded function to create background efficiency (rejection) versus
   signal efficiency plot (first call of this function)
 - the function returns the signal efficiency at background efficiency
   indicated in theString

 "theString" must have two entries:
 [0]: "Efficiency"
 [1]: the value of background efficiency at which the signal efficiency
      is to be returned
void MakeClassSpecific(ostream& , const TString& ) const
 write specific classifier response
void GetHelpMessage() const
 get help message text

 typical length of text line:
MethodCuts* DynamicCast(TMVA::IMethod* method)
 this is a workaround which is necessary since CINT is not capable of handling dynamic casts
{ return dynamic_cast<MethodCuts*>(method); }
Double_t GetSeparation( TH1*, TH1* )
 also overwrite --> not computed for cuts
{ return -1; }
Double_t GetSeparation( PDF* = 0, PDF* = 0 )
{ return -1; }
Double_t GetSignificance( void )
{ return -1; }
Double_t GetmuTransform(TTree* )
{ return -1; }
Double_t GetRarity(Double_t , TMVA::Types::ESBType ) const
 rarity distributions (signal or background (default) is uniform in [0,1])
{ return 0; }
void SetTestSignalEfficiency(Double_t effS)
{ fTestSignalEff = effS; }
const Ranking* CreateRanking()
 ranking of input variables (not available for cuts)
{ return 0; }
void CheckSetup()
 no check of options at this place
void MatchParsToCuts( const std::vector<Double_t>&, Double_t*, Double_t* )
 the definition of fit parameters can be different from the actual
 cut requirements; these functions provide the matching