Logo ROOT  
Reference Guide
RooAbsPdf.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 RooAbsPdf
19  \ingroup Roofitcore
20 
21 ## RooAbsPdf, the base class of all PDFs
22 
23 RooAbsPdf is the abstract interface for all probability density
24 functions. The class provides hybrid analytical/numerical
25 normalization for its implementations, error tracing and a MC
26 generator interface.
27 
28 ### A Minimal PDF Implementation
29 
30 A minimal implementation of a PDF class derived from RooAbsPdf
31 should override the `evaluate()` function. This function should
32 return the PDF's value (which does not need to be normalised).
33 
34 
35 #### Normalization/Integration
36 
37 Although the normalization of a PDF is an integral part of a
38 probability density function, normalization is treated separately
39 in RooAbsPdf. The reason is that a RooAbsPdf object is more than a
40 PDF: it can be a building block for a more complex, composite PDF
41 if any of its variables are functions instead of variables. In
42 such cases the normalization of the composite may not be simply the
43 integral over the dependents of the top level PDF as these are
44 functions with potentially non-trivial Jacobian terms themselves.
45 \note Therefore, no explicit attempt should be made to normalize the
46 function output in evaluate(). In particular, normalisation constants
47 can be omitted to speed up the function evaluations, and included later
48 in the integration of the PDF (see below), which is called rarely in
49 comparison to the `evaluate()` function.
50 
51 In addition, RooAbsPdf objects do not have a static concept of what
52 variables are parameters and what variables are dependents (which
53 need to be integrated over for a correct PDF normalization).
54 Instead, the choice of normalization is always specified each time a
55 normalized value is requested from the PDF via the getVal()
56 method.
57 
58 RooAbsPdf manages the entire normalization logic of each PDF with
59 help of a RooRealIntegral object, which coordinates the integration
60 of a given choice of normalization. By default, RooRealIntegral will
61 perform a fully numeric integration of all dependents. However,
62 PDFs can advertise one or more (partial) analytical integrals of
63 their function, and these will be used by RooRealIntegral, if it
64 determines that this is safe (i.e. no hidden Jacobian terms,
65 multiplication with other PDFs that have one or more dependents in
66 commen etc).
67 
68 #### Implementing analytical integrals
69 To implement analytical integrals, two functions must be implemented. First,
70 
71 ```
72 Int_t getAnalyticalIntegral(const RooArgSet& integSet, RooArgSet& anaIntSet)
73 ```
74 should return the analytical integrals that are supported. `integSet`
75 is the set of dependents for which integration is requested. The
76 function should copy the subset of dependents it can analytically
77 integrate to `anaIntSet`, and return a unique identification code for
78 this integration configuration. If no integration can be
79 performed, zero should be returned. Second,
80 
81 ```
82 Double_t analyticalIntegral(Int_t code)
83 ```
84 
85 implements the actual analytical integral(s) advertised by
86 `getAnalyticalIntegral()`. This function will only be called with
87 codes returned by `getAnalyticalIntegral()`, except code zero.
88 
89 The integration range for each dependent to be integrated can
90 be obtained from the dependent's proxy functions `min()` and
91 `max()`. Never call these proxy functions for any proxy not known to
92 be a dependent via the integration code. Doing so may be
93 ill-defined, e.g. in case the proxy holds a function, and will
94 trigger an assert. Integrated category dependents should always be
95 summed over all of their states.
96 
97 
98 
99 ### Direct generation of observables
100 
101 Distributions for any PDF can be generated with the accept/reject method,
102 but for certain PDFs, more efficient methods may be implemented. To
103 implement direct generation of one or more observables, two
104 functions need to be implemented, similar to those for analytical
105 integrals:
106 
107 ```
108 Int_t getGenerator(const RooArgSet& generateVars, RooArgSet& directVars)
109 ```
110 and
111 ```
112 void generateEvent(Int_t code)
113 ```
114 
115 The first function advertises observables, for which distributions can be generated,
116 similar to the way analytical integrals are advertised. The second
117 function implements the actual generator for the advertised observables.
118 
119 The generated dependent values should be stored in the proxy
120 objects. For this, the assignment operator can be used (i.e. `xProxy
121 = 3.0` ). Never call assign to any proxy not known to be a dependent
122 via the generation code. Doing so may be ill-defined, e.g. in case
123 the proxy holds a function, and will trigger an assert.
124 
125 
126 ### Batched function evaluations (Advanced usage)
127 
128 To speed up computations with large numbers of data events in unbinned fits,
129 it is beneficial to override `evaluateSpan()`. Like this, large spans of
130 computations can be done, without having to call `evaluate()` for each single data event.
131 `evaluateSpan()` should execute the same computation as `evaluate()`, but it
132 may choose an implementation that is capable of SIMD computations.
133 If evaluateSpan is not implemented, the classic and slower `evaluate()` will be
134 called for each data event.
135 */
136 
137 #include "RooAbsPdf.h"
138 
139 #include "RooFit.h"
140 #include "RooMsgService.h"
141 #include "RooDataSet.h"
142 #include "RooArgSet.h"
143 #include "RooArgProxy.h"
144 #include "RooRealProxy.h"
145 #include "RooRealVar.h"
146 #include "RooGenContext.h"
147 #include "RooBinnedGenContext.h"
148 #include "RooPlot.h"
149 #include "RooCurve.h"
150 #include "RooNLLVar.h"
151 #include "RooMinuit.h"
152 #include "RooCategory.h"
153 #include "RooNameReg.h"
154 #include "RooCmdConfig.h"
155 #include "RooGlobalFunc.h"
156 #include "RooAddition.h"
157 #include "RooRandom.h"
158 #include "RooNumIntConfig.h"
159 #include "RooProjectedPdf.h"
160 #include "RooInt.h"
161 #include "RooCustomizer.h"
162 #include "RooConstraintSum.h"
163 #include "RooParamBinning.h"
164 #include "RooNumCdf.h"
165 #include "RooFitResult.h"
166 #include "RooNumGenConfig.h"
167 #include "RooCachedReal.h"
168 #include "RooXYChi2Var.h"
169 #include "RooChi2Var.h"
170 #include "RooMinimizer.h"
171 #include "RooRealIntegral.h"
172 #include "RooWorkspace.h"
173 #include "RooNaNPacker.h"
174 #include "RooHelpers.h"
175 #include "RooBatchCompute.h"
176 #include "RooFormulaVar.h"
177 
178 #include "TClass.h"
179 #include "TMath.h"
180 #include "TPaveText.h"
181 #include "TList.h"
182 #include "TMatrixD.h"
183 #include "TMatrixDSym.h"
184 #include "Math/CholeskyDecomp.h"
185 #include "RooDerivative.h"
186 
187 #include <iostream>
188 #include <string>
189 #include <cmath>
190 
191 using namespace std;
192 
194 
196 
197 
200 
201 ////////////////////////////////////////////////////////////////////////////////
202 /// Default constructor
203 
204 RooAbsPdf::RooAbsPdf() : _norm(0), _normSet(0), _specGeneratorConfig(0)
205 {
206  _errorCount = 0 ;
207  _negCount = 0 ;
208  _rawValue = 0 ;
209  _selectComp = kFALSE ;
210  _traceCount = 0 ;
211 }
212 
213 
214 
215 ////////////////////////////////////////////////////////////////////////////////
216 /// Constructor with name and title only
217 
218 RooAbsPdf::RooAbsPdf(const char *name, const char *title) :
219  RooAbsReal(name,title), _norm(0), _normSet(0), _normMgr(this,10), _selectComp(kTRUE), _specGeneratorConfig(0)
220 {
222  setTraceCounter(0) ;
223 }
224 
225 
226 
227 ////////////////////////////////////////////////////////////////////////////////
228 /// Constructor with name, title, and plot range
229 
230 RooAbsPdf::RooAbsPdf(const char *name, const char *title,
231  Double_t plotMin, Double_t plotMax) :
232  RooAbsReal(name,title,plotMin,plotMax), _norm(0), _normSet(0), _normMgr(this,10), _selectComp(kTRUE), _specGeneratorConfig(0)
233 {
235  setTraceCounter(0) ;
236 }
237 
238 
239 
240 ////////////////////////////////////////////////////////////////////////////////
241 /// Copy constructor
242 
243 RooAbsPdf::RooAbsPdf(const RooAbsPdf& other, const char* name) :
244  RooAbsReal(other,name), _norm(0), _normSet(0),
245  _normMgr(other._normMgr,this), _selectComp(other._selectComp), _normRange(other._normRange)
246 {
247  resetErrorCounters() ;
248  setTraceCounter(other._traceCount) ;
249 
250  if (other._specGeneratorConfig) {
251  _specGeneratorConfig = new RooNumGenConfig(*other._specGeneratorConfig) ;
252  } else {
253  _specGeneratorConfig = 0 ;
254  }
255 }
256 
257 
258 
259 ////////////////////////////////////////////////////////////////////////////////
260 /// Destructor
261 
263 {
265 }
266 
267 
268 
269 ////////////////////////////////////////////////////////////////////////////////
270 /// Return current value, normalized by integrating over
271 /// the observables in `nset`. If `nset` is 0, the unnormalized value
272 /// is returned. All elements of `nset` must be lvalues.
273 ///
274 /// Unnormalized values are not cached.
275 /// Doing so would be complicated as `_norm->getVal()` could
276 /// spoil the cache and interfere with returning the cached
277 /// return value. Since unnormalized calls are typically
278 /// done in integration calls, there is no performance hit.
279 
281 {
282 
283  // Special handling of case without normalization set (used in numeric integration of pdfs)
284  if (!nset) {
285  RooArgSet* tmp = _normSet ;
286  _normSet = 0 ;
287  Double_t val = evaluate() ;
288  _normSet = tmp ;
289 
290  return TMath::IsNaN(val) ? 0. : val;
291  }
292 
293 
294  // Process change in last data set used
295  Bool_t nsetChanged(kFALSE) ;
296  if (nset!=_normSet || _norm==0) {
297  nsetChanged = syncNormalization(nset) ;
298  }
299 
300  // Return value of object. Calculated if dirty, otherwise cached value is returned.
301  if (isValueDirty() || nsetChanged || _norm->isValueDirty()) {
302 
303  // Evaluate numerator
304  const double rawVal = evaluate();
305 
306  // Evaluate denominator
307  const double normVal = _norm->getVal();
308 
309  if (normVal < 0. || (normVal == 0. && rawVal != 0)) {
310  //Unreasonable normalisations. A zero integral can be tolerated if the function vanishes, though.
311  const std::string msg = "p.d.f normalization integral is zero or negative: " + std::to_string(normVal);
312  logEvalError(msg.c_str());
314  return _value = RooNaNPacker::packFloatIntoNaN(-normVal + (rawVal < 0. ? -rawVal : 0.));
315  }
316 
317  if (rawVal < 0.) {
318  logEvalError(Form("p.d.f value is less than zero (%f), trying to recover", rawVal));
320  return _value = RooNaNPacker::packFloatIntoNaN(-rawVal);
321  }
322 
323  if (TMath::IsNaN(rawVal)) {
324  logEvalError("p.d.f value is Not-a-Number");
326  return _value = rawVal;
327  }
328 
329  _value = (rawVal == 0. && normVal == 0.) ? 0. : rawVal / normVal;
330 
332  }
333 
334  return _value ;
335 }
336 
337 
338 ////////////////////////////////////////////////////////////////////////////////
339 /// Compute batch of values for given input data, and normalise by integrating over
340 /// the observables in `normSet`. Store result in `evalData`, and return a span pointing to
341 /// it.
342 /// This uses evaluateSpan() to perform an (unnormalised) computation of data points. This computation
343 /// is finalised by normalising the bare values, and by checking for computation errors.
344 /// Derived classes should override evaluateSpan() to reach maximal performance.
345 ///
346 /// \param[in,out] evalData Object holding data that should be used in computations. Results are also stored here.
347 /// \param[in] normSet If not nullptr, normalise results by integrating over
348 /// the variables in this set. The normalisation is only computed once, and applied
349 /// to the full batch.
350 /// \return RooSpan with probabilities. The memory of this span is owned by `evalData`.
351 /// \see RooAbsReal::getValues().
353  auto item = evalData.spans.find(this);
354  if (item != evalData.spans.end()) {
355  return item->second;
356  }
357 
358  auto outputs = evaluateSpan(evalData, normSet);
359  assert(evalData.spans.count(this) > 0);
360 
361  if (normSet != nullptr) {
362  if (normSet != _normSet || _norm == nullptr) {
363  syncNormalization(normSet);
364  }
365  // Evaluate denominator
366  // In most cases, the integral will be a scalar. But it can still happen
367  // that the integral is a vector, for example in a conditional fit where
368  // pdf is parametrized by another observable that is also a batch. That's
369  // why we have to use the batch interface also for the integral.
370  auto const& normVals = _norm->getValues(evalData);
371 
372  if(normVals.size() > 1) {
373  for(std::size_t i = 0; i < outputs.size(); ++i) {
374  if (normVals[i] < 0. || (normVals[i] == 0. && outputs[i] != 0)) {
375  logEvalError(Form("p.d.f normalization integral is zero or negative."
376  "\n\tInt(%s) = %f", GetName(), normVals[i]));
377  }
378  if(normVals[i] != 1. && normVals[i] > 0.) {
379  outputs[i] /= normVals[i];
380  }
381  }
382 
383  } else {
384  const double normVal = normVals[0];
385  if (normVal < 0.
386  || (normVal == 0. && std::any_of(outputs.begin(), outputs.end(), [](double val){return val != 0;}))) {
387  logEvalError(Form("p.d.f normalization integral is zero or negative."
388  "\n\tInt(%s) = %f", GetName(), normVal));
389  }
390 
391  if (normVal != 1. && normVal > 0.) {
392  const double invNorm = 1./normVal;
393  for (double& val : outputs) { //CHECK_VECTORISE
394  val *= invNorm;
395  }
396  }
397  }
398  }
399 
400  return outputs;
401 }
402 
403 ////////////////////////////////////////////////////////////////////////////////
404 /// Analytical integral with normalization (see RooAbsReal::analyticalIntegralWN() for further information)
405 ///
406 /// This function applies the normalization specified by 'normSet' to the integral returned
407 /// by RooAbsReal::analyticalIntegral(). The passthrough scenario (code=0) is also changed
408 /// to return a normalized answer
409 
410 Double_t RooAbsPdf::analyticalIntegralWN(Int_t code, const RooArgSet* normSet, const char* rangeName) const
411 {
412  cxcoutD(Eval) << "RooAbsPdf::analyticalIntegralWN(" << GetName() << ") code = " << code << " normset = " << (normSet?*normSet:RooArgSet()) << endl ;
413 
414 
415  if (code==0) return getVal(normSet) ;
416  if (normSet) {
417  return analyticalIntegral(code,rangeName) / getNorm(normSet) ;
418  } else {
419  return analyticalIntegral(code,rangeName) ;
420  }
421 }
422 
423 
424 
425 ////////////////////////////////////////////////////////////////////////////////
426 /// Check that passed value is positive and not 'not-a-number'. If
427 /// not, print an error, until the error counter reaches its set
428 /// maximum.
429 
431 {
432  // check for a math error or negative value
433  Bool_t error(kFALSE) ;
434  if (TMath::IsNaN(value)) {
435  logEvalError(Form("p.d.f value is Not-a-Number (%f), forcing value to zero",value)) ;
436  error=kTRUE ;
437  }
438  if (value<0) {
439  logEvalError(Form("p.d.f value is less than zero (%f), forcing value to zero",value)) ;
440  error=kTRUE ;
441  }
442 
443  // do nothing if we are no longer tracing evaluations and there was no error
444  if(!error) return error ;
445 
446  // otherwise, print out this evaluations input values and result
447  if(++_errorCount <= 10) {
448  cxcoutD(Tracing) << "*** Evaluation Error " << _errorCount << " ";
449  if(_errorCount == 10) cxcoutD(Tracing) << "(no more will be printed) ";
450  }
451  else {
452  return error ;
453  }
454 
455  Print() ;
456  return error ;
457 }
458 
459 
460 ////////////////////////////////////////////////////////////////////////////////
461 /// Get normalisation term needed to normalise the raw values returned by
462 /// getVal(). Note that `getVal(normalisationVariables)` will automatically
463 /// apply the normalisation term returned here.
464 /// \param nset Set of variables to normalise over.
466 {
467  if (!nset) return 1 ;
468 
469  syncNormalization(nset,kTRUE) ;
470  if (_verboseEval>1) cxcoutD(Tracing) << IsA()->GetName() << "::getNorm(" << GetName() << "): norm(" << _norm << ") = " << _norm->getVal() << endl ;
471 
472  Double_t ret = _norm->getVal() ;
473  if (ret==0.) {
474  if(++_errorCount <= 10) {
475  coutW(Eval) << "RooAbsPdf::getNorm(" << GetName() << ":: WARNING normalization is zero, nset = " ; nset->Print("1") ;
476  if(_errorCount == 10) coutW(Eval) << "RooAbsPdf::getNorm(" << GetName() << ") INFO: no more messages will be printed " << endl ;
477  }
478  }
479 
480  return ret ;
481 }
482 
483 
484 
485 ////////////////////////////////////////////////////////////////////////////////
486 /// Return pointer to RooAbsReal object that implements calculation of integral over observables iset in range
487 /// rangeName, optionally taking the integrand normalized over observables nset
488 
489 const RooAbsReal* RooAbsPdf::getNormObj(const RooArgSet* nset, const RooArgSet* iset, const TNamed* rangeName) const
490 {
491 
492  // Check normalization is already stored
493  CacheElem* cache = (CacheElem*) _normMgr.getObj(nset,iset,0,rangeName) ;
494  if (cache) {
495  return cache->_norm ;
496  }
497 
498  // If not create it now
499  std::unique_ptr<RooArgSet> depList{getObservables(iset)} ;
500  RooAbsReal* norm = createIntegral(*depList,*nset, *getIntegratorConfig(), RooNameReg::str(rangeName)) ;
501 
502  // Store it in the cache
503  cache = new CacheElem(*norm) ;
504  _normMgr.setObj(nset,iset,cache,rangeName) ;
505 
506  // And return the newly created integral
507  return norm ;
508 }
509 
510 
511 
512 ////////////////////////////////////////////////////////////////////////////////
513 /// Verify that the normalization integral cached with this PDF
514 /// is valid for given set of normalization observables.
515 ///
516 /// If not, the cached normalization integral (if any) is deleted
517 /// and a new integral is constructed for use with 'nset'.
518 /// Elements in 'nset' can be discrete and real, but must be lvalues.
519 ///
520 /// For functions that declare to be self-normalized by overloading the
521 /// selfNormalized() function, a unit normalization is always constructed.
522 
523 Bool_t RooAbsPdf::syncNormalization(const RooArgSet* nset, Bool_t adjustProxies) const
524 {
525 
526 // cout << IsA()->GetName() << "::syncNormalization(" << GetName() << ") nset = " << nset << " = " << (nset?*nset:RooArgSet()) << endl ;
527 
528  _normSet = (RooArgSet*) nset ;
529 
530  // Check if data sets are identical
531  CacheElem* cache = (CacheElem*) _normMgr.getObj(nset) ;
532  if (cache) {
533 
534  Bool_t nsetChanged = (_norm!=cache->_norm) ;
535  _norm = cache->_norm ;
536 
537 
538 // cout << "returning existing object " << _norm->GetName() << endl ;
539 
540  if (nsetChanged && adjustProxies) {
541  // Update dataset pointers of proxies
542  ((RooAbsPdf*) this)->setProxyNormSet(nset) ;
543  }
544 
545  return nsetChanged ;
546  }
547 
548  // Update dataset pointers of proxies
549  if (adjustProxies) {
550  ((RooAbsPdf*) this)->setProxyNormSet(nset) ;
551  }
552 
553  std::unique_ptr<RooArgSet> depList(getObservables(nset));
554 
555  if (_verboseEval>0) {
556  if (!selfNormalized()) {
557  cxcoutD(Tracing) << IsA()->GetName() << "::syncNormalization(" << GetName()
558  << ") recreating normalization integral " << endl ;
559  if (depList) depList->printStream(ccoutD(Tracing),kName|kValue|kArgs,kSingleLine) ; else ccoutD(Tracing) << "<none>" << endl ;
560  } else {
561  cxcoutD(Tracing) << IsA()->GetName() << "::syncNormalization(" << GetName() << ") selfNormalized, creating unit norm" << endl;
562  }
563  }
564 
565  // Destroy old normalization & create new
566  if (selfNormalized() || !dependsOn(*depList)) {
567  auto ntitle = std::string(GetTitle()) + " Unit Normalization";
568  auto nname = std::string(GetName()) + "_UnitNorm";
569  _norm = new RooRealVar(nname.c_str(),ntitle.c_str(),1) ;
570  } else {
571  const char* nr = (_normRangeOverride.Length()>0 ? _normRangeOverride.Data() : (_normRange.Length()>0 ? _normRange.Data() : 0)) ;
572 
573 // cout << "RooAbsPdf::syncNormalization(" << GetName() << ") rangeName for normalization is " << (nr?nr:"<null>") << endl ;
574  RooAbsReal* normInt = createIntegral(*depList,*getIntegratorConfig(),nr) ;
575  normInt->getVal() ;
576 // cout << "resulting normInt = " << normInt->GetName() << endl ;
577 
578  const char* cacheParamsStr = getStringAttribute("CACHEPARAMINT") ;
579  if (cacheParamsStr && strlen(cacheParamsStr)) {
580 
581  std::unique_ptr<RooArgSet> intParams{normInt->getVariables()} ;
582 
583  RooNameSet cacheParamNames ;
584  cacheParamNames.setNameList(cacheParamsStr) ;
585  std::unique_ptr<RooArgSet> cacheParams{cacheParamNames.select(*intParams)} ;
586 
587  if (cacheParams->getSize()>0) {
588  cxcoutD(Caching) << "RooAbsReal::createIntObj(" << GetName() << ") INFO: constructing " << cacheParams->getSize()
589  << "-dim value cache for integral over " << *depList << " as a function of " << *cacheParams << " in range " << (nr?nr:"<default>") << endl ;
590  string name = Form("%s_CACHE_[%s]",normInt->GetName(),cacheParams->contentsString().c_str()) ;
591  RooCachedReal* cachedIntegral = new RooCachedReal(name.c_str(),name.c_str(),*normInt,*cacheParams) ;
592  cachedIntegral->setInterpolationOrder(2) ;
593  cachedIntegral->addOwnedComponents(*normInt) ;
594  cachedIntegral->setCacheSource(kTRUE) ;
595  if (normInt->operMode()==ADirty) {
596  cachedIntegral->setOperMode(ADirty) ;
597  }
598  normInt= cachedIntegral ;
599  }
600 
601  }
602  _norm = normInt ;
603  }
604 
605  // Register new normalization with manager (takes ownership)
606  cache = new CacheElem(*_norm) ;
607  _normMgr.setObj(nset,cache) ;
608 
609 // cout << "making new object " << _norm->GetName() << endl ;
610 
611  return kTRUE ;
612 }
613 
614 
615 
616 ////////////////////////////////////////////////////////////////////////////////
617 /// Reset error counter to given value, limiting the number
618 /// of future error messages for this pdf to 'resetValue'
619 
621 {
622  _errorCount = resetValue ;
623  _negCount = resetValue ;
624 }
625 
626 
627 
628 ////////////////////////////////////////////////////////////////////////////////
629 /// Reset trace counter to given value, limiting the
630 /// number of future trace messages for this pdf to 'value'
631 
633 {
634  if (!allNodes) {
635  _traceCount = value ;
636  return ;
637  } else {
638  RooArgList branchList ;
639  branchNodeServerList(&branchList) ;
640  TIterator* iter = branchList.createIterator() ;
641  RooAbsArg* arg ;
642  while((arg=(RooAbsArg*)iter->Next())) {
643  RooAbsPdf* pdf = dynamic_cast<RooAbsPdf*>(arg) ;
644  if (pdf) pdf->setTraceCounter(value,kFALSE) ;
645  }
646  delete iter ;
647  }
648 
649 }
650 
651 
652 
653 
654 ////////////////////////////////////////////////////////////////////////////////
655 /// Return the log of the current value with given normalization
656 /// An error message is printed if the argument of the log is negative.
657 
659 {
660  Double_t prob = getVal(nset) ;
661 
662  if (fabs(prob)>1e6) {
663  coutW(Eval) << "RooAbsPdf::getLogVal(" << GetName() << ") WARNING: large likelihood value: " << prob << endl ;
664  }
665 
666  if(prob < 0) {
667  logEvalError("getLogVal() top-level p.d.f evaluates to a negative number") ;
668  return RooNaNPacker::packFloatIntoNaN(-prob);
669  }
670 
671  if(prob == 0) {
672  logEvalError("getLogVal() top-level p.d.f evaluates to zero") ;
673 
674  return -std::numeric_limits<double>::infinity();
675  }
676 
677  if (TMath::IsNaN(prob)) {
678  logEvalError("getLogVal() top-level p.d.f evaluates to NaN") ;
679 
680  return prob;
681  }
682 
683  return log(prob);
684 }
685 
686 
687 ////////////////////////////////////////////////////////////////////////////////
688 /// Check for infinity or NaN.
689 /// \param[in] inputs Array to check
690 /// \return True if either infinity or NaN were found.
691 namespace {
692 template<class T>
693 bool checkInfNaNNeg(const T& inputs) {
694  // check for a math error or negative value
695  bool inf = false;
696  bool nan = false;
697  bool neg = false;
698 
699  for (double val : inputs) { //CHECK_VECTORISE
700  inf |= !std::isfinite(val);
701  nan |= TMath::IsNaN(val); // Works also during fast math
702  neg |= val < 0;
703  }
704 
705  return inf || nan || neg;
706 }
707 }
708 
709 
710 ////////////////////////////////////////////////////////////////////////////////
711 /// Scan through outputs and fix+log all nans and negative values.
712 /// \param[in,out] outputs Array to be scanned & fixed.
713 /// \param[in] begin Begin of event range. Only needed to print the correct event number
714 /// where the error occurred.
715 void RooAbsPdf::logBatchComputationErrors(RooSpan<const double>& outputs, std::size_t begin) const {
716  for (unsigned int i=0; i<outputs.size(); ++i) {
717  const double value = outputs[i];
718  if (TMath::IsNaN(outputs[i])) {
719  logEvalError(Form("p.d.f value of (%s) is Not-a-Number (%f) for entry %zu",
720  GetName(), value, begin+i));
721  } else if (!std::isfinite(outputs[i])){
722  logEvalError(Form("p.d.f value of (%s) is (%f) for entry %zu",
723  GetName(), value, begin+i));
724  } else if (outputs[i] < 0.) {
725  logEvalError(Form("p.d.f value of (%s) is less than zero (%f) for entry %zu",
726  GetName(), value, begin+i));
727  }
728  }
729 }
730 
731 
732 ////////////////////////////////////////////////////////////////////////////////
733 /// Compute the log-likelihoods for all events in the requested batch.
734 /// The arguments are passed over to getValues().
735 /// \param[in] evalData Struct with data that should be used for evaluation.
736 /// \param[in] normSet Optional normalisation set to be used during computations.
737 /// \return Returns a batch of doubles that contains the log probabilities.
739 {
740  auto pdfValues = getValues(evalData, normSet);
741 
742  evalData.logProbabilities.resize(pdfValues.size());
744 
745  if (checkInfNaNNeg(pdfValues)) {
746  logBatchComputationErrors(pdfValues, 0);
747 
748  for (std::size_t i = 0; i < pdfValues.size(); ++i) {
749  const double prob = pdfValues[i];
750  double theLog = RooBatchCompute::fast_log(prob);
751 
752  if (prob <= 0.) {
753  // Pass magnitude of undershoot to minimiser:
754  theLog = RooNaNPacker::packFloatIntoNaN(-prob);
755  } else if (std::isnan(prob)) {
756  theLog = prob;
757  }
758 
759  output[i] = theLog;
760  }
761 
762  return output;
763  }
764 
765  for (std::size_t i = 0; i < pdfValues.size(); ++i) { //CHECK_VECTORISE
766  const double prob = pdfValues[i];
767  output[i] = RooBatchCompute::fast_log(prob);;
768  }
769 
770  return output;
771 }
772 
773 ////////////////////////////////////////////////////////////////////////////////
774 /// Return the extended likelihood term (\f$ N_\mathrm{expect} - N_\mathrm{observed} \cdot \log(N_\mathrm{expect} \f$)
775 /// of this PDF for the given number of observed events.
776 ///
777 /// For successful operation, the PDF implementation must indicate that
778 /// it is extendable by overloading `canBeExtended()`, and must
779 /// implement the `expectedEvents()` function.
780 
782 {
783  // check if this PDF supports extended maximum likelihood fits
784  if(!canBeExtended()) {
785  coutE(InputArguments) << fName << ": this PDF does not support extended maximum likelihood"
786  << endl;
787  return 0;
788  }
789 
790  Double_t expected= expectedEvents(nset);
791  if(expected < 0) {
792  coutE(InputArguments) << fName << ": calculated negative expected events: " << expected
793  << endl;
794  return 0;
795  }
796 
797 
798  // Explicitly handle case Nobs=Nexp=0
799  if (fabs(expected)<1e-10 && fabs(observed)<1e-10) {
800  return 0 ;
801  }
802 
803  // Check for errors in Nexpected
804  if (expected<0 || TMath::IsNaN(expected)) {
805  logEvalError("extendedTerm #expected events is <0 or NaN") ;
806  return 0 ;
807  }
808 
809  // calculate and return the negative log-likelihood of the Poisson
810  // factor for this dataset, dropping the constant log(observed!)
811  // Double_t extra=0;
812  // if(observed<1000000) {
813  // Double_t Delta1 = (expected-observed);
814  // Double_t Delta2 = observed*(log(expected)-log(observed+1));
815  // Double_t Const3 = 0.5*log(observed+1);
816  // extra= Delta1 - Delta2 + Const3;
817 
818  // cout << " extra obs = " << observed << " exp = " << expected << endl ;
819  // cout << " extra orig = " << expected - observed*log(expected) << endl ;
820  // cout << " extra orig fix = " << expected - observed*log(expected) + log(TMath::Gamma(observed+1)) << endl ;
821  // cout << " extra new = " << extra << endl ;
822 
823  // } else {
824  // Double_t sigma_square=expected;
825  // Double_t diff=observed-expected;
826  // extra=-log(sigma_square)/2 + (diff*diff)/(2*sigma_square);
827  // }
828 
829  Double_t extra= expected - observed*log(expected);
830 
831 // cout << "RooAbsPdf::extendedTerm(" << GetName() << ") observed = " << observed << " expected = " << expected << endl ;
832 
833  Bool_t trace(kFALSE) ;
834  if(trace) {
835  cxcoutD(Tracing) << fName << "::extendedTerm: expected " << expected << " events, got "
836  << observed << " events. extendedTerm = " << extra << endl;
837  }
838 
839 // cout << "RooAbsPdf::extendedTerm(" << GetName() << ") nExp = " << expected << " nObs = " << observed << endl ;
840  return extra;
841 }
842 
843 
844 
845 ////////////////////////////////////////////////////////////////////////////////
846 /// Construct representation of -log(L) of PDF with given dataset. If dataset is unbinned, an unbinned likelihood is constructed. If the dataset
847 /// is binned, a binned likelihood is constructed.
848 ///
849 /// The following named arguments are supported
850 ///
851 /// <table>
852 /// <tr><th> Type of CmdArg <th> Effect on nll
853 /// <tr><td> `ConditionalObservables(const RooArgSet& set)` <td> Do not normalize PDF over listed observables
854 /// <tr><td> `Extended(Bool_t flag)` <td> Add extended likelihood term, off by default
855 /// <tr><td> `Range(const char* name)` <td> Fit only data inside range with given name
856 /// <tr><td> `Range(Double_t lo, Double_t hi)` <td> Fit only data inside given range. A range named "fit" is created on the fly on all observables.
857 /// Multiple comma separated range names can be specified.
858 /// <tr><td> `SumCoefRange(const char* name)` <td> Set the range in which to interpret the coefficients of RooAddPdf components
859 /// <tr><td> `NumCPU(int num, int strat)` <td> Parallelize NLL calculation on num CPUs
860 /// <table>
861 /// <tr><th> Strategy <th> Effect
862 /// <tr><td> 0 = RooFit::BulkPartition (Default) <td> Divide events in N equal chunks
863 /// <tr><td> 1 = RooFit::Interleave <td> Process event i%N in process N. Recommended for binned data with
864 /// a substantial number of zero-bins, which will be distributed across processes more equitably in this strategy
865 /// <tr><td> 2 = RooFit::SimComponents <td> Process each component likelihood of a RooSimultaneous fully in a single process
866 /// and distribute components over processes. This approach can be benificial if normalization calculation time
867 /// dominates the total computation time of a component (since the normalization calculation must be performed
868 /// in each process in strategies 0 and 1. However beware that if the RooSimultaneous components do not share many
869 /// parameters this strategy is inefficient: as most minuit-induced likelihood calculations involve changing
870 /// a single parameter, only 1 of the N processes will be active most of the time if RooSimultaneous components
871 /// do not share many parameters
872 /// <tr><td> 3 = RooFit::Hybrid <td> Follow strategy 0 for all RooSimultaneous components, except those with less than
873 /// 30 dataset entries, for which strategy 2 is followed.
874 /// </table>
875 /// <tr><td> `BatchMode(bool on)` <td> Batch evaluation mode. See fitTo().
876 /// <tr><td> `Optimize(Bool_t flag)` <td> Activate constant term optimization (on by default)
877 /// <tr><td> `SplitRange(Bool_t flag)` <td> Use separate fit ranges in a simultaneous fit. Actual range name for each subsample is assumed to
878 /// be `rangeName_indexState`, where `indexState` is the state of the master index category of the simultaneous fit.
879 /// Using `Range("range"), SplitRange()` as switches, different ranges could be set like this:
880 /// ```
881 /// myVariable.setRange("range_pi0", 135, 210);
882 /// myVariable.setRange("range_gamma", 50, 210);
883 /// ```
884 /// <tr><td> `Constrain(const RooArgSet&pars)` <td> For p.d.f.s that contain internal parameter constraint terms (that is usually product PDFs, where one
885 /// term of the product depends on parameters but not on the observable(s),), only apply constraints to the given subset of parameters.
886 /// <tr><td> `ExternalConstraints(const RooArgSet& )` <td> Include given external constraints to likelihood by multiplying them with the original likelihood.
887 /// <tr><td> `GlobalObservables(const RooArgSet&)` <td> Define the set of normalization observables to be used for the constraint terms.
888 /// If none are specified the constrained parameters are used.
889 /// <tr><td> `GlobalObservablesTag(const char* tagName)` <td> Define the set of normalization observables to be used for the constraint terms by
890 /// a string attribute associated with pdf observables that match the given tagName.
891 /// <tr><td> `Verbose(Bool_t flag)` <td> Controls RooFit informational messages in likelihood construction
892 /// <tr><td> `CloneData(Bool flag)` <td> Use clone of dataset in NLL (default is true)
893 /// <tr><td> `Offset(Bool_t)` <td> Offset likelihood by initial value (so that starting value of FCN in minuit is zero).
894 /// This can improve numeric stability in simultaneous fits with components with large likelihood values
895 /// <tr><td> `IntegrateBins(double precision)` <td> In binned fits, integrate the PDF over the bins instead of using the probability density at the bin centre.
896 /// This can reduce the bias observed when fitting functions with high curvature to binned data.
897 /// - precision > 0: Activate bin integration everywhere. Use precision between 0.01 and 1.E-6, depending on binning.
898 /// Note that a low precision such as 0.01 might yield identical results to 1.E-4, since the integrator might reach 1.E-4 already in its first
899 /// integration step. If lower precision is desired (more speed), a RooBinSamplingPdf has to be created manually, and its integrator
900 /// has to be manipulated directly.
901 /// - precision = 0: Activate bin integration only for continuous PDFs fit to a RooDataHist.
902 /// - precision < 0: Deactivate.
903 /// \see RooBinSamplingPdf
904 /// </table>
905 ///
906 ///
907 
908 RooAbsReal* RooAbsPdf::createNLL(RooAbsData& data, const RooCmdArg& arg1, const RooCmdArg& arg2, const RooCmdArg& arg3, const RooCmdArg& arg4,
909  const RooCmdArg& arg5, const RooCmdArg& arg6, const RooCmdArg& arg7, const RooCmdArg& arg8)
910 {
911  RooLinkedList l ;
912  l.Add((TObject*)&arg1) ; l.Add((TObject*)&arg2) ;
913  l.Add((TObject*)&arg3) ; l.Add((TObject*)&arg4) ;
914  l.Add((TObject*)&arg5) ; l.Add((TObject*)&arg6) ;
915  l.Add((TObject*)&arg7) ; l.Add((TObject*)&arg8) ;
916  return createNLL(data,l) ;
917 }
918 
919 namespace {
920 
921 RooAbsReal *createMultiRangeNLLCorrectionTerm(RooAbsPdf const &pdf, RooAbsData const &data, std::string const &baseName,
922  std::string const &rangeNames)
923 {
924  double sumEntriesTotal = 0.0;
925 
926  RooArgList termList;
927  RooArgList integralList;
928 
929  for (const auto &currentRangeName : RooHelpers::tokenise(rangeNames, ",")) {
930  const std::string currentName = baseName + "_" + currentRangeName;
931 
932  auto sumEntriesCurrent = data.sumEntries("1", currentRangeName.c_str());
933  sumEntriesTotal += sumEntriesCurrent;
934 
935  auto pdfIntegralCurrent =
936  pdf.createIntegral(*pdf.getObservables(data), nullptr, nullptr, currentRangeName.c_str());
937 
938  auto term = new RooFormulaVar((currentName + "_correctionTerm").c_str(),
939  (std::string("-(") + std::to_string(sumEntriesCurrent) + " * log(x[0]))").c_str(),
940  RooArgList(*pdfIntegralCurrent));
941 
942  termList.add(*term);
943  integralList.add(*pdfIntegralCurrent);
944  }
945 
946  auto integralFull = new RooAddition((baseName + "_correctionFullIntegralTerm").c_str(),
947  "integral",
948  integralList,
949  true);
950 
951  auto fullRangeTerm = new RooFormulaVar((baseName + "_foobar").c_str(),
952  (std::string("(") + std::to_string(sumEntriesTotal) + " * log(x[0]))").c_str(),
953  RooArgList(*integralFull));
954 
955  termList.add(*fullRangeTerm);
956  return new RooAddition((baseName + "_correction").c_str(), "correction", termList, true);
957 }
958 
959 } // namespace
960 
961 
962 ////////////////////////////////////////////////////////////////////////////////
963 /// Construct representation of -log(L) of PDFwith given dataset. If dataset is unbinned, an unbinned likelihood is constructed. If the dataset
964 /// is binned, a binned likelihood is constructed.
965 ///
966 /// See RooAbsPdf::createNLL(RooAbsData& data, RooCmdArg arg1, RooCmdArg arg2, RooCmdArg arg3, RooCmdArg arg4,
967 /// RooCmdArg arg5, RooCmdArg arg6, RooCmdArg arg7, RooCmdArg arg8)
968 /// for documentation of options
969 
971 {
972 
973  // Select the pdf-specific commands
974  RooCmdConfig pc(Form("RooAbsPdf::createNLL(%s)",GetName())) ;
975 
976  pc.defineString("rangeName","RangeWithName",0,"",kTRUE) ;
977  pc.defineString("addCoefRange","SumCoefRange",0,"") ;
978  pc.defineString("globstag","GlobalObservablesTag",0,"") ;
979  pc.defineDouble("rangeLo","Range",0,-999.) ;
980  pc.defineDouble("rangeHi","Range",1,-999.) ;
981  pc.defineInt("splitRange","SplitRange",0,0) ;
982  pc.defineInt("ext","Extended",0,2) ;
983  pc.defineInt("numcpu","NumCPU",0,1) ;
984  pc.defineInt("interleave","NumCPU",1,0) ;
985  pc.defineInt("verbose","Verbose",0,0) ;
986  pc.defineInt("optConst","Optimize",0,0) ;
987  pc.defineInt("cloneData","CloneData", 0, 2);
988  pc.defineSet("projDepSet","ProjectedObservables",0,0) ;
989  pc.defineSet("cPars","Constrain",0,0) ;
990  pc.defineSet("glObs","GlobalObservables",0,0) ;
991 // pc.defineInt("constrAll","Constrained",0,0) ;
992  pc.defineInt("doOffset","OffsetLikelihood",0,0) ;
993  pc.defineSet("extCons","ExternalConstraints",0,0) ;
994  pc.defineInt("BatchMode", "BatchMode", 0, 0);
995  pc.defineDouble("IntegrateBins", "IntegrateBins", 0, -1.);
996  pc.defineMutex("Range","RangeWithName") ;
997 // pc.defineMutex("Constrain","Constrained") ;
998  pc.defineMutex("GlobalObservables","GlobalObservablesTag") ;
999 
1000  // Process and check varargs
1001  pc.process(cmdList) ;
1002  if (!pc.ok(kTRUE)) {
1003  return 0 ;
1004  }
1005 
1006  // Decode command line arguments
1007  const char* rangeName = pc.getString("rangeName",0,kTRUE) ;
1008  const char* addCoefRangeName = pc.getString("addCoefRange",0,kTRUE) ;
1009  const char* globsTag = pc.getString("globstag",0,kTRUE) ;
1010  Int_t ext = pc.getInt("ext") ;
1011  Int_t numcpu = pc.getInt("numcpu") ;
1012  Int_t numcpu_strategy = pc.getInt("interleave");
1013  // strategy 3 works only for RooSimultaneus.
1014  if (numcpu_strategy==3 && !this->InheritsFrom("RooSimultaneous") ) {
1015  coutW(Minimization) << "Cannot use a NumCpu Strategy = 3 when the pdf is not a RooSimultaneus, "
1016  "falling back to default strategy = 0" << endl;
1017  numcpu_strategy = 0;
1018  }
1019  RooFit::MPSplit interl = (RooFit::MPSplit) numcpu_strategy;
1020 
1021  Int_t splitr = pc.getInt("splitRange") ;
1022  Bool_t verbose = pc.getInt("verbose") ;
1023  Int_t optConst = pc.getInt("optConst") ;
1024  Int_t cloneData = pc.getInt("cloneData") ;
1025  Int_t doOffset = pc.getInt("doOffset") ;
1026 
1027  // If no explicit cloneData command is specified, cloneData is set to true if optimization is activated
1028  if (cloneData==2) {
1029  cloneData = optConst ;
1030  }
1031 
1032 
1033  RooArgSet* cPars = pc.getSet("cPars") ;
1034  RooArgSet* glObs = pc.getSet("glObs") ;
1035  if (pc.hasProcessed("GlobalObservablesTag")) {
1036  if (glObs) delete glObs ;
1037  RooArgSet* allVars = getVariables() ;
1038  glObs = (RooArgSet*) allVars->selectByAttrib(globsTag,kTRUE) ;
1039  coutI(Minimization) << "User-defined specification of global observables definition with tag named '" << globsTag << "'" << endl ;
1040  delete allVars ;
1041  } else if (!pc.hasProcessed("GlobalObservables")) {
1042 
1043  // Neither GlobalObservables nor GlobalObservablesTag has been processed - try if a default tag is defined in the head node
1044  // Check if head not specifies default global observable tag
1045  const char* defGlobObsTag = getStringAttribute("DefaultGlobalObservablesTag") ;
1046  if (defGlobObsTag) {
1047  coutI(Minimization) << "p.d.f. provides built-in specification of global observables definition with tag named '" << defGlobObsTag << "'" << endl ;
1048  if (glObs) delete glObs ;
1049  RooArgSet* allVars = getVariables() ;
1050  glObs = (RooArgSet*) allVars->selectByAttrib(defGlobObsTag,kTRUE) ;
1051  }
1052  }
1053 
1054 
1055  Bool_t doStripDisconnected=kFALSE ;
1056 
1057  // If no explicit list of parameters to be constrained is specified apply default algorithm
1058  // All terms of RooProdPdfs that do not contain observables and share a parameters with one or more
1059  // terms that do contain observables are added as constraints.
1060  if (!cPars) {
1061  cPars = getParameters(data,kFALSE) ;
1062  doStripDisconnected=kTRUE ;
1063  }
1064  const RooArgSet* extCons = pc.getSet("extCons") ;
1065 
1066  // Process automatic extended option
1067  if (ext==2) {
1068  ext = ((extendMode()==CanBeExtended || extendMode()==MustBeExtended)) ? 1 : 0 ;
1069  if (ext) {
1070  coutI(Minimization) << "p.d.f. provides expected number of events, including extended term in likelihood." << endl ;
1071  }
1072  }
1073 
1074  // Clear possible range attributes from previous fits.
1075  setStringAttribute("fitrange", nullptr);
1076 
1077  if (pc.hasProcessed("Range")) {
1078  Double_t rangeLo = pc.getDouble("rangeLo") ;
1079  Double_t rangeHi = pc.getDouble("rangeHi") ;
1080 
1081  // Create range with name 'fit' with above limits on all observables
1082  RooArgSet* obs = getObservables(&data) ;
1083  for (auto arg : *obs) {
1084  RooRealVar* rrv = dynamic_cast<RooRealVar*>(arg) ;
1085  if (rrv) rrv->setRange("fit",rangeLo,rangeHi) ;
1086  }
1087 
1088  // Set range name to be fitted to "fit"
1089  rangeName = "fit" ;
1090  }
1091 
1092  RooArgSet projDeps ;
1093  RooArgSet* tmp = pc.getSet("projDepSet") ;
1094  if (tmp) {
1095  projDeps.add(*tmp) ;
1096  }
1097 
1098  // Construct NLL
1100  RooAbsReal* nll ;
1101  string baseName = Form("nll_%s_%s",GetName(),data.GetName()) ;
1102  if (!rangeName || strchr(rangeName,',')==0) {
1103  // Simple case: default range, or single restricted range
1104  //cout<<"FK: Data test 1: "<<data.sumEntries()<<endl;
1105 
1107  cfg.rangeName = rangeName ? rangeName : "";
1108  cfg.addCoefRangeName = addCoefRangeName ? addCoefRangeName : "";
1109  cfg.nCPU = numcpu;
1110  cfg.interleave = interl;
1111  cfg.verbose = verbose;
1112  cfg.splitCutRange = static_cast<bool>(splitr);
1113  cfg.cloneInputData = static_cast<bool>(cloneData);
1114  cfg.integrateOverBinsPrecision = pc.getDouble("IntegrateBins");
1115  cfg.binnedL = false;
1116  auto theNLL = new RooNLLVar(baseName.c_str(),"-log(likelihood)",*this,data,projDeps,std::move(cfg), ext);
1117  theNLL->batchMode(pc.getInt("BatchMode"));
1118  nll = theNLL;
1119  } else {
1120  // Composite case: multiple ranges
1121  RooArgList nllList ;
1122  auto tokens = RooHelpers::tokenise(rangeName, ",");
1123  for (const auto& token : tokens) {
1125  cfg.rangeName = token;
1126  cfg.addCoefRangeName = addCoefRangeName ? addCoefRangeName : "";
1127  cfg.nCPU = numcpu;
1128  cfg.interleave = interl;
1129  cfg.verbose = verbose;
1130  cfg.splitCutRange = static_cast<bool>(splitr);
1131  cfg.cloneInputData = static_cast<bool>(cloneData);
1132  cfg.integrateOverBinsPrecision = pc.getDouble("IntegrateBins");
1133  cfg.binnedL = false;
1134  auto nllComp = new RooNLLVar(Form("%s_%s",baseName.c_str(),token.c_str()),"-log(likelihood)",
1135  *this,data,projDeps,std::move(cfg),ext);
1136  nllComp->batchMode(pc.getInt("BatchMode"));
1137  nllList.add(*nllComp) ;
1138  }
1139 
1140  if (!ext) {
1141  // Each RooNLLVar was created with the normalization set corresponding to
1142  // the subrange, not the union range like it should be. We have to add an
1143  // extra term to cancel this normalization problem. However, this is
1144  // only necessarry for the non-extended case, because adding an extension
1145  // term to the individual NLLs as done here is mathematicall equivalent
1146  // to adding the normalization correction terms plus a global extension
1147  // term.
1148  nllList.add(*createMultiRangeNLLCorrectionTerm(*this, data, baseName, rangeName));
1149  }
1150 
1151  nll = new RooAddition(baseName.c_str(),"-log(likelihood)",nllList,true) ;
1152  }
1154 
1155  // Collect internal and external constraint specifications
1156  RooArgSet allConstraints ;
1157 
1158  if (_myws && _myws->set(Form("CACHE_CONSTR_OF_PDF_%s_FOR_OBS_%s", GetName(), RooNameSet(*data.get()).content()))) {
1159 
1160  // retrieve from cache
1161  const RooArgSet *constr =
1162  _myws->set(Form("CACHE_CONSTR_OF_PDF_%s_FOR_OBS_%s", GetName(), RooNameSet(*data.get()).content()));
1163  coutI(Minimization) << "createNLL picked up cached constraints from workspace with " << constr->getSize()
1164  << " entries" << endl;
1165  allConstraints.add(*constr);
1166 
1167  } else {
1168 
1169  if (cPars && cPars->getSize() > 0) {
1170  RooArgSet *constraints = getAllConstraints(*data.get(), *cPars, doStripDisconnected);
1171  allConstraints.add(*constraints);
1172  delete constraints;
1173  }
1174  if (extCons) {
1175  allConstraints.add(*extCons);
1176  }
1177 
1178  // write to cache
1179  if (_myws) {
1180  // cout << "createNLL: creating cache for allconstraints=" << allConstraints << endl ;
1181  coutI(Minimization) << "createNLL: caching constraint set under name "
1182  << Form("CONSTR_OF_PDF_%s_FOR_OBS_%s", GetName(), RooNameSet(*data.get()).content())
1183  << " with " << allConstraints.getSize() << " entries" << endl;
1185  Form("CACHE_CONSTR_OF_PDF_%s_FOR_OBS_%s", GetName(), RooNameSet(*data.get()).content()), allConstraints);
1186  }
1187  }
1188 
1189  // Include constraints, if any, in likelihood
1190  RooAbsReal* nllCons(0) ;
1191  if (allConstraints.getSize()>0 && cPars) {
1192 
1193  coutI(Minimization) << " Including the following constraint terms in minimization: " << allConstraints << endl ;
1194  if (glObs) {
1195  coutI(Minimization) << "The following global observables have been defined: " << *glObs << endl ;
1196  }
1197  nllCons = new RooConstraintSum(Form("%s_constr",baseName.c_str()),"nllCons",allConstraints,glObs ? *glObs : *cPars) ;
1198  nllCons->setOperMode(ADirty) ;
1199  RooAbsReal* orignll = nll ;
1200 
1201  nll = new RooAddition(Form("%s_with_constr",baseName.c_str()),"nllWithCons",RooArgSet(*nll,*nllCons)) ;
1202  nll->addOwnedComponents(RooArgSet(*orignll,*nllCons)) ;
1203  }
1204 
1205 
1206  if (optConst) {
1208  }
1209 
1210  if (doStripDisconnected) {
1211  delete cPars ;
1212  }
1213 
1214  if (doOffset) {
1215  nll->enableOffsetting(kTRUE) ;
1216  }
1217 
1218  return nll ;
1219 }
1220 
1221 
1222 template <class Minimizer>
1224 {
1225  // Calculated corrected errors for weighted likelihood fits
1226  std::unique_ptr<RooFitResult> rw(minimizer.save());
1227  // Weighted inverse Hessian matrix
1228  const TMatrixDSym &matV = rw->covarianceMatrix();
1229  coutI(Fitting)
1230  << "RooAbsPdf::fitTo(" << this->GetName()
1231  << ") Calculating covariance matrix according to the asymptotically correct approach. If you find this "
1232  "method useful please consider citing https://arxiv.org/abs/1911.01303."
1233  << endl;
1234 
1235  // Initialise matrix containing first derivatives
1236  auto nFloatPars = rw->floatParsFinal().getSize();
1237  TMatrixDSym num(nFloatPars);
1238  for (int k = 0; k < nFloatPars; k++) {
1239  for (int l = 0; l < nFloatPars; l++) {
1240  num(k, l) = 0.0;
1241  }
1242  }
1243  RooArgSet *obs = this->getObservables(data);
1244  // Create derivative objects
1245  std::vector<std::unique_ptr<RooDerivative>> derivatives;
1246  const RooArgList &floated = rw->floatParsFinal();
1247  std::unique_ptr<RooArgSet> floatingparams{
1248  static_cast<RooArgSet *>(this->getParameters(data)->selectByAttrib("Constant", false))};
1249  for (const auto paramresult : floated) {
1250  auto paraminternal = static_cast<RooRealVar *>(floatingparams->find(*paramresult));
1251  assert(floatingparams->find(*paramresult)->IsA() == RooRealVar::Class());
1252  derivatives.emplace_back(this->derivative(*paraminternal, *obs, 1));
1253  }
1254 
1255  // Loop over data
1256  for (int j = 0; j < data.numEntries(); j++) {
1257  // Sets obs to current data point, this is where the pdf will be evaluated
1258  *obs = *data.get(j);
1259  // Determine first derivatives
1260  std::vector<double> diffs(floated.getSize(), 0.0);
1261  for (int k = 0; k < floated.getSize(); k++) {
1262  const auto paramresult = static_cast<RooRealVar *>(floated.at(k));
1263  auto paraminternal = static_cast<RooRealVar *>(floatingparams->find(*paramresult));
1264  // first derivative to parameter k at best estimate point for this measurement
1265  double diff = derivatives[k]->getVal();
1266  // need to reset to best fit point after differentiation
1267  *paraminternal = paramresult->getVal();
1268  diffs[k] = diff;
1269  }
1270  // Fill numerator matrix
1271  double prob = getVal(obs);
1272  for (int k = 0; k < floated.getSize(); k++) {
1273  for (int l = 0; l < floated.getSize(); l++) {
1274  num(k, l) += data.weight() * data.weight() * diffs[k] * diffs[l] / (prob * prob);
1275  }
1276  }
1277  }
1278  num.Similarity(matV);
1279 
1280  // Propagate corrected errors to parameters objects
1281  minimizer.applyCovarianceMatrix(num);
1282 
1283  // The derivatives are found in RooFit and not with the minimizer (e.g.
1284  // minuit), so the quality of the corrected covariance matrix corresponds to
1285  // the quality of the original covariance matrix
1286  return rw->covQual();
1287 }
1288 
1289 template <class Minimizer>
1291 {
1292 
1293  // Make list of RooNLLVar components of FCN
1294  std::vector<RooNLLVar *> nllComponents;
1295  std::unique_ptr<RooArgSet> comps{nll.getComponents()};
1296  for (auto const &arg : *comps) {
1297  if (RooNLLVar *nllComp = dynamic_cast<RooNLLVar *>(arg)) {
1298  nllComponents.push_back(nllComp);
1299  }
1300  }
1301 
1302  // Calculated corrected errors for weighted likelihood fits
1303  std::unique_ptr<RooFitResult> rw{minimizer.save()};
1304  for (auto &comp : nllComponents) {
1305  comp->applyWeightSquared(true);
1306  }
1307  coutI(Fitting) << "RooAbsPdf::fitTo(" << this->GetName()
1308  << ") Calculating sum-of-weights-squared correction matrix for covariance matrix"
1309  << std::endl;
1310  minimizer.hesse();
1311  std::unique_ptr<RooFitResult> rw2{minimizer.save()};
1312  for (auto &comp : nllComponents) {
1313  comp->applyWeightSquared(false);
1314  }
1315 
1316  // Apply correction matrix
1317  const TMatrixDSym &matV = rw->covarianceMatrix();
1318  TMatrixDSym matC = rw2->covarianceMatrix();
1319  ROOT::Math::CholeskyDecompGenDim<double> decomp(matC.GetNrows(), matC);
1320  if (!decomp) {
1321  coutE(Fitting) << "RooAbsPdf::fitTo(" << this->GetName()
1322  << ") ERROR: Cannot apply sum-of-weights correction to covariance matrix: correction "
1323  "matrix calculated with weight-squared is singular"
1324  << std::endl;
1325  return -1;
1326  }
1327 
1328  // replace C by its inverse
1329  decomp.Invert(matC);
1330  // the class lies about the matrix being symmetric, so fill in the
1331  // part above the diagonal
1332  for (int i = 0; i < matC.GetNrows(); ++i) {
1333  for (int j = 0; j < i; ++j) {
1334  matC(j, i) = matC(i, j);
1335  }
1336  }
1337  matC.Similarity(matV);
1338  // C now contiains V C^-1 V
1339  // Propagate corrected errors to parameters objects
1340  minimizer.applyCovarianceMatrix(matC);
1341 
1342  return std::min(rw->covQual(), rw2->covQual());
1343 }
1344 
1345 
1346 ////////////////////////////////////////////////////////////////////////////////
1347 /// Fit PDF to given dataset. If dataset is unbinned, an unbinned maximum likelihood is performed. If the dataset
1348 /// is binned, a binned maximum likelihood is performed. By default the fit is executed through the MINUIT
1349 /// commands MIGRAD, HESSE in succession.
1350 /// \param[in] data Data to fit the PDF to
1351 /// \param[in] arg1 One or more arguments to control the behaviour of the fit
1352 /// \return RooFitResult with fit status and parameters if option Save() is used, `nullptr` otherwise. The user takes ownership of the fit result.
1353 ///
1354 /// The following named arguments are supported
1355 ///
1356 /// <table>
1357 /// <tr><th> Type of CmdArg <th> Options to control construction of -log(L)
1358 /// <tr><td> `ConditionalObservables(const RooArgSet& set)` <td> Do not normalize PDF over listed observables
1359 /// <tr><td> `Extended(Bool_t flag)` <td> Add extended likelihood term, off by default
1360 /// <tr><td> `Range(const char* name)` <td> Fit only data inside range with given name. Multiple comma-separated range names can be specified.
1361 /// In this case, the unnormalized PDF \f$f(x)\f$ is normalized by the integral over all ranges \f$r_i\f$:
1362 /// \f[
1363 /// p(x) = \frac{f(x)}{\sum_i \int_{r_i} f(x) dx}.
1364 /// \f]
1365 /// <tr><td> `Range(Double_t lo, Double_t hi)` <td> Fit only data inside given range. A range named "fit" is created on the fly on all observables.
1366 /// <tr><td> `SumCoefRange(const char* name)` <td> Set the range in which to interpret the coefficients of RooAddPdf components
1367 /// <tr><td> `NumCPU(int num, int strat)` <td> Parallelize NLL calculation on `num` CPUs
1368 /// <table>
1369 /// <tr><th> Strategy <th> Effect
1370 /// <tr><td> 0 = RooFit::BulkPartition (Default) <td> Divide events in N equal chunks
1371 /// <tr><td> 1 = RooFit::Interleave <td> Process event i%N in process N. Recommended for binned data with
1372 /// a substantial number of zero-bins, which will be distributed across processes more equitably in this strategy
1373 /// <tr><td> 2 = RooFit::SimComponents <td> Process each component likelihood of a RooSimultaneous fully in a single process
1374 /// and distribute components over processes. This approach can be benificial if normalization calculation time
1375 /// dominates the total computation time of a component (since the normalization calculation must be performed
1376 /// in each process in strategies 0 and 1. However beware that if the RooSimultaneous components do not share many
1377 /// parameters this strategy is inefficient: as most minuit-induced likelihood calculations involve changing
1378 /// a single parameter, only 1 of the N processes will be active most of the time if RooSimultaneous components
1379 /// do not share many parameters
1380 /// <tr><td> 3 = RooFit::Hybrid <td> Follow strategy 0 for all RooSimultaneous components, except those with less than
1381 /// 30 dataset entries, for which strategy 2 is followed.
1382 /// </table>
1383 /// <tr><td> `SplitRange(Bool_t flag)` <td> Use separate fit ranges in a simultaneous fit. Actual range name for each subsample is assumed
1384 /// to by `rangeName_indexState` where indexState is the state of the master index category of the simultaneous fit.
1385 /// Using `Range("range"), SplitRange()` as switches, different ranges could be set like this:
1386 /// ```
1387 /// myVariable.setRange("range_pi0", 135, 210);
1388 /// myVariable.setRange("range_gamma", 50, 210);
1389 /// ```
1390 /// <tr><td> `Constrain(const RooArgSet&pars)` <td> For p.d.f.s that contain internal parameter constraint terms (that is usually product PDFs, where one
1391 /// term of the product depends on parameters but not on the observable(s),), only apply constraints to the given subset of parameters.
1392 /// <tr><td> `ExternalConstraints(const RooArgSet& )` <td> Include given external constraints to likelihood by multiplying them with the original likelihood.
1393 /// <tr><td> `GlobalObservables(const RooArgSet&)` <td> Define the set of normalization observables to be used for the constraint terms.
1394 /// If none are specified the constrained parameters are used.
1395 /// <tr><td> `Offset(Bool_t)` <td> Offset likelihood by initial value (so that starting value of FCN in minuit is zero).
1396 /// This can improve numeric stability in simultaneously fits with components with large likelihood values
1397 /// <tr><td> `BatchMode(bool on)` <td> **Experimental** batch evaluation mode. This computes a batch of likelihood values at a time,
1398 /// uses faster math functions and possibly auto vectorisation (this depends on the compiler flags).
1399 /// Depending on hardware capabilities, the compiler flags and whether a batch evaluation function was
1400 /// implemented for the PDFs of the model, likelihood computations are 2x to 10x faster.
1401 /// The relative difference of the single log-likelihoods w.r.t. the legacy mode is usually better than 1.E-12,
1402 /// and fit parameters usually agree to better than 1.E-6.
1403 /// <tr><td> `IntegrateBins(double precision)` <td> In binned fits, integrate the PDF over the bins instead of using the probability density at the bin centre.
1404 /// This can reduce the bias observed when fitting functions with high curvature to binned data.
1405 /// - precision > 0: Activate bin integration everywhere. Use precision between 0.01 and 1.E-6, depending on binning.
1406 /// Note that a low precision such as 0.01 might yield identical results to 1.E-4, since the integrator might reach 1.E-4 already in its first
1407 /// integration step. If lower precision is desired (more speed), a RooBinSamplingPdf has to be created manually, and its integrator
1408 /// has to be manipulated directly.
1409 /// - precision = 0: Activate bin integration only for continuous PDFs fit to a RooDataHist.
1410 /// - precision < 0: Deactivate.
1411 /// \see RooBinSamplingPdf
1412 ///
1413 /// <tr><th><th> Options to control flow of fit procedure
1414 /// <tr><td> `Minimizer(type,algo)` <td> Choose minimization package and algorithm to use. Default is MINUIT/MIGRAD through the RooMinimizer interface,
1415 /// but others can be specified (through RooMinimizer interface). Select OldMinuit to use MINUIT through the old RooMinuit interface
1416 /// <table>
1417 /// <tr><th> Type <th> Algorithm
1418 /// <tr><td> OldMinuit <td> migrad, simplex, minimize (=migrad+simplex), migradimproved (=migrad+improve)
1419 /// <tr><td> Minuit <td> migrad, simplex, minimize (=migrad+simplex), migradimproved (=migrad+improve)
1420 /// <tr><td> Minuit2 <td> migrad, simplex, minimize, scan
1421 /// <tr><td> GSLMultiMin <td> conjugatefr, conjugatepr, bfgs, bfgs2, steepestdescent
1422 /// <tr><td> GSLSimAn <td> -
1423 /// </table>
1424 ///
1425 /// <tr><td> `InitialHesse(Bool_t flag)` <td> Flag controls if HESSE before MIGRAD as well, off by default
1426 /// <tr><td> `Optimize(Bool_t flag)` <td> Activate constant term optimization of test statistic during minimization (on by default)
1427 /// <tr><td> `Hesse(Bool_t flag)` <td> Flag controls if HESSE is run after MIGRAD, on by default
1428 /// <tr><td> `Minos(Bool_t flag)` <td> Flag controls if MINOS is run after HESSE, off by default
1429 /// <tr><td> `Minos(const RooArgSet& set)` <td> Only run MINOS on given subset of arguments
1430 /// <tr><td> `Save(Bool_t flag)` <td> Flag controls if RooFitResult object is produced and returned, off by default
1431 /// <tr><td> `Strategy(Int_t flag)` <td> Set Minuit strategy (0 to 2, default is 1)
1432 /// <tr><td> `EvalErrorWall(bool flag=true)` <td> When parameters are in disallowed regions (e.g. PDF is negative), return very high value to fitter
1433 /// to force it out of that region. This can, however, mean that the fitter gets lost in this region. If
1434 /// this happens, try switching it off.
1435 /// <tr><td> `RecoverFromUndefinedRegions(double strength)` <td> When PDF is invalid (e.g. parameter in undefined region), try to direct minimiser away from that region.
1436 /// `strength` controls the magnitude of the penalty term. Leaving out this argument defaults to 10. Switch off with `strength = 0.`.
1437 /// <tr><td> `FitOptions(const char* optStr)` <td> \deprecated Steer fit with classic options string (for backward compatibility).
1438 /// \attention Use of this option excludes use of any of the new style steering options.
1439 ///
1440 /// <tr><td> `SumW2Error(Bool_t flag)` <td> Apply correction to errors and covariance matrix.
1441 /// This uses two covariance matrices, one with the weights, the other with squared weights,
1442 /// to obtain the correct errors for weighted likelihood fits. If this option is activated, the
1443 /// corrected covariance matrix is calculated as \f$ V_\mathrm{corr} = V C^{-1} V \f$, where \f$ V \f$ is the original
1444 /// covariance matrix and \f$ C \f$ is the inverse of the covariance matrix calculated using the
1445 /// squared weights. This allows to switch between two interpretations of errors:
1446 /// <table>
1447 /// <tr><th> SumW2Error <th> Interpretation
1448 /// <tr><td> true <td> The errors reflect the uncertainty of the Monte Carlo simulation.
1449 /// Use this if you want to know how much accuracy you can get from the available Monte Carlo statistics.
1450 ///
1451 /// **Example**: Simulation with 1000 events, the average weight is 0.1.
1452 /// The errors are as big as if one fitted to 1000 events.
1453 /// <tr><td> false <td> The errors reflect the errors of a dataset, which is as big as the sum of weights.
1454 /// Use this if you want to know what statistical errors you would get if you had a dataset with as many
1455 /// events as the (weighted) Monte Carlo simulation represents.
1456 ///
1457 /// **Example** (Data as above):
1458 /// The errors are as big as if one fitted to 100 events.
1459 /// </table>
1460 /// \note If the `SumW2Error` correction is enabled, the covariance matrix quality stored in the RooFitResult
1461 /// object will be the minimum of the original covariance matrix quality and the quality of the covariance
1462 /// matrix calculated with the squared weights.
1463 /// <tr><td> `AsymptoticError()` <td> Use the asymptotically correct approach to estimate errors in the presence of weights.
1464 /// This is slower but more accurate than `SumW2Error`. See also https://arxiv.org/abs/1911.01303).
1465 /// <tr><td> `PrefitDataFraction(double fraction)`
1466 /// <td> Runs a prefit on a small dataset of size fraction*(actual data size). This can speed up fits
1467 /// by finding good starting values for the parameters for the actual fit.
1468 /// \warning Prefitting may give bad results when used in binned analysis.
1469 ///
1470 /// <tr><th><th> Options to control informational output
1471 /// <tr><td> `Verbose(Bool_t flag)` <td> Flag controls if verbose output is printed (NLL, parameter changes during fit).
1472 /// <tr><td> `Timer(Bool_t flag)` <td> Time CPU and wall clock consumption of fit steps, off by default.
1473 /// <tr><td> `PrintLevel(Int_t level)` <td> Set Minuit print level (-1 to 3, default is 1). At -1 all RooFit informational messages are suppressed as well.
1474 /// See RooMinimizer::PrintLevel for the meaning of the levels.
1475 /// <tr><td> `Warnings(Bool_t flag)` <td> Enable or disable MINUIT warnings (enabled by default)
1476 /// <tr><td> `PrintEvalErrors(Int_t numErr)` <td> Control number of p.d.f evaluation errors printed per likelihood evaluation.
1477 /// A negative value suppresses output completely, a zero value will only print the error count per p.d.f component,
1478 /// a positive value will print details of each error up to `numErr` messages per p.d.f component.
1479 /// </table>
1480 ///
1481 
1482 RooFitResult* RooAbsPdf::fitTo(RooAbsData& data, const RooCmdArg& arg1, const RooCmdArg& arg2, const RooCmdArg& arg3, const RooCmdArg& arg4,
1483  const RooCmdArg& arg5, const RooCmdArg& arg6, const RooCmdArg& arg7, const RooCmdArg& arg8)
1484 {
1485  RooLinkedList l ;
1486  l.Add((TObject*)&arg1) ; l.Add((TObject*)&arg2) ;
1487  l.Add((TObject*)&arg3) ; l.Add((TObject*)&arg4) ;
1488  l.Add((TObject*)&arg5) ; l.Add((TObject*)&arg6) ;
1489  l.Add((TObject*)&arg7) ; l.Add((TObject*)&arg8) ;
1490  return fitTo(data,l) ;
1491 }
1492 
1493 
1494 
1495 ////////////////////////////////////////////////////////////////////////////////
1496 /// Fit PDF to given dataset. If dataset is unbinned, an unbinned maximum likelihood is performed. If the dataset
1497 /// is binned, a binned maximum likelihood is performed. By default the fit is executed through the MINUIT
1498 /// commands MIGRAD, HESSE and MINOS in succession.
1499 ///
1500 /// See RooAbsPdf::fitTo(RooAbsData&,RooCmdArg&,RooCmdArg&,RooCmdArg&,RooCmdArg&,RooCmdArg&,RooCmdArg&,RooCmdArg&,RooCmdArg&)
1501 ///
1502 /// for documentation of options
1503 
1505 {
1506  // Select the pdf-specific commands
1507  RooCmdConfig pc(Form("RooAbsPdf::fitTo(%s)",GetName())) ;
1508 
1509  RooLinkedList fitCmdList(cmdList) ;
1510  RooLinkedList nllCmdList = pc.filterCmdList(fitCmdList,"ProjectedObservables,Extended,Range,"
1511  "RangeWithName,SumCoefRange,NumCPU,SplitRange,Constrained,Constrain,ExternalConstraints,"
1512  "CloneData,GlobalObservables,GlobalObservablesTag,OffsetLikelihood,BatchMode,IntegrateBins");
1513 
1514  pc.defineDouble("prefit", "Prefit",0,0);
1515  pc.defineDouble("RecoverFromUndefinedRegions", "RecoverFromUndefinedRegions",0,10.);
1516  pc.defineString("fitOpt","FitOptions",0,"") ;
1517  pc.defineInt("optConst","Optimize",0,2) ;
1518  pc.defineInt("verbose","Verbose",0,0) ;
1519  pc.defineInt("doSave","Save",0,0) ;
1520  pc.defineInt("doTimer","Timer",0,0) ;
1521  pc.defineInt("plevel","PrintLevel",0,1) ;
1522  pc.defineInt("strat","Strategy",0,1) ;
1523  pc.defineInt("initHesse","InitialHesse",0,0) ;
1524  pc.defineInt("hesse","Hesse",0,1) ;
1525  pc.defineInt("minos","Minos",0,0) ;
1526  pc.defineInt("ext","Extended",0,2) ;
1527  pc.defineInt("numcpu","NumCPU",0,1) ;
1528  pc.defineInt("numee","PrintEvalErrors",0,10) ;
1529  pc.defineInt("doEEWall","EvalErrorWall",0,1) ;
1530  pc.defineInt("doWarn","Warnings",0,1) ;
1531  pc.defineInt("doSumW2","SumW2Error",0,-1) ;
1532  pc.defineInt("doAsymptoticError","AsymptoticError",0,-1) ;
1533  pc.defineInt("doOffset","OffsetLikelihood",0,0) ;
1534  pc.defineString("mintype","Minimizer",0,"Minuit") ;
1535  pc.defineString("minalg","Minimizer",1,"minuit") ;
1536  pc.defineObject("minosSet","Minos",0,0) ;
1537  pc.defineSet("cPars","Constrain",0,0) ;
1538  pc.defineSet("extCons","ExternalConstraints",0,0) ;
1539  pc.defineMutex("FitOptions","Verbose") ;
1540  pc.defineMutex("FitOptions","Save") ;
1541  pc.defineMutex("FitOptions","Timer") ;
1542  pc.defineMutex("FitOptions","Strategy") ;
1543  pc.defineMutex("FitOptions","InitialHesse") ;
1544  pc.defineMutex("FitOptions","Hesse") ;
1545  pc.defineMutex("FitOptions","Minos") ;
1546  pc.defineMutex("Range","RangeWithName") ;
1547  pc.defineMutex("InitialHesse","Minimizer") ;
1548 
1549  // Process and check varargs
1550  pc.process(fitCmdList) ;
1551  if (!pc.ok(kTRUE)) {
1552  return 0 ;
1553  }
1554 
1555  // Decode command line arguments
1556  Double_t prefit = pc.getDouble("prefit");
1557  const double recoverFromNaN = pc.getDouble("RecoverFromUndefinedRegions");
1558  const char* fitOpt = pc.getString("fitOpt",0,kTRUE) ;
1559  Int_t optConst = pc.getInt("optConst") ;
1560  Int_t verbose = pc.getInt("verbose") ;
1561  Int_t doSave = pc.getInt("doSave") ;
1562  Int_t doTimer = pc.getInt("doTimer") ;
1563  Int_t plevel = pc.getInt("plevel") ;
1564  Int_t strat = pc.getInt("strat") ;
1565  Int_t initHesse= pc.getInt("initHesse") ;
1566  Int_t hesse = pc.getInt("hesse") ;
1567  Int_t minos = pc.getInt("minos") ;
1568  Int_t numee = pc.getInt("numee") ;
1569  Int_t doEEWall = pc.getInt("doEEWall") ;
1570  Int_t doWarn = pc.getInt("doWarn") ;
1571  Int_t doSumW2 = pc.getInt("doSumW2") ;
1572  Int_t doAsymptotic = pc.getInt("doAsymptoticError");
1573  const RooArgSet* minosSet = static_cast<RooArgSet*>(pc.getObject("minosSet")) ;
1574 #ifdef __ROOFIT_NOROOMINIMIZER
1575  const char* minType =0 ;
1576 #else
1577  const char* minType = pc.getString("mintype","Minuit") ;
1578  const char* minAlg = pc.getString("minalg","minuit") ;
1579 #endif
1580 
1581  if (optConst > 1) {
1582  // optConst >= 2 is pre-computating values, which are never used when
1583  // the batchMode is on. This just wastes time.
1584 
1585  RooCmdConfig conf(Form("RooAbsPdf::fitTo(%s)", GetName()));
1586  conf.defineInt("BatchMode","BatchMode",0,0);
1587  conf.allowUndefined(true);
1588  conf.process(nllCmdList);
1589  if (conf.getInt("BatchMode") != 0) {
1590  optConst = 1;
1591  }
1592  }
1593 
1594 
1595  // Determine if the dataset has weights
1596  Bool_t weightedData = data.isNonPoissonWeighted() ;
1597 
1598  // Warn user that a method to determine parameter uncertainties should be provided if weighted data is offered
1599  if (weightedData && doSumW2==-1 && doAsymptotic==-1) {
1600  coutW(InputArguments) << "RooAbsPdf::fitTo(" << GetName() << ") WARNING: a likelihood fit is requested of what appears to be weighted data.\n"
1601  << " While the estimated values of the parameters will always be calculated taking the weights into account,\n"
1602  << " there are multiple ways to estimate the errors of the parameters. You are advised to make an \n"
1603  << " explicit choice for the error calculation:\n"
1604  << " - Either provide SumW2Error(true), to calculate a sum-of-weights-corrected HESSE error matrix\n"
1605  << " (error will be proportional to the number of events in MC).\n"
1606  << " - Or provide SumW2Error(false), to return errors from original HESSE error matrix\n"
1607  << " (which will be proportional to the sum of the weights, i.e., a dataset with <sum of weights> events).\n"
1608  << " - Or provide AsymptoticError(true), to use the asymptotically correct expression\n"
1609  << " (for details see https://arxiv.org/abs/1911.01303)."
1610  << endl ;
1611  }
1612 
1613  if (minos && (doSumW2==1 || doAsymptotic == 1)) {
1614  coutE(InputArguments) << "RooAbsPdf::fitTo(" << GetName() << "): sum-of-weights and asymptotic error correction do not work with MINOS errors. Not fitting." << endl;
1615  return nullptr;
1616  }
1617  if (doAsymptotic==1 && minos) {
1618  coutW(InputArguments) << "RooAbsPdf::fitTo(" << GetName() << ") WARNING: asymptotic correction does not apply to MINOS errors" << endl ;
1619  }
1620 
1621  if (prefit != 0) {
1622  size_t nEvents = static_cast<size_t>(prefit*data.numEntries());
1623  if (prefit > 0.5 || nEvents < 100) {
1624  oocoutW(this,InputArguments) << "PrefitDataFraction should be in suitable range."
1625  << "With the current PrefitDataFraction=" << prefit
1626  << ", the number of events would be " << nEvents<< " out of "
1627  << data.numEntries() << ". Skipping prefit..." << endl;
1628  }
1629  else {
1630  size_t step = data.numEntries()/nEvents;
1631  RooArgSet tinyVars(*data.get());
1632  RooRealVar weight("weight","weight",1);
1633 
1634  if (data.isWeighted()) tinyVars.add(weight);
1635 
1636  RooDataSet tiny("tiny", "tiny", tinyVars,
1637  data.isWeighted() ? RooFit::WeightVar(weight) : RooCmdArg());
1638 
1639  for (int i=0; i<data.numEntries(); i+=step)
1640  {
1641  const RooArgSet *event = data.get(i);
1642  tiny.add(*event, data.weight());
1643  }
1644  RooLinkedList tinyCmdList(cmdList) ;
1645  pc.filterCmdList(tinyCmdList,"Prefit,Hesse,Minos,Verbose,Save,Timer");
1646  RooCmdArg hesse_option = RooFit::Hesse(false);
1647  RooCmdArg print_option = RooFit::PrintLevel(-1);
1648 
1649  tinyCmdList.Add(&hesse_option);
1650  tinyCmdList.Add(&print_option);
1651 
1652  fitTo(tiny,tinyCmdList);
1653  }
1654  }
1655 
1656  RooAbsReal* nll = createNLL(data,nllCmdList) ;
1657  RooFitResult *ret = 0 ;
1658 
1659  //avoid setting both SumW2 and Asymptotic for uncertainty correction
1660  if (doSumW2==1 && doAsymptotic==1) {
1661  coutE(InputArguments) << "RooAbsPdf::fitTo(" << GetName() << ") ERROR: Cannot compute both asymptotically correct and SumW2 errors." << endl ;
1662  return ret;
1663  }
1664 
1665  // Instantiate MINUIT
1666 
1667  if (string(minType)!="OldMinuit") {
1668 
1669 #ifndef __ROOFIT_NOROOMINIMIZER
1670  RooMinimizer m(*nll) ;
1671 
1672  m.setMinimizerType(minType) ;
1673 
1674  m.setEvalErrorWall(doEEWall) ;
1675  m.setRecoverFromNaNStrength(recoverFromNaN);
1676  if (doWarn==0) {
1677  // m.setNoWarn() ; WVE FIX THIS
1678  }
1679 
1680  m.setPrintEvalErrors(numee) ;
1681  if (plevel!=1) {
1682  m.setPrintLevel(plevel) ;
1683  }
1684 
1685  if (optConst) {
1686  // Activate constant term optimization
1687  m.optimizeConst(optConst) ;
1688  }
1689 
1690  if (fitOpt) {
1691 
1692  // Play fit options as historically defined
1693  ret = m.fit(fitOpt) ;
1694 
1695  } else {
1696 
1697  if (verbose) {
1698  // Activate verbose options
1699  m.setVerbose(1) ;
1700  }
1701  if (doTimer) {
1702  // Activate timer options
1703  m.setProfile(1) ;
1704  }
1705 
1706  if (strat!=1) {
1707  // Modify fit strategy
1708  m.setStrategy(strat) ;
1709  }
1710 
1711  if (initHesse) {
1712  // Initialize errors with hesse
1713  m.hesse() ;
1714  }
1715 
1716  // Minimize using chosen algorithm
1717  m.minimize(minType,minAlg) ;
1718 
1719  if (hesse) {
1720  // Evaluate errors with Hesse
1721  m.hesse() ;
1722  }
1723 
1724  int corrCovQual = -1;
1725 
1726  //asymptotically correct approach
1727  if (doAsymptotic==1 && m.getNPar()>0) {
1728  corrCovQual = calculateAsymptoticCorrectedCovMatrix(m, data);
1729  }
1730 
1731  if (doSumW2==1 && m.getNPar()>0) {
1732  corrCovQual = calculateSumW2CorrectedCovMatrix(m, *nll);
1733  }
1734 
1735  if (minos) {
1736  // Evaluate errs with Minos
1737  if (minosSet) {
1738  m.minos(*minosSet) ;
1739  } else {
1740  m.minos() ;
1741  }
1742  }
1743 
1744  // Optionally return fit result
1745  if (doSave) {
1746  string name = Form("fitresult_%s_%s",GetName(),data.GetName()) ;
1747  string title = Form("Result of fit of p.d.f. %s to dataset %s",GetName(),data.GetName()) ;
1748  ret = m.save(name.c_str(),title.c_str()) ;
1749  if((doSumW2==1 || doAsymptotic==1) && m.getNPar()>0) {
1750  ret->setCovQual(corrCovQual);
1751  }
1752  }
1753 
1754  }
1755 
1756  if (optConst) {
1757  m.optimizeConst(0) ;
1758  }
1759 
1760 #endif
1761 
1762  } else {
1763 
1764  RooMinuit m(*nll) ;
1765 
1766  m.setEvalErrorWall(doEEWall) ;
1767  if (doWarn==0) {
1768  m.setNoWarn() ;
1769  }
1770 
1771  m.setPrintEvalErrors(numee) ;
1772  if (plevel!=1) {
1773  m.setPrintLevel(plevel) ;
1774  }
1775 
1776  if (optConst) {
1777  // Activate constant term optimization
1778  m.optimizeConst(optConst) ;
1779  }
1780 
1781  if (fitOpt) {
1782 
1783  // Play fit options as historically defined
1784  ret = m.fit(fitOpt) ;
1785 
1786  } else {
1787 
1788  if (verbose) {
1789  // Activate verbose options
1790  m.setVerbose(1) ;
1791  }
1792  if (doTimer) {
1793  // Activate timer options
1794  m.setProfile(1) ;
1795  }
1796 
1797  if (strat!=1) {
1798  // Modify fit strategy
1799  m.setStrategy(strat) ;
1800  }
1801 
1802  if (initHesse) {
1803  // Initialize errors with hesse
1804  m.hesse() ;
1805  }
1806 
1807  // Minimize using migrad
1808  m.migrad() ;
1809 
1810  if (hesse) {
1811  // Evaluate errors with Hesse
1812  m.hesse() ;
1813  }
1814 
1815  int corrCovQual = -1;
1816 
1817  //asymptotically correct approach
1818  if (doAsymptotic==1 && m.getNPar()>0) {
1819  corrCovQual = calculateAsymptoticCorrectedCovMatrix(m, data);
1820  }
1821 
1822  if (doSumW2==1 && m.getNPar()>0) {
1823  corrCovQual = calculateSumW2CorrectedCovMatrix(m, *nll);
1824  }
1825 
1826  if (minos) {
1827  // Evaluate errs with Minos
1828  if (minosSet) {
1829  m.minos(*minosSet) ;
1830  } else {
1831  m.minos() ;
1832  }
1833  }
1834 
1835  // Optionally return fit result
1836  if (doSave) {
1837  string name = Form("fitresult_%s_%s",GetName(),data.GetName()) ;
1838  string title = Form("Result of fit of p.d.f. %s to dataset %s",GetName(),data.GetName()) ;
1839  ret = m.save(name.c_str(),title.c_str()) ;
1840  if((doSumW2==1 || doAsymptotic==1) && m.getNPar()>0) {
1841  ret->setCovQual(corrCovQual);
1842  }
1843  }
1844 
1845  }
1846 
1847  if (optConst) {
1848  m.optimizeConst(0) ;
1849  }
1850 
1851  }
1852 
1853 
1854 
1855  // Cleanup
1856  delete nll ;
1857  return ret ;
1858 }
1859 
1860 
1861 
1862 ////////////////////////////////////////////////////////////////////////////////
1863 /// Calls RooAbsPdf::createChi2(RooDataSet& data, const RooLinkedList& cmdList) and returns fit result.
1864 
1866 {
1867  // Select the pdf-specific commands
1868  RooCmdConfig pc(Form("RooAbsPdf::chi2FitTo(%s)",GetName())) ;
1869 
1870  // Pull arguments to be passed to chi2 construction from list
1871  RooLinkedList fitCmdList(cmdList) ;
1872  RooLinkedList chi2CmdList = pc.filterCmdList(fitCmdList,"Range,RangeWithName,NumCPU,Optimize,ProjectedObservables,AddCoefRange,SplitRange,DataError,Extended,IntegrateBins") ;
1873 
1874  RooAbsReal* chi2 = createChi2(data,chi2CmdList) ;
1875  RooFitResult* ret = chi2FitDriver(*chi2,fitCmdList) ;
1876 
1877  // Cleanup
1878  delete chi2 ;
1879  return ret ;
1880 }
1881 
1882 
1883 
1884 
1885 ////////////////////////////////////////////////////////////////////////////////
1886 /// Create a \f$ \chi^2 \f$ from a histogram and this function.
1887 ///
1888 /// Options to control construction of the \f$ \chi^2 \f$
1889 /// ------------------------------------------
1890 /// <table>
1891 /// <tr><th> Type of CmdArg <th> Effect on \f$ \chi^2 \f$
1892 /// <tr><td> `Extended()` <td> Use expected number of events of an extended p.d.f as normalization
1893 /// <tr><td> `DataError()` <td> Choose between:
1894 /// - Expected error [RooAbsData::Expected]
1895 /// - Observed error (e.g. Sum-of-weights) [RooAbsData::SumW2]
1896 /// - Poisson interval [RooAbsData::Poisson]
1897 /// - Default: Expected error for unweighted data, Sum-of-weights for weighted data [RooAbsData::Auto]
1898 /// <tr><td> `NumCPU()` <td> Activate parallel processing feature
1899 /// <tr><td> `Range()` <td> Fit only selected region
1900 /// <tr><td> `SumCoefRange()` <td> Set the range in which to interpret the coefficients of RooAddPdf components
1901 /// <tr><td> `SplitRange()` <td> Fit ranges used in different categories get named after the category.
1902 /// Using `Range("range"), SplitRange()` as switches, different ranges could be set like this:
1903 /// ```
1904 /// myVariable.setRange("range_pi0", 135, 210);
1905 /// myVariable.setRange("range_gamma", 50, 210);
1906 /// ```
1907 /// <tr><td> `ConditionalObservables()` <td> Define projected observables
1908 /// </table>
1909 
1911  const RooCmdArg& arg3, const RooCmdArg& arg4, const RooCmdArg& arg5,
1912  const RooCmdArg& arg6, const RooCmdArg& arg7, const RooCmdArg& arg8)
1913 {
1914  RooLinkedList cmdList ;
1915  cmdList.Add((TObject*)&arg1) ; cmdList.Add((TObject*)&arg2) ;
1916  cmdList.Add((TObject*)&arg3) ; cmdList.Add((TObject*)&arg4) ;
1917  cmdList.Add((TObject*)&arg5) ; cmdList.Add((TObject*)&arg6) ;
1918  cmdList.Add((TObject*)&arg7) ; cmdList.Add((TObject*)&arg8) ;
1919 
1920  RooCmdConfig pc(Form("RooAbsPdf::createChi2(%s)",GetName())) ;
1921  pc.defineString("rangeName","RangeWithName",0,"",kTRUE) ;
1922  pc.allowUndefined(kTRUE) ;
1923  pc.process(cmdList) ;
1924  if (!pc.ok(kTRUE)) {
1925  return 0 ;
1926  }
1927  const char* rangeName = pc.getString("rangeName",0,kTRUE) ;
1928 
1929  // Construct Chi2
1931  RooAbsReal* chi2 ;
1932  string baseName = Form("chi2_%s_%s",GetName(),data.GetName()) ;
1933 
1934  // Clear possible range attributes from previous fits.
1935  setStringAttribute("fitrange", nullptr);
1936 
1937  if (!rangeName || strchr(rangeName,',')==0) {
1938  // Simple case: default range, or single restricted range
1939 
1940  chi2 = new RooChi2Var(baseName.c_str(),baseName.c_str(),*this,data,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8) ;
1941 
1942  } else {
1943 
1944  // Find which argument is RangeWithName
1945  const RooCmdArg* rarg(0) ;
1946  string rcmd = "RangeWithName" ;
1947  if (arg1.GetName()==rcmd) rarg = &arg1 ;
1948  if (arg2.GetName()==rcmd) rarg = &arg2 ;
1949  if (arg3.GetName()==rcmd) rarg = &arg3 ;
1950  if (arg4.GetName()==rcmd) rarg = &arg4 ;
1951  if (arg5.GetName()==rcmd) rarg = &arg5 ;
1952  if (arg6.GetName()==rcmd) rarg = &arg6 ;
1953  if (arg7.GetName()==rcmd) rarg = &arg7 ;
1954  if (arg8.GetName()==rcmd) rarg = &arg8 ;
1955 
1956  // Composite case: multiple ranges
1957  RooArgList chi2List ;
1958  for (std::string& token : RooHelpers::tokenise(rangeName, ",")) {
1959  RooCmdArg subRangeCmd = RooFit::Range(token.c_str()) ;
1960  // Construct chi2 while substituting original RangeWithName argument with subrange argument created above
1961  RooAbsReal* chi2Comp = new RooChi2Var(Form("%s_%s", baseName.c_str(), token.c_str()), "chi^2", *this, data,
1962  &arg1==rarg?subRangeCmd:arg1,&arg2==rarg?subRangeCmd:arg2,
1963  &arg3==rarg?subRangeCmd:arg3,&arg4==rarg?subRangeCmd:arg4,
1964  &arg5==rarg?subRangeCmd:arg5,&arg6==rarg?subRangeCmd:arg6,
1965  &arg7==rarg?subRangeCmd:arg7,&arg8==rarg?subRangeCmd:arg8) ;
1966  chi2List.add(*chi2Comp) ;
1967  }
1968  chi2 = new RooAddition(baseName.c_str(),"chi^2",chi2List,kTRUE) ;
1969  }
1971 
1972 
1973  return chi2 ;
1974 }
1975 
1976 
1977 
1978 
1979 ////////////////////////////////////////////////////////////////////////////////
1980 /// Argument-list version of RooAbsPdf::createChi2()
1981 
1983 {
1984  // Select the pdf-specific commands
1985  RooCmdConfig pc(Form("RooAbsPdf::createChi2(%s)",GetName())) ;
1986 
1987  pc.defineInt("integrate","Integrate",0,0) ;
1988  pc.defineObject("yvar","YVar",0,0) ;
1989 
1990  // Process and check varargs
1991  pc.process(cmdList) ;
1992  if (!pc.ok(kTRUE)) {
1993  return 0 ;
1994  }
1995 
1996  // Decode command line arguments
1997  Bool_t integrate = pc.getInt("integrate") ;
1998  RooRealVar* yvar = (RooRealVar*) pc.getObject("yvar") ;
1999 
2000  string name = Form("chi2_%s_%s",GetName(),data.GetName()) ;
2001 
2002  if (yvar) {
2003  return new RooXYChi2Var(name.c_str(),name.c_str(),*this,data,*yvar,integrate) ;
2004  } else {
2005  return new RooXYChi2Var(name.c_str(),name.c_str(),*this,data,integrate) ;
2006  }
2007 }
2008 
2009 
2010 
2011 
2012 ////////////////////////////////////////////////////////////////////////////////
2013 /// Print value of p.d.f, also print normalization integral that was last used, if any
2014 
2015 void RooAbsPdf::printValue(ostream& os) const
2016 {
2017  // silent warning messages coming when evaluating a RooAddPdf without a normalization set
2019 
2020  getVal() ;
2021 
2022  if (_norm) {
2023  os << evaluate() << "/" << _norm->getVal() ;
2024  } else {
2025  os << evaluate() ;
2026  }
2027 }
2028 
2029 
2030 
2031 ////////////////////////////////////////////////////////////////////////////////
2032 /// Print multi line detailed information of this RooAbsPdf
2033 
2034 void RooAbsPdf::printMultiline(ostream& os, Int_t contents, Bool_t verbose, TString indent) const
2035 {
2037  os << indent << "--- RooAbsPdf ---" << endl;
2038  os << indent << "Cached value = " << _value << endl ;
2039  if (_norm) {
2040  os << indent << " Normalization integral: " << endl ;
2041  auto moreIndent = std::string(indent.Data()) + " " ;
2042  _norm->printStream(os,kName|kAddress|kTitle|kValue|kArgs,kSingleLine,moreIndent.c_str()) ;
2043  }
2044 }
2045 
2046 
2047 
2048 ////////////////////////////////////////////////////////////////////////////////
2049 /// Return a binned generator context
2050 
2052 {
2053  return new RooBinnedGenContext(*this,vars,0,0,verbose) ;
2054 }
2055 
2056 
2057 ////////////////////////////////////////////////////////////////////////////////
2058 /// Interface function to create a generator context from a p.d.f. This default
2059 /// implementation returns a 'standard' context that works for any p.d.f
2060 
2062  const RooArgSet* auxProto, Bool_t verbose) const
2063 {
2064  return new RooGenContext(*this,vars,prototype,auxProto,verbose) ;
2065 }
2066 
2067 
2068 ////////////////////////////////////////////////////////////////////////////////
2069 
2070 RooAbsGenContext* RooAbsPdf::autoGenContext(const RooArgSet &vars, const RooDataSet* prototype, const RooArgSet* auxProto,
2071  Bool_t verbose, Bool_t autoBinned, const char* binnedTag) const
2072 {
2073  if (prototype || (auxProto && auxProto->getSize()>0)) {
2074  return genContext(vars,prototype,auxProto,verbose);
2075  }
2076 
2077  RooAbsGenContext *context(0) ;
2078  if ( (autoBinned && isBinnedDistribution(vars)) || ( binnedTag && strlen(binnedTag) && (getAttribute(binnedTag)||string(binnedTag)=="*"))) {
2079  context = binnedGenContext(vars,verbose) ;
2080  } else {
2081  context= genContext(vars,0,0,verbose);
2082  }
2083  return context ;
2084 }
2085 
2086 
2087 
2088 ////////////////////////////////////////////////////////////////////////////////
2089 /// Generate a new dataset containing the specified variables with events sampled from our distribution.
2090 /// Generate the specified number of events or expectedEvents() if not specified.
2091 /// \param[in] whatVars Choose variables in which to generate events. Variables not listed here will remain
2092 /// constant and not be used for event generation.
2093 /// \param[in] argxx Optional RooCmdArg() to change behaviour of generate().
2094 /// \return RooDataSet *, owned by caller.
2095 ///
2096 /// Any variables of this PDF that are not in whatVars will use their
2097 /// current values and be treated as fixed parameters. Returns zero
2098 /// in case of an error.
2099 ///
2100 /// <table>
2101 /// <tr><th> Type of CmdArg <th> Effect on generate
2102 /// <tr><td> `Name(const char* name)` <td> Name of the output dataset
2103 /// <tr><td> `Verbose(Bool_t flag)` <td> Print informational messages during event generation
2104 /// <tr><td> `NumEvent(int nevt)` <td> Generate specified number of events
2105 /// <tr><td> `Extended()` <td> If no number of events to be generated is given,
2106 /// use expected number of events from extended likelihood term.
2107 /// This evidently only works for extended PDFs.
2108 /// <tr><td> `GenBinned(const char* tag)` <td> Use binned generation for all component pdfs that have 'setAttribute(tag)' set
2109 /// <tr><td> `AutoBinned(Bool_t flag)` <td> Automatically deploy binned generation for binned distributions (e.g. RooHistPdf, sums and products of
2110 /// RooHistPdfs etc)
2111 /// \note Datasets that are generated in binned mode are returned as weighted unbinned datasets. This means that
2112 /// for each bin, there will be one event in the dataset with a weight corresponding to the (possibly randomised) bin content.
2113 ///
2114 ///
2115 /// <tr><td> `AllBinned()` <td> As above, but for all components.
2116 /// \note The notion of components is only meaningful for simultaneous PDFs
2117 /// as binned generation is always executed at the top-level node for a regular
2118 /// PDF, so for those it only mattes that the top-level node is tagged.
2119 ///
2120 /// <tr><td> ProtoData(const RooDataSet& data, Bool_t randOrder)
2121 /// <td> Use specified dataset as prototype dataset. If randOrder in ProtoData() is set to true,
2122 /// the order of the events in the dataset will be read in a random order if the requested
2123 /// number of events to be generated does not match the number of events in the prototype dataset.
2124 /// \note If ProtoData() is used, the specified existing dataset as a prototype: the new dataset will contain
2125 /// the same number of events as the prototype (unless otherwise specified), and any prototype variables not in
2126 /// whatVars will be copied into the new dataset for each generated event and also used to set our PDF parameters.
2127 /// The user can specify a number of events to generate that will override the default. The result is a
2128 /// copy of the prototype dataset with only variables in whatVars randomized. Variables in whatVars that
2129 /// are not in the prototype will be added as new columns to the generated dataset.
2130 ///
2131 /// </table>
2132 ///
2133 /// #### Accessing the underlying event generator
2134 /// Depending on the fit model (if it is difficult to sample), it may be necessary to change generator settings.
2135 /// For the default generator (RooFoamGenerator), the number of samples or cells could be increased by e.g. using
2136 /// myPdf->specialGeneratorConfig()->getConfigSection("RooFoamGenerator").setRealValue("nSample",1e4);
2137 ///
2138 /// The foam generator e.g. has the following config options:
2139 /// - nCell[123N]D
2140 /// - nSample
2141 /// - chatLevel
2142 /// \see rf902_numgenconfig.C
2143 
2144 RooDataSet *RooAbsPdf::generate(const RooArgSet& whatVars, const RooCmdArg& arg1,const RooCmdArg& arg2,
2145  const RooCmdArg& arg3,const RooCmdArg& arg4, const RooCmdArg& arg5,const RooCmdArg& arg6)
2146 {
2147  // Select the pdf-specific commands
2148  RooCmdConfig pc(Form("RooAbsPdf::generate(%s)",GetName())) ;
2149  pc.defineObject("proto","PrototypeData",0,0) ;
2150  pc.defineString("dsetName","Name",0,"") ;
2151  pc.defineInt("randProto","PrototypeData",0,0) ;
2152  pc.defineInt("resampleProto","PrototypeData",1,0) ;
2153  pc.defineInt("verbose","Verbose",0,0) ;
2154  pc.defineInt("extended","Extended",0,0) ;
2155  pc.defineInt("nEvents","NumEvents",0,0) ;
2156  pc.defineInt("autoBinned","AutoBinned",0,1) ;
2157  pc.defineInt("expectedData","ExpectedData",0,0) ;
2158  pc.defineDouble("nEventsD","NumEventsD",0,-1.) ;
2159  pc.defineString("binnedTag","GenBinned",0,"") ;
2160  pc.defineMutex("GenBinned","ProtoData") ;
2161  pc.defineMutex("Extended", "NumEvents");
2162 
2163  // Process and check varargs
2164  pc.process(arg1,arg2,arg3,arg4,arg5,arg6) ;
2165  if (!pc.ok(kTRUE)) {
2166  return 0 ;
2167  }
2168 
2169  // Decode command line arguments
2170  RooDataSet* protoData = static_cast<RooDataSet*>(pc.getObject("proto",0)) ;
2171  const char* dsetName = pc.getString("dsetName") ;
2172  Bool_t verbose = pc.getInt("verbose") ;
2173  Bool_t randProto = pc.getInt("randProto") ;
2174  Bool_t resampleProto = pc.getInt("resampleProto") ;
2175  Bool_t extended = pc.getInt("extended") ;
2176  Bool_t autoBinned = pc.getInt("autoBinned") ;
2177  const char* binnedTag = pc.getString("binnedTag") ;
2178  Int_t nEventsI = pc.getInt("nEvents") ;
2179  Double_t nEventsD = pc.getInt("nEventsD") ;
2180  //Bool_t verbose = pc.getInt("verbose") ;
2181  Bool_t expectedData = pc.getInt("expectedData") ;
2182 
2183  Double_t nEvents = (nEventsD>0) ? nEventsD : Double_t(nEventsI);
2184 
2185  // Force binned mode for expected data mode
2186  if (expectedData) {
2187  binnedTag="*" ;
2188  }
2189 
2190  if (extended) {
2191  if (nEvents == 0) nEvents = expectedEvents(&whatVars);
2192  } else if (nEvents==0) {
2193  cxcoutI(Generation) << "No number of events specified , number of events generated is "
2194  << GetName() << "::expectedEvents() = " << expectedEvents(&whatVars)<< endl ;
2195  }
2196 
2197  if (extended && protoData && !randProto) {
2198  cxcoutI(Generation) << "WARNING Using generator option Extended() (Poisson distribution of #events) together "
2199  << "with a prototype dataset implies incomplete sampling or oversampling of proto data. "
2200  << "Set randomize flag in ProtoData() option to randomize prototype dataset order and thus "
2201  << "to randomize the set of over/undersampled prototype events for each generation cycle." << endl ;
2202  }
2203 
2204 
2205  // Forward to appropriate implementation
2206  RooDataSet* data ;
2207  if (protoData) {
2208  data = generate(whatVars,*protoData,Int_t(nEvents),verbose,randProto,resampleProto) ;
2209  } else {
2210  data = generate(whatVars,nEvents,verbose,autoBinned,binnedTag,expectedData, extended) ;
2211  }
2212 
2213  // Rename dataset to given name if supplied
2214  if (dsetName && strlen(dsetName)>0) {
2215  data->SetName(dsetName) ;
2216  }
2217 
2218  return data ;
2219 }
2220 
2221 
2222 
2223 
2224 
2225 
2226 ////////////////////////////////////////////////////////////////////////////////
2227 /// \note This method does not perform any generation. To generate according to generations specification call RooAbsPdf::generate(RooAbsPdf::GenSpec&) const
2228 ///
2229 /// Details copied from RooAbsPdf::generate():
2230 /// --------------------------------------------
2231 /// \copydetails RooAbsPdf::generate(const RooArgSet&,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&)
2232 
2234  const RooCmdArg& arg1,const RooCmdArg& arg2,
2235  const RooCmdArg& arg3,const RooCmdArg& arg4,
2236  const RooCmdArg& arg5,const RooCmdArg& arg6)
2237 {
2238 
2239  // Select the pdf-specific commands
2240  RooCmdConfig pc(Form("RooAbsPdf::generate(%s)",GetName())) ;
2241  pc.defineObject("proto","PrototypeData",0,0) ;
2242  pc.defineString("dsetName","Name",0,"") ;
2243  pc.defineInt("randProto","PrototypeData",0,0) ;
2244  pc.defineInt("resampleProto","PrototypeData",1,0) ;
2245  pc.defineInt("verbose","Verbose",0,0) ;
2246  pc.defineInt("extended","Extended",0,0) ;
2247  pc.defineInt("nEvents","NumEvents",0,0) ;
2248  pc.defineInt("autoBinned","AutoBinned",0,1) ;
2249  pc.defineString("binnedTag","GenBinned",0,"") ;
2250  pc.defineMutex("GenBinned","ProtoData") ;
2251 
2252 
2253  // Process and check varargs
2254  pc.process(arg1,arg2,arg3,arg4,arg5,arg6) ;
2255  if (!pc.ok(kTRUE)) {
2256  return 0 ;
2257  }
2258 
2259  // Decode command line arguments
2260  RooDataSet* protoData = static_cast<RooDataSet*>(pc.getObject("proto",0)) ;
2261  const char* dsetName = pc.getString("dsetName") ;
2262  Int_t nEvents = pc.getInt("nEvents") ;
2263  Bool_t verbose = pc.getInt("verbose") ;
2264  Bool_t randProto = pc.getInt("randProto") ;
2265  Bool_t resampleProto = pc.getInt("resampleProto") ;
2266  Bool_t extended = pc.getInt("extended") ;
2267  Bool_t autoBinned = pc.getInt("autoBinned") ;
2268  const char* binnedTag = pc.getString("binnedTag") ;
2269 
2270  RooAbsGenContext* cx = autoGenContext(whatVars,protoData,0,verbose,autoBinned,binnedTag) ;
2271 
2272  return new GenSpec(cx,whatVars,protoData,nEvents,extended,randProto,resampleProto,dsetName) ;
2273 }
2274 
2275 
2276 ////////////////////////////////////////////////////////////////////////////////
2277 /// If many identical generation requests
2278 /// are needed, e.g. in toy MC studies, it is more efficient to use the prepareMultiGen()/generate()
2279 /// combination than calling the standard generate() multiple times as
2280 /// initialization overhead is only incurred once.
2281 
2283 {
2284  //Int_t nEvt = spec._extended ? RooRandom::randomGenerator()->Poisson(spec._nGen) : spec._nGen ;
2285  //Int_t nEvt = spec._extended ? RooRandom::randomGenerator()->Poisson(spec._nGen==0?expectedEvents(spec._whatVars):spec._nGen) : spec._nGen ;
2286  //Int_t nEvt = spec._nGen == 0 ? RooRandom::randomGenerator()->Poisson(expectedEvents(spec._whatVars)) : spec._nGen;
2287 
2288  Double_t nEvt = spec._nGen == 0 ? expectedEvents(spec._whatVars) : spec._nGen;
2289 
2290  RooDataSet* ret = generate(*spec._genContext,spec._whatVars,spec._protoData, nEvt,kFALSE,spec._randProto,spec._resampleProto,
2291  spec._init,spec._extended) ;
2292  spec._init = kTRUE ;
2293  return ret ;
2294 }
2295 
2296 
2297 
2298 
2299 
2300 ////////////////////////////////////////////////////////////////////////////////
2301 /// Generate a new dataset containing the specified variables with
2302 /// events sampled from our distribution.
2303 ///
2304 /// \param[in] whatVars Generate a dataset with the variables (and categories) in this set.
2305 /// Any variables of this PDF that are not in `whatVars` will use their
2306 /// current values and be treated as fixed parameters.
2307 /// \param[in] nEvents Generate the specified number of events or else try to use
2308 /// expectedEvents() if nEvents <= 0 (default).
2309 /// \param[in] verbose Show which generator strategies are being used.
2310 /// \param[in] autoBinned If original distribution is binned, return bin centers and randomise weights
2311 /// instead of generating single events.
2312 /// \param[in] binnedTag
2313 /// \param[in] expectedData Call setExpectedData on the genContext.
2314 /// \param[in] extended Randomise number of events generated according to Poisson(nEvents). Only useful
2315 /// if PDF is extended.
2316 /// \return New dataset. Returns zero in case of an error. The caller takes ownership of the returned
2317 /// dataset.
2318 
2319 RooDataSet *RooAbsPdf::generate(const RooArgSet &whatVars, Double_t nEvents, Bool_t verbose, Bool_t autoBinned, const char* binnedTag, Bool_t expectedData, Bool_t extended) const
2320 {
2321  if (nEvents==0 && extendMode()==CanNotBeExtended) {
2322  return new RooDataSet("emptyData","emptyData",whatVars) ;
2323  }
2324 
2325  // Request for binned generation
2326  RooAbsGenContext *context = autoGenContext(whatVars,0,0,verbose,autoBinned,binnedTag) ;
2327  if (expectedData) {
2328  context->setExpectedData(kTRUE) ;
2329  }
2330 
2331  RooDataSet *generated = 0;
2332  if(0 != context && context->isValid()) {
2333  generated= context->generate(nEvents, kFALSE, extended);
2334  }
2335  else {
2336  coutE(Generation) << "RooAbsPdf::generate(" << GetName() << ") cannot create a valid context" << endl;
2337  }
2338  if(0 != context) delete context;
2339  return generated;
2340 }
2341 
2342 
2343 
2344 
2345 ////////////////////////////////////////////////////////////////////////////////
2346 /// Internal method
2347 
2348 RooDataSet *RooAbsPdf::generate(RooAbsGenContext& context, const RooArgSet &whatVars, const RooDataSet *prototype,
2349  Double_t nEvents, Bool_t /*verbose*/, Bool_t randProtoOrder, Bool_t resampleProto,
2350  Bool_t skipInit, Bool_t extended) const
2351 {
2352  if (nEvents==0 && (prototype==0 || prototype->numEntries()==0)) {
2353  return new RooDataSet("emptyData","emptyData",whatVars) ;
2354  }
2355 
2356  RooDataSet *generated = 0;
2357 
2358  // Resampling implies reshuffling in the implementation
2359  if (resampleProto) {
2360  randProtoOrder=kTRUE ;
2361  }
2362 
2363  if (randProtoOrder && prototype && prototype->numEntries()!=nEvents) {
2364  coutI(Generation) << "RooAbsPdf::generate (Re)randomizing event order in prototype dataset (Nevt=" << nEvents << ")" << endl ;
2365  Int_t* newOrder = randomizeProtoOrder(prototype->numEntries(),Int_t(nEvents),resampleProto) ;
2366  context.setProtoDataOrder(newOrder) ;
2367  delete[] newOrder ;
2368  }
2369 
2370  if(context.isValid()) {
2371  generated= context.generate(nEvents,skipInit,extended);
2372  }
2373  else {
2374  coutE(Generation) << "RooAbsPdf::generate(" << GetName() << ") do not have a valid generator context" << endl;
2375  }
2376  return generated;
2377 }
2378 
2379 
2380 
2381 
2382 ////////////////////////////////////////////////////////////////////////////////
2383 /// Generate a new dataset using a prototype dataset as a model,
2384 /// with values of the variables in `whatVars` sampled from our distribution.
2385 ///
2386 /// \param[in] whatVars Generate for these variables.
2387 /// \param[in] prototype Use this dataset
2388 /// as a prototype: the new dataset will contain the same number of
2389 /// events as the prototype (by default), and any prototype variables not in
2390 /// whatVars will be copied into the new dataset for each generated
2391 /// event and also used to set our PDF parameters. The user can specify a
2392 /// number of events to generate that will override the default. The result is a
2393 /// copy of the prototype dataset with only variables in whatVars
2394 /// randomized. Variables in whatVars that are not in the prototype
2395 /// will be added as new columns to the generated dataset.
2396 /// \param[in] nEvents Number of events to generate. Defaults to 0, which means number
2397 /// of event in prototype dataset.
2398 /// \param[in] verbose Show which generator strategies are being used.
2399 /// \param[in] randProtoOrder Randomise order of retrieval of events from proto dataset.
2400 /// \param[in] resampleProto Resample from the proto dataset.
2401 /// \return The new dataset. Returns zero in case of an error. The caller takes ownership of the
2402 /// returned dataset.
2403 
2404 RooDataSet *RooAbsPdf::generate(const RooArgSet &whatVars, const RooDataSet& prototype,
2405  Int_t nEvents, Bool_t verbose, Bool_t randProtoOrder, Bool_t resampleProto) const
2406 {
2407  RooAbsGenContext *context= genContext(whatVars,&prototype,0,verbose);
2408  if (context) {
2409  RooDataSet* data = generate(*context,whatVars,&prototype,nEvents,verbose,randProtoOrder,resampleProto) ;
2410  delete context ;
2411  return data ;
2412  } else {
2413  coutE(Generation) << "RooAbsPdf::generate(" << GetName() << ") ERROR creating generator context" << endl ;
2414  return 0 ;
2415  }
2416 }
2417 
2418 
2419 
2420 ////////////////////////////////////////////////////////////////////////////////
2421 /// Return lookup table with randomized access order for prototype events,
2422 /// given nProto prototype data events and nGen events that will actually
2423 /// be accessed
2424 
2426 {
2427  // Make unsorted linked list of indeces
2428  RooLinkedList l ;
2429  Int_t i ;
2430  for (i=0 ; i<nProto ; i++) {
2431  l.Add(new RooInt(i)) ;
2432  }
2433 
2434  // Make output list
2435  Int_t* lut = new Int_t[nProto] ;
2436 
2437  // Randomly samply input list into output list
2438  if (!resampleProto) {
2439  // In this mode, randomization is a strict reshuffle of the order
2440  for (i=0 ; i<nProto ; i++) {
2441  Int_t iran = RooRandom::integer(nProto-i) ;
2442  RooInt* sample = (RooInt*) l.At(iran) ;
2443  lut[i] = *sample ;
2444  l.Remove(sample) ;
2445  delete sample ;
2446  }
2447  } else {
2448  // In this mode, we resample, i.e. events can be used more than once
2449  for (i=0 ; i<nProto ; i++) {
2450  lut[i] = RooRandom::integer(nProto);
2451  }
2452  }
2453 
2454 
2455  return lut ;
2456 }
2457 
2458 
2459 
2460 ////////////////////////////////////////////////////////////////////////////////
2461 /// Load generatedVars with the subset of directVars that we can generate events for,
2462 /// and return a code that specifies the generator algorithm we will use. A code of
2463 /// zero indicates that we cannot generate any of the directVars (in this case, nothing
2464 /// should be added to generatedVars). Any non-zero codes will be passed to our generateEvent()
2465 /// implementation, but otherwise its value is arbitrary. The default implemetation of
2466 /// this method returns zero. Subclasses will usually implement this method using the
2467 /// matchArgs() methods to advertise the algorithms they provide.
2468 
2469 Int_t RooAbsPdf::getGenerator(const RooArgSet &/*directVars*/, RooArgSet &/*generatedVars*/, Bool_t /*staticInitOK*/) const
2470 {
2471  return 0 ;
2472 }
2473 
2474 
2475 
2476 ////////////////////////////////////////////////////////////////////////////////
2477 /// Interface for one-time initialization to setup the generator for the specified code.
2478 
2480 {
2481 }
2482 
2483 
2484 
2485 ////////////////////////////////////////////////////////////////////////////////
2486 /// Interface for generation of an event using the algorithm
2487 /// corresponding to the specified code. The meaning of each code is
2488 /// defined by the getGenerator() implementation. The default
2489 /// implementation does nothing.
2490 
2492 {
2493 }
2494 
2495 
2496 
2497 ////////////////////////////////////////////////////////////////////////////////
2498 /// Check if given observable can be safely generated using the
2499 /// pdfs internal generator mechanism (if that existsP). Observables
2500 /// on which a PDF depends via more than route are not safe
2501 /// for use with internal generators because they introduce
2502 /// correlations not known to the internal generator
2503 
2505 {
2506  // Arg must be direct server of self
2507  if (!findServer(arg.GetName())) return kFALSE ;
2508 
2509  // There must be no other dependency routes
2510  for (const auto server : _serverList) {
2511  if(server == &arg) continue;
2512  if(server->dependsOn(arg)) {
2513  return kFALSE ;
2514  }
2515  }
2516 
2517  return kTRUE ;
2518 }
2519 
2520 
2521 ////////////////////////////////////////////////////////////////////////////////
2522 /// Generate a new dataset containing the specified variables with events sampled from our distribution.
2523 /// \param[in] whatVars Choose variables in which to generate events. Variables not listed here will remain
2524 /// constant and not be used for event generation
2525 /// \param[in] arg1 Optional RooCmdArg to change behaviour of generateBinned()
2526 /// \return RooDataHist *, to be managed by caller.
2527 ///
2528 /// Generate the specified number of events or expectedEvents() if not specified.
2529 ///
2530 /// Any variables of this PDF that are not in whatVars will use their
2531 /// current values and be treated as fixed parameters. Returns zero
2532 /// in case of an error. The caller takes ownership of the returned
2533 /// dataset.
2534 ///
2535 /// The following named arguments are supported
2536 /// | Type of CmdArg | Effect on generation
2537 /// |-------------------------|-----------------------
2538 /// | `Name(const char* name)` | Name of the output dataset
2539 /// | `Verbose(Bool_t flag)` | Print informational messages during event generation
2540 /// | `NumEvent(int nevt)` | Generate specified number of events
2541 /// | `Extended()` | The actual number of events generated will be sampled from a Poisson distribution with mu=nevt.
2542 /// This can be *much* faster for peaked PDFs, but the number of events is not exactly what was requested.
2543 /// | `ExpectedData()` | Return a binned dataset _without_ statistical fluctuations (also aliased as Asimov())
2544 ///
2545 
2546 RooDataHist *RooAbsPdf::generateBinned(const RooArgSet& whatVars, const RooCmdArg& arg1,const RooCmdArg& arg2,
2547  const RooCmdArg& arg3,const RooCmdArg& arg4, const RooCmdArg& arg5,const RooCmdArg& arg6) const
2548 {
2549 
2550  // Select the pdf-specific commands
2551  RooCmdConfig pc(Form("RooAbsPdf::generate(%s)",GetName())) ;
2552  pc.defineString("dsetName","Name",0,"") ;
2553  pc.defineInt("verbose","Verbose",0,0) ;
2554  pc.defineInt("extended","Extended",0,0) ;
2555  pc.defineInt("nEvents","NumEvents",0,0) ;
2556  pc.defineDouble("nEventsD","NumEventsD",0,-1.) ;
2557  pc.defineInt("expectedData","ExpectedData",0,0) ;
2558 
2559  // Process and check varargs
2560  pc.process(arg1,arg2,arg3,arg4,arg5,arg6) ;
2561  if (!pc.ok(kTRUE)) {
2562  return 0 ;
2563  }
2564 
2565  // Decode command line arguments
2566  Double_t nEvents = pc.getDouble("nEventsD") ;
2567  if (nEvents<0) {
2568  nEvents = pc.getInt("nEvents") ;
2569  }
2570  //Bool_t verbose = pc.getInt("verbose") ;
2571  Bool_t extended = pc.getInt("extended") ;
2572  Bool_t expectedData = pc.getInt("expectedData") ;
2573  const char* dsetName = pc.getString("dsetName") ;
2574 
2575  if (extended) {
2576  //nEvents = (nEvents==0?Int_t(expectedEvents(&whatVars)+0.5):nEvents) ;
2577  nEvents = (nEvents==0 ? expectedEvents(&whatVars) :nEvents) ;
2578  cxcoutI(Generation) << " Extended mode active, number of events generated (" << nEvents << ") is Poisson fluctuation on "
2579  << GetName() << "::expectedEvents() = " << nEvents << endl ;
2580  // If Poisson fluctuation results in zero events, stop here
2581  if (nEvents==0) {
2582  return 0 ;
2583  }
2584  } else if (nEvents==0) {
2585  cxcoutI(Generation) << "No number of events specified , number of events generated is "
2586  << GetName() << "::expectedEvents() = " << expectedEvents(&whatVars)<< endl ;
2587  }
2588 
2589  // Forward to appropriate implementation
2590  RooDataHist* data = generateBinned(whatVars,nEvents,expectedData,extended) ;
2591 
2592  // Rename dataset to given name if supplied
2593  if (dsetName && strlen(dsetName)>0) {
2594  data->SetName(dsetName) ;
2595  }
2596 
2597  return data ;
2598 }
2599 
2600 
2601 
2602 
2603 ////////////////////////////////////////////////////////////////////////////////
2604 /// Generate a new dataset containing the specified variables with
2605 /// events sampled from our distribution.
2606 ///
2607 /// \param[in] whatVars Variables that values should be generated for.
2608 /// \param[in] nEvents How many events to generate. If `nEvents <=0`, use the value returned by expectedEvents() as target.
2609 /// \param[in] expectedData If set to true (false by default), the returned histogram returns the 'expected'
2610 /// data sample, i.e. no statistical fluctuations are present.
2611 /// \param[in] extended For each bin, generate Poisson(x, mu) events, where `mu` is chosen such that *on average*,
2612 /// one would obtain `nEvents` events. This means that the true number of events will fluctuate around the desired value,
2613 /// but the generation happens a lot faster.
2614 /// Especially if the PDF is sharply peaked, the multinomial event generation necessary to generate *exactly* `nEvents` events can
2615 /// be very slow.
2616 ///
2617 /// The binning used for generation of events is the currently set binning for the variables.
2618 /// It can e.g. be changed using
2619 /// ```
2620 /// x.setBins(15);
2621 /// x.setRange(-5., 5.);
2622 /// pdf.generateBinned(RooArgSet(x), 1000);
2623 /// ```
2624 ///
2625 /// Any variables of this PDF that are not in `whatVars` will use their
2626 /// current values and be treated as fixed parameters.
2627 /// \return RooDataHist* owned by the caller. Returns `nullptr` in case of an error.
2628 RooDataHist *RooAbsPdf::generateBinned(const RooArgSet &whatVars, Double_t nEvents, Bool_t expectedData, Bool_t extended) const
2629 {
2630  // Create empty RooDataHist
2631  RooDataHist* hist = new RooDataHist("genData","genData",whatVars) ;
2632 
2633  // Scale to number of events and introduce Poisson fluctuations
2634  if (nEvents<=0) {
2635  if (!canBeExtended()) {
2636  coutE(InputArguments) << "RooAbsPdf::generateBinned(" << GetName() << ") ERROR: No event count provided and p.d.f does not provide expected number of events" << endl ;
2637  delete hist ;
2638  return 0 ;
2639  } else {
2640 
2641  // Don't round in expectedData or extended mode
2642  if (expectedData || extended) {
2643  nEvents = expectedEvents(&whatVars) ;
2644  } else {
2645  nEvents = std::round(expectedEvents(&whatVars));
2646  }
2647  }
2648  }
2649 
2650  // Sample p.d.f. distribution
2651  fillDataHist(hist,&whatVars,1,kTRUE) ;
2652 
2653  vector<int> histOut(hist->numEntries()) ;
2654  Double_t histMax(-1) ;
2655  Int_t histOutSum(0) ;
2656  for (int i=0 ; i<hist->numEntries() ; i++) {
2657  hist->get(i) ;
2658  if (expectedData) {
2659 
2660  // Expected data, multiply p.d.f by nEvents
2661  Double_t w=hist->weight()*nEvents ;
2662  hist->set(i, w, sqrt(w));
2663 
2664  } else if (extended) {
2665 
2666  // Extended mode, set contents to Poisson(pdf*nEvents)
2667  Double_t w = RooRandom::randomGenerator()->Poisson(hist->weight()*nEvents) ;
2668  hist->set(w,sqrt(w)) ;
2669 
2670  } else {
2671 
2672  // Regular mode, fill array of weights with Poisson(pdf*nEvents), but to not fill
2673  // histogram yet.
2674  if (hist->weight()>histMax) {
2675  histMax = hist->weight() ;
2676  }
2677  histOut[i] = RooRandom::randomGenerator()->Poisson(hist->weight()*nEvents) ;
2678  histOutSum += histOut[i] ;
2679  }
2680  }
2681 
2682 
2683  if (!expectedData && !extended) {
2684 
2685  // Second pass for regular mode - Trim/Extend dataset to exact number of entries
2686 
2687  // Calculate difference between what is generated so far and what is requested
2688  Int_t nEvtExtra = abs(Int_t(nEvents)-histOutSum) ;
2689  Int_t wgt = (histOutSum>nEvents) ? -1 : 1 ;
2690 
2691  // Perform simple binned accept/reject procedure to get to exact event count
2692  std::size_t counter = 0;
2693  bool havePrintedInfo = false;
2694  while(nEvtExtra>0) {
2695 
2696  Int_t ibinRand = RooRandom::randomGenerator()->Integer(hist->numEntries()) ;
2697  hist->get(ibinRand) ;
2698  Double_t ranY = RooRandom::randomGenerator()->Uniform(histMax) ;
2699 
2700  if (ranY<hist->weight()) {
2701  if (wgt==1) {
2702  histOut[ibinRand]++ ;
2703  } else {
2704  // If weight is negative, prior bin content must be at least 1
2705  if (histOut[ibinRand]>0) {
2706  histOut[ibinRand]-- ;
2707  } else {
2708  continue ;
2709  }
2710  }
2711  nEvtExtra-- ;
2712  }
2713 
2714  if ((counter++ > 10*nEvents || nEvents > 1.E7) && !havePrintedInfo) {
2715  havePrintedInfo = true;
2716  coutP(Generation) << "RooAbsPdf::generateBinned(" << GetName() << ") Performing costly accept/reject sampling. If this takes too long, use "
2717  << "extended mode to speed up the process." << std::endl;
2718  }
2719  }
2720 
2721  // Transfer working array to histogram
2722  for (int i=0 ; i<hist->numEntries() ; i++) {
2723  hist->get(i) ;
2724  hist->set(histOut[i],sqrt(1.0*histOut[i])) ;
2725  }
2726 
2727  } else if (expectedData) {
2728 
2729  // Second pass for expectedData mode -- Normalize to exact number of requested events
2730  // Minor difference may be present in first round due to difference between
2731  // bin average and bin integral in sampling bins
2732  Double_t corr = nEvents/hist->sumEntries() ;
2733  for (int i=0 ; i<hist->numEntries() ; i++) {
2734  hist->get(i) ;
2735  hist->set(hist->weight()*corr,sqrt(hist->weight()*corr)) ;
2736  }
2737 
2738  }
2739 
2740  return hist;
2741 }
2742 
2743 
2744 
2745 ////////////////////////////////////////////////////////////////////////////////
2746 /// Special generator interface for generation of 'global observables' -- for RooStats tools
2747 
2749 {
2750  return generate(whatVars,nEvents) ;
2751 }
2752 
2753 namespace {
2754 void removeRangeOverlap(std::vector<std::pair<double, double>>& ranges) {
2755  //Sort from left to right
2756  std::sort(ranges.begin(), ranges.end());
2757 
2758  for (auto it = ranges.begin(); it != ranges.end(); ++it) {
2759  double& startL = it->first;
2760  double& endL = it->second;
2761 
2762  for (auto innerIt = it+1; innerIt != ranges.end(); ++innerIt) {
2763  const double startR = innerIt->first;
2764  const double endR = innerIt->second;
2765 
2766  if (startL <= startR && startR <= endL) {
2767  //Overlapping ranges, extend left one
2768  endL = std::max(endL, endR);
2769  *innerIt = make_pair(0., 0.);
2770  }
2771  }
2772  }
2773 
2774  auto newEnd = std::remove_if(ranges.begin(), ranges.end(),
2775  [](const std::pair<double,double>& input){
2776  return input.first == input.second;
2777  });
2778  ranges.erase(newEnd, ranges.end());
2779 }
2780 }
2781 
2782 
2783 ////////////////////////////////////////////////////////////////////////////////
2784 /// Plot (project) PDF on specified frame.
2785 /// - If a PDF is plotted in an empty frame, it
2786 /// will show a unit-normalized curve in the frame variable. When projecting a multi-
2787 /// dimensional PDF onto the frame axis, hidden parameters are taken are taken at
2788 /// their current value.
2789 /// - If a PDF is plotted in a frame in which a dataset has already been plotted, it will
2790 /// show a projection integrated over all variables that were present in the shown
2791 /// dataset (except for the one on the x-axis). The normalization of the curve will
2792 /// be adjusted to the event count of the plotted dataset. An informational message
2793 /// will be printed for each projection step that is performed.
2794 /// - If a PDF is plotted in a frame showing a dataset *after* a fit, the above happens,
2795 /// but the PDF will be drawn and normalised only in the fit range. If this is not desired,
2796 /// plotting and normalisation range can be overridden using Range() and NormRange() as
2797 /// documented in the table below.
2798 ///
2799 /// This function takes the following named arguments (for more arguments, see also
2800 /// RooAbsReal::plotOn(RooPlot*,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,
2801 /// const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,
2802 /// const RooCmdArg&) const )
2803 ///
2804 ///
2805 /// <table>
2806 /// <tr><th> Type of argument <th> Controlling normalisation
2807 /// <tr><td> `NormRange(const char* name)` <td> Calculate curve normalization w.r.t. specified range[s].
2808 /// See the tutorial rf212_plottingInRanges_blinding.C
2809 /// \note Setting a Range() by default also sets a NormRange() on the same range, meaning that the
2810 /// PDF is plotted and normalised in the same range. Overriding this can be useful if the PDF was fit
2811 /// in limited range[s] such as side bands, `NormRange("sidebandLeft,sidebandRight")`, but the PDF
2812 /// should be drawn in the full range, `Range("")`.
2813 ///
2814 /// <tr><td> `Normalization(Double_t scale, ScaleType code)` <td> Adjust normalization by given scale factor.
2815 /// Interpretation of number depends on code:
2816 /// `RooAbsReal::Relative`: relative adjustment factor
2817 /// `RooAbsReal::NumEvent`: scale to match given number of events.
2818 ///
2819 /// <tr><th> Type of argument <th> Misc control
2820 /// <tr><td> `Name(const chat* name)` <td> Give curve specified name in frame. Useful if curve is to be referenced later
2821 /// <tr><td> `Asymmetry(const RooCategory& c)` <td> Show the asymmetry of the PDF in given two-state category
2822 /// \f$ \frac{F(+)-F(-)}{F(+)+F(-)} \f$ rather than the PDF projection. Category must have two
2823 /// states with indices -1 and +1 or three states with indeces -1,0 and +1.
2824 /// <tr><td> `ShiftToZero(Bool_t flag)` <td> Shift entire curve such that lowest visible point is at exactly zero.
2825 /// Mostly useful when plotting -log(L) or \f$ \chi^2 \f$ distributions
2826 /// <tr><td> `AddTo(const char* name, double_t wgtSelf, double_t wgtOther)` <td> Create a projection of this PDF onto the x-axis, but
2827 /// instead of plotting it directly, add it to an existing curve with given name (and relative weight factors).
2828 /// <tr><td> `Components(const char* names)` <td> When plotting sums of PDFs, plot only the named components (*e.g.* only
2829 /// the signal of a signal+background model).
2830 /// <tr><td> `Components(const RooArgSet& compSet)` <td> As above, but pass a RooArgSet of the components themselves.
2831 ///
2832 /// <tr><th> Type of argument <th> Projection control
2833 /// <tr><td> `Slice(const RooArgSet& set)` <td> Override default projection behaviour by omitting observables listed
2834 /// in set from the projection, i.e. by not integrating over these.
2835 /// Slicing is usually only sensible in discrete observables, by e.g. creating a slice
2836 /// of the PDF at the current value of the category observable.
2837 /// <tr><td> `Slice(RooCategory& cat, const char* label)` <td> Override default projection behaviour by omitting the specified category
2838 /// observable from the projection, i.e., by not integrating over all states of this category.
2839 /// The slice is positioned at the given label value. Multiple Slice() commands can be given to specify slices
2840 /// in multiple observables, e.g.
2841 /// ```{.cpp}
2842 /// pdf.plotOn(frame, Slice(tagCategory, "2tag"), Slice(jetCategory, "3jet"));
2843 /// ```
2844 /// <tr><td> `Project(const RooArgSet& set)` <td> Override default projection behaviour by projecting
2845 /// over observables given in set, completely ignoring the default projection behavior. Advanced use only.
2846 /// <tr><td> `ProjWData(const RooAbsData& d)` <td> Override default projection _technique_ (integration). For observables
2847 /// present in given dataset projection of PDF is achieved by constructing an average over all observable
2848 /// values in given set. Consult RooFit plotting tutorial for further explanation of meaning & use of this technique
2849 /// <tr><td> `ProjWData(const RooArgSet& s, const RooAbsData& d)` <td> As above but only consider subset 's' of
2850 /// observables in dataset 'd' for projection through data averaging
2851 /// <tr><td> `ProjectionRange(const char* rn)` <td> When projecting the PDF onto the plot axis, it is usually integrated
2852 /// over the full range of the invisible variables. The ProjectionRange overrides this.
2853 /// This is useful if the PDF was fitted in a limited range in y, but it is now projected onto x. If
2854 /// `ProjectionRange("<name of fit range>")` is passed, the projection is normalised correctly.
2855 ///
2856 /// <tr><th> Type of argument <th> Plotting control
2857 /// <tr><td> `LineStyle(Int_t style)` <td> Select line style by ROOT line style code, default is solid
2858 /// <tr><td> `LineColor(Int_t color)` <td> Select line color by ROOT color code, default is blue
2859 /// <tr><td> `LineWidth(Int_t width)` <td> Select line with in pixels, default is 3
2860 /// <tr><td> `FillStyle(Int_t style)` <td> Select fill style, default is not filled. If a filled style is selected,
2861 /// also use VLines() to add vertical downward lines at end of curve to ensure proper closure
2862 /// <tr><td> `FillColor(Int_t color)` <td> Select fill color by ROOT color code
2863 /// <tr><td> `Range(const char* name)` <td> Only draw curve in range defined by given name. Multiple comma-separated ranges can be given.
2864 /// An empty string "" or `nullptr` means to use the default range of the variable.
2865 /// <tr><td> `Range(double lo, double hi)` <td> Only draw curve in specified range
2866 /// <tr><td> `VLines()` <td> Add vertical lines to y=0 at end points of curve
2867 /// <tr><td> `Precision(Double_t eps)` <td> Control precision of drawn curve w.r.t to scale of plot, default is 1e-3. A higher precision will
2868 /// result in more and more densely spaced curve points. A negative precision value will disable
2869 /// adaptive point spacing and restrict sampling to the grid point of points defined by the binning
2870 /// of the plotted observable (recommended for expensive functions such as profile likelihoods)
2871 /// <tr><td> `Invisible(Bool_t flag)` <td> Add curve to frame, but do not display. Useful in combination AddTo()
2872 /// <tr><td> `VisualizeError(const RooFitResult& fitres, Double_t Z=1, Bool_t linearMethod=kTRUE)`
2873 /// <td> Visualize the uncertainty on the parameters, as given in fitres, at 'Z' sigma.
2874 ///
2875 /// <tr><td> `VisualizeError(const RooFitResult& fitres, const RooArgSet& param, Double_t Z=1, Bool_t linearMethod=kTRUE)`
2876 /// <td> Visualize the uncertainty on the subset of parameters 'param', as given in fitres, at 'Z' sigma.
2877 /// </table>
2878 
2880 {
2881 
2882  // Pre-processing if p.d.f. contains a fit range and there is no command specifying one,
2883  // add a fit range as default range
2884  RooCmdArg* plotRange(0) ;
2885  RooCmdArg* normRange2(0);
2886  if (getStringAttribute("fitrange") && !cmdList.FindObject("Range") &&
2887  !cmdList.FindObject("RangeWithName")) {
2888  plotRange = (RooCmdArg*) RooFit::Range(getStringAttribute("fitrange")).Clone() ;
2889  cmdList.Add(plotRange) ;
2890  }
2891 
2892  if (getStringAttribute("fitrange") && !cmdList.FindObject("NormRange")) {
2893  normRange2 = (RooCmdArg*) RooFit::NormRange(getStringAttribute("fitrange")).Clone() ;
2894  cmdList.Add(normRange2) ;
2895  }
2896 
2897  if (plotRange || normRange2) {
2898  coutI(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") p.d.f was fitted in a subrange and no explicit "
2899  << (plotRange?"Range()":"") << ((plotRange&&normRange2)?" and ":"")
2900  << (normRange2?"NormRange()":"") << " was specified. Plotting / normalising in fit range. To override, do one of the following"
2901  << "\n\t- Clear the automatic fit range attribute: <pdf>.setStringAttribute(\"fitrange\", nullptr);"
2902  << "\n\t- Explicitly specify the plotting range: Range(\"<rangeName>\")."
2903  << "\n\t- Explicitly specify where to compute the normalisation: NormRange(\"<rangeName>\")."
2904  << "\n\tThe default (full) range can be denoted with Range(\"\") / NormRange(\"\")."<< endl ;
2905  }
2906 
2907  // Sanity checks
2908  if (plotSanityChecks(frame)) return frame ;
2909 
2910  // Select the pdf-specific commands
2911  RooCmdConfig pc(Form("RooAbsPdf::plotOn(%s)",GetName())) ;
2912  pc.defineDouble("scaleFactor","Normalization",0,1.0) ;
2913  pc.defineInt("scaleType","Normalization",0,Relative) ;
2914  pc.defineObject("compSet","SelectCompSet",0) ;
2915  pc.defineString("compSpec","SelectCompSpec",0) ;
2916  pc.defineObject("asymCat","Asymmetry",0) ;
2917  pc.defineDouble("rangeLo","Range",0,-999.) ;
2918  pc.defineDouble("rangeHi","Range",1,-999.) ;
2919  pc.defineString("rangeName","RangeWithName",0,"") ;
2920  pc.defineString("normRangeName","NormRange",0,"") ;
2921  pc.defineInt("rangeAdjustNorm","Range",0,0) ;
2922  pc.defineInt("rangeWNAdjustNorm","RangeWithName",0,0) ;
2923  pc.defineMutex("SelectCompSet","SelectCompSpec") ;
2924  pc.defineMutex("Range","RangeWithName") ;
2925  pc.allowUndefined() ; // unknowns may be handled by RooAbsReal
2926 
2927  // Process and check varargs
2928  pc.process(cmdList) ;
2929  if (!pc.ok(kTRUE)) {
2930  return frame ;
2931  }
2932 
2933  // Decode command line arguments
2934  ScaleType stype = (ScaleType) pc.getInt("scaleType") ;
2935  Double_t scaleFactor = pc.getDouble("scaleFactor") ;
2936  const RooAbsCategoryLValue* asymCat = (const RooAbsCategoryLValue*) pc.getObject("asymCat") ;
2937  const char* compSpec = pc.getString("compSpec") ;
2938  const RooArgSet* compSet = (const RooArgSet*) pc.getObject("compSet") ;
2939  Bool_t haveCompSel = ( (compSpec && strlen(compSpec)>0) || compSet) ;
2940 
2941  // Suffix for curve name
2942  std::string nameSuffix ;
2943  if (compSpec && strlen(compSpec)>0) {
2944  nameSuffix.append("_Comp[") ;
2945  nameSuffix.append(compSpec) ;
2946  nameSuffix.append("]") ;
2947  } else if (compSet) {
2948  nameSuffix.append("_Comp[") ;
2949  nameSuffix.append(compSet->contentsString().c_str()) ;
2950  nameSuffix.append("]") ;
2951  }
2952 
2953  // Remove PDF-only commands from command list
2954  pc.stripCmdList(cmdList,"SelectCompSet,SelectCompSpec") ;
2955 
2956  // Adjust normalization, if so requested
2957  if (asymCat) {
2958  RooCmdArg cnsuffix("CurveNameSuffix",0,0,0,0,nameSuffix.c_str(),0,0,0) ;
2959  cmdList.Add(&cnsuffix);
2960  return RooAbsReal::plotOn(frame,cmdList) ;
2961  }
2962 
2963  // More sanity checks
2964  Double_t nExpected(1) ;
2965  if (stype==RelativeExpected) {
2966  if (!canBeExtended()) {
2967  coutE(Plotting) << "RooAbsPdf::plotOn(" << GetName()
2968  << "): ERROR the 'Expected' scale option can only be used on extendable PDFs" << endl ;
2969  return frame ;
2970  }
2971  nExpected = expectedEvents(frame->getNormVars()) ;
2972  }
2973 
2974  if (stype != Raw) {
2975 
2976  if (frame->getFitRangeNEvt() && stype==Relative) {
2977 
2978  Bool_t hasCustomRange(kFALSE), adjustNorm(kFALSE) ;
2979 
2980  std::vector<pair<Double_t,Double_t> > rangeLim;
2981 
2982  // Retrieve plot range to be able to adjust normalization to data
2983  if (pc.hasProcessed("Range")) {
2984 
2985  Double_t rangeLo = pc.getDouble("rangeLo") ;
2986  Double_t rangeHi = pc.getDouble("rangeHi") ;
2987  rangeLim.push_back(make_pair(rangeLo,rangeHi)) ;
2988  adjustNorm = pc.getInt("rangeAdjustNorm") ;
2989  hasCustomRange = kTRUE ;
2990 
2991  coutI(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") only plotting range ["
2992  << rangeLo << "," << rangeHi << "]" ;
2993  if (!pc.hasProcessed("NormRange")) {
2994  ccoutI(Plotting) << ", curve is normalized to data in " << (adjustNorm?"given":"full") << " range" << endl ;
2995  } else {
2996  ccoutI(Plotting) << endl ;
2997  }
2998 
2999  nameSuffix.append(Form("_Range[%f_%f]",rangeLo,rangeHi)) ;
3000 
3001  } else if (pc.hasProcessed("RangeWithName")) {
3002 
3003  for (const std::string& rangeNameToken : RooHelpers::tokenise(pc.getString("rangeName", "", false), ",", /*returnEmptyToken=*/true)) {
3004  const char* thisRangeName = rangeNameToken.empty() ? nullptr : rangeNameToken.c_str();
3005  if (thisRangeName && !frame->getPlotVar()->hasRange(thisRangeName)) {
3006  coutE(Plotting) << "Range '" << rangeNameToken << "' not defined for variable '"
3007  << frame->getPlotVar()->GetName() << "'. Ignoring ..." << std::endl;
3008  continue;
3009  }
3010  rangeLim.push_back(frame->getPlotVar()->getRange(thisRangeName));
3011  }
3012  adjustNorm = pc.getInt("rangeWNAdjustNorm") ;
3013  hasCustomRange = kTRUE ;
3014 
3015  coutI(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") only plotting range '" << pc.getString("rangeName", "", false) << "'" ;
3016  if (!pc.hasProcessed("NormRange")) {
3017  ccoutI(Plotting) << ", curve is normalized to data in " << (adjustNorm?"given":"full") << " range" << endl ;
3018  } else {
3019  ccoutI(Plotting) << endl ;
3020  }
3021 
3022  nameSuffix.append(Form("_Range[%s]",pc.getString("rangeName"))) ;
3023  }
3024  // Specification of a normalization range override those in a regular range
3025  if (pc.hasProcessed("NormRange")) {
3026  rangeLim.clear();
3027  for (const auto& rangeNameToken : RooHelpers::tokenise(pc.getString("normRangeName", "", false), ",", /*returnEmptyToken=*/true)) {
3028  const char* thisRangeName = rangeNameToken.empty() ? nullptr : rangeNameToken.c_str();
3029  if (thisRangeName && !frame->getPlotVar()->hasRange(thisRangeName)) {
3030  coutE(Plotting) << "Range '" << rangeNameToken << "' not defined for variable '"
3031  << frame->getPlotVar()->GetName() << "'. Ignoring ..." << std::endl;
3032  continue;
3033  }
3034  rangeLim.push_back(frame->getPlotVar()->getRange(thisRangeName));
3035  }
3036  adjustNorm = kTRUE ;
3037  hasCustomRange = kTRUE ;
3038  coutI(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") p.d.f. curve is normalized using explicit choice of ranges '" << pc.getString("normRangeName", "", false) << "'" << endl ;
3039 
3040  nameSuffix.append(Form("_NormRange[%s]",pc.getString("rangeName"))) ;
3041 
3042  }
3043 
3044  if (hasCustomRange && adjustNorm) {
3045  // If overlapping ranges were given, remove them now
3046  const std::size_t oldSize = rangeLim.size();
3047  removeRangeOverlap(rangeLim);
3048 
3049  if (oldSize != rangeLim.size() && !pc.hasProcessed("NormRange")) {
3050  // User gave overlapping ranges. This leads to double-counting events and integrals, and must
3051  // therefore be avoided. If a NormRange has been given, the overlap is alreay gone.
3052  // It's safe to plot even with overlap now.
3053  coutE(Plotting) << "Requested plot/integration ranges overlap. For correct plotting, new ranges "
3054  "will be defined." << std::endl;
3055  auto plotVar = dynamic_cast<RooRealVar*>(frame->getPlotVar());
3056  assert(plotVar);
3057  std::string rangesNoOverlap;
3058  for (auto it = rangeLim.begin(); it != rangeLim.end(); ++it) {
3059  std::stringstream rangeName;
3060  rangeName << "Remove_overlap_range_" << it - rangeLim.begin();
3061  plotVar->setRange(rangeName.str().c_str(), it->first, it->second);
3062  if (!rangesNoOverlap.empty())
3063  rangesNoOverlap += ",";
3064  rangesNoOverlap += rangeName.str();
3065  }
3066 
3067  auto rangeArg = static_cast<RooCmdArg*>(cmdList.FindObject("RangeWithName"));
3068  if (rangeArg)
3069  rangeArg->setString(0, rangesNoOverlap.c_str());
3070  else {
3071  plotRange = new RooCmdArg(RooFit::Range(rangesNoOverlap.c_str()));
3072  cmdList.Add(plotRange);
3073  }
3074  }
3075 
3076  Double_t rangeNevt(0) ;
3077  for (const auto& riter : rangeLim) {
3078  Double_t nevt= frame->getFitRangeNEvt(riter.first, riter.second);
3079  rangeNevt += nevt ;
3080  }
3081 
3082  scaleFactor *= rangeNevt/nExpected ;
3083 
3084  } else {
3085  scaleFactor *= frame->getFitRangeNEvt()/nExpected ;
3086  }
3087  } else if (stype==RelativeExpected) {
3088  scaleFactor *= nExpected ;
3089  } else if (stype==NumEvent) {
3090  scaleFactor /= nExpected ;
3091  }
3092  scaleFactor *= frame->getFitRangeBinW() ;
3093  }
3094  frame->updateNormVars(*frame->getPlotVar()) ;
3095 
3096  // Append overriding scale factor command at end of original command list
3097  RooCmdArg tmp = RooFit::Normalization(scaleFactor,Raw) ;
3098  tmp.setInt(1,1) ; // Flag this normalization command as created for internal use (so that VisualizeError can strip it)
3099  cmdList.Add(&tmp) ;
3100 
3101  // Was a component selected requested
3102  if (haveCompSel) {
3103 
3104  // Get complete set of tree branch nodes
3105  RooArgSet branchNodeSet ;
3106  branchNodeServerList(&branchNodeSet) ;
3107 
3108  // Discard any non-RooAbsReal nodes
3109  for (const auto arg : branchNodeSet) {
3110  if (!dynamic_cast<RooAbsReal*>(arg)) {
3111  branchNodeSet.remove(*arg) ;
3112  }
3113  }
3114 
3115  // Obtain direct selection
3116  RooArgSet* dirSelNodes ;
3117  if (compSet) {
3118  dirSelNodes = (RooArgSet*) branchNodeSet.selectCommon(*compSet) ;
3119  } else {
3120  dirSelNodes = (RooArgSet*) branchNodeSet.selectByName(compSpec) ;
3121  }
3122  if (dirSelNodes->getSize()>0) {
3123  coutI(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") directly selected PDF components: " << *dirSelNodes << endl ;
3124 
3125  // Do indirect selection and activate both
3126  plotOnCompSelect(dirSelNodes) ;
3127  } else {
3128  if (compSet) {
3129  coutE(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") ERROR: component selection set " << *compSet << " does not match any components of p.d.f." << endl ;
3130  } else {
3131  coutE(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") ERROR: component selection expression '" << compSpec << "' does not select any components of p.d.f." << endl ;
3132  }
3133  return 0 ;
3134  }
3135 
3136  delete dirSelNodes ;
3137  }
3138 
3139 
3140  RooCmdArg cnsuffix("CurveNameSuffix",0,0,0,0,nameSuffix.c_str(),0,0,0) ;
3141  cmdList.Add(&cnsuffix);
3142 
3143  RooPlot* ret = RooAbsReal::plotOn(frame,cmdList) ;
3144 
3145  // Restore selection status ;
3146  if (haveCompSel) plotOnCompSelect(0) ;
3147 
3148  if (plotRange) {
3149  delete plotRange ;
3150  }
3151  if (normRange2) {
3152  delete normRange2 ;
3153  }
3154 
3155  return ret ;
3156 }
3157 
3158 
3159 //_____________________________________________________________________________
3160 /// Plot oneself on 'frame'. In addition to features detailed in RooAbsReal::plotOn(),
3161 /// the scale factor for a PDF can be interpreted in three different ways. The interpretation
3162 /// is controlled by ScaleType
3163 /// ```
3164 /// Relative - Scale factor is applied on top of PDF normalization scale factor
3165 /// NumEvent - Scale factor is interpreted as a number of events. The surface area
3166 /// under the PDF curve will match that of a histogram containing the specified
3167 /// number of event
3168 /// Raw - Scale factor is applied to the raw (projected) probability density.
3169 /// Not too useful, option provided for completeness.
3170 /// ```
3171 // coverity[PASS_BY_VALUE]
3173 {
3174 
3175  // Sanity checks
3176  if (plotSanityChecks(frame)) return frame ;
3177 
3178  // More sanity checks
3179  Double_t nExpected(1) ;
3180  if (o.stype==RelativeExpected) {
3181  if (!canBeExtended()) {
3182  coutE(Plotting) << "RooAbsPdf::plotOn(" << GetName()
3183  << "): ERROR the 'Expected' scale option can only be used on extendable PDFs" << endl ;
3184  return frame ;
3185  }
3186  nExpected = expectedEvents(frame->getNormVars()) ;
3187  }
3188 
3189  // Adjust normalization, if so requested
3190  if (o.stype != Raw) {
3191 
3192  if (frame->getFitRangeNEvt() && o.stype==Relative) {
3193  // If non-default plotting range is specified, adjust number of events in fit range
3194  o.scaleFactor *= frame->getFitRangeNEvt()/nExpected ;
3195  } else if (o.stype==RelativeExpected) {
3196  o.scaleFactor *= nExpected ;
3197  } else if (o.stype==NumEvent) {
3198  o.scaleFactor /= nExpected ;
3199  }
3200  o.scaleFactor *= frame->getFitRangeBinW() ;
3201  }
3202  frame->updateNormVars(*frame->getPlotVar()) ;
3203 
3204  return RooAbsReal::plotOn(frame,o) ;
3205 }
3206 
3207 
3208 
3209 
3210 ////////////////////////////////////////////////////////////////////////////////
3211 /// The following named arguments are supported
3212 /// <table>
3213 /// <tr><th> Type of CmdArg <th> Effect on parameter box
3214 /// <tr><td> `Parameters(const RooArgSet& param)` <td> Only the specified subset of parameters will be shown. By default all non-constant parameters are shown.
3215 /// <tr><td> `ShowConstants(Bool_t flag)` <td> Also display constant parameters
3216 /// <tr><td> `Format(const char* optStr)` <td> \deprecated Classing parameter formatting options, provided for backward compatibility
3217 ///
3218 /// <tr><td> `Format(const char* what,...)` <td> Parameter formatting options.
3219 /// | Parameter | Format
3220 /// | ---------------------- | --------------------------
3221 /// | `const char* what` | Controls what is shown. "N" adds name, "E" adds error, "A" shows asymmetric error, "U" shows unit, "H" hides the value
3222 /// | `FixedPrecision(int n)`| Controls precision, set fixed number of digits
3223 /// | `AutoPrecision(int n)` | Controls precision. Number of shown digits is calculated from error + n specified additional digits (1 is sensible default)
3224 /// <tr><td> `Label(const chat* label)` <td> Add label to parameter box. Use `\n` for multi-line labels.
3225 /// <tr><td> `Layout(Double_t xmin, Double_t xmax, Double_t ymax)` <td> Specify relative position of left/right side of box and top of box.
3226 /// Coordinates are given as position on the pad between 0 and 1.
3227 /// The lower end of the box is calculated automatically from the number of lines in the box.
3228 /// </table>
3229 ///
3230 ///
3231 /// Example use:
3232 /// ```
3233 /// pdf.paramOn(frame, Label("fit result"), Format("NEU",AutoPrecision(1)) ) ;
3234 /// ```
3235 ///
3236 
3237 RooPlot* RooAbsPdf::paramOn(RooPlot* frame, const RooCmdArg& arg1, const RooCmdArg& arg2,
3238  const RooCmdArg& arg3, const RooCmdArg& arg4, const RooCmdArg& arg5,
3239  const RooCmdArg& arg6, const RooCmdArg& arg7, const RooCmdArg& arg8)
3240 {
3241  // Stuff all arguments in a list
3242  RooLinkedList cmdList;
3243  cmdList.Add(const_cast<RooCmdArg*>(&arg1)) ; cmdList.Add(const_cast<RooCmdArg*>(&arg2)) ;
3244  cmdList.Add(const_cast<RooCmdArg*>(&arg3)) ; cmdList.Add(const_cast<RooCmdArg*>(&arg4)) ;
3245  cmdList.Add(const_cast<RooCmdArg*>(&arg5)) ; cmdList.Add(const_cast<RooCmdArg*>(&arg6)) ;
3246  cmdList.Add(const_cast<RooCmdArg*>(&arg7)) ; cmdList.Add(const_cast<RooCmdArg*>(&arg8)) ;
3247 
3248  // Select the pdf-specific commands
3249  RooCmdConfig pc(Form("RooAbsPdf::paramOn(%s)",GetName())) ;
3250  pc.defineString("label","Label",0,"") ;
3251  pc.defineDouble("xmin","Layout",0,0.50) ;
3252  pc.defineDouble("xmax","Layout",1,0.99) ;
3253  pc.defineInt("ymaxi","Layout",0,Int_t(0.95*10000)) ;
3254  pc.defineInt("showc","ShowConstants",0,0) ;
3255  pc.defineObject("params","Parameters",0,0) ;
3256  pc.defineString("formatStr","Format",0,"NELU") ;
3257  pc.defineInt("sigDigit","Format",0,2) ;
3258  pc.defineInt("dummy","FormatArgs",0,0) ;
3259  pc.defineMutex("Format","FormatArgs") ;
3260 
3261  // Process and check varargs
3262  pc.process(cmdList) ;
3263  if (!pc.ok(kTRUE)) {
3264  return frame ;
3265  }
3266 
3267  const char* label = pc.getString("label") ;
3268  Double_t xmin = pc.getDouble("xmin") ;
3269  Double_t xmax = pc.getDouble("xmax") ;
3270  Double_t ymax = pc.getInt("ymaxi") / 10000. ;
3271  Int_t showc = pc.getInt("showc") ;
3272 
3273 
3274  const char* formatStr = pc.getString("formatStr") ;
3275  Int_t sigDigit = pc.getInt("sigDigit") ;
3276 
3277  // Decode command line arguments
3278  RooArgSet* params = static_cast<RooArgSet*>(pc.getObject("params")) ;
3279  if (!params) {
3280  std::unique_ptr<RooArgSet> paramsPtr{getParameters(frame->getNormVars())} ;
3281  if (pc.hasProcessed("FormatArgs")) {
3282  const RooCmdArg* formatCmd = static_cast<RooCmdArg*>(cmdList.FindObject("FormatArgs")) ;
3283  paramOn(frame,*paramsPtr,showc,label,0,0,xmin,xmax,ymax,formatCmd) ;
3284  } else {
3285  paramOn(frame,*paramsPtr,showc,label,sigDigit,formatStr,xmin,xmax,ymax) ;
3286  }
3287  } else {
3288  std::unique_ptr<RooArgSet> pdfParams{getParameters(frame->getNormVars())} ;
3289  std::unique_ptr<RooArgSet> selParams{static_cast<RooArgSet*>(pdfParams->selectCommon(*params))} ;
3290  if (pc.hasProcessed("FormatArgs")) {
3291  const RooCmdArg* formatCmd = static_cast<RooCmdArg*>(cmdList.FindObject("FormatArgs")) ;
3292  paramOn(frame,*selParams,showc,label,0,0,xmin,xmax,ymax,formatCmd) ;
3293  } else {
3294  paramOn(frame,*selParams,showc,label,sigDigit,formatStr,xmin,xmax,ymax) ;
3295  }
3296  }
3297 
3298  return frame ;
3299 }
3300 
3301 
3302 
3303 
3304 ////////////////////////////////////////////////////////////////////////////////
3305 /// \deprecated Obsolete, provided for backward compatibility. Don't use.
3306 
3307 RooPlot* RooAbsPdf::paramOn(RooPlot* frame, const RooAbsData* data, const char *label,
3308  Int_t sigDigits, Option_t *options, Double_t xmin,
3310 {
3311  std::unique_ptr<RooArgSet> params{getParameters(data)} ;
3312  TString opts(options) ;
3313  paramOn(frame,*params,opts.Contains("c"),label,sigDigits,options,xmin,xmax,ymax) ;
3314  return frame ;
3315 }
3316 
3317 
3318 
3319 ////////////////////////////////////////////////////////////////////////////////
3320 /// Add a text box with the current parameter values and their errors to the frame.
3321 /// Observables of this PDF appearing in the 'data' dataset will be omitted.
3322 ///
3323 /// An optional label will be inserted if passed. Multi-line labels can be generated
3324 /// by adding `\n` to the label string. Use 'sigDigits'
3325 /// to modify the default number of significant digits printed. The 'xmin,xmax,ymax'
3326 /// values specify the initial relative position of the text box in the plot frame.
3327 
3328 RooPlot* RooAbsPdf::paramOn(RooPlot* frame, const RooArgSet& params, Bool_t showConstants, const char *label,
3329  Int_t sigDigits, Option_t *options, Double_t xmin,
3330  Double_t xmax ,Double_t ymax, const RooCmdArg* formatCmd)
3331 {
3332 
3333  // parse the options
3334  TString opts = options;
3335  opts.ToLower();
3336  Bool_t showLabel= (label != 0 && strlen(label) > 0);
3337 
3338  // calculate the box's size, adjusting for constant parameters
3339 
3340  Double_t ymin(ymax), dy(0.06);
3341  for (const auto param : params) {
3342  auto var = static_cast<RooRealVar*>(param);
3343  if(showConstants || !var->isConstant()) ymin-= dy;
3344  }
3345 
3346  std::string labelString = label;
3347  unsigned int numLines = std::count(labelString.begin(), labelString.end(), '\n') + 1;
3348  if (showLabel) ymin -= numLines * dy;
3349 
3350  // create the box and set its options
3351  TPaveText *box= new TPaveText(xmin,ymax,xmax,ymin,"BRNDC");
3352  if(!box) return 0;
3353  box->SetName(Form("%s_paramBox",GetName())) ;
3354  box->SetFillColor(0);
3355  box->SetBorderSize(1);
3356  box->SetTextAlign(12);
3357  box->SetTextSize(0.04F);
3358  box->SetFillStyle(1001);
3359  box->SetFillColor(0);
3360 
3361  for (const auto param : params) {
3362  auto var = static_cast<const RooRealVar*>(param);
3363  if(var->isConstant() && !showConstants) continue;
3364 
3365  TString *formatted= options ? var->format(sigDigits, options) : var->format(*formatCmd) ;
3366  box->AddText(formatted->Data());
3367  delete formatted;
3368  }
3369 
3370  // add the optional label if specified
3371  if (showLabel) {
3372  for (const auto& line : RooHelpers::tokenise(label, "\n")) {
3373  box->AddText(line.c_str());
3374  }
3375  }
3376 
3377  // Add box to frame
3378  frame->addObject(box) ;
3379 
3380  return frame ;
3381 }
3382 
3383 
3384 
3385 
3386 ////////////////////////////////////////////////////////////////////////////////
3387 /// Return expected number of events from this p.d.f for use in extended
3388 /// likelihood calculations. This default implementation returns zero
3389 
3391 {
3392  return 0 ;
3393 }
3394 
3395 
3396 
3397 ////////////////////////////////////////////////////////////////////////////////
3398 /// Change global level of verbosity for p.d.f. evaluations
3399 
3401 {
3402  _verboseEval = stat ;
3403 }
3404 
3405 
3406 
3407 ////////////////////////////////////////////////////////////////////////////////
3408 /// Return global level of verbosity for p.d.f. evaluations
3409 
3411 {
3412  return _verboseEval ;
3413 }
3414 
3415 
3416 
3417 ////////////////////////////////////////////////////////////////////////////////
3418 /// Destructor of normalization cache element. If this element
3419 /// provides the 'current' normalization stored in RooAbsPdf::_norm
3420 /// zero _norm pointer here before object pointed to is deleted here
3421 
3423 {
3424  // Zero _norm pointer in RooAbsPdf if it is points to our cache payload
3425  if (_owner) {
3426  RooAbsPdf* pdfOwner = static_cast<RooAbsPdf*>(_owner) ;
3427  if (pdfOwner->_norm == _norm) {
3428  pdfOwner->_norm = 0 ;
3429  }
3430  }
3431 
3432  delete _norm ;
3433 }
3434 
3435 
3436 
3437 ////////////////////////////////////////////////////////////////////////////////
3438 /// Return a p.d.f that represent a projection of this p.d.f integrated over given observables
3439 
3441 {
3442  // Construct name for new object
3443  std::string name(GetName()) ;
3444  name.append("_Proj[") ;
3445  if (iset.getSize()>0) {
3446  bool first = true;
3447  for(auto const& arg : iset) {
3448  if (first) {
3449  first = false ;
3450  } else {
3451  name.append(",") ;
3452  }
3453  name.append(arg->GetName()) ;
3454  }
3455  }
3456  name.append("]") ;
3457 
3458  // Return projected p.d.f.
3459  return new RooProjectedPdf(name.c_str(),name.c_str(),*this,iset) ;
3460 }
3461 
3462 
3463 
3464 ////////////////////////////////////////////////////////////////////////////////
3465 /// Create a cumulative distribution function of this p.d.f in terms
3466 /// of the observables listed in iset. If no nset argument is given
3467 /// the c.d.f normalization is constructed over the integrated
3468 /// observables, so that its maximum value is precisely 1. It is also
3469 /// possible to choose a different normalization for
3470 /// multi-dimensional p.d.f.s: eg. for a pdf f(x,y,z) one can
3471 /// construct a partial cdf c(x,y) that only when integrated itself
3472 /// over z results in a maximum value of 1. To construct such a cdf pass
3473 /// z as argument to the optional nset argument
3474 
3476 {
3477  return createCdf(iset,RooFit::SupNormSet(nset)) ;
3478 }
3479 
3480 
3481 
3482 ////////////////////////////////////////////////////////////////////////////////
3483 /// Create an object that represents the integral of the function over one or more observables listed in `iset`.
3484 /// The actual integration calculation is only performed when the return object is evaluated. The name
3485 /// of the integral object is automatically constructed from the name of the input function, the variables
3486 /// it integrates and the range integrates over
3487 ///
3488 /// The following named arguments are accepted
3489 /// | Type of CmdArg | Effect on CDF
3490 /// | ---------------------|-------------------
3491 /// | SupNormSet(const RooArgSet&) | Observables over which should be normalized _in addition_ to the integration observables
3492 /// | ScanNumCdf() | Apply scanning technique if cdf integral involves numeric integration [ default ]
3493 /// | ScanAllCdf() | Always apply scanning technique
3494 /// | ScanNoCdf() | Never apply scanning technique
3495 /// | ScanParameters(Int_t nbins, Int_t intOrder) | Parameters for scanning technique of making CDF: number of sampled bins and order of interpolation applied on numeric cdf
3496 
3497 RooAbsReal* RooAbsPdf::createCdf(const RooArgSet& iset, const RooCmdArg& arg1, const RooCmdArg& arg2,
3498  const RooCmdArg& arg3, const RooCmdArg& arg4, const RooCmdArg& arg5,
3499  const RooCmdArg& arg6, const RooCmdArg& arg7, const RooCmdArg& arg8)
3500 {
3501  // Define configuration for this method
3502  RooCmdConfig pc(Form("RooAbsReal::createCdf(%s)",GetName())) ;
3503  pc.defineObject("supNormSet","SupNormSet",0,0) ;
3504  pc.defineInt("numScanBins","ScanParameters",0,1000) ;
3505  pc.defineInt("intOrder","ScanParameters",1,2) ;
3506  pc.defineInt("doScanNum","ScanNumCdf",0,1) ;
3507  pc.defineInt("doScanAll","ScanAllCdf",0,0) ;
3508  pc.defineInt("doScanNon","ScanNoCdf",0,0) ;
3509  pc.defineMutex("ScanNumCdf","ScanAllCdf","ScanNoCdf") ;
3510 
3511  // Process & check varargs
3512  pc.process(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8) ;
3513  if (!pc.ok(kTRUE)) {
3514  return 0 ;
3515  }
3516 
3517  // Extract values from named arguments
3518  const RooArgSet* snset = static_cast<const RooArgSet*>(pc.getObject("supNormSet",0)) ;
3519  RooArgSet nset ;
3520  if (snset) {
3521  nset.add(*snset) ;
3522  }
3523  Int_t numScanBins = pc.getInt("numScanBins") ;
3524  Int_t intOrder = pc.getInt("intOrder") ;
3525  Int_t doScanNum = pc.getInt("doScanNum") ;
3526  Int_t doScanAll = pc.getInt("doScanAll") ;
3527  Int_t doScanNon = pc.getInt("doScanNon") ;
3528 
3529  // If scanning technique is not requested make integral-based cdf and return
3530  if (doScanNon) {
3531  return createIntRI(iset,nset) ;
3532  }
3533  if (doScanAll) {
3534  return createScanCdf(iset,nset,numScanBins,intOrder) ;
3535  }
3536  if (doScanNum) {
3537  std::unique_ptr<RooRealIntegral> tmp{static_cast<RooRealIntegral*>(createIntegral(iset))} ;
3538  Int_t isNum= (tmp->numIntRealVars().getSize()>0) ;
3539 
3540  if (isNum) {
3541  coutI(NumIntegration) << "RooAbsPdf::createCdf(" << GetName() << ") integration over observable(s) " << iset << " involves numeric integration," << endl
3542  << " constructing cdf though numeric integration of sampled pdf in " << numScanBins << " bins and applying order "
3543  << intOrder << " interpolation on integrated histogram." << endl
3544  << " To override this choice of technique use argument ScanNone(), to change scan parameters use ScanParameters(nbins,order) argument" << endl ;
3545  }
3546 
3547  return isNum ? createScanCdf(iset,nset,numScanBins,intOrder) : createIntRI(iset,nset) ;
3548  }
3549  return 0 ;
3550 }
3551 
3552 RooAbsReal* RooAbsPdf::createScanCdf(const RooArgSet& iset, const RooArgSet& nset, Int_t numScanBins, Int_t intOrder)
3553 {
3554  string name = string(GetName()) + "_NUMCDF_" + integralNameSuffix(iset,&nset).Data() ;
3555  RooRealVar* ivar = (RooRealVar*) iset.first() ;
3556  ivar->setBins(numScanBins,"numcdf") ;
3557  RooNumCdf* ret = new RooNumCdf(name.c_str(),name.c_str(),*this,*ivar,"numcdf") ;
3558  ret->setInterpolationOrder(intOrder) ;
3559  return ret ;
3560 }
3561 
3562 
3563 
3564 
3565 ////////////////////////////////////////////////////////////////////////////////
3566 /// This helper function finds and collects all constraints terms of all component p.d.f.s
3567 /// and returns a RooArgSet with all those terms.
3568 
3569 RooArgSet* RooAbsPdf::getAllConstraints(const RooArgSet& observables, RooArgSet& constrainedParams, Bool_t stripDisconnected) const
3570 {
3571  RooArgSet* ret = new RooArgSet("AllConstraints") ;
3572 
3573  std::unique_ptr<RooArgSet> comps(getComponents());
3574  for (const auto arg : *comps) {
3575  auto pdf = dynamic_cast<const RooAbsPdf*>(arg) ;
3576  if (pdf && !ret->find(pdf->GetName())) {
3577  std::unique_ptr<RooArgSet> compRet(pdf->getConstraints(observables,constrainedParams,stripDisconnected));
3578  if (compRet) {
3579  ret->add(*compRet,kFALSE) ;
3580  }
3581  }
3582  }
3583 
3584  return ret ;
3585 }
3586 
3587 
3588 ////////////////////////////////////////////////////////////////////////////////
3589 /// Returns the default numeric MC generator configuration for all RooAbsReals
3590 
3592 {
3593  return &RooNumGenConfig::defaultConfig() ;
3594 }
3595 
3596 
3597 ////////////////////////////////////////////////////////////////////////////////
3598 /// Returns the specialized integrator configuration for _this_ RooAbsReal.
3599 /// If this object has no specialized configuration, a null pointer is returned
3600 
3602 {
3603  return _specGeneratorConfig ;
3604 }
3605 
3606 
3607 
3608 ////////////////////////////////////////////////////////////////////////////////
3609 /// Returns the specialized integrator configuration for _this_ RooAbsReal.
3610 /// If this object has no specialized configuration, a null pointer is returned,
3611 /// unless createOnTheFly is kTRUE in which case a clone of the default integrator
3612 /// configuration is created, installed as specialized configuration, and returned
3613 
3615 {
3616  if (!_specGeneratorConfig && createOnTheFly) {
3618  }
3619  return _specGeneratorConfig ;
3620 }
3621 
3622 
3623 
3624 ////////////////////////////////////////////////////////////////////////////////
3625 /// Return the numeric MC generator configuration used for this object. If
3626 /// a specialized configuration was associated with this object, that configuration
3627 /// is returned, otherwise the default configuration for all RooAbsReals is returned
3628 
3630 {
3631  const RooNumGenConfig* config = specialGeneratorConfig() ;
3632  if (config) return config ;
3633  return defaultGeneratorConfig() ;
3634 }
3635 
3636 
3637 
3638 ////////////////////////////////////////////////////////////////////////////////
3639 /// Set the given configuration as default numeric MC generator
3640 /// configuration for this object
3641 
3643 {
3644  if (_specGeneratorConfig) {
3645  delete _specGeneratorConfig ;
3646  }
3647  _specGeneratorConfig = new RooNumGenConfig(config) ;
3648 }
3649 
3650 
3651 
3652 ////////////////////////////////////////////////////////////////////////////////
3653 /// Remove the specialized numeric MC generator configuration associated
3654 /// with this object
3655 
3657 {
3658  if (_specGeneratorConfig) {
3659  delete _specGeneratorConfig ;
3660  }
3661  _specGeneratorConfig = 0 ;
3662 }
3663 
3664 
3665 
3666 ////////////////////////////////////////////////////////////////////////////////
3667 
3669 {
3670  delete _genContext ;
3671 }
3672 
3673 
3674 ////////////////////////////////////////////////////////////////////////////////
3675 
3676 RooAbsPdf::GenSpec::GenSpec(RooAbsGenContext* context, const RooArgSet& whatVars, RooDataSet* protoData, Int_t nGen,
3677  Bool_t extended, Bool_t randProto, Bool_t resampleProto, TString dsetName, Bool_t init) :
3678  _genContext(context), _whatVars(whatVars), _protoData(protoData), _nGen(nGen), _extended(extended),
3679  _randProto(randProto), _resampleProto(resampleProto), _dsetName(dsetName), _init(init)
3680 {
3681 }
3682 
3683 
3684 
3685 ////////////////////////////////////////////////////////////////////////////////
3686 
3687 void RooAbsPdf::setNormRange(const char* rangeName)
3688 {
3689  if (rangeName) {
3690  _normRange = rangeName ;
3691  } else {
3692  _normRange.Clear() ;
3693  }
3694 
3695  if (_norm) {
3696  _normMgr.sterilize() ;
3697  _norm = 0 ;
3698  }
3699 }
3700 
3701 
3702 ////////////////////////////////////////////////////////////////////////////////
3703 
3704 void RooAbsPdf::setNormRangeOverride(const char* rangeName)
3705 {
3706  if (rangeName) {
3707  _normRangeOverride = rangeName ;
3708  } else {
3710  }
3711 
3712  if (_norm) {
3713  _normMgr.sterilize() ;
3714  _norm = 0 ;
3715  }
3716 }
RooFormulaVar.h
RooAbsArg::Clone
virtual TObject * Clone(const char *newname=0) const
Make a clone of an object using the Streamer facility.
Definition: RooAbsArg.h:84
RooAbsReal::analyticalIntegral
virtual Double_t analyticalIntegral(Int_t code, const char *rangeName=0) const
Implements the actual analytical integral(s) advertised by getAnalyticalIntegral.
Definition: RooAbsReal.cxx:429
RooAbsRealLValue::getRange
std::pair< double, double > getRange(const char *name=0) const
Get low and high bound of the variable.
Definition: RooAbsRealLValue.h:93
RooAbsPdf::createScanCdf
RooAbsReal * createScanCdf(const RooArgSet &iset, const RooArgSet &nset, Int_t numScanBins, Int_t intOrder)
Definition: RooAbsPdf.cxx:3552
l
auto * l
Definition: textangle.C:4
RooAbsPdf::_normSet
RooArgSet * _normSet
Normalization integral (owned by _normMgr)
Definition: RooAbsPdf.h:322
RooCacheManager::setObj
Int_t setObj(const RooArgSet *nset, T *obj, const TNamed *isetRangeName=0)
Definition: RooCacheManager.h:49
m
auto * m
Definition: textangle.C:8
RooAbsPdf::chi2FitTo
virtual RooFitResult * chi2FitTo(RooDataHist &data, const RooCmdArg &arg1=RooCmdArg::none(), const RooCmdArg &arg2=RooCmdArg::none(), const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none(), const RooCmdArg &arg6=RooCmdArg::none(), const RooCmdArg &arg7=RooCmdArg::none(), const RooCmdArg &arg8=RooCmdArg::none())
Perform a fit to given histogram.
Definition: RooAbsReal.cxx:4391
RooBatchCompute.h
RooBinnedGenContext.h
RooAbsReal::evaluateSpan
virtual RooSpan< double > evaluateSpan(RooBatchCompute::RunContext &evalData, const RooArgSet *normSet) const
Evaluate this object for a batch/span of data points.
Definition: RooAbsReal.cxx:4898
RooAbsReal::NumEvent
@ NumEvent
Definition: RooAbsReal.h:266
RooAbsPdf::CacheElem
friend class CacheElem
Definition: RooAbsPdf.h:333
RooAbsArg::ADirty
@ ADirty
Definition: RooAbsArg.h:388
RooAbsPdf::_normRange
TString _normRange
MC generator configuration specific for this object.
Definition: RooAbsPdf.h:354
RooWorkspace.h
RooCmdArg
RooCmdArg is a named container for two doubles, two integers two object points and three string point...
Definition: RooCmdArg.h:27
RooAbsPdf::genContext
virtual RooAbsGenContext * genContext(const RooArgSet &vars, const RooDataSet *prototype=0, const RooArgSet *auxProto=0, Bool_t verbose=kFALSE) const
Interface function to create a generator context from a p.d.f.
Definition: RooAbsPdf.cxx:2061
first
Definition: first.py:1
RooHelpers.h
RooFit::Minimization
@ Minimization
Definition: RooGlobalFunc.h:67
ymax
float ymax
Definition: THbookFile.cxx:95
RooAbsArg::operMode
OperMode operMode() const
Query the operation mode of this node.
Definition: RooAbsArg.h:482
RooAbsPdf::generateSimGlobal
virtual RooDataSet * generateSimGlobal(const RooArgSet &whatVars, Int_t nEvents)
Special generator interface for generation of 'global observables' – for RooStats tools.
Definition: RooAbsPdf.cxx:2748
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:100
RooCmdConfig.h
e
#define e(i)
Definition: RSha256.hxx:103
RooMinuit.h
RooAbsReal::setEvalErrorLoggingMode
static void setEvalErrorLoggingMode(ErrorLoggingMode m)
Set evaluation error logging mode.
Definition: RooAbsReal.cxx:4849
RooMsgService.h
RooAbsPdf::traceEvalPdf
Bool_t traceEvalPdf(Double_t value) const
Check that passed value is positive and not 'not-a-number'.
Definition: RooAbsPdf.cxx:430
ccoutD
#define ccoutD(a)
Definition: RooMsgService.h:37
RooCmdConfig::allowUndefined
void allowUndefined(Bool_t flag=kTRUE)
Definition: RooCmdConfig.h:39
RooAbsCollection::first
RooAbsArg * first() const
Definition: RooAbsCollection.h:187
RooPlot::updateNormVars
void updateNormVars(const RooArgSet &vars)
Install the given set of observables are reference normalization variables for this frame.
Definition: RooPlot.cxx:380
RooAbsPdf::calculateSumW2CorrectedCovMatrix
int calculateSumW2CorrectedCovMatrix(Minimizer &minimizer, RooAbsReal const &nll) const
Definition: RooAbsPdf.cxx:1290
Option_t
const char Option_t
Definition: RtypesCore.h:66
RooAbsPdf::autoGenContext
virtual RooAbsGenContext * autoGenContext(const RooArgSet &vars, const RooDataSet *prototype=0, const RooArgSet *auxProto=0, Bool_t verbose=kFALSE, Bool_t autoBinned=kTRUE, const char *binnedTag="") const
Definition: RooAbsPdf.cxx:2070
RooAbsReal::logEvalError
void logEvalError(const char *message, const char *serverValueString=0) const
Log evaluation error message.
Definition: RooAbsReal.cxx:3717
RooAbsData::isNonPoissonWeighted
virtual Bool_t isNonPoissonWeighted() const
Definition: RooAbsData.h:130
RooAbsData
RooAbsData is the common abstract base class for binned and unbinned datasets.
Definition: RooAbsData.h:49
RooDataHist::weight
double weight(std::size_t i) const
Return weight of i-th bin.
Definition: RooDataHist.h:98
RooNumIntConfig.h
RooAbsPdf::setNormRangeOverride
void setNormRangeOverride(const char *rangeName)
Definition: RooAbsPdf.cxx:3704
RooAbsPdf::generateEvent
virtual void generateEvent(Int_t code)
Interface for generation of an event using the algorithm corresponding to the specified code.
Definition: RooAbsPdf.cxx:2491
RooFit.h
RooFit::InputArguments
@ InputArguments
Definition: RooGlobalFunc.h:68
RooAbsArg::getComponents
RooArgSet * getComponents() const
Create a RooArgSet with all components (branch nodes) of the expression tree headed by this object.
Definition: RooAbsArg.cxx:712
RooCacheManager::getObj
T * getObj(const RooArgSet *nset, Int_t *sterileIndex=0, const TNamed *isetRangeName=0)
Definition: RooCacheManager.h:44
RooNaNPacker::packFloatIntoNaN
static double packFloatIntoNaN(float payload)
Pack float into mantissa of a NaN.
Definition: RooNaNPacker.h:109
RooAbsPdf::extendMode
virtual ExtendMode extendMode() const
Returns ability of PDF to provide extended likelihood terms.
Definition: RooAbsPdf.h:236
RooFit::PrintLevel
RooCmdArg PrintLevel(Int_t code)
Definition: RooGlobalFunc.cxx:192
RooArgSet.h
RooAbsReal::isBinnedDistribution
virtual Bool_t isBinnedDistribution(const RooArgSet &) const
Tests if the distribution is binned. Unless overridden by derived classes, this always returns false.
Definition: RooAbsReal.h:327
TString::Data
const char * Data() const
Definition: TString.h:369
coutP
#define coutP(a)
Definition: RooMsgService.h:31
RooAbsData::isWeighted
virtual Bool_t isWeighted() const
Definition: RooAbsData.h:126
RooAbsPdf::CanBeExtended
@ CanBeExtended
Definition: RooAbsPdf.h:232
RooAbsReal::createIntegral
RooAbsReal * createIntegral(const RooArgSet &iset, const RooCmdArg &arg1, const RooCmdArg &arg2=RooCmdArg::none(), const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none(), const RooCmdArg &arg6=RooCmdArg::none(), const RooCmdArg &arg7=RooCmdArg::none(), const RooCmdArg &arg8=RooCmdArg::none()) const
Create an object that represents the integral of the function over one or more observables listed in ...
Definition: RooAbsReal.cxx:548
RooBatchCompute::RunContext::logProbabilities
std::vector< double > logProbabilities
If evaluation should only occur in a range, the range name can be passed here.
Definition: RunContext.h:56
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
RooAbsTestStatistic::Configuration::cloneInputData
bool cloneInputData
Definition: RooAbsTestStatistic.h:51
RooCmdConfig::process
Bool_t process(const RooCmdArg &arg)
Process given RooCmdArg.
Definition: RooCmdConfig.cxx:513
RooAbsArg::Print
virtual void Print(Option_t *options=0) const
Print the object to the defaultPrintStream().
Definition: RooAbsArg.h:320
RooRandom::integer
static UInt_t integer(UInt_t max, TRandom *generator=randomGenerator())
Return an integer uniformly distributed from [0,n-1].
Definition: RooRandom.cxx:101
RooXYChi2Var.h
xmax
float xmax
Definition: THbookFile.cxx:95
RooAbsArg::_serverList
RefCountList_t _serverList
Definition: RooAbsArg.h:594
RooNumCdf
Class RooNumCdf is an implementation of RooNumRunningInt specialized to calculate cumulative distribu...
Definition: RooNumCdf.h:17
RooAbsReal::CollectErrors
@ CollectErrors
Definition: RooAbsReal.h:311
RooPlot::getFitRangeNEvt
Double_t getFitRangeNEvt() const
Return the number of events in the fit range.
Definition: RooPlot.h:141
coutE
#define coutE(a)
Definition: RooMsgService.h:33
RooAbsPdf::binnedGenContext
virtual RooAbsGenContext * binnedGenContext(const RooArgSet &vars, Bool_t verbose=kFALSE) const
Return a binned generator context.
Definition: RooAbsPdf.cxx:2051
RooCachedReal::setCacheSource
void setCacheSource(Bool_t flag)
Definition: RooCachedReal.h:44
RooAbsPdf::getLogProbabilities
RooSpan< const double > getLogProbabilities(RooBatchCompute::RunContext &evalData, const RooArgSet *normSet=nullptr) const
Compute the log-likelihoods for all events in the requested batch.
Definition: RooAbsPdf.cxx:738
coutW
#define coutW(a)
Definition: RooMsgService.h:32
output
static void output(int code)
Definition: gifencode.c:226
RooAbsPdf::createCdf
RooAbsReal * createCdf(const RooArgSet &iset, const RooArgSet &nset=RooArgSet())
Create a cumulative distribution function of this p.d.f in terms of the observables listed in iset.
Definition: RooAbsPdf.cxx:3475
RooArgList
RooArgList is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgList.h:21
RooGenContext
Class RooGenContext implement a universal generator context for all RooAbsPdf classes that do not hav...
Definition: RooGenContext.h:30
RooFit::WeightVar
RooCmdArg WeightVar(const char *name, Bool_t reinterpretAsWeight=kFALSE)
Definition: RooGlobalFunc.cxx:124
RooAbsData::weight
virtual Double_t weight() const =0
RooFit::Hesse
RooCmdArg Hesse(Bool_t flag=kTRUE)
Definition: RooGlobalFunc.cxx:196
RooAbsReal::plotSanityChecks
Bool_t plotSanityChecks(RooPlot *frame) const
Utility function for plotOn(), perform general sanity check on frame to ensure safe plotting operatio...
Definition: RooAbsReal.cxx:3066
RooAbsReal::getVal
Double_t getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
Definition: RooAbsReal.h:91
RooDataHist::sumEntries
Double_t sumEntries() const override
Sum the weights of all bins.
Definition: RooDataHist.cxx:1750
log
double log(double)
RooAbsTestStatistic::Configuration::rangeName
std::string rangeName
Stores the configuration parameters for RooAbsTestStatistic.
Definition: RooAbsTestStatistic.h:45
RooAbsGenContext::generate
virtual RooDataSet * generate(Double_t nEvents=0, Bool_t skipInit=kFALSE, Bool_t extendedMode=kFALSE)
Generate the specified number of events with nEvents>0 and and return a dataset containing the genera...
Definition: RooAbsGenContext.cxx:152
Int_t
int Int_t
Definition: RtypesCore.h:45
RooAbsPdf::getValV
virtual Double_t getValV(const RooArgSet *set=0) const
Return current value, normalized by integrating over the observables in nset.
Definition: RooAbsPdf.cxx:280
RooAbsPdf::printMultiline
virtual void printMultiline(std::ostream &os, Int_t contents, Bool_t verbose=kFALSE, TString indent="") const
Print multi line detailed information of this RooAbsPdf.
Definition: RooAbsPdf.cxx:2034
RooChi2Var
RooChi2Var implements a simple calculation from a binned dataset and a PDF.
Definition: RooChi2Var.h:25
box
void box(Int_t pat, Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Definition: fillpatterns.C:1
RooAbsPdf::RooAbsPdf
RooAbsPdf()
Default constructor.
Definition: RooAbsPdf.cxx:204
TRandom::Uniform
virtual Double_t Uniform(Double_t x1=1)
Returns a uniform deviate on the interval (0, x1).
Definition: TRandom.cxx:672
RooFit::Normalization
RooCmdArg Normalization(Double_t scaleFactor)
Definition: RooGlobalFunc.cxx:52
RooFit::MPSplit
MPSplit
Definition: RooGlobalFunc.h:70
RooCmdArg::setInt
void setInt(Int_t idx, Int_t value)
Definition: RooCmdArg.h:66
RooAbsTestStatistic::Configuration::verbose
bool verbose
Definition: RooAbsTestStatistic.h:49
TNamed::fName
TString fName
Definition: TNamed.h:32
RooAbsCollection::find
RooAbsArg * find(const char *name) const
Find object with given name in list.
Definition: RooAbsCollection.cxx:813
RooAbsPdf::specialGeneratorConfig
RooNumGenConfig * specialGeneratorConfig() const
Returns the specialized integrator configuration for this RooAbsReal.
Definition: RooAbsPdf.cxx:3601
TGeant4Unit::pc
static constexpr double pc
Definition: TGeant4SystemOfUnits.h:130
TString::Contains
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:624
RooCurve.h
RooAbsArg::setOperMode
void setOperMode(OperMode mode, Bool_t recurseADirty=kTRUE)
Set the operation mode of this node.
Definition: RooAbsArg.cxx:1781
RooAbsPdf::CacheElem::_norm
RooAbsReal * _norm
Definition: RooAbsPdf.h:329
RooAbsPdf::GenSpec
Definition: RooAbsPdf.h:73
RooAbsPdf::getGenerator
virtual Int_t getGenerator(const RooArgSet &directVars, RooArgSet &generateVars, Bool_t staticInitOK=kTRUE) const
Load generatedVars with the subset of directVars that we can generate events for, and return a code t...
Definition: RooAbsPdf.cxx:2469
TString::Length
Ssiz_t Length() const
Definition: TString.h:410
RooAbsPdf::CacheElem
Normalization set with for above integral.
Definition: RooAbsPdf.h:324
coutI
#define coutI(a)
Definition: RooMsgService.h:30
TClass.h
TList.h
indent
static void indent(ostringstream &buf, int indent_level)
Definition: TClingCallFunc.cxx:87
RooObjCacheManager::sterilize
void sterilize()
Clear the cache payload but retain slot mapping w.r.t to normalization and integration sets.
Definition: RooObjCacheManager.cxx:159
RooPrintable::kAddress
@ kAddress
Definition: RooPrintable.h:33
RooAbsPdf::defaultGeneratorConfig
static RooNumGenConfig * defaultGeneratorConfig()
Returns the default numeric MC generator configuration for all RooAbsReals.
Definition: RooAbsPdf.cxx:3591
RooAbsReal
RooAbsReal is the common abstract base class for objects that represent a real value and implements f...
Definition: RooAbsReal.h:61
RooFitResult::setCovQual
void setCovQual(Int_t val)
Definition: RooFitResult.h:171
RooAbsReal::getIntegratorConfig
const RooNumIntConfig * getIntegratorConfig() const
Return the numeric integration configuration used for this object.
Definition: RooAbsReal.cxx:3557
TMatrixTSym< Double_t >
RooDataSet::SetName
void SetName(const char *name) override
Change the name of this dataset into the given name.
Definition: RooDataSet.cxx:2005
RooAbsPdf::initGenerator
virtual void initGenerator(Int_t code)
Interface for one-time initialization to setup the generator for the specified code.
Definition: RooAbsPdf.cxx:2479
RooAbsPdf::_normMgr
RooObjCacheManager _normMgr
Definition: RooAbsPdf.h:331
RooNameSet::select
RooArgSet * select(const RooArgSet &list) const
Construct a RooArgSet of objects in input 'list' whose names match to those in the internal name list...
Definition: RooNameSet.cxx:185
TString
Basic string class.
Definition: TString.h:136
ROOT::Math::CholeskyDecompGenDim::Invert
bool Invert(M &m) const
place the inverse into m
Definition: CholeskyDecomp.h:389
RooLinkedList::FindObject
TObject * FindObject(const char *name) const
Return pointer to obejct with given name.
Definition: RooLinkedList.cxx:540
RooRealVar::setRange
void setRange(const char *name, Double_t min, Double_t max)
Set a fit or plotting range.
Definition: RooRealVar.cxx:526
RooWorkspace::set
const RooArgSet * set(const char *name)
Return pointer to previously defined named set with given nmame If no such set is found a null pointe...
Definition: RooWorkspace.cxx:977
RooAbsPdf::_traceCount
Int_t _traceCount
Definition: RooAbsPdf.h:347
TObject::InheritsFrom
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:445
RooDataSet.h
TString::Clear
void Clear()
Clear string without changing its capacity.
Definition: TString.cxx:1198
RooAbsPdf::isDirectGenSafe
virtual Bool_t isDirectGenSafe(const RooAbsArg &arg) const
Check if given observable can be safely generated using the pdfs internal generator mechanism (if tha...
Definition: RooAbsPdf.cxx:2504
RooNLLVar.h
RooFit::NumIntegration
@ NumIntegration
Definition: RooGlobalFunc.h:69
RooAbsArg::branchNodeServerList
void branchNodeServerList(RooAbsCollection *list, const RooAbsArg *arg=0, Bool_t recurseNonDerived=kFALSE) const
Fill supplied list with all branch nodes of the arg tree starting with ourself as top node.
Definition: RooAbsArg.cxx:521
RooAbsData::sumEntries
virtual Double_t sumEntries() const =0
Return effective number of entries in dataset, i.e., sum all weights.
RooAbsPdf::GenSpec::GenSpec
GenSpec()
Definition: RooAbsPdf.h:76
RooAbsPdf::plotOn
virtual RooPlot * plotOn(RooPlot *frame, const RooCmdArg &arg1=RooCmdArg::none(), const RooCmdArg &arg2=RooCmdArg::none(), const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none(), const RooCmdArg &arg6=RooCmdArg::none(), const RooCmdArg &arg7=RooCmdArg::none(), const RooCmdArg &arg8=RooCmdArg::none(), const RooCmdArg &arg9=RooCmdArg::none(), const RooCmdArg &arg10=RooCmdArg::none()) const
Helper calling plotOn(RooPlot*, RooLinkedList&) const.
Definition: RooAbsPdf.h:121
bool
CholeskyDecomp.h
header file containing the templated implementation of matrix inversion routines for use with ROOT's ...
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
RooAbsReal::ScaleType
ScaleType
Definition: RooAbsReal.h:266
RooChi2Var.h
RooInt
RooInt is a minimal implementation of a TObject holding a Int_t value.
Definition: RooInt.h:22
RooCmdConfig::getInt
Int_t getInt(const char *name, Int_t defaultValue=0)
Return integer property registered with name 'name'.
Definition: RooCmdConfig.cxx:690
TPaveText.h
RooAbsTestStatistic::Configuration::addCoefRangeName
std::string addCoefRangeName
Definition: RooAbsTestStatistic.h:46
RooAbsReal::PlotOpt::scaleFactor
Double_t scaleFactor
Definition: RooAbsReal.h:483
TMatrixDSym.h
RooConstraintSum.h
RooProjectedPdf.h
RooAbsPdf::verboseEval
static int verboseEval()
Return global level of verbosity for p.d.f. evaluations.
Definition: RooAbsPdf.cxx:3410
RooAbsGenContext::setProtoDataOrder
virtual void setProtoDataOrder(Int_t *lut)
Set the traversal order of prototype data to that in the lookup tables passed as argument.
Definition: RooAbsGenContext.cxx:348
RooSpan::size
constexpr std::span< T >::index_type size() const noexcept
Definition: RooSpan.h:121
RooAbsPdf::setTraceCounter
void setTraceCounter(Int_t value, Bool_t allNodes=kFALSE)
Reset trace counter to given value, limiting the number of future trace messages for this pdf to 'val...
Definition: RooAbsPdf.cxx:632
RooRealIntegral
RooRealIntegral performs hybrid numerical/analytical integrals of RooAbsReal objects.
Definition: RooRealIntegral.h:34
RooCmdArg::setString
void setString(Int_t idx, const char *value)
Definition: RooCmdArg.h:72
RooAbsPdf::getNormObj
virtual const RooAbsReal * getNormObj(const RooArgSet *set, const RooArgSet *iset, const TNamed *rangeName=0) const
Return pointer to RooAbsReal object that implements calculation of integral over observables iset in ...
Definition: RooAbsPdf.cxx:489
RooAbsPdf::setGeneratorConfig
void setGeneratorConfig()
Remove the specialized numeric MC generator configuration associated with this object.
Definition: RooAbsPdf.cxx:3656
RooCmdConfig
Class RooCmdConfig is a configurable parser for RooCmdArg named arguments.
Definition: RooCmdConfig.h:27
RooAbsPdf::_errorCount
Int_t _errorCount
Definition: RooAbsPdf.h:343
RooAbsPdf::extendedTerm
virtual Double_t extendedTerm(Double_t observedEvents, const RooArgSet *nset=0) const
Return the extended likelihood term ( ) of this PDF for the given number of observed events.
Definition: RooAbsPdf.cxx:781
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:579
RooPlot::addObject
void addObject(TObject *obj, Option_t *drawOptions="", Bool_t invisible=kFALSE)
Add a generic object to this plot.
Definition: RooPlot.cxx:422
TObject::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:359
RooPlot::getFitRangeBinW
Double_t getFitRangeBinW() const
Return the bin width that is being used to normalise the PDF.
Definition: RooPlot.h:144
RooAbsCollection::selectByName
RooAbsCollection * selectByName(const char *nameList, Bool_t verbose=kFALSE) const
Create a subset of the current collection, consisting only of those elements with names matching the ...
Definition: RooAbsCollection.cxx:723
ccoutI
#define ccoutI(a)
Definition: RooMsgService.h:38
RooAbsPdf::MustBeExtended
@ MustBeExtended
Definition: RooAbsPdf.h:232
RooDataSet::add
virtual void add(const RooArgSet &row, Double_t weight=1.0, Double_t weightError=0) override
Add a data point, with its coordinates specified in the 'data' argset, to the data set.
Definition: RooDataSet.cxx:1181
RooAbsArg::setStringAttribute
void setStringAttribute(const Text_t *key, const Text_t *value)
Associate string 'value' to this object under key 'key'.
Definition: RooAbsArg.cxx:324
RooAbsPdf::~RooAbsPdf
virtual ~RooAbsPdf()
Destructor.
Definition: RooAbsPdf.cxx:262
RooParamBinning.h
RooAbsReal::PlotOpt
Definition: RooAbsReal.h:477
RooAbsPdf::setNormRange
void setNormRange(const char *rangeName)
Definition: RooAbsPdf.cxx:3687
RooAbsTestStatistic::Configuration::interleave
RooFit::MPSplit interleave
Definition: RooAbsTestStatistic.h:48
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
RooFit::WARNING
@ WARNING
Definition: RooGlobalFunc.h:65
RooDataHist
The RooDataHist is a container class to hold N-dimensional binned data.
Definition: RooDataHist.h:37
RooCachedReal.h
RooPrintable::kName
@ kName
Definition: RooPrintable.h:33
RooAbsPdf::_rawValue
Double_t _rawValue
Definition: RooAbsPdf.h:320
RooFormulaVar
A RooFormulaVar is a generic implementation of a real-valued object, which takes a RooArgList of serv...
Definition: RooFormulaVar.h:30
RooDataHist::get
const RooArgSet * get() const override
Get bin centre of current bin.
Definition: RooDataHist.h:74
RooAbsPdf::CanNotBeExtended
@ CanNotBeExtended
Definition: RooAbsPdf.h:232
RooAbsPdf::getNorm
Double_t getNorm(const RooArgSet &nset) const
Get normalisation term needed to normalise the raw values returned by getVal().
Definition: RooAbsPdf.h:211
RooCustomizer.h
RooNumCdf.h
RooAbsPdf::GenSpec::~GenSpec
virtual ~GenSpec()
Definition: RooAbsPdf.cxx:3668
RooDerivative.h
xmin
float xmin
Definition: THbookFile.cxx:95
RooNaNPacker.h
RooAbsPdf::paramOn
virtual RooPlot * paramOn(RooPlot *frame, const RooCmdArg &arg1=RooCmdArg::none(), const RooCmdArg &arg2=RooCmdArg::none(), const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none(), const RooCmdArg &arg6=RooCmdArg::none(), const RooCmdArg &arg7=RooCmdArg::none(), const RooCmdArg &arg8=RooCmdArg::none())
Add a box with parameter values (and errors) to the specified frame.
Definition: RooAbsPdf.cxx:3237
RooAbsPdf.h
RooCachedReal
RooCachedReal is an implementation of RooAbsCachedReal that can cache any external RooAbsReal input f...
Definition: RooCachedReal.h:20
RooAbsGenContext::isValid
Bool_t isValid() const
Definition: RooAbsGenContext.h:34
TMath::IsNaN
Bool_t IsNaN(Double_t x)
Definition: TMath.h:892
RooAbsReal::integralNameSuffix
TString integralNameSuffix(const RooArgSet &iset, const RooArgSet *nset=0, const char *rangeName=0, Bool_t omitEmpty=kFALSE) const
Construct string with unique suffix name to give to integral object that encodes integrated observabl...
Definition: RooAbsReal.cxx:795
RooAbsArg::isValueDirty
Bool_t isValueDirty() const
Definition: RooAbsArg.h:419
TNamed
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
RooAbsPdf::prepareMultiGen
GenSpec * prepareMultiGen(const RooArgSet &whatVars, const RooCmdArg &arg1=RooCmdArg::none(), const RooCmdArg &arg2=RooCmdArg::none(), const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none(), const RooCmdArg &arg6=RooCmdArg::none())
Prepare GenSpec configuration object for efficient generation of multiple datasets from identical spe...
Definition: RooAbsPdf.cxx:2233
RooFit::Generation
@ Generation
Definition: RooGlobalFunc.h:67
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:101
RooBinnedGenContext
RooBinnedGenContext is an efficient implementation of the generator context specific for binned pdfs.
Definition: RooBinnedGenContext.h:30
RooAbsPdf::analyticalIntegralWN
Double_t analyticalIntegralWN(Int_t code, const RooArgSet *normSet, const char *rangeName=0) const
Analytical integral with normalization (see RooAbsReal::analyticalIntegralWN() for further informatio...
Definition: RooAbsPdf.cxx:410
RooAbsArg::clearValueAndShapeDirty
void clearValueAndShapeDirty() const
Definition: RooAbsArg.h:556
RooRandom.h
RooFit::Fitting
@ Fitting
Definition: RooGlobalFunc.h:67
RooAbsPdf::createNLL
virtual RooAbsReal * createNLL(RooAbsData &data, const RooLinkedList &cmdList)
Construct representation of -log(L) of PDFwith given dataset.
Definition: RooAbsPdf.cxx:970
RooAbsReal::derivative
RooDerivative * derivative(RooRealVar &obs, Int_t order=1, Double_t eps=0.001)
Return function representing first, second or third order derivative of this function.
Definition: RooAbsReal.cxx:4261
RooAbsData::get
virtual const RooArgSet * get() const
Definition: RooAbsData.h:92
TMatrixTSym::Similarity
TMatrixTSym< Element > & Similarity(const TMatrixT< Element > &n)
Calculate B * (*this) * B^T , final matrix will be (nrowsb x nrowsb) This is a similarity transform w...
Definition: TMatrixTSym.cxx:1099
RooArgSet::add
Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE) override
Add element to non-owning set.
Definition: RooArgSet.cxx:261
RooAbsPdf::getGeneratorConfig
const RooNumGenConfig * getGeneratorConfig() const
Return the numeric MC generator configuration used for this object.
Definition: RooAbsPdf.cxx:3629
RooAbsCollection::selectCommon
RooAbsCollection * selectCommon(const RooAbsCollection &refColl) const
Create a subset of the current collection, consisting only of those elements that are contained as we...
Definition: RooAbsCollection.cxx:700
RooFit::Plotting
@ Plotting
Definition: RooGlobalFunc.h:67
RooNLLVar
Class RooNLLVar implements a -log(likelihood) calculation from a dataset and a PDF.
Definition: RooNLLVar.h:30
RooLinkedList
RooLinkedList is an collection class for internal use, storing a collection of RooAbsArg pointers in ...
Definition: RooLinkedList.h:35
RooPlot.h
RooAbsCollection::createIterator
TIterator * createIterator(Bool_t dir=kIterForward) const
TIterator-style iteration over contained elements.
Definition: RooAbsCollection.h:129
RooAbsReal::evaluate
virtual Double_t evaluate() const =0
Evaluate this PDF / function / constant. Needs to be overridden by all derived classes.
RooAbsPdf::_normRangeOverride
static TString _normRangeOverride
Definition: RooAbsPdf.h:355
RooAbsReal::fillDataHist
RooDataHist * fillDataHist(RooDataHist *hist, const RooArgSet *nset, Double_t scaleFactor, Bool_t correctForBinVolume=kFALSE, Bool_t showProgress=kFALSE) const
Fill a RooDataHist with values sampled from this function at the bin centers.
Definition: RooAbsReal.cxx:1216
RooAbsReal::chi2FitDriver
RooFitResult * chi2FitDriver(RooAbsReal &fcn, RooLinkedList &cmdList)
Internal driver function for chi2 fits.
Definition: RooAbsReal.cxx:4620
RooWorkspace::defineSetInternal
Bool_t defineSetInternal(const char *name, const RooArgSet &aset)
Definition: RooWorkspace.cxx:891
RooAbsReal::PlotOpt::stype
ScaleType stype
Definition: RooAbsReal.h:484
RooAbsReal::createIntRI
RooAbsReal * createIntRI(const RooArgSet &iset, const RooArgSet &nset=RooArgSet())
Utility function for createRunningIntegral.
Definition: RooAbsReal.cxx:4091
RooAbsPdf::CacheElem::~CacheElem
virtual ~CacheElem()
Destructor of normalization cache element.
Definition: RooAbsPdf.cxx:3422
RooAbsArg::RooProjectedPdf
friend class RooProjectedPdf
Definition: RooAbsArg.h:593
RooPrintable::kArgs
@ kArgs
Definition: RooPrintable.h:33
RooRealProxy.h
RooAddition
RooAddition calculates the sum of a set of RooAbsReal terms, or when constructed with two sets,...
Definition: RooAddition.h:27
RooPlot
A RooPlot is a plot frame and a container for graphics objects within that frame.
Definition: RooPlot.h:44
RooAbsArg::RooArgSet
friend class RooArgSet
Definition: RooAbsArg.h:586
RooAbsGenContext
RooAbsGenContext is the abstract base class for generator contexts of RooAbsPdf objects.
Definition: RooAbsGenContext.h:26
RooAbsArg::setProxyNormSet
void setProxyNormSet(const RooArgSet *nset)
Forward a change in the cached normalization argset to all the registered proxies.
Definition: RooAbsArg.cxx:1302
RooAbsCacheElement::_owner
RooAbsArg * _owner
Definition: RooAbsCacheElement.h:53
RooNumGenConfig::defaultConfig
static RooNumGenConfig & defaultConfig()
Return reference to instance of default numeric integrator configuration object.
Definition: RooNumGenConfig.cxx:48
RooAbsPdf::getAllConstraints
virtual RooArgSet * getAllConstraints(const RooArgSet &observables, RooArgSet &constrainedParams, Bool_t stripDisconnected=kTRUE) const
This helper function finds and collects all constraints terms of all component p.d....
Definition: RooAbsPdf.cxx:3569
RooAbsCollection::add
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE)
Add the specified argument to list.
Definition: RooAbsCollection.cxx:437
RooAddition.h
RooGenContext.h
RooAbsTestStatistic::Configuration
Definition: RooAbsTestStatistic.h:43
RooAbsArg::getStringAttribute
const Text_t * getStringAttribute(const Text_t *key) const
Get string attribute mapped under key 'key'.
Definition: RooAbsArg.cxx:337
isnan
int isnan(double)
RooAbsData::numEntries
virtual Int_t numEntries() const
Return number of entries in dataset, i.e., count unweighted entries.
Definition: RooAbsData.cxx:304
RooCategory.h
RooLinkedList::Add
virtual void Add(TObject *arg)
Definition: RooLinkedList.h:62
RooPrintable::kValue
@ kValue
Definition: RooPrintable.h:33
sqrt
double sqrt(double)
RooAbsReal::_value
Double_t _value
Definition: RooAbsReal.h:464
RooAbsReal::enableOffsetting
virtual void enableOffsetting(Bool_t)
Definition: RooAbsReal.h:353
RooAbsArg::constOptimizeTestStatistic
virtual void constOptimizeTestStatistic(ConstOpCode opcode, Bool_t doAlsoTrackingOpt=kTRUE)
Interface function signaling a request to perform constant term optimization.
Definition: RooAbsArg.cxx:1768
oocoutW
#define oocoutW(o, a)
Definition: RooMsgService.h:47
RooAbsReal::plotOnCompSelect
void plotOnCompSelect(RooArgSet *selNodes) const
Helper function for plotting of composite p.d.fs.
Definition: RooAbsReal.cxx:1537
RooRealVar.h
line
TLine * line
Definition: entrylistblock_figure1.C:235
RooAbsPdf::logBatchComputationErrors
void logBatchComputationErrors(RooSpan< const double > &outputs, std::size_t begin) const
Scan through outputs and fix+log all nans and negative values.
Definition: RooAbsPdf.cxx:715
TRandom::Integer
virtual UInt_t Integer(UInt_t imax)
Returns a random integer uniformly distributed on the interval [ 0, imax-1 ].
Definition: TRandom.cxx:360
RooFitResult.h
TIterator::Next
virtual TObject * Next()=0
RooAbsCachedReal::setInterpolationOrder
void setInterpolationOrder(Int_t order)
Set interpolation order of RooHistFunct representing cache histogram.
Definition: RooAbsCachedReal.cxx:291
ROOT::Math::CholeskyDecompGenDim
class to compute the Cholesky decomposition of a matrix
Definition: CholeskyDecomp.h:311
RooAbsReal::plotOn
virtual RooPlot * plotOn(RooPlot *frame, const RooCmdArg &arg1=RooCmdArg(), const RooCmdArg &arg2=RooCmdArg(), const RooCmdArg &arg3=RooCmdArg(), const RooCmdArg &arg4=RooCmdArg(), const RooCmdArg &arg5=RooCmdArg(), const RooCmdArg &arg6=RooCmdArg(), const RooCmdArg &arg7=RooCmdArg(), const RooCmdArg &arg8=RooCmdArg(), const RooCmdArg &arg9=RooCmdArg(), const RooCmdArg &arg10=RooCmdArg()) const
Plot (project) PDF on specified frame.
Definition: RooAbsReal.cxx:1704
ymin
float ymin
Definition: THbookFile.cxx:95
RooDataHist::SetName
void SetName(const char *name) override
Change the name of the RooDataHist.
Definition: RooDataHist.cxx:1889
RooGlobalFunc.h
RooHelpers::tokenise
std::vector< std::string > tokenise(const std::string &str, const std::string &delims, bool returnEmptyToken=true)
Tokenise the string by splitting at the characters in delims.
Definition: RooHelpers.cxx:62
RooAbsArg::Activate
@ Activate
Definition: RooAbsArg.h:386
RooAbsPdf::getConstraints
virtual RooArgSet * getConstraints(const RooArgSet &, RooArgSet &, Bool_t) const
Definition: RooAbsPdf.h:184
RooAbsReal::Raw
@ Raw
Definition: RooAbsReal.h:266
RooFit::SupNormSet
RooCmdArg SupNormSet(const RooArgSet &nset)
Definition: RooGlobalFunc.cxx:333
RooAbsPdf::printValue
virtual void printValue(std::ostream &os) const
Print value of p.d.f, also print normalization integral that was last used, if any.
Definition: RooAbsPdf.cxx:2015
RooFit::Tracing
@ Tracing
Definition: RooGlobalFunc.h:68
RooFit::Minimizer
RooCmdArg Minimizer(const char *type, const char *alg=0)
Definition: RooGlobalFunc.cxx:214
RooAbsPdf::_negCount
Int_t _negCount
Definition: RooAbsPdf.h:348
RooNameSet
RooNameSet is a utility class that stores the names the objects in a RooArget.
Definition: RooNameSet.h:24
RooCmdConfig::defineInt
Bool_t defineInt(const char *name, const char *argName, Int_t intNum, Int_t defValue=0)
Define integer property name 'name' mapped to integer in slot 'intNum' in RooCmdArg with name argName...
Definition: RooCmdConfig.cxx:316
RooDataHist::numEntries
Int_t numEntries() const override
Return the number of bins.
Definition: RooDataHist.cxx:1741
RooAbsRealLValue::hasRange
virtual Bool_t hasRange(const char *name) const
Check if variable has a binning with given name.
Definition: RooAbsRealLValue.h:102
RooAbsPdf::_selectComp
Bool_t _selectComp
Definition: RooAbsPdf.h:350
Double_t
double Double_t
Definition: RtypesCore.h:59
RooAbsArg::RooDataSet
friend class RooDataSet
Definition: RooAbsArg.h:631
RooNumGenConfig
RooNumGenConfig holds the configuration parameters of the various numeric integrators used by RooReal...
Definition: RooNumGenConfig.h:25
RooPlot::getNormVars
const RooArgSet * getNormVars() const
Definition: RooPlot.h:148
RooAbsArg::getObservables
RooArgSet * getObservables(const RooArgSet &set, Bool_t valueOnly=kTRUE) const
Given a set of possible observables, return the observables that this PDF depends on.
Definition: RooAbsArg.h:294
RooAbsArg::addOwnedComponents
Bool_t addOwnedComponents(const RooArgSet &comps)
Take ownership of the contents of 'comps'.
Definition: RooAbsArg.cxx:2180
RooAbsPdf::createProjection
virtual RooAbsPdf * createProjection(const RooArgSet &iset)
Return a p.d.f that represent a projection of this p.d.f integrated over given observables.
Definition: RooAbsPdf.cxx:3440
RooMinimizer.h
RooAbsPdf::_norm
RooAbsReal * _norm
Definition: RooAbsPdf.h:321
TRandom::Poisson
virtual Int_t Poisson(Double_t mean)
Generates a random integer N according to a Poisson law.
Definition: TRandom.cxx:402
RooAbsPdf::_specGeneratorConfig
RooNumGenConfig * _specGeneratorConfig
Definition: RooAbsPdf.h:352
RooInt.h
RooAbsPdf::generate
RooDataSet * generate(const RooArgSet &whatVars, Int_t nEvents, const RooCmdArg &arg1, const RooCmdArg &arg2=RooCmdArg::none(), const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none())
See RooAbsPdf::generate(const RooArgSet&,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,...
Definition: RooAbsPdf.h:58
RooAbsTestStatistic::Configuration::nCPU
int nCPU
Definition: RooAbsTestStatistic.h:47
RooAbsPdf::calculateAsymptoticCorrectedCovMatrix
int calculateAsymptoticCorrectedCovMatrix(Minimizer &minimizer, RooAbsData const &data)
Definition: RooAbsPdf.cxx:1223
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
RooNameSet::content
const char * content() const
Definition: RooNameSet.h:50
RooNumGenConfig.h
RooAbsPdf::getValues
RooSpan< const double > getValues(RooBatchCompute::RunContext &evalData, const RooArgSet *normSet) const
Compute batch of values for given input data, and normalise by integrating over the observables in no...
Definition: RooAbsPdf.cxx:352
RooNameReg::str
static const char * str(const TNamed *ptr)
Return C++ string corresponding to given TNamed pointer.
Definition: RooNameReg.cxx:103
RooAbsPdf::_verboseEval
static Int_t _verboseEval
Definition: RooAbsPdf.h:315
RooFit::NormRange
RooCmdArg NormRange(const char *rangeNameList)
Definition: RooGlobalFunc.cxx:55
RooFit::Range
RooCmdArg Range(const char *rangeName, Bool_t adjustNorm=kTRUE)
Definition: RooGlobalFunc.cxx:53
name
char name[80]
Definition: TGX11.cxx:110
RooMinuit
RooMinuit is a wrapper class around TFitter/TMinuit that provides a seamless interface between the MI...
Definition: RooMinuit.h:39
RooAbsArg::dependsOn
Bool_t dependsOn(const RooAbsCollection &serverList, const RooAbsArg *ignoreArg=0, Bool_t valueOnly=kFALSE) const
Test whether we depend on (ie, are served by) any object in the specified collection.
Definition: RooAbsArg.cxx:765
RooPrintable::kTitle
@ kTitle
Definition: RooPrintable.h:33
ROOT::Math::Chebyshev::T
double T(double x)
Definition: ChebyshevPol.h:34
RooNameSet::setNameList
void setNameList(const char *givenList)
Definition: RooNameSet.cxx:142
RooXYChi2Var
RooXYChi2Var implements a simple chi^2 calculation from an unbinned dataset with values x,...
Definition: RooXYChi2Var.h:29
RooAbsReal::printMultiline
virtual void printMultiline(std::ostream &os, Int_t contents, Bool_t verbose=kFALSE, TString indent="") const
Structure printing.
Definition: RooAbsReal.cxx:490
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
genreflex::verbose
bool verbose
Definition: rootcling_impl.cxx:133
RooPrintable::kSingleLine
@ kSingleLine
Definition: RooPrintable.h:34
RooFit::Caching
@ Caching
Definition: RooGlobalFunc.h:68
RooDataSet
RooDataSet is a container class to hold unbinned data.
Definition: RooDataSet.h:33
RooAbsPdf::generateBinned
virtual RooDataHist * generateBinned(const RooArgSet &whatVars, Double_t nEvents, const RooCmdArg &arg1, const RooCmdArg &arg2=RooCmdArg::none(), const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none()) const
As RooAbsPdf::generateBinned(const RooArgSet&, const RooCmdArg&,const RooCmdArg&, const RooCmdArg&,...
Definition: RooAbsPdf.h:107
TPaveText
A Pave (see TPave) with text, lines or/and boxes inside.
Definition: TPaveText.h:21
RooAbsArg
RooAbsArg is the common abstract base class for objects that represent a value and a "shape" in RooFi...
Definition: RooAbsArg.h:72
RooAbsReal::getValues
virtual RooSpan< const double > getValues(RooBatchCompute::RunContext &evalData, const RooArgSet *normSet=nullptr) const
by this change, please consult the release notes for ROOT 6.24 for guidance on how to make this trans...
Definition: RooAbsReal.cxx:312
RooAbsTestStatistic::Configuration::integrateOverBinsPrecision
double integrateOverBinsPrecision
Definition: RooAbsTestStatistic.h:52
RooRealIntegral.h
RooRandom::randomGenerator
static TRandom * randomGenerator()
Return a pointer to a singleton random-number generator implementation.
Definition: RooRandom.cxx:53
RooAbsGenContext::setExpectedData
virtual void setExpectedData(Bool_t)
Definition: RooAbsGenContext.h:66
RooAbsCollection::Print
virtual void Print(Option_t *options=0) const
This method must be overridden when a class wants to print itself.
Definition: RooAbsCollection.h:210
RooAbsPdf
Definition: RooAbsPdf.h:43
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
RooAbsPdf::selfNormalized
virtual Bool_t selfNormalized() const
Shows if a PDF is self-normalized, which means that no attempt is made to add a normalization term.
Definition: RooAbsPdf.h:227
RooAbsArg::getVariables
RooArgSet * getVariables(Bool_t stripDisconnected=kTRUE) const
Return RooArgSet with all variables (tree leaf nodes of expresssion tree)
Definition: RooAbsArg.cxx:1972
RooAbsReal::Relative
@ Relative
Definition: RooAbsReal.h:266
RooAbsArg::findServer
RooAbsArg * findServer(const char *name) const
Return server of this with name name. Returns nullptr if not found.
Definition: RooAbsArg.h:203
RooRealVar::setBins
void setBins(Int_t nBins, const char *name=0)
Create a uniform binning under name 'name' for this variable.
Definition: RooRealVar.cxx:408
RooAbsArg::_myws
RooWorkspace * _myws
Prevent 'AlwaysDirty' mode for this node.
Definition: RooAbsArg.h:685
RooAbsPdf::syncNormalization
virtual Bool_t syncNormalization(const RooArgSet *dset, Bool_t adjustProxies=kTRUE) const
Verify that the normalization integral cached with this PDF is valid for given set of normalization o...
Definition: RooAbsPdf.cxx:523
RooConstraintSum
RooConstraintSum calculates the sum of the -(log) likelihoods of a set of RooAbsPfs that represent co...
Definition: RooConstraintSum.h:27
RooAbsReal::PrintErrors
@ PrintErrors
Definition: RooAbsReal.h:311
launcher.spec
spec
Definition: launcher.py:30
TMatrixD.h
RooAbsCategoryLValue
RooAbsCategoryLValue is the common abstract base class for objects that represent a discrete value th...
Definition: RooAbsCategoryLValue.h:25
RooAbsPdf::getLogVal
virtual Double_t getLogVal(const RooArgSet *set=0) const
Return the log of the current value with given normalization An error message is printed if the argum...
Definition: RooAbsPdf.cxx:658
Class
void Class()
Definition: Class.C:29
TString::ToLower
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1147
RooRealVar
RooRealVar represents a variable that can be changed from the outside.
Definition: RooRealVar.h:39
RooAbsTestStatistic::Configuration::binnedL
bool binnedL
Definition: RooAbsTestStatistic.h:53
RooBatchCompute::fast_log
double fast_log(double x)
Definition: RooVDTHeaders.h:56
RooAbsTestStatistic::Configuration::splitCutRange
bool splitCutRange
Definition: RooAbsTestStatistic.h:50
RooFit::Eval
@ Eval
Definition: RooGlobalFunc.h:68
cxcoutI
#define cxcoutI(a)
Definition: RooMsgService.h:85
RooHelpers::LocalChangeMsgLevel
Switches the message service to a different level while the instance is alive.
Definition: RooHelpers.h:39
RooAbsCollection::selectByAttrib
RooAbsCollection * selectByAttrib(const char *name, Bool_t value) const
Create a subset of the current collection, consisting only of those elements with the specified attri...
Definition: RooAbsCollection.cxx:677
RooMinimizer
RooMinimizer is a wrapper class around ROOT::Fit:Fitter that provides a seamless interface between th...
Definition: RooMinimizer.h:40
RooNameReg.h
RooAbsPdf::resetErrorCounters
virtual void resetErrorCounters(Int_t resetValue=10)
Reset error counter to given value, limiting the number of future error messages for this pdf to 'res...
Definition: RooAbsPdf.cxx:620
RooDataHist::set
void set(std::size_t binNumber, double weight, double wgtErr)
Set bin content of bin that was last loaded with get(std::size_t).
Definition: RooDataHist.cxx:1375
RooPlot::getPlotVar
RooAbsRealLValue * getPlotVar() const
Definition: RooPlot.h:139
RooBatchCompute::RunContext::spans
std::unordered_map< const RooAbsReal *, RooSpan< const double > > spans
Once an object has computed its value(s), the span pointing to the results is registered here.
Definition: RunContext.h:52
RooBatchCompute::RunContext
This struct enables passing computation data around between elements of a computation graph.
Definition: RunContext.h:31
RooArgProxy.h
RooAbsPdf::createChi2
virtual RooAbsReal * createChi2(RooDataHist &data, const RooLinkedList &cmdList)
Create a variable from a histogram and this function.
Definition: RooAbsReal.cxx:4460
RooAbsPdf::randomizeProtoOrder
Int_t * randomizeProtoOrder(Int_t nProto, Int_t nGen, Bool_t resample=kFALSE) const
Return lookup table with randomized access order for prototype events, given nProto prototype data ev...
Definition: RooAbsPdf.cxx:2425
RooAbsPdf::canBeExtended
Bool_t canBeExtended() const
If true, PDF can provide extended likelihood term.
Definition: RooAbsPdf.h:238
RooAbsCollection::getSize
Int_t getSize() const
Definition: RooAbsCollection.h:182
RooSpan
A simple container to hold a batch of data values.
Definition: RooSpan.h:34
TMath.h
RooArgSet
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:29
cxcoutD
#define cxcoutD(a)
Definition: RooMsgService.h:81
RooAbsReal::RelativeExpected
@ RelativeExpected
Definition: RooAbsReal.h:266
int
RooAbsCollection::contentsString
std::string contentsString() const
Return comma separated list of contained object names as STL string.
Definition: RooAbsCollection.cxx:1026
RooAbsArg::getAttribute
Bool_t getAttribute(const Text_t *name) const
Check if a named attribute is set. By default, all attributes are unset.
Definition: RooAbsArg.cxx:315
RooAbsPdf::expectedEvents
virtual Double_t expectedEvents(const RooArgSet *nset) const
Return expected number of events from this p.d.f for use in extended likelihood calculations.
Definition: RooAbsPdf.cxx:3390
RooAbsPdf::fitTo
virtual RooFitResult * fitTo(RooAbsData &data, const RooCmdArg &arg1=RooCmdArg::none(), const RooCmdArg &arg2=RooCmdArg::none(), const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none(), const RooCmdArg &arg6=RooCmdArg::none(), const RooCmdArg &arg7=RooCmdArg::none(), const RooCmdArg &arg8=RooCmdArg::none())
Fit PDF to given dataset.
Definition: RooAbsPdf.cxx:1482