Logo ROOT  
Reference Guide
RooFitResult.cxx
Go to the documentation of this file.
1 /*****************************************************************************
2  * Project: RooFit *
3  * Package: RooFitCore *
4  * @(#)root/roofitcore:$Id$
5  * Authors: *
6  * WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
7  * DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
8  * *
9  * Copyright (c) 2000-2005, Regents of the University of California *
10  * and Stanford University. All rights reserved. *
11  * *
12  * Redistribution and use in source and binary forms, *
13  * with or without modification, are permitted according to the terms *
14  * listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
15  *****************************************************************************/
16 
17 //////////////////////////////////////////////////////////////////////////////
18 /// \class RooFitResult
19 /// RooFitResult is a container class to hold the input and output
20 /// of a PDF fit to a dataset. It contains:
21 ///
22 /// * Values of all constant parameters
23 /// * Initial and final values of floating parameters with error
24 /// * Correlation matrix and global correlation coefficients
25 /// * NLL and EDM at mininum
26 ///
27 /// No references to the fitted PDF and dataset are stored
28 ///
29 
30 #include "RooFit.h"
31 
32 #include <iostream>
33 #include <iomanip>
34 
35 #include "TBuffer.h"
36 #include "TMinuit.h"
37 #include "TMath.h"
38 #include "TMarker.h"
39 #include "TLine.h"
40 #include "TBox.h"
41 #include "TGaxis.h"
42 #include "TMatrix.h"
43 #include "TVector.h"
44 #include "TDirectory.h"
45 #include "TClass.h"
46 #include "RooFitResult.h"
47 #include "RooArgSet.h"
48 #include "RooArgList.h"
49 #include "RooRealVar.h"
50 #include "RooPlot.h"
51 #include "RooEllipse.h"
52 #include "RooRandom.h"
53 #include "RooMsgService.h"
54 #include "TH2D.h"
55 #include "TText.h"
56 #include "TMatrixDSym.h"
57 #include "RooMultiVarGaussian.h"
58 
59 
60 using namespace std;
61 
63 
64 
65 
66 ////////////////////////////////////////////////////////////////////////////////
67 /// Constructor with name and title
68 
69 RooFitResult::RooFitResult(const char* name, const char* title) :
70  TNamed(name,title), _constPars(0), _initPars(0), _finalPars(0), _globalCorr(0), _randomPars(0), _Lt(0),
71  _CM(0), _VM(0), _GC(0)
72 {
73  if (name) appendToDir(this,kTRUE) ;
74 }
75 
76 
77 ////////////////////////////////////////////////////////////////////////////////
78 /// Copy constructor
79 
81  TNamed(other),
82  RooPrintable(other),
83  RooDirItem(other),
84  _status(other._status),
85  _covQual(other._covQual),
86  _numBadNLL(other._numBadNLL),
87  _minNLL(other._minNLL),
88  _edm(other._edm),
89  _globalCorr(0),
90  _randomPars(0),
91  _Lt(0),
92  _CM(0),
93  _VM(0),
94  _GC(0),
95  _statusHistory(other._statusHistory)
96 {
98  _initPars = (RooArgList*) other._initPars->snapshot() ;
100  if (other._randomPars) _randomPars = (RooArgList*) other._randomPars->snapshot() ;
101  if (other._Lt) _Lt = new TMatrix(*other._Lt);
102  if (other._VM) _VM = new TMatrixDSym(*other._VM) ;
103  if (other._CM) _CM = new TMatrixDSym(*other._CM) ;
104  if (other._GC) _GC = new TVectorD(*other._GC) ;
105 
106  if (GetName())
107  appendToDir(this, kTRUE);
108 }
109 
110 
111 
112 ////////////////////////////////////////////////////////////////////////////////
113 /// Destructor
114 
116 {
117  if (_constPars) delete _constPars ;
118  if (_initPars) delete _initPars ;
119  if (_finalPars) delete _finalPars ;
120  if (_globalCorr) delete _globalCorr;
121  if (_randomPars) delete _randomPars;
122  if (_Lt) delete _Lt;
123  if (_CM) delete _CM ;
124  if (_VM) delete _VM ;
125  if (_GC) delete _GC ;
126 
129 
130  removeFromDir(this) ;
131 }
132 
133 
134 ////////////////////////////////////////////////////////////////////////////////
135 /// Fill the list of constant parameters
136 
138 {
139  if (_constPars) delete _constPars ;
140  _constPars = (RooArgList*) list.snapshot() ;
141  TIterator* iter = _constPars->createIterator() ;
142  RooAbsArg* arg ;
143  while((arg=(RooAbsArg*)iter->Next())) {
144  RooRealVar* rrv = dynamic_cast<RooRealVar*>(arg) ;
145  if (rrv) {
146  rrv->deleteSharedProperties() ;
147  }
148  }
149  delete iter ;
150 }
151 
152 
153 
154 ////////////////////////////////////////////////////////////////////////////////
155 /// Fill the list of initial values of the floating parameters
156 
158 {
159  if (_initPars) delete _initPars ;
160  _initPars = (RooArgList*) list.snapshot() ;
161  TIterator* iter = _initPars->createIterator() ;
162  RooAbsArg* arg ;
163  while((arg=(RooAbsArg*)iter->Next())) {
164  RooRealVar* rrv = dynamic_cast<RooRealVar*>(arg) ;
165  if (rrv) {
166  rrv->deleteSharedProperties() ;
167  }
168  }
169  delete iter ;
170 }
171 
172 
173 
174 ////////////////////////////////////////////////////////////////////////////////
175 /// Fill the list of final values of the floating parameters
176 
178 {
179  if (_finalPars) delete _finalPars ;
180  _finalPars = (RooArgList*) list.snapshot() ;
181 
182  TIterator* iter = _finalPars->createIterator() ;
183  RooAbsArg* arg ;
184  while((arg=(RooAbsArg*)iter->Next())) {
185  RooRealVar* rrv = dynamic_cast<RooRealVar*>(arg) ;
186  if (rrv) {
187  rrv->deleteSharedProperties() ;
188  }
189  }
190  delete iter ;
191 }
192 
193 
194 
195 ////////////////////////////////////////////////////////////////////////////////
196 
198 {
199  if (icycle>=_statusHistory.size()) {
200  coutE(InputArguments) << "RooFitResult::statusCodeHistory(" << GetName()
201  << " ERROR request for status history slot "
202  << icycle << " exceeds history count of " << _statusHistory.size() << endl ;
203  }
204  return _statusHistory[icycle].second ;
205 }
206 
207 
208 
209 ////////////////////////////////////////////////////////////////////////////////
210 
211 const char* RooFitResult::statusLabelHistory(UInt_t icycle) const
212 {
213  if (icycle>=_statusHistory.size()) {
214  coutE(InputArguments) << "RooFitResult::statusLabelHistory(" << GetName()
215  << " ERROR request for status history slot "
216  << icycle << " exceeds history count of " << _statusHistory.size() << endl ;
217  }
218  return _statusHistory[icycle].first.c_str() ;
219 }
220 
221 
222 
223 ////////////////////////////////////////////////////////////////////////////////
224 /// Add objects to a 2D plot that represent the fit results for the
225 /// two named parameters. The input frame with the objects added is
226 /// returned, or zero in case of an error. Which objects are added
227 /// are determined by the options string which should be a concatenation
228 /// of the following (not case sensitive):
229 ///
230 /// * M - a marker at the best fit result
231 /// * E - an error ellipse calculated at 1-sigma using the error matrix at the minimum
232 /// * 1 - the 1-sigma error bar for parameter 1
233 /// * 2 - the 1-sigma error bar for parameter 2
234 /// * B - the bounding box for the error ellipse
235 /// * H - a line and horizontal axis for reading off the correlation coefficient
236 /// * V - a line and vertical axis for reading off the correlation coefficient
237 /// * A - draw axes for reading off the correlation coefficients with the H or V options
238 ///
239 /// You can change the attributes of objects in the returned RooPlot using the
240 /// various `RooPlot::getAttXxx(name)` member functions, e.g.
241 /// ```
242 /// plot->getAttLine("contour")->SetLineStyle(kDashed);
243 /// ```
244 /// Use `plot->Print()` for a list of all objects and their names (unfortunately most
245 /// of the ROOT builtin graphics objects like TLine are unnamed). Drag the left mouse
246 /// button along the labels of either axis button to interactively zoom in a plot.
247 
248 RooPlot *RooFitResult::plotOn(RooPlot *frame, const char *parName1, const char *parName2,
249  const char *options) const
250 {
251  // lookup the input parameters by name: we require that they were floated in our fit
252  const RooRealVar *par1= dynamic_cast<const RooRealVar*>(floatParsFinal().find(parName1));
253  if(0 == par1) {
254  coutE(InputArguments) << "RooFitResult::correlationPlot: parameter not floated in fit: " << parName1 << endl;
255  return 0;
256  }
257  const RooRealVar *par2= dynamic_cast<const RooRealVar*>(floatParsFinal().find(parName2));
258  if(0 == par2) {
259  coutE(InputArguments) << "RooFitResult::correlationPlot: parameter not floated in fit: " << parName2 << endl;
260  return 0;
261  }
262 
263  // options are not case sensitive
264  TString opt(options);
265  opt.ToUpper();
266 
267  // lookup the 2x2 covariance matrix elements for these variables
268  Double_t x1= par1->getVal();
269  Double_t x2= par2->getVal();
270  Double_t s1= par1->getError();
271  Double_t s2= par2->getError();
272  Double_t rho= correlation(parName1, parName2);
273 
274  // add a 1-sigma error ellipse, if requested
275  if(opt.Contains("E")) {
276  RooEllipse *contour= new RooEllipse("contour",x1,x2,s1,s2,rho);
277  contour->SetLineWidth(2) ;
278  frame->addPlotable(contour);
279  }
280 
281  // add the error bar for parameter 1, if requested
282  if(opt.Contains("1")) {
283  TLine *hline= new TLine(x1-s1,x2,x1+s1,x2);
284  hline->SetLineColor(kRed);
285  frame->addObject(hline);
286  }
287 
288  if(opt.Contains("2")) {
289  TLine *vline= new TLine(x1,x2-s2,x1,x2+s2);
290  vline->SetLineColor(kRed);
291  frame->addObject(vline);
292  }
293 
294  if(opt.Contains("B")) {
295  TBox *box= new TBox(x1-s1,x2-s2,x1+s1,x2+s2);
296  box->SetLineStyle(kDashed);
297  box->SetLineColor(kRed);
298  box->SetFillStyle(0);
299  frame->addObject(box);
300  }
301 
302  if(opt.Contains("H")) {
303  TLine *line= new TLine(x1-rho*s1,x2-s2,x1+rho*s1,x2+s2);
306  line->SetLineWidth(2) ;
307  frame->addObject(line);
308  if(opt.Contains("A")) {
309  TGaxis *axis= new TGaxis(x1-s1,x2-s2,x1+s1,x2-s2,-1.,+1.,502,"-=");
310  axis->SetLineColor(kBlue);
311  frame->addObject(axis);
312  }
313  }
314 
315  if(opt.Contains("V")) {
316  TLine *line= new TLine(x1-s1,x2-rho*s2,x1+s1,x2+rho*s2);
319  line->SetLineWidth(2) ;
320  frame->addObject(line);
321  if(opt.Contains("A")) {
322  TGaxis *axis= new TGaxis(x1-s1,x2-s2,x1-s1,x2+s2,-1.,+1.,502,"-=");
323  axis->SetLineColor(kBlue);
324  frame->addObject(axis);
325  }
326  }
327 
328  // add a marker at the fitted value, if requested
329  if(opt.Contains("M")) {
330  TMarker *marker= new TMarker(x1,x2,20);
331  marker->SetMarkerColor(kBlack);
332  frame->addObject(marker);
333  }
334 
335  return frame;
336 }
337 
338 
339 ////////////////////////////////////////////////////////////////////////////////
340 /// Return a list of floating parameter values that are perturbed from the final
341 /// fit values by random amounts sampled from the covariance matrix. The returned
342 /// object is overwritten with each call and belongs to the RooFitResult. Uses
343 /// the "square root method" to decompose the covariance matrix, which makes inverting
344 /// it unnecessary.
345 
347 {
348  Int_t nPar= _finalPars->getSize();
349  if(0 == _randomPars) { // first-time initialization
350  assert(0 != _finalPars);
351  // create the list of random values to fill
353  // calculate the elements of the upper-triangular matrix L that gives Lt*L = C
354  // where Lt is the transpose of L (the "square-root method")
355  TMatrix L(nPar,nPar);
356  for(Int_t iPar= 0; iPar < nPar; iPar++) {
357  // calculate the diagonal term first
358  L(iPar,iPar)= covariance(iPar,iPar);
359  for(Int_t k= 0; k < iPar; k++) {
360  Double_t tmp= L(k,iPar);
361  L(iPar,iPar)-= tmp*tmp;
362  }
363  L(iPar,iPar)= sqrt(L(iPar,iPar));
364  // then the off-diagonal terms
365  for(Int_t jPar= iPar+1; jPar < nPar; jPar++) {
366  L(iPar,jPar)= covariance(iPar,jPar);
367  for(Int_t k= 0; k < iPar; k++) {
368  L(iPar,jPar)-= L(k,iPar)*L(k,jPar);
369  }
370  L(iPar,jPar)/= L(iPar,iPar);
371  }
372  }
373  // remember Lt
375  }
376  else {
377  // reset to the final fit values
379  }
380 
381  // create a vector of unit Gaussian variables
382  TVector g(nPar);
383  for(Int_t k= 0; k < nPar; k++) g(k)= RooRandom::gaussian();
384  // multiply this vector by Lt to introduce the appropriate correlations
385  g*= (*_Lt);
386  // add the mean value offsets and store the results
388  RooRealVar *par(0);
389  Int_t index(0);
390  while((0 != (par= (RooRealVar*)iter->Next()))) {
391  par->setVal(par->getVal() + g(index++));
392  }
393  delete iter;
394 
395  return *_randomPars;
396 }
397 
398 
399 ////////////////////////////////////////////////////////////////////////////////
400 /// Return the correlation between parameters 'par1' and 'par2'
401 
402 Double_t RooFitResult::correlation(const char* parname1, const char* parname2) const
403 {
404  Int_t idx1 = _finalPars->index(parname1) ;
405  Int_t idx2 = _finalPars->index(parname2) ;
406  if (idx1<0) {
407  coutE(InputArguments) << "RooFitResult::correlation(" << GetName() << ") parameter " << parname1 << " is not a floating fit parameter" << endl ;
408  return 0 ;
409  }
410  if (idx2<0) {
411  coutE(InputArguments) << "RooFitResult::correlation(" << GetName() << ") parameter " << parname2 << " is not a floating fit parameter" << endl ;
412  return 0 ;
413  }
414  return correlation(idx1,idx2) ;
415 }
416 
417 
418 
419 ////////////////////////////////////////////////////////////////////////////////
420 /// Return the set of correlation coefficients of parameter 'par' with
421 /// all other floating parameters
422 
423 const RooArgList* RooFitResult::correlation(const char* parname) const
424 {
425  if (_globalCorr==0) {
427  }
428 
429  RooAbsArg* arg = _initPars->find(parname) ;
430  if (!arg) {
431  coutE(InputArguments) << "RooFitResult::correlation: variable " << parname << " not a floating parameter in fit" << endl ;
432  return 0 ;
433  }
434  return (RooArgList*)_corrMatrix.At(_initPars->index(arg)) ;
435 }
436 
437 
438 
439 ////////////////////////////////////////////////////////////////////////////////
440 /// Return the global correlation of the named parameter
441 
442 Double_t RooFitResult::globalCorr(const char* parname)
443 {
444  if (_globalCorr==0) {
446  }
447 
448  RooAbsArg* arg = _initPars->find(parname) ;
449  if (!arg) {
450  coutE(InputArguments) << "RooFitResult::globalCorr: variable " << parname << " not a floating parameter in fit" << endl ;
451  return 0 ;
452  }
453 
454  if (_globalCorr) {
455  return ((RooAbsReal*)_globalCorr->at(_initPars->index(arg)))->getVal() ;
456  } else {
457  return 1.0 ;
458  }
459 }
460 
461 
462 
463 ////////////////////////////////////////////////////////////////////////////////
464 /// Return the list of all global correlations
465 
467 {
468  if (_globalCorr==0) {
470  }
471 
472  return _globalCorr ;
473 }
474 
475 
476 
477 ////////////////////////////////////////////////////////////////////////////////
478 /// Return a correlation matrix element addressed with numeric indices.
479 
481 {
482  return (*_CM)(row,col) ;
483 }
484 
485 
486 ////////////////////////////////////////////////////////////////////////////////
487 /// Return the covariance matrix element addressed with numeric indices.
488 
490 {
491  return (*_VM)(row,col) ;
492 }
493 
494 
495 
496 ////////////////////////////////////////////////////////////////////////////////
497 /// Print fit result to stream 'os'. In Verbose mode, the constant parameters and
498 /// the initial and final values of the floating parameters are printed.
499 /// Standard mode only the final values of the floating parameters are printed
500 
501 void RooFitResult::printMultiline(ostream& os, Int_t /*contents*/, Bool_t verbose, TString indent) const
502 {
503 
504  os << endl
505  << indent << " RooFitResult: minimized FCN value: " << _minNLL << ", estimated distance to minimum: " << _edm << endl
506  << indent << " covariance matrix quality: " ;
507  switch(_covQual) {
508  case -1 : os << "Unknown, matrix was externally provided" ; break ;
509  case 0 : os << "Not calculated at all" ; break ;
510  case 1 : os << "Approximation only, not accurate" ; break ;
511  case 2 : os << "Full matrix, but forced positive-definite" ; break ;
512  case 3 : os << "Full, accurate covariance matrix" ; break ;
513  }
514  os << endl ;
515  os << indent << " Status : " ;
516  for (vector<pair<string,int> >::const_iterator iter = _statusHistory.begin() ; iter != _statusHistory.end() ; ++iter) {
517  os << iter->first << "=" << iter->second << " " ;
518  }
519  os << endl << endl ;;
520 
521  Int_t i ;
522  if (verbose) {
523  if (_constPars->getSize()>0) {
524  os << indent << " Constant Parameter Value " << endl
525  << indent << " -------------------- ------------" << endl ;
526 
527  for (i=0 ; i<_constPars->getSize() ; i++) {
528  os << indent << " " << setw(20) << ((RooAbsArg*)_constPars->at(i))->GetName()
529  << " " << setw(12) << Form("%12.4e",((RooRealVar*)_constPars->at(i))->getVal())
530  << endl ;
531  }
532 
533  os << endl ;
534  }
535 
536  // Has any parameter asymmetric errors?
537  Bool_t doAsymErr(kFALSE) ;
538  for (i=0 ; i<_finalPars->getSize() ; i++) {
539  if (((RooRealVar*)_finalPars->at(i))->hasAsymError()) {
540  doAsymErr=kTRUE ;
541  break ;
542  }
543  }
544 
545  if (doAsymErr) {
546  os << indent << " Floating Parameter InitialValue FinalValue (+HiError,-LoError) GblCorr." << endl
547  << indent << " -------------------- ------------ ---------------------------------- --------" << endl ;
548  } else {
549  os << indent << " Floating Parameter InitialValue FinalValue +/- Error GblCorr." << endl
550  << indent << " -------------------- ------------ -------------------------- --------" << endl ;
551  }
552 
553  for (i=0 ; i<_finalPars->getSize() ; i++) {
554  os << indent << " " << setw(20) << ((RooAbsArg*)_finalPars->at(i))->GetName() ;
555  os << indent << " " << setw(12) << Form("%12.4e",((RooRealVar*)_initPars->at(i))->getVal())
556  << indent << " " << setw(12) << Form("%12.4e",((RooRealVar*)_finalPars->at(i))->getVal()) ;
557 
558  if (((RooRealVar*)_finalPars->at(i))->hasAsymError()) {
559  os << setw(21) << Form(" (+%8.2e,-%8.2e)",((RooRealVar*)_finalPars->at(i))->getAsymErrorHi(),
560  -1*((RooRealVar*)_finalPars->at(i))->getAsymErrorLo()) ;
561  } else {
562  Double_t err = ((RooRealVar*)_finalPars->at(i))->getError() ;
563  os << (doAsymErr?" ":"") << " +/- " << setw(9) << Form("%9.2e",err) ;
564  }
565 
566  if (_globalCorr) {
567  os << " " << setw(8) << Form("%8.6f" ,((RooRealVar*)_globalCorr->at(i))->getVal()) ;
568  } else {
569  os << " <none>" ;
570  }
571 
572  os << endl ;
573  }
574 
575  } else {
576  os << indent << " Floating Parameter FinalValue +/- Error " << endl
577  << indent << " -------------------- --------------------------" << endl ;
578 
579  for (i=0 ; i<_finalPars->getSize() ; i++) {
580  Double_t err = ((RooRealVar*)_finalPars->at(i))->getError() ;
581  os << indent << " " << setw(20) << ((RooAbsArg*)_finalPars->at(i))->GetName()
582  << " " << setw(12) << Form("%12.4e",((RooRealVar*)_finalPars->at(i))->getVal())
583  << " +/- " << setw(9) << Form("%9.2e",err)
584  << endl ;
585  }
586  }
587 
588 
589  os << endl ;
590 }
591 
592 
593 ////////////////////////////////////////////////////////////////////////////////
594 /// Function called by RooMinimizer
595 
596 void RooFitResult::fillCorrMatrix(const std::vector<double>& globalCC, const TMatrixDSym& corrs, const TMatrixDSym& covs)
597 {
598  // Sanity check
599  if (globalCC.empty() || corrs.GetNoElements() < 1 || covs.GetNoElements() < 1) {
600  coutI(Minimization) << "RooFitResult::fillCorrMatrix: number of floating parameters is zero, correlation matrix not filled" << endl ;
601  return ;
602  }
603 
604  if (!_initPars) {
605  coutE(Minimization) << "RooFitResult::fillCorrMatrix: ERROR: list of initial parameters must be filled first" << endl ;
606  return ;
607  }
608 
609  // Delete eventual prevous correlation data holders
610  if (_CM) delete _CM ;
611  if (_VM) delete _VM ;
612  if (_GC) delete _GC ;
613 
614  // Build holding arrays for correlation coefficients
615  _CM = new TMatrixDSym(corrs) ;
616  _VM = new TMatrixDSym(covs) ;
617  _GC = new TVectorD(_CM->GetNcols()) ;
618  for(int i=0 ; i<_CM->GetNcols() ; i++) {
619  (*_GC)[i] = globalCC[i] ;
620  }
621  //fillLegacyCorrMatrix() ;
622 }
623 
624 
625 
626 
627 
628 ////////////////////////////////////////////////////////////////////////////////
629 /// Sanity check
630 
632 {
633  if (!_CM) return ;
634 
635  // Delete eventual prevous correlation data holders
636  if (_globalCorr) delete _globalCorr ;
638 
639  // Build holding arrays for correlation coefficients
640  _globalCorr = new RooArgList("globalCorrelations") ;
641 
642  TIterator* vIter = _initPars->createIterator() ;
643  RooAbsArg* arg ;
644  Int_t idx(0) ;
645  while((arg=(RooAbsArg*)vIter->Next())) {
646  // Create global correlation value holder
647  TString gcName("GC[") ;
648  gcName.Append(arg->GetName()) ;
649  gcName.Append("]") ;
650  TString gcTitle(arg->GetTitle()) ;
651  gcTitle.Append(" Global Correlation") ;
652  _globalCorr->addOwned(*(new RooRealVar(gcName.Data(),gcTitle.Data(),0.))) ;
653 
654  // Create array with correlation holders for this parameter
655  TString name("C[") ;
656  name.Append(arg->GetName()) ;
657  name.Append(",*]") ;
658  RooArgList* corrMatrixRow = new RooArgList(name.Data()) ;
659  _corrMatrix.Add(corrMatrixRow) ;
660  TIterator* vIter2 = _initPars->createIterator() ;
661  RooAbsArg* arg2 ;
662  while((arg2=(RooAbsArg*)vIter2->Next())) {
663 
664  TString cName("C[") ;
665  cName.Append(arg->GetName()) ;
666  cName.Append(",") ;
667  cName.Append(arg2->GetName()) ;
668  cName.Append("]") ;
669  TString cTitle("Correlation between ") ;
670  cTitle.Append(arg->GetName()) ;
671  cTitle.Append(" and ") ;
672  cTitle.Append(arg2->GetName()) ;
673  corrMatrixRow->addOwned(*(new RooRealVar(cName.Data(),cTitle.Data(),0.))) ;
674  }
675  delete vIter2 ;
676  idx++ ;
677  }
678  delete vIter ;
679 
680  TIterator *gcIter = _globalCorr->createIterator() ;
681  TIterator *parIter = _finalPars->createIterator() ;
682  RooRealVar* gcVal = 0;
683  for (unsigned int i = 0; i < (unsigned int)_CM->GetNcols() ; ++i) {
684 
685  // Find the next global correlation slot to fill, skipping fixed parameters
686  gcVal = (RooRealVar*) gcIter->Next() ;
687  gcVal->setVal((*_GC)(i)) ; // WVE FIX THIS
688 
689  // Fill a row of the correlation matrix
690  TIterator* cIter = ((RooArgList*)_corrMatrix.At(i))->createIterator() ;
691  for (unsigned int it = 0; it < (unsigned int)_CM->GetNcols() ; ++it) {
692  RooRealVar* cVal = (RooRealVar*) cIter->Next() ;
693  double value = (*_CM)(i,it) ;
694  cVal->setVal(value);
695  (*_CM)(i,it) = value;
696  }
697  delete cIter ;
698  }
699 
700  delete gcIter ;
701  delete parIter ;
702 
703 }
704 
705 
706 
707 
708 
709 ////////////////////////////////////////////////////////////////////////////////
710 /// Internal utility method to extract the correlation matrix and the
711 /// global correlation coefficients from the MINUIT memory buffer and
712 /// fill the internal arrays.
713 
715 {
716  // Sanity check
717  if (gMinuit->fNpar < 1) {
718  coutI(Minimization) << "RooFitResult::fillCorrMatrix: number of floating parameters is zero, correlation matrix not filled" << endl ;
719  return ;
720  }
721 
722  if (!_initPars) {
723  coutE(Minimization) << "RooFitResult::fillCorrMatrix: ERROR: list of initial parameters must be filled first" << endl ;
724  return ;
725  }
726 
727  // Delete eventual prevous correlation data holders
728  if (_CM) delete _CM ;
729  if (_VM) delete _VM ;
730  if (_GC) delete _GC ;
731 
732  // Build holding arrays for correlation coefficients
733  _CM = new TMatrixDSym(_initPars->getSize()) ;
734  _VM = new TMatrixDSym(_initPars->getSize()) ;
735  _GC = new TVectorD(_initPars->getSize()) ;
736 
737  // Extract correlation information for MINUIT (code taken from TMinuit::mnmatu() )
738 
739  // WVE: This code directly manipulates minuit internal workspace,
740  // if TMinuit code changes this may need updating
741  Int_t ndex, i, j, m, n, it /* nparm,id,ix */ ;
742  Int_t ndi, ndj /*, iso, isw2, isw5*/;
743  for (i = 1; i <= gMinuit->fNpar; ++i) {
744  ndi = i*(i + 1) / 2;
745  for (j = 1; j <= gMinuit->fNpar; ++j) {
746  m = TMath::Max(i,j);
747  n = TMath::Min(i,j);
748  ndex = m*(m-1) / 2 + n;
749  ndj = j*(j + 1) / 2;
750  gMinuit->fMATUvline[j-1] = gMinuit->fVhmat[ndex-1] / TMath::Sqrt(TMath::Abs(gMinuit->fVhmat[ndi-1]*gMinuit->fVhmat[ndj-1]));
751  }
752 
753  (*_GC)(i-1) = gMinuit->fGlobcc[i-1] ;
754 
755  // Fill a row of the correlation matrix
756  for (it = 1; it <= gMinuit->fNpar ; ++it) {
757  (*_CM)(i-1,it-1) = gMinuit->fMATUvline[it-1] ;
758  }
759  }
760 
761  for (int ii=0 ; ii<_finalPars->getSize() ; ii++) {
762  for (int jj=0 ; jj<_finalPars->getSize() ; jj++) {
763  (*_VM)(ii,jj) = (*_CM)(ii,jj) * ((RooRealVar*)_finalPars->at(ii))->getError() * ((RooRealVar*)_finalPars->at(jj))->getError() ;
764  }
765  }
766 }
767 
768 ////////////////////////////////////////////////////////////////////////////////
769 
771 {
772 
773  // Delete eventual prevous correlation data holders
774  if (_CM)
775  delete _CM;
776  if (_VM)
777  delete _VM;
778  if (_GC)
779  delete _GC;
780 
781  // Build holding arrays for correlation coefficients
782  _CM = new TMatrixDSym(_initPars->getSize());
783  _VM = new TMatrixDSym(_initPars->getSize());
784  _GC = new TVectorD(_initPars->getSize());
785 
786  for (int ii = 0; ii < _finalPars->getSize(); ii++) {
787  (*_CM)(ii, ii) = 1;
788  (*_VM)(ii, ii) = ((RooRealVar *)_finalPars->at(ii))->getError() * ((RooRealVar *)_finalPars->at(ii))->getError();
789  (*_GC)(ii) = 0;
790  }
791 }
792 
793 ////////////////////////////////////////////////////////////////////////////////
794 /// Return true if this fit result is identical to other within tolerances.
795 /// \param[in] other Fit result to test against.
796 /// \param[in] tol **Relative** tolerance for parameters and NLL.
797 /// \param[in] tolCorr **absolute** tolerance for correlation coefficients.
798 /// \param[in] verbose Ignored.
799 
800 Bool_t RooFitResult::isIdentical(const RooFitResult& other, Double_t tol, Double_t tolCorr, Bool_t /*verbose*/) const
801 {
802  Bool_t ret = kTRUE ;
803  auto deviation = [tol](const double left, const double right){
804  if (right != 0.)
805  return fabs((left - right)/right) >= tol;
806  else
807  return fabs(left) >= tol;
808  };
809 
810  auto errMsg = [](std::string msgHead, const RooAbsReal* tv, const RooAbsReal* ov) {
811  cout << "RooFitResult::isIdentical: " << msgHead << " " << tv->GetName() << " differs in value:\t"
812  << tv->getVal() << " vs.\t" << ov->getVal()
813  << "\t(" << (tv->getVal()-ov->getVal())/ov->getVal() << ")" << endl;
814  };
815 
816  if (deviation(_minNLL, other._minNLL)) {
817  cout << "RooFitResult::isIdentical: minimized value of -log(L) is different " << _minNLL << " vs. " << other._minNLL << endl ;
818  ret = kFALSE ;
819  }
820 
821  for (Int_t i=0 ; i<_constPars->getSize() ; i++) {
822  auto tv = static_cast<const RooAbsReal*>(_constPars->at(i));
823  auto ov = static_cast<const RooAbsReal*>(other._constPars->find(tv->GetName())) ;
824  if (!ov) {
825  cout << "RooFitResult::isIdentical: cannot find constant parameter " << _constPars->at(i)->GetName() << " in reference" << endl ;
826  ret = kFALSE ;
827  }
828  if (ov && deviation(tv->getVal(), ov->getVal())) {
829  errMsg("constant parameter", tv, ov);
830  ret = kFALSE ;
831  }
832  }
833 
834  for (Int_t i=0 ; i<_initPars->getSize() ; i++) {
835  auto ov = static_cast<const RooAbsReal*>(other._initPars->find(_initPars->at(i)->GetName())) ;
836  auto tv = static_cast<const RooAbsReal*>(_initPars->at(i));
837  if (!ov) {
838  cout << "RooFitResult::isIdentical: cannot find initial parameter " << _initPars->at(i)->GetName() << " in reference" << endl ;
839  ret = kFALSE ;
840  }
841  if (ov && deviation(tv->getVal(), ov->getVal())) {
842  errMsg("initial parameter", tv, ov);
843  ret = kFALSE ;
844  }
845  }
846 
847  for (Int_t i=0 ; i<_finalPars->getSize() ; i++) {
848  auto tv = static_cast<const RooAbsReal*>(_finalPars->at(i));
849  auto ov = static_cast<const RooAbsReal*>(other._finalPars->find(tv->GetName())) ;
850  if (!ov) {
851  cout << "RooFitResult::isIdentical: cannot find final parameter " << tv->GetName() << " in reference" << endl ;
852  ret = kFALSE ;
853  }
854  if (ov && deviation(tv->getVal(), ov->getVal())) {
855  errMsg("final parameter", tv, ov);
856  ret = kFALSE ;
857  }
858  }
859 
860  auto deviationCorr = [tolCorr](const double left, const double right){
861  return fabs(left - right) >= tolCorr;
862  };
863 
864  // Only examine correlations for cases with >1 floating parameter
865  if (_finalPars->getSize()>1) {
866 
868  other.fillLegacyCorrMatrix() ;
869 
870  for (Int_t i=0 ; i<_globalCorr->getSize() ; i++) {
871  auto tv = static_cast<const RooAbsReal*>(_globalCorr->at(i));
872  auto ov = static_cast<const RooAbsReal*>(other._globalCorr->find(_globalCorr->at(i)->GetName())) ;
873  if (!ov) {
874  cout << "RooFitResult::isIdentical: cannot find global correlation coefficient " << tv->GetName() << " in reference" << endl ;
875  ret = kFALSE ;
876  }
877  if (ov && deviationCorr(tv->getVal(), ov->getVal())) {
878  errMsg("global correlation coefficient", tv, ov);
879  ret = kFALSE ;
880  }
881  }
882 
883  for (Int_t j=0 ; j<_corrMatrix.GetSize() ; j++) {
884  RooArgList* row = (RooArgList*) _corrMatrix.At(j) ;
885  RooArgList* orow = (RooArgList*) other._corrMatrix.At(j) ;
886  for (Int_t i=0 ; i<row->getSize() ; i++) {
887  auto tv = static_cast<const RooAbsReal*>(row->at(i));
888  auto ov = static_cast<const RooAbsReal*>(orow->find(tv->GetName())) ;
889  if (!ov) {
890  cout << "RooFitResult::isIdentical: cannot find correlation coefficient " << tv->GetName() << " in reference" << endl ;
891  ret = kFALSE ;
892  }
893  if (ov && deviationCorr(tv->getVal(), ov->getVal())) {
894  errMsg("correlation coefficient", tv, ov);
895  ret = kFALSE ;
896  }
897  }
898  }
899  }
900 
901  return ret ;
902 }
903 
904 
905 
906 ////////////////////////////////////////////////////////////////////////////////
907 /// Import the results of the last fit performed by gMinuit, interpreting
908 /// the fit parameters as the given varList of parameters.
909 
911 {
912  // Verify length of supplied varList
913  if (varList.getSize()>0 && varList.getSize()!=gMinuit->fNu) {
914  oocoutE((TObject*)0,InputArguments) << "RooFitResult::lastMinuitFit: ERROR: supplied variable list must be either empty " << endl
915  << " or match the number of variables of the last fit (" << gMinuit->fNu << ")" << endl ;
916  return 0 ;
917  }
918 
919  // Verify that all members of varList are of type RooRealVar
920  TIter iter = varList.createIterator() ;
921  RooAbsArg* arg ;
922  while((arg=(RooAbsArg*)iter.Next())) {
923  if (!dynamic_cast<RooRealVar*>(arg)) {
924  oocoutE((TObject*)0,InputArguments) << "RooFitResult::lastMinuitFit: ERROR: variable '" << arg->GetName() << "' is not of type RooRealVar" << endl ;
925  return 0 ;
926  }
927  }
928 
929  RooFitResult* r = new RooFitResult("lastMinuitFit","Last MINUIT fit") ;
930 
931  // Extract names of fit parameters from MINUIT
932  // and construct corresponding RooRealVars
933  RooArgList constPars("constPars") ;
934  RooArgList floatPars("floatPars") ;
935 
936  Int_t i ;
937  for (i = 1; i <= gMinuit->fNu; ++i) {
938  if (gMinuit->fNvarl[i-1] < 0) continue;
939  Int_t l = gMinuit->fNiofex[i-1];
940  TString varName(gMinuit->fCpnam[i-1]) ;
941  Bool_t isConst(l==0) ;
942 
943  Double_t xlo = gMinuit->fAlim[i-1];
944  Double_t xhi = gMinuit->fBlim[i-1];
945  Double_t xerr = gMinuit->fWerr[l-1];
946  Double_t xval = gMinuit->fU[i-1] ;
947 
948  RooRealVar* var ;
949  if (varList.getSize()==0) {
950 
951  if ((xlo<xhi) && !isConst) {
952  var = new RooRealVar(varName,varName,xval,xlo,xhi) ;
953  } else {
954  var = new RooRealVar(varName,varName,xval) ;
955  }
956  var->setConstant(isConst) ;
957  } else {
958 
959  var = (RooRealVar*) varList.at(i-1)->Clone() ;
960  var->setConstant(isConst) ;
961  var->setVal(xval) ;
962  if (xlo<xhi) {
963  var->setRange(xlo,xhi) ;
964  }
965  if (varName.CompareTo(var->GetName())) {
966  oocoutI((TObject*)0,Eval) << "RooFitResult::lastMinuitFit: fit parameter '" << varName
967  << "' stored in variable '" << var->GetName() << "'" << endl ;
968  }
969 
970  }
971 
972  if (isConst) {
973  constPars.addOwned(*var) ;
974  } else {
975  var->setError(xerr) ;
976  floatPars.addOwned(*var) ;
977  }
978  }
979 
980  Int_t icode,npari,nparx ;
981  Double_t fmin,edm,errdef ;
982  gMinuit->mnstat(fmin,edm,errdef,npari,nparx,icode) ;
983 
984  r->setConstParList(constPars) ;
985  r->setInitParList(floatPars) ;
986  r->setFinalParList(floatPars) ;
987  r->setMinNLL(fmin) ;
988  r->setEDM(edm) ;
989  r->setCovQual(icode) ;
990  r->setStatus(gMinuit->fStatus) ;
991  r->fillCorrMatrix() ;
992 
993  return r ;
994 }
995 
996 
997 
998 ////////////////////////////////////////////////////////////////////////////////
999 /// Import the results of the last fit performed by gMinuit, interpreting
1000 /// the fit parameters as the given varList of parameters.
1001 
1003 {
1004  // Verify that all members of varList are of type RooRealVar
1005  TIter iter = paramList.createIterator();
1006  RooAbsArg *arg;
1007  while ((arg = (RooAbsArg *)iter.Next())) {
1008  if (!dynamic_cast<RooRealVar *>(arg)) {
1009  oocoutE((TObject *)0, InputArguments) << "RooFitResult::lastMinuitFit: ERROR: variable '" << arg->GetName()
1010  << "' is not of type RooRealVar" << endl;
1011  return nullptr;
1012  }
1013  }
1014 
1015  RooFitResult *r = new RooFitResult("lastMinuitFit", "Last MINUIT fit");
1016 
1017  // Extract names of fit parameters from MINUIT
1018  // and construct corresponding RooRealVars
1019  RooArgList constPars("constPars");
1020  RooArgList floatPars("floatPars");
1021 
1022  iter.Reset();
1023  while ((arg = (RooAbsArg *)iter.Next())) {
1024  if (arg->isConstant()) {
1025  constPars.addClone(*arg);
1026  } else {
1027  floatPars.addClone(*arg);
1028  }
1029  }
1030 
1031  r->setConstParList(constPars);
1032  r->setInitParList(floatPars);
1033  r->setFinalParList(floatPars);
1034  r->setMinNLL(0);
1035  r->setEDM(0);
1036  r->setCovQual(0);
1037  r->setStatus(0);
1038  r->fillPrefitCorrMatrix();
1039 
1040  return r;
1041 }
1042 
1043 ////////////////////////////////////////////////////////////////////////////////
1044 /// Store externally provided correlation matrix in this RooFitResult ;
1045 
1047 {
1048  // Delete any previous matrices
1049  if (_VM) {
1050  delete _VM ;
1051  }
1052  if (_CM) {
1053  delete _CM ;
1054  }
1055 
1056  // Clone input covariance matrix ;
1057  _VM = (TMatrixDSym*) V.Clone() ;
1058 
1059  // Now construct correlation matrix from it
1060  _CM = (TMatrixDSym*) _VM->Clone() ;
1061  for (Int_t i=0 ; i<_CM->GetNrows() ; i++) {
1062  for (Int_t j=0 ; j<_CM->GetNcols() ; j++) {
1063  if (i!=j) {
1064  (*_CM)(i,j) = (*_CM)(i,j) / sqrt((*_CM)(i,i)*(*_CM)(j,j)) ;
1065  }
1066  }
1067  }
1068  for (Int_t i=0 ; i<_CM->GetNrows() ; i++) {
1069  (*_CM)(i,i) = 1.0 ;
1070  }
1071 
1072  _covQual = -1 ;
1073 }
1074 
1075 
1076 
1077 ////////////////////////////////////////////////////////////////////////////////
1078 /// Return TH2D of correlation matrix
1079 
1081 {
1082  Int_t n = _CM->GetNcols() ;
1083 
1084  TH2D* hh = new TH2D(name,name,n,0,n,n,0,n) ;
1085 
1086  for (Int_t i = 0 ; i<n ; i++) {
1087  for (Int_t j = 0 ; j<n; j++) {
1088  hh->Fill(i+0.5,n-j-0.5,(*_CM)(i,j)) ;
1089  }
1090  hh->GetXaxis()->SetBinLabel(i+1,_finalPars->at(i)->GetName()) ;
1091  hh->GetYaxis()->SetBinLabel(n-i,_finalPars->at(i)->GetName()) ;
1092  }
1093  hh->SetMinimum(-1) ;
1094  hh->SetMaximum(+1) ;
1095 
1096 
1097  return hh ;
1098 }
1099 
1100 
1101 
1102 
1103 ////////////////////////////////////////////////////////////////////////////////
1104 /// Return covariance matrix
1105 
1107 {
1108  return *_VM ;
1109 }
1110 
1111 
1112 
1113 
1114 ////////////////////////////////////////////////////////////////////////////////
1115 /// Return a reduced covariance matrix (Note that Vred _is_ a simple sub-matrix of V,
1116 /// row/columns are ordered to matched the convention given in input argument 'params'
1117 
1119 {
1120  const TMatrixDSym& V = covarianceMatrix() ;
1121 
1122 
1123  // Make sure that all given params were floating parameters in the represented fit
1124  RooArgList params2 ;
1125  TIterator* iter = params.createIterator() ;
1126  RooAbsArg* arg ;
1127  while((arg=(RooAbsArg*)iter->Next())) {
1128  if (_finalPars->find(arg->GetName())) {
1129  params2.add(*arg) ;
1130  } else {
1131  coutW(InputArguments) << "RooFitResult::reducedCovarianceMatrix(" << GetName() << ") WARNING input variable "
1132  << arg->GetName() << " was not a floating parameters in fit result and is ignored" << endl ;
1133  }
1134  }
1135  delete iter ;
1136 
1137  // fix for bug ROOT-8044
1138  // use same order given bby vector params
1139  vector<int> indexMap(params2.getSize());
1140  for (int i=0 ; i<params2.getSize() ; i++) {
1141  indexMap[i] = _finalPars->index(params2[i].GetName());
1142  assert(indexMap[i] < V.GetNrows());
1143  }
1144 
1145  TMatrixDSym Vred(indexMap.size());
1146  for (int i = 0; i < Vred.GetNrows(); ++i) {
1147  for (int j = 0; j < Vred.GetNcols(); ++j) {
1148  Vred(i,j) = V( indexMap[i], indexMap[j]);
1149  }
1150  }
1151  return Vred;
1152 }
1153 
1154 
1155 
1156 ////////////////////////////////////////////////////////////////////////////////
1157 /// Return a reduced covariance matrix, which is calculated as
1158 /// \f[
1159 /// V_\mathrm{red} = \bar{V_{22}} = V_{11} - V_{12} \cdot V_{22}^{-1} \cdot V_{21},
1160 /// \f]
1161 /// where \f$ V_{11},V_{12},V_{21},V_{22} \f$ represent a block decomposition of the covariance matrix into observables that
1162 /// are propagated (labeled by index '1') and that are not propagated (labeled by index '2'), and \f$ \bar{V_{22}} \f$
1163 /// is the Shur complement of \f$ V_{22} \f$, calculated as shown above.
1164 ///
1165 /// (Note that \f$ V_\mathrm{red} \f$ is *not* a simple sub-matrix of \f$ V \f$)
1166 
1168 {
1169  const TMatrixDSym& V = covarianceMatrix() ;
1170 
1171  // Handle case where V==Vred here
1172  if (V.GetNcols()==params.getSize()) {
1173  return V ;
1174  }
1175 
1176  Double_t det = V.Determinant() ;
1177 
1178  if (det<=0) {
1179  coutE(Eval) << "RooFitResult::conditionalCovarianceMatrix(" << GetName() << ") ERROR: covariance matrix is not positive definite (|V|="
1180  << det << ") cannot reduce it" << endl ;
1181  throw string("RooFitResult::conditionalCovarianceMatrix() ERROR, input covariance matrix is not positive definite") ;
1182  }
1183 
1184  // Make sure that all given params were floating parameters in the represented fit
1185  RooArgList params2 ;
1186  TIterator* iter = params.createIterator() ;
1187  RooAbsArg* arg ;
1188  while((arg=(RooAbsArg*)iter->Next())) {
1189  if (_finalPars->find(arg->GetName())) {
1190  params2.add(*arg) ;
1191  } else {
1192  coutW(InputArguments) << "RooFitResult::conditionalCovarianceMatrix(" << GetName() << ") WARNING input variable "
1193  << arg->GetName() << " was not a floating parameters in fit result and is ignored" << endl ;
1194  }
1195  }
1196  delete iter ;
1197 
1198  // Need to order params in vector in same order as in covariance matrix
1199  RooArgList params3 ;
1200  iter = _finalPars->createIterator() ;
1201  while((arg=(RooAbsArg*)iter->Next())) {
1202  if (params2.find(arg->GetName())) {
1203  params3.add(*arg) ;
1204  }
1205  }
1206  delete iter ;
1207 
1208  // Find (subset) of parameters that are stored in the covariance matrix
1209  vector<int> map1, map2 ;
1210  for (int i=0 ; i<_finalPars->getSize() ; i++) {
1211  if (params3.find(_finalPars->at(i)->GetName())) {
1212  map1.push_back(i) ;
1213  } else {
1214  map2.push_back(i) ;
1215  }
1216  }
1217 
1218  // Rearrange matrix in block form with 'params' first and 'others' last
1219  // (preserving relative order)
1220  TMatrixDSym S11, S22 ;
1221  TMatrixD S12, S21 ;
1222  RooMultiVarGaussian::blockDecompose(V,map1,map2,S11,S12,S21,S22) ;
1223 
1224  // Constructed conditional matrix form -1
1225  // F(X1|X2) --> CovI --> S22bar = S11 - S12 S22 S21
1226 
1227  // Do eigenvalue decomposition
1228  TMatrixD S22Inv(TMatrixD::kInverted,S22) ;
1229  TMatrixD S22bar = S11 - S12 * (S22Inv * S21) ;
1230 
1231  // Convert explicitly to symmetric form
1232  TMatrixDSym Vred(S22bar.GetNcols()) ;
1233  for (int i=0 ; i<Vred.GetNcols() ; i++) {
1234  for (int j=i ; j<Vred.GetNcols() ; j++) {
1235  Vred(i,j) = (S22bar(i,j) + S22bar(j,i))/2 ;
1236  Vred(j,i) = Vred(i,j) ;
1237  }
1238  }
1239 
1240  return Vred ;
1241 }
1242 
1243 
1244 
1245 ////////////////////////////////////////////////////////////////////////////////
1246 /// Return correlation matrix ;
1247 
1249 {
1250  return *_CM ;
1251 }
1252 
1253 
1254 
1255 ////////////////////////////////////////////////////////////////////////////////
1256 /// Return a p.d.f that represents the fit result as a multi-variate probability densisty
1257 /// function on the floating fit parameters, including correlations
1258 
1260 {
1261  const TMatrixDSym& V = covarianceMatrix() ;
1262  Double_t det = V.Determinant() ;
1263 
1264  if (det<=0) {
1265  coutE(Eval) << "RooFitResult::createHessePdf(" << GetName() << ") ERROR: covariance matrix is not positive definite (|V|="
1266  << det << ") cannot construct p.d.f" << endl ;
1267  return 0 ;
1268  }
1269 
1270  // Make sure that all given params were floating parameters in the represented fit
1271  RooArgList params2 ;
1272  TIterator* iter = params.createIterator() ;
1273  RooAbsArg* arg ;
1274  while((arg=(RooAbsArg*)iter->Next())) {
1275  if (_finalPars->find(arg->GetName())) {
1276  params2.add(*arg) ;
1277  } else {
1278  coutW(InputArguments) << "RooFitResult::createHessePdf(" << GetName() << ") WARNING input variable "
1279  << arg->GetName() << " was not a floating parameters in fit result and is ignored" << endl ;
1280  }
1281  }
1282  delete iter ;
1283 
1284  // Need to order params in vector in same order as in covariance matrix
1285  RooArgList params3 ;
1286  iter = _finalPars->createIterator() ;
1287  while((arg=(RooAbsArg*)iter->Next())) {
1288  if (params2.find(arg->GetName())) {
1289  params3.add(*arg) ;
1290  }
1291  }
1292  delete iter ;
1293 
1294 
1295  // Handle special case of representing full covariance matrix here
1296  if (params3.getSize()==_finalPars->getSize()) {
1297 
1298  RooArgList mu ;
1299  for (Int_t i=0 ; i<_finalPars->getSize() ; i++) {
1300  RooRealVar* parclone = (RooRealVar*) _finalPars->at(i)->Clone(Form("%s_centralvalue",_finalPars->at(i)->GetName())) ;
1301  parclone->setConstant(kTRUE) ;
1302  mu.add(*parclone) ;
1303  }
1304 
1305  string name = Form("pdf_%s",GetName()) ;
1306  string title = Form("P.d.f of %s",GetTitle()) ;
1307 
1308  // Create p.d.f.
1309  RooAbsPdf* mvg = new RooMultiVarGaussian(name.c_str(),title.c_str(),params3,mu,V) ;
1310  mvg->addOwnedComponents(mu) ;
1311  return mvg ;
1312  }
1313 
1314  // -> ->
1315  // Handle case of conditional p.d.f. MVG(p1|p2) here
1316 
1317  // Find (subset) of parameters that are stored in the covariance matrix
1318  vector<int> map1, map2 ;
1319  for (int i=0 ; i<_finalPars->getSize() ; i++) {
1320  if (params3.find(_finalPars->at(i)->GetName())) {
1321  map1.push_back(i) ;
1322  } else {
1323  map2.push_back(i) ;
1324  }
1325  }
1326 
1327  // Rearrange matrix in block form with 'params' first and 'others' last
1328  // (preserving relative order)
1329  TMatrixDSym S11, S22 ;
1330  TMatrixD S12, S21 ;
1331  RooMultiVarGaussian::blockDecompose(V,map1,map2,S11,S12,S21,S22) ;
1332 
1333  // Calculate offset vectors mu1 and mu2
1334  RooArgList mu1 ;
1335  for (UInt_t i=0 ; i<map1.size() ; i++) {
1336  RooRealVar* parclone = (RooRealVar*) _finalPars->at(map1[i])->Clone(Form("%s_centralvalue",_finalPars->at(map1[i])->GetName())) ;
1337  parclone->setConstant(kTRUE) ;
1338  mu1.add(*parclone) ;
1339  }
1340 
1341  // Constructed conditional matrix form -1
1342  // F(X1|X2) --> CovI --> S22bar = S11 - S12 S22 S21
1343 
1344  // Do eigenvalue decomposition
1345  TMatrixD S22Inv(TMatrixD::kInverted,S22) ;
1346  TMatrixD S22bar = S11 - S12 * (S22Inv * S21) ;
1347 
1348  // Convert explicitly to symmetric form
1349  TMatrixDSym Vred(S22bar.GetNcols()) ;
1350  for (int i=0 ; i<Vred.GetNcols() ; i++) {
1351  for (int j=i ; j<Vred.GetNcols() ; j++) {
1352  Vred(i,j) = (S22bar(i,j) + S22bar(j,i))/2 ;
1353  Vred(j,i) = Vred(i,j) ;
1354  }
1355  }
1356  string name = Form("pdf_%s",GetName()) ;
1357  string title = Form("P.d.f of %s",GetTitle()) ;
1358 
1359  // Create p.d.f.
1360  RooAbsPdf* ret = new RooMultiVarGaussian(name.c_str(),title.c_str(),params3,mu1,Vred) ;
1361  ret->addOwnedComponents(mu1) ;
1362  return ret ;
1363 }
1364 
1365 
1366 
1367 ////////////////////////////////////////////////////////////////////////////////
1368 /// Change name of RooFitResult object
1369 
1370 void RooFitResult::SetName(const char *name)
1371 {
1372  if (_dir) _dir->GetList()->Remove(this);
1374  if (_dir) _dir->GetList()->Add(this);
1375 }
1376 
1377 
1378 ////////////////////////////////////////////////////////////////////////////////
1379 /// Change name and title of RooFitResult object
1380 
1381 void RooFitResult::SetNameTitle(const char *name, const char* title)
1382 {
1383  if (_dir) _dir->GetList()->Remove(this);
1384  TNamed::SetNameTitle(name,title) ;
1385  if (_dir) _dir->GetList()->Add(this);
1386 }
1387 
1388 
1389 ////////////////////////////////////////////////////////////////////////////////
1390 /// Print name of fit result
1391 
1392 void RooFitResult::printName(ostream& os) const
1393 {
1394  os << GetName() ;
1395 }
1396 
1397 
1398 ////////////////////////////////////////////////////////////////////////////////
1399 /// Print title of fit result
1400 
1401 void RooFitResult::printTitle(ostream& os) const
1402 {
1403  os << GetTitle() ;
1404 }
1405 
1406 
1407 ////////////////////////////////////////////////////////////////////////////////
1408 /// Print class name of fit result
1409 
1410 void RooFitResult::printClassName(ostream& os) const
1411 {
1412  os << IsA()->GetName() ;
1413 }
1414 
1415 
1416 ////////////////////////////////////////////////////////////////////////////////
1417 /// Print arguments of fit result, i.e. the parameters of the fit
1418 
1419 void RooFitResult::printArgs(ostream& os) const
1420 {
1421  os << "[constPars=" << *_constPars << ",floatPars=" << *_finalPars << "]" ;
1422 }
1423 
1424 
1425 
1426 ////////////////////////////////////////////////////////////////////////////////
1427 /// Print the value of the fit result, i.e.g the status, minimized FCN, edm and covariance quality code
1428 
1429 void RooFitResult::printValue(ostream& os) const
1430 {
1431  os << "(status=" << _status << ",FCNmin=" << _minNLL << ",EDM=" << _edm << ",covQual=" << _covQual << ")" ;
1432 }
1433 
1434 
1435 ////////////////////////////////////////////////////////////////////////////////
1436 /// Configure default contents to be printed
1437 
1439 {
1440  return kName|kClassName|kArgs|kValue ;
1441 }
1442 
1443 
1444 ////////////////////////////////////////////////////////////////////////////////
1445 /// Configure mapping of Print() arguments to RooPrintable print styles
1446 
1448 {
1449  if (!opt || strlen(opt)==0) {
1450  return kStandard ;
1451  }
1452  return RooPrintable::defaultPrintStyle(opt) ;
1453 }
1454 
1455 
1456 ////////////////////////////////////////////////////////////////////////////////
1457 /// Stream an object of class RooFitResult.
1458 
1459 void RooFitResult::Streamer(TBuffer &R__b)
1460 {
1461  if (R__b.IsReading()) {
1462  UInt_t R__s, R__c;
1463  Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
1464  if (R__v>3) {
1465  R__b.ReadClassBuffer(RooFitResult::Class(),this,R__v,R__s,R__c);
1468  } else {
1469  // backward compatibitily streaming
1470  TNamed::Streamer(R__b);
1471  RooPrintable::Streamer(R__b);
1472  RooDirItem::Streamer(R__b);
1473  R__b >> _status;
1474  R__b >> _covQual;
1475  R__b >> _numBadNLL;
1476  R__b >> _minNLL;
1477  R__b >> _edm;
1478  R__b >> _constPars;
1479  R__b >> _initPars;
1480  R__b >> _finalPars;
1481  R__b >> _globalCorr;
1482  _corrMatrix.Streamer(R__b);
1483  R__b.CheckByteCount(R__s, R__c, RooFitResult::IsA());
1484 
1485  // Now fill new-style covariance and correlation matrix information
1486  // from legacy form
1487  _CM = new TMatrixDSym(_finalPars->getSize()) ;
1488  _VM = new TMatrixDSym(_CM->GetNcols()) ;
1489  _GC = new TVectorD(_CM->GetNcols()) ;
1490 
1491  TIterator *gcIter = _globalCorr->createIterator() ;
1492  TIterator *parIter = _finalPars->createIterator() ;
1493  RooRealVar* gcVal = 0;
1494  for (unsigned int i = 0; i < (unsigned int)_CM->GetNcols() ; ++i) {
1495 
1496  // Find the next global correlation slot to fill, skipping fixed parameters
1497  gcVal = (RooRealVar*) gcIter->Next() ;
1498  (*_GC)(i) = gcVal->getVal() ;
1499 
1500  // Fill a row of the correlation matrix
1501  TIterator* cIter = ((RooArgList*)_corrMatrix.At(i))->createIterator() ;
1502  for (unsigned int it = 0; it < (unsigned int)_CM->GetNcols() ; ++it) {
1503  RooRealVar* cVal = (RooRealVar*) cIter->Next() ;
1504  double value = cVal->getVal() ;
1505  (*_CM)(it,i) = value ;
1506  (*_CM)(i,it) = value;
1507  (*_VM)(it,i) = value*((RooRealVar*)_finalPars->at(i))->getError()*((RooRealVar*)_finalPars->at(it))->getError() ;
1508  (*_VM)(i,it) = (*_VM)(it,i) ;
1509  }
1510  delete cIter ;
1511  }
1512 
1513  delete gcIter ;
1514  delete parIter ;
1515  }
1516 
1517  } else {
1519  }
1520 }
1521 
RooAbsArg::Clone
virtual TObject * Clone(const char *newname=0) const
Make a clone of an object using the Streamer facility.
Definition: RooAbsArg.h:84
RooDirItem::removeFromDir
void removeFromDir(TObject *obj)
Remove object from directory it was added to.
Definition: RooDirItem.cxx:43
l
auto * l
Definition: textangle.C:4
m
auto * m
Definition: textangle.C:8
RooMultiVarGaussian.h
n
const Int_t n
Definition: legend1.C:16
RooFitResult::SetNameTitle
void SetNameTitle(const char *name, const char *title)
Change name and title of RooFitResult object.
Definition: RooFitResult.cxx:1381
TMatrixT< Double_t >::kInverted
@ kInverted
Definition: TMatrixT.h:58
RooFitResult::defaultPrintStyle
virtual StyleOption defaultPrintStyle(Option_t *opt) const
Configure mapping of Print() arguments to RooPrintable print styles.
Definition: RooFitResult.cxx:1447
RooFit::Minimization
@ Minimization
Definition: RooGlobalFunc.h:67
RooRealVar::setVal
virtual void setVal(Double_t value)
Set value of variable to 'value'.
Definition: RooRealVar.cxx:257
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:95
TDirectory::GetList
virtual TList * GetList() const
Definition: TDirectory.h:213
TLine.h
RooFitResult::printMultiline
void printMultiline(std::ostream &os, Int_t contents, Bool_t verbose=kFALSE, TString indent="") const
Print fit result to stream 'os'.
Definition: RooFitResult.cxx:501
Version_t
short Version_t
Definition: RtypesCore.h:65
RooMsgService.h
RooFitResult::setInitParList
void setInitParList(const RooArgList &list)
Fill the list of initial values of the floating parameters.
Definition: RooFitResult.cxx:157
TDirectory.h
TNamed::SetNameTitle
virtual void SetNameTitle(const char *name, const char *title)
Set all the TNamed parameters (name and title).
Definition: TNamed.cxx:154
TLine
A simple line.
Definition: TLine.h:22
RooFitResult::_constPars
RooArgList * _constPars
Definition: RooFitResult.h:187
TNamed::SetName
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition: TNamed.cxx:140
RooFitResult::fillCorrMatrix
void fillCorrMatrix()
Internal utility method to extract the correlation matrix and the global correlation coefficients fro...
Definition: RooFitResult.cxx:714
Option_t
const char Option_t
Definition: RtypesCore.h:66
RooDirItem::_dir
TDirectory * _dir
Definition: RooDirItem.h:33
TMath::Max
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:212
RooFit.h
RooFitResult::printValue
virtual void printValue(std::ostream &os) const
Print the value of the fit result, i.e.g the status, minimized FCN, edm and covariance quality code.
Definition: RooFitResult.cxx:1429
RooFit::InputArguments
@ InputArguments
Definition: RooGlobalFunc.h:68
oocoutI
#define oocoutI(o, a)
Definition: RooMsgService.h:45
TH1::SetMinimum
virtual void SetMinimum(Double_t minimum=-1111)
Definition: TH1.h:399
RooArgSet.h
TList::Delete
virtual void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: TList.cxx:470
TString::Data
const char * Data() const
Definition: TString.h:369
RooPrintable::kStandard
@ kStandard
Definition: RooPrintable.h:34
RooFitResult::statusCodeHistory
Int_t statusCodeHistory(UInt_t icycle) const
Definition: RooFitResult.cxx:197
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
Form
char * Form(const char *fmt,...)
TNamed::GetTitle
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:48
RooAbsArg::ioStreamerPass2Finalize
static void ioStreamerPass2Finalize()
Method called by workspace container to finalize schema evolution issues that cannot be handled in a ...
Definition: RooAbsArg.cxx:2372
TBuffer::ReadClassBuffer
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=0)=0
r
ROOT::R::TRInterface & r
Definition: Object.C:4
RooMultiVarGaussian
Multivariate Gaussian p.d.f.
Definition: RooMultiVarGaussian.h:31
coutE
#define coutE(a)
Definition: RooMsgService.h:33
RooFitResult::plotOn
RooPlot * plotOn(RooPlot *frame, const RooAbsArg &par1, const RooAbsArg &par2, const char *options="ME") const
Add objects to a 2D plot.
Definition: RooFitResult.h:144
coutW
#define coutW(a)
Definition: RooMsgService.h:32
RooArgList
RooArgList is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgList.h:21
RooPrintable::StyleOption
StyleOption
Definition: RooPrintable.h:34
TMath::Sqrt
Double_t Sqrt(Double_t x)
Definition: TMath.h:691
RooDirItem
RooDirItem is a utility base class for RooFit objects that are to be attached to ROOT directories.
Definition: RooDirItem.h:22
TCollection::SetOwner
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
Definition: TCollection.cxx:746
RooAbsReal::getVal
Double_t getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
Definition: RooAbsReal.h:91
RooFitResult::createHessePdf
RooAbsPdf * createHessePdf(const RooArgSet &params) const
Return a p.d.f that represents the fit result as a multi-variate probability densisty function on the...
Definition: RooFitResult.cxx:1259
RooFitResult::_Lt
TMatrixF * _Lt
List of floating parameters with most recent random perturbation applied.
Definition: RooFitResult.h:195
RooFitResult::~RooFitResult
virtual ~RooFitResult()
Destructor.
Definition: RooFitResult.cxx:115
RooFitResult::setFinalParList
void setFinalParList(const RooArgList &list)
Fill the list of final values of the floating parameters.
Definition: RooFitResult.cxx:177
box
void box(Int_t pat, Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Definition: fillpatterns.C:1
RooAbsCollection::find
RooAbsArg * find(const char *name) const
Find object with given name in list.
Definition: RooAbsCollection.cxx:813
RooFitResult::_edm
Double_t _edm
Definition: RooFitResult.h:186
TString::Contains
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:624
RooFitResult::setCovarianceMatrix
void setCovarianceMatrix(TMatrixDSym &V)
Store externally provided correlation matrix in this RooFitResult ;.
Definition: RooFitResult.cxx:1046
coutI
#define coutI(a)
Definition: RooMsgService.h:30
RooFitResult::_statusHistory
std::vector< std::pair< std::string, int > > _statusHistory
Definition: RooFitResult.h:201
TClass.h
indent
static void indent(ostringstream &buf, int indent_level)
Definition: TClingCallFunc.cxx:87
RooAbsReal
RooAbsReal is the common abstract base class for objects that represent a real value and implements f...
Definition: RooAbsReal.h:61
TIter::Reset
void Reset()
Definition: TCollection.h:252
TMatrixTSym< Double_t >
TMinuit::fCpnam
TString * fCpnam
Character to be plotted at the X,Y contour positions.
Definition: TMinuit.h:165
RooArgList::at
RooAbsArg * at(Int_t idx) const
Return object at given index, or nullptr if index is out of range.
Definition: RooArgList.h:70
TMath::Abs
Short_t Abs(Short_t d)
Definition: TMathBase.h:120
TBuffer
Buffer base class used for serializing objects.
Definition: TBuffer.h:43
TAttLine::SetLineColor
virtual void SetLineColor(Color_t lcolor)
Set the line color.
Definition: TAttLine.h:40
TMinuit::fNvarl
Int_t * fNvarl
Definition: TMinuit.h:126
oocoutE
#define oocoutE(o, a)
Definition: RooMsgService.h:48
RooFitResult::_corrMatrix
TList _corrMatrix
List of global correlation coefficients.
Definition: RooFitResult.h:192
TBuffer::CheckByteCount
virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss)=0
TString
Basic string class.
Definition: TString.h:136
TMinuit::mnstat
virtual void mnstat(Double_t &fmin, Double_t &fedm, Double_t &errdef, Int_t &npari, Int_t &nparx, Int_t &istat)
Returns concerning the current status of the minimization.
Definition: TMinuit.cxx:7637
TMatrixT
TMatrixT.
Definition: TMatrixT.h:39
RooRealVar::setRange
void setRange(const char *name, Double_t min, Double_t max)
Set a fit or plotting range.
Definition: RooRealVar.cxx:526
RooPrintable
RooPlotable is a 'mix-in' base class that define the standard RooFit plotting and printing methods.
Definition: RooPrintable.h:25
TMinuit::fVhmat
Double_t * fVhmat
Definition: TMinuit.h:89
RooFitResult::_CM
TMatrixDSym * _CM
triangular matrix used for generate random perturbations
Definition: RooFitResult.h:197
RooFitResult::correlationHist
TH2 * correlationHist(const char *name="correlation_matrix") const
Return TH2D of correlation matrix.
Definition: RooFitResult.cxx:1080
RooFitResult::reducedCovarianceMatrix
TMatrixDSym reducedCovarianceMatrix(const RooArgList &params) const
Return a reduced covariance matrix (Note that Vred is a simple sub-matrix of V, row/columns are order...
Definition: RooFitResult.cxx:1118
RooFitResult::covariance
Double_t covariance(Int_t row, Int_t col) const
Return the covariance matrix element addressed with numeric indices.
Definition: RooFitResult.cxx:489
bool
TMatrix.h
TIterator
Iterator abstract base class.
Definition: TIterator.h:30
RooFitResult
RooFitResult is a container class to hold the input and output of a PDF fit to a dataset.
Definition: RooFitResult.h:40
RooFitResult::conditionalCovarianceMatrix
TMatrixDSym conditionalCovarianceMatrix(const RooArgList &params) const
Return a reduced covariance matrix, which is calculated as.
Definition: RooFitResult.cxx:1167
RooFitResult::fillLegacyCorrMatrix
void fillLegacyCorrMatrix() const
Sanity check.
Definition: RooFitResult.cxx:631
TMatrixDSym.h
gMinuit
R__EXTERN TMinuit * gMinuit
Definition: TMinuit.h:271
RooFitResult::RooFitResult
RooFitResult(const char *name=0, const char *title=0)
Constructor with name and title.
Definition: RooFitResult.cxx:69
x1
static const double x1[5]
Definition: RooGaussKronrodIntegrator1D.cxx:346
RooFitResult::isIdentical
Bool_t isIdentical(const RooFitResult &other, Double_t tol=1e-6, Double_t tolCorr=1e-4, Bool_t verbose=kTRUE) const
Return true if this fit result is identical to other within tolerances.
Definition: RooFitResult.cxx:800
TMinuit::fBlim
Double_t * fBlim
Definition: TMinuit.h:70
TString::ToUpper
void ToUpper()
Change string to upper case.
Definition: TString.cxx:1160
TGeant4Unit::L
static constexpr double L
Definition: TGeant4SystemOfUnits.h:117
RooPlot::addObject
void addObject(TObject *obj, Option_t *drawOptions="", Bool_t invisible=kFALSE)
Add a generic object to this plot.
Definition: RooPlot.cxx:422
RooFitResult::_randomPars
RooArgList * _randomPars
Correlation matrix (list of RooArgLists)
Definition: RooFitResult.h:194
RooFitResult::_status
Int_t _status
Definition: RooFitResult.h:182
TList::At
virtual TObject * At(Int_t idx) const
Returns the object at position idx. Returns 0 if idx is out of range.
Definition: TList.cxx:357
kBlack
@ kBlack
Definition: Rtypes.h:65
TMinuit::fMATUvline
Double_t * fMATUvline
Definition: TMinuit.h:107
ROOT::Math::fabs
VecExpr< UnaryOp< Fabs< T >, VecExpr< A, T, D >, T >, T, D > fabs(const VecExpr< A, T, D > &rhs)
Definition: UnaryOperators.h:131
RooFitResult::_numBadNLL
Int_t _numBadNLL
Definition: RooFitResult.h:184
RooFitResult::printName
virtual void printName(std::ostream &os) const
Print name of fit result.
Definition: RooFitResult.cxx:1392
RooPrintable::kName
@ kName
Definition: RooPrintable.h:33
RooFitResult::setConstParList
void setConstParList(const RooArgList &list)
Fill the list of constant parameters.
Definition: RooFitResult.cxx:137
RooEllipse
A RooEllipse is a two-dimensional ellipse that can be used to represent an error contour.
Definition: RooEllipse.h:22
TMinuit::fGlobcc
Double_t * fGlobcc
Definition: TMinuit.h:74
RooPlot::addPlotable
void addPlotable(RooPlotable *plotable, Option_t *drawOptions="", Bool_t invisible=kFALSE, Bool_t refreshNorm=kFALSE)
Add the specified plotable object to our plot.
Definition: RooPlot.cxx:570
TBuffer.h
RooRealVar::getError
Double_t getError() const
Definition: RooRealVar.h:60
RooFitResult::fillPrefitCorrMatrix
void fillPrefitCorrMatrix()
Definition: RooFitResult.cxx:770
TH1::GetYaxis
TAxis * GetYaxis()
Definition: TH1.h:321
TH2D.h
TBox.h
TMarker.h
TMatrixTSym::Determinant
virtual Double_t Determinant() const
Definition: TMatrixTSym.cxx:935
RooFitResult::statusLabelHistory
const char * statusLabelHistory(UInt_t icycle) const
Definition: RooFitResult.cxx:211
RooFitResult::_globalCorr
RooArgList * _globalCorr
Definition: RooFitResult.h:191
TAttMarker::SetMarkerColor
virtual void SetMarkerColor(Color_t mcolor=1)
Set the marker color.
Definition: TAttMarker.h:38
RooAbsCollection::addClone
virtual RooAbsArg * addClone(const RooAbsArg &var, Bool_t silent=kFALSE)
Add a clone of the specified argument to list.
Definition: RooAbsCollection.cxx:412
RooFitResult::randomizePars
const RooArgList & randomizePars() const
Generate random perturbations of the final parameters using the covariance matrix.
Definition: RooFitResult.cxx:346
TNamed
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
TBuffer::WriteClassBuffer
virtual Int_t WriteClassBuffer(const TClass *cl, void *pointer)=0
RooFitResult::_covQual
Int_t _covQual
Definition: RooFitResult.h:183
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:96
TString::Append
TString & Append(const char *cs)
Definition: TString.h:564
RooRealVar::setError
void setError(Double_t value)
Definition: RooRealVar.h:62
RooRandom.h
s1
#define s1(x)
Definition: RSha256.hxx:91
RooEllipse.h
TH2D
2-D histogram with a double per channel (see TH1 documentation)}
Definition: TH2.h:292
RooPlot.h
TH1::SetMaximum
virtual void SetMaximum(Double_t maximum=-1111)
Definition: TH1.h:398
RooAbsCollection::createIterator
TIterator * createIterator(Bool_t dir=kIterForward) const
TIterator-style iteration over contained elements.
Definition: RooAbsCollection.h:129
RooPrintable::kArgs
@ kArgs
Definition: RooPrintable.h:33
TH2
Service class for 2-Dim histogram classes.
Definition: TH2.h:30
RooPlot
A RooPlot is a plot frame and a container for graphics objects within that frame.
Definition: RooPlot.h:44
TMinuit::fNpar
Int_t fNpar
Definition: TMinuit.h:41
RooAbsCollection::add
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE)
Add the specified argument to list.
Definition: RooAbsCollection.cxx:437
RooFitResult::prefitResult
static RooFitResult * prefitResult(const RooArgList &paramList)
Import the results of the last fit performed by gMinuit, interpreting the fit parameters as the given...
Definition: RooFitResult.cxx:1002
RooPrintable::kValue
@ kValue
Definition: RooPrintable.h:33
RooFitResult::printArgs
virtual void printArgs(std::ostream &os) const
Print arguments of fit result, i.e. the parameters of the fit.
Definition: RooFitResult.cxx:1419
sqrt
double sqrt(double)
RooRealVar.h
RooFitResult::correlation
Double_t correlation(const RooAbsArg &par1, const RooAbsArg &par2) const
Return correlation between par1 and par2.
Definition: RooFitResult.h:118
kRed
@ kRed
Definition: Rtypes.h:66
line
TLine * line
Definition: entrylistblock_figure1.C:235
RooDirItem::appendToDir
void appendToDir(TObject *obj, Bool_t forceMemoryResident=kFALSE)
Append object to directory.
Definition: RooDirItem.cxx:55
TBuffer::ReadVersion
virtual Version_t ReadVersion(UInt_t *start=0, UInt_t *bcnt=0, const TClass *cl=0)=0
RooAbsCollection::addOwned
virtual Bool_t addOwned(RooAbsArg &var, Bool_t silent=kFALSE)
Add the specified argument to list.
Definition: RooAbsCollection.cxx:389
RooFitResult.h
TMath::Min
Short_t Min(Short_t a, Short_t b)
Definition: TMathBase.h:180
TIterator::Next
virtual TObject * Next()=0
TH2::Fill
Int_t Fill(Double_t)
Invalid Fill method.
Definition: TH2.cxx:294
unsigned int
RooFitResult::printTitle
virtual void printTitle(std::ostream &os) const
Print title of fit result.
Definition: RooFitResult.cxx:1401
TMinuit::fNiofex
Int_t * fNiofex
Definition: TMinuit.h:127
TMinuit::fStatus
Int_t fStatus
Definition: TMinuit.h:154
TGaxis.h
TMinuit::fNu
Int_t fNu
Definition: TMinuit.h:130
TBox
Create a Box.
Definition: TBox.h:22
TAttLine::SetLineWidth
virtual void SetLineWidth(Width_t lwidth)
Set the line width.
Definition: TAttLine.h:43
TAxis::SetBinLabel
virtual void SetBinLabel(Int_t bin, const char *label)
Set label for bin.
Definition: TAxis.cxx:823
TIter::Next
TObject * Next()
Definition: TCollection.h:249
TBuffer::IsReading
Bool_t IsReading() const
Definition: TBuffer.h:86
TVectorT
TVectorT.
Definition: TVectorT.h:27
TVector.h
RooPrintable::kClassName
@ kClassName
Definition: RooPrintable.h:33
TString::CompareTo
int CompareTo(const char *cs, ECaseCompare cmp=kExact) const
Compare a string to char *cs2.
Definition: TString.cxx:439
Double_t
double Double_t
Definition: RtypesCore.h:59
RooAbsArg::addOwnedComponents
Bool_t addOwnedComponents(const RooArgSet &comps)
Take ownership of the contents of 'comps'.
Definition: RooAbsArg.cxx:2180
RooFitResult::printClassName
virtual void printClassName(std::ostream &os) const
Print class name of fit result.
Definition: RooFitResult.cxx:1410
TList::Remove
virtual TObject * Remove(TObject *obj)
Remove object from the list.
Definition: TList.cxx:822
TVectorD
TVectorT< Double_t > TVectorD
Definition: TVectorDfwd.h:22
RooFitResult::_finalPars
RooArgList * _finalPars
Definition: RooFitResult.h:189
TCollection::GetSize
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TCollection.h:182
TGaxis
The axis painter class.
Definition: TGaxis.h:23
TMinuit.h
RooRandom::gaussian
static Double_t gaussian(TRandom *generator=randomGenerator())
Return a Gaussian random variable with mean 0 and variance 1.
Definition: RooRandom.cxx:110
TMatrixT::kTransposed
@ kTransposed
Definition: TMatrixT.h:58
RooFitResult::globalCorr
const RooArgList * globalCorr()
Return the list of all global correlations.
Definition: RooFitResult.cxx:466
TMinuit::fU
Double_t * fU
Definition: TMinuit.h:68
TList::Add
virtual void Add(TObject *obj)
Definition: TList.h:87
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
RooFitResult::_minNLL
Double_t _minNLL
Definition: RooFitResult.h:185
RooMultiVarGaussian::blockDecompose
static void blockDecompose(const TMatrixD &input, const std::vector< int > &map1, const std::vector< int > &map2, TMatrixDSym &S11, TMatrixD &S12, TMatrixD &S21, TMatrixDSym &S22)
Block decomposition of covI according to given maps of observables.
Definition: RooMultiVarGaussian.cxx:617
RooFitResult::lastMinuitFit
static RooFitResult * lastMinuitFit(const RooArgList &varList=RooArgList())
Import the results of the last fit performed by gMinuit, interpreting the fit parameters as the given...
Definition: RooFitResult.cxx:910
RooFitResult::edm
Double_t edm() const
Return estimated distance to minimum.
Definition: RooFitResult.h:95
name
char name[80]
Definition: TGX11.cxx:110
RooAbsRealLValue::setConstant
void setConstant(Bool_t value=kTRUE)
Definition: RooAbsRealLValue.h:115
TMinuit::fWerr
Double_t * fWerr
Definition: TMinuit.h:73
kBlue
@ kBlue
Definition: Rtypes.h:66
kDashed
@ kDashed
Definition: TAttLine.h:48
genreflex::verbose
bool verbose
Definition: rootcling_impl.cxx:133
x2
static const double x2[5]
Definition: RooGaussKronrodIntegrator1D.cxx:364
RooFitResult::floatParsFinal
const RooArgList & floatParsFinal() const
Return list of floarting parameters after fit.
Definition: RooFitResult.h:111
TIter
Definition: TCollection.h:233
RooAbsArg
RooAbsArg is the common abstract base class for objects that represent a value and a "shape" in RooFi...
Definition: RooAbsArg.h:72
RooFitResult::correlationMatrix
const TMatrixDSym & correlationMatrix() const
Return correlation matrix ;.
Definition: RooFitResult.cxx:1248
RooFitResult::_GC
TVectorD * _GC
Definition: RooFitResult.h:199
TMarker
Manages Markers.
Definition: TMarker.h:22
RooAbsPdf
Definition: RooAbsPdf.h:43
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
TCollection::RemoveAll
virtual void RemoveAll(TCollection *col)
Remove all objects in collection col from this collection.
Definition: TCollection.cxx:594
RooPrintable::defaultPrintStyle
virtual StyleOption defaultPrintStyle(Option_t *opt) const
Definition: RooPrintable.cxx:241
Class
void Class()
Definition: Class.C:29
TMatrixDSym
TMatrixTSym< Double_t > TMatrixDSym
Definition: TMatrixDSymfwd.h:22
RooRealVar
RooRealVar represents a variable that can be changed from the outside.
Definition: RooRealVar.h:39
TH1::GetXaxis
TAxis * GetXaxis()
Get the behaviour adopted by the object about the statoverflows. See EStatOverflows for more informat...
Definition: TH1.h:320
RooFit::Eval
@ Eval
Definition: RooGlobalFunc.h:68
RooFitResult::defaultPrintContents
virtual Int_t defaultPrintContents(Option_t *opt) const
Configure default contents to be printed.
Definition: RooFitResult.cxx:1438
TMatrix
TMatrixT< Float_t > TMatrix
Definition: TMatrix.h:24
TAttLine::SetLineStyle
virtual void SetLineStyle(Style_t lstyle)
Set the line style.
Definition: TAttLine.h:42
RooFitResult::_initPars
RooArgList * _initPars
Definition: RooFitResult.h:188
RooArgList.h
for
for(Int_t i=0;i< n;i++)
Definition: legend1.C:18
RooRealVar::deleteSharedProperties
void deleteSharedProperties()
Stop sharing properties.
Definition: RooRealVar.cxx:1312
TText.h
TMinuit::fAlim
Double_t * fAlim
Definition: TMinuit.h:69
RooFitResult::_VM
TMatrixDSym * _VM
Definition: RooFitResult.h:198
RooAbsArg::isConstant
Bool_t isConstant() const
Check if the "Constant" attribute is set.
Definition: RooAbsArg.h:360
RooAbsCollection::getSize
Int_t getSize() const
Definition: RooAbsCollection.h:182
RooFitResult::constPars
const RooArgList & constPars() const
Return list of constant parameters.
Definition: RooFitResult.h:103
RooFitResult::SetName
void SetName(const char *name)
Change name of RooFitResult object.
Definition: RooFitResult.cxx:1370
TMath.h
RooArgSet
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:29
RooAbsCollection::index
Int_t index(const RooAbsArg *arg) const
Returns index of given arg, or -1 if arg is not in the collection.
Definition: RooAbsCollection.h:198
RooAbsCollection::snapshot
RooAbsCollection * snapshot(Bool_t deepCopy=kTRUE) const
Take a snap shot of current collection contents.
Definition: RooAbsCollection.cxx:201
RooFitResult::covarianceMatrix
const TMatrixDSym & covarianceMatrix() const
Return covariance matrix.
Definition: RooFitResult.cxx:1106
int
g
#define g(i)
Definition: RSha256.hxx:105