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