Logo ROOT  
Reference Guide
ProfileLikelihoodCalculator.cxx
Go to the documentation of this file.
1 // @(#)root/roostats:$Id$
2 // Author: Kyle Cranmer 28/07/2008
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 /** \class RooStats::ProfileLikelihoodCalculator
13  \ingroup Roostats
14 
15 The ProfileLikelihoodCalculator is a concrete implementation of CombinedCalculator
16 (the interface class for tools which can produce both a RooStats HypoTestResult
17 and ConfInterval). The tool uses the profile likelihood ratio as a test statistic,
18 and assumes that Wilks' theorem is valid. Wilks' theorem states that \f$ -2 \cdot \ln(\lambda) \f$
19 (profile likelihood ratio) is asymptotically distributed as a \f$ \chi^2 \f$ distribution
20 with \f$ N \f$ degrees of freedom. Thus, \f$p\f$-values can be
21 constructed, and the profile likelihood ratio can be used to construct a
22 LikelihoodInterval. (In the future, this class could be extended to use toy
23 Monte Carlo to calibrate the distribution of the test statistic).
24 
25 Usage: It uses the interface of the CombinedCalculator, so that it can be
26 configured by specifying:
27 
28  - A model common model (*e.g.* a family of specific models, which includes both
29  the null and alternate)
30  - A data set
31  - A set of parameters of interest. The nuisance parameters will be all other
32  parameters of the model.
33  - A set of parameters which specify the null hypothesis (including values
34  and const/non-const status).
35 
36 The interface allows one to pass the model, data, and parameters either directly
37 or via a ModelConfig class. The alternate hypothesis leaves the parameter free
38 to take any value other than those specified by the null hypothesis. There is
39 therefore no need to specify the alternate parameters.
40 
41 After configuring the calculator, one only needs to call GetHypoTest() (which
42 will return a HypoTestResult pointer) or GetInterval() (which will return a
43 ConfInterval pointer).
44 
45 This calculator can work with both one-dimensional intervals or multi-
46 dimensional ones (contours).
47 
48 Note that for hypothesis tests, it is often better to use the
49 AsymptoticCalculator, which can compute in addition the expected
50 \f$p\f$-value using an Asimov data set.
51 
52 */
53 
55 
56 #include "RooStats/RooStatsUtils.h"
57 
60 
61 #include "RooFitResult.h"
62 #include "RooRealVar.h"
63 #include "RooProfileLL.h"
64 #include "RooNLLVar.h"
65 #include "RooGlobalFunc.h"
66 #include "RooMsgService.h"
67 
68 #include "Math/MinimizerOptions.h"
69 #include "RooMinimizer.h"
70 //#include "RooProdPdf.h"
71 
72 using namespace std;
73 
75 
76 using namespace RooFit;
77 using namespace RooStats;
78 
79 
80 ////////////////////////////////////////////////////////////////////////////////
81 /// default constructor
82 
83 ProfileLikelihoodCalculator::ProfileLikelihoodCalculator() :
84  CombinedCalculator(), fFitResult(0), fGlobalFitDone(false)
85 {
86 }
87 
89  Double_t size, const RooArgSet* nullParams ) :
90  CombinedCalculator(data,pdf, paramsOfInterest, size, nullParams ),
91  fFitResult(0), fGlobalFitDone(false)
92 {
93  // constructor from pdf and parameters
94  // the pdf must contain eventually the nuisance parameters
95 }
96 
98  CombinedCalculator(data, model, size),
99  fFitResult(0), fGlobalFitDone(false)
100 {
101  // construct from a ModelConfig. Assume data model.GetPdf() will provide full description of model including
102  // constraint term on the nuisances parameters
103  assert(model.GetPdf() );
104 }
105 
106 
107 ////////////////////////////////////////////////////////////////////////////////
108 /// destructor
109 /// cannot delete prod pdf because it will delete all the composing pdf's
110 /// if (fOwnPdf) delete fPdf;
111 /// fPdf = 0;
112 
114  if (fFitResult) delete fFitResult;
115 }
116 
118  // reset and clear fit result
119  // to be called when a new model or data are set in the calculator
120  if (fFitResult) delete fFitResult;
121  fFitResult = 0;
122 }
123 
125  // perform a global fit of the likelihood letting with all parameter of interest and
126  // nuisance parameters
127  // keep the list of fitted parameters
128 
129  DoReset();
130  RooAbsPdf * pdf = GetPdf();
131  RooAbsData* data = GetData();
132  if (!data || !pdf ) return 0;
133 
134  // get all non-const parameters
135  RooArgSet* constrainedParams = pdf->getParameters(*data);
136  if (!constrainedParams) return 0;
137  RemoveConstantParameters(constrainedParams);
138 
139  const auto& config = GetGlobalRooStatsConfig();
141  RooFit::Offset(config.useLikelihoodOffset) );
142 
143  // check if global fit has been already done
144  if (fFitResult && fGlobalFitDone) {
145  delete constrainedParams;
146  return nll;
147  }
148 
149  // calculate MLE
150  oocoutP((TObject*)0,Minimization) << "ProfileLikelihoodCalcultor::DoGLobalFit - find MLE " << std::endl;
151 
152  if (fFitResult) delete fFitResult;
153  fFitResult = DoMinimizeNLL(nll);
154 
155  // print fit result
156  if (fFitResult) {
158 
159  if (fFitResult->status() != 0)
160  oocoutW((TObject*)0,Minimization) << "ProfileLikelihoodCalcultor::DoGlobalFit - Global fit failed - status = " << fFitResult->status() << std::endl;
161  else
162  fGlobalFitDone = true;
163  }
164 
165  delete constrainedParams;
166  return nll;
167 }
168 
170  // Minimizer the given NLL using the default options
171 
172  const char * minimType = ROOT::Math::MinimizerOptions::DefaultMinimizerType().c_str();
173  const char * minimAlgo = ROOT::Math::MinimizerOptions::DefaultMinimizerAlgo().c_str();
175  int level = ROOT::Math::MinimizerOptions::DefaultPrintLevel() -1;// RooFit level starts from -1
177  oocoutP((TObject*)0,Minimization) << "ProfileLikelihoodCalcultor::DoMinimizeNLL - using " << minimType << " / " << minimAlgo << " with strategy " << strategy << std::endl;
178  // do global fit and store fit result for further use
179 
180  const auto& config = GetGlobalRooStatsConfig();
181 
182  RooMinimizer minim(*nll);
183  minim.setStrategy(strategy);
184  minim.setEps(tolerance);
185  minim.setPrintLevel(level);
186  minim.optimizeConst(2); // to optimize likelihood calculations
187  minim.setEvalErrorWall(config.useEvalErrorWall);
188 
189  int status = -1;
190  for (int tries = 1, maxtries = 4; tries <= maxtries; ++tries) {
191  status = minim.minimize(minimType,minimAlgo);
192  if (status%1000 == 0) { // ignore erros from Improve
193  break;
194  } else if (tries < maxtries) {
195  cout << " ----> Doing a re-scan first" << endl;
196  minim.minimize(minimType,"Scan");
197  if (tries == 2) {
198  if (strategy == 0 ) {
199  cout << " ----> trying with strategy = 1" << endl;;
200  minim.setStrategy(1);
201  }
202  else
203  tries++; // skip this trial if strategy is already 1
204  }
205  if (tries == 3) {
206  cout << " ----> trying with improve" << endl;;
207  minimType = "Minuit";
208  minimAlgo = "migradimproved";
209  }
210  }
211  }
212 
213  RooFitResult * result = minim.save();
214 
215 
216  return result;
217 }
218 
219 ////////////////////////////////////////////////////////////////////////////////
220 /// Main interface to get a RooStats::ConfInterval.
221 /// It constructs a profile likelihood ratio, and uses that to construct a RooStats::LikelihoodInterval.
222 
224 // RooAbsPdf* pdf = fWS->pdf(fPdfName);
225 // RooAbsData* data = fWS->data(fDataName);
226  RooAbsPdf * pdf = GetPdf();
227  RooAbsData* data = GetData();
228  if (!data || !pdf || fPOI.getSize() == 0) return 0;
229 
230  RooArgSet* constrainedParams = pdf->getParameters(*data);
231  RemoveConstantParameters(constrainedParams);
232 
233 
234  /*
235  RooNLLVar* nll = new RooNLLVar("nll","",*pdf,*data, Extended(),Constrain(*constrainedParams));
236  RooProfileLL* profile = new RooProfileLL("pll","",*nll, *fPOI);
237  profile->addOwnedComponents(*nll) ; // to avoid memory leak
238  */
239 
240  // do a global fit cloning the data
241  RooAbsReal * nll = DoGlobalFit();
242  if (!nll) return 0;
243 
244  if (!fFitResult) {
245  delete nll;
246  return 0;
247  }
248 
249  RooAbsReal* profile = nll->createProfile(fPOI);
250  profile->addOwnedComponents(*nll) ; // to avoid memory leak
251 
252  // t.b.f. " RooProfileLL should keep and provide possibility to query on global minimum
253  // set POI to fit value (this will speed up profileLL calculation of global minimum)
254  const RooArgList & fitParams = fFitResult->floatParsFinal();
255  for (int i = 0; i < fitParams.getSize(); ++i) {
256  RooRealVar & fitPar = (RooRealVar &) fitParams[i];
257  RooRealVar * par = (RooRealVar*) fPOI.find( fitPar.GetName() );
258  if (par) {
259  par->setVal( fitPar.getVal() );
260  par->setError( fitPar.getError() );
261  }
262  }
263 
264  // do this so profile will cache inside the absolute minimum and
265  // minimum values of nuisance parameters
266  // (no need to this here)
267  // profile->getVal();
268  //RooMsgService::instance().setGlobalKillBelow(RooFit::DEBUG) ;
269  // profile->Print();
270 
271  TString name = TString("LikelihoodInterval_");// + TString(GetName() );
272 
273  // make a list of fPOI with fit result values and pass to LikelihoodInterval class
274  // bestPOI is a cloned list of POI only with their best fit values
275  TIter iter = fPOI.createIterator();
276  RooArgSet fitParSet(fitParams);
277  RooArgSet * bestPOI = new RooArgSet();
278  while (RooAbsArg * arg = (RooAbsArg*) iter.Next() ) {
279  RooAbsArg * p = fitParSet.find( arg->GetName() );
280  if (p) bestPOI->addClone(*p);
281  else bestPOI->addClone(*arg);
282  }
283  // fPOI contains the parameter of interest of the PL object
284  // and bestPOI contains a snapshot with the best fit values
285  LikelihoodInterval* interval = new LikelihoodInterval(name, profile, &fPOI, bestPOI);
286  interval->SetConfidenceLevel(1.-fSize);
287  delete constrainedParams;
288  return interval;
289 }
290 
291 ////////////////////////////////////////////////////////////////////////////////
292 /// Main interface to get a HypoTestResult.
293 /// It does two fits:
294 /// 1. The first lets the null parameters float, so it's a maximum likelihood estimate.
295 /// 2. The second is to the null model (fixing null parameters to their specified values): *e.g.* a conditional maximum likelihood.
296 /// Since not all parameters are floating, this likelihood will be lower than the unconditional model.
297 ///
298 /// The ratio of the likelihood obtained from the conditional MLE to the MLE is the profile likelihood ratio.
299 /// Wilks' theorem is used to get \f$p\f$-values.
300 
302 // RooAbsPdf* pdf = fWS->pdf(fPdfName);
303 // RooAbsData* data = fWS->data(fDataName);
304  RooAbsPdf * pdf = GetPdf();
305  RooAbsData* data = GetData();
306 
307 
308  if (!data || !pdf) return 0;
309 
310  if (fNullParams.getSize() == 0) return 0;
311 
312  // make a clone and ordered list since a vector will be associated to keep parameter values
313  // clone the list since first fit will changes the fNullParams values
314  RooArgList poiList;
315  poiList.addClone(fNullParams); // make a clone list
316 
317 
318  // do a global fit
319  RooAbsReal * nll = DoGlobalFit();
320  if (!nll) return 0;
321 
322  if (!fFitResult) {
323  delete nll;
324  return 0;
325  }
326 
327  RooArgSet* constrainedParams = pdf->getParameters(*data);
328  RemoveConstantParameters(constrainedParams);
329 
330  Double_t nLLatMLE = fFitResult->minNll();
331  // in case of using offset need to save offset value
332  Double_t nlloffset = (RooStats::IsNLLOffset() ) ? nll->getVal() - nLLatMLE : 0;
333 
334  // set POI to given values, set constant, calculate conditional MLE
335  std::vector<double> oldValues(poiList.getSize() );
336  for (unsigned int i = 0; i < oldValues.size(); ++i) {
337  RooRealVar * mytarget = (RooRealVar*) constrainedParams->find(poiList[i].GetName());
338  if (mytarget) {
339  oldValues[i] = mytarget->getVal();
340  mytarget->setVal( ( (RooRealVar&) poiList[i] ).getVal() );
341  mytarget->setConstant(kTRUE);
342  }
343  }
344 
345 
346 
347  // perform the fit only if nuisance parameters are available
348  // get nuisance parameters
349  // nuisance parameters are the non const parameters from the likelihood parameters
350  RooArgSet nuisParams(*constrainedParams);
351 
352  // need to remove the parameter of interest
353  RemoveConstantParameters(&nuisParams);
354 
355  // check there are variable parameter in order to do a fit
356  bool existVarParams = false;
357  TIter it = nuisParams.createIterator();
358  RooRealVar * myarg = 0;
359  while ((myarg = (RooRealVar *)it.Next())) {
360  if ( !myarg->isConstant() ) {
361  existVarParams = true;
362  break;
363  }
364  }
365 
366  Double_t nLLatCondMLE = nLLatMLE;
367  if (existVarParams) {
368  oocoutP((TObject*)0,Minimization) << "ProfileLikelihoodCalcultor::GetHypoTest - do conditional fit " << std::endl;
369 
370  RooFitResult * fit2 = DoMinimizeNLL(nll);
371 
372  // print fit result
373  if (fit2) {
374  nLLatCondMLE = fit2->minNll();
376 
377  if (fit2->status() != 0)
378  oocoutW((TObject*)0,Minimization) << "ProfileLikelihoodCalcultor::GetHypotest - Conditional fit failed - status = " << fit2->status() << std::endl;
379  }
380 
381  }
382  else {
383  // get just the likelihood value (no need to do a fit since the likelihood is a constant function)
384  nLLatCondMLE = nll->getVal();
385  // this value contains the offset
386  if (RooStats::IsNLLOffset() ) nLLatCondMLE -= nlloffset;
387  }
388 
389  // Use Wilks' theorem to translate -2 log lambda into a significance/p-value
390  Double_t deltaNLL = std::max( nLLatCondMLE-nLLatMLE, 0.);
391 
392  // get number of free parameter of interest
393  RemoveConstantParameters(poiList);
394  int ndf = poiList.getSize();
395 
396  Double_t pvalue = ROOT::Math::chisquared_cdf_c( 2* deltaNLL, ndf);
397 
398  // in case of one dimension (1 poi) do the one-sided p-value (need to divide by 2)
399  if (ndf == 1) pvalue = 0.5 * pvalue;
400 
401  TString name = TString("ProfileLRHypoTestResult_");// + TString(GetName() );
402  HypoTestResult* htr = new HypoTestResult(name, pvalue, 0 );
403 
404  // restore previous value of poi
405  for (unsigned int i = 0; i < oldValues.size(); ++i) {
406  RooRealVar * mytarget = (RooRealVar*) constrainedParams->find(poiList[i].GetName());
407  if (mytarget) {
408  mytarget->setVal(oldValues[i] );
409  mytarget->setConstant(false);
410  }
411  }
412 
413  delete constrainedParams;
414  delete nll;
415  return htr;
416 
417 }
RooFitResult::defaultPrintStyle
virtual StyleOption defaultPrintStyle(Option_t *opt) const
Configure mapping of Print() arguments to RooPrintable print styles.
Definition: RooFitResult.cxx:1449
RooFit::Minimization
@ Minimization
Definition: RooGlobalFunc.h:67
RooRealVar::setVal
virtual void setVal(Double_t value)
Set value of variable to 'value'.
Definition: RooRealVar.cxx:226
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
RooStats::IsNLLOffset
bool IsNLLOffset()
Test of RooStats should by default offset NLL calculations.
Definition: RooStatsUtils.cxx:66
RooMinimizer::setEps
void setEps(Double_t eps)
Change MINUIT epsilon.
Definition: RooMinimizer.cxx:225
RooMsgService.h
RooMinimizer::save
RooFitResult * save(const char *name=0, const char *title=0)
Save and return a RooFitResult snaphot of current minimizer status.
Definition: RooMinimizer.cxx:635
RooAbsData
Definition: RooAbsData.h:46
oocoutI
#define oocoutI(o, a)
Definition: RooMsgService.h:45
RooStats::ProfileLikelihoodCalculator
Definition: ProfileLikelihoodCalculator.h:28
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
oocoutP
#define oocoutP(o, a)
Definition: RooMsgService.h:46
RooArgList
Definition: RooArgList.h:21
RooAbsReal::getVal
Double_t getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
Definition: RooAbsReal.h:91
RooStats::ProfileLikelihoodCalculator::fFitResult
RooFitResult * fFitResult
Definition: ProfileLikelihoodCalculator.h:76
RooMinimizer::setStrategy
void setStrategy(Int_t strat)
Change MINUIT strategy to istrat.
Definition: RooMinimizer.cxx:176
RooStats::ProfileLikelihoodCalculator::GetHypoTest
virtual HypoTestResult * GetHypoTest() const
Return the hypothesis test result obtained from the likelihood ratio of the maximum likelihood value ...
Definition: ProfileLikelihoodCalculator.cxx:301
RooFit::Offset
RooCmdArg Offset(Bool_t flag=kTRUE)
Definition: RooGlobalFunc.cxx:212
RooAbsCollection::find
RooAbsArg * find(const char *name) const
Find object with given name in list.
Definition: RooAbsCollection.cxx:813
RooStats::ProfileLikelihoodCalculator::~ProfileLikelihoodCalculator
virtual ~ProfileLikelihoodCalculator()
destructor cannot delete prod pdf because it will delete all the composing pdf's if (fOwnPdf) delete ...
Definition: ProfileLikelihoodCalculator.cxx:113
RooAbsReal
Definition: RooAbsReal.h:61
TString
Definition: TString.h:136
HypoTestResult.h
RooAbsCollection::GetName
const char * GetName() const
Returns name of object.
Definition: RooAbsCollection.h:226
MinimizerOptions.h
RooNLLVar.h
RooFitResult
Definition: RooFitResult.h:40
RooStats::CombinedCalculator::GetPdf
RooAbsPdf * GetPdf() const
Definition: CombinedCalculator.h:167
RooAbsArg::getParameters
RooArgSet * getParameters(const RooAbsData *data, Bool_t stripDisconnected=kTRUE) const
Create a list of leaf nodes in the arg tree starting with ourself as top node that don't match any of...
Definition: RooAbsArg.cxx:546
RooFit::GlobalObservables
RooCmdArg GlobalObservables(const RooArgSet &globs)
Definition: RooGlobalFunc.cxx:201
RooStats::ProfileLikelihoodCalculator::fGlobalFitDone
bool fGlobalFitDone
Definition: ProfileLikelihoodCalculator.h:77
LikelihoodInterval.h
ROOT::Math::MinimizerOptions::DefaultMinimizerType
static const std::string & DefaultMinimizerType()
Definition: MinimizerOptions.cxx:102
RooRealVar::getError
Double_t getError() const
Definition: RooRealVar.h:62
RooStats::CombinedCalculator
Definition: CombinedCalculator.h:68
RooStats::CombinedCalculator::fNullParams
RooArgSet fNullParams
Definition: CombinedCalculator.h:175
RooStats::CombinedCalculator::fGlobalObs
RooArgSet fGlobalObs
Definition: CombinedCalculator.h:179
RooFit
Definition: RooCFunction1Binding.h:29
RooFitResult::status
Int_t status() const
Definition: RooFitResult.h:77
RooFit::Constrain
RooCmdArg Constrain(const RooArgSet &params)
Definition: RooGlobalFunc.cxx:200
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
RooRealVar::setError
void setError(Double_t value)
Definition: RooRealVar.h:64
RooAbsPdf::createNLL
virtual RooAbsReal * createNLL(RooAbsData &data, const RooLinkedList &cmdList)
Construct representation of -log(L) of PDFwith given dataset.
Definition: RooAbsPdf.cxx:917
RooAbsCollection::createIterator
TIterator * createIterator(Bool_t dir=kIterForward) const
TIterator-style iteration over contained elements.
Definition: RooAbsCollection.h:118
RooStats::CombinedCalculator::fPOI
RooArgSet fPOI
Definition: CombinedCalculator.h:174
RooStats::ProfileLikelihoodCalculator::GetInterval
virtual LikelihoodInterval * GetInterval() const
Return a likelihood interval.
Definition: ProfileLikelihoodCalculator.cxx:223
oocoutW
#define oocoutW(o, a)
Definition: RooMsgService.h:47
RooStats::ProfileLikelihoodCalculator::DoMinimizeNLL
static RooFitResult * DoMinimizeNLL(RooAbsReal *nll)
Definition: ProfileLikelihoodCalculator.cxx:169
RooRealVar.h
RooFit::ConditionalObservables
RooCmdArg ConditionalObservables(const RooArgSet &set)
Definition: RooGlobalFunc.cxx:196
ROOT::Math::MinimizerOptions::DefaultStrategy
static int DefaultStrategy()
Definition: MinimizerOptions.cxx:98
RooStats::CombinedCalculator::GetData
RooAbsData * GetData() const
Definition: CombinedCalculator.h:168
RooFitResult.h
RooGlobalFunc.h
RooAbsReal::createProfile
virtual RooAbsReal * createProfile(const RooArgSet &paramsOfInterest)
Create a RooProfileLL object that eliminates all nuisance parameters in the present function.
Definition: RooAbsReal.cxx:516
TIter::Next
TObject * Next()
Definition: TCollection.h:249
RooStatsUtils.h
RooStats::CombinedCalculator::fSize
Double_t fSize
Definition: CombinedCalculator.h:170
RooMinimizer::minimize
Int_t minimize(const char *type, const char *alg=0)
Minimise the function passed in the constructor.
Definition: RooMinimizer.cxx:312
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:2109
ROOT::Math::MinimizerOptions::DefaultTolerance
static double DefaultTolerance()
Definition: MinimizerOptions.cxx:94
ROOT::Math::MinimizerOptions::DefaultMinimizerAlgo
static const std::string & DefaultMinimizerAlgo()
Definition: MinimizerOptions.cxx:92
RooMinimizer.h
RooStats
Definition: Asimov.h:19
RooStats::CombinedCalculator::fConditionalObs
RooArgSet fConditionalObs
Definition: CombinedCalculator.h:178
RooStats::ProfileLikelihoodCalculator::ProfileLikelihoodCalculator
ProfileLikelihoodCalculator()
Default constructor (needed for I/O)
Definition: ProfileLikelihoodCalculator.cxx:83
TObject
Definition: TObject.h:37
ProfileLikelihoodCalculator.h
ROOT::Math::MinimizerOptions::DefaultPrintLevel
static int DefaultPrintLevel()
Definition: MinimizerOptions.cxx:99
RooStats::HypoTestResult
Definition: HypoTestResult.h:28
name
char name[80]
Definition: TGX11.cxx:110
RooStats::RemoveConstantParameters
void RemoveConstantParameters(RooArgSet *set)
Definition: RooStatsUtils.h:69
RooAbsRealLValue::setConstant
void setConstant(Bool_t value=kTRUE)
Definition: RooAbsRealLValue.h:109
RooPrintable::printStream
virtual void printStream(std::ostream &os, Int_t contents, StyleOption style, TString indent="") const
Print description of object on ostream, printing contents set by contents integer,...
Definition: RooPrintable.cxx:75
RooFit::CloneData
RooCmdArg CloneData(Bool_t flag)
Definition: RooGlobalFunc.cxx:209
RooFitResult::floatParsFinal
const RooArgList & floatParsFinal() const
Definition: RooFitResult.h:110
TIter
Definition: TCollection.h:233
make_cnn_model.model
model
Definition: make_cnn_model.py:6
RooAbsArg
Definition: RooAbsArg.h:73
RooArgSet::addClone
virtual void addClone(const RooAbsCollection &col, Bool_t silent=kFALSE)
Add a collection of arguments to this collection by calling addOwned() for each element in the source...
Definition: RooArgSet.h:96
RooAbsPdf
Definition: RooAbsPdf.h:40
ROOT::Math::chisquared_cdf_c
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...
Definition: ProbFuncMathCore.cxx:57
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:53
RooStats::GetGlobalRooStatsConfig
RooStatsConfig & GetGlobalRooStatsConfig()
Retrieve the config object which can be used to set flags for things like offsetting the likelihood o...
Definition: RooStatsUtils.cxx:33
RooStats::ProfileLikelihoodCalculator::DoGlobalFit
RooAbsReal * DoGlobalFit() const
Definition: ProfileLikelihoodCalculator.cxx:124
RooRealVar
Definition: RooRealVar.h:35
RooFitResult::defaultPrintContents
virtual Int_t defaultPrintContents(Option_t *opt) const
Configure default contents to be printed.
Definition: RooFitResult.cxx:1440
RooStats::ModelConfig
Definition: ModelConfig.h:36
RooMinimizer
Definition: RooMinimizer.h:40
RooMinimizer::setEvalErrorWall
void setEvalErrorWall(Bool_t flag)
Definition: RooMinimizer.h:52
RooMinimizer::optimizeConst
void optimizeConst(Int_t flag)
If flag is true, perform constant term optimization on function being minimized.
Definition: RooMinimizer.cxx:603
RooStats::ProfileLikelihoodCalculator::DoReset
void DoReset() const
Definition: ProfileLikelihoodCalculator.cxx:117
RooAbsArg::isConstant
Bool_t isConstant() const
Check if the "Constant" attribute is set.
Definition: RooAbsArg.h:360
RooStats::LikelihoodInterval
Definition: LikelihoodInterval.h:34
RooMinimizer::setPrintLevel
Int_t setPrintLevel(Int_t newLevel)
Change the MINUIT internal printing level.
Definition: RooMinimizer.cxx:591
RooFitResult::minNll
Double_t minNll() const
Definition: RooFitResult.h:98
RooAbsCollection::getSize
Int_t getSize() const
Definition: RooAbsCollection.h:171
RooProfileLL.h
RooArgSet
Definition: RooArgSet.h:28
RooStats::LikelihoodInterval::SetConfidenceLevel
virtual void SetConfidenceLevel(Double_t cl)
set the confidence level for the interval (e.g 0.682 for a 1-sigma interval)
Definition: LikelihoodInterval.h:52