Logo ROOT  
Reference Guide
ModularFunctionMinimizer.cxx
Go to the documentation of this file.
1// @(#)root/minuit2:$Id$
2// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei, E.G.P. Bos 2003-2017
3
4/**********************************************************************
5 * *
6 * Copyright (c) 2005 LCG ROOT Math team, CERN/PH-SFT *
7 * *
8 **********************************************************************/
9
16#include "Minuit2/MinimumSeed.h"
22#include "Minuit2/MnUserFcn.h"
23#include "Minuit2/FCNBase.h"
25#include "Minuit2/MnStrategy.h"
26#include "Minuit2/MnHesse.h"
29#include "Minuit2/MnPrint.h"
30
31namespace ROOT {
32
33namespace Minuit2 {
34
35// #include "Minuit2/MnUserParametersPrint.h"
36
37FunctionMinimum ModularFunctionMinimizer::Minimize(const FCNBase &fcn, const std::vector<double> &par,
38 const std::vector<double> &err, unsigned int stra,
39 unsigned int maxfcn, double toler) const
40{
41 // minimize from FCNBase and std::vector of double's for parameter values and errors (step sizes)
42 MnUserParameterState st(par, err);
43 MnStrategy strategy(stra);
44 return Minimize(fcn, st, strategy, maxfcn, toler);
45}
46
47FunctionMinimum ModularFunctionMinimizer::Minimize(const FCNGradientBase &fcn, const std::vector<double> &par,
48 const std::vector<double> &err, unsigned int stra,
49 unsigned int maxfcn, double toler) const
50{
51 // minimize from FCNGradientBase (use analytical gradient provided in FCN)
52 // and std::vector of double's for parameter values and errors (step sizes)
53 MnUserParameterState st(par, err);
54 MnStrategy strategy(stra);
55 return Minimize(fcn, st, strategy, maxfcn, toler);
56}
57
58// move nrow before cov to avoid ambiguities when using default parameters
59FunctionMinimum ModularFunctionMinimizer::Minimize(const FCNBase &fcn, const std::vector<double> &par,
60 unsigned int nrow, const std::vector<double> &cov, unsigned int stra,
61 unsigned int maxfcn, double toler) const
62{
63 // minimize from FCNBase using std::vector for parameter error and
64 // an std::vector of size n*(n+1)/2 for the covariance matrix and n (rank of cov matrix)
65
66 MnUserParameterState st(par, cov, nrow);
67 MnStrategy strategy(stra);
68 return Minimize(fcn, st, strategy, maxfcn, toler);
69}
70
71FunctionMinimum ModularFunctionMinimizer::Minimize(const FCNGradientBase &fcn, const std::vector<double> &par,
72 unsigned int nrow, const std::vector<double> &cov, unsigned int stra,
73 unsigned int maxfcn, double toler) const
74{
75 // minimize from FCNGradientBase (use analytical gradient provided in FCN)
76 // using std::vector for parameter error and
77 // an std::vector of size n*(n+1)/2 for the covariance matrix and n (rank of cov matrix)
78
79 MnUserParameterState st(par, cov, nrow);
80 MnStrategy strategy(stra);
81 return Minimize(fcn, st, strategy, maxfcn, toler);
82}
83
85 const MnStrategy &strategy, unsigned int maxfcn, double toler) const
86{
87 // minimize from FCNBase and MnUserParameters object
88
89 MnUserParameterState st(upar);
90 return Minimize(fcn, st, strategy, maxfcn, toler);
91}
92
94 const MnStrategy &strategy, unsigned int maxfcn, double toler) const
95{
96 // minimize from FCNGradientBase (use analytical gradient provided in FCN) and MnUserParameters object
97
98 MnUserParameterState st(upar);
99 return Minimize(fcn, st, strategy, maxfcn, toler);
100}
101
103 const MnUserCovariance &cov, const MnStrategy &strategy,
104 unsigned int maxfcn, double toler) const
105{
106 // minimize from FCNBase and MnUserParameters and MnUserCovariance objects
107
108 MnUserParameterState st(upar, cov);
109 return Minimize(fcn, st, strategy, maxfcn, toler);
110}
111
113 const MnUserCovariance &cov, const MnStrategy &strategy,
114 unsigned int maxfcn, double toler) const
115{
116 // minimize from FCNGradientBase (use analytical gradient provided in FCN) and
117 // MnUserParameters MnUserCovariance objects
118
119 MnUserParameterState st(upar, cov);
120 return Minimize(fcn, st, strategy, maxfcn, toler);
121}
122
124 const MnStrategy &strategy, unsigned int maxfcn, double toler) const
125{
126 // minimize from a FCNBase and a MnUserparameterState - interface used by all the previous ones
127 // based on FCNBase. Create in this case a NumericalGradient calculator
128 // Create the minuit FCN wrapper (MnUserFcn) containing the trasformation (int<->ext)
129
130 // neeed MnUsserFcn for difference int-ext parameters
131 MnUserFcn mfcn(fcn, st.Trafo());
132 Numerical2PGradientCalculator gc(mfcn, st.Trafo(), strategy);
133
134 unsigned int npar = st.VariableParameters();
135 if (maxfcn == 0)
136 maxfcn = 200 + 100 * npar + 5 * npar * npar;
137 MinimumSeed mnseeds = SeedGenerator()(mfcn, gc, st, strategy);
138
139 return Minimize(mfcn, gc, mnseeds, strategy, maxfcn, toler);
140}
141
142// use Gradient here
144 const MnStrategy &strategy, unsigned int maxfcn, double toler) const
145{
146 // minimize from a FCNGradientBase and a MnUserparameterState - interface used by all the previous ones
147 // based on FCNGradientBase.
148 // Create in this acase an AnalyticalGradient calculator
149 // Create the minuit FCN wrapper (MnUserFcn) containing the trasformation (int<->ext)
150
151 MnUserFcn mfcn(fcn, st.Trafo());
154 // std::cout << "-- ModularFunctionMinimizer::Minimize: Internal parameter space" << std::endl;
156 } else {
157 // std::cout << "-- ModularFunctionMinimizer::Minimize: External parameter space" << std::endl;
158 gc = new AnalyticalGradientCalculator(fcn, st.Trafo());
159 }
160
161 unsigned int npar = st.VariableParameters();
162 if (maxfcn == 0)
163 maxfcn = 200 + 100 * npar + 5 * npar * npar;
164
165 // use numerical gradient to compute initial derivatives for SeedGenerator
166 Numerical2PGradientCalculator numgc(mfcn, st.Trafo(), strategy);
167 MinimumSeed mnseeds = SeedGenerator()(mfcn, numgc, st, strategy);
168
169 auto minimum = Minimize(mfcn, *gc, mnseeds, strategy, maxfcn, toler);
170
171 delete gc;
172
173 return minimum;
174}
175
177 const MinimumSeed &seed, const MnStrategy &strategy,
178 unsigned int maxfcn, double toler) const
179{
180 // Interface used by all the others for the minimization using the base MinimumBuilder class
181 // According to the contained type of MinimumBuilder the right type will be used
182
183 MnPrint print("ModularFunctionMinimizer");
184
185 const MinimumBuilder &mb = Builder();
186 // std::cout << typeid(&mb).Name() << std::endl;
187 double effective_toler = toler * mfcn.Up(); // scale tolerance with Up()
188 // avoid tolerance too smalls (than limits)
189 double eps = MnMachinePrecision().Eps2();
190 if (effective_toler < eps)
191 effective_toler = eps;
192
193 // check if maxfcn is already exhausted
194 // case already reached call limit
195 if (mfcn.NumOfCalls() >= maxfcn) {
196 print.Warn("Stop before iterating - call limit already exceeded");
197
198 return FunctionMinimum(seed, std::vector<MinimumState>(1, seed.State()), mfcn.Up(),
200 }
201
202 return mb.Minimum(mfcn, gc, seed, strategy, maxfcn, effective_toler);
203}
204
205} // namespace Minuit2
206
207} // namespace ROOT
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void gc
Similar to the AnalyticalGradientCalculator, the ExternalInternalGradientCalculator supplies Minuit w...
Interface (abstract class) defining the function to be minimized, which has to be implemented by the ...
Definition: FCNBase.h:45
virtual GradientParameterSpace gradParameterSpace() const
class holding the full result of the minimization; both internal and external (MnUserParameterState) ...
interface class for gradient calculators
virtual FunctionMinimum Minimum(const MnFcn &, const GradientCalculator &, const MinimumSeed &, const MnStrategy &, unsigned int, double) const =0
const MinimumState & State() const
Definition: MinimumSeed.h:28
Wrapper class to FCNBase interface used internally by Minuit.
Definition: MnFcn.h:30
double Up() const
Definition: MnFcn.cxx:39
unsigned int NumOfCalls() const
Definition: MnFcn.h:39
Sets the relative floating point (double) arithmetic precision.
double Eps2() const
eps2 returns 2*sqrt(eps)
void Warn(const Ts &... args)
Definition: MnPrint.h:126
API class for defining three levels of strategies: low (0), medium (1), high (>=2); acts on: Migrad (...
Definition: MnStrategy.h:27
Class containing the covariance matrix data represented as a vector of size n*(n+1)/2 Used to hide in...
Wrapper used by Minuit of FCN interface containing a reference to the transformation object.
Definition: MnUserFcn.h:25
class which holds the external user and/or internal Minuit representation of the parameters and error...
const MnUserTransformation & Trafo() const
API class for the user interaction with the parameters; serves as input to the minimizer as well as o...
virtual const MinimumBuilder & Builder() const =0
FunctionMinimum Minimize(const FCNBase &, const std::vector< double > &, const std::vector< double > &, unsigned int stra=1, unsigned int maxfcn=0, double toler=0.1) const override
virtual const MinimumSeedGenerator & SeedGenerator() const =0
class performing the numerical gradient calculation
This file contains a specialised ROOT message handler to test for diagnostic in unit tests.