Logo ROOT  
Reference Guide
FitResult.cxx
Go to the documentation of this file.
1// @(#)root/mathcore:$Id$
2// Author: L. Moneta Wed Aug 30 11:05:34 2006
3
4/**********************************************************************
5 * *
6 * Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
7 * *
8 * *
9 **********************************************************************/
10
11// Implementation file for class FitResult
12
13#include "Fit/FitResult.h"
14
15#include "Fit/FitConfig.h"
16
17#include "Fit/BinData.h"
18
19//#include "Fit/Chi2FCN.h"
20
21#include "Math/Minimizer.h"
22
23#include "Math/IParamFunction.h"
25
28
29#include "TMath.h"
31#include "Math/Error.h"
32
33#include <cassert>
34#include <cmath>
35#include <iostream>
36#include <iomanip>
37
38namespace ROOT {
39
40 namespace Fit {
41
42
43const int gInitialResultStatus = -99; // use this special convention to flag it when printing result
44
46 fValid(false), fNormalized(false), fNFree(0), fNdf(0), fNCalls(0),
47 fStatus(-1), fCovStatus(0), fVal(0), fEdm(-1), fChi2(-1)
48{
49 // Default constructor implementation.
50}
51
53 fValid(false),
54 fNormalized(false),
55 fNFree(0),
56 fNdf(0),
57 fNCalls(0),
58 fStatus(gInitialResultStatus),
59 fCovStatus(0),
60 fVal(0),
61 fEdm(-1),
62 fChi2(-1),
63 fFitFunc(0),
64 fParams(std::vector<double>( fconfig.NPar() ) ),
65 fErrors(std::vector<double>( fconfig.NPar() ) ),
66 fParNames(std::vector<std::string> ( fconfig.NPar() ) )
67{
68 // create a Fit result from a fit config (i.e. with initial parameter values
69 // and errors equal to step values
70 // The model function is NULL in this case
71
72 // set minimizer type and algorithm
73 fMinimType = fconfig.MinimizerType();
74 // append algorithm name for minimizer that support it
75 if ( (fMinimType.find("Fumili") == std::string::npos) &&
76 (fMinimType.find("GSLMultiFit") == std::string::npos)
77 ) {
78 if (fconfig.MinimizerAlgoType() != "") fMinimType += " / " + fconfig.MinimizerAlgoType();
79 }
80
81 // get parameter values and errors (step sizes)
82 unsigned int npar = fconfig.NPar();
83 for (unsigned int i = 0; i < npar; ++i ) {
84 const ParameterSettings & par = fconfig.ParSettings(i);
85 fParams[i] = par.Value();
86 fErrors[i] = par.StepSize();
87 fParNames[i] = par.Name();
88 if (par.IsFixed() ) fFixedParams[i] = true;
89 else fNFree++;
90 if (par.IsBound() ) {
91 double lower = (par.HasLowerLimit()) ? par.LowerLimit() : - std::numeric_limits<double>::infinity() ;
92 double upper = (par.HasUpperLimit()) ? par.UpperLimit() : std::numeric_limits<double>::infinity() ;
93 fBoundParams[i] = fParamBounds.size();
94 fParamBounds.push_back(std::make_pair(lower,upper));
95 }
96 }
97 std::cout << "create fit result from config - nfree " << fNFree << std::endl;
98}
99
100void FitResult::FillResult(const std::shared_ptr<ROOT::Math::Minimizer> & min, const FitConfig & fconfig, const std::shared_ptr<IModelFunction> & func,
101 bool isValid, unsigned int sizeOfData, bool binnedFit, const ROOT::Math::IMultiGenFunction * chi2func, unsigned int ncalls )
102{
103 // Fill the FitResult after minimization using result from Minimizers
104
105 // minimizer must exist
106 assert(min);
107
108 fValid = isValid;
109 fNFree= min->NFree();
110 fNCalls = min->NCalls();
111 fStatus = min->Status();
112 fCovStatus= min->CovMatrixStatus();
113 fVal = min->MinValue();
114 fEdm = min->Edm();
115
116 fMinimizer= min;
117 fFitFunc = func;
118
119 fMinimType = fconfig.MinimizerName();
120
121 // replace ncalls if minimizer does not support it (they are taken then from the FitMethodFunction)
122 if (fNCalls == 0) fNCalls = ncalls;
123
124 const unsigned int npar = min->NDim();
125 if (npar == 0) return;
126
127 if (min->X() )
128 fParams = std::vector<double>(min->X(), min->X() + npar);
129 else {
130 // case minimizer does not provide minimum values (it failed) take from configuration
131 fParams.resize(npar);
132 for (unsigned int i = 0; i < npar; ++i ) {
133 fParams[i] = ( fconfig.ParSettings(i).Value() );
134 }
135 }
136
137 if (sizeOfData > min->NFree() ) fNdf = sizeOfData - min->NFree();
138
139
140 // set right parameters in function (in case minimizer did not do before)
141 // do also when fit is not valid
142 if (func ) {
143 // I think we can avoid cloning the model function
144 //fFitFunc = dynamic_cast<IModelFunction *>( func->Clone() );
145 //assert(fFitFunc);
146 fFitFunc->SetParameters(&fParams.front());
147 }
148 else {
149 // when no fFitFunc is present take parameters from FitConfig
150 fParNames.resize( npar );
151 for (unsigned int i = 0; i < npar; ++i ) {
152 fParNames[i] = fconfig.ParSettings(i).Name();
153 }
154 }
155
156
157 // check for fixed or limited parameters
158 unsigned int nfree = 0;
159 if (!fParamBounds.empty()) fParamBounds.clear();
160 for (unsigned int ipar = 0; ipar < npar; ++ipar) {
161 const ParameterSettings & par = fconfig.ParSettings(ipar);
162 if (par.IsFixed() ) fFixedParams[ipar] = true;
163 else nfree++;
164 if (par.IsBound() ) {
165 double lower = (par.HasLowerLimit()) ? par.LowerLimit() : - std::numeric_limits<double>::infinity() ;
166 double upper = (par.HasUpperLimit()) ? par.UpperLimit() : std::numeric_limits<double>::infinity() ;
167 fBoundParams[ipar] = fParamBounds.size();
168 fParamBounds.push_back(std::make_pair(lower,upper));
169 }
170 }
171 // check if nfree (from FitConfig) and fNFree (from minimizer) are consistent
172 if (nfree != fNFree ) {
173 MATH_ERROR_MSG("FitResult","FitConfiguration and Minimizer result are not consistent");
174 std::cout << "Number of free parameters from FitConfig = " << nfree << std::endl;
175 std::cout << "Number of free parameters from Minimizer = " << fNFree << std::endl;
176 }
177
178 // if flag is binned compute a chi2 when a chi2 function is given
179 if (binnedFit) {
180 if (chi2func == 0)
181 fChi2 = fVal;
182 else {
183 // compute chi2 equivalent for likelihood fits
184 // NB: empty bins are considered
185 fChi2 = (*chi2func)(&fParams[0]);
186 }
187 }
188
189 // fill error matrix
190 // if minimizer provides error provides also error matrix
191 // clear in case of re-filling an existing result
192 if (!fCovMatrix.empty()) fCovMatrix.clear();
193 if (!fGlobalCC.empty()) fGlobalCC.clear();
194
195 if (min->Errors() != 0) {
196
197 fErrors = std::vector<double>(min->Errors(), min->Errors() + npar ) ;
198
199 if (fCovStatus != 0) {
200 unsigned int r = npar * ( npar + 1 )/2;
201 fCovMatrix.reserve(r);
202 for (unsigned int i = 0; i < npar; ++i)
203 for (unsigned int j = 0; j <= i; ++j)
204 fCovMatrix.push_back(min->CovMatrix(i,j) );
205 }
206 // minos errors are set separetly when calling Fitter::CalculateMinosErrors()
207
208 // globalCC
209 fGlobalCC.reserve(npar);
210 for (unsigned int i = 0; i < npar; ++i) {
211 double globcc = min->GlobalCC(i);
212 if (globcc < 0) break; // it is not supported by that minimizer
213 fGlobalCC.push_back(globcc);
214 }
215
216 }
217
218}
219
220bool FitResult::Update(const std::shared_ptr<ROOT::Math::Minimizer> & min, const ROOT::Fit::FitConfig & fconfig, bool isValid, unsigned int ncalls) {
221 // update fit result with new status from minimizer
222 // ncalls if it is not zero is used instead of value from minimizer
223
224 fMinimizer = min;
225
226 // in case minimizer changes
227 fMinimType = fconfig.MinimizerName();
228
229 const unsigned int npar = fParams.size();
230 if (min->NDim() != npar ) {
231 MATH_ERROR_MSG("FitResult::Update","Wrong minimizer status ");
232 return false;
233 }
234 if (min->X() == 0 ) {
235 MATH_ERROR_MSG("FitResult::Update","Invalid minimizer status ");
236 return false;
237 }
238 //fNFree = min->NFree();
239 if (fNFree != min->NFree() ) {
240 MATH_ERROR_MSG("FitResult::Update","Configuration has changed ");
241 return false;
242 }
243
244 fValid = isValid;
245 // update minimum value
246 fVal = min->MinValue();
247 fEdm = min->Edm();
248 fStatus = min->Status();
249 fCovStatus = min->CovMatrixStatus();
250
251 // update number of function calls
252 if ( min->NCalls() > 0) fNCalls = min->NCalls();
253 else fNCalls = ncalls;
254
255 // copy parameter value and errors
256 std::copy(min->X(), min->X() + npar, fParams.begin());
257
258
259 // set parameters in fit model function
260 if (fFitFunc) fFitFunc->SetParameters(&fParams.front());
261
262 if (min->Errors() != 0) {
263
264 if (fErrors.size() != npar) fErrors.resize(npar);
265
266 std::copy(min->Errors(), min->Errors() + npar, fErrors.begin() ) ;
267
268 if (fCovStatus != 0) {
269
270 // update error matrix
271 unsigned int r = npar * ( npar + 1 )/2;
272 if (fCovMatrix.size() != r) fCovMatrix.resize(r);
273 unsigned int l = 0;
274 for (unsigned int i = 0; i < npar; ++i) {
275 for (unsigned int j = 0; j <= i; ++j)
276 fCovMatrix[l++] = min->CovMatrix(i,j);
277 }
278 }
279
280 // update global CC
281 if (fGlobalCC.size() != npar) fGlobalCC.resize(npar);
282 for (unsigned int i = 0; i < npar; ++i) {
283 double globcc = min->GlobalCC(i);
284 if (globcc < 0) {
285 fGlobalCC.clear();
286 break; // it is not supported by that minimizer
287 }
288 fGlobalCC[i] = globcc;
289 }
290
291 }
292 return true;
293}
294
296 // normalize errors and covariance matrix according to chi2 value
297 if (fNdf == 0 || fChi2 <= 0) return;
298 double s2 = fChi2/fNdf;
299 double s = std::sqrt(fChi2/fNdf);
300 for (unsigned int i = 0; i < fErrors.size() ; ++i)
301 fErrors[i] *= s;
302 for (unsigned int i = 0; i < fCovMatrix.size() ; ++i)
303 fCovMatrix[i] *= s2;
304
305 fNormalized = true;
306}
307
308
309double FitResult::Prob() const {
310 // fit probability
311 return ROOT::Math::chisquared_cdf_c(fChi2, static_cast<double>(fNdf) );
312}
313
314bool FitResult::HasMinosError(unsigned int i) const {
315 // query if the parameter i has the Minos error
316 std::map<unsigned int, std::pair<double,double> >::const_iterator itr = fMinosErrors.find(i);
317 return (itr != fMinosErrors.end() );
318}
319
320
321double FitResult::LowerError(unsigned int i) const {
322 // return lower Minos error for parameter i
323 // return the parabolic error if Minos error has not been calculated for the parameter i
324 std::map<unsigned int, std::pair<double,double> >::const_iterator itr = fMinosErrors.find(i);
325 return ( itr != fMinosErrors.end() ) ? itr->second.first : Error(i) ;
326}
327
328double FitResult::UpperError(unsigned int i) const {
329 // return upper Minos error for parameter i
330 // return the parabolic error if Minos error has not been calculated for the parameter i
331 std::map<unsigned int, std::pair<double,double> >::const_iterator itr = fMinosErrors.find(i);
332 return ( itr != fMinosErrors.end() ) ? itr->second.second : Error(i) ;
333}
334
335void FitResult::SetMinosError(unsigned int i, double elow, double eup) {
336 // set the Minos error for parameter i
337 fMinosErrors[i] = std::make_pair(elow,eup);
338}
339
340int FitResult::Index(const std::string & name) const {
341 // find index for given parameter name
342 if (! fFitFunc) return -1;
343 unsigned int npar = fParams.size();
344 for (unsigned int i = 0; i < npar; ++i)
345 if ( fFitFunc->ParameterName(i) == name) return i;
346
347 return -1; // case name is not found
348}
349
350bool FitResult::IsParameterBound(unsigned int ipar) const {
351 return fBoundParams.find(ipar) != fBoundParams.end();
352}
353
354bool FitResult::IsParameterFixed(unsigned int ipar) const {
355 return fFixedParams.find(ipar) != fFixedParams.end();
356}
357
358bool FitResult::ParameterBounds(unsigned int ipar, double & lower, double & upper) const {
359 std::map<unsigned int, unsigned int>::const_iterator itr = fBoundParams.find(ipar);
360 if (itr == fBoundParams.end() ) {
361 lower = -std::numeric_limits<Double_t>::infinity();
362 upper = std::numeric_limits<Double_t>::infinity();
363 return false;
364 }
365 assert(itr->second < fParamBounds.size() );
366 lower = fParamBounds[itr->second].first;
367 upper = fParamBounds[itr->second].second;
368 return false;
369}
370
371std::string FitResult::ParName(unsigned int ipar) const {
372 // return parameter name
373 if (fFitFunc) return fFitFunc->ParameterName(ipar);
374 else if (ipar < fParNames.size() ) return fParNames[ipar];
375 return "param_" + ROOT::Math::Util::ToString(ipar);
376}
377
378void FitResult::Print(std::ostream & os, bool doCovMatrix) const {
379 // print the result in the given stream
380 // need to add also minos errors , globalCC, etc..
381 unsigned int npar = fParams.size();
382 if (npar == 0) {
383 os << "<Empty FitResult>\n";
384 return;
385 }
386 os << "\n****************************************\n";
387 if (!fValid) {
389 os << " Invalid FitResult";
390 os << " (status = " << fStatus << " )";
391 }
392 else {
393 os << " FitResult before fitting";
394 }
395 os << "\n****************************************\n";
396 }
397
398 //os << " FitResult \n\n";
399 os << "Minimizer is " << fMinimType << std::endl;
400 const unsigned int nw = 25; // spacing for text
401 const unsigned int nn = 12; // spacing for numbers
402 const std::ios_base::fmtflags prFmt = os.setf(std::ios::left,std::ios::adjustfield); // set left alignment
403
404 if (fVal != fChi2 || fChi2 < 0)
405 os << std::left << std::setw(nw) << "MinFCN" << " = " << std::right << std::setw(nn) << fVal << std::endl;
406 if (fChi2 >= 0)
407 os << std::left << std::setw(nw) << "Chi2" << " = " << std::right << std::setw(nn) << fChi2 << std::endl;
408 os << std::left << std::setw(nw) << "NDf" << " = " << std::right << std::setw(nn) << fNdf << std::endl;
409 if (fMinimType.find("Linear") == std::string::npos) { // no need to print this for linear fits
410 if (fEdm >=0) os << std::left << std::setw(nw) << "Edm" << " = " << std::right << std::setw(nn) << fEdm << std::endl;
411 os << std::left << std::setw(nw) << "NCalls" << " = " << std::right << std::setw(nn) << fNCalls << std::endl;
412 }
413 for (unsigned int i = 0; i < npar; ++i) {
414 os << std::left << std::setw(nw) << GetParameterName(i);
415 os << " = " << std::right << std::setw(nn) << fParams[i];
416 if (IsParameterFixed(i) )
417 os << std::setw(9) << " " << std::setw(nn) << " " << " \t (fixed)";
418 else {
419 if (fErrors.size() != 0)
420 os << " +/- " << std::left << std::setw(nn) << fErrors[i] << std::right;
421 if (HasMinosError(i))
422 os << " " << std::left << std::setw(nn) << LowerError(i) << " +" << std::setw(nn) << UpperError(i)
423 << " (Minos) ";
424 if (IsParameterBound(i))
425 os << " \t (limited)";
426 }
427 os << std::endl;
428 }
429
430 // restore stremam adjustfield
431 if (prFmt != os.flags() ) os.setf(prFmt, std::ios::adjustfield);
432
433 if (doCovMatrix) PrintCovMatrix(os);
434}
435
436void FitResult::PrintCovMatrix(std::ostream &os) const {
437 // print the covariance and correlation matrix
438 if (!fValid) return;
439 if (fCovMatrix.size() == 0) return;
440// os << "****************************************\n";
441 os << "\nCovariance Matrix:\n\n";
442 unsigned int npar = fParams.size();
443 const int kPrec = 5;
444 const int kWidth = 8;
445 const int parw = 12;
446 const int matw = kWidth+4;
447
448 // query previous precision and format flags
449 int prevPrec = os.precision(kPrec);
450 const std::ios_base::fmtflags prevFmt = os.flags();
451
452 os << std::setw(parw) << " " << "\t";
453 for (unsigned int i = 0; i < npar; ++i) {
454 if (!IsParameterFixed(i) ) {
455 os << std::right << std::setw(matw) << GetParameterName(i) ;
456 }
457 }
458 os << std::endl;
459 for (unsigned int i = 0; i < npar; ++i) {
460 if (!IsParameterFixed(i) ) {
461 os << std::left << std::setw(parw) << GetParameterName(i) << "\t";
462 for (unsigned int j = 0; j < npar; ++j) {
463 if (!IsParameterFixed(j) ) {
464 os.precision(kPrec); os.width(kWidth); os << std::right << std::setw(matw) << CovMatrix(i,j);
465 }
466 }
467 os << std::endl;
468 }
469 }
470// os << "****************************************\n";
471 os << "\nCorrelation Matrix:\n\n";
472 os << std::setw(parw) << " " << "\t";
473 for (unsigned int i = 0; i < npar; ++i) {
474 if (!IsParameterFixed(i) ) {
475 os << std::right << std::setw(matw) << GetParameterName(i) ;
476 }
477 }
478 os << std::endl;
479 for (unsigned int i = 0; i < npar; ++i) {
480 if (!IsParameterFixed(i) ) {
481 os << std::left << std::setw(parw) << std::left << GetParameterName(i) << "\t";
482 for (unsigned int j = 0; j < npar; ++j) {
483 if (!IsParameterFixed(j) ) {
484 os.precision(kPrec); os.width(kWidth); os << std::right << std::setw(matw) << Correlation(i,j);
485 }
486 }
487 os << std::endl;
488 }
489 }
490 // restore alignment and precision
491 os.setf(prevFmt, std::ios::adjustfield);
492 os.precision(prevPrec);
493}
494
495void FitResult::GetConfidenceIntervals(unsigned int n, unsigned int stride1, unsigned int stride2, const double * x, double * ci, double cl, bool norm ) const {
496 // stride1 stride in coordinate stride2 stride in dimension space
497 // i.e. i-th point in k-dimension is x[ stride1 * i + stride2 * k]
498 // compute the confidence interval of the fit on the given data points
499 // the dimension of the data points must match the dimension of the fit function
500 // confidence intervals are returned in array ci
501
502 if (!fFitFunc) {
503 // check if model function exists
504 MATH_ERROR_MSG("FitResult::GetConfidenceIntervals","Cannot compute Confidence Intervals without fit model function");
505 return;
506 }
507 assert(fFitFunc);
508
509 // use student quantile in case of normalized errors
510 double corrFactor = 1;
511 if (fChi2 <= 0 || fNdf == 0) norm = false;
512 if (norm)
513 corrFactor = TMath::StudentQuantile(0.5 + cl/2, fNdf) * std::sqrt( fChi2/fNdf );
514 else
515 // correction to apply to the errors given a CL different than 1 sigma (cl=0.683)
516 corrFactor = ROOT::Math::normal_quantile(0.5 + cl/2, 1);
517
518
519
520 unsigned int ndim = fFitFunc->NDim();
521 unsigned int npar = fFitFunc->NPar();
522
523 std::vector<double> xpoint(ndim);
524 std::vector<double> grad(npar);
525 std::vector<double> vsum(npar);
526
527 // loop on the points
528 for (unsigned int ipoint = 0; ipoint < n; ++ipoint) {
529
530 for (unsigned int kdim = 0; kdim < ndim; ++kdim) {
531 unsigned int i = ipoint * stride1 + kdim * stride2;
532 assert(i < ndim*n);
533 xpoint[kdim] = x[i];
534 }
535
536 // calculate gradient of fitted function w.r.t the parameters
538 for (unsigned int ipar = 0; ipar < npar; ++ipar) {
539 if (!IsParameterFixed(ipar)) {
541 d.SetFunction(fadapter);
542 // compute step size as a small fraction of the error
543 // (see numerical recipes in C 5.7.8) 1.E-5 is ~ (eps)^1/3
544 if ( fErrors[ipar] > 0 )
545 d.SetStepSize( std::max( fErrors[ipar]*1.E-5, 1.E-15) );
546 else
547 d.SetStepSize( std::min(std::max(fParams[ipar]*1.E-5, 1.E-15), 0.0001 ) );
548
549 grad[ipar] = d(fParams[ipar] ); // evaluate df/dp
550 }
551 else
552 grad[ipar] = 0.; // for fixed parameters
553 }
554
555 // multiply covariance matrix with gradient
556 vsum.assign(npar,0.0);
557 for (unsigned int ipar = 0; ipar < npar; ++ipar) {
558 for (unsigned int jpar = 0; jpar < npar; ++jpar) {
559 vsum[ipar] += CovMatrix(ipar,jpar) * grad[jpar];
560 }
561 }
562 // multiply gradient by vsum
563 double r2 = 0;
564 for (unsigned int ipar = 0; ipar < npar; ++ipar) {
565 r2 += grad[ipar] * vsum[ipar];
566 }
567 double r = std::sqrt(r2);
568 ci[ipoint] = r * corrFactor;
569 }
570}
571
572void FitResult::GetConfidenceIntervals(const BinData & data, double * ci, double cl, bool norm ) const {
573 // implement confidence intervals from a given bin data sets
574 // currently copy the data from Bindata.
575 // could implement otherwise directly
576 unsigned int ndim = data.NDim();
577 unsigned int np = data.NPoints();
578 std::vector<double> xdata( ndim * np );
579 for (unsigned int i = 0; i < np ; ++i) {
580 const double * x = data.Coords(i);
581 std::vector<double>::iterator itr = xdata.begin()+ ndim * i;
582 std::copy(x,x+ndim,itr);
583 }
584 // points are arraned as x0,y0,z0, ....xN,yN,zN (stride1=ndim, stride2=1)
585 GetConfidenceIntervals(np,ndim,1,&xdata.front(),ci,cl,norm);
586}
587
588std::vector<double> FitResult::GetConfidenceIntervals(double cl, bool norm ) const {
589 // implement confidence intervals using stored data sets (if can be retrieved from objective function)
590 // it works only in case of chi2 or binned likelihood fits
591 const BinData * data = FittedBinData();
592 std::vector<double> result;
593 if (data) {
594 result.resize(data->NPoints() );
595 GetConfidenceIntervals(*data, result.data(), cl, norm);
596 }
597 else {
598 MATH_ERROR_MSG("FitResult::GetConfidenceIntervals","Cannot compute Confidence Intervals without the fit bin data");
599 }
600 return result;
601}
602
603// const BinData * GetFitBinData() const {
604// // return a pointer to the binned data used in the fit
605// // works only for chi2 or binned likelihood fits
606// // thus when the objective function stored is a Chi2Func or a PoissonLikelihood
607// ROOT::Math::IMultiGenFunction * f = fObjFunc->get();
608// Chi2Function * chi2func = dynamic_cast<Chi2Function*>(f);
609// if (chi2func) return &(chi2func->Data());
610// PoissonLLFunction * pllfunc = dynamic_cast<PoissonLLFunction*>(f);
611// if (pllfunc) return &(pllfunc->Data());
612// Chi2GradFunction * chi2gradfunc = dynamic_cast<Chi2GradFunction*>(f);
613// if (chi2gradfunc) return &(chi2gradfunc->Data());
614// PoissonLLGradFunction * pllgradfunc = dynamic_cast<PoissonLLFunction*>(f);
615// if (pllgradfunc) return &(pllgradfunc->Data());
616// MATH_WARN_MSG("FitResult::GetFitBinData","Cannot retrun fit bin data set if objective function is not of a known type");
617// return nullptr;
618// }
619
621 return dynamic_cast<const BinData*> ( fFitData.get() );
622}
623
624////////////////////////////////////////////////////////////////////////////////
625/// Scan parameter ipar between value of xmin and xmax
626/// A array for x and y points should be provided
627
628bool FitResult::Scan(unsigned int ipar, unsigned int &npoints, double *pntsx, double *pntsy, double xmin, double xmax)
629{
630 if (!pntsx || !pntsy || !npoints)
631 return false;
632
633 if (!fMinimizer) {
634 MATH_ERROR_MSG("FitResult::Scan", "Minimizer is not available - cannot Scan");
635 return false;
636 }
637
638 return fMinimizer->Scan(ipar, npoints, pntsx, pntsy, xmin, xmax);
639}
640
641////////////////////////////////////////////////////////////////////////////////
642/// Create a 2D contour around the minimum for the parameter ipar and jpar
643/// if a minimum does not exist or is invalid it will return false
644/// A array for x and y points should be provided
645/// Pass optionally the confidence level, default is 0.683
646/// it is assumed that ErrorDef() defines the right error definition
647/// (i.e 1 sigma error for one parameter). If not the confidence level are scaled to new level
648
649bool FitResult::Contour(unsigned int ipar, unsigned int jpar, unsigned int &npoints, double *pntsx, double *pntsy, double confLevel)
650{
651 if (!pntsx || !pntsy || !npoints)
652 return false;
653
654 if (!fMinimizer) {
655 MATH_ERROR_MSG("FitResult::Contour", "Minimizer is not available - cannot produce Contour");
656 return false;
657 }
658
659 // get error level used for fitting
660 double upScale = fMinimizer->ErrorDef();
661
662 double upVal = TMath::ChisquareQuantile(confLevel, 2); // 2 is number of parameter we do the contour
663
664 // set required error definition in minimizer
665 fMinimizer->SetErrorDef(upScale * upVal);
666
667 bool ret = fMinimizer->Contour(ipar, jpar, npoints, pntsx, pntsy);
668
669 // restore the error level used for fitting
670 fMinimizer->SetErrorDef(upScale);
671
672 return ret;
673}
674
675 } // end namespace Fit
676
677} // end namespace ROOT
#define MATH_ERROR_MSG(loc, str)
Definition: Error.h:83
#define d(i)
Definition: RSha256.hxx:102
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 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 np
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 r
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
char name[80]
Definition: TGX11.cxx:110
float xmin
Definition: THbookFile.cxx:95
float xmax
Definition: THbookFile.cxx:95
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
const std::string & MinimizerAlgoType() const
return type of minimizer algorithms
Definition: FitConfig.h:194
unsigned int NPar() const
number of parameters settings
Definition: FitConfig.h:96
std::string MinimizerName() const
return Minimizer full name (type / algorithm)
Definition: FitConfig.cxx:239
const std::string & MinimizerType() const
return type of minimizer package
Definition: FitConfig.h:189
const ParameterSettings & ParSettings(unsigned int i) const
get the parameter settings for the i-th parameter (const method)
Definition: FitConfig.h:76
std::vector< double > fGlobalCC
global Correlation coefficient
Definition: FitResult.h:355
void FillResult(const std::shared_ptr< ROOT::Math::Minimizer > &min, const FitConfig &fconfig, const std::shared_ptr< IModelFunction > &f, bool isValid, unsigned int sizeOfData=0, bool binFit=true, const ROOT::Math::IMultiGenFunction *chi2func=nullptr, unsigned int ncalls=0)
Fill the fit result from a Minimizer instance after fitting Run also Minos if requested from the conf...
Definition: FitResult.cxx:100
unsigned int fNFree
number of fit free parameters (total parameters are in size of parameter vector)
Definition: FitResult.h:337
bool Update(const std::shared_ptr< ROOT::Math::Minimizer > &min, const ROOT::Fit::FitConfig &fconfig, bool isValid, unsigned int ncalls=0)
Update the fit result with a new minimization status To be run only if same fit is performed with sam...
Definition: FitResult.cxx:220
std::map< unsigned int, unsigned int > fBoundParams
list of limited parameters
Definition: FitResult.h:350
const BinData * FittedBinData() const
return BinData used in the fit (return a nullptr in case a different fit is done or the data are not ...
Definition: FitResult.cxx:620
double UpperError(unsigned int i) const
upper Minos error. If Minos has not run for parameter i return the parabolic error
Definition: FitResult.cxx:328
double fVal
minimum function value
Definition: FitResult.h:342
double fEdm
expected distance from minimum
Definition: FitResult.h:343
std::vector< double > fErrors
errors
Definition: FitResult.h:353
std::shared_ptr< ROOT::Math::Minimizer > fMinimizer
! minimizer object used for fitting
Definition: FitResult.h:345
bool fValid
flag for indicating valid fit
Definition: FitResult.h:335
bool IsParameterFixed(unsigned int ipar) const
query if a parameter is fixed
Definition: FitResult.cxx:354
unsigned int fNdf
number of degree of freedom
Definition: FitResult.h:338
double Error(unsigned int i) const
parameter error by index
Definition: FitResult.h:177
double CovMatrix(unsigned int i, unsigned int j) const
retrieve covariance matrix element
Definition: FitResult.h:207
void GetConfidenceIntervals(unsigned int n, unsigned int stride1, unsigned int stride2, const double *x, double *ci, double cl=0.95, bool norm=false) const
get confidence intervals for an array of n points x.
Definition: FitResult.cxx:495
int fCovStatus
covariance matrix status code
Definition: FitResult.h:341
bool Scan(unsigned int ipar, unsigned int &npoints, double *pntsx, double *pntsy, double xmin=0, double xmax=0)
scan likelihood value of parameter and fill the given graph.
Definition: FitResult.cxx:628
FitResult()
Default constructor for an empty (non valid) fit result.
Definition: FitResult.cxx:45
std::shared_ptr< FitData > fFitData
! data set used in the fit
Definition: FitResult.h:348
std::string GetParameterName(unsigned int ipar) const
get name of parameter (deprecated)
Definition: FitResult.h:319
bool ParameterBounds(unsigned int ipar, double &lower, double &upper) const
retrieve parameter bounds - return false if parameter is not bound
Definition: FitResult.cxx:358
std::vector< double > fParams
parameter values. Size is total number of parameters
Definition: FitResult.h:352
std::vector< double > fCovMatrix
covariance matrix (size is npar*(npar+1)/2) where npar is total parameters
Definition: FitResult.h:354
void SetMinosError(unsigned int i, double elow, double eup)
set the Minos errors for parameter i (called by the Fitter class when running Minos)
Definition: FitResult.cxx:335
void Print(std::ostream &os, bool covmat=false) const
print the result and optionally covariance matrix and correlations
Definition: FitResult.cxx:378
double LowerError(unsigned int i) const
lower Minos error. If Minos has not run for parameter i return the parabolic error
Definition: FitResult.cxx:321
void PrintCovMatrix(std::ostream &os) const
print error matrix and correlations
Definition: FitResult.cxx:436
unsigned int fNCalls
number of function calls
Definition: FitResult.h:339
bool Contour(unsigned int ipar, unsigned int jpar, unsigned int &npoints, double *pntsx, double *pntsy, double confLevel=0.683)
create contour of two parameters around the minimum pass as option confidence level: default is a val...
Definition: FitResult.cxx:649
bool HasMinosError(unsigned int i) const
query if parameter i has the Minos error
Definition: FitResult.cxx:314
std::vector< std::pair< double, double > > fParamBounds
parameter bounds
Definition: FitResult.h:351
int fStatus
minimizer status code
Definition: FitResult.h:340
double fChi2
fit chi2 value (different than fval in case of chi2 fits)
Definition: FitResult.h:344
std::shared_ptr< IModelFunction > fFitFunc
! model function resulting from the fit.
Definition: FitResult.h:347
std::map< unsigned int, bool > fFixedParams
list of fixed parameters
Definition: FitResult.h:349
std::string fMinimType
string indicating type of minimizer
Definition: FitResult.h:357
double Correlation(unsigned int i, unsigned int j) const
retrieve correlation elements
Definition: FitResult.h:217
int Index(const std::string &name) const
get index for parameter name (return -1 if not found)
Definition: FitResult.cxx:340
double Prob() const
p value of the fit (chi2 probability)
Definition: FitResult.cxx:309
std::string ParName(unsigned int i) const
name of the parameter
Definition: FitResult.cxx:371
void NormalizeErrors()
normalize errors using chi2/ndf for chi2 fits
Definition: FitResult.cxx:295
bool fNormalized
flag for indicating is errors are normalized
Definition: FitResult.h:336
bool IsParameterBound(unsigned int ipar) const
query if a parameter is bound
Definition: FitResult.cxx:350
std::vector< std::string > fParNames
parameter names (only with FCN only fits, when fFitFunc=0)
Definition: FitResult.h:358
std::map< unsigned int, std::pair< double, double > > fMinosErrors
map contains the two Minos errors
Definition: FitResult.h:356
Class, describing value, limits and step size of the parameters Provides functionality also to set/re...
bool IsFixed() const
check if is fixed
bool HasUpperLimit() const
check if parameter has upper limit
double LowerLimit() const
return lower limit value
const std::string & Name() const
return name
bool HasLowerLimit() const
check if parameter has lower limit
double Value() const
copy constructor and assignment operators (leave them to the compiler)
double StepSize() const
return step size
double UpperLimit() const
return upper limit value
bool IsBound() const
check if is bound
Documentation for the abstract class IBaseFunctionMultiDim.
Definition: IFunction.h:62
OneDimParamFunctionAdapter class to wrap a multi-dim parametric function in one dimensional one.
User class for calculating the derivatives of a function.
double chisquared_cdf_c(double x, double r, double x0=0)
Complement of the cumulative distribution function of the distribution with degrees of freedom (upp...
double normal_quantile(double z, double sigma)
Inverse ( ) of the cumulative distribution function of the lower tail of the normal (Gaussian) distri...
Double_t x[n]
Definition: legend1.C:17
const Int_t n
Definition: legend1.C:16
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
const int gInitialResultStatus
Definition: FitResult.cxx:43
std::string ToString(const T &val)
Utility function for conversion to strings.
Definition: Util.h:50
VecExpr< UnaryOp< Sqrt< T >, VecExpr< A, T, D >, T >, T, D > sqrt(const VecExpr< A, T, D > &rhs)
This file contains a specialised ROOT message handler to test for diagnostic in unit tests.
static constexpr double s
Double_t ChisquareQuantile(Double_t p, Double_t ndf)
Evaluate the quantiles of the chi-squared probability distribution function.
Definition: TMath.cxx:2189
Double_t StudentQuantile(Double_t p, Double_t ndf, Bool_t lower_tail=kTRUE)
Computes quantiles of the Student's t-distribution 1st argument is the probability,...
Definition: TMath.cxx:2668
TLine l
Definition: textangle.C:4