Logo ROOT  
Reference Guide
Fitter.h
Go to the documentation of this file.
1// @(#)root/mathcore:$Id$
2// Author: L. Moneta Wed Aug 30 11:05:19 2006
3
4/**********************************************************************
5 * *
6 * Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
7 * *
8 * *
9 **********************************************************************/
10
11// Header file for class Fitter
12
13#ifndef ROOT_Fit_Fitter
14#define ROOT_Fit_Fitter
15
16/**
17@defgroup Fit Fitting and Parameter Estimation
18
19Classes used for fitting (regression analysis) and estimation of parameter values given a data sample.
20
21@ingroup MathCore
22
23*/
24
25#include "Fit/BinData.h"
26#include "Fit/UnBinData.h"
27#include "Fit/FitConfig.h"
29#include "Fit/FitResult.h"
30#include "Math/IParamFunction.h"
31#include <memory>
32
33namespace ROOT {
34
35
36 namespace Math {
37 class Minimizer;
38
39 // should maybe put this in a FitMethodFunctionfwd file
40 template<class FunctionType> class BasicFitMethodFunction;
41
42 // define the normal and gradient function
45
46 }
47
48 /**
49 Namespace for the fitting classes
50 @ingroup Fit
51 */
52
53 namespace Fit {
54
55/**
56 @defgroup FitMain User Fitting classes
57
58 Main Classes used for fitting a given data set
59 @ingroup Fit
60*/
61
62
63//___________________________________________________________________________________
64/**
65 Fitter class, entry point for performing all type of fits.
66 Fits are performed using the generic ROOT::Fit::Fitter::Fit method.
67 The inputs are the data points and a model function (using a ROOT::Math::IParamFunction)
68 The result of the fit is returned and kept internally in the ROOT::Fit::FitResult class.
69 The configuration of the fit (parameters, options, etc...) are specified in the
70 ROOT::Math::FitConfig class.
71 After fitting the config of the fit will be modified to have the new values the resulting
72 parameter of the fit with step sizes equal to the errors. FitConfig can be preserved with
73 initial parameters by calling FitConfig.SetUpdateAfterFit(false);
74
75 @ingroup FitMain
76*/
77class Fitter {
78
79public:
80
82 template <class T>
84#ifdef R__HAS_VECCORE
87#else
90#endif
94
97
98
99 /**
100 Default constructor
101 */
102 Fitter () {}
103
104 /**
105 Constructor from a result
106 */
107 Fitter (const std::shared_ptr<FitResult> & result);
108
109
110 /**
111 Destructor
112 */
114
115 /**
116 Copy constructor (disabled, class is not copyable)
117 */
118 Fitter(const Fitter &) = delete;
119
120 /**
121 Assignment operator (disabled, class is not copyable)
122 */
123 Fitter & operator = (const Fitter &) = delete;
124
125
126public:
127
128 /**
129 fit a data set using any generic model function
130 If data set is binned a least square fit is performed
131 If data set is unbinned a maximum likelihood fit (not extended) is done
132 Pre-requisite on the function:
133 it must implement the 1D or multidimensional parametric function interface.
134 Note that both the input data and the function object are copied by the Fitter.
135 */
136 template <class Data, class Function,
137 class cond = typename std::enable_if<!(std::is_same<Function, ROOT::EExecutionPolicy>::value ||
140 bool Fit(const Data &data, const Function &func,
142 {
143 SetFunction(func);
144 return Fit(data, executionPolicy);
145 }
146
147 /**
148 Fit a binned data set using a least square fit.
149 Note that the provided input data are copied in the Fitter class.
150 Use the next function (passing a `shared_ptr` to the BinData class if you want to avoid
151 copying.
152 */
154 return LeastSquareFit(data, executionPolicy);
155 }
156
157 /**
158 Fit a binned data set using a least square fit.
159 Pass the input data using a `shared_ptr` for NOT copying the input data.
160 */
161 bool Fit(const std::shared_ptr<BinData> & data, const ROOT::EExecutionPolicy &executionPolicy = ROOT::EExecutionPolicy::kSequential) {
162 return LeastSquareFit(data, executionPolicy);
163 }
164
165 /**
166 Fit a binned data set using a least square fit copying the input data.
167 */
169 SetData(data);
170 return DoLeastSquareFit(executionPolicy);
171 }
172 /**
173 Fit a binned data set using a least square fit NOT copying the input data.
174 */
175 bool LeastSquareFit(const std::shared_ptr<BinData> & data, const ROOT::EExecutionPolicy &executionPolicy = ROOT::EExecutionPolicy::kSequential) {
176 SetData(data);
177 return DoLeastSquareFit(executionPolicy);
178 }
179
180 /**
181 Fit an un-binned data set using the negative log-likelihood method.
182 This function copies the input data.
183 */
184 bool Fit(const UnBinData & data, bool extended = false, const ROOT::EExecutionPolicy &executionPolicy = ROOT::EExecutionPolicy::kSequential) {
185 return LikelihoodFit(data, extended, executionPolicy);
186 }
187 /**
188 Fit an un-binned data set using the negative log-likelihood method.
189 This function uses a `shared_ptr` to avoid copying the input data.
190 */
191 bool Fit(const std::shared_ptr<UnBinData> & data, bool extended = false, const ROOT::EExecutionPolicy &executionPolicy = ROOT::EExecutionPolicy::kSequential) {
192 return LikelihoodFit(data, extended, executionPolicy);
193 }
194
195 /**
196 Binned Likelihood fit copying the input data.
197 Default is extended.
198 */
199 bool LikelihoodFit(const BinData &data, bool extended = true,
201 SetData(data);
202 return DoBinnedLikelihoodFit(extended, executionPolicy);
203 }
204 /**
205 Binned Likelihood fit using a `shared_ptr` for NOT copying the input data.
206 Default is extended.
207 */
208 bool LikelihoodFit(const std::shared_ptr<BinData> &data, bool extended = true,
210 SetData(data);
211 return DoBinnedLikelihoodFit(extended, executionPolicy);
212 }
213 /**
214 Un-binned Likelihood fit copying the input data
215 Default is NOT extended
216 */
217 bool LikelihoodFit(const UnBinData & data, bool extended = false, const ROOT::EExecutionPolicy &executionPolicy = ROOT::EExecutionPolicy::kSequential) {
218 SetData(data);
219 return DoUnbinnedLikelihoodFit(extended, executionPolicy);
220 }
221 /**
222 Un-binned Likelihood fit using a `shared_ptr` for NOT copying the input data.
223 Default is NOT extended
224 */
225 bool LikelihoodFit(const std::shared_ptr<UnBinData> & data, bool extended = false, const ROOT::EExecutionPolicy &executionPolicy = ROOT::EExecutionPolicy::kSequential) {
226 SetData(data);
227 return DoUnbinnedLikelihoodFit(extended, executionPolicy);
228 }
229
230 /**
231 Likelihood fit given a data set (Binned or Un-binned) using any generic model function.
232 This interface copies the input data and the model function object
233 */
234 template < class Data , class Function>
235 bool LikelihoodFit( const Data & data, const Function & func, bool extended) {
236 SetFunction(func);
237 return LikelihoodFit(data, extended);
238 }
239
240 /**
241 Do a linear fit copying the input data
242 */
243 bool LinearFit(const BinData & data) {
244 SetData(data);
245 return DoLinearFit();
246 }
247 /**
248 Do a linear fit using a `shared_ptr` for NOT copying the input data
249 */
250 bool LinearFit(const std::shared_ptr<BinData> & data) {
251 SetData(data);
252 return DoLinearFit();
253 }
254
255 /**
256 Fit using the a generic FCN function as a C++ callable object implementing
257 double () (const double *)
258 Note that the function dimension (i.e. the number of parameter) is needed in this case
259 For the options see documentation for following methods FitFCN(IMultiGenFunction & fcn,..)
260 */
261 template <class Function>
262 bool FitFCN(unsigned int npar, Function & fcn, const double * params = 0, unsigned int dataSize = 0, bool chi2fit = false);
263
264 /**
265 Set a generic FCN function as a C++ callable object implementing
266 double () (const double *)
267 Note that the function dimension (i.e. the number of parameter) is needed in this case
268 For the options see documentation for following methods FitFCN(IMultiGenFunction & fcn,..)
269 */
270 template <class Function>
271 bool SetFCN(unsigned int npar, Function & fcn, const double * params = 0, unsigned int dataSize = 0, bool chi2fit = false);
272
273 /**
274 Fit using the given FCN function represented by a multi-dimensional function interface
275 (ROOT::Math::IMultiGenFunction).
276 Give optionally the initial parameter values, data size to have the fit Ndf correctly
277 set in the FitResult and flag specifying if it is a chi2 fit.
278 Note that if the parameters values are not given (params=0) the
279 current parameter settings are used. The parameter settings can be created before
280 by using the FitConfig::SetParamsSetting. If they have not been created they are created
281 automatically when the params pointer is not zero.
282 Note that passing a params != 0 will set the parameter settings to the new value AND also the
283 step sizes to some pre-defined value (stepsize = 0.3 * abs(parameter_value) )
284 */
285 bool FitFCN(const ROOT::Math::IMultiGenFunction &fcn, const double *params = nullptr, unsigned int dataSize = 0, bool chi2fit = false);
286
287 /**
288 Fit using a FitMethodFunction interface. Same as method above, but now extra information
289 can be taken from the function class
290 */
291 bool FitFCN(const ROOT::Math::FitMethodFunction & fcn, const double *params = nullptr);
292
293 /**
294 Set the FCN function represented by a multi-dimensional function interface
295 (ROOT::Math::IMultiGenFunction) and optionally the initial parameters
296 See also note above for the initial parameters for FitFCN
297 */
298 bool SetFCN(const ROOT::Math::IMultiGenFunction &fcn, const double *params = nullptr, unsigned int dataSize = 0, bool chi2fit = false);
299
300 /**
301 Set the FCN function represented by a multi-dimensional function interface
302 (ROOT::Math::IMultiGenFunction) and optionally the initial parameters
303 See also note above for the initial parameters for FitFCN
304 With this interface we pass in addition a ModelFunction that will be attached to the FitResult and
305 used to compute confidence interval of the fit
306 */
307 bool SetFCN(const ROOT::Math::IMultiGenFunction &fcn, const IModelFunction & func, const double *params = nullptr,
308 unsigned int dataSize = 0, bool chi2fit = false);
309
310 /**
311 Set the objective function (FCN) using a FitMethodFunction interface.
312 Same as method above, but now extra information can be taken from the function class
313 */
314 bool SetFCN(const ROOT::Math::FitMethodFunction & fcn, const double *params = nullptr);
315
316 /**
317 Fit using the given FCN function representing a multi-dimensional gradient function
318 interface (ROOT::Math::IMultiGradFunction). In this case the minimizer will use the
319 gradient information provided by the function.
320 For the options same consideration as in the previous method
321 */
322 bool FitFCN(const ROOT::Math::IMultiGradFunction &fcn, const double *params = nullptr, unsigned int dataSize = 0, bool chi2fit = false);
323
324 /**
325 Fit using a FitMethodGradFunction interface. Same as method above, but now extra information
326 can be taken from the function class
327 */
328 bool FitFCN(const ROOT::Math::FitMethodGradFunction & fcn, const double *params = nullptr);
329
330 /**
331 Set the FCN function represented by a multi-dimensional gradient function interface
332 (ROOT::Math::IMultiGradFunction) and optionally the initial parameters
333 See also note above for the initial parameters for FitFCN
334 */
335 bool SetFCN(const ROOT::Math::IMultiGradFunction &fcn, const double *params = nullptr, unsigned int dataSize = 0, bool chi2fit = false);
336
337 /**
338 Set the FCN function represented by a multi-dimensional gradient function interface
339 (ROOT::Math::IMultiGradFunction) and optionally the initial parameters
340 See also note above for the initial parameters for FitFCN
341 With this interface we pass in addition a ModelFunction that will be attached to the FitResult and
342 used to compute confidence interval of the fit
343 */
344 bool SetFCN(const ROOT::Math::IMultiGradFunction &fcn, const IModelFunction &func, const double *params = nullptr,
345 unsigned int dataSize = 0, bool chi2fit = false);
346
347 /**
348 Set the objective function (FCN) using a FitMethodGradFunction interface.
349 Same as method above, but now extra information can be taken from the function class
350 */
351 bool SetFCN(const ROOT::Math::FitMethodGradFunction & fcn, const double *params = nullptr);
352
353
354 /**
355 fit using user provided FCN with Minuit-like interface
356 If npar = 0 it is assumed that the parameters are specified in the parameter settings created before
357 For the options same consideration as in the previous method
358 */
359 typedef void (* MinuitFCN_t )(int &npar, double *gin, double &f, double *u, int flag);
360 bool FitFCN( MinuitFCN_t fcn, int npar = 0, const double *params = nullptr, unsigned int dataSize = 0, bool chi2fit = false);
361
362 /**
363 set objective function using user provided FCN with Minuit-like interface
364 If npar = 0 it is assumed that the parameters are specified in the parameter settings created before
365 For the options same consideration as in the previous method
366 */
367 bool SetFCN( MinuitFCN_t fcn, int npar = 0, const double *params = nullptr, unsigned int dataSize = 0, bool chi2fit = false);
368
369 /**
370 Perform a fit with the previously set FCN function. Require SetFCN before
371 */
372 bool FitFCN();
373
374 /**
375 Perform a simple FCN evaluation. FitResult will be modified and contain the value of the FCN
376 */
377 bool EvalFCN();
378
379
380
381 /**
382 Set the fitted function (model function) from a parametric function interface
383 */
384 void SetFunction(const IModelFunction & func, bool useGradient = false);
385
386 /**
387 Set the fitted function (model function) from a vectorized parametric function interface
388 */
389#ifdef R__HAS_VECCORE
390 template <class NotCompileIfScalarBackend = std::enable_if<!(std::is_same<double, ROOT::Double_v>::value)>>
391 void SetFunction(const IModelFunction_v &func, bool useGradient = false);
392
393 template <class NotCompileIfScalarBackend = std::enable_if<!(std::is_same<double, ROOT::Double_v>::value)>>
394 void SetFunction(const IGradModelFunction_v &func, bool useGradient = true);
395#endif
396 /**
397 Set the fitted function from a parametric 1D function interface
398 */
399 void SetFunction(const IModel1DFunction & func, bool useGradient = false);
400
401 /**
402 Set the fitted function (model function) from a parametric gradient function interface
403 */
404 void SetFunction(const IGradModelFunction & func, bool useGradient = true);
405 /**
406 Set the fitted function from 1D gradient parametric function interface
407 */
408 void SetFunction(const IGradModel1DFunction & func, bool useGradient = true);
409
410
411 /**
412 get fit result
413 */
414 const FitResult & Result() const {
415 assert( fResult.get() );
416 return *fResult;
417 }
418
419
420 /**
421 perform an error analysis on the result using the Hessian
422 Errors are obtained from the inverse of the Hessian matrix
423 To be called only after fitting and when a minimizer supporting the Hessian calculations is used
424 otherwise an error (false) is returned.
425 A new FitResult with the Hessian result will be produced
426 */
427 bool CalculateHessErrors();
428
429 /**
430 perform an error analysis on the result using MINOS
431 To be called only after fitting and when a minimizer supporting MINOS is used
432 otherwise an error (false) is returned.
433 The result will be appended in the fit result class
434 Optionally a vector of parameter indices can be passed for selecting
435 the parameters to analyse using FitConfig::SetMinosErrors
436 */
438
439 /**
440 access to the fit configuration (const method)
441 */
442 const FitConfig & Config() const { return fConfig; }
443
444 /**
445 access to the configuration (non const method)
446 */
447 FitConfig & Config() { return fConfig; }
448
449 /**
450 query if fit is binned. In cse of false the fit can be unbinned
451 or is not defined (like in case of fitting through a ROOT::Fit::Fitter::FitFCN)
452 */
453 bool IsBinFit() const { return fBinFit; }
454
455 /**
456 return pointer to last used minimizer
457 (is NULL in case fit is not yet done)
458 This pointer is guaranteed to be valid as far as the fitter class is valid and a new fit is not redone.
459 To be used only after fitting.
460 The pointer should not be stored and will be invalided after performing a new fitting.
461 In this case a new instance of ROOT::Math::Minimizer will be re-created and can be
462 obtained calling again GetMinimizer()
463 */
465
466 /**
467 return pointer to last used objective function
468 (is NULL in case fit is not yet done)
469 This pointer will be valid as far as the fitter class
470 has not been deleted. To be used after the fitting.
471 The pointer should not be stored and will be invalided after performing a new fitting.
472 In this case a new instance of the function pointer will be re-created and can be
473 obtained calling again GetFCN()
474 */
476 return fObjFunction.get();
477 }
478
479
480 /**
481 apply correction in the error matrix for the weights for likelihood fits
482 This method can be called only after a fit. The
483 passed function (loglw2) is a log-likelihood function implemented using the
484 sum of weight squared
485 When using FitConfig.SetWeightCorrection() this correction is applied
486 automatically when doing a likelihood fit (binned or unbinned)
487 */
488 bool ApplyWeightCorrection(const ROOT::Math::IMultiGenFunction & loglw2, bool minimizeW2L=false);
489
490
491protected:
492
493
494 /// least square fit
496 /// binned likelihood fit
497 bool DoBinnedLikelihoodFit(bool extended = true, const ROOT::EExecutionPolicy &executionPolicy = ROOT::EExecutionPolicy::kSequential);
498 /// un-binned likelihood fit
499 bool DoUnbinnedLikelihoodFit( bool extended = false, const ROOT::EExecutionPolicy &executionPolicy = ROOT::EExecutionPolicy::kSequential);
500 /// linear least square fit
501 bool DoLinearFit();
502 /// Set Objective function
503 bool DoSetFCN(bool useExtFCN, const ROOT::Math::IMultiGenFunction &fcn, const double *params, unsigned int dataSize,
504 bool chi2fit);
505
506 // initialize the minimizer
507 bool DoInitMinimizer();
508 /// do minimization
509 template<class ObjFunc_t>
510 bool DoMinimization(std::unique_ptr<ObjFunc_t> f, const ROOT::Math::IMultiGenFunction * chifunc = nullptr);
511 // do minimization for weighted likelihood fits
512 template<class ObjFunc_t>
513 bool DoWeightMinimization(std::unique_ptr<ObjFunc_t> f, const ROOT::Math::IMultiGenFunction * chifunc = nullptr);
514 // do minimization after having set the objective function
515 bool DoMinimization(const ROOT::Math::IMultiGenFunction * chifunc = nullptr);
516 // update config after fit
517 void DoUpdateFitConfig();
518 // update minimizer options for re-fitting
519 bool DoUpdateMinimizerOptions(bool canDifferentMinim = true);
520 // get function calls from the FCN
521 int GetNCallsFromFCN();
522
523 /// Set the input data for the fit using a shared ptr (No Copying)
524 template <class Data>
525 void SetData(const std::shared_ptr<Data> & data) {
526 fData = std::static_pointer_cast<Data>(data);
527 }
528
529 /// Set the input data for the fit (Copying the given data object)
530 template <class Data>
531 void SetData(const Data & data) {
532 auto dataClone = std::make_shared<Data>(data);
533 SetData(dataClone);
534 }
535
536 /// look at the user provided FCN and get data and model function is
537 /// they derive from ROOT::Fit FCN classes
538 void ExamineFCN();
539
540
541 /// internal functions to get data set and model function from FCN
542 /// useful for fits done with customized FCN classes
543 template <class ObjFuncType>
544 bool GetDataFromFCN();
545
546 /// return pointer to used objective function
547 /// if using an external one use external, otherwise use the one stored
548 /// in shared ptr
551 }
552
553private:
554
555 bool fUseGradient = false; ///< flag to indicate if using gradient or not
556
557 bool fBinFit = false; ///< flag to indicate if fit is binned
558 ///< in case of false the fit is unbinned or undefined)
559 ///< flag it is used to compute chi2 for binned likelihood fit
560
561 int fFitType = 0; ///< type of fit (0 undefined, 1 least square, 2 likelihood)
562
563 int fDataSize = 0; ///< size of data sets (need for Fumili or LM fitters)
564
565 FitConfig fConfig; ///< fitter configuration (options and parameter settings)
566
567 std::shared_ptr<IModelFunction_v> fFunc_v; ///<! copy of the fitted function containing on output the fit result
568
569 std::shared_ptr<IModelFunction> fFunc; ///<! copy of the fitted function containing on output the fit result
570
571 std::shared_ptr<ROOT::Fit::FitResult> fResult; ///<! pointer to the object containing the result of the fit
572
573 std::shared_ptr<ROOT::Math::Minimizer> fMinimizer; ///<! pointer to used minimizer
574
575 std::shared_ptr<ROOT::Fit::FitData> fData; ///<! pointer to the fit data (binned or unbinned data)
576
577 std::shared_ptr<ROOT::Math::IMultiGenFunction> fObjFunction; ///<! pointer to used objective function
578
579 const ROOT::Math::IMultiGenFunction * fExtObjFunction = nullptr; ///<! pointer to an external FCN
580
581};
582
583
584// internal functions to get data set and model function from FCN
585// useful for fits done with customized FCN classes
586template <class ObjFuncType>
588 const ObjFuncType * objfunc = dynamic_cast<const ObjFuncType*>(ObjFunction());
589 if (objfunc) {
590 fFunc = objfunc->ModelFunctionPtr();
591 fData = objfunc->DataPtr();
592 return true;
593 }
594 else {
595 return false;
596 }
597}
598
599#ifdef R__HAS_VECCORE
600template <class NotCompileIfScalarBackend>
601void Fitter::SetFunction(const IModelFunction_v &func, bool useGradient)
602{
603 fUseGradient = useGradient;
604 if (fUseGradient) {
605 const IGradModelFunction_v *gradFunc = dynamic_cast<const IGradModelFunction_v *>(&func);
606 if (gradFunc) {
607 SetFunction(*gradFunc, true);
608 return;
609 } else {
610 MATH_WARN_MSG("Fitter::SetFunction",
611 "Requested function does not provide gradient - use it as non-gradient function ");
612 }
613 }
614
615 // set the fit model function (clone the given one and keep a copy )
616 // std::cout << "set a non-grad function" << std::endl;
617 fUseGradient = false;
618 fFunc_v = std::shared_ptr<IModelFunction_v>(dynamic_cast<IModelFunction_v *>(func.Clone()));
619 assert(fFunc_v);
620
621 // creates the parameter settings
623 fFunc.reset();
624}
625
626template <class NotCompileIfScalarBackend>
627void Fitter::SetFunction(const IGradModelFunction_v &func, bool useGradient)
628{
629 fUseGradient = useGradient;
630
631 // set the fit model function (clone the given one and keep a copy )
632 fFunc_v = std::shared_ptr<IModelFunction_v>(dynamic_cast<IGradModelFunction_v *>(func.Clone()));
633 assert(fFunc_v);
634
635 // creates the parameter settings
637 fFunc.reset();
638}
639#endif
640
641 } // end namespace Fit
642
643} // end namespace ROOT
644
645// implementation of inline methods
646
647
648#ifndef __CINT__
649
650#include "Math/WrappedFunction.h"
651
652template<class Function>
653bool ROOT::Fit::Fitter::FitFCN(unsigned int npar, Function & f, const double * par, unsigned int datasize,bool chi2fit) {
655 if (!DoSetFCN(false, wf, par, datasize, chi2fit))
656 return false;
657 return FitFCN();
658}
659template<class Function>
660bool ROOT::Fit::Fitter::SetFCN(unsigned int npar, Function & f, const double * par, unsigned int datasize,bool chi2fit) {
662 return DoSetFCN(false, wf, par, datasize, chi2fit);
663}
664
665
666
667
668#endif // endif __CINT__
669
670#endif /* ROOT_Fit_Fitter */
#define MATH_WARN_MSG(loc, str)
Definition: Error.h:80
#define f(i)
Definition: RSha256.hxx:104
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
Double_t(* Function)(Double_t)
Definition: Functor.C:4
Class describing the binned data sets : vectors of x coordinates, y values and optionally error on y ...
Definition: BinData.h:52
Class describing the configuration of the fit, options and parameter settings using the ROOT::Fit::Pa...
Definition: FitConfig.h:47
void CreateParamsSettings(const ROOT::Math::IParamMultiFunctionTempl< T > &func)
set the parameter settings from a model function.
Definition: FitConfig.h:109
class containing the result of the fit and all the related information (fitted parameter values,...
Definition: FitResult.h:47
Fitter class, entry point for performing all type of fits.
Definition: Fitter.h:77
bool LikelihoodFit(const std::shared_ptr< UnBinData > &data, bool extended=false, const ROOT::EExecutionPolicy &executionPolicy=ROOT::EExecutionPolicy::kSequential)
Un-binned Likelihood fit using a shared_ptr for NOT copying the input data.
Definition: Fitter.h:225
bool LinearFit(const BinData &data)
Do a linear fit copying the input data.
Definition: Fitter.h:243
bool DoSetFCN(bool useExtFCN, const ROOT::Math::IMultiGenFunction &fcn, const double *params, unsigned int dataSize, bool chi2fit)
Set Objective function.
Definition: Fitter.cxx:137
bool LeastSquareFit(const std::shared_ptr< BinData > &data, const ROOT::EExecutionPolicy &executionPolicy=ROOT::EExecutionPolicy::kSequential)
Fit a binned data set using a least square fit NOT copying the input data.
Definition: Fitter.h:175
bool EvalFCN()
Perform a simple FCN evaluation.
Definition: Fitter.cxx:314
const ROOT::Math::IMultiGenFunction * fExtObjFunction
! pointer to an external FCN
Definition: Fitter.h:579
Fitter & operator=(const Fitter &)=delete
Assignment operator (disabled, class is not copyable)
bool FitFCN()
Perform a fit with the previously set FCN function.
Definition: Fitter.cxx:295
void DoUpdateFitConfig()
Definition: Fitter.cxx:859
const ROOT::Math::IMultiGenFunction * ObjFunction() const
return pointer to used objective function if using an external one use external, otherwise use the on...
Definition: Fitter.h:549
bool DoMinimization(std::unique_ptr< ObjFunc_t > f, const ROOT::Math::IMultiGenFunction *chifunc=nullptr)
do minimization
Definition: Fitter.cxx:837
int fDataSize
size of data sets (need for Fumili or LM fitters)
Definition: Fitter.h:563
bool DoUnbinnedLikelihoodFit(bool extended=false, const ROOT::EExecutionPolicy &executionPolicy=ROOT::EExecutionPolicy::kSequential)
un-binned likelihood fit
Definition: Fitter.cxx:466
void SetData(const Data &data)
Set the input data for the fit (Copying the given data object)
Definition: Fitter.h:531
ROOT::Math::IParamMultiFunction IModelFunction_v
Definition: Fitter.h:88
bool Fit(const BinData &data, const ROOT::EExecutionPolicy &executionPolicy=ROOT::EExecutionPolicy::kSequential)
Fit a binned data set using a least square fit.
Definition: Fitter.h:153
std::shared_ptr< ROOT::Math::Minimizer > fMinimizer
! pointer to used minimizer
Definition: Fitter.h:573
bool DoWeightMinimization(std::unique_ptr< ObjFunc_t > f, const ROOT::Math::IMultiGenFunction *chifunc=nullptr)
Definition: Fitter.cxx:846
bool LikelihoodFit(const Data &data, const Function &func, bool extended)
Likelihood fit given a data set (Binned or Un-binned) using any generic model function.
Definition: Fitter.h:235
bool DoBinnedLikelihoodFit(bool extended=true, const ROOT::EExecutionPolicy &executionPolicy=ROOT::EExecutionPolicy::kSequential)
binned likelihood fit
Definition: Fitter.cxx:386
int fFitType
type of fit (0 undefined, 1 least square, 2 likelihood)
Definition: Fitter.h:561
ROOT::Math::IMultiGenFunction * GetFCN() const
return pointer to last used objective function (is NULL in case fit is not yet done) This pointer wil...
Definition: Fitter.h:475
ROOT::Math::IParamGradFunction IGradModel1DFunction
Definition: Fitter.h:93
std::shared_ptr< ROOT::Fit::FitData > fData
! pointer to the fit data (binned or unbinned data)
Definition: Fitter.h:575
ROOT::Math::Minimizer * GetMinimizer() const
return pointer to last used minimizer (is NULL in case fit is not yet done) This pointer is guarantee...
Definition: Fitter.h:464
ROOT::Math::IMultiGenFunction BaseFunc
Definition: Fitter.h:95
FitConfig & Config()
access to the configuration (non const method)
Definition: Fitter.h:447
bool fUseGradient
flag to indicate if using gradient or not
Definition: Fitter.h:555
bool fBinFit
flag to indicate if fit is binned in case of false the fit is unbinned or undefined) flag it is used ...
Definition: Fitter.h:557
bool SetFCN(unsigned int npar, Function &fcn, const double *params=0, unsigned int dataSize=0, bool chi2fit=false)
Set a generic FCN function as a C++ callable object implementing double () (const double *) Note that...
Definition: Fitter.h:660
void(* MinuitFCN_t)(int &npar, double *gin, double &f, double *u, int flag)
fit using user provided FCN with Minuit-like interface If npar = 0 it is assumed that the parameters ...
Definition: Fitter.h:359
bool IsBinFit() const
query if fit is binned.
Definition: Fitter.h:453
bool LinearFit(const std::shared_ptr< BinData > &data)
Do a linear fit using a shared_ptr for NOT copying the input data.
Definition: Fitter.h:250
std::shared_ptr< ROOT::Math::IMultiGenFunction > fObjFunction
! pointer to used objective function
Definition: Fitter.h:577
bool Fit(const std::shared_ptr< BinData > &data, const ROOT::EExecutionPolicy &executionPolicy=ROOT::EExecutionPolicy::kSequential)
Fit a binned data set using a least square fit.
Definition: Fitter.h:161
const FitResult & Result() const
get fit result
Definition: Fitter.h:414
bool ApplyWeightCorrection(const ROOT::Math::IMultiGenFunction &loglw2, bool minimizeW2L=false)
apply correction in the error matrix for the weights for likelihood fits This method can be called on...
Definition: Fitter.cxx:885
ROOT::Math::IMultiGradFunction BaseGradFunc
Definition: Fitter.h:96
void ExamineFCN()
look at the user provided FCN and get data and model function is they derive from ROOT::Fit FCN class...
Definition: Fitter.cxx:978
const FitConfig & Config() const
access to the fit configuration (const method)
Definition: Fitter.h:442
void SetData(const std::shared_ptr< Data > &data)
Set the input data for the fit using a shared ptr (No Copying)
Definition: Fitter.h:525
bool DoLeastSquareFit(const ROOT::EExecutionPolicy &executionPolicy=ROOT::EExecutionPolicy::kSequential)
least square fit
Definition: Fitter.cxx:335
ROOT::Math::IParamMultiFunction IModelFunction
Definition: Fitter.h:81
ROOT::Math::IParamFunction IModel1DFunction
Definition: Fitter.h:92
bool LikelihoodFit(const BinData &data, bool extended=true, const ROOT::EExecutionPolicy &executionPolicy=ROOT::EExecutionPolicy::kSequential)
Binned Likelihood fit copying the input data.
Definition: Fitter.h:199
std::shared_ptr< IModelFunction_v > fFunc_v
! copy of the fitted function containing on output the fit result
Definition: Fitter.h:567
ROOT::Math::IParamMultiGradFunction IGradModelFunction_v
Definition: Fitter.h:89
bool LikelihoodFit(const std::shared_ptr< BinData > &data, bool extended=true, const ROOT::EExecutionPolicy &executionPolicy=ROOT::EExecutionPolicy::kSequential)
Binned Likelihood fit using a shared_ptr for NOT copying the input data.
Definition: Fitter.h:208
std::shared_ptr< ROOT::Fit::FitResult > fResult
! pointer to the object containing the result of the fit
Definition: Fitter.h:571
bool GetDataFromFCN()
internal functions to get data set and model function from FCN useful for fits done with customized F...
Definition: Fitter.h:587
ROOT::Math::IParamMultiGradFunction IGradModelFunction
Definition: Fitter.h:91
bool CalculateMinosErrors()
perform an error analysis on the result using MINOS To be called only after fitting and when a minimi...
Definition: Fitter.cxx:619
~Fitter()
Destructor.
Definition: Fitter.h:113
Fitter(const Fitter &)=delete
Copy constructor (disabled, class is not copyable)
bool DoUpdateMinimizerOptions(bool canDifferentMinim=true)
Definition: Fitter.cxx:764
bool Fit(const Data &data, const Function &func, const ROOT::EExecutionPolicy &executionPolicy=ROOT::EExecutionPolicy::kSequential)
fit a data set using any generic model function If data set is binned a least square fit is performed...
Definition: Fitter.h:140
bool Fit(const UnBinData &data, bool extended=false, const ROOT::EExecutionPolicy &executionPolicy=ROOT::EExecutionPolicy::kSequential)
Fit an un-binned data set using the negative log-likelihood method.
Definition: Fitter.h:184
void SetFunction(const IModelFunction &func, bool useGradient=false)
Set the fitted function (model function) from a parametric function interface.
Definition: Fitter.cxx:59
bool CalculateHessErrors()
perform an error analysis on the result using the Hessian Errors are obtained from the inverse of the...
Definition: Fitter.cxx:556
FitConfig fConfig
fitter configuration (options and parameter settings)
Definition: Fitter.h:565
Fitter()
Default constructor.
Definition: Fitter.h:102
std::shared_ptr< IModelFunction > fFunc
! copy of the fitted function containing on output the fit result
Definition: Fitter.h:569
bool SetFCN(const ROOT::Math::FitMethodGradFunction &fcn, const double *params=nullptr)
Set the objective function (FCN) using a FitMethodGradFunction interface.
bool LeastSquareFit(const BinData &data, const ROOT::EExecutionPolicy &executionPolicy=ROOT::EExecutionPolicy::kSequential)
Fit a binned data set using a least square fit copying the input data.
Definition: Fitter.h:168
bool FitFCN(const ROOT::Math::FitMethodGradFunction &fcn, const double *params=nullptr)
Fit using a FitMethodGradFunction interface.
bool Fit(const std::shared_ptr< UnBinData > &data, bool extended=false, const ROOT::EExecutionPolicy &executionPolicy=ROOT::EExecutionPolicy::kSequential)
Fit an un-binned data set using the negative log-likelihood method.
Definition: Fitter.h:191
bool LikelihoodFit(const UnBinData &data, bool extended=false, const ROOT::EExecutionPolicy &executionPolicy=ROOT::EExecutionPolicy::kSequential)
Un-binned Likelihood fit copying the input data Default is NOT extended.
Definition: Fitter.h:217
bool DoLinearFit()
linear least square fit
Definition: Fitter.cxx:539
bool DoInitMinimizer()
Definition: Fitter.cxx:718
int GetNCallsFromFCN()
Definition: Fitter.cxx:869
Class describing the un-binned data sets (just x coordinates values) of any dimensions.
Definition: UnBinData.h:46
FitMethodFunction class Interface for objective functions (like chi2 and likelihood used in the fit) ...
Documentation for the abstract class IBaseFunctionMultiDim.
Definition: IFunction.h:62
Interface (abstract class) for multi-dimensional functions providing a gradient calculation.
Definition: IFunction.h:343
Specialized IParamFunction interface (abstract class) for one-dimensional parametric functions It is ...
Interface (abstract class) for parametric gradient multi-dimensional functions providing in addition ...
Interface (abstract class) for parametric one-dimensional gradient functions providing in addition to...
Abstract Minimizer class, defining the interface for the various minimizer (like Minuit2,...
Definition: Minimizer.h:75
Template class to wrap any C++ callable object implementing operator() (const double * x) in a multi-...
RooCmdArg Minimizer(const char *type, const char *alg=nullptr)
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
Namespace for new Math classes and functions.
void(off) SmallVectorTemplateBase< T
BasicFitMethodFunction< ROOT::Math::IMultiGenFunction > FitMethodFunction
Definition: Fitter.h:43
BasicFitMethodFunction< ROOT::Math::IMultiGradFunction > FitMethodGradFunction
Definition: Fitter.h:44
This file contains a specialised ROOT message handler to test for diagnostic in unit tests.