Logo ROOT   6.16/01
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
18
20
22
23#include "TMath.h"
24
25#include <vector>
26
27namespace 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*/
46class FitConfig {
47
48public:
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 */
160
161
162
163 /**
164 access to the minimizer control parameter (non const method)
165 */
167
168
169#ifndef __CINT__ // this method fails on Windows
170 /**
171 set all the minimizer options using class MinimizerOptions
172 */
174#endif
175
176
177 /**
178 set minimizer type
179 */
180 void SetMinimizer(const char * type, const char * algo = 0) {
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
251protected:
252
253
254private:
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 */
int type
Definition: TGX11.cxx:120
Class describing the configuration of the fit, options and parameter settings using the ROOT::Fit::Pa...
Definition: FitConfig.h:46
const std::vector< unsigned int > & MinosParams() const
return vector of parameter indeces for which the Minos Error will be computed
Definition: FitConfig.h:215
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
ParameterSettings & ParSettings(unsigned int i)
get the parameter settings for the i-th parameter (non-const method)
Definition: FitConfig.h:80
bool UpdateAfterFit() const
Update configuration after a fit using the FitResult.
Definition: FitConfig.h:208
std::vector< unsigned int > fMinosParams
Definition: FitConfig.h:263
FitConfig(unsigned int npar=0)
Default constructor.
Definition: FitConfig.cxx:41
void SetMinosErrors(bool on=true)
set Minos erros computation to be performed after fitting
Definition: FitConfig.h:226
std::vector< double > ParamsValues() const
return a vector of stored parameter values (i.e initial fit parameters)
Definition: FitConfig.cxx:241
const std::string & MinimizerAlgoType() const
return type of minimizer algorithms
Definition: FitConfig.h:193
std::vector< ROOT::Fit::ParameterSettings > & ParamsSettings()
get the vector of parameter settings (non-const method)
Definition: FitConfig.h:90
void SetNormErrors(bool on=true)
set the option to normalize the error on the result according to chi2/ndf
Definition: FitConfig.h:220
void SetParamsSettings(const std::vector< ROOT::Fit::ParameterSettings > &pars)
Definition: FitConfig.h:144
void SetMinimizer(const char *type, const char *algo=0)
set minimizer type
Definition: FitConfig.h:180
bool NormalizeErrors() const
flag to check if resulting errors are be normalized according to chi2/ndf
Definition: FitConfig.h:199
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
bool ParabErrors() const
do analysis for parabolic errors
Definition: FitConfig.h:202
void SetMinimizerOptions(const ROOT::Math::MinimizerOptions &minopt)
set all the minimizer options using class MinimizerOptions
Definition: FitConfig.cxx:236
void SetWeightCorrection(bool on=true)
apply the weight correction for error matric computation
Definition: FitConfig.h:229
unsigned int NPar() const
number of parameters settings
Definition: FitConfig.h:95
void SetUpdateAfterFit(bool on=true)
Update configuration after a fit using the FitResult.
Definition: FitConfig.h:240
std::vector< ROOT::Fit::ParameterSettings > fSettings
Definition: FitConfig.h:262
bool UseWeightCorrection() const
Apply Weight correction for error matrix computation.
Definition: FitConfig.h:211
const std::vector< ROOT::Fit::ParameterSettings > & ParamsSettings() const
get the vector of parameter settings (const method)
Definition: FitConfig.h:85
ROOT::Math::MinimizerOptions fMinimizerOpts
Definition: FitConfig.h:265
~FitConfig()
Destructor.
Definition: FitConfig.cxx:53
ROOT::Math::Minimizer * CreateMinimizer()
create a new minimizer according to chosen configuration
Definition: FitConfig.cxx:174
void SetParabErrors(bool on=true)
set parabolic erros
Definition: FitConfig.h:223
void SetFromFitResult(const FitResult &rhs)
Definition: FitConfig.cxx:81
void CreateParamsSettings(const ROOT::Math::IParamMultiFunctionTempl< T > &func)
set the parameter settings from a model function.
Definition: FitConfig.h:108
static void SetDefaultMinimizer(const char *type, const char *algo=0)
static function to control default minimizer type and algorithm
Definition: FitConfig.cxx:231
const std::string & MinimizerType() const
return type of minimizer package
Definition: FitConfig.h:188
const ParameterSettings & ParSettings(unsigned int i) const
get the parameter settings for the i-th parameter (const method)
Definition: FitConfig.h:75
FitConfig & operator=(const FitConfig &rhs)
Definition: FitConfig.cxx:63
ROOT::Math::MinimizerOptions & MinimizerOptions()
access to the minimizer control parameter (non const method)
Definition: FitConfig.h:166
bool MinosErrors() const
do minos errros analysis on the parameters
Definition: FitConfig.h:205
class containg the result of the fit and all the related information (fitted parameter values,...
Definition: FitResult.h:48
Class, describing value, limits and step size of the parameters Provides functionality also to set/re...
virtual const double * Parameters() const =0
Access the parameter values.
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...
virtual unsigned int NPar() const =0
Return the number of Parameters.
IParamFunction interface (abstract class) describing multi-dimensional parameteric functions It is a ...
void SetMinimizerType(const char *type)
set minimizer type
const std::string & MinimizerAlgorithm() const
type of algorithm
const std::string & MinimizerType() const
type of minimizer
void SetMinimizerAlgorithm(const char *type)
set minimizer algorithm
Abstract Minimizer class, defining the interface for the various minimizer (like Minuit2,...
Definition: Minimizer.h:78
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
Namespace for new Math classes and functions.
VecExpr< UnaryOp< Fabs< T >, VecExpr< A, T, D >, T >, T, D > fabs(const VecExpr< A, T, D > &rhs)
Namespace for new ROOT classes and functions.
Definition: StringConv.hxx:21
RooCmdArg Minimizer(const char *type, const char *alg=0)