Logo ROOT  
Reference Guide
Minuit2Minimizer.h
Go to the documentation of this file.
1// @(#)root/minuit2:$Id$
2// Author: L. Moneta Wed Oct 18 11:48:00 2006
3
4/**********************************************************************
5 * *
6 * Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
7 * *
8 * *
9 **********************************************************************/
10
11// Header file for class Minuit2Minimizer
12
13#ifndef ROOT_Minuit2_Minuit2Minimizer
14#define ROOT_Minuit2_Minuit2Minimizer
15
16#include "Math/Minimizer.h"
17
19
20#include "Math/IFunctionfwd.h"
21
22#include <vector>
23#include <string>
24#include <functional>
25
26namespace ROOT {
27
28namespace Minuit2 {
29
30class ModularFunctionMinimizer;
31class FCNBase;
32class FunctionMinimum;
33class MnTraceObject;
34
35// enumeration specifying the type of Minuit2 minimizers
37
38} // namespace Minuit2
39
40namespace Minuit2 {
41//_____________________________________________________________________________________________________
42/**
43 Minuit2Minimizer class implementing the ROOT::Math::Minimizer interface for
44 Minuit2 minimization algorithm.
45 In ROOT it can be instantiated using the plug-in manager (plug-in "Minuit2")
46 Using a string (used by the plugin manager) or via an enumeration
47 an one can set all the possible minimization algorithms (Migrad, Simplex, Combined, Scan and Fumili).
48
49 Refer to the [guide](https://root.cern.ch/root/htmldoc/guides/minuit2/Minuit2.html) for an introduction how Minuit
50 works.
51
52 @ingroup Minuit
53*/
55
56public:
57 /**
58 Default constructor
59 */
61
62 /**
63 Constructor with a char (used by PM)
64 */
65 Minuit2Minimizer(const char *type);
66
67 /**
68 Destructor (no operations)
69 */
70 ~Minuit2Minimizer() override;
71
72private:
73 // usually copying is non trivial, so we make this unaccessible
74
75 /**
76 Copy constructor
77 */
79
80 /**
81 Assignment operator
82 */
84
85public:
86 // clear resources (parameters) for consecutives minimizations
87 void Clear() override;
88
89 /// set the function to minimize
90 void SetFunction(const ROOT::Math::IMultiGenFunction &func) override;
91
92 /// set the function to minimize using an interface with gradient computation capabilities
93 void SetFunction(const ROOT::Math::IMultiGradFunction &func) override;
94
95 /// set the function implementing Hessian computation
96 void SetHessianFunction(std::function<bool(const std::vector<double> &, double *)> hfunc) override;
97
98 /// set free variable
99 bool SetVariable(unsigned int ivar, const std::string &name, double val, double step) override;
100
101 /// set lower limit variable (override if minimizer supports them )
102 bool
103 SetLowerLimitedVariable(unsigned int ivar, const std::string &name, double val, double step, double lower) override;
104 /// set upper limit variable (override if minimizer supports them )
105 bool
106 SetUpperLimitedVariable(unsigned int ivar, const std::string &name, double val, double step, double upper) override;
107 /// set upper/lower limited variable (override if minimizer supports them )
108 bool SetLimitedVariable(unsigned int ivar, const std::string &name, double val, double step,
109 double /* lower */, double /* upper */) override;
110 /// set fixed variable (override if minimizer supports them )
111 bool SetFixedVariable(unsigned int /* ivar */, const std::string & /* name */, double /* val */) override;
112 /// set variable
113 bool SetVariableValue(unsigned int ivar, double val) override;
114 // set variable values
115 bool SetVariableValues(const double *val) override;
116 /// set the step size of an already existing variable
117 bool SetVariableStepSize(unsigned int ivar, double step) override;
118 /// set the lower-limit of an already existing variable
119 bool SetVariableLowerLimit(unsigned int ivar, double lower) override;
120 /// set the upper-limit of an already existing variable
121 bool SetVariableUpperLimit(unsigned int ivar, double upper) override;
122 /// set the limits of an already existing variable
123 bool SetVariableLimits(unsigned int ivar, double lower, double upper) override;
124 /// fix an existing variable
125 bool FixVariable(unsigned int ivar) override;
126 /// release an existing variable
127 bool ReleaseVariable(unsigned int ivar) override;
128 /// query if an existing variable is fixed (i.e. considered constant in the minimization)
129 /// note that by default all variables are not fixed
130 bool IsFixedVariable(unsigned int ivar) const override;
131 /// get variable settings in a variable object (like ROOT::Fit::ParamsSettings)
132 bool GetVariableSettings(unsigned int ivar, ROOT::Fit::ParameterSettings &varObj) const override;
133 /// get name of variables (override if minimizer support storing of variable names)
134 std::string VariableName(unsigned int ivar) const override;
135 /// get index of variable given a variable given a name
136 /// return -1 if variable is not found
137 int VariableIndex(const std::string &name) const override;
138
139 /**
140 method to perform the minimization.
141 Return false in case the minimization did not converge. In this case a
142 status code different than zero is set
143 (retrieved by the derived method Minimizer::Status() )"
144
145 status = 1 : Covariance was made pos defined
146 status = 2 : Hesse is invalid
147 status = 3 : Edm is above max
148 status = 4 : Reached call limit
149 status = 5 : Any other failure
150 */
151 bool Minimize() override;
152
153 /// return minimum function value
154 double MinValue() const override { return fState.Fval(); }
155
156 /// return expected distance reached from the minimum
157 double Edm() const override { return fState.Edm(); }
158
159 /// return pointer to X values at the minimum
160 const double *X() const override { return &fValues.front(); }
161
162 /// return pointer to gradient values at the minimum
163 const double *MinGradient() const override { return nullptr; } // not available in Minuit2
164
165 /// number of function calls to reach the minimum
166 unsigned int NCalls() const override { return fState.NFcn(); }
167
168 /// this is <= Function().NDim() which is the total
169 /// number of variables (free+ constrained ones)
170 unsigned int NDim() const override { return fDim; }
171
172 /// number of free variables (real dimension of the problem)
173 /// this is <= Function().NDim() which is the total
174 unsigned int NFree() const override { return fState.VariableParameters(); }
175
176 /// minimizer provides error and error matrix
177 bool ProvidesError() const override { return true; }
178
179 /// return errors at the minimum
180 const double *Errors() const override;
181
182 /**
183 return covariance matrix elements
184 if the variable is fixed or const the value is zero
185 The ordering of the variables is the same as in errors and parameter value.
186 This is different from the direct interface of Minuit2 or TMinuit where the
187 values were obtained only to variable parameters
188 */
189 double CovMatrix(unsigned int i, unsigned int j) const override;
190
191 /**
192 Fill the passed array with the covariance matrix elements
193 if the variable is fixed or const the value is zero.
194 The array will be filled as cov[i *ndim + j]
195 The ordering of the variables is the same as in errors and parameter value.
196 This is different from the direct interface of Minuit2 or TMinuit where the
197 values were obtained only to variable parameters
198 */
199 bool GetCovMatrix(double *cov) const override;
200
201 /**
202 Fill the passed array with the Hessian matrix elements
203 The Hessian matrix is the matrix of the second derivatives
204 and is the inverse of the covariance matrix
205 If the variable is fixed or const the values for that variables are zero.
206 The array will be filled as h[i *ndim + j]
207 */
208 bool GetHessianMatrix(double *h) const override;
209
210 /**
211 return the status of the covariance matrix
212 status = -1 : not available (inversion failed or Hesse failed)
213 status = 0 : available but not positive defined
214 status = 1 : covariance only approximate
215 status = 2 : full matrix but forced pos def
216 status = 3 : full accurate matrix
217
218 */
219 int CovMatrixStatus() const override;
220 /**
221 return correlation coefficient between variable i and j.
222 If the variable is fixed or const the return value is zero
223 */
224 double Correlation(unsigned int i, unsigned int j) const override;
225
226 /**
227 get global correlation coefficient for the variable i. This is a number between zero and one which gives
228 the correlation between the i-th variable and that linear combination of all other variables which
229 is most strongly correlated with i.
230 If the variable is fixed or const the return value is zero
231 */
232 double GlobalCC(unsigned int i) const override;
233
234 /**
235 get the minos error for parameter i, return false if Minos failed
236 A minimizaiton must be performed befre, return false if no minimization has been done
237 In case of Minos failed the status error is updated as following
238 status += 10 * minosStatus.
239 The Minos status of last Minos run can also be retrieved by calling MinosStatus()
240 */
241 bool GetMinosError(unsigned int i, double &errLow, double &errUp, int = 0) override;
242
243 /**
244 MINOS status code of last Minos run
245 `status & 1 > 0` : invalid lower error
246 `status & 2 > 0` : invalid upper error
247 `status & 4 > 0` : invalid because maximum number of function calls exceeded
248 `status & 8 > 0` : a new minimum has been found
249 `status & 16 > 0` : error is truncated because parameter is at lower/upper limit
250 */
251 int MinosStatus() const override { return fMinosStatus; }
252
253 /**
254 scan a parameter i around the minimum. A minimization must have been done before,
255 return false if it is not the case
256 */
257 bool Scan(unsigned int i, unsigned int &nstep, double *x, double *y, double xmin = 0, double xmax = 0) override;
258
259 /**
260 find the contour points (xi,xj) of the function for parameter i and j around the minimum
261 The contour will be find for value of the function = Min + ErrorUp();
262 */
263 bool Contour(unsigned int i, unsigned int j, unsigned int &npoints, double *xi, double *xj) override;
264
265 /**
266 perform a full calculation of the Hessian matrix for error calculation
267 If a valid minimum exists the calculation is done on the minimum point otherwise is performed
268 in the current set values of parameters
269 Status code of minimizer is updated according to the following convention (in case Hesse failed)
270 status += 100*hesseStatus where hesse status is:
271 status = 1 : hesse failed
272 status = 2 : matrix inversion failed
273 status = 3 : matrix is not pos defined
274 */
275 bool Hesse() override;
276
277 /// return reference to the objective function
278 /// virtual const ROOT::Math::IGenFunction & Function() const;
279
280 /// print result of minimization
281 void PrintResults() override;
282
283 /// set an object to trace operation for each iteration
284 /// The object must be a (or inherit from) ROOT::Minuit2::MnTraceObject and implement operator() (int, const
285 /// MinimumState & state)
286 void SetTraceObject(MnTraceObject &obj);
287
288 /// set storage level = 1 : store all iteration states (default)
289 /// = 0 : store only first and last state to save memory
290 void SetStorageLevel(int level);
291
292 /// return the minimizer state (containing values, step size , etc..)
294
295protected:
296 // protected function for accessing the internal Minuit2 object. Needed for derived classes
297
299
301
303
304 virtual const ROOT::Minuit2::FCNBase *GetFCN() const { return fMinuitFCN; }
305
306 /// examine the minimum result
308
309 // internal function to compute Minos errors
310 int RunMinosError(unsigned int i, double &errLow, double &errUp, int runopt);
311
312private:
313 unsigned int fDim; // dimension of the function to be minimized
315 int fMinosStatus = -1; // Minos status code
316
318 // std::vector<ROOT::Minuit2::MinosError> fMinosErrors;
322 mutable std::vector<double> fValues;
323 mutable std::vector<double> fErrors;
324};
325
326} // namespace Minuit2
327
328} // end namespace ROOT
329
330#endif /* ROOT_Minuit2_Minuit2Minimizer */
#define h(i)
Definition: RSha256.hxx:106
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
char name[80]
Definition: TGX11.cxx:110
float xmin
Definition: THbookFile.cxx:95
float xmax
Definition: THbookFile.cxx:95
Class, describing value, limits and step size of the parameters Provides functionality also to set/re...
Documentation for the abstract class IBaseFunctionMultiDim.
Definition: IFunction.h:62
Interface (abstract class) for multi-dimensional functions providing a gradient calculation.
Definition: IFunction.h:343
Abstract Minimizer class, defining the interface for the various minimizer (like Minuit2,...
Definition: Minimizer.h:78
Interface (abstract class) defining the function to be minimized, which has to be implemented by the ...
Definition: FCNBase.h:45
class holding the full result of the minimization; both internal and external (MnUserParameterState) ...
Minuit2Minimizer class implementing the ROOT::Math::Minimizer interface for Minuit2 minimization algo...
bool ExamineMinimum(const ROOT::Minuit2::FunctionMinimum &min)
examine the minimum result
Minuit2Minimizer(ROOT::Minuit2::EMinimizerType type=ROOT::Minuit2::kMigrad)
Default constructor.
const ROOT::Minuit2::MnUserParameterState & State()
return the minimizer state (containing values, step size , etc..)
void SetStorageLevel(int level)
set storage level = 1 : store all iteration states (default) = 0 : store only first and last state to...
Minuit2Minimizer & operator=(const Minuit2Minimizer &rhs)
Assignment operator.
bool SetLimitedVariable(unsigned int ivar, const std::string &name, double val, double step, double, double) override
set upper/lower limited variable (override if minimizer supports them )
bool Contour(unsigned int i, unsigned int j, unsigned int &npoints, double *xi, double *xj) override
find the contour points (xi,xj) of the function for parameter i and j around the minimum The contour ...
bool IsFixedVariable(unsigned int ivar) const override
query if an existing variable is fixed (i.e.
bool SetVariableUpperLimit(unsigned int ivar, double upper) override
set the upper-limit of an already existing variable
unsigned int NCalls() const override
number of function calls to reach the minimum
double GlobalCC(unsigned int i) const override
get global correlation coefficient for the variable i.
bool SetVariableValues(const double *val) override
set the values of all existing variables (array must be dimensioned to the size of the existing param...
bool SetVariable(unsigned int ivar, const std::string &name, double val, double step) override
set free variable
virtual const ROOT::Minuit2::FCNBase * GetFCN() const
const double * X() const override
return pointer to X values at the minimum
const double * Errors() const override
return errors at the minimum
void SetFunction(const ROOT::Math::IMultiGenFunction &func) override
set the function to minimize
double MinValue() const override
return minimum function value
bool SetVariableStepSize(unsigned int ivar, double step) override
set the step size of an already existing variable
bool GetCovMatrix(double *cov) const override
Fill the passed array with the covariance matrix elements if the variable is fixed or const the value...
bool ReleaseVariable(unsigned int ivar) override
release an existing variable
void SetHessianFunction(std::function< bool(const std::vector< double > &, double *)> hfunc) override
set the function implementing Hessian computation
bool GetVariableSettings(unsigned int ivar, ROOT::Fit::ParameterSettings &varObj) const override
get variable settings in a variable object (like ROOT::Fit::ParamsSettings)
bool Hesse() override
perform a full calculation of the Hessian matrix for error calculation If a valid minimum exists the ...
ROOT::Minuit2::ModularFunctionMinimizer * fMinimizer
bool GetMinosError(unsigned int i, double &errLow, double &errUp, int=0) override
get the minos error for parameter i, return false if Minos failed A minimizaiton must be performed be...
std::string VariableName(unsigned int ivar) const override
get name of variables (override if minimizer support storing of variable names)
int RunMinosError(unsigned int i, double &errLow, double &errUp, int runopt)
bool SetVariableLimits(unsigned int ivar, double lower, double upper) override
set the limits of an already existing variable
bool ProvidesError() const override
minimizer provides error and error matrix
double Correlation(unsigned int i, unsigned int j) const override
return correlation coefficient between variable i and j.
bool SetLowerLimitedVariable(unsigned int ivar, const std::string &name, double val, double step, double lower) override
set lower limit variable (override if minimizer supports them )
void SetTraceObject(MnTraceObject &obj)
set an object to trace operation for each iteration The object must be a (or inherit from) ROOT::Minu...
virtual const ROOT::Minuit2::ModularFunctionMinimizer * GetMinimizer() const
unsigned int NFree() const override
number of free variables (real dimension of the problem) this is <= Function().NDim() which is the to...
double CovMatrix(unsigned int i, unsigned int j) const override
return covariance matrix elements if the variable is fixed or const the value is zero The ordering of...
void SetMinimizerType(ROOT::Minuit2::EMinimizerType type)
bool SetVariableValue(unsigned int ivar, double val) override
set variable
bool Scan(unsigned int i, unsigned int &nstep, double *x, double *y, double xmin=0, double xmax=0) override
scan a parameter i around the minimum.
int VariableIndex(const std::string &name) const override
get index of variable given a variable given a name return -1 if variable is not found
int MinosStatus() const override
MINOS status code of last Minos run status & 1 > 0 : invalid lower error status & 2 > 0 : invalid upp...
bool SetUpperLimitedVariable(unsigned int ivar, const std::string &name, double val, double step, double upper) override
set upper limit variable (override if minimizer supports them )
ROOT::Minuit2::MnUserParameterState fState
unsigned int NDim() const override
this is <= Function().NDim() which is the total number of variables (free+ constrained ones)
bool SetVariableLowerLimit(unsigned int ivar, double lower) override
set the lower-limit of an already existing variable
bool FixVariable(unsigned int ivar) override
fix an existing variable
virtual void SetMinimizer(ROOT::Minuit2::ModularFunctionMinimizer *m)
double Edm() const override
return expected distance reached from the minimum
bool Minimize() override
method to perform the minimization.
ROOT::Minuit2::FunctionMinimum * fMinimum
bool SetFixedVariable(unsigned int, const std::string &, double) override
set fixed variable (override if minimizer supports them )
bool GetHessianMatrix(double *h) const override
Fill the passed array with the Hessian matrix elements The Hessian matrix is the matrix of the second...
ROOT::Minuit2::FCNBase * fMinuitFCN
const double * MinGradient() const override
return pointer to gradient values at the minimum
void PrintResults() override
return reference to the objective function virtual const ROOT::Math::IGenFunction & Function() const;
void Clear() override
reset for consecutive minimization - implement if needed
~Minuit2Minimizer() override
Destructor (no operations)
int CovMatrixStatus() const override
return the status of the covariance matrix status = -1 : not available (inversion failed or Hesse fai...
class which holds the external user and/or internal Minuit representation of the parameters and error...
Base common class providing the API for all the minimizer Various Minimize methods are provided varyi...
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
void function(const Char_t *name_, T fun, const Char_t *docstring=0)
Definition: RExports.h:167
This file contains a specialised ROOT message handler to test for diagnostic in unit tests.
TMarker m
Definition: textangle.C:8