Logo ROOT   6.08/07
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 #include <iostream>
34 
35 namespace ROOT {
36 
37 namespace Fit {
38 
39 
40 
41 FitConfig::FitConfig(unsigned int npar) :
42  fNormErrors(false),
43  fParabErrors(false), // ensure that in any case correct parabolic errors are estimated
44  fMinosErrors(false), // do full Minos error analysis for all parameters
45  fUpdateAfterFit(true), // update after fit
46  fWeightCorr(false),
47  fSettings(std::vector<ParameterSettings>(npar) )
48 {
49  // constructor implementation
50 }
51 
52 
54 {
55  // destructor implementation. No Operations
56 }
57 
59  // Implementation of copy constructor
60  (*this) = rhs;
61 }
62 
64  // Implementation of assignment operator.
65  if (this == &rhs) return *this; // time saving self-test
66 
72 
73  fSettings = rhs.fSettings;
75 
77 
78  return *this;
79 }
80 
82  // Implementation of setting of parameters from the result of the fit
83  // all the other options will stay the same.
84  // If the size of parameters do not match they will be re-created
85  // but in that case the bound on the parameter will be lost
86 
87  unsigned int npar = result.NPar();
88  if (fSettings.size() != npar) {
89  fSettings.clear();
90  fSettings.resize(npar);
91  }
92  // fill the parameter settings
93  for (unsigned int i = 0; i < npar; ++i) {
94  if (result.IsParameterFixed(i) )
95  fSettings[i].Set(result.ParName(i), result.Value(i) );
96  else {
97  fSettings[i].Set( result.ParName(i), result.Value(i), result.Error(i) );
98  // check if parameter is bound
99  double lower = 0;
100  double upper = 0;
101  if (result.ParameterBounds(i,lower,upper) ) {
102  if (lower == -std::numeric_limits<double>::infinity()) fSettings[i].SetUpperLimit(upper);
103  else if (upper == std::numeric_limits<double>::infinity()) fSettings[i].SetLowerLimit(lower);
104  else fSettings[i].SetLimits(lower,upper);
105  }
106 
107  // query if parameter needs to run Minos
108  if (result.HasMinosError(i) ) {
109  if (fMinosParams.size() == 0) {
110  fMinosErrors = true;
111  fMinosParams.reserve(npar-i);
112  }
113  fMinosParams.push_back(i);
114  }
115  }
116  }
117 
118  // set information about errors
119  SetNormErrors( result.NormalizedErrors() );
120 
121  // set also minimizer type
122  // algorithm is after " / "
123  const std::string & minname = result.MinimizerType();
124  size_t pos = minname.find(" / ");
125  if (pos != std::string::npos) {
126  std::string minimType = minname.substr(0,pos);
127  std::string algoType = minname.substr(pos+3,minname.length() );
128  SetMinimizer(minimType.c_str(), algoType.c_str() );
129  }
130  else {
131  SetMinimizer(minname.c_str());
132  }
133 }
134 
135 
136 void FitConfig::SetParamsSettings(unsigned int npar, const double *params, const double * vstep ) {
137  // initialize FitConfig from given parameter values and step sizes
138  // if npar different than existing one - clear old one and create new ones
139  if (params == 0) {
140  fSettings = std::vector<ParameterSettings>(npar);
141  return;
142  }
143  // if a vector of parameters is given and parameters are not existing or are of different size
144  bool createNew = false;
145  if (npar != fSettings.size() ) {
146  fSettings.clear();
147  fSettings.reserve(npar);
148  createNew = true;
149  }
150  unsigned int i = 0;
151  const double * end = params+npar;
152  for (const double * ipar = params; ipar != end; ++ipar) {
153  double val = *ipar;
154  double step = 0;
155  if (vstep == 0) {
156  step = 0.3*std::fabs(val); // step size is 30% of par value
157  //double step = 2.0*std::fabs(val); // step size is 30% of par value
158  if (val == 0) step = 0.3;
159  }
160  else
161  step = vstep[i];
162 
163  if (createNew)
164  fSettings.push_back( ParameterSettings("Par_" + ROOT::Math::Util::ToString(i), val, step ) );
165  else {
166  fSettings[i].SetValue(val);
167  fSettings[i].SetStepSize(step);
168  }
169 
170  i++;
171  }
172 }
173 
175  // initialize from model function
176  // set the parameters values from the function
177  unsigned int npar = func.NPar();
178  const double * begin = func.Parameters();
179  if (begin == 0) {
180  fSettings = std::vector<ParameterSettings>(npar);
181  return;
182  }
183 
184  fSettings.clear();
185  fSettings.reserve(npar);
186  const double * end = begin+npar;
187  unsigned int i = 0;
188  for (const double * ipar = begin; ipar != end; ++ipar) {
189  double val = *ipar;
190  double step = 0.3*std::fabs(val); // step size is 30% of par value
191  //double step = 2.0*std::fabs(val); // step size is 30% of par value
192  if (val == 0) step = 0.3;
193 
194  fSettings.push_back( ParameterSettings(func.ParameterName(i), val, step ) );
195 #ifdef DEBUG
196  std::cout << "FitConfig: add parameter " << func.ParameterName(i) << " val = " << val << std::endl;
197 #endif
198  i++;
199  }
200 
201 }
202 
204  // create minimizer according to the chosen configuration using the
205  // plug-in manager
206 
207  const std::string & minimType = fMinimizerOpts.MinimizerType();
208  const std::string & algoType = fMinimizerOpts.MinimizerAlgorithm();
209 
210  std::string defaultMinim = ROOT::Math::MinimizerOptions::DefaultMinimizerType();
211  ROOT::Math::Minimizer * min = ROOT::Math::Factory::CreateMinimizer(minimType, algoType);
212  // check if a different minimizer is used (in case a default value is passed, then set correctly in FitConfig)
213  const std::string & minim_newDefault = ROOT::Math::MinimizerOptions::DefaultMinimizerType();
214  if (defaultMinim != minim_newDefault ) fMinimizerOpts.SetMinimizerType(minim_newDefault.c_str());
215 
216  if (min == 0) {
217  // if creation of minimizer failed force the use by default of Minuit
218  std::string minim2 = "Minuit";
219  if (minimType == "Minuit") minim2 = "Minuit2";
220  if (minimType != minim2 ) {
221  std::string msg = "Could not create the " + minimType + " minimizer. Try using the minimizer " + minim2;
222  MATH_WARN_MSG("FitConfig::CreateMinimizer",msg.c_str());
223  min = ROOT::Math::Factory::CreateMinimizer(minim2,"Migrad");
224  if (min == 0) {
225  MATH_ERROR_MSG("FitConfig::CreateMinimizer","Could not create the Minuit2 minimizer");
226  return 0;
227  }
228  SetMinimizer( minim2.c_str(),"Migrad");
229  }
230  else {
231  std::string msg = "Could not create the Minimizer " + minimType;
232  MATH_ERROR_MSG("FitConfig::CreateMinimizer",msg.c_str());
233  return 0;
234  }
235  }
236 
237  // set default max of function calls according to the number of parameters
238  // formula from Minuit2 (adapted)
239  if (fMinimizerOpts.MaxFunctionCalls() == 0) {
240  unsigned int npar = fSettings.size();
241  int maxfcn = 1000 + 100*npar + 5*npar*npar;
243  }
244 
245 
246  // set default minimizer control parameters
252  min->SetValidError( fParabErrors );
255 
256 
257  return min;
258 }
259 
260 void FitConfig::SetDefaultMinimizer(const char * type, const char *algo ) {
261  // set the default minimizer type and algorithms
263 }
264 
266  // set all the minimizer options
267  fMinimizerOpts = minopt;
268 }
269 
270 
271  } // end namespace Fit
272 
273 } // end namespace ROOT
274 
FitConfig(unsigned int npar=0)
Default constructor.
Definition: FitConfig.cxx:41
virtual const double * Parameters() const =0
Access the parameter values.
std::string ParName(unsigned int i) const
name of the parameter
Definition: FitResult.cxx:439
unsigned int MaxFunctionCalls() const
max number of function calls
const std::string & MinimizerAlgorithm() const
type of algorithm
void SetMaxIterations(unsigned int maxiter)
set maximum iterations (one iteration can have many function calls)
Definition: Minimizer.h:459
void SetErrorDef(double up)
set scale for calculating the errors
Definition: Minimizer.h:472
This namespace contains pre-defined functions to be used in conjuction with TExecutor::Map and TExecu...
Definition: StringConv.hxx:21
void SetMinimizerType(const char *type)
set minimizer type
ROOT::Math::Minimizer * CreateMinimizer()
create a new minimizer according to chosen configuration
Definition: FitConfig.cxx:203
double Error(unsigned int i) const
parameter error by index
Definition: FitResult.h:191
unsigned int NPar() const
total number of parameters (abbreviation)
Definition: FitResult.h:136
Class, describing value, limits and step size of the parameters Provides functionality also to set/re...
double Value(unsigned int i) const
parameter value by index
Definition: FitResult.h:184
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
ROOT::Math::MinimizerOptions fMinimizerOpts
Definition: FitConfig.h:237
void SetValidError(bool on)
flag to check if minimizer needs to perform accurate error analysis (e.g. run Hesse for Minuit) ...
Definition: Minimizer.h:475
STL namespace.
#define MATH_WARN_MSG(loc, str)
Definition: Error.h:47
unsigned int MaxIterations() const
max iterations
const std::string & MinimizerType() const
type of minimizer
~FitConfig()
Destructor.
Definition: FitConfig.cxx:53
FitConfig & operator=(const FitConfig &rhs)
Definition: FitConfig.cxx:63
bool HasMinosError(unsigned int i) const
query if parameter i has the Minos error
Definition: FitResult.cxx:382
void CreateParamsSettings(const ROOT::Math::IParamMultiFunction &func)
set the parameter settings from a model function.
Definition: FitConfig.cxx:174
Abstract Minimizer class, defining the interface for the various minimizer (like Minuit2, Minuit, GSL, etc..) Plug-in&#39;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.
Definition: Minimizer.h:86
int PrintLevel() const
non-static methods for retrieving options
static void SetDefaultMinimizer(const char *type, const char *algo=0)
static function to control default minimizer type and algorithm
Definition: FitConfig.cxx:260
#define MATH_ERROR_MSG(loc, str)
Definition: Error.h:50
int Strategy() const
strategy
bool NormalizedErrors() const
flag to chek if errors are normalized
Definition: FitResult.h:304
double Precision() const
precision in the objective funciton calculation (value <=0 means left to default) ...
virtual unsigned int NPar() const =0
Return the number of Parameters.
VecExpr< UnaryOp< Fabs< T >, VecExpr< A, T, D >, T >, T, D > fabs(const VecExpr< A, T, D > &rhs)
void SetMinimizer(const char *type, const char *algo=0)
set minimizer type
Definition: FitConfig.h:152
void SetMaxFunctionCalls(unsigned int maxfcn)
set maximum of function calls
IParamFunction interface (abstract class) describing multi-dimensional parameteric functions It is a ...
static const std::string & DefaultMinimizerType()
void SetMinimizerOptions(const ROOT::Math::MinimizerOptions &minopt)
set all the minimizer options using class MinimizerOptions
Definition: FitConfig.cxx:265
const std::string & MinimizerType() const
minimization quantities
Definition: FitResult.h:107
void SetMaxFunctionCalls(unsigned int maxfcn)
set maximum of function calls
Definition: Minimizer.h:456
class containg the result of the fit and all the related information (fitted parameter values...
Definition: FitResult.h:52
double Tolerance() const
absolute tolerance
void SetTolerance(double tol)
set the tolerance
Definition: Minimizer.h:462
TFitResultPtr Fit(FitObject *h1, TF1 *f1, Foption_t &option, const ROOT::Math::MinimizerOptions &moption, const char *goption, ROOT::Fit::DataRange &range)
Definition: HFitImpl.cxx:134
bool IsParameterFixed(unsigned int ipar) const
query if a parameter is fixed
Definition: FitResult.cxx:422
int type
Definition: TGX11.cxx:120
double func(double *x, double *p)
Definition: stressTF1.cxx:213
void SetStrategy(int strategyLevel)
set the strategy
Definition: Minimizer.h:469
std::string ToString(const T &val)
Utility function for conversion to strings.
Definition: Util.h:42
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:136
void SetNormErrors(bool on=true)
set the option to normalize the error on the result according to chi2/ndf
Definition: FitConfig.h:192
double ErrorDef() const
error definition
void SetFromFitResult(const FitResult &rhs)
Definition: FitConfig.cxx:81
std::vector< ROOT::Fit::ParameterSettings > fSettings
Definition: FitConfig.h:234
bool ParameterBounds(unsigned int ipar, double &lower, double &upper) const
retrieve parameter bounds - return false if parameter is not bound
Definition: FitResult.cxx:426
double result[121]
void SetPrecision(double prec)
set in the minimizer the objective function evaluation precision ( a value <=0 means the minimizer wi...
Definition: Minimizer.h:466
void SetPrintLevel(int level)
set print level
Definition: Minimizer.h:453
virtual std::string ParameterName(unsigned int i) const
Return the name of the i-th parameter (starting from zero) Overwrite if want to avoid the default nam...
static void SetDefaultMinimizer(const char *type, const char *algo=0)
std::vector< unsigned int > fMinosParams
Definition: FitConfig.h:235
Class describing the configuration of the fit, options and parameter settings using the ROOT::Fit::Pa...
Definition: FitConfig.h:51