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