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