Quick Links: ROOT Homepage Class Index Class Hierarchy

Sections: class description function members data members class charts

ROOT » MATH » MATHMORE » ROOT::Math::GSLNLSMinimizer

class ROOT::Math::GSLNLSMinimizer: public ROOT::Math::Minimizer


    LSResidualFunc class description.
    Internal class used for accessing the residuals of the Least Square function
    and their derivates which are estimated numerically using GSL numerical derivation.
    The class contains a pointer to the fit method function and an index specifying
    the i-th residual and wraps it in a multi-dim gradient function interface
    ROOT::Math::IGradientFunctionMultiDim.
    The class is used by ROOT::Math::GSLNLSMinimizer (GSL non linear least square fitter)

    @ingroup MultiMin

Function Members (Methods)

public:

virtual	~GSLNLSMinimizer()
virtual void	ROOT::Math::Minimizer::Clear()
virtual bool	ROOT::Math::Minimizer::Contour(unsigned int, unsigned int, unsigned int&, double, double)
virtual double	ROOT::Math::Minimizer::Correlation(unsigned int i, unsigned int j) const
virtual double	CovMatrix(unsigned int, unsigned int) const
virtual double	ROOT::Math::Minimizer::CovMatrix(unsigned int i, unsigned int j) const
virtual int	ROOT::Math::Minimizer::CovMatrixStatus() const
virtual double	Edm() const
virtual double	ROOT::Math::Minimizer::Edm() const
double	ROOT::Math::Minimizer::ErrorDef() const
virtual const double*	Errors() const
virtual const double*	ROOT::Math::Minimizer::Errors() const
virtual bool	GetMinosError(unsigned int, double&, double&)
virtual bool	ROOT::Math::Minimizer::GetMinosError(unsigned int, double& errLow, double& errUp)
virtual double	ROOT::Math::Minimizer::GlobalCC(unsigned int) const
ROOT::Math::GSLNLSMinimizer	GSLNLSMinimizer(int type = 0)
virtual bool	ROOT::Math::Minimizer::Hesse()
bool	ROOT::Math::Minimizer::IsValidError() const
unsigned int	ROOT::Math::Minimizer::MaxFunctionCalls()
unsigned int	ROOT::Math::Minimizer::MaxIterations()
virtual const double*	MinGradient() const
virtual bool	Minimize()
virtual bool	ROOT::Math::Minimizer::Minimize()
virtual double	MinValue() const
virtual double	ROOT::Math::Minimizer::MinValue() const
virtual unsigned int	NCalls() const
virtual unsigned int	ROOT::Math::Minimizer::NCalls() const
virtual unsigned int	NDim() const
virtual unsigned int	ROOT::Math::Minimizer::NDim() const
virtual unsigned int	NFree() const
virtual unsigned int	ROOT::Math::Minimizer::NFree() const
int	ROOT::Math::Minimizer::PrintLevel() const
virtual void	ROOT::Math::Minimizer::PrintResults()
virtual bool	ProvidesError() const
virtual bool	ROOT::Math::Minimizer::ProvidesError() const
virtual bool	ROOT::Math::Minimizer::Scan(unsigned int, unsigned int&, double, double, double = 0, double = 0)
void	ROOT::Math::Minimizer::SetErrorDef(double up)
virtual bool	SetFixedVariable(unsigned int ivar, const string& name, double val)
virtual bool	ROOT::Math::Minimizer::SetFixedVariable(unsigned int, const string&, double)
virtual void	SetFunction(const ROOT::Math::IMultiGenFunction& func)
virtual void	SetFunction(const ROOT::Math::IMultiGradFunction& func)
virtual void	ROOT::Math::Minimizer::SetFunction(const ROOT::Math::IMultiGenFunction& func)
virtual void	ROOT::Math::Minimizer::SetFunction(const ROOT::Math::IMultiGradFunction& func)
virtual bool	SetLimitedVariable(unsigned int ivar, const string& name, double val, double step, double lower, double upper)
virtual bool	SetLowerLimitedVariable(unsigned int ivar, const string& name, double val, double step, double lower)
virtual bool	ROOT::Math::Minimizer::SetLowerLimitedVariable(unsigned int ivar, const string& name, double val, double step, double lower)
void	ROOT::Math::Minimizer::SetMaxFunctionCalls(unsigned int maxfcn)
void	ROOT::Math::Minimizer::SetMaxIterations(unsigned int maxiter)
void	ROOT::Math::Minimizer::SetPrintLevel(int level)
void	ROOT::Math::Minimizer::SetStrategy(int strategyLevel)
void	ROOT::Math::Minimizer::SetTolerance(double tol)
virtual bool	SetUpperLimitedVariable(unsigned int ivar, const string& name, double val, double step, double upper)
virtual bool	ROOT::Math::Minimizer::SetUpperLimitedVariable(unsigned int ivar, const string& name, double val, double step, double upper)
void	ROOT::Math::Minimizer::SetValidError(bool on)
virtual bool	SetVariable(unsigned int ivar, const string& name, double val, double step)
virtual bool	ROOT::Math::Minimizer::SetVariable(unsigned int ivar, const string& name, double val, double step)
virtual bool	SetVariableValue(unsigned int ivar, double val)
virtual bool	ROOT::Math::Minimizer::SetVariableValue(unsigned int, double)
virtual bool	SetVariableValues(const double* x)
virtual bool	ROOT::Math::Minimizer::SetVariableValues(const double* x)
int	ROOT::Math::Minimizer::Status() const
int	ROOT::Math::Minimizer::Strategy() const
double	ROOT::Math::Minimizer::Tolerance() const
virtual const double*	X() const
virtual const double*	ROOT::Math::Minimizer::X() const

private:

ROOT::Math::GSLNLSMinimizer	GSLNLSMinimizer(const ROOT::Math::GSLNLSMinimizer&)
ROOT::Math::GSLNLSMinimizer&	operator=(const ROOT::Math::GSLNLSMinimizer& rhs)

Data Members

protected:

int	ROOT::Math::Minimizer::fDebug	print level
unsigned int	ROOT::Math::Minimizer::fMaxCalls	max number of funciton calls
unsigned int	ROOT::Math::Minimizer::fMaxIter	max number or iterations used to find the minimum
int	ROOT::Math::Minimizer::fStatus	status of minimizer
int	ROOT::Math::Minimizer::fStrategy	minimizer strategy
double	ROOT::Math::Minimizer::fTol	tolerance (absolute)
double	ROOT::Math::Minimizer::fUp	error scale
bool	ROOT::Math::Minimizer::fValidError	flag to control if errors have been validated (Hesse has been run in case of Minuit)

private:

map<unsigned int,std::pair<double,double> >	fBounds	map specifying the bound using as key the parameter index
vector<double>	fCovMatrix	cov matrix (stored as cov[ i * dim + j]
unsigned int	fDim	dimension of the function to be minimized
double	fEdm	edm value
vector<double>	fErrors
ROOT::Math::GSLMultiFit*	fGSLMultiFit	pointer to GSL multi fit solver
double	fLSTolerance	Line Search Tolerance
double	fMinVal	minimum function value
unsigned int	fNFree	dimension of the internal function to be minimized
vector<std::string>	fNames
const ROOT::Math::FitMethodFunction*	fObjFunc	pointer to Least square function
vector<LSResidualFunc>	fResiduals	! transient Vector of the residual functions
unsigned int	fSize	number of fit points (residuals)
vector<double>	fSteps
vector<double>	fValues
vector<ROOT::Math::EMinimVariableType>	fVarTypes	vector specifyng the type of variables

Class Charts

Inheritance Inherited Members Includes Libraries

Function documentation

operator=(const ROOT::Math::GSLNLSMinimizer& rhs)

unsigned int NDim() const

{ return fChi2->NDim(); }

GSLNLSMinimizer(int type = 0)

      Default constructor

~GSLNLSMinimizer()

      Destructor (no operations)

GSLNLSMinimizer(const GSLNLSMinimizer &)

 usually copying is non trivial, so we make this unaccessible

      Copy constructor

{}

void SetFunction(const ROOT::Math::IMultiGenFunction & func)

 set the function to minimize

void SetFunction(const ROOT::Math::IMultiGradFunction & func)

 set gradient the function to minimize

bool SetVariable(unsigned int ivar, const string& name, double val, double step)

 set free variable

bool SetLowerLimitedVariable(unsigned int ivar, const string& name, double val, double step, double lower)

 set lower limited variable

bool SetUpperLimitedVariable(unsigned int ivar, const string& name, double val, double step, double upper)

 set upper/lower limited variable

bool SetLimitedVariable(unsigned int ivar, const string& name, double val, double step, double lower, double upper)

 set fixed variable

bool SetFixedVariable(unsigned int ivar, const string& name, double val)

bool SetVariableValue(unsigned int ivar, double val)

 set the value of an existing variable

bool SetVariableValues(const double* x)

bool Minimize()

 method to perform the minimization

double MinValue() const

 return minimum function value

{ return fMinVal; }

double Edm() const

 return expected distance reached from the minimum

const double * X() const

 return  pointer to X values at the minimum

{ return &fValues.front(); }

const double * MinGradient() const

 return pointer to gradient values at the minimum

unsigned int NCalls() const

 number of function calls to reach the minimum

{ return 0; }

unsigned int NFree() const

 number of free variables (real dimension of the problem)
 this is <= Function().NDim() which is the total

{ return fNFree; }

bool ProvidesError() const

 minimizer provides error and error matrix

{ return true; }

const double * Errors() const

 return errors at the minimum

{ return &fErrors.front(); }

double CovMatrix(unsigned int , unsigned int ) const

 return covariance matrices elements
       if the variable is fixed the matrix is zero
       The ordering of the variables is the same as in errors

bool GetMinosError(unsigned int , double& , double& )

 minos error for variable i, return false if Minos failed

{ return false; }