Logo ROOT  
Reference Guide
FitConfig.cxx
Go to the documentation of this file.
1// @(#)root/mathcore:$Id$
2// Author: L. Moneta Thu Sep 21 16:21:29 2006
3
4/**********************************************************************
5 * *
6 * Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
7 * *
8 * *
9 **********************************************************************/
10
11// Implementation file for class FitConfig
12
13#include "Fit/FitConfig.h"
14
15#include "Fit/FitResult.h"
16
17#include "Math/IParamFunction.h"
18#include "Math/Util.h"
19
20#include "Math/Minimizer.h"
21#include "Math/Factory.h"
22
23#include <cmath>
24
25#include <string>
26#include <sstream>
27
28#include "Math/Error.h"
29
30//#define DEBUG
31#ifdef DEBUG
32#endif
33
34namespace ROOT {
35
36namespace Fit {
37
38
39
40FitConfig::FitConfig(unsigned int npar) :
41 fNormErrors(false),
42 fParabErrors(false), // ensure that in any case correct parabolic errors are estimated
43 fMinosErrors(false), // do full Minos error analysis for all parameters
44 fUpdateAfterFit(true), // update after fit
45 fWeightCorr(false),
46 fSettings(std::vector<ParameterSettings>(npar) )
47{
48 // constructor implementation
49}
50
51
53{
54 // destructor implementation. No Operations
55}
56
58 // Implementation of copy constructor
59 (*this) = rhs;
60}
61
63 // Implementation of assignment operator.
64 if (this == &rhs) return *this; // time saving self-test
65
71
72 fSettings = rhs.fSettings;
74
76
77 return *this;
78}
79
81 // Implementation of setting of parameters from the result of the fit
82 // all the other options will stay the same.
83 // If the size of parameters do not match they will be re-created
84 // but in that case the bound on the parameter will be lost
85
86 unsigned int npar = result.NPar();
87 if (fSettings.size() != npar) {
88 fSettings.clear();
89 fSettings.resize(npar);
90 }
91 // fill the parameter settings
92 for (unsigned int i = 0; i < npar; ++i) {
93 if (result.IsParameterFixed(i) )
94 fSettings[i].Set(result.ParName(i), result.Value(i) );
95 else {
96 fSettings[i].Set( result.ParName(i), result.Value(i), result.Error(i) );
97 // check if parameter is bound
98 double lower = 0;
99 double upper = 0;
100 if (result.ParameterBounds(i,lower,upper) ) {
101 if (lower == -std::numeric_limits<double>::infinity()) fSettings[i].SetUpperLimit(upper);
102 else if (upper == std::numeric_limits<double>::infinity()) fSettings[i].SetLowerLimit(lower);
103 else fSettings[i].SetLimits(lower,upper);
104 }
105
106 // query if parameter needs to run Minos
107 if (result.HasMinosError(i) ) {
108 if (fMinosParams.size() == 0) {
109 fMinosErrors = true;
110 fMinosParams.reserve(npar-i);
111 }
112 fMinosParams.push_back(i);
113 }
114 }
115 }
116
117 // set information about errors
119
120 // set also minimizer type
121 // algorithm is after " / "
122 const std::string & minname = result.MinimizerType();
123 size_t pos = minname.find(" / ");
124 if (pos != std::string::npos) {
125 std::string minimType = minname.substr(0,pos);
126 std::string algoType = minname.substr(pos+3,minname.length() );
127 SetMinimizer(minimType.c_str(), algoType.c_str() );
128 }
129 else {
130 SetMinimizer(minname.c_str());
131 }
132}
133
134
135void FitConfig::SetParamsSettings(unsigned int npar, const double *params, const double * vstep ) {
136 // initialize FitConfig from given parameter values and step sizes
137 // if npar different than existing one - clear old one and create new ones
138 if (params == 0) {
139 fSettings = std::vector<ParameterSettings>(npar);
140 return;
141 }
142 // if a vector of parameters is given and parameters are not existing or are of different size
143 bool createNew = false;
144 if (npar != fSettings.size() ) {
145 fSettings.clear();
146 fSettings.reserve(npar);
147 createNew = true;
148 }
149 unsigned int i = 0;
150 const double * end = params+npar;
151 for (const double * ipar = params; ipar != end; ++ipar) {
152 double val = *ipar;
153 double step = 0;
154 if (vstep == 0) {
155 step = 0.3*std::fabs(val); // step size is 30% of par value
156 //double step = 2.0*std::fabs(val); // step size is 30% of par value
157 if (val == 0) step = 0.3;
158 }
159 else
160 step = vstep[i];
161
162 if (createNew)
163 fSettings.push_back( ParameterSettings("Par_" + ROOT::Math::Util::ToString(i), val, step ) );
164 else {
165 fSettings[i].SetValue(val);
166 fSettings[i].SetStepSize(step);
167 }
168
169 i++;
170 }
171}
172
174 // create minimizer according to the chosen configuration using the
175 // plug-in manager
176
177 // in case of empty string usesd default values
178 if (fMinimizerOpts.MinimizerType().empty())
182
183 const std::string &minimType = fMinimizerOpts.MinimizerType();
184 const std::string & algoType = fMinimizerOpts.MinimizerAlgorithm();
185
186 std::string defaultMinim = ROOT::Math::MinimizerOptions::DefaultMinimizerType();
187
189 // check if a different minimizer is used (in case a default value is passed, then set correctly in FitConfig)
190 const std::string & minim_newDefault = ROOT::Math::MinimizerOptions::DefaultMinimizerType();
191 if (defaultMinim != minim_newDefault ) fMinimizerOpts.SetMinimizerType(minim_newDefault.c_str());
192
193 if (min == 0) {
194 // if creation of minimizer failed force the use by default of Minuit
195 std::string minim2 = "Minuit";
196 if (minimType == "Minuit") minim2 = "Minuit2";
197 if (minimType != minim2 ) {
198 std::string msg = "Could not create the " + minimType + " minimizer. Try using the minimizer " + minim2;
199 MATH_WARN_MSG("FitConfig::CreateMinimizer",msg.c_str());
200 min = ROOT::Math::Factory::CreateMinimizer(minim2,"Migrad");
201 if (min == 0) {
202 MATH_ERROR_MSG("FitConfig::CreateMinimizer","Could not create the Minuit2 minimizer");
203 return 0;
204 }
205 SetMinimizer( minim2.c_str(),"Migrad");
206 }
207 else {
208 std::string msg = "Could not create the Minimizer " + minimType;
209 MATH_ERROR_MSG("FitConfig::CreateMinimizer",msg.c_str());
210 return 0;
211 }
212 }
213
214 // set default max of function calls according to the number of parameters
215 // formula from Minuit2 (adapted)
216 if (fMinimizerOpts.MaxFunctionCalls() == 0) {
217 unsigned int npar = fSettings.size();
218 int maxfcn = 1000 + 100*npar + 5*npar*npar;
220 }
221
222
223 // set default minimizer control parameters
232 // set extra options if existing
235
236 return min;
237}
238
239std::string FitConfig::MinimizerName() const
240{
241 // set minimizer type
242 std::string name = MinimizerType();
243
244 // append algorithm name for minimizer that support it
245 if ((name.find("Fumili") == std::string::npos) && (name.find("GSLMultiFit") == std::string::npos)) {
246 if (MinimizerAlgoType() != "")
247 name += " / " + MinimizerAlgoType();
248 }
249 return name;
250}
251
252void FitConfig::SetDefaultMinimizer(const char * type, const char *algo ) {
253 // set the default minimizer type and algorithms
255}
256
258 // set all the minimizer options
259 fMinimizerOpts = minopt;
260}
261
262std::vector<double> FitConfig::ParamsValues() const {
263
264 std::vector<double> params(NPar() );
265 for (unsigned int i = 0; i < params.size(); ++i) {
266 params[i] = fSettings[i].Value();
267 }
268 return params;
269}
270 } // end namespace Fit
271
272} // end namespace ROOT
#define MATH_ERROR_MSG(loc, str)
Definition: Error.h:83
#define MATH_WARN_MSG(loc, str)
Definition: Error.h:80
char name[80]
Definition: TGX11.cxx:110
int type
Definition: TGX11.cxx:121
Class describing the configuration of the fit, options and parameter settings using the ROOT::Fit::Pa...
Definition: FitConfig.h:47
void SetParamsSettings(unsigned int npar, const double *params, const double *vstep=0)
set the parameter settings from number of parameters and a vector of values and optionally step value...
Definition: FitConfig.cxx:135
std::vector< unsigned int > fMinosParams
Definition: FitConfig.h:268
FitConfig(unsigned int npar=0)
Default constructor.
Definition: FitConfig.cxx:40
std::vector< double > ParamsValues() const
return a vector of stored parameter values (i.e initial fit parameters)
Definition: FitConfig.cxx:262
const std::string & MinimizerAlgoType() const
return type of minimizer algorithms
Definition: FitConfig.h:194
void SetNormErrors(bool on=true)
set the option to normalize the error on the result according to chi2/ndf
Definition: FitConfig.h:225
void SetMinimizer(const char *type, const char *algo=0)
set minimizer type
Definition: FitConfig.h:181
void SetMinimizerOptions(const ROOT::Math::MinimizerOptions &minopt)
set all the minimizer options using class MinimizerOptions
Definition: FitConfig.cxx:257
unsigned int NPar() const
number of parameters settings
Definition: FitConfig.h:96
std::vector< ROOT::Fit::ParameterSettings > fSettings
Definition: FitConfig.h:267
std::string MinimizerName() const
return Minimizer full name (type / algorithm)
Definition: FitConfig.cxx:239
ROOT::Math::MinimizerOptions fMinimizerOpts
Definition: FitConfig.h:270
~FitConfig()
Destructor.
Definition: FitConfig.cxx:52
ROOT::Math::Minimizer * CreateMinimizer()
create a new minimizer according to chosen configuration
Definition: FitConfig.cxx:173
void SetFromFitResult(const FitResult &rhs)
Definition: FitConfig.cxx:80
static void SetDefaultMinimizer(const char *type, const char *algo=0)
static function to control default minimizer type and algorithm
Definition: FitConfig.cxx:252
const std::string & MinimizerType() const
return type of minimizer package
Definition: FitConfig.h:189
FitConfig & operator=(const FitConfig &rhs)
Definition: FitConfig.cxx:62
class containg the result of the fit and all the related information (fitted parameter values,...
Definition: FitResult.h:47
bool NormalizedErrors() const
flag to chek if errors are normalized
Definition: FitResult.h:309
bool IsParameterFixed(unsigned int ipar) const
query if a parameter is fixed
Definition: FitResult.cxx:409
double Error(unsigned int i) const
parameter error by index
Definition: FitResult.h:186
double Value(unsigned int i) const
parameter value by index
Definition: FitResult.h:179
const std::string & MinimizerType() const
minimization quantities
Definition: FitResult.h:102
bool ParameterBounds(unsigned int ipar, double &lower, double &upper) const
retrieve parameter bounds - return false if parameter is not bound
Definition: FitResult.cxx:413
bool HasMinosError(unsigned int i) const
query if parameter i has the Minos error
Definition: FitResult.cxx:369
unsigned int NPar() const
total number of parameters (abbreviation)
Definition: FitResult.h:131
std::string ParName(unsigned int i) const
name of the parameter
Definition: FitResult.cxx:426
Class, describing value, limits and step size of the parameters Provides functionality also to set/re...
static ROOT::Math::Minimizer * CreateMinimizer(const std::string &minimizerType="", const std::string &algoType="")
static method to create the corrisponding Minimizer given the string Supported Minimizers types are: ...
Definition: Factory.cxx:63
void SetMaxFunctionCalls(unsigned int maxfcn)
set maximum of function calls
static void SetDefaultMinimizer(const char *type, const char *algo=0)
int Strategy() const
strategy
const IOptions * ExtraOptions() const
return extra options (NULL pointer if they are not present)
double Tolerance() const
absolute tolerance
double Precision() const
precision in the objective funciton calculation (value <=0 means left to default)
void SetMinimizerType(const char *type)
set minimizer type
const std::string & MinimizerAlgorithm() const
type of algorithm
double ErrorDef() const
error definition
static const std::string & DefaultMinimizerType()
static const std::string & DefaultMinimizerAlgo()
const std::string & MinimizerType() const
type of minimizer
unsigned int MaxIterations() const
max iterations
unsigned int MaxFunctionCalls() const
max number of function calls
int PrintLevel() const
non-static methods for retrieving options
void SetMinimizerAlgorithm(const char *type)
set minimizer algorithm
Abstract Minimizer class, defining the interface for the various minimizer (like Minuit2,...
Definition: Minimizer.h:75
void SetMaxIterations(unsigned int maxiter)
set maximum iterations (one iteration can have many function calls)
Definition: Minimizer.h:450
void SetErrorDef(double up)
set scale for calculating the errors
Definition: Minimizer.h:463
void SetValidError(bool on)
flag to check if minimizer needs to perform accurate error analysis (e.g. run Hesse for Minuit)
Definition: Minimizer.h:466
void SetTolerance(double tol)
set the tolerance
Definition: Minimizer.h:453
void SetPrintLevel(int level)
set print level
Definition: Minimizer.h:444
void SetStrategy(int strategyLevel)
set the strategy
Definition: Minimizer.h:460
void SetPrecision(double prec)
set in the minimizer the objective function evaluation precision ( a value <=0 means the minimizer wi...
Definition: Minimizer.h:457
void SetMaxFunctionCalls(unsigned int maxfcn)
set maximum of function calls
Definition: Minimizer.h:447
void SetExtraOptions(const IOptions &extraOptions)
set only the extra options
Definition: Minimizer.h:474
TFitResultPtr Fit(FitObject *h1, TF1 *f1, Foption_t &option, const ROOT::Math::MinimizerOptions &moption, const char *goption, ROOT::Fit::DataRange &range)
Definition: HFitImpl.cxx:133
std::string ToString(const T &val)
Utility function for conversion to strings.
Definition: Util.h:50
VecExpr< UnaryOp< Fabs< T >, VecExpr< A, T, D >, T >, T, D > fabs(const VecExpr< A, T, D > &rhs)
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...