Logo ROOT   6.14/05
Reference Guide
FitConfig.h
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 // Header file for class FitConfig
12 
13 #ifndef ROOT_Fit_FitConfig
14 #define ROOT_Fit_FitConfig
15 
16 
17 #include "Fit/ParameterSettings.h"
18 
19 #include "Math/MinimizerOptions.h"
20 
21 #include "Math/IParamFunctionfwd.h"
22 
23 #include "TMath.h"
24 
25 #include <vector>
26 
27 namespace ROOT {
28 
29  namespace Math {
30 
31  class Minimizer;
32  class MinimizerOptions;
33  }
34 
35  namespace Fit {
36 
37  class FitResult;
38 
39 //___________________________________________________________________________________
40 /**
41  Class describing the configuration of the fit, options and parameter settings
42  using the ROOT::Fit::ParameterSettings class
43 
44  @ingroup FitMain
45 */
46 class FitConfig {
47 
48 public:
49 
50  /**
51  Default constructor
52  */
53  FitConfig (unsigned int npar = 0);
54 
55 
56  /*
57  Copy constructor
58  */
59  FitConfig(const FitConfig & rhs);
60 
61  /**
62  Destructor
63  */
64  ~FitConfig ();
65 
66  /*
67  Assignment operator
68  */
69  FitConfig & operator= (const FitConfig & rhs);
70 
71 
72  /**
73  get the parameter settings for the i-th parameter (const method)
74  */
75  const ParameterSettings & ParSettings(unsigned int i) const { return fSettings.at(i); }
76 
77  /**
78  get the parameter settings for the i-th parameter (non-const method)
79  */
80  ParameterSettings & ParSettings(unsigned int i) { return fSettings.at(i); }
81 
82  /**
83  get the vector of parameter settings (const method)
84  */
85  const std::vector<ROOT::Fit::ParameterSettings> & ParamsSettings() const { return fSettings; }
86 
87  /**
88  get the vector of parameter settings (non-const method)
89  */
90  std::vector<ROOT::Fit::ParameterSettings> & ParamsSettings() { return fSettings; }
91 
92  /**
93  number of parameters settings
94  */
95  unsigned int NPar() const { return fSettings.size(); }
96 
97  /**
98  return a vector of stored parameter values (i.e initial fit parameters)
99  */
100  std::vector<double> ParamsValues() const;
101 
102 
103  /**
104  set the parameter settings from a model function.
105  Create always new parameter setting list from a given model function
106  */
107  template <class T>
109  // initialize from model function
110  // set the parameters values from the function
111  unsigned int npar = func.NPar();
112  const double *begin = func.Parameters();
113  if (begin == 0) {
114  fSettings = std::vector<ParameterSettings>(npar);
115  return;
116  }
117 
118  fSettings.clear();
119  fSettings.reserve(npar);
120  const double *end = begin + npar;
121  unsigned int i = 0;
122  for (const double *ipar = begin; ipar != end; ++ipar) {
123  double val = *ipar;
124  double step = 0.3 * fabs(val); // step size is 30% of par value
125  // double step = 2.0*fabs(val); // step size is 30% of par value
126  if (val == 0) step = 0.3;
127 
128  fSettings.push_back(ParameterSettings(func.ParameterName(i), val, step));
129 #ifdef DEBUG
130  std::cout << "FitConfig: add parameter " << func.ParameterName(i) << " val = " << val << std::endl;
131 #endif
132  i++;
133  }
134  }
135 
136  /**
137  set the parameter settings from number of parameters and a vector of values and optionally step values. If there are not existing or number of parameters does not match existing one, create a new parameter setting list.
138  */
139  void SetParamsSettings(unsigned int npar, const double * params, const double * vstep = 0);
140 
141  /*
142  Set the parameter settings from a vector of parameter settings
143  */
144  void SetParamsSettings (const std::vector<ROOT::Fit::ParameterSettings>& pars ) {
145  fSettings = pars;
146  }
147 
148 
149  /*
150  Set the parameter settings from a fit Result
151  */
152  void SetFromFitResult (const FitResult & rhs);
153 
154 
155 
156  /**
157  create a new minimizer according to chosen configuration
158  */
159  ROOT::Math::Minimizer * CreateMinimizer();
160 
161 
162 
163  /**
164  access to the minimizer control parameter (non const method)
165  */
166  ROOT::Math::MinimizerOptions & MinimizerOptions() { return fMinimizerOpts; }
167 
168 
169 #ifndef __CINT__ // this method fails on Windows
170  /**
171  set all the minimizer options using class MinimizerOptions
172  */
173  void SetMinimizerOptions(const ROOT::Math::MinimizerOptions & minopt);
174 #endif
175 
176 
177  /**
178  set minimizer type
179  */
180  void SetMinimizer(const char * type, const char * algo = 0) {
181  if (type) fMinimizerOpts.SetMinimizerType(type);
182  if (algo) fMinimizerOpts.SetMinimizerAlgorithm(algo);
183  }
184 
185  /**
186  return type of minimizer package
187  */
188  const std::string & MinimizerType() const { return fMinimizerOpts.MinimizerType(); }
189 
190  /**
191  return type of minimizer algorithms
192  */
193  const std::string & MinimizerAlgoType() const { return fMinimizerOpts.MinimizerAlgorithm(); }
194 
195 
196  /**
197  flag to check if resulting errors are be normalized according to chi2/ndf
198  */
199  bool NormalizeErrors() const { return fNormErrors; }
200 
201  ///do analysis for parabolic errors
202  bool ParabErrors() const { return fParabErrors; }
203 
204  ///do minos errros analysis on the parameters
205  bool MinosErrors() const { return fMinosErrors; }
206 
207  ///Update configuration after a fit using the FitResult
208  bool UpdateAfterFit() const { return fUpdateAfterFit; }
209 
210  ///Apply Weight correction for error matrix computation
211  bool UseWeightCorrection() const { return fWeightCorr; }
212 
213 
214  /// return vector of parameter indeces for which the Minos Error will be computed
215  const std::vector<unsigned int> & MinosParams() const { return fMinosParams; }
216 
217  /**
218  set the option to normalize the error on the result according to chi2/ndf
219  */
220  void SetNormErrors(bool on = true) { fNormErrors= on; }
221 
222  ///set parabolic erros
223  void SetParabErrors(bool on = true) { fParabErrors = on; }
224 
225  ///set Minos erros computation to be performed after fitting
226  void SetMinosErrors(bool on = true) { fMinosErrors = on; }
227 
228  ///apply the weight correction for error matric computation
229  void SetWeightCorrection(bool on = true) { fWeightCorr = on; }
230 
231  /// set parameter indeces for running Minos
232  /// this can be used for running Minos on a subset of parameters - otherwise is run on all of them
233  /// if MinosErrors() is set
234  void SetMinosErrors(const std::vector<unsigned int> & paramInd ) {
235  fMinosErrors = true;
236  fMinosParams = paramInd;
237  }
238 
239  ///Update configuration after a fit using the FitResult
240  void SetUpdateAfterFit(bool on = true) { fUpdateAfterFit = on; }
241 
242 
243  /**
244  static function to control default minimizer type and algorithm
245  */
246  static void SetDefaultMinimizer(const char * type, const char * algo = 0);
247 
248 
249 
250 
251 protected:
252 
253 
254 private:
255 
256  bool fNormErrors; // flag for error normalization
257  bool fParabErrors; // get correct parabolic errors estimate (call Hesse after minimizing)
258  bool fMinosErrors; // do full error analysis using Minos
259  bool fUpdateAfterFit; // update the configuration after a fit using the result
260  bool fWeightCorr; // apply correction to errors for weights fits
261 
262  std::vector<ROOT::Fit::ParameterSettings> fSettings; // vector with the parameter settings
263  std::vector<unsigned int> fMinosParams; // vector with the parameter indeces for running Minos
264 
265  ROOT::Math::MinimizerOptions fMinimizerOpts; //minimizer control parameters including name and algo type
266 
267 };
268 
269  } // end namespace Fit
270 
271 } // end namespace ROOT
272 
273 
274 #endif /* ROOT_Fit_FitConfig */
void SetMinosErrors(const std::vector< unsigned int > &paramInd)
set parameter indeces for running Minos this can be used for running Minos on a subset of parameters ...
Definition: FitConfig.h:234
virtual const double * Parameters() const =0
Access the parameter values.
Namespace for new ROOT classes and functions.
Definition: StringConv.hxx:21
void SetUpdateAfterFit(bool on=true)
Update configuration after a fit using the FitResult.
Definition: FitConfig.h:240
Class, describing value, limits and step size of the parameters Provides functionality also to set/re...
bool NormalizeErrors() const
flag to check if resulting errors are be normalized according to chi2/ndf
Definition: FitConfig.h:199
const std::vector< unsigned int > & MinosParams() const
return vector of parameter indeces for which the Minos Error will be computed
Definition: FitConfig.h:215
unsigned int NPar() const
number of parameters settings
Definition: FitConfig.h:95
ROOT::Math::MinimizerOptions fMinimizerOpts
Definition: FitConfig.h:265
ROOT::Math::MinimizerOptions & MinimizerOptions()
access to the minimizer control parameter (non const method)
Definition: FitConfig.h:166
const ParameterSettings & ParSettings(unsigned int i) const
get the parameter settings for the i-th parameter (const method)
Definition: FitConfig.h:75
void CreateParamsSettings(const ROOT::Math::IParamMultiFunctionTempl< T > &func)
set the parameter settings from a model function.
Definition: FitConfig.h:108
bool UseWeightCorrection() const
Apply Weight correction for error matrix computation.
Definition: FitConfig.h:211
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:78
bool UpdateAfterFit() const
Update configuration after a fit using the FitResult.
Definition: FitConfig.h:208
bool ParabErrors() const
do analysis for parabolic errors
Definition: FitConfig.h:202
ParameterSettings & ParSettings(unsigned int i)
get the parameter settings for the i-th parameter (non-const method)
Definition: FitConfig.h:80
void SetMinosErrors(bool on=true)
set Minos erros computation to be performed after fitting
Definition: FitConfig.h:226
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:180
RooCmdArg Minimizer(const char *type, const char *alg=0)
const std::vector< ROOT::Fit::ParameterSettings > & ParamsSettings() const
get the vector of parameter settings (const method)
Definition: FitConfig.h:85
IParamFunction interface (abstract class) describing multi-dimensional parameteric functions It is a ...
class containg the result of the fit and all the related information (fitted parameter values...
Definition: FitResult.h:48
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
int type
Definition: TGX11.cxx:120
void SetWeightCorrection(bool on=true)
apply the weight correction for error matric computation
Definition: FitConfig.h:229
const std::string & MinimizerType() const
return type of minimizer package
Definition: FitConfig.h:188
std::vector< ROOT::Fit::ParameterSettings > & ParamsSettings()
get the vector of parameter settings (non-const method)
Definition: FitConfig.h:90
Namespace for new Math classes and functions.
Binding & operator=(OUT(*fun)(void))
bool MinosErrors() const
do minos errros analysis on the parameters
Definition: FitConfig.h:205
void SetParamsSettings(const std::vector< ROOT::Fit::ParameterSettings > &pars)
Definition: FitConfig.h:144
void SetNormErrors(bool on=true)
set the option to normalize the error on the result according to chi2/ndf
Definition: FitConfig.h:220
std::vector< ROOT::Fit::ParameterSettings > fSettings
Definition: FitConfig.h:262
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...
void SetParabErrors(bool on=true)
set parabolic erros
Definition: FitConfig.h:223
std::vector< unsigned int > fMinosParams
Definition: FitConfig.h:263
Class describing the configuration of the fit, options and parameter settings using the ROOT::Fit::Pa...
Definition: FitConfig.h:46
const std::string & MinimizerAlgoType() const
return type of minimizer algorithms
Definition: FitConfig.h:193