A++ » MATH » TLinearMinimizer

class TLinearMinimizer: public ROOT::Math::Minimizer


   Abstract Minimizer class, defining  the interface for the various minimizer
   (like Minuit2, Minuit, GSL, etc..)
   Plug-in's exist in ROOT to be able to instantiate the derived classes like
   ROOT::Math::GSLMinimizer or ROOT::Math::Minuit2Minimizer via the
   plug-in manager.

   Provides interface for setting the function to be minimized.
   The function must  implemente the multi-dimensional generic interface
   ROOT::Math::IBaseFunctionMultiDim.
   If the function provides gradient calculation
   (implements the ROOT::Math::IGradientFunctionMultiDim interface) this will be
   used by the Minimizer.

   It Defines also interface for setting the initial values for the function variables (which are the parameters in
   of the model function in case of solving for fitting) and especifying their limits.

   It defines the interface to set and retrieve basic minimization parameters
   (for specific Minimizer parameters one must use the derived classes).

   Then it defines the interface to retrieve the result of minimization ( minimum X values, function value,
   gradient, error on the mimnimum, etc...)

   @ingroup MultiMin

Function Members (Methods)

public:
virtual~TLinearMinimizer()
static TClass*Class()
virtual voidROOT::Math::Minimizer::Clear()
virtual boolROOT::Math::Minimizer::Contour(unsigned int ivar, unsigned int jvar, unsigned int& npoints, double* xi, double* xj)
virtual doubleROOT::Math::Minimizer::Correlation(unsigned int i, unsigned int j) const
virtual doubleCovMatrix(unsigned int i, unsigned int j) const
virtual intCovMatrixStatus() const
virtual doubleEdm() const
doubleROOT::Math::Minimizer::ErrorDef() const
virtual const double*Errors() const
virtual boolROOT::Math::Minimizer::FixVariable(unsigned int ivar)
virtual boolROOT::Math::Minimizer::GetCovMatrix(double* covMat) const
virtual boolROOT::Math::Minimizer::GetHessianMatrix(double* hMat) const
virtual boolROOT::Math::Minimizer::GetMinosError(unsigned int ivar, double& errLow, double& errUp, int option = 0)
virtual boolROOT::Math::Minimizer::GetVariableSettings(unsigned int ivar, ROOT::Fit::ParameterSettings& pars) const
virtual doubleROOT::Math::Minimizer::GlobalCC(unsigned int ivar) const
virtual boolROOT::Math::Minimizer::Hesse()
virtual TClass*IsA() const
virtual boolROOT::Math::Minimizer::IsFixedVariable(unsigned int ivar) const
boolROOT::Math::Minimizer::IsValidError() const
unsigned intROOT::Math::Minimizer::MaxFunctionCalls() const
unsigned intROOT::Math::Minimizer::MaxIterations() const
virtual const double*MinGradient() const
virtual boolMinimize()
ROOT::Math::MinimizerROOT::Math::Minimizer::Minimizer()
virtual doubleMinValue() const
virtual unsigned intNCalls() const
virtual unsigned intNDim() const
virtual unsigned intNFree() const
virtual unsigned intROOT::Math::Minimizer::NIterations() const
virtual ROOT::Math::MinimizerOptionsROOT::Math::Minimizer::Options() const
doubleROOT::Math::Minimizer::Precision() const
intROOT::Math::Minimizer::PrintLevel() const
virtual voidROOT::Math::Minimizer::PrintResults()
virtual boolProvidesError() const
virtual boolROOT::Math::Minimizer::ReleaseVariable(unsigned int ivar)
virtual boolROOT::Math::Minimizer::Scan(unsigned int ivar, unsigned int& nstep, double* x, double* y, double xmin = 0, double xmax = 0)
voidROOT::Math::Minimizer::SetDefaultOptions()
voidROOT::Math::Minimizer::SetErrorDef(double up)
virtual boolSetFixedVariable(unsigned int, const string&, double)
virtual voidSetFunction(const ROOT::Math::IMultiGenFunction& func)
virtual voidSetFunction(const ROOT::Math::IMultiGradFunction& func)
virtual boolROOT::Math::Minimizer::SetLimitedVariable(unsigned int ivar, const string& name, double val, double step, double lower, double upper)
virtual boolROOT::Math::Minimizer::SetLowerLimitedVariable(unsigned int ivar, const string& name, double val, double step, double lower)
voidROOT::Math::Minimizer::SetMaxFunctionCalls(unsigned int maxfcn)
voidROOT::Math::Minimizer::SetMaxIterations(unsigned int maxiter)
voidROOT::Math::Minimizer::SetOptions(const ROOT::Math::MinimizerOptions& opt)
voidROOT::Math::Minimizer::SetPrecision(double prec)
voidROOT::Math::Minimizer::SetPrintLevel(int level)
voidROOT::Math::Minimizer::SetStrategy(int strategyLevel)
voidROOT::Math::Minimizer::SetTolerance(double tol)
virtual boolROOT::Math::Minimizer::SetUpperLimitedVariable(unsigned int ivar, const string& name, double val, double step, double upper)
voidROOT::Math::Minimizer::SetValidError(bool on)
virtual boolSetVariable(unsigned int, const string&, double, double)
virtual boolROOT::Math::Minimizer::SetVariableInitialRange(unsigned int, double, double)
virtual boolROOT::Math::Minimizer::SetVariableLimits(unsigned int ivar, double lower, double upper)
virtual boolROOT::Math::Minimizer::SetVariableLowerLimit(unsigned int ivar, double lower)
virtual boolROOT::Math::Minimizer::SetVariableStepSize(unsigned int ivar, double value)
virtual boolROOT::Math::Minimizer::SetVariableUpperLimit(unsigned int ivar, double upper)
virtual boolROOT::Math::Minimizer::SetVariableValue(unsigned int ivar, double value)
virtual boolROOT::Math::Minimizer::SetVariableValues(const double* x)
virtual voidShowMembers(TMemberInspector& insp) const
intROOT::Math::Minimizer::Status() const
intROOT::Math::Minimizer::Strategy() const
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
TLinearMinimizer(int type = 0)
TLinearMinimizer(const char* type)
doubleROOT::Math::Minimizer::Tolerance() const
virtual intROOT::Math::Minimizer::VariableIndex(const string& name) const
virtual stringROOT::Math::Minimizer::VariableName(unsigned int ivar) const
virtual const double*X() const

Data Members

protected:
ROOT::Math::MinimizerOptionsROOT::Math::Minimizer::fOptionsminimizer options
intROOT::Math::Minimizer::fStatusstatus of minimizer
boolROOT::Math::Minimizer::fValidErrorflag to control if errors have been validated (Hesse has been run in case of Minuit)
private:
vector<double>fCovar
unsigned intfDim
vector<double>fErrors
TLinearFitter*fFitter
doublefMinVal
unsigned intfNFree
const ROOT::Math::IMultiGradFunction*fObjFunc
vector<double>fParams
boolfRobust

Class Charts

Inheritance Chart:
ROOT::Math::Minimizer
TLinearMinimizer

Function documentation

void SetFunction(const ROOT::Math::IMultiGenFunction& func)
 set the function to minimize
void SetFunction(const ROOT::Math::IMultiGradFunction& func)
 set a function to minimize using gradient
bool SetVariable(unsigned int , const string& , double , double )
 set a new free variable
bool SetFixedVariable(unsigned int , const string& , double )
 set a new fixed variable (override if minimizer supports them )
bool Minimize()
 method to perform the minimization
double MinValue() const
 return minimum function value
const double * X() const
 return  pointer to X values at the minimum
double Edm() const
 return expected distance reached from the minimum (re-implement if minimizer provides it
{ return -1; }
const double * MinGradient() const
 return pointer to gradient values at the minimum
{ return NULL; }
unsigned int NCalls() const
 number of function calls to reach the minimum
{ return 0; }
unsigned int NDim() const
 this is <= Function().NDim() which is the total
 number of variables (free+ constrained ones)
unsigned int NFree() const
 number of free variables (real dimension of the problem)
 this is <= Function().NDim() which is the total
 (re-implement if minimizer supports bounded parameters)
{ return NDim(); }
bool ProvidesError() const
 minimizer provides error and error matrix
{ return false; }
const double * Errors() const
 return errors at the minimum
{ return NULL; }
double CovMatrix(unsigned int i, unsigned int j) const
 return covariance matrices element for variables ivar,jvar
       if the variable is fixed the return value is zero
       The ordering of the variables is the same as in the parameter and errors vectors

int CovMatrixStatus() const
return status of covariance matrix
 using Minuit convention {0 not calculated 1 approximated 2 made pos def , 3 accurate}
 Minimizer who implements covariance matrix calculation will re-implement the method