Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
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 \brief Abstract interface for all probability density functions.
21
22## RooAbsPdf, the base class of all PDFs
23
24RooAbsPdf is the base class for all probability density
25functions (PDFs). The class provides hybrid analytical/numerical
26normalization for its implementations, error tracing, and a Monte Carlo
27generator interface.
28
29### A Minimal PDF Implementation
30
31A minimal implementation of a PDF class derived from RooAbsPdf
32should override the `evaluate()` function. This function should
33return the PDF's value (which does not need to be normalised).
34
35
36#### Normalization/Integration
37
38Although the normalization of a PDF is an integral part of a
39probability density function, normalization is treated separately
40in RooAbsPdf. The reason is that a RooAbsPdf object is more than a
41PDF: it can be a building block for a more complex composite PDF
42if any of its variables are functions instead of variables. In
43such cases, the normalization of the composite PDF may not simply be
44integral over the dependents of the top-level PDF: these are
45functions with potentially non-trivial Jacobian terms themselves.
46\note Therefore, no explicit attempt should be made to normalize the
47function output in evaluate(). In particular, normalisation constants
48can be omitted to speed up the function evaluations, and included later
49in the integration of the PDF (see below), which is rarely called in
50comparison to the `evaluate()` function.
51
52In addition, RooAbsPdf objects do not have a static concept of what
53variables are parameters, and what variables are dependents (which
54need to be integrated over for a correct PDF normalization).
55Instead, the choice of normalization is always specified each time a
56normalized value is requested from the PDF via the getVal()
57method.
58
59RooAbsPdf manages the entire normalization logic of each PDF with
60the help of a RooRealIntegral object, which coordinates the integration
61of a given choice of normalization. By default, RooRealIntegral will
62perform an entirely numeric integration of all dependents. However,
63PDFs can advertise one or more (partial) analytical integrals of
64their function, and these will be used by RooRealIntegral, if it
65determines that this is safe (i.e., no hidden Jacobian terms,
66multiplication with other PDFs that have one or more dependents in
67common, etc).
68
69#### Implementing analytical integrals
70To implement analytical integrals, two functions must be implemented. First,
71
72```
73Int_t getAnalyticalIntegral(const RooArgSet& integSet, RooArgSet& anaIntSet)
74```
75should return the analytical integrals that are supported. `integSet`
76is the set of dependents for which integration is requested. The
77function should copy the subset of dependents it can analytically
78integrate to `anaIntSet`, and return a unique identification code for
79this integration configuration. If no integration can be
80performed, zero should be returned. Second,
81
82```
83double analyticalIntegral(Int_t code)
84```
85
86implements the actual analytical integral(s) advertised by
87`getAnalyticalIntegral()`. This function will only be called with
88codes returned by `getAnalyticalIntegral()`, except code zero.
89
90The integration range for each dependent to be integrated can
91be obtained from the dependent's proxy functions `min()` and
92`max()`. Never call these proxy functions for any proxy not known to
93be a dependent via the integration code. Doing so may be
94ill-defined, e.g., in case the proxy holds a function, and will
95trigger an assert. Integrated category dependents should always be
96summed over all of their states.
97
98
99
100### Direct generation of observables
101
102Distributions for any PDF can be generated with the accept/reject method,
103but for certain PDFs, more efficient methods may be implemented. To
104implement direct generation of one or more observables, two
105functions need to be implemented, similar to those for analytical
106integrals:
107
108```
109Int_t getGenerator(const RooArgSet& generateVars, RooArgSet& directVars)
110```
111and
112```
113void generateEvent(Int_t code)
114```
115
116The first function advertises observables, for which distributions can be generated,
117similar to the way analytical integrals are advertised. The second
118function implements the actual generator for the advertised observables.
119
120The generated dependent values should be stored in the proxy
121objects. For this, the assignment operator can be used (i.e. `xProxy
122= 3.0` ). Never call assign to any proxy not known to be a dependent
123via the generation code. Doing so may be ill-defined, e.g. in case
124the proxy holds a function, and will trigger an assert.
125
126
127### Batched function evaluations (Advanced usage)
128
129To speed up computations with large numbers of data events in unbinned fits,
130it is beneficial to override `doEval()`. Like this, large spans of
131computations can be done, without having to call `evaluate()` for each single data event.
132`doEval()` should execute the same computation as `evaluate()`, but it
133may choose an implementation that is capable of SIMD computations.
134If doEval is not implemented, the classic and slower `evaluate()` will be
135called for each data event.
136*/
137
138#include "RooAbsPdf.h"
139
140#include "FitHelpers.h"
141#include "RooNormalizedPdf.h"
142#include "RooMsgService.h"
143#include "RooArgSet.h"
144#include "RooArgProxy.h"
145#include "RooRealProxy.h"
146#include "RooRealVar.h"
147#include "RooGenContext.h"
148#include "RooBinnedGenContext.h"
149#include "RooPlot.h"
150#include "RooCurve.h"
151#include "RooCategory.h"
152#include "RooNameReg.h"
153#include "RooCmdConfig.h"
154#include "RooGlobalFunc.h"
155#include "RooRandom.h"
156#include "RooNumIntConfig.h"
157#include "RooProjectedPdf.h"
158#include "RooParamBinning.h"
159#include "RooNumCdf.h"
160#include "RooFitResult.h"
161#include "RooNumGenConfig.h"
162#include "RooCachedReal.h"
163#include "RooRealIntegral.h"
164#include "RooWorkspace.h"
165#include "RooNaNPacker.h"
166#include "RooFitImplHelpers.h"
167#include "RooHelpers.h"
168#include "RooFormulaVar.h"
169#include "RooDerivative.h"
170
171#include "ROOT/StringUtils.hxx"
172#include "TMath.h"
173#include "TPaveText.h"
174#include "TMatrixD.h"
175#include "TMatrixDSym.h"
176
177#include <algorithm>
178#include <iostream>
179#include <string>
180#include <cmath>
181#include <stdexcept>
182
183namespace {
184
185inline double getLog(double prob, RooAbsReal const *caller)
186{
187
188 if (prob < 0) {
189 caller->logEvalError("getLogVal() top-level p.d.f evaluates to a negative number");
190 return RooNaNPacker::packFloatIntoNaN(-prob);
191 }
192
193 if (std::isinf(prob)) {
194 oocoutW(caller, Eval) << "RooAbsPdf::getLogVal(" << caller->GetName()
195 << ") WARNING: top-level pdf has an infinite value" << std::endl;
196 }
197
198 if (prob == 0) {
199 caller->logEvalError("getLogVal() top-level p.d.f evaluates to zero");
200
201 return -std::numeric_limits<double>::infinity();
202 }
203
204 if (TMath::IsNaN(prob)) {
205 caller->logEvalError("getLogVal() top-level p.d.f evaluates to NaN");
206
207 return prob;
208 }
209
210 return std::log(prob);
211}
212
213} // namespace
214
215using std::endl, std::string, std::ostream, std::vector, std::pair, std::make_pair;
216
218
220
222
223
226
227////////////////////////////////////////////////////////////////////////////////
228/// Default constructor
229
230RooAbsPdf::RooAbsPdf() : _normMgr(this, 10) {}
231
232////////////////////////////////////////////////////////////////////////////////
233/// Constructor with name and title only
234
235RooAbsPdf::RooAbsPdf(const char *name, const char *title) :
236 RooAbsReal(name,title), _normMgr(this,10), _selectComp(true)
237{
239 setTraceCounter(0) ;
240}
241
242
243
244////////////////////////////////////////////////////////////////////////////////
245/// Constructor with name, title, and plot range
246
247RooAbsPdf::RooAbsPdf(const char *name, const char *title,
248 double plotMin, double plotMax) :
249 RooAbsReal(name,title,plotMin,plotMax), _normMgr(this,10), _selectComp(true)
250{
252 setTraceCounter(0) ;
253}
254
255
256
257////////////////////////////////////////////////////////////////////////////////
258/// Copy constructor
259
260RooAbsPdf::RooAbsPdf(const RooAbsPdf& other, const char* name) :
261 RooAbsReal(other,name),
262 _normMgr(other._normMgr,this), _selectComp(other._selectComp), _normRange(other._normRange)
263{
266
267 if (other._specGeneratorConfig) {
268 _specGeneratorConfig = std::make_unique<RooNumGenConfig>(*other._specGeneratorConfig);
269 }
270}
271
272
273
274////////////////////////////////////////////////////////////////////////////////
275/// Destructor
276
278{
279}
280
281
282double RooAbsPdf::normalizeWithNaNPacking(double rawVal, double normVal) const {
283
284 if (normVal < 0. || (normVal == 0. && rawVal != 0)) {
285 //Unreasonable normalisations. A zero integral can be tolerated if the function vanishes, though.
286 const std::string msg = "p.d.f normalization integral is zero or negative: " + std::to_string(normVal);
287 logEvalError(msg.c_str());
289 return RooNaNPacker::packFloatIntoNaN(-normVal + (rawVal < 0. ? -rawVal : 0.));
290 }
291
292 if (rawVal < 0.) {
293 logEvalError(Form("p.d.f value is less than zero (%f), trying to recover", rawVal));
295 return RooNaNPacker::packFloatIntoNaN(-rawVal);
296 }
297
298 if (TMath::IsNaN(rawVal)) {
299 logEvalError("p.d.f value is Not-a-Number");
301 return rawVal;
302 }
303
304 return (rawVal == 0. && normVal == 0.) ? 0. : rawVal / normVal;
306
307
308////////////////////////////////////////////////////////////////////////////////
309/// Return current value, normalized by integrating over
310/// the observables in `nset`. If `nset` is 0, the unnormalized value
311/// is returned. All elements of `nset` must be lvalues.
312///
313/// Unnormalized values are not cached.
314/// Doing so would be complicated as `_norm->getVal()` could
315/// spoil the cache and interfere with returning the cached
316/// return value. Since unnormalized calls are typically
317/// done in integration calls, there is no performance hit.
318
319double RooAbsPdf::getValV(const RooArgSet* nset) const
320{
321
322 // Special handling of case without normalization set (used in numeric integration of pdfs)
323 if (!nset) {
324 RooArgSet const* tmp = _normSet ;
325 _normSet = nullptr ;
326 double val = evaluate() ;
327 _normSet = tmp ;
328
329 return TMath::IsNaN(val) ? 0. : val;
330 }
331
332
333 // Process change in last data set used
334 bool nintChanged(false) ;
335 if (!isActiveNormSet(nset) || _norm==nullptr) {
336 nintChanged = syncNormalization(nset) ;
337 }
338
339 // Return value of object. Calculated if dirty, otherwise cached value is returned.
340 if (isValueDirty() || nintChanged || _norm->isValueDirty()) {
341
342 // Evaluate numerator
343 const double rawVal = evaluate();
344
345 // Evaluate denominator
346 const double normVal = _norm->getVal();
347
348 _value = normalizeWithNaNPacking(rawVal, normVal);
349
351 }
352
353 return _value ;
354}
355
356
357////////////////////////////////////////////////////////////////////////////////
358/// Analytical integral with normalization (see RooAbsReal::analyticalIntegralWN() for further information).
359///
360/// This function applies the normalization specified by `normSet` to the integral returned
361/// by RooAbsReal::analyticalIntegral(). The passthrough scenario (code=0) is also changed
362/// to return a normalized answer.
363
364double RooAbsPdf::analyticalIntegralWN(Int_t code, const RooArgSet* normSet, const char* rangeName) const
365{
366 cxcoutD(Eval) << "RooAbsPdf::analyticalIntegralWN(" << GetName() << ") code = " << code << " normset = " << (normSet?*normSet:RooArgSet()) << endl ;
367
368
369 if (code==0) return getVal(normSet) ;
370 if (normSet) {
371 return analyticalIntegral(code,rangeName) / getNorm(normSet) ;
372 } else {
373 return analyticalIntegral(code,rangeName) ;
374 }
375}
376
377
378
379////////////////////////////////////////////////////////////////////////////////
380/// Check that passed value is positive and not 'not-a-number'. If
381/// not, print an error, until the error counter reaches its set
382/// maximum.
383
385{
386 // check for a math error or negative value
387 bool error(false) ;
388 if (TMath::IsNaN(value)) {
389 logEvalError(Form("p.d.f value is Not-a-Number (%f), forcing value to zero",value)) ;
390 error=true ;
391 }
392 if (value<0) {
393 logEvalError(Form("p.d.f value is less than zero (%f), forcing value to zero",value)) ;
394 error=true ;
395 }
396
397 // do nothing if we are no longer tracing evaluations and there was no error
398 if(!error) return error ;
399
400 // otherwise, print out this evaluations input values and result
401 if(++_errorCount <= 10) {
402 cxcoutD(Tracing) << "*** Evaluation Error " << _errorCount << " ";
403 if(_errorCount == 10) cxcoutD(Tracing) << "(no more will be printed) ";
404 }
405 else {
406 return error ;
407 }
408
409 Print() ;
410 return error ;
411}
412
413
414////////////////////////////////////////////////////////////////////////////////
415/// Get normalisation term needed to normalise the raw values returned by
416/// getVal(). Note that `getVal(normalisationVariables)` will automatically
417/// apply the normalisation term returned here.
418/// \param nset Set of variables to normalise over.
419double RooAbsPdf::getNorm(const RooArgSet* nset) const
420{
421 if (!nset) return 1 ;
422
423 syncNormalization(nset,true) ;
424 if (_verboseEval>1) cxcoutD(Tracing) << ClassName() << "::getNorm(" << GetName() << "): norm(" << _norm << ") = " << _norm->getVal() << endl ;
425
426 double ret = _norm->getVal() ;
427 if (ret==0.) {
428 if(++_errorCount <= 10) {
429 coutW(Eval) << "RooAbsPdf::getNorm(" << GetName() << ":: WARNING normalization is zero, nset = " ; nset->Print("1") ;
430 if(_errorCount == 10) coutW(Eval) << "RooAbsPdf::getNorm(" << GetName() << ") INFO: no more messages will be printed " << endl ;
431 }
432 }
433
434 return ret ;
435}
436
437
438
439////////////////////////////////////////////////////////////////////////////////
440/// Return pointer to RooAbsReal object that implements calculation of integral over observables iset in range
441/// rangeName, optionally taking the integrand normalized over observables nset
442
443const RooAbsReal* RooAbsPdf::getNormObj(const RooArgSet* nset, const RooArgSet* iset, const TNamed* rangeName) const
444{
445 // Check normalization is already stored
446 CacheElem* cache = static_cast<CacheElem*>(_normMgr.getObj(nset,iset,nullptr,rangeName)) ;
447 if (cache) {
448 return cache->_norm.get();
449 }
450
451 // If not create it now
452 RooArgSet depList;
453 getObservables(iset, depList);
454
455 // Normalization is always over all pdf components. Overriding the global
456 // component selection temporarily makes all RooRealIntegrals created during
457 // that time always include all components.
458 GlobalSelectComponentRAII globalSelComp(true);
459 RooAbsReal* norm = std::unique_ptr<RooAbsReal>{createIntegral(depList,*nset, *getIntegratorConfig(), RooNameReg::str(rangeName))}.release();
460
461 // Store it in the cache
462 _normMgr.setObj(nset,iset,new CacheElem(*norm),rangeName) ;
463
464 // And return the newly created integral
465 return norm ;
466}
467
468
469
470////////////////////////////////////////////////////////////////////////////////
471/// Verify that the normalization integral cached with this PDF
472/// is valid for given set of normalization observables.
473///
474/// If not, the cached normalization integral (if any) is deleted
475/// and a new integral is constructed for use with 'nset'.
476/// Elements in 'nset' can be discrete and real, but must be lvalues.
477///
478/// For functions that declare to be self-normalized by overloading the
479/// selfNormalized() function, a unit normalization is always constructed.
480
481bool RooAbsPdf::syncNormalization(const RooArgSet* nset, bool adjustProxies) const
482{
483 setActiveNormSet(nset);
484
485 // Check if data sets are identical
486 CacheElem* cache = static_cast<CacheElem*>(_normMgr.getObj(nset)) ;
487 if (cache) {
488
489 bool nintChanged = (_norm!=cache->_norm.get()) ;
490 _norm = cache->_norm.get();
491
492 // In the past, this condition read `if (nintChanged && adjustProxies)`.
493 // However, the cache checks if the nset was already cached **by content**,
494 // and not by RooArgSet instance! So it can happen that the normalization
495 // set object is different, but the integral object is the same, in which
496 // case it would be wrong to not adjust the proxies. They always have to be
497 // adjusted when the nset changed, which is always the case when
498 // `syncNormalization()` is called.
499 if (adjustProxies) {
500 // Update dataset pointers of proxies
501 const_cast<RooAbsPdf*>(this)->setProxyNormSet(nset) ;
502 }
503
504 return nintChanged ;
505 }
506
507 // Update dataset pointers of proxies
508 if (adjustProxies) {
509 const_cast<RooAbsPdf*>(this)->setProxyNormSet(nset) ;
510 }
511
512 RooArgSet depList;
513 getObservables(nset, depList);
514
515 if (_verboseEval>0) {
516 if (!selfNormalized()) {
517 cxcoutD(Tracing) << ClassName() << "::syncNormalization(" << GetName()
518 << ") recreating normalization integral " << endl ;
519 depList.printStream(ccoutD(Tracing),kName|kValue|kArgs,kSingleLine) ;
520 } else {
521 cxcoutD(Tracing) << ClassName() << "::syncNormalization(" << GetName() << ") selfNormalized, creating unit norm" << endl;
522 }
523 }
524
525 // Destroy old normalization & create new
526 if (selfNormalized() || !dependsOn(depList)) {
527 auto ntitle = std::string(GetTitle()) + " Unit Normalization";
528 auto nname = std::string(GetName()) + "_UnitNorm";
529 _norm = new RooRealVar(nname.c_str(),ntitle.c_str(),1) ;
530 } else {
531 const char* nr = (_normRangeOverride.Length()>0 ? _normRangeOverride.Data() : (_normRange.Length()>0 ? _normRange.Data() : nullptr)) ;
532
533// cout << "RooAbsPdf::syncNormalization(" << GetName() << ") rangeName for normalization is " << (nr?nr:"<null>") << endl ;
534 RooAbsReal* normInt;
535 {
536 // Normalization is always over all pdf components. Overriding the global
537 // component selection temporarily makes all RooRealIntegrals created during
538 // that time always include all components.
539 GlobalSelectComponentRAII selCompRAII(true);
540 normInt = std::unique_ptr<RooAbsReal>{createIntegral(depList,*getIntegratorConfig(),nr)}.release();
541 }
542 static_cast<RooRealIntegral*>(normInt)->setAllowComponentSelection(false);
543 normInt->getVal() ;
544// cout << "resulting normInt = " << normInt->GetName() << endl ;
545
546 const char* cacheParamsStr = getStringAttribute("CACHEPARAMINT") ;
547 if (cacheParamsStr && strlen(cacheParamsStr)) {
548
549 std::unique_ptr<RooArgSet> intParams{normInt->getVariables()} ;
550
551 RooArgSet cacheParams = RooHelpers::selectFromArgSet(*intParams, cacheParamsStr);
552
553 if (!cacheParams.empty()) {
554 cxcoutD(Caching) << "RooAbsReal::createIntObj(" << GetName() << ") INFO: constructing " << cacheParams.size()
555 << "-dim value cache for integral over " << depList << " as a function of " << cacheParams << " in range " << (nr?nr:"<default>") << endl ;
556 string name = Form("%s_CACHE_[%s]",normInt->GetName(),cacheParams.contentsString().c_str()) ;
557 RooCachedReal* cachedIntegral = new RooCachedReal(name.c_str(),name.c_str(),*normInt,cacheParams) ;
558 cachedIntegral->setInterpolationOrder(2) ;
559 cachedIntegral->addOwnedComponents(*normInt) ;
560 cachedIntegral->setCacheSource(true) ;
561 if (normInt->operMode()==ADirty) {
562 cachedIntegral->setOperMode(ADirty) ;
563 }
564 normInt= cachedIntegral ;
565 }
566
567 }
568 _norm = normInt ;
569 }
570
571 // Register new normalization with manager (takes ownership)
572 cache = new CacheElem(*_norm) ;
573 _normMgr.setObj(nset,cache) ;
574
575// cout << "making new object " << _norm->GetName() << endl ;
576
577 return true ;
578}
579
580
581
582////////////////////////////////////////////////////////////////////////////////
583/// Reset error counter to given value, limiting the number
584/// of future error messages for this pdf to 'resetValue'
585
587{
588 _errorCount = resetValue ;
589 _negCount = resetValue ;
590}
591
592
593
594////////////////////////////////////////////////////////////////////////////////
595/// Reset trace counter to given value, limiting the
596/// number of future trace messages for this pdf to 'value'
597
599{
600 if (!allNodes) {
602 return ;
603 } else {
604 RooArgList branchList ;
605 branchNodeServerList(&branchList) ;
606 for(auto * pdf : dynamic_range_cast<RooAbsPdf*>(branchList)) {
607 if (pdf) pdf->setTraceCounter(value,false) ;
608 }
609 }
610
611}
612
613
614
615
616////////////////////////////////////////////////////////////////////////////////
617/// Return the log of the current value with given normalization
618/// An error message is printed if the argument of the log is negative.
619
620double RooAbsPdf::getLogVal(const RooArgSet* nset) const
621{
622 return getLog(getVal(nset), this);
623}
624
625
626////////////////////////////////////////////////////////////////////////////////
627/// Check for infinity or NaN.
628/// \param[in] inputs Array to check
629/// \return True if either infinity or NaN were found.
630namespace {
631template<class T>
632bool checkInfNaNNeg(const T& inputs) {
633 // check for a math error or negative value
634 bool inf = false;
635 bool nan = false;
636 bool neg = false;
637
638 for (double val : inputs) { //CHECK_VECTORISE
639 inf |= !std::isfinite(val);
640 nan |= TMath::IsNaN(val); // Works also during fast math
641 neg |= val < 0;
642 }
643
644 return inf || nan || neg;
645}
646}
647
648
649////////////////////////////////////////////////////////////////////////////////
650/// Scan through outputs and fix+log all nans and negative values.
651/// \param[in,out] outputs Array to be scanned & fixed.
652/// \param[in] begin Begin of event range. Only needed to print the correct event number
653/// where the error occurred.
654void RooAbsPdf::logBatchComputationErrors(std::span<const double>& outputs, std::size_t begin) const {
655 for (unsigned int i=0; i<outputs.size(); ++i) {
656 const double value = outputs[i];
657 if (TMath::IsNaN(outputs[i])) {
658 logEvalError(Form("p.d.f value of (%s) is Not-a-Number (%f) for entry %zu",
659 GetName(), value, begin+i));
660 } else if (!std::isfinite(outputs[i])){
661 logEvalError(Form("p.d.f value of (%s) is (%f) for entry %zu",
662 GetName(), value, begin+i));
663 } else if (outputs[i] < 0.) {
664 logEvalError(Form("p.d.f value of (%s) is less than zero (%f) for entry %zu",
665 GetName(), value, begin+i));
666 }
667 }
668}
669
670
671void RooAbsPdf::getLogProbabilities(std::span<const double> pdfValues, double * output) const {
672 for (std::size_t i = 0; i < pdfValues.size(); ++i) {
673 output[i] = getLog(pdfValues[i], this);
674 }
675}
676
677////////////////////////////////////////////////////////////////////////////////
678/// Return the extended likelihood term (\f$ N_\mathrm{expect} - N_\mathrm{observed} \cdot \log(N_\mathrm{expect} \f$)
679/// of this PDF for the given number of observed events.
680///
681/// For successful operation, the PDF implementation must indicate that
682/// it is extendable by overloading `canBeExtended()`, and must
683/// implement the `expectedEvents()` function.
684///
685/// \param[in] sumEntries The number of observed events.
686/// \param[in] nset The normalization set when asking the pdf for the expected
687/// number of events.
688/// \param[in] observedSumW2 The number of observed events when weighting with
689/// squared weights. If non-zero, the weight-squared error
690/// correction is applied to the extended term.
691/// \param[in] doOffset Offset the extended term by a counterterm where the
692/// expected number of events equals the observed number of events.
693/// This constant shift results in a term closer to zero that is
694/// approximately chi-square distributed. It is useful to do this
695/// also when summing multiple NLL terms to avoid numeric precision
696/// loss that happens if you sum multiple terms of different orders
697/// of magnitude.
698///
699/// The weight-squared error correction works as follows:
700/// adjust poisson such that
701/// estimate of \f$N_\mathrm{expect}\f$ stays at the same value, but has a different variance, rescale
702/// both the observed and expected count of the Poisson with a factor \f$ \sum w_{i} / \sum w_{i}^2 \f$
703/// (the effective weight of the Poisson term),
704/// i.e., change \f$\mathrm{Poisson}(N_\mathrm{observed} = \sum w_{i} | N_\mathrm{expect} )\f$
705/// to \f$ \mathrm{Poisson}(\sum w_{i} \cdot \sum w_{i} / \sum w_{i}^2 | N_\mathrm{expect} \cdot \sum w_{i} / \sum w_{i}^2 ) \f$,
706/// weighted by the effective weight \f$ \sum w_{i}^2 / \sum w_{i} \f$ in the likelihood.
707/// Since here we compute the likelihood with the weight square, we need to multiply by the
708/// square of the effective weight:
709/// - \f$ W_\mathrm{expect} = N_\mathrm{expect} \cdot \sum w_{i} / \sum w_{i}^2 \f$ : effective expected entries
710/// - \f$ W_\mathrm{observed} = \sum w_{i} \cdot \sum w_{i} / \sum w_{i}^2 \f$ : effective observed entries
711///
712/// The extended term for the likelihood weighted by the square of the weight will be then:
713///
714/// \f$ \left(\sum w_{i}^2 / \sum w_{i}\right)^2 \cdot W_\mathrm{expect} - (\sum w_{i}^2 / \sum w_{i})^2 \cdot W_\mathrm{observed} \cdot \log{W_\mathrm{expect}} \f$
715///
716/// aund this is using the previous expressions for \f$ W_\mathrm{expect} \f$ and \f$ W_\mathrm{observed} \f$:
717///
718/// \f$ \sum w_{i}^2 / \sum w_{i} \cdot N_\mathrm{expect} - \sum w_{i}^2 \cdot \log{W_\mathrm{expect}} \f$
719///
720/// Since the weights are constants in the likelihood we can use \f$\log{N_\mathrm{expect}}\f$ instead of \f$\log{W_\mathrm{expect}}\f$.
721///
722/// See also RooAbsPdf::extendedTerm(RooAbsData const& data, bool weightSquared, bool doOffset),
723/// which takes a dataset to extract \f$N_\mathrm{observed}\f$ and the
724/// normalization set.
725double RooAbsPdf::extendedTerm(double sumEntries, RooArgSet const* nset, double sumEntriesW2, bool doOffset) const
726{
727 return extendedTerm(sumEntries, expectedEvents(nset), sumEntriesW2, doOffset);
728}
729
730double RooAbsPdf::extendedTerm(double sumEntries, double expected, double sumEntriesW2, bool doOffset) const
731{
732 // check if this PDF supports extended maximum likelihood fits
733 if(!canBeExtended()) {
734 coutE(InputArguments) << GetName() << ": this PDF does not support extended maximum likelihood"
735 << std::endl;
736 return 0.0;
737 }
738
739 if(expected < 0.0) {
740 coutE(InputArguments) << GetName() << ": calculated negative expected events: " << expected
741 << std::endl;
742 logEvalError("extendedTerm #expected events is <0 return a NaN");
743 return TMath::QuietNaN();
744 }
745
746
747 // Explicitly handle case Nobs=Nexp=0
748 if (std::abs(expected)<1e-10 && std::abs(sumEntries)<1e-10) {
749 return 0.0;
750 }
751
752 // Check for errors in Nexpected
753 if (TMath::IsNaN(expected)) {
754 logEvalError("extendedTerm #expected events is a NaN") ;
755 return TMath::QuietNaN() ;
756 }
757
758 double extra = doOffset
759 ? (expected - sumEntries) - sumEntries * (std::log(expected) - std::log(sumEntries))
760 : expected - sumEntries * std::log(expected);
761
762 if(sumEntriesW2 != 0.0) {
763 extra *= sumEntriesW2 / sumEntries;
764 }
765
766 return extra;
767}
768
769////////////////////////////////////////////////////////////////////////////////
770/// Return the extended likelihood term (\f$ N_\mathrm{expect} - N_\mathrm{observed} \cdot \log(N_\mathrm{expect} \f$)
771/// of this PDF for the given number of observed events.
772///
773/// This function is a wrapper around
774/// RooAbsPdf::extendedTerm(double, RooArgSet const *, double, bool) const,
775/// where the number of observed events and observables to be used as the
776/// normalization set for the pdf is extracted from a RooAbsData.
777///
778/// For successful operation, the PDF implementation must indicate that
779/// it is extendable by overloading `canBeExtended()`, and must
780/// implement the `expectedEvents()` function.
781///
782/// \param[in] data The RooAbsData to retrieve the set of observables and
783/// number of expected events.
784/// \param[in] weightSquared If set to `true`, the extended term will be scaled by
785/// the ratio of squared event weights over event weights:
786/// \f$ \sum w_{i}^2 / \sum w_{i} \f$.
787/// Intended to be used by fits with the `SumW2Error()` option that
788/// can be passed to RooAbsPdf::fitTo()
789/// (see the documentation of said function to learn more about the
790/// interpretation of fits with squared weights).
791/// \param[in] doOffset See RooAbsPdf::extendedTerm(double, RooArgSet const*, double, bool) const.
792
793double RooAbsPdf::extendedTerm(RooAbsData const& data, bool weightSquared, bool doOffset) const {
794 double sumW = data.sumEntries();
795 double sumW2 = 0.0;
796 if (weightSquared) {
797 sumW2 = data.sumEntriesW2();
798 }
799 return extendedTerm(sumW, data.get(), sumW2, doOffset);
800}
801
802
803/** @fn RooAbsPdf::createNLL()
804 *
805 * @brief Construct representation of -log(L) of PDF with given dataset.
806 *
807 * If dataset is unbinned, an unbinned likelihood is constructed.
808 * If the dataset is binned, a binned likelihood is constructed.
809 *
810 * @param data Reference to a RooAbsData object representing the dataset.
811 * @param cmdArgs Variadic template arguments representing optional command arguments.
812 * You can pass either an arbitrary number of RooCmdArg instances
813 * or a single RooLinkedList that points to the RooCmdArg objects.
814 * @return An owning pointer to the created RooAbsReal NLL object.
815 *
816 * @tparam CmdArgs_t Template types for optional command arguments.
817 * Can either be an arbitrary number of RooCmdArg or a single RooLinkedList.
818 *
819 * \note This front-end function should not be re-implemented in derived PDF types.
820 * If you mean to customize the NLL creation routine,
821 * you need to override the virtual RooAbsPdf::createNLLImpl() method.
822 *
823 * The following named arguments are supported:
824 *
825 * <table>
826 * <tr><th> Type of CmdArg <th> Effect on NLL
827 * <tr><td> `ConditionalObservables(Args_t &&... argsOrArgSet)` <td> Do not normalize PDF over listed observables.
828 * Arguments can either be multiple RooRealVar or a single RooArgSet containing them.
829 * <tr><td> `Extended(bool flag)` <td> Add extended likelihood term, off by default.
830 * <tr><td> `Range(const char* name)` <td> Fit only data inside range with given name. Multiple comma-separated range names can be specified.
831 * In this case, the unnormalized PDF \f$f(x)\f$ is normalized by the integral over all ranges \f$r_i\f$:
832 * \f[
833 * p(x) = \frac{f(x)}{\sum_i \int_{r_i} f(x) dx}.
834 * \f]
835 * <tr><td> `Range(double lo, double hi)` <td> Fit only data inside given range. A range named "fit" is created on the fly on all observables.
836 * <tr><td> `SumCoefRange(const char* name)` <td> Set the range in which to interpret the coefficients of RooAddPdf components
837 * <tr><td> `NumCPU(int num, int istrat)` <td> Parallelize NLL calculation on num CPUs
838 * <table>
839 * <tr><th> Strategy <th> Effect
840 * <tr><td> 0 = RooFit::BulkPartition - *default* <td> Divide events in N equal chunks
841 * <tr><td> 1 = RooFit::Interleave <td> Process event i%N in process N. Recommended for binned data with
842 * a substantial number of zero-bins, which will be distributed across processes more equitably in this strategy
843 * <tr><td> 2 = RooFit::SimComponents <td> Process each component likelihood of a RooSimultaneous fully in a single process
844 * and distribute components over processes. This approach can be beneficial if normalization calculation time
845 * dominates the total computation time of a component (since the normalization calculation must be performed
846 * in each process in strategies 0 and 1. However beware that if the RooSimultaneous components do not share many
847 * parameters this strategy is inefficient: as most minuit-induced likelihood calculations involve changing
848 * a single parameter, only 1 of the N processes will be active most of the time if RooSimultaneous components
849 * do not share many parameters
850 * <tr><td> 3 = RooFit::Hybrid <td> Follow strategy 0 for all RooSimultaneous components, except those with less than
851 * 30 dataset entries, for which strategy 2 is followed.
852 * </table>
853 * <tr><td> `EvalBackend(std::string const&)` <td> Choose a likelihood evaluation backend:
854 * <table>
855 * <tr><th> Backend <th> Description
856 * <tr><td> **cpu** - *default* <td> New vectorized evaluation mode, using faster math functions and auto-vectorisation.
857 * Since ROOT 6.23, this is the default if `EvalBackend()` is not passed, succeeding the **legacy** backend.
858 * If all RooAbsArg objects in the model support vectorized evaluation,
859 * likelihood computations are 2 to 10 times faster than with the **legacy** backend
860 * - unless your dataset is so small that the vectorization is not worth it.
861 * The relative difference of the single log-likelihoods with respect to the legacy mode is usually better than \f$10^{-12}\f$,
862 * and for fit parameters it's usually better than \f$10^{-6}\f$. In past ROOT releases, this backend could be activated with the now deprecated `BatchMode()` option.
863 * <tr><td> **cuda** <td> Evaluate the likelihood on a GPU that supports CUDA.
864 * This backend re-uses code from the **cpu** backend, but compiled in CUDA kernels.
865 * Hence, the results are expected to be identical, modulo some numerical differences that can arise from the different order in which the GPU is summing the log probabilities.
866 * This backend can drastically speed up the fit if all RooAbsArg object in the model support it.
867 * <tr><td> **legacy** <td> The original likelihood evaluation method.
868 * Evaluates the PDF for each single data entry at a time before summing the negative log probabilities.
869 * <tr><td> **codegen** <td> **Experimental** - Generates and compiles minimal C++ code for the NLL on-the-fly and wraps it in the returned RooAbsReal.
870 * Also generates and compiles the code for the gradient using Automatic Differentiation (AD) with [Clad](https://github.com/vgvassilev/clad).
871 * This analytic gradient is passed to the minimizer, which can result in significant speedups for many-parameter fits,
872 * even compared to the **cpu** backend. However, if one of the RooAbsArg objects in the model does not support the code generation,
873 * this backend can't be used.
874 * <tr><td> **codegen_no_grad** <td> **Experimental** - Same as **codegen**, but doesn't generate and compile the gradient code and use the regular numerical differentiation instead.
875 * This is expected to be slower, but useful for debugging problems with the analytic gradient.
876 * </table>
877 * <tr><td> `Optimize(bool flag)` <td> Activate constant term optimization (on by default)
878 * <tr><td> `SplitRange(bool flag)` <td> Use separate fit ranges in a simultaneous fit. Actual range name for each subsample is assumed to
879 * be `rangeName_indexState`, where `indexState` is the state of the master index category of the simultaneous fit.
880 * Using `Range("range"), SplitRange()` as switches, different ranges could be set like this:
881 * ```
882 * myVariable.setRange("range_pi0", 135, 210);
883 * myVariable.setRange("range_gamma", 50, 210);
884 * ```
885 * <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
886 * term of the product depends on parameters but not on the observable(s),), only apply constraints to the given subset of parameters.
887 * <tr><td> `ExternalConstraints(const RooArgSet& )` <td> Include given external constraints to likelihood by multiplying them with the original likelihood.
888 * <tr><td> `GlobalObservables(const RooArgSet&)` <td> Define the set of normalization observables to be used for the constraint terms.
889 * If none are specified the constrained parameters are used.
890 * <tr><td> `GlobalObservablesSource(const char* sourceName)` <td> Which source to prioritize for global observable values.
891 * Can be either:
892 * - `data`: to take the values from the dataset,
893 * falling back to the pdf value if a given global observable is not available.
894 * If no `GlobalObservables` or `GlobalObservablesTag` command argument is given, the set
895 * of global observables will be automatically defined to be the set stored in the data.
896 * - `model`: to take all values from the pdf and completely ignore the set of global observables stored in the data
897 * (not even using it to automatically define the set of global observables
898 * if the `GlobalObservables` or `GlobalObservablesTag` command arguments are not given).
899 * The default option is `data`.
900 * <tr><td> `GlobalObservablesTag(const char* tagName)` <td> Define the set of normalization observables to be used for the constraint terms by
901 * a string attribute associated with pdf observables that match the given tagName.
902 * <tr><td> `Verbose(bool flag)` <td> Controls RooFit informational messages in likelihood construction
903 * <tr><td> `CloneData(bool flag)` <td> Use clone of dataset in NLL (default is true).
904 * \warning Deprecated option that is ignored. It is up to the implementation of the NLL creation method if the data is cloned or not.
905 * <tr><td> `Offset(std::string const& mode)` <td> Likelihood offsetting mode. Can be either:
906 * <table>
907 * <tr><th> Mode <th> Description
908 * <tr><td> **none** - *default* <td> No offsetting.
909 * <tr><td> **initial** <td> Offset likelihood by initial value (so that starting value of FCN in minuit is zero).
910 * This can improve numeric stability in simultaneous fits with components with large likelihood values.
911 * <tr><td> **bin** <td> Offset likelihood bin-by-bin with a template histogram model based on the obersved data.
912 * This results in per-bin values that are all in the same order of magnitude, which reduces precision loss in the sum,
913 * which can drastically improve numeric stability.
914 * Furthermore, \f$2\cdot \text{NLL}\f$ defined like this is approximately chi-square distributed, allowing for goodness-of-fit tests.
915 * </table>
916 * <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.
917 * This can reduce the bias observed when fitting functions with high curvature to binned data.
918 * - precision > 0: Activate bin integration everywhere. Use precision between 0.01 and 1.E-6, depending on binning.
919 * 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
920 * integration step. If lower precision is desired (more speed), a RooBinSamplingPdf has to be created manually, and its integrator
921 * has to be manipulated directly.
922 * - precision = 0: Activate bin integration only for continuous PDFs fit to a RooDataHist.
923 * - precision < 0: Deactivate.
924 * \see RooBinSamplingPdf
925 * <tr><td> `ModularL(bool flag)` <td> Enable or disable modular likelihoods, which will become the default in a future release.
926 * This does not change any user-facing code, but only enables a different likelihood class in the back-end. Note that this
927 * should be set to true for parallel minimization of likelihoods!
928 * Note that it is currently not recommended to use Modular likelihoods without any parallelization enabled in the minimization, since
929 * some features such as offsetting might not yet work in this case.
930 * </table>
931 */
932
933
934/** @brief Protected implementation of the NLL creation routine.
935 *
936 * This virtual function can be overridden in case you want to change the NLL creation logic for custom PDFs.
937 *
938 * \note Never call this function directly. Instead, call RooAbsPdf::createNLL().
939 */
940
941std::unique_ptr<RooAbsReal> RooAbsPdf::createNLLImpl(RooAbsData &data, const RooLinkedList &cmdList)
942{
943 return RooFit::FitHelpers::createNLL(*this, data, cmdList);
944}
945
946
947/** @fn RooAbsPdf::fitTo()
948 *
949 * @brief Fit PDF to given dataset.
950 *
951 * If dataset is unbinned, an unbinned maximum likelihood is performed.
952 * If the dataset is binned, a binned maximum likelihood is performed.
953 * By default the fit is executed through the MINUIT commands MIGRAD, HESSE in succession.
954 *
955 * @param data Reference to a RooAbsData object representing the dataset.
956 * @param cmdArgs Variadic template arguments representing optional command arguments.
957 * You can pass either an arbitrary number of RooCmdArg instances
958 * or a single RooLinkedList that points to the RooCmdArg objects.
959 * @return An owning pointer to the created RooAbsReal NLL object.
960 * @return RooFitResult with fit status and parameters if option Save() is used, `nullptr` otherwise. The user takes ownership of the fit result.
961 *
962 * @tparam CmdArgs_t Template types for optional command arguments.
963 * Can either be an arbitrary number of RooCmdArg or a single RooLinkedList.
964 *
965 * \note This front-end function should not be re-implemented in derived PDF types.
966 * If you mean to customize the likelihood fitting routine,
967 * you need to override the virtual RooAbsPdf::fitToImpl() method.
968 *
969 * The following named arguments are supported:
970 *
971 * <table>
972 * <tr><th> Type of CmdArg <th> Options to control construction of -log(L)
973 * <tr><td> <td> All command arguments that can also be passed to the NLL creation method.
974 * \see RooAbsPdf::createNLL()
975 *
976 * <tr><th><th> Options to control flow of fit procedure
977 * <tr><td> `Minimizer("<type>", "<algo>")` <td> Choose minimization package and optionally the algorithm to use. Default is MINUIT/MIGRAD through the RooMinimizer interface,
978 * but others can be specified (through RooMinimizer interface).
979 * <table>
980 * <tr><th> Type <th> Algorithm
981 * <tr><td> Minuit <td> migrad, simplex, minimize (=migrad+simplex), migradimproved (=migrad+improve)
982 * <tr><td> Minuit2 <td> migrad, simplex, minimize, scan
983 * <tr><td> GSLMultiMin <td> conjugatefr, conjugatepr, bfgs, bfgs2, steepestdescent
984 * <tr><td> GSLSimAn <td> -
985 * </table>
986 *
987 * <tr><td> `InitialHesse(bool flag)` <td> Flag controls if HESSE before MIGRAD as well, off by default
988 * <tr><td> `Optimize(bool flag)` <td> Activate constant term optimization of test statistic during minimization (on by default)
989 * <tr><td> `Hesse(bool flag)` <td> Flag controls if HESSE is run after MIGRAD, on by default
990 * <tr><td> `Minos(bool flag)` <td> Flag controls if MINOS is run after HESSE, off by default
991 * <tr><td> `Minos(const RooArgSet& set)` <td> Only run MINOS on given subset of arguments
992 * <tr><td> `Save(bool flag)` <td> Flag controls if RooFitResult object is produced and returned, off by default
993 * <tr><td> `Strategy(Int_t flag)` <td> Set Minuit strategy (0 to 2, default is 1)
994 * <tr><td> `MaxCalls(int n)` <td> Change maximum number of likelihood function calls from MINUIT (if `n <= 0`, the default of 500 * #%parameters is used)
995 * <tr><td> `EvalErrorWall(bool flag=true)` <td> When parameters are in disallowed regions (e.g. PDF is negative), return very high value to fitter
996 * to force it out of that region. This can, however, mean that the fitter gets lost in this region. If
997 * this happens, try switching it off.
998 * <tr><td> `RecoverFromUndefinedRegions(double strength)` <td> When PDF is invalid (e.g. parameter in undefined region), try to direct minimiser away from that region.
999 * `strength` controls the magnitude of the penalty term. Leaving out this argument defaults to 10. Switch off with `strength = 0.`.
1000 *
1001 * <tr><td> `SumW2Error(bool flag)` <td> Apply correction to errors and covariance matrix.
1002 * This uses two covariance matrices, one with the weights, the other with squared weights,
1003 * to obtain the correct errors for weighted likelihood fits. If this option is activated, the
1004 * corrected covariance matrix is calculated as \f$ V_\mathrm{corr} = V C^{-1} V \f$, where \f$ V \f$ is the original
1005 * covariance matrix and \f$ C \f$ is the inverse of the covariance matrix calculated using the
1006 * squared weights. This allows to switch between two interpretations of errors:
1007 * <table>
1008 * <tr><th> SumW2Error <th> Interpretation
1009 * <tr><td> true <td> The errors reflect the uncertainty of the Monte Carlo simulation.
1010 * Use this if you want to know how much accuracy you can get from the available Monte Carlo statistics.
1011 *
1012 * **Example**: Simulation with 1000 events, the average weight is 0.1.
1013 * The errors are as big as if one fitted to 1000 events.
1014 * <tr><td> false <td> The errors reflect the errors of a dataset, which is as big as the sum of weights.
1015 * Use this if you want to know what statistical errors you would get if you had a dataset with as many
1016 * events as the (weighted) Monte Carlo simulation represents.
1017 *
1018 * **Example** (Data as above):
1019 * The errors are as big as if one fitted to 100 events.
1020 * </table>
1021 * \note If the `SumW2Error` correction is enabled, the covariance matrix quality stored in the RooFitResult
1022 * object will be the minimum of the original covariance matrix quality and the quality of the covariance
1023 * matrix calculated with the squared weights.
1024 * <tr><td> `AsymptoticError()` <td> Use the asymptotically correct approach to estimate errors in the presence of weights.
1025 * This is slower but more accurate than `SumW2Error`. See also https://arxiv.org/abs/1911.01303).
1026 This option even correctly implements the case of extended likelihood fits
1027 (see this [writeup on extended weighted fits](https://root.cern/files/extended_weighted_fits.pdf) that complements the paper linked before).
1028 * <tr><td> `PrefitDataFraction(double fraction)`
1029 * <td> Runs a prefit on a small dataset of size fraction*(actual data size). This can speed up fits
1030 * by finding good starting values for the parameters for the actual fit.
1031 * \warning Prefitting may give bad results when used in binned analysis.
1032 *
1033 * <tr><th><th> Options to control informational output
1034 * <tr><td> `Verbose(bool flag)` <td> Flag controls if verbose output is printed (NLL, parameter changes during fit).
1035 * <tr><td> `Timer(bool flag)` <td> Time CPU and wall clock consumption of fit steps, off by default.
1036 * <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.
1037 * See RooMinimizer::PrintLevel for the meaning of the levels.
1038 * <tr><td> `Warnings(bool flag)` <td> Enable or disable MINUIT warnings (enabled by default)
1039 * <tr><td> `PrintEvalErrors(Int_t numErr)` <td> Control number of p.d.f evaluation errors printed per likelihood evaluation.
1040 * A negative value suppresses output completely, a zero value will only print the error count per p.d.f component,
1041 * a positive value will print details of each error up to `numErr` messages per p.d.f component.
1042 * <tr><td> `Parallelize(Int_t nWorkers)` <td> Control global parallelization settings. Arguments 1 and above enable the use of RooFit's parallel minimization
1043 * backend and uses the number given as the number of workers to use in the parallelization. -1 also enables
1044 * RooFit's parallel minimization backend, and sets the number of workers to the number of available processes.
1045 * 0 disables this feature.
1046 * In case parallelization is requested, this option implies `ModularL(true)` in the internal call to the NLL creation method.
1047 * <tr><td> `ParallelGradientOptions(bool enable=true, int orderStrategy=0, int chainFactor=1)` <td> **Experimental** - Control gradient parallelization settings. The first argument
1048 * only disables or enables gradient parallelization, this is on by default.
1049 * The second argument determines the internal partial derivative calculation
1050 * ordering strategy. The third argument determines the number of partial
1051 * derivatives that are executed per task package on each worker.
1052 * <tr><td> `ParallelDescentOptions(bool enable=false, int splitStrategy=0, int numSplits=4)` <td> **Experimental** - Control settings related to the parallelization of likelihoods
1053 * outside of the gradient calculation but in the minimization, most prominently
1054 * in the linesearch step. The first argument this disables or enables likelihood
1055 * parallelization. The second argument determines whether to split the task batches
1056 * per event or per likelihood component. And the third argument how many events or
1057 * respectively components to include in each batch.
1058 * <tr><td> `TimingAnalysis(bool flag)` <td> **Experimental** - Log timings. This feature logs timings with NewStyle likelihoods on multiple processes simultaneously
1059 * and outputs the timings at the end of a run to json log files, which can be analyzed with the
1060 * `RooFit::MultiProcess::HeatmapAnalyzer`. Only works with simultaneous likelihoods.
1061 * </table>
1062 */
1063
1064
1065/** @brief Protected implementation of the likelihood fitting routine.
1066 *
1067 * This virtual function can be overridden in case you want to change the likelihood fitting logic for custom PDFs.
1068 *
1069 * \note Never call this function directly. Instead, call RooAbsPdf::fitTo().
1070 */
1071
1072std::unique_ptr<RooFitResult> RooAbsPdf::fitToImpl(RooAbsData& data, const RooLinkedList& cmdList)
1073{
1074 return RooFit::FitHelpers::fitTo(*this, data, cmdList, false);
1075}
1076
1077
1078////////////////////////////////////////////////////////////////////////////////
1079/// Print value of p.d.f, also print normalization integral that was last used, if any
1080
1081void RooAbsPdf::printValue(ostream& os) const
1082{
1083 // silent warning messages coming when evaluating a RooAddPdf without a normalization set
1085
1086 getVal() ;
1087
1088 if (_norm) {
1089 os << getVal() << "/" << _norm->getVal() ;
1090 } else {
1091 os << getVal();
1092 }
1093}
1094
1095
1096
1097////////////////////////////////////////////////////////////////////////////////
1098/// Print multi line detailed information of this RooAbsPdf
1099
1100void RooAbsPdf::printMultiline(ostream& os, Int_t contents, bool verbose, TString indent) const
1101{
1102 RooAbsReal::printMultiline(os,contents,verbose,indent);
1103 os << indent << "--- RooAbsPdf ---" << endl;
1104 os << indent << "Cached value = " << _value << endl ;
1105 if (_norm) {
1106 os << indent << " Normalization integral: " << endl ;
1107 auto moreIndent = std::string(indent.Data()) + " " ;
1108 _norm->printStream(os,kName|kAddress|kTitle|kValue|kArgs,kSingleLine,moreIndent.c_str()) ;
1109 }
1110}
1111
1112
1113
1114////////////////////////////////////////////////////////////////////////////////
1115/// Return a binned generator context
1116
1118{
1119 return new RooBinnedGenContext(*this,vars,nullptr,nullptr,verbose) ;
1120}
1121
1122
1123////////////////////////////////////////////////////////////////////////////////
1124/// Interface function to create a generator context from a p.d.f. This default
1125/// implementation returns a 'standard' context that works for any p.d.f
1126
1128 const RooArgSet* auxProto, bool verbose) const
1129{
1130 return new RooGenContext(*this,vars,prototype,auxProto,verbose) ;
1131}
1132
1133
1134////////////////////////////////////////////////////////////////////////////////
1135
1136RooAbsGenContext* RooAbsPdf::autoGenContext(const RooArgSet &vars, const RooDataSet* prototype, const RooArgSet* auxProto,
1137 bool verbose, bool autoBinned, const char* binnedTag) const
1138{
1139 if (prototype || (auxProto && !auxProto->empty())) {
1140 return genContext(vars,prototype,auxProto,verbose);
1141 }
1142
1143 RooAbsGenContext *context(nullptr) ;
1144 if ( (autoBinned && isBinnedDistribution(vars)) || ( binnedTag && strlen(binnedTag) && (getAttribute(binnedTag)||string(binnedTag)=="*"))) {
1145 context = binnedGenContext(vars,verbose) ;
1146 } else {
1147 context= genContext(vars,nullptr,nullptr,verbose);
1148 }
1149 return context ;
1150}
1151
1152
1153
1154////////////////////////////////////////////////////////////////////////////////
1155/// Generate a new dataset containing the specified variables with events sampled from our distribution.
1156/// Generate the specified number of events or expectedEvents() if not specified.
1157/// \param[in] whatVars Choose variables in which to generate events. Variables not listed here will remain
1158/// constant and not be used for event generation.
1159/// \param[in] arg1,arg2,arg3,arg4,arg5,arg6 Optional RooCmdArg() to change behaviour of generate().
1160/// \return RooDataSet *, owned by caller.
1161///
1162/// Any variables of this PDF that are not in whatVars will use their
1163/// current values and be treated as fixed parameters. Returns zero
1164/// in case of an error.
1165///
1166/// <table>
1167/// <tr><th> Type of CmdArg <th> Effect on generate
1168/// <tr><td> `Name(const char* name)` <td> Name of the output dataset
1169/// <tr><td> `Verbose(bool flag)` <td> Print informational messages during event generation
1170/// <tr><td> `NumEvents(int nevt)` <td> Generate specified number of events
1171/// <tr><td> `Extended()` <td> If no number of events to be generated is given,
1172/// use expected number of events from extended likelihood term.
1173/// This evidently only works for extended PDFs.
1174/// <tr><td> `GenBinned(const char* tag)` <td> Use binned generation for all component pdfs that have 'setAttribute(tag)' set
1175/// <tr><td> `AutoBinned(bool flag)` <td> Automatically deploy binned generation for binned distributions (e.g. RooHistPdf, sums and products of
1176/// RooHistPdfs etc)
1177/// \note Datasets that are generated in binned mode are returned as weighted unbinned datasets. This means that
1178/// for each bin, there will be one event in the dataset with a weight corresponding to the (possibly randomised) bin content.
1179///
1180///
1181/// <tr><td> `AllBinned()` <td> As above, but for all components.
1182/// \note The notion of components is only meaningful for simultaneous PDFs
1183/// as binned generation is always executed at the top-level node for a regular
1184/// PDF, so for those it only mattes that the top-level node is tagged.
1185///
1186/// <tr><td> ProtoData(const RooDataSet& data, bool randOrder)
1187/// <td> Use specified dataset as prototype dataset. If randOrder in ProtoData() is set to true,
1188/// the order of the events in the dataset will be read in a random order if the requested
1189/// number of events to be generated does not match the number of events in the prototype dataset.
1190/// \note If ProtoData() is used, the specified existing dataset as a prototype: the new dataset will contain
1191/// the same number of events as the prototype (unless otherwise specified), and any prototype variables not in
1192/// whatVars will be copied into the new dataset for each generated event and also used to set our PDF parameters.
1193/// The user can specify a number of events to generate that will override the default. The result is a
1194/// copy of the prototype dataset with only variables in whatVars randomized. Variables in whatVars that
1195/// are not in the prototype will be added as new columns to the generated dataset.
1196///
1197/// </table>
1198///
1199/// #### Accessing the underlying event generator
1200/// Depending on the fit model (if it is difficult to sample), it may be necessary to change generator settings.
1201/// For the default generator (RooFoamGenerator), the number of samples or cells could be increased by e.g. using
1202/// myPdf->specialGeneratorConfig()->getConfigSection("RooFoamGenerator").setRealValue("nSample",1e4);
1203///
1204/// The foam generator e.g. has the following config options:
1205/// - nCell[123N]D
1206/// - nSample
1207/// - chatLevel
1208/// \see rf902_numgenconfig.C
1209
1211 const RooCmdArg& arg3,const RooCmdArg& arg4, const RooCmdArg& arg5,const RooCmdArg& arg6)
1212{
1213 // Select the pdf-specific commands
1214 RooCmdConfig pc("RooAbsPdf::generate(" + std::string(GetName()) + ")");
1215 pc.defineObject("proto","PrototypeData",0,nullptr) ;
1216 pc.defineString("dsetName","Name",0,"") ;
1217 pc.defineInt("randProto","PrototypeData",0,0) ;
1218 pc.defineInt("resampleProto","PrototypeData",1,0) ;
1219 pc.defineInt("verbose","Verbose",0,0) ;
1220 pc.defineInt("extended","Extended",0,0) ;
1221 pc.defineInt("nEvents","NumEvents",0,0) ;
1222 pc.defineInt("autoBinned","AutoBinned",0,1) ;
1223 pc.defineInt("expectedData","ExpectedData",0,0) ;
1224 pc.defineDouble("nEventsD","NumEventsD",0,-1.) ;
1225 pc.defineString("binnedTag","GenBinned",0,"") ;
1226 pc.defineMutex("GenBinned","ProtoData") ;
1227 pc.defineMutex("Extended", "NumEvents");
1228
1229 // Process and check varargs
1230 pc.process(arg1,arg2,arg3,arg4,arg5,arg6) ;
1231 if (!pc.ok(true)) {
1232 return nullptr;
1233 }
1234
1235 // Decode command line arguments
1236 RooDataSet* protoData = static_cast<RooDataSet*>(pc.getObject("proto",nullptr)) ;
1237 const char* dsetName = pc.getString("dsetName") ;
1238 bool verbose = pc.getInt("verbose") ;
1239 bool randProto = pc.getInt("randProto") ;
1240 bool resampleProto = pc.getInt("resampleProto") ;
1241 bool extended = pc.getInt("extended") ;
1242 bool autoBinned = pc.getInt("autoBinned") ;
1243 const char* binnedTag = pc.getString("binnedTag") ;
1244 Int_t nEventsI = pc.getInt("nEvents") ;
1245 double nEventsD = pc.getInt("nEventsD") ;
1246 //bool verbose = pc.getInt("verbose") ;
1247 bool expectedData = pc.getInt("expectedData") ;
1248
1249 double nEvents = (nEventsD>0) ? nEventsD : double(nEventsI);
1250
1251 // Force binned mode for expected data mode
1252 if (expectedData) {
1253 binnedTag="*" ;
1254 }
1255
1256 if (extended) {
1257 if (nEvents == 0) nEvents = expectedEvents(&whatVars);
1258 } else if (nEvents==0) {
1259 cxcoutI(Generation) << "No number of events specified , number of events generated is "
1260 << GetName() << "::expectedEvents() = " << expectedEvents(&whatVars)<< endl ;
1261 }
1262
1263 if (extended && protoData && !randProto) {
1264 cxcoutI(Generation) << "WARNING Using generator option Extended() (Poisson distribution of #events) together "
1265 << "with a prototype dataset implies incomplete sampling or oversampling of proto data. "
1266 << "Set randomize flag in ProtoData() option to randomize prototype dataset order and thus "
1267 << "to randomize the set of over/undersampled prototype events for each generation cycle." << endl ;
1268 }
1269
1270
1271 // Forward to appropriate implementation
1272 std::unique_ptr<RooDataSet> data;
1273 if (protoData) {
1274 data = std::unique_ptr<RooDataSet>{generate(whatVars,*protoData,Int_t(nEvents),verbose,randProto,resampleProto)};
1275 } else {
1276 data = std::unique_ptr<RooDataSet>{generate(whatVars,nEvents,verbose,autoBinned,binnedTag,expectedData, extended)};
1277 }
1278
1279 // Rename dataset to given name if supplied
1280 if (dsetName && strlen(dsetName)>0) {
1281 data->SetName(dsetName) ;
1282 }
1283
1284 return RooFit::makeOwningPtr(std::move(data));
1285}
1286
1287
1288
1289
1290
1291
1292////////////////////////////////////////////////////////////////////////////////
1293/// \note This method does not perform any generation. To generate according to generations specification call RooAbsPdf::generate(RooAbsPdf::GenSpec&) const
1294///
1295/// Details copied from RooAbsPdf::generate():
1296/// --------------------------------------------
1297/// \copydetails RooAbsPdf::generate(const RooArgSet&,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&)
1298
1300 const RooCmdArg& arg1,const RooCmdArg& arg2,
1301 const RooCmdArg& arg3,const RooCmdArg& arg4,
1302 const RooCmdArg& arg5,const RooCmdArg& arg6)
1303{
1304
1305 // Select the pdf-specific commands
1306 RooCmdConfig pc("RooAbsPdf::generate(" + std::string(GetName()) + ")");
1307 pc.defineObject("proto","PrototypeData",0,nullptr) ;
1308 pc.defineString("dsetName","Name",0,"") ;
1309 pc.defineInt("randProto","PrototypeData",0,0) ;
1310 pc.defineInt("resampleProto","PrototypeData",1,0) ;
1311 pc.defineInt("verbose","Verbose",0,0) ;
1312 pc.defineInt("extended","Extended",0,0) ;
1313 pc.defineInt("nEvents","NumEvents",0,0) ;
1314 pc.defineInt("autoBinned","AutoBinned",0,1) ;
1315 pc.defineString("binnedTag","GenBinned",0,"") ;
1316 pc.defineMutex("GenBinned","ProtoData") ;
1317
1318
1319 // Process and check varargs
1320 pc.process(arg1,arg2,arg3,arg4,arg5,arg6) ;
1321 if (!pc.ok(true)) {
1322 return nullptr ;
1323 }
1324
1325 // Decode command line arguments
1326 RooDataSet* protoData = static_cast<RooDataSet*>(pc.getObject("proto",nullptr)) ;
1327 const char* dsetName = pc.getString("dsetName") ;
1328 Int_t nEvents = pc.getInt("nEvents") ;
1329 bool verbose = pc.getInt("verbose") ;
1330 bool randProto = pc.getInt("randProto") ;
1331 bool resampleProto = pc.getInt("resampleProto") ;
1332 bool extended = pc.getInt("extended") ;
1333 bool autoBinned = pc.getInt("autoBinned") ;
1334 const char* binnedTag = pc.getString("binnedTag") ;
1335
1336 RooAbsGenContext* cx = autoGenContext(whatVars,protoData,nullptr,verbose,autoBinned,binnedTag) ;
1337
1338 return new GenSpec(cx,whatVars,protoData,nEvents,extended,randProto,resampleProto,dsetName) ;
1339}
1340
1341
1342////////////////////////////////////////////////////////////////////////////////
1343/// If many identical generation requests
1344/// are needed, e.g. in toy MC studies, it is more efficient to use the prepareMultiGen()/generate()
1345/// combination than calling the standard generate() multiple times as
1346/// initialization overhead is only incurred once.
1347
1349{
1350 //Int_t nEvt = spec._extended ? RooRandom::randomGenerator()->Poisson(spec._nGen) : spec._nGen ;
1351 //Int_t nEvt = spec._extended ? RooRandom::randomGenerator()->Poisson(spec._nGen==0?expectedEvents(spec._whatVars):spec._nGen) : spec._nGen ;
1352 //Int_t nEvt = spec._nGen == 0 ? RooRandom::randomGenerator()->Poisson(expectedEvents(spec._whatVars)) : spec._nGen;
1353
1354 double nEvt = spec._nGen == 0 ? expectedEvents(spec._whatVars) : spec._nGen;
1355
1356 std::unique_ptr<RooDataSet> ret{generate(*spec._genContext,spec._whatVars,spec._protoData, nEvt,false,spec._randProto,spec._resampleProto,
1357 spec._init,spec._extended)};
1358 spec._init = true ;
1359 return RooFit::makeOwningPtr(std::move(ret));
1360}
1361
1362
1363
1364
1365
1366////////////////////////////////////////////////////////////////////////////////
1367/// Generate a new dataset containing the specified variables with
1368/// events sampled from our distribution.
1369///
1370/// \param[in] whatVars Generate a dataset with the variables (and categories) in this set.
1371/// Any variables of this PDF that are not in `whatVars` will use their
1372/// current values and be treated as fixed parameters.
1373/// \param[in] nEvents Generate the specified number of events or else try to use
1374/// expectedEvents() if nEvents <= 0 (default).
1375/// \param[in] verbose Show which generator strategies are being used.
1376/// \param[in] autoBinned If original distribution is binned, return bin centers and randomise weights
1377/// instead of generating single events.
1378/// \param[in] binnedTag
1379/// \param[in] expectedData Call setExpectedData on the genContext.
1380/// \param[in] extended Randomise number of events generated according to Poisson(nEvents). Only useful
1381/// if PDF is extended.
1382/// \return New dataset. Returns zero in case of an error. The caller takes ownership of the returned
1383/// dataset.
1384
1385RooFit::OwningPtr<RooDataSet> RooAbsPdf::generate(const RooArgSet &whatVars, double nEvents, bool verbose, bool autoBinned, const char* binnedTag, bool expectedData, bool extended) const
1386{
1387 if (nEvents==0 && extendMode()==CanNotBeExtended) {
1388 return RooFit::makeOwningPtr(std::make_unique<RooDataSet>("emptyData","emptyData",whatVars));
1389 }
1390
1391 // Request for binned generation
1392 std::unique_ptr<RooAbsGenContext> context{autoGenContext(whatVars,nullptr,nullptr,verbose,autoBinned,binnedTag)};
1393 if (expectedData) {
1394 context->setExpectedData(true) ;
1395 }
1396
1397 std::unique_ptr<RooDataSet> generated;
1398 if(nullptr != context && context->isValid()) {
1399 generated = std::unique_ptr<RooDataSet>{context->generate(nEvents, false, extended)};
1400 }
1401 else {
1402 coutE(Generation) << "RooAbsPdf::generate(" << GetName() << ") cannot create a valid context" << endl;
1403 }
1404 return RooFit::makeOwningPtr(std::move(generated));
1405}
1406
1407
1408
1409
1410////////////////////////////////////////////////////////////////////////////////
1411/// Internal method
1412
1413std::unique_ptr<RooDataSet> RooAbsPdf::generate(RooAbsGenContext& context, const RooArgSet &whatVars, const RooDataSet *prototype,
1414 double nEvents, bool /*verbose*/, bool randProtoOrder, bool resampleProto,
1415 bool skipInit, bool extended) const
1416{
1417 if (nEvents==0 && (prototype==nullptr || prototype->numEntries()==0)) {
1418 return std::make_unique<RooDataSet>("emptyData","emptyData",whatVars);
1419 }
1420
1421 std::unique_ptr<RooDataSet> generated;
1422
1423 // Resampling implies reshuffling in the implementation
1424 if (resampleProto) {
1425 randProtoOrder=true ;
1426 }
1427
1428 if (randProtoOrder && prototype && prototype->numEntries()!=nEvents) {
1429 coutI(Generation) << "RooAbsPdf::generate (Re)randomizing event order in prototype dataset (Nevt=" << nEvents << ")" << endl ;
1430 Int_t* newOrder = randomizeProtoOrder(prototype->numEntries(),Int_t(nEvents),resampleProto) ;
1431 context.setProtoDataOrder(newOrder) ;
1432 delete[] newOrder ;
1433 }
1434
1435 if(context.isValid()) {
1436 generated = std::unique_ptr<RooDataSet>{context.generate(nEvents,skipInit,extended)};
1437 }
1438 else {
1439 coutE(Generation) << "RooAbsPdf::generate(" << GetName() << ") do not have a valid generator context" << endl;
1440 }
1441 return generated;
1442}
1443
1444
1445
1446
1447////////////////////////////////////////////////////////////////////////////////
1448/// Generate a new dataset using a prototype dataset as a model,
1449/// with values of the variables in `whatVars` sampled from our distribution.
1450///
1451/// \param[in] whatVars Generate for these variables.
1452/// \param[in] prototype Use this dataset
1453/// as a prototype: the new dataset will contain the same number of
1454/// events as the prototype (by default), and any prototype variables not in
1455/// whatVars will be copied into the new dataset for each generated
1456/// event and also used to set our PDF parameters. The user can specify a
1457/// number of events to generate that will override the default. The result is a
1458/// copy of the prototype dataset with only variables in whatVars
1459/// randomized. Variables in whatVars that are not in the prototype
1460/// will be added as new columns to the generated dataset.
1461/// \param[in] nEvents Number of events to generate. Defaults to 0, which means number
1462/// of event in prototype dataset.
1463/// \param[in] verbose Show which generator strategies are being used.
1464/// \param[in] randProtoOrder Randomise order of retrieval of events from proto dataset.
1465/// \param[in] resampleProto Resample from the proto dataset.
1466/// \return The new dataset. Returns zero in case of an error. The caller takes ownership of the
1467/// returned dataset.
1468
1470 Int_t nEvents, bool verbose, bool randProtoOrder, bool resampleProto) const
1471{
1472 std::unique_ptr<RooAbsGenContext> context{genContext(whatVars,&prototype,nullptr,verbose)};
1473 if (context) {
1474 return RooFit::makeOwningPtr(generate(*context,whatVars,&prototype,nEvents,verbose,randProtoOrder,resampleProto));
1475 }
1476 coutE(Generation) << "RooAbsPdf::generate(" << GetName() << ") ERROR creating generator context" << endl ;
1477 return nullptr;
1478}
1479
1480
1481
1482////////////////////////////////////////////////////////////////////////////////
1483/// Return lookup table with randomized order for nProto prototype events.
1484
1485Int_t* RooAbsPdf::randomizeProtoOrder(Int_t nProto, Int_t, bool resampleProto) const
1486{
1487 // Make output list
1488 Int_t* lut = new Int_t[nProto] ;
1489
1490 // Randomly sample input list into output list
1491 if (!resampleProto) {
1492 // In this mode, randomization is a strict reshuffle of the order
1493 std::iota(lut, lut + nProto, 0); // fill the vector with 0 to nProto - 1
1494 // Shuffle code taken from https://en.cppreference.com/w/cpp/algorithm/random_shuffle.
1495 // The std::random_shuffle function was deprecated in C++17. We could have
1496 // used std::shuffle instead, but this is not straight-forward to use with
1497 // RooRandom::integer() and we didn't want to change the random number
1498 // generator. It might cause unwanted effects like reproducibility problems.
1499 for (int i = nProto-1; i > 0; --i) {
1500 std::swap(lut[i], lut[RooRandom::integer(i+1)]);
1501 }
1502 } else {
1503 // In this mode, we resample, i.e. events can be used more than once
1504 std::generate(lut, lut + nProto, [&]{ return RooRandom::integer(nProto); });
1505 }
1506
1507
1508 return lut ;
1509}
1510
1511
1512
1513////////////////////////////////////////////////////////////////////////////////
1514/// Load generatedVars with the subset of directVars that we can generate events for,
1515/// and return a code that specifies the generator algorithm we will use. A code of
1516/// zero indicates that we cannot generate any of the directVars (in this case, nothing
1517/// should be added to generatedVars). Any non-zero codes will be passed to our generateEvent()
1518/// implementation, but otherwise its value is arbitrary. The default implementation of
1519/// this method returns zero. Subclasses will usually implement this method using the
1520/// matchArgs() methods to advertise the algorithms they provide.
1521
1522Int_t RooAbsPdf::getGenerator(const RooArgSet &/*directVars*/, RooArgSet &/*generatedVars*/, bool /*staticInitOK*/) const
1523{
1524 return 0 ;
1525}
1526
1527
1528
1529////////////////////////////////////////////////////////////////////////////////
1530/// Interface for one-time initialization to setup the generator for the specified code.
1531
1533{
1534}
1535
1536
1537
1538////////////////////////////////////////////////////////////////////////////////
1539/// Interface for generation of an event using the algorithm
1540/// corresponding to the specified code. The meaning of each code is
1541/// defined by the getGenerator() implementation. The default
1542/// implementation does nothing.
1543
1545{
1546}
1547
1548
1549
1550////////////////////////////////////////////////////////////////////////////////
1551/// Check if given observable can be safely generated using the
1552/// pdfs internal generator mechanism (if that existsP). Observables
1553/// on which a PDF depends via more than route are not safe
1554/// for use with internal generators because they introduce
1555/// correlations not known to the internal generator
1556
1558{
1559 // Arg must be direct server of self
1560 if (!findServer(arg.GetName())) return false ;
1561
1562 // There must be no other dependency routes
1563 for (const auto server : _serverList) {
1564 if(server == &arg) continue;
1565 if(server->dependsOn(arg)) {
1566 return false ;
1567 }
1568 }
1569
1570 return true ;
1571}
1572
1573
1574////////////////////////////////////////////////////////////////////////////////
1575/// Generate a new dataset containing the specified variables with events sampled from our distribution.
1576/// \param[in] whatVars Choose variables in which to generate events. Variables not listed here will remain
1577/// constant and not be used for event generation
1578/// \param[in] arg1,arg2,arg3,arg4,arg5,arg6 Optional RooCmdArg to change behaviour of generateBinned()
1579/// \return RooDataHist *, to be managed by caller.
1580///
1581/// Generate the specified number of events or expectedEvents() if not specified.
1582///
1583/// Any variables of this PDF that are not in whatVars will use their
1584/// current values and be treated as fixed parameters. Returns zero
1585/// in case of an error. The caller takes ownership of the returned
1586/// dataset.
1587///
1588/// The following named arguments are supported
1589/// | Type of CmdArg | Effect on generation
1590/// |---------------------------|-----------------------
1591/// | `Name(const char* name)` | Name of the output dataset
1592/// | `Verbose(bool flag)` | Print informational messages during event generation
1593/// | `NumEvents(int nevt)` | Generate specified number of events
1594/// | `Extended()` | The actual number of events generated will be sampled from a Poisson distribution with mu=nevt. This can be *much* faster for peaked PDFs, but the number of events is not exactly what was requested.
1595/// | `ExpectedData()` | Return a binned dataset _without_ statistical fluctuations (also aliased as Asimov())
1596///
1597
1599 const RooCmdArg& arg3,const RooCmdArg& arg4, const RooCmdArg& arg5,const RooCmdArg& arg6) const
1600{
1601
1602 // Select the pdf-specific commands
1603 RooCmdConfig pc("RooAbsPdf::generate(" + std::string(GetName()) + ")");
1604 pc.defineString("dsetName","Name",0,"") ;
1605 pc.defineInt("verbose","Verbose",0,0) ;
1606 pc.defineInt("extended","Extended",0,0) ;
1607 pc.defineInt("nEvents","NumEvents",0,0) ;
1608 pc.defineDouble("nEventsD","NumEventsD",0,-1.) ;
1609 pc.defineInt("expectedData","ExpectedData",0,0) ;
1610
1611 // Process and check varargs
1612 pc.process(arg1,arg2,arg3,arg4,arg5,arg6) ;
1613 if (!pc.ok(true)) {
1614 return nullptr;
1615 }
1616
1617 // Decode command line arguments
1618 double nEvents = pc.getDouble("nEventsD") ;
1619 if (nEvents<0) {
1620 nEvents = pc.getInt("nEvents") ;
1621 }
1622 //bool verbose = pc.getInt("verbose") ;
1623 bool extended = pc.getInt("extended") ;
1624 bool expectedData = pc.getInt("expectedData") ;
1625 const char* dsetName = pc.getString("dsetName") ;
1626
1627 if (extended) {
1628 //nEvents = (nEvents==0?Int_t(expectedEvents(&whatVars)+0.5):nEvents) ;
1629 nEvents = (nEvents==0 ? expectedEvents(&whatVars) :nEvents) ;
1630 cxcoutI(Generation) << " Extended mode active, number of events generated (" << nEvents << ") is Poisson fluctuation on "
1631 << GetName() << "::expectedEvents() = " << nEvents << endl ;
1632 // If Poisson fluctuation results in zero events, stop here
1633 if (nEvents==0) {
1634 return nullptr ;
1635 }
1636 } else if (nEvents==0) {
1637 cxcoutI(Generation) << "No number of events specified , number of events generated is "
1638 << GetName() << "::expectedEvents() = " << expectedEvents(&whatVars)<< endl ;
1639 }
1640
1641 // Forward to appropriate implementation
1642 auto data = generateBinned(whatVars,nEvents,expectedData,extended);
1643
1644 // Rename dataset to given name if supplied
1645 if (dsetName && strlen(dsetName)>0) {
1646 data->SetName(dsetName) ;
1647 }
1648
1649 return data;
1650}
1651
1652
1653
1654
1655////////////////////////////////////////////////////////////////////////////////
1656/// Generate a new dataset containing the specified variables with
1657/// events sampled from our distribution.
1658///
1659/// \param[in] whatVars Variables that values should be generated for.
1660/// \param[in] nEvents How many events to generate. If `nEvents <=0`, use the value returned by expectedEvents() as target.
1661/// \param[in] expectedData If set to true (false by default), the returned histogram returns the 'expected'
1662/// data sample, i.e. no statistical fluctuations are present.
1663/// \param[in] extended For each bin, generate Poisson(x, mu) events, where `mu` is chosen such that *on average*,
1664/// one would obtain `nEvents` events. This means that the true number of events will fluctuate around the desired value,
1665/// but the generation happens a lot faster.
1666/// Especially if the PDF is sharply peaked, the multinomial event generation necessary to generate *exactly* `nEvents` events can
1667/// be very slow.
1668///
1669/// The binning used for generation of events is the currently set binning for the variables.
1670/// It can e.g. be changed using
1671/// ```
1672/// x.setBins(15);
1673/// x.setRange(-5., 5.);
1674/// pdf.generateBinned(RooArgSet(x), 1000);
1675/// ```
1676///
1677/// Any variables of this PDF that are not in `whatVars` will use their
1678/// current values and be treated as fixed parameters.
1679/// \return RooDataHist* owned by the caller. Returns `nullptr` in case of an error.
1680RooFit::OwningPtr<RooDataHist> RooAbsPdf::generateBinned(const RooArgSet &whatVars, double nEvents, bool expectedData, bool extended) const
1681{
1682 // Create empty RooDataHist
1683 auto hist = std::make_unique<RooDataHist>("genData","genData",whatVars);
1684
1685 // Scale to number of events and introduce Poisson fluctuations
1686 if (nEvents<=0) {
1687 if (!canBeExtended()) {
1688 coutE(InputArguments) << "RooAbsPdf::generateBinned(" << GetName() << ") ERROR: No event count provided and p.d.f does not provide expected number of events" << endl ;
1689 return nullptr;
1690 } else {
1691
1692 // Don't round in expectedData or extended mode
1693 if (expectedData || extended) {
1694 nEvents = expectedEvents(&whatVars) ;
1695 } else {
1696 nEvents = std::round(expectedEvents(&whatVars));
1697 }
1698 }
1699 }
1700
1701 // Sample p.d.f. distribution
1702 fillDataHist(hist.get(),&whatVars,1,true) ;
1703
1704 vector<int> histOut(hist->numEntries()) ;
1705 double histMax(-1) ;
1706 Int_t histOutSum(0) ;
1707 for (int i=0 ; i<hist->numEntries() ; i++) {
1708 hist->get(i) ;
1709 if (expectedData) {
1710
1711 // Expected data, multiply p.d.f by nEvents
1712 double w=hist->weight()*nEvents ;
1713 hist->set(i, w, sqrt(w));
1714
1715 } else if (extended) {
1716
1717 // Extended mode, set contents to Poisson(pdf*nEvents)
1718 double w = RooRandom::randomGenerator()->Poisson(hist->weight()*nEvents) ;
1719 hist->set(w,sqrt(w)) ;
1720
1721 } else {
1722
1723 // Regular mode, fill array of weights with Poisson(pdf*nEvents), but to not fill
1724 // histogram yet.
1725 if (hist->weight()>histMax) {
1726 histMax = hist->weight() ;
1727 }
1728 histOut[i] = RooRandom::randomGenerator()->Poisson(hist->weight()*nEvents) ;
1729 histOutSum += histOut[i] ;
1730 }
1731 }
1732
1733
1734 if (!expectedData && !extended) {
1735
1736 // Second pass for regular mode - Trim/Extend dataset to exact number of entries
1737
1738 // Calculate difference between what is generated so far and what is requested
1739 Int_t nEvtExtra = std::abs(Int_t(nEvents)-histOutSum) ;
1740 Int_t wgt = (histOutSum>nEvents) ? -1 : 1 ;
1741
1742 // Perform simple binned accept/reject procedure to get to exact event count
1743 std::size_t counter = 0;
1744 bool havePrintedInfo = false;
1745 while(nEvtExtra>0) {
1746
1747 Int_t ibinRand = RooRandom::randomGenerator()->Integer(hist->numEntries()) ;
1748 hist->get(ibinRand) ;
1749 double ranY = RooRandom::randomGenerator()->Uniform(histMax) ;
1750
1751 if (ranY<hist->weight()) {
1752 if (wgt==1) {
1753 histOut[ibinRand]++ ;
1754 } else {
1755 // If weight is negative, prior bin content must be at least 1
1756 if (histOut[ibinRand]>0) {
1757 histOut[ibinRand]-- ;
1758 } else {
1759 continue ;
1760 }
1761 }
1762 nEvtExtra-- ;
1763 }
1764
1765 if ((counter++ > 10*nEvents || nEvents > 1.E7) && !havePrintedInfo) {
1766 havePrintedInfo = true;
1767 coutP(Generation) << "RooAbsPdf::generateBinned(" << GetName() << ") Performing costly accept/reject sampling. If this takes too long, use "
1768 << "extended mode to speed up the process." << std::endl;
1769 }
1770 }
1771
1772 // Transfer working array to histogram
1773 for (int i=0 ; i<hist->numEntries() ; i++) {
1774 hist->get(i) ;
1775 hist->set(histOut[i],sqrt(1.0*histOut[i])) ;
1776 }
1777
1778 } else if (expectedData) {
1779
1780 // Second pass for expectedData mode -- Normalize to exact number of requested events
1781 // Minor difference may be present in first round due to difference between
1782 // bin average and bin integral in sampling bins
1783 double corr = nEvents/hist->sumEntries() ;
1784 for (int i=0 ; i<hist->numEntries() ; i++) {
1785 hist->get(i) ;
1786 hist->set(hist->weight()*corr,sqrt(hist->weight()*corr)) ;
1787 }
1788
1789 }
1790
1791 return RooFit::makeOwningPtr(std::move(hist));
1792}
1793
1794
1795
1796////////////////////////////////////////////////////////////////////////////////
1797/// Special generator interface for generation of 'global observables' -- for RooStats tools
1798
1800{
1801 return generate(whatVars,nEvents) ;
1802}
1803
1804namespace {
1805void removeRangeOverlap(std::vector<std::pair<double, double>>& ranges) {
1806 //Sort from left to right
1807 std::sort(ranges.begin(), ranges.end());
1808
1809 for (auto it = ranges.begin(); it != ranges.end(); ++it) {
1810 double& startL = it->first;
1811 double& endL = it->second;
1812
1813 for (auto innerIt = it+1; innerIt != ranges.end(); ++innerIt) {
1814 const double startR = innerIt->first;
1815 const double endR = innerIt->second;
1816
1817 if (startL <= startR && startR <= endL) {
1818 //Overlapping ranges, extend left one
1819 endL = std::max(endL, endR);
1820 *innerIt = make_pair(0., 0.);
1821 }
1822 }
1823 }
1824
1825 auto newEnd = std::remove_if(ranges.begin(), ranges.end(),
1826 [](const std::pair<double,double>& input){
1827 return input.first == input.second;
1828 });
1829 ranges.erase(newEnd, ranges.end());
1830}
1831}
1832
1833
1834////////////////////////////////////////////////////////////////////////////////
1835/// Plot (project) PDF on specified frame.
1836/// - If a PDF is plotted in an empty frame, it
1837/// will show a unit-normalized curve in the frame variable. When projecting a multi-
1838/// dimensional PDF onto the frame axis, hidden parameters are taken are taken at
1839/// their current value.
1840/// - If a PDF is plotted in a frame in which a dataset has already been plotted, it will
1841/// show a projection integrated over all variables that were present in the shown
1842/// dataset (except for the one on the x-axis). The normalization of the curve will
1843/// be adjusted to the event count of the plotted dataset. An informational message
1844/// will be printed for each projection step that is performed.
1845/// - If a PDF is plotted in a frame showing a dataset *after* a fit, the above happens,
1846/// but the PDF will be drawn and normalised only in the fit range. If this is not desired,
1847/// plotting and normalisation range can be overridden using Range() and NormRange() as
1848/// documented in the table below.
1849///
1850/// This function takes the following named arguments (for more arguments, see also
1851/// RooAbsReal::plotOn(RooPlot*,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,
1852/// const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,
1853/// const RooCmdArg&) const )
1854///
1855///
1856/// <table>
1857/// <tr><th> Type of argument <th> Controlling normalisation
1858/// <tr><td> `NormRange(const char* name)` <td> Calculate curve normalization w.r.t. specified range[s].
1859/// See the tutorial rf212_plottingInRanges_blinding.C
1860/// \note Setting a Range() by default also sets a NormRange() on the same range, meaning that the
1861/// PDF is plotted and normalised in the same range. Overriding this can be useful if the PDF was fit
1862/// in limited range[s] such as side bands, `NormRange("sidebandLeft,sidebandRight")`, but the PDF
1863/// should be drawn in the full range, `Range("")`.
1864///
1865/// <tr><td> `Normalization(double scale, ScaleType code)` <td> Adjust normalization by given scale factor.
1866/// Interpretation of number depends on code:
1867/// `RooAbsReal::Relative`: relative adjustment factor
1868/// `RooAbsReal::NumEvent`: scale to match given number of events.
1869///
1870/// <tr><th> Type of argument <th> Misc control
1871/// <tr><td> `Name(const chat* name)` <td> Give curve specified name in frame. Useful if curve is to be referenced later
1872/// <tr><td> `Asymmetry(const RooCategory& c)` <td> Show the asymmetry of the PDF in given two-state category
1873/// \f$ \frac{F(+)-F(-)}{F(+)+F(-)} \f$ rather than the PDF projection. Category must have two
1874/// states with indices -1 and +1 or three states with indices -1,0 and +1.
1875/// <tr><td> `ShiftToZero(bool flag)` <td> Shift entire curve such that lowest visible point is at exactly zero.
1876/// Mostly useful when plotting -log(L) or \f$ \chi^2 \f$ distributions
1877/// <tr><td> `AddTo(const char* name, double_t wgtSelf, double_t wgtOther)` <td> Create a projection of this PDF onto the x-axis, but
1878/// instead of plotting it directly, add it to an existing curve with given name (and relative weight factors).
1879/// <tr><td> `Components(const char* names)` <td> When plotting sums of PDFs, plot only the named components (*e.g.* only
1880/// the signal of a signal+background model).
1881/// <tr><td> `Components(const RooArgSet& compSet)` <td> As above, but pass a RooArgSet of the components themselves.
1882///
1883/// <tr><th> Type of argument <th> Projection control
1884/// <tr><td> `Slice(const RooArgSet& set)` <td> Override default projection behaviour by omitting observables listed
1885/// in set from the projection, i.e. by not integrating over these.
1886/// Slicing is usually only sensible in discrete observables, by e.g. creating a slice
1887/// of the PDF at the current value of the category observable.
1888/// <tr><td> `Slice(RooCategory& cat, const char* label)` <td> Override default projection behaviour by omitting the specified category
1889/// observable from the projection, i.e., by not integrating over all states of this category.
1890/// The slice is positioned at the given label value. Multiple Slice() commands can be given to specify slices
1891/// in multiple observables, e.g.
1892/// ```{.cpp}
1893/// pdf.plotOn(frame, Slice(tagCategory, "2tag"), Slice(jetCategory, "3jet"));
1894/// ```
1895/// <tr><td> `Project(const RooArgSet& set)` <td> Override default projection behaviour by projecting
1896/// over observables given in set, completely ignoring the default projection behavior. Advanced use only.
1897/// <tr><td> `ProjWData(const RooAbsData& d)` <td> Override default projection _technique_ (integration). For observables
1898/// present in given dataset projection of PDF is achieved by constructing an average over all observable
1899/// values in given set. Consult RooFit plotting tutorial for further explanation of meaning & use of this technique
1900/// <tr><td> `ProjWData(const RooArgSet& s, const RooAbsData& d)` <td> As above but only consider subset 's' of
1901/// observables in dataset 'd' for projection through data averaging
1902/// <tr><td> `ProjectionRange(const char* rn)` <td> When projecting the PDF onto the plot axis, it is usually integrated
1903/// over the full range of the invisible variables. The ProjectionRange overrides this.
1904/// This is useful if the PDF was fitted in a limited range in y, but it is now projected onto x. If
1905/// `ProjectionRange("<name of fit range>")` is passed, the projection is normalised correctly.
1906///
1907/// <tr><th> Type of argument <th> Plotting control
1908/// <tr><td> `LineStyle(Int_t style)` <td> Select line style by ROOT line style code, default is solid
1909/// <tr><td> `LineColor(Int_t color)` <td> Select line color by ROOT color code, default is blue
1910/// <tr><td> `LineWidth(Int_t width)` <td> Select line with in pixels, default is 3
1911/// <tr><td> `FillStyle(Int_t style)` <td> Select fill style, default is not filled. If a filled style is selected,
1912/// also use VLines() to add vertical downward lines at end of curve to ensure proper closure
1913/// <tr><td> `FillColor(Int_t color)` <td> Select fill color by ROOT color code
1914/// <tr><td> `Range(const char* name)` <td> Only draw curve in range defined by given name. Multiple comma-separated ranges can be given.
1915/// An empty string "" or `nullptr` means to use the default range of the variable.
1916/// <tr><td> `Range(double lo, double hi)` <td> Only draw curve in specified range
1917/// <tr><td> `VLines()` <td> Add vertical lines to y=0 at end points of curve
1918/// <tr><td> `Precision(double eps)` <td> Control precision of drawn curve w.r.t to scale of plot, default is 1e-3. A higher precision will
1919/// result in more and more densely spaced curve points. A negative precision value will disable
1920/// adaptive point spacing and restrict sampling to the grid point of points defined by the binning
1921/// of the plotted observable (recommended for expensive functions such as profile likelihoods)
1922/// <tr><td> `Invisible(bool flag)` <td> Add curve to frame, but do not display. Useful in combination AddTo()
1923/// <tr><td> `VisualizeError(const RooFitResult& fitres, double Z=1, bool linearMethod=true)`
1924/// <td> Visualize the uncertainty on the parameters, as given in fitres, at 'Z' sigma.
1925/// The linear method is fast but may not be accurate in the presence of strong correlations (~>0.9) and at Z>2 due to linear and Gaussian approximations made.
1926/// Intervals from the sampling method can be asymmetric, and may perform better in the presence of strong correlations, but may take (much) longer to calculate
1927/// \note To include the uncertainty from the expected number of events,
1928/// the Normalization() argument with `ScaleType` `RooAbsReal::RelativeExpected` has to be passed, e.g.
1929/// ```{.cpp}
1930/// pdf.plotOn(frame, VisualizeError(fitResult), Normalization(1.0, RooAbsReal::RelativeExpected));
1931/// ```
1932///
1933/// <tr><td> `VisualizeError(const RooFitResult& fitres, const RooArgSet& param, double Z=1, bool linearMethod=true)`
1934/// <td> Visualize the uncertainty on the subset of parameters 'param', as given in fitres, at 'Z' sigma
1935/// </table>
1936
1938{
1939
1940 // Pre-processing if p.d.f. contains a fit range and there is no command specifying one,
1941 // add a fit range as default range
1942 std::unique_ptr<RooCmdArg> plotRange;
1943 std::unique_ptr<RooCmdArg> normRange2;
1944 if (getStringAttribute("fitrange") && !cmdList.FindObject("Range") &&
1945 !cmdList.FindObject("RangeWithName")) {
1946 plotRange.reset(static_cast<RooCmdArg*>(RooFit::Range(getStringAttribute("fitrange")).Clone()));
1947 cmdList.Add(plotRange.get());
1948 }
1949
1950 if (getStringAttribute("fitrange") && !cmdList.FindObject("NormRange")) {
1951 normRange2.reset(static_cast<RooCmdArg*>(RooFit::NormRange(getStringAttribute("fitrange")).Clone()));
1952 cmdList.Add(normRange2.get());
1953 }
1954
1955 if (plotRange || normRange2) {
1956 coutI(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") p.d.f was fitted in a subrange and no explicit "
1957 << (plotRange?"Range()":"") << ((plotRange&&normRange2)?" and ":"")
1958 << (normRange2?"NormRange()":"") << " was specified. Plotting / normalising in fit range. To override, do one of the following"
1959 << "\n\t- Clear the automatic fit range attribute: <pdf>.removeStringAttribute(\"fitrange\");"
1960 << "\n\t- Explicitly specify the plotting range: Range(\"<rangeName>\")."
1961 << "\n\t- Explicitly specify where to compute the normalisation: NormRange(\"<rangeName>\")."
1962 << "\n\tThe default (full) range can be denoted with Range(\"\") / NormRange(\"\")."<< endl ;
1963 }
1964
1965 // Sanity checks
1966 if (plotSanityChecks(frame)) return frame ;
1967
1968 // Select the pdf-specific commands
1969 RooCmdConfig pc("RooAbsPdf::plotOn(" + std::string(GetName()) + ")");
1970 pc.defineDouble("scaleFactor","Normalization",0,1.0) ;
1971 pc.defineInt("scaleType","Normalization",0,Relative) ;
1972 pc.defineSet("compSet","SelectCompSet",0) ;
1973 pc.defineString("compSpec","SelectCompSpec",0) ;
1974 pc.defineObject("asymCat","Asymmetry",0) ;
1975 pc.defineDouble("rangeLo","Range",0,-999.) ;
1976 pc.defineDouble("rangeHi","Range",1,-999.) ;
1977 pc.defineString("rangeName","RangeWithName",0,"") ;
1978 pc.defineString("normRangeName","NormRange",0,"") ;
1979 pc.defineInt("rangeAdjustNorm","Range",0,0) ;
1980 pc.defineInt("rangeWNAdjustNorm","RangeWithName",0,0) ;
1981 pc.defineMutex("SelectCompSet","SelectCompSpec") ;
1982 pc.defineMutex("Range","RangeWithName") ;
1983 pc.allowUndefined() ; // unknowns may be handled by RooAbsReal
1984
1985 // Process and check varargs
1986 pc.process(cmdList) ;
1987 if (!pc.ok(true)) {
1988 return frame ;
1989 }
1990
1991 // Decode command line arguments
1992 ScaleType stype = (ScaleType) pc.getInt("scaleType") ;
1993 double scaleFactor = pc.getDouble("scaleFactor") ;
1994 const RooAbsCategoryLValue* asymCat = static_cast<const RooAbsCategoryLValue*>(pc.getObject("asymCat")) ;
1995 const char* compSpec = pc.getString("compSpec") ;
1996 const RooArgSet* compSet = pc.getSet("compSet");
1997 bool haveCompSel = ( (compSpec && strlen(compSpec)>0) || compSet) ;
1998
1999 // Suffix for curve name
2000 std::string nameSuffix ;
2001 if (compSpec && strlen(compSpec)>0) {
2002 nameSuffix.append("_Comp[") ;
2003 nameSuffix.append(compSpec) ;
2004 nameSuffix.append("]") ;
2005 } else if (compSet) {
2006 nameSuffix += "_Comp[" + compSet->contentsString() + "]";
2007 }
2008
2009 // Remove PDF-only commands from command list
2010 RooCmdConfig::stripCmdList(cmdList,"SelectCompSet,SelectCompSpec") ;
2011
2012 // Adjust normalization, if so requested
2013 if (asymCat) {
2014 RooCmdArg cnsuffix("CurveNameSuffix",0,0,0,0,nameSuffix.c_str(),nullptr,nullptr,nullptr) ;
2015 cmdList.Add(&cnsuffix);
2016 return RooAbsReal::plotOn(frame,cmdList) ;
2017 }
2018
2019 // More sanity checks
2020 double nExpected(1) ;
2021 if (stype==RelativeExpected) {
2022 if (!canBeExtended()) {
2023 coutE(Plotting) << "RooAbsPdf::plotOn(" << GetName()
2024 << "): ERROR the 'Expected' scale option can only be used on extendable PDFs" << endl ;
2025 return frame ;
2026 }
2027 frame->updateNormVars(*frame->getPlotVar()) ;
2028 nExpected = expectedEvents(frame->getNormVars()) ;
2029 }
2030
2031 if (stype != Raw) {
2032
2033 if (frame->getFitRangeNEvt() && stype==Relative) {
2034
2035 bool hasCustomRange(false);
2036 bool adjustNorm(false);
2037
2038 std::vector<pair<double,double> > rangeLim;
2039
2040 // Retrieve plot range to be able to adjust normalization to data
2041 if (pc.hasProcessed("Range")) {
2042
2043 double rangeLo = pc.getDouble("rangeLo") ;
2044 double rangeHi = pc.getDouble("rangeHi") ;
2045 rangeLim.push_back(make_pair(rangeLo,rangeHi)) ;
2046 adjustNorm = pc.getInt("rangeAdjustNorm") ;
2047 hasCustomRange = true ;
2048
2049 coutI(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") only plotting range ["
2050 << rangeLo << "," << rangeHi << "]" ;
2051 if (!pc.hasProcessed("NormRange")) {
2052 ccoutI(Plotting) << ", curve is normalized to data in " << (adjustNorm?"given":"full") << " range" << endl ;
2053 } else {
2054 ccoutI(Plotting) << endl ;
2055 }
2056
2057 nameSuffix.append(Form("_Range[%f_%f]",rangeLo,rangeHi)) ;
2058
2059 } else if (pc.hasProcessed("RangeWithName")) {
2060
2061 for (const std::string& rangeNameToken : ROOT::Split(pc.getString("rangeName", "", false), ",")) {
2062 const char* thisRangeName = rangeNameToken.empty() ? nullptr : rangeNameToken.c_str();
2063 if (thisRangeName && !frame->getPlotVar()->hasRange(thisRangeName)) {
2064 coutE(Plotting) << "Range '" << rangeNameToken << "' not defined for variable '"
2065 << frame->getPlotVar()->GetName() << "'. Ignoring ..." << std::endl;
2066 continue;
2067 }
2068 rangeLim.push_back(frame->getPlotVar()->getRange(thisRangeName));
2069 }
2070 adjustNorm = pc.getInt("rangeWNAdjustNorm") ;
2071 hasCustomRange = true ;
2072
2073 coutI(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") only plotting range '" << pc.getString("rangeName", "", false) << "'" ;
2074 if (!pc.hasProcessed("NormRange")) {
2075 ccoutI(Plotting) << ", curve is normalized to data in " << (adjustNorm?"given":"full") << " range" << endl ;
2076 } else {
2077 ccoutI(Plotting) << endl ;
2078 }
2079
2080 nameSuffix.append("_Range[" + std::string(pc.getString("rangeName")) + "]");
2081 }
2082 // Specification of a normalization range override those in a regular range
2083 if (pc.hasProcessed("NormRange")) {
2084 rangeLim.clear();
2085 for (const auto& rangeNameToken : ROOT::Split(pc.getString("normRangeName", "", false), ",")) {
2086 const char* thisRangeName = rangeNameToken.empty() ? nullptr : rangeNameToken.c_str();
2087 if (thisRangeName && !frame->getPlotVar()->hasRange(thisRangeName)) {
2088 coutE(Plotting) << "Range '" << rangeNameToken << "' not defined for variable '"
2089 << frame->getPlotVar()->GetName() << "'. Ignoring ..." << std::endl;
2090 continue;
2091 }
2092 rangeLim.push_back(frame->getPlotVar()->getRange(thisRangeName));
2093 }
2094 adjustNorm = true ;
2095 hasCustomRange = true ;
2096 coutI(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") p.d.f. curve is normalized using explicit choice of ranges '" << pc.getString("normRangeName", "", false) << "'" << endl ;
2097
2098 nameSuffix.append("_NormRange[" + std::string(pc.getString("rangeName")) + "]");
2099
2100 }
2101
2102 if (hasCustomRange && adjustNorm) {
2103 // If overlapping ranges were given, remove them now
2104 const std::size_t oldSize = rangeLim.size();
2105 removeRangeOverlap(rangeLim);
2106
2107 if (oldSize != rangeLim.size() && !pc.hasProcessed("NormRange")) {
2108 // User gave overlapping ranges. This leads to double-counting events and integrals, and must
2109 // therefore be avoided. If a NormRange has been given, the overlap is already gone.
2110 // It's safe to plot even with overlap now.
2111 coutE(Plotting) << "Requested plot/integration ranges overlap. For correct plotting, new ranges "
2112 "will be defined." << std::endl;
2113 auto plotVar = dynamic_cast<RooRealVar*>(frame->getPlotVar());
2114 assert(plotVar);
2115 std::string rangesNoOverlap;
2116 for (auto it = rangeLim.begin(); it != rangeLim.end(); ++it) {
2117 std::stringstream rangeName;
2118 rangeName << "Remove_overlap_range_" << it - rangeLim.begin();
2119 plotVar->setRange(rangeName.str().c_str(), it->first, it->second);
2120 if (!rangesNoOverlap.empty())
2121 rangesNoOverlap += ",";
2122 rangesNoOverlap += rangeName.str();
2123 }
2124
2125 auto rangeArg = static_cast<RooCmdArg*>(cmdList.FindObject("RangeWithName"));
2126 if (rangeArg) {
2127 rangeArg->setString(0, rangesNoOverlap.c_str());
2128 } else {
2129 plotRange = std::make_unique<RooCmdArg>(RooFit::Range(rangesNoOverlap.c_str()));
2130 cmdList.Add(plotRange.get());
2131 }
2132 }
2133
2134 double rangeNevt(0) ;
2135 for (const auto& riter : rangeLim) {
2136 double nevt= frame->getFitRangeNEvt(riter.first, riter.second);
2137 rangeNevt += nevt ;
2138 }
2139
2140 scaleFactor *= rangeNevt/nExpected ;
2141
2142 } else {
2143 scaleFactor *= frame->getFitRangeNEvt()/nExpected ;
2144 }
2145 } else if (stype==RelativeExpected) {
2146 scaleFactor *= nExpected ;
2147 } else if (stype==NumEvent) {
2148 scaleFactor /= nExpected ;
2149 }
2150 scaleFactor *= frame->getFitRangeBinW() ;
2151 }
2152 frame->updateNormVars(*frame->getPlotVar()) ;
2153
2154 // Append overriding scale factor command at end of original command list
2155 RooCmdArg tmp = RooFit::Normalization(scaleFactor,Raw) ;
2156 tmp.setInt(1,1) ; // Flag this normalization command as created for internal use (so that VisualizeError can strip it)
2157 cmdList.Add(&tmp) ;
2158
2159 // Was a component selected requested
2160 if (haveCompSel) {
2161
2162 // Get complete set of tree branch nodes
2163 RooArgSet branchNodeSet ;
2164 branchNodeServerList(&branchNodeSet) ;
2165
2166 // Discard any non-RooAbsReal nodes
2167 for (const auto arg : branchNodeSet) {
2168 if (!dynamic_cast<RooAbsReal*>(arg)) {
2169 branchNodeSet.remove(*arg) ;
2170 }
2171 }
2172
2173 // Obtain direct selection
2174 std::unique_ptr<RooArgSet> dirSelNodes;
2175 if (compSet) {
2176 dirSelNodes = std::unique_ptr<RooArgSet>{branchNodeSet.selectCommon(*compSet)};
2177 } else {
2178 dirSelNodes = std::unique_ptr<RooArgSet>{branchNodeSet.selectByName(compSpec)};
2179 }
2180 if (!dirSelNodes->empty()) {
2181 coutI(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") directly selected PDF components: " << *dirSelNodes << endl ;
2182
2183 // Do indirect selection and activate both
2184 plotOnCompSelect(dirSelNodes.get());
2185 } else {
2186 if (compSet) {
2187 coutE(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") ERROR: component selection set " << *compSet << " does not match any components of p.d.f." << endl ;
2188 } else {
2189 coutE(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") ERROR: component selection expression '" << compSpec << "' does not select any components of p.d.f." << endl ;
2190 }
2191 return nullptr ;
2192 }
2193 }
2194
2195
2196 RooCmdArg cnsuffix("CurveNameSuffix",0,0,0,0,nameSuffix.c_str(),nullptr,nullptr,nullptr) ;
2197 cmdList.Add(&cnsuffix);
2198
2199 RooPlot* ret = RooAbsReal::plotOn(frame,cmdList) ;
2200
2201 // Restore selection status ;
2202 if (haveCompSel) plotOnCompSelect(nullptr) ;
2203
2204 return ret ;
2205}
2206
2207
2208//_____________________________________________________________________________
2209/// Plot oneself on 'frame'. In addition to features detailed in RooAbsReal::plotOn(),
2210/// the scale factor for a PDF can be interpreted in three different ways. The interpretation
2211/// is controlled by ScaleType
2212/// ```
2213/// Relative - Scale factor is applied on top of PDF normalization scale factor
2214/// NumEvent - Scale factor is interpreted as a number of events. The surface area
2215/// under the PDF curve will match that of a histogram containing the specified
2216/// number of event
2217/// Raw - Scale factor is applied to the raw (projected) probability density.
2218/// Not too useful, option provided for completeness.
2219/// ```
2220// coverity[PASS_BY_VALUE]
2222{
2223
2224 // Sanity checks
2225 if (plotSanityChecks(frame)) return frame ;
2226
2227 // More sanity checks
2228 double nExpected(1) ;
2229 if (o.stype==RelativeExpected) {
2230 if (!canBeExtended()) {
2231 coutE(Plotting) << "RooAbsPdf::plotOn(" << GetName()
2232 << "): ERROR the 'Expected' scale option can only be used on extendable PDFs" << endl ;
2233 return frame ;
2234 }
2235 frame->updateNormVars(*frame->getPlotVar()) ;
2236 nExpected = expectedEvents(frame->getNormVars()) ;
2237 }
2238
2239 // Adjust normalization, if so requested
2240 if (o.stype != Raw) {
2241
2242 if (frame->getFitRangeNEvt() && o.stype==Relative) {
2243 // If non-default plotting range is specified, adjust number of events in fit range
2244 o.scaleFactor *= frame->getFitRangeNEvt()/nExpected ;
2245 } else if (o.stype==RelativeExpected) {
2246 o.scaleFactor *= nExpected ;
2247 } else if (o.stype==NumEvent) {
2248 o.scaleFactor /= nExpected ;
2249 }
2250 o.scaleFactor *= frame->getFitRangeBinW() ;
2251 }
2252 frame->updateNormVars(*frame->getPlotVar()) ;
2253
2254 return RooAbsReal::plotOn(frame,o) ;
2255}
2256
2257
2258
2259
2260////////////////////////////////////////////////////////////////////////////////
2261/// The following named arguments are supported
2262/// <table>
2263/// <tr><th> Type of CmdArg <th> Effect on parameter box
2264/// <tr><td> `Parameters(const RooArgSet& param)` <td> Only the specified subset of parameters will be shown. By default all non-constant parameters are shown.
2265/// <tr><td> `ShowConstants(bool flag)` <td> Also display constant parameters
2266/// <tr><td> `Format(const char* what,...)` <td> Parameter formatting options.
2267/// | Parameter | Format
2268/// | ---------------------- | --------------------------
2269/// | `const char* what` | Controls what is shown. "N" adds name (alternatively, "T" adds the title), "E" adds error, "A" shows asymmetric error, "U" shows unit, "H" hides the value
2270/// | `FixedPrecision(int n)`| Controls precision, set fixed number of digits
2271/// | `AutoPrecision(int n)` | Controls precision. Number of shown digits is calculated from error + n specified additional digits (1 is sensible default)
2272/// <tr><td> `Label(const chat* label)` <td> Add label to parameter box. Use `\n` for multi-line labels.
2273/// <tr><td> `Layout(double xmin, double xmax, double ymax)` <td> Specify relative position of left/right side of box and top of box.
2274/// Coordinates are given as position on the pad between 0 and 1.
2275/// The lower end of the box is calculated automatically from the number of lines in the box.
2276/// </table>
2277///
2278///
2279/// Example use:
2280/// ```
2281/// pdf.paramOn(frame, Label("fit result"), Format("NEU",AutoPrecision(1)) ) ;
2282/// ```
2283///
2284
2285RooPlot* RooAbsPdf::paramOn(RooPlot* frame, const RooCmdArg& arg1, const RooCmdArg& arg2,
2286 const RooCmdArg& arg3, const RooCmdArg& arg4, const RooCmdArg& arg5,
2287 const RooCmdArg& arg6, const RooCmdArg& arg7, const RooCmdArg& arg8)
2288{
2289 // Stuff all arguments in a list
2290 RooLinkedList cmdList;
2291 cmdList.Add(const_cast<RooCmdArg*>(&arg1)) ; cmdList.Add(const_cast<RooCmdArg*>(&arg2)) ;
2292 cmdList.Add(const_cast<RooCmdArg*>(&arg3)) ; cmdList.Add(const_cast<RooCmdArg*>(&arg4)) ;
2293 cmdList.Add(const_cast<RooCmdArg*>(&arg5)) ; cmdList.Add(const_cast<RooCmdArg*>(&arg6)) ;
2294 cmdList.Add(const_cast<RooCmdArg*>(&arg7)) ; cmdList.Add(const_cast<RooCmdArg*>(&arg8)) ;
2295
2296 // Select the pdf-specific commands
2297 RooCmdConfig pc("RooAbsPdf::paramOn(" + std::string(GetName()) + ")");
2298 pc.defineString("label","Label",0,"") ;
2299 pc.defineDouble("xmin","Layout",0,0.65) ;
2300 pc.defineDouble("xmax","Layout",1,0.9) ;
2301 pc.defineInt("ymaxi","Layout",0,Int_t(0.9*10000)) ;
2302 pc.defineInt("showc","ShowConstants",0,0) ;
2303 pc.defineSet("params","Parameters",0,nullptr) ;
2304 pc.defineInt("dummy","FormatArgs",0,0) ;
2305
2306 // Process and check varargs
2307 pc.process(cmdList) ;
2308 if (!pc.ok(true)) {
2309 return frame ;
2310 }
2311
2312 auto formatCmd = static_cast<RooCmdArg const*>(cmdList.FindObject("FormatArgs")) ;
2313
2314 const char* label = pc.getString("label") ;
2315 double xmin = pc.getDouble("xmin") ;
2316 double xmax = pc.getDouble("xmax") ;
2317 double ymax = pc.getInt("ymaxi") / 10000. ;
2318 int showc = pc.getInt("showc") ;
2319
2320 // Decode command line arguments
2321 std::unique_ptr<RooArgSet> params{getParameters(frame->getNormVars())} ;
2322 if(RooArgSet* requestedParams = pc.getSet("params")) {
2323 params = std::unique_ptr<RooArgSet>{params->selectCommon(*requestedParams)};
2324 }
2325 paramOn(frame,*params,showc,label,xmin,xmax,ymax,formatCmd);
2326
2327 return frame ;
2328}
2329
2330
2331////////////////////////////////////////////////////////////////////////////////
2332/// Add a text box with the current parameter values and their errors to the frame.
2333/// Observables of this PDF appearing in the 'data' dataset will be omitted.
2334///
2335/// An optional label will be inserted if passed. Multi-line labels can be generated
2336/// by adding `\n` to the label string. Use 'sigDigits'
2337/// to modify the default number of significant digits printed. The 'xmin,xmax,ymax'
2338/// values specify the initial relative position of the text box in the plot frame.
2339
2340RooPlot* RooAbsPdf::paramOn(RooPlot* frame, const RooArgSet& params, bool showConstants, const char *label,
2341 double xmin, double xmax ,double ymax, const RooCmdArg* formatCmd)
2342{
2343
2344 // parse the options
2345 bool showLabel= (label != nullptr && strlen(label) > 0);
2346
2347 // calculate the box's size, adjusting for constant parameters
2348
2349 double ymin(ymax);
2350 double dy(0.06);
2351 for (const auto param : params) {
2352 auto var = static_cast<RooRealVar*>(param);
2353 if(showConstants || !var->isConstant()) ymin-= dy;
2354 }
2355
2356 std::string labelString = label;
2357 unsigned int numLines = std::count(labelString.begin(), labelString.end(), '\n') + 1;
2358 if (showLabel) ymin -= numLines * dy;
2359
2360 // create the box and set its options
2361 TPaveText *box= new TPaveText(xmin,ymax,xmax,ymin,"BRNDC");
2362 if(!box) return nullptr;
2363 box->SetName((std::string(GetName()) + "_paramBox").c_str());
2364 box->SetFillColor(0);
2365 box->SetBorderSize(0);
2366 box->SetTextAlign(12);
2367 box->SetTextSize(0.04F);
2368 box->SetFillStyle(0);
2369
2370 for (const auto param : params) {
2371 auto var = static_cast<const RooRealVar*>(param);
2372 if(var->isConstant() && !showConstants) continue;
2373
2374 std::unique_ptr<TString> formatted{formatCmd ? var->format(*formatCmd) : var->format(2, "NELU")};
2375 box->AddText(formatted->Data());
2376 }
2377
2378 // add the optional label if specified
2379 if (showLabel) {
2380 for (const auto& line : ROOT::Split(label, "\n")) {
2381 box->AddText(line.c_str());
2382 }
2383 }
2384
2385 // Add box to frame
2386 frame->addObject(box) ;
2387
2388 return frame ;
2389}
2390
2391
2392
2393
2394////////////////////////////////////////////////////////////////////////////////
2395/// Return expected number of events from this p.d.f for use in extended
2396/// likelihood calculations. This default implementation returns zero
2397
2399{
2400 return 0 ;
2401}
2402
2403
2404
2405////////////////////////////////////////////////////////////////////////////////
2406/// Change global level of verbosity for p.d.f. evaluations
2407
2409{
2410 _verboseEval = stat ;
2411}
2412
2413
2414
2415////////////////////////////////////////////////////////////////////////////////
2416/// Return global level of verbosity for p.d.f. evaluations
2417
2419{
2420 return _verboseEval ;
2421}
2422
2423
2424
2425////////////////////////////////////////////////////////////////////////////////
2426/// Destructor of normalization cache element. If this element
2427/// provides the 'current' normalization stored in RooAbsPdf::_norm
2428/// zero _norm pointer here before object pointed to is deleted here
2429
2431{
2432 // Zero _norm pointer in RooAbsPdf if it is points to our cache payload
2433 if (_owner) {
2434 RooAbsPdf* pdfOwner = static_cast<RooAbsPdf*>(_owner) ;
2435 if (pdfOwner->_norm == _norm.get()) {
2436 pdfOwner->_norm = nullptr ;
2437 }
2438 }
2439}
2440
2441
2442
2443////////////////////////////////////////////////////////////////////////////////
2444/// Return a p.d.f that represent a projection of this p.d.f integrated over given observables
2445
2447{
2448 // Construct name for new object
2449 std::string name = std::string{GetName()} + "_Proj[" + RooHelpers::getColonSeparatedNameString(iset, ',') + "]";
2450
2451 // Return projected p.d.f.
2452 return new RooProjectedPdf(name.c_str(),name.c_str(),*this,iset) ;
2453}
2454
2455
2456
2457////////////////////////////////////////////////////////////////////////////////
2458/// Create a cumulative distribution function of this p.d.f in terms
2459/// of the observables listed in iset. If no nset argument is given
2460/// the c.d.f normalization is constructed over the integrated
2461/// observables, so that its maximum value is precisely 1. It is also
2462/// possible to choose a different normalization for
2463/// multi-dimensional p.d.f.s: eg. for a pdf f(x,y,z) one can
2464/// construct a partial cdf c(x,y) that only when integrated itself
2465/// over z results in a maximum value of 1. To construct such a cdf pass
2466/// z as argument to the optional nset argument
2467
2469{
2470 return createCdf(iset,RooFit::SupNormSet(nset)) ;
2471}
2472
2473
2474
2475////////////////////////////////////////////////////////////////////////////////
2476/// Create an object that represents the integral of the function over one or more observables listed in `iset`.
2477/// The actual integration calculation is only performed when the return object is evaluated. The name
2478/// of the integral object is automatically constructed from the name of the input function, the variables
2479/// it integrates and the range integrates over
2480///
2481/// The following named arguments are accepted
2482/// | Type of CmdArg | Effect on CDF
2483/// | ---------------------|-------------------
2484/// | SupNormSet(const RooArgSet&) | Observables over which should be normalized _in addition_ to the integration observables
2485/// | ScanNumCdf() | Apply scanning technique if cdf integral involves numeric integration [ default ]
2486/// | ScanAllCdf() | Always apply scanning technique
2487/// | ScanNoCdf() | Never apply scanning technique
2488/// | 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
2489
2491 const RooCmdArg& arg3, const RooCmdArg& arg4, const RooCmdArg& arg5,
2492 const RooCmdArg& arg6, const RooCmdArg& arg7, const RooCmdArg& arg8)
2493{
2494 // Define configuration for this method
2495 RooCmdConfig pc("RooAbsReal::createCdf(" + std::string(GetName()) + ")");
2496 pc.defineSet("supNormSet","SupNormSet",0,nullptr) ;
2497 pc.defineInt("numScanBins","ScanParameters",0,1000) ;
2498 pc.defineInt("intOrder","ScanParameters",1,2) ;
2499 pc.defineInt("doScanNum","ScanNumCdf",0,1) ;
2500 pc.defineInt("doScanAll","ScanAllCdf",0,0) ;
2501 pc.defineInt("doScanNon","ScanNoCdf",0,0) ;
2502 pc.defineMutex("ScanNumCdf","ScanAllCdf","ScanNoCdf") ;
2503
2504 // Process & check varargs
2505 pc.process(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8) ;
2506 if (!pc.ok(true)) {
2507 return nullptr ;
2508 }
2509
2510 // Extract values from named arguments
2511 const RooArgSet* snset = pc.getSet("supNormSet",nullptr);
2512 RooArgSet nset ;
2513 if (snset) {
2514 nset.add(*snset) ;
2515 }
2516 Int_t numScanBins = pc.getInt("numScanBins") ;
2517 Int_t intOrder = pc.getInt("intOrder") ;
2518 Int_t doScanNum = pc.getInt("doScanNum") ;
2519 Int_t doScanAll = pc.getInt("doScanAll") ;
2520 Int_t doScanNon = pc.getInt("doScanNon") ;
2521
2522 // If scanning technique is not requested make integral-based cdf and return
2523 if (doScanNon) {
2524 return createIntRI(iset,nset) ;
2525 }
2526 if (doScanAll) {
2527 return createScanCdf(iset,nset,numScanBins,intOrder) ;
2528 }
2529 if (doScanNum) {
2530 std::unique_ptr<RooAbsReal> tmp{createIntegral(iset)} ;
2531 Int_t isNum= !static_cast<RooRealIntegral&>(*tmp).numIntRealVars().empty();
2532
2533 if (isNum) {
2534 coutI(NumIntegration) << "RooAbsPdf::createCdf(" << GetName() << ") integration over observable(s) " << iset << " involves numeric integration," << endl
2535 << " constructing cdf though numeric integration of sampled pdf in " << numScanBins << " bins and applying order "
2536 << intOrder << " interpolation on integrated histogram." << endl
2537 << " To override this choice of technique use argument ScanNone(), to change scan parameters use ScanParameters(nbins,order) argument" << endl ;
2538 }
2539
2540 return isNum ? createScanCdf(iset,nset,numScanBins,intOrder) : createIntRI(iset,nset) ;
2541 }
2542 return nullptr ;
2543}
2544
2546{
2547 string name = string(GetName()) + "_NUMCDF_" + integralNameSuffix(iset,&nset).Data() ;
2548 RooRealVar* ivar = static_cast<RooRealVar*>(iset.first()) ;
2549 ivar->setBins(numScanBins,"numcdf") ;
2550 auto ret = std::make_unique<RooNumCdf>(name.c_str(),name.c_str(),*this,*ivar,"numcdf");
2551 ret->setInterpolationOrder(intOrder) ;
2552 return RooFit::makeOwningPtr<RooAbsReal>(std::move(ret));
2553}
2554
2555
2556
2557
2558////////////////////////////////////////////////////////////////////////////////
2559/// This helper function finds and collects all constraints terms of all component p.d.f.s
2560/// and returns a RooArgSet with all those terms.
2561
2562RooArgSet* RooAbsPdf::getAllConstraints(const RooArgSet& observables, RooArgSet& constrainedParams,
2563 bool stripDisconnected) const
2564{
2565 RooArgSet constraints;
2566 RooArgSet pdfParams;
2567
2568 std::unique_ptr<RooArgSet> comps(getComponents());
2569 for (const auto arg : *comps) {
2570 auto pdf = dynamic_cast<const RooAbsPdf*>(arg) ;
2571 if (pdf && !constraints.find(pdf->GetName())) {
2572 std::unique_ptr<RooArgSet> compRet(
2573 pdf->getConstraints(observables,constrainedParams, pdfParams));
2574 if (compRet) {
2575 constraints.add(*compRet,false) ;
2576 }
2577 }
2578 }
2579
2580 RooArgSet conParams;
2581
2582 // Strip any constraints that are completely decoupled from the other product terms
2583 RooArgSet* finalConstraints = new RooArgSet("AllConstraints") ;
2584 for(auto * pdf : static_range_cast<RooAbsPdf*>(constraints)) {
2585
2586 RooArgSet tmp;
2587 pdf->getParameters(nullptr, tmp);
2588 conParams.add(tmp,true) ;
2589
2590 if (pdf->dependsOnValue(pdfParams) || !stripDisconnected) {
2591 finalConstraints->add(*pdf) ;
2592 } else {
2593 coutI(Minimization) << "RooAbsPdf::getAllConstraints(" << GetName() << ") omitting term " << pdf->GetName()
2594 << " as constraint term as it does not share any parameters with the other pdfs in product. "
2595 << "To force inclusion in likelihood, add an explicit Constrain() argument for the target parameter" << endl ;
2596 }
2597 }
2598
2599 // Now remove from constrainedParams all parameters that occur exclusively in constraint term and not in regular pdf term
2600
2601 RooArgSet cexl;
2602 conParams.selectCommon(constrainedParams, cexl);
2603 cexl.remove(pdfParams,true,true) ;
2604 constrainedParams.remove(cexl,true,true) ;
2605
2606 return finalConstraints ;
2607}
2608
2609
2610////////////////////////////////////////////////////////////////////////////////
2611/// Returns the default numeric MC generator configuration for all RooAbsReals
2612
2614{
2616}
2617
2618
2619////////////////////////////////////////////////////////////////////////////////
2620/// Returns the specialized integrator configuration for _this_ RooAbsReal.
2621/// If this object has no specialized configuration, a null pointer is returned
2622
2624{
2625 return _specGeneratorConfig.get();
2626}
2627
2628
2629
2630////////////////////////////////////////////////////////////////////////////////
2631/// Returns the specialized integrator configuration for _this_ RooAbsReal.
2632/// If this object has no specialized configuration, a null pointer is returned,
2633/// unless createOnTheFly is true in which case a clone of the default integrator
2634/// configuration is created, installed as specialized configuration, and returned
2635
2637{
2638 if (!_specGeneratorConfig && createOnTheFly) {
2639 _specGeneratorConfig = std::make_unique<RooNumGenConfig>(*defaultGeneratorConfig()) ;
2640 }
2641 return _specGeneratorConfig.get();
2642}
2643
2644
2645
2646////////////////////////////////////////////////////////////////////////////////
2647/// Return the numeric MC generator configuration used for this object. If
2648/// a specialized configuration was associated with this object, that configuration
2649/// is returned, otherwise the default configuration for all RooAbsReals is returned
2650
2652{
2653 const RooNumGenConfig* config = specialGeneratorConfig() ;
2654 if (config) return config ;
2655 return defaultGeneratorConfig() ;
2656}
2657
2658
2659
2660////////////////////////////////////////////////////////////////////////////////
2661/// Set the given configuration as default numeric MC generator
2662/// configuration for this object
2663
2665{
2666 _specGeneratorConfig = std::make_unique<RooNumGenConfig>(config);
2667}
2668
2669
2670
2671////////////////////////////////////////////////////////////////////////////////
2672/// Remove the specialized numeric MC generator configuration associated
2673/// with this object
2674
2676{
2677 _specGeneratorConfig.reset();
2678}
2679
2681
2682
2683////////////////////////////////////////////////////////////////////////////////
2684
2685RooAbsPdf::GenSpec::GenSpec(RooAbsGenContext* context, const RooArgSet& whatVars, RooDataSet* protoData, Int_t nGen,
2686 bool extended, bool randProto, bool resampleProto, TString dsetName, bool init) :
2687 _genContext(context), _whatVars(whatVars), _protoData(protoData), _nGen(nGen), _extended(extended),
2688 _randProto(randProto), _resampleProto(resampleProto), _dsetName(dsetName), _init(init)
2689{
2690}
2691
2692
2693namespace {
2694
2695void sterilizeClientCaches(RooAbsArg & arg) {
2696 auto const& clients = arg.clients();
2697 for(std::size_t iClient = 0; iClient < clients.size(); ++iClient) {
2698
2699 const std::size_t oldClientsSize = clients.size();
2700 RooAbsArg* client = clients[iClient];
2701
2702 for(int iCache = 0; iCache < client->numCaches(); ++iCache) {
2703 if(auto cacheMgr = dynamic_cast<RooObjCacheManager*>(client->getCache(iCache))) {
2704 cacheMgr->sterilize();
2705 }
2706 }
2707
2708 // It can happen that the objects cached by the client are also clients of
2709 // the arg itself! In that case, the position of the client in the client
2710 // list might have changed, and we need to find the new index.
2711 if(clients.size() != oldClientsSize) {
2712 auto clientIter = std::find(clients.begin(), clients.end(), client);
2713 if(clientIter == clients.end()) {
2714 throw std::runtime_error("After a clients caches were cleared, the client was gone! This should not happen.");
2715 }
2716 iClient = std::distance(clients.begin(), clientIter);
2717 }
2718 }
2719}
2720
2721} // namespace
2722
2723
2724////////////////////////////////////////////////////////////////////////////////
2725
2726void RooAbsPdf::setNormRange(const char* rangeName)
2727{
2728 if (rangeName) {
2729 _normRange = rangeName ;
2730 } else {
2731 _normRange.Clear() ;
2732 }
2733
2734 // the stuff that the clients have cached may depend on the normalization range
2735 sterilizeClientCaches(*this);
2736
2737 if (_norm) {
2739 _norm = nullptr ;
2740 }
2741}
2742
2743
2744////////////////////////////////////////////////////////////////////////////////
2745
2746void RooAbsPdf::setNormRangeOverride(const char* rangeName)
2747{
2748 if (rangeName) {
2749 _normRangeOverride = rangeName ;
2750 } else {
2752 }
2753
2754 // the stuff that the clients have cached may depend on the normalization range
2755 sterilizeClientCaches(*this);
2756
2757 if (_norm) {
2759 _norm = nullptr ;
2760 }
2761}
2762
2763
2764////////////////////////////////////////////////////////////////////////////////
2765/// Hook function intercepting redirectServer calls. Discard current
2766/// normalization object if any server is redirected
2767
2768bool RooAbsPdf::redirectServersHook(const RooAbsCollection & newServerList, bool mustReplaceAll,
2769 bool nameChange, bool isRecursiveStep)
2770{
2771 // If servers are redirected, the cached normalization integrals and
2772 // normalization sets are most likely invalid.
2774
2775 // Object is own by _normCacheManager that will delete object as soon as cache
2776 // is sterilized by server redirect
2777 _norm = nullptr ;
2778
2779 // Similar to the situation with the normalization integral above: if a
2780 // server is redirected, the cached normalization set might not point to
2781 // the right observables anymore. We need to reset it.
2782 setActiveNormSet(nullptr);
2783 return RooAbsReal::redirectServersHook(newServerList, mustReplaceAll, nameChange, isRecursiveStep);
2784}
2785
2786
2787std::unique_ptr<RooAbsArg>
2789{
2790 if (normSet.empty() || selfNormalized()) {
2791 return RooAbsReal::compileForNormSet(normSet, ctx);
2792 }
2793 std::unique_ptr<RooAbsPdf> pdfClone(static_cast<RooAbsPdf *>(this->Clone()));
2794 ctx.compileServers(*pdfClone, normSet);
2795
2796 auto newArg = std::make_unique<RooNormalizedPdf>(*pdfClone, normSet);
2797
2798 // The direct servers are this pdf and the normalization integral, which
2799 // don't need to be compiled further.
2800 for (RooAbsArg *server : newArg->servers()) {
2801 ctx.markAsCompiled(*server);
2802 }
2803 ctx.markAsCompiled(*newArg);
2804 newArg->addOwnedComponents(std::move(pdfClone));
2805 return newArg;
2806}
2807
2808/// Returns an object that represents the expected number of events for a given
2809/// normalization set, similar to how createIntegral() returns an object that
2810/// returns the integral. This is used to build the computation graph for the
2811/// final likelihood.
2812std::unique_ptr<RooAbsReal> RooAbsPdf::createExpectedEventsFunc(const RooArgSet * /*nset*/) const
2813{
2814 std::stringstream errMsg;
2815 errMsg << "The pdf \"" << GetName() << "\" of type " << ClassName()
2816 << " did not overload RooAbsPdf::createExpectedEventsFunc()!";
2817 coutE(InputArguments) << errMsg.str() << std::endl;
2818 return nullptr;
2819}
#define e(i)
Definition RSha256.hxx:103
#define coutI(a)
#define cxcoutI(a)
#define cxcoutD(a)
#define coutP(a)
#define oocoutW(o, a)
#define coutW(a)
#define coutE(a)
#define ccoutI(a)
#define ccoutD(a)
int Int_t
Definition RtypesCore.h:45
#define ClassImp(name)
Definition Rtypes.h:382
static void indent(ostringstream &buf, int indent_level)
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void input
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
char name[80]
Definition TGX11.cxx:110
float xmin
float ymin
float xmax
float ymax
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition TString.cxx:2489
Common abstract base class for objects that represent a value and a "shape" in RooFit.
Definition RooAbsArg.h:79
void clearValueAndShapeDirty() const
Definition RooAbsArg.h:571
void Print(Option_t *options=nullptr) const override
Print the object to the defaultPrintStream().
Definition RooAbsArg.h:294
bool dependsOn(const RooAbsCollection &serverList, const RooAbsArg *ignoreArg=nullptr, bool valueOnly=false) const
Test whether we depend on (ie, are served by) any object in the specified collection.
R__DEPRECATED(6, 36, "Use getObservables().") RooFit R__DEPRECATED(6, 36, "Use getObservables().") RooFit R__DEPRECATED(6, 36, "Use getObservables().") RooFit const RooAbsArg &testArg const
Definition RooAbsArg.h:145
void setOperMode(OperMode mode, bool recurseADirty=true)
Set the operation mode of this node.
RooFit::OwningPtr< RooArgSet > getParameters(const RooAbsData *data, bool stripDisconnected=true) const
Create a list of leaf nodes in the arg tree starting with ourself as top node that don't match any of...
RooFit::OwningPtr< RooArgSet > getObservables(const RooArgSet &set, bool valueOnly=true) const
Given a set of possible observables, return the observables that this PDF depends on.
bool addOwnedComponents(const RooAbsCollection &comps)
Take ownership of the contents of 'comps'.
const Text_t * getStringAttribute(const Text_t *key) const
Get string attribute mapped under key 'key'.
virtual std::unique_ptr< RooAbsArg > compileForNormSet(RooArgSet const &normSet, RooFit::Detail::CompileContext &ctx) const
RooFit::OwningPtr< RooArgSet > getComponents() const
Create a RooArgSet with all components (branch nodes) of the expression tree headed by this object.
bool getAttribute(const Text_t *name) const
Check if a named attribute is set. By default, all attributes are unset.
RooFit::OwningPtr< RooArgSet > getVariables(bool stripDisconnected=true) const
Return RooArgSet with all variables (tree leaf nodes of expression tree)
RooAbsCache * getCache(Int_t index) const
Return registered cache object by index.
const RefCountList_t & clients() const
List of all clients of this object.
Definition RooAbsArg.h:166
bool isValueDirty() const
Definition RooAbsArg.h:393
void setProxyNormSet(const RooArgSet *nset)
Forward a change in the cached normalization argset to all the registered proxies.
void branchNodeServerList(RooAbsCollection *list, const RooAbsArg *arg=nullptr, bool recurseNonDerived=false) const
Fill supplied list with all branch nodes of the arg tree starting with ourself as top node.
TObject * Clone(const char *newname=nullptr) const override
Make a clone of an object using the Streamer facility.
Definition RooAbsArg.h:91
RefCountList_t _serverList
Definition RooAbsArg.h:606
Int_t numCaches() const
Return number of registered caches.
RooAbsArg * findServer(const char *name) const
Return server of this with name name. Returns nullptr if not found.
Definition RooAbsArg.h:184
OperMode operMode() const
Query the operation mode of this node.
Definition RooAbsArg.h:456
RooAbsArg * _owner
! Pointer to owning RooAbsArg
void setInterpolationOrder(Int_t order)
Set interpolation order of RooHistFunct representing cache histogram.
Abstract base class for objects that represent a discrete value that can be set from the outside,...
Abstract container object that can hold multiple RooAbsArg objects.
virtual bool remove(const RooAbsArg &var, bool silent=false, bool matchByNameOnly=false)
Remove the specified argument from our list.
virtual bool add(const RooAbsArg &var, bool silent=false)
Add the specified argument to list.
Storage_t::size_type size() const
RooAbsArg * first() const
std::string contentsString() const
Return comma separated list of contained object names as STL string.
RooAbsArg * find(const char *name) const
Find object with given name in list.
void Print(Option_t *options=nullptr) const override
This method must be overridden when a class wants to print itself.
Abstract base class for binned and unbinned datasets.
Definition RooAbsData.h:57
virtual Int_t numEntries() const
Return number of entries in dataset, i.e., count unweighted entries.
Abstract base class for generator contexts of RooAbsPdf objects.
virtual void setExpectedData(bool)
virtual RooDataSet * generate(double nEvents=0, bool skipInit=false, bool extendedMode=false)
Generate the specified number of events with nEvents>0 and and return a dataset containing the genera...
bool isValid() const
virtual void setProtoDataOrder(Int_t *lut)
Set the traversal order of prototype data to that in the lookup tables passed as argument.
Normalization set with for above integral.
Definition RooAbsPdf.h:322
std::unique_ptr< RooAbsReal > _norm
Definition RooAbsPdf.h:327
~CacheElem() override
Destructor of normalization cache element.
std::unique_ptr< RooAbsGenContext > _genContext
Definition RooAbsPdf.h:83
RooArgSet _whatVars
Definition RooAbsPdf.h:84
RooDataSet * _protoData
Definition RooAbsPdf.h:85
Abstract interface for all probability density functions.
Definition RooAbsPdf.h:40
virtual bool syncNormalization(const RooArgSet *dset, bool adjustProxies=true) const
Verify that the normalization integral cached with this PDF is valid for given set of normalization o...
double getNorm(const RooArgSet &nset) const
Get normalisation term needed to normalise the raw values returned by getVal().
Definition RooAbsPdf.h:195
std::unique_ptr< RooAbsArg > compileForNormSet(RooArgSet const &normSet, RooFit::Detail::CompileContext &ctx) const override
RooObjCacheManager _normMgr
Definition RooAbsPdf.h:329
std::unique_ptr< RooNumGenConfig > _specGeneratorConfig
! MC generator configuration specific for this object
Definition RooAbsPdf.h:340
double getValV(const RooArgSet *set=nullptr) const override
Return current value, normalized by integrating over the observables in nset.
virtual std::unique_ptr< RooFitResult > fitToImpl(RooAbsData &data, const RooLinkedList &cmdList)
Protected implementation of the likelihood fitting routine.
virtual void generateEvent(Int_t code)
Interface for generation of an event using the algorithm corresponding to the specified code.
RooFit::OwningPtr< RooAbsReal > createScanCdf(const RooArgSet &iset, const RooArgSet &nset, Int_t numScanBins, Int_t intOrder)
void setGeneratorConfig()
Remove the specialized numeric MC generator configuration associated with this object.
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...
static int verboseEval()
Return global level of verbosity for p.d.f. evaluations.
RooFit::OwningPtr< 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.
bool isActiveNormSet(RooArgSet const *normSet) const
Checks if normSet is the currently active normalization set of this PDF, meaning is exactly the same ...
Definition RooAbsPdf.h:299
virtual double expectedEvents(const RooArgSet *nset) const
Return expected number of events to be used in calculation of extended likelihood.
virtual RooAbsGenContext * binnedGenContext(const RooArgSet &vars, bool verbose=false) const
Return a binned generator context.
TString _normRange
Normalization range.
Definition RooAbsPdf.h:342
virtual bool isDirectGenSafe(const RooAbsArg &arg) const
Check if given observable can be safely generated using the pdfs internal generator mechanism (if tha...
Int_t * randomizeProtoOrder(Int_t nProto, Int_t nGen, bool resample=false) const
Return lookup table with randomized order for nProto prototype events.
void setNormRange(const char *rangeName)
~RooAbsPdf() override
Destructor.
RooArgSet const * _normSet
Normalization integral (owned by _normMgr)
Definition RooAbsPdf.h:320
RooPlot * plotOn(RooPlot *frame, const RooCmdArg &arg1={}, const RooCmdArg &arg2={}, const RooCmdArg &arg3={}, const RooCmdArg &arg4={}, const RooCmdArg &arg5={}, const RooCmdArg &arg6={}, const RooCmdArg &arg7={}, const RooCmdArg &arg8={}, const RooCmdArg &arg9={}, const RooCmdArg &arg10={}) const override
Helper calling plotOn(RooPlot*, RooLinkedList&) const.
Definition RooAbsPdf.h:124
RooNumGenConfig * specialGeneratorConfig() const
Returns the specialized integrator configuration for this RooAbsReal.
virtual bool selfNormalized() const
Shows if a PDF is self-normalized, which means that no attempt is made to add a normalization term.
Definition RooAbsPdf.h:207
void printMultiline(std::ostream &os, Int_t contents, bool verbose=false, TString indent="") const override
Print multi line detailed information of this RooAbsPdf.
Int_t _traceCount
Number of traces remaining to print.
Definition RooAbsPdf.h:335
bool canBeExtended() const
If true, PDF can provide extended likelihood term.
Definition RooAbsPdf.h:218
RooAbsReal * _norm
Definition RooAbsPdf.h:319
void setTraceCounter(Int_t value, bool allNodes=false)
Reset trace counter to given value, limiting the number of future trace messages for this pdf to 'val...
GenSpec * prepareMultiGen(const RooArgSet &whatVars, const RooCmdArg &arg1={}, const RooCmdArg &arg2={}, const RooCmdArg &arg3={}, const RooCmdArg &arg4={}, const RooCmdArg &arg5={}, const RooCmdArg &arg6={})
Prepare GenSpec configuration object for efficient generation of multiple datasets from identical spe...
Int_t _errorCount
Number of errors remaining to print.
Definition RooAbsPdf.h:334
@ CanNotBeExtended
Definition RooAbsPdf.h:212
virtual std::unique_ptr< RooAbsReal > createExpectedEventsFunc(const RooArgSet *nset) const
Returns an object that represents the expected number of events for a given normalization set,...
virtual RooPlot * paramOn(RooPlot *frame, const RooCmdArg &arg1={}, const RooCmdArg &arg2={}, const RooCmdArg &arg3={}, const RooCmdArg &arg4={}, const RooCmdArg &arg5={}, const RooCmdArg &arg6={}, const RooCmdArg &arg7={}, const RooCmdArg &arg8={})
Add a box with parameter values (and errors) to the specified frame.
Int_t _negCount
Number of negative probabilities remaining to print.
Definition RooAbsPdf.h:336
RooFit::OwningPtr< RooDataSet > generate(const RooArgSet &whatVars, Int_t nEvents, const RooCmdArg &arg1, const RooCmdArg &arg2={}, const RooCmdArg &arg3={}, const RooCmdArg &arg4={}, const RooCmdArg &arg5={})
See RooAbsPdf::generate(const RooArgSet&,const RooCmdArg&,const RooCmdArg&,const RooCmdArg&,...
Definition RooAbsPdf.h:57
virtual const RooAbsReal * getNormObj(const RooArgSet *set, const RooArgSet *iset, const TNamed *rangeName=nullptr) const
Return pointer to RooAbsReal object that implements calculation of integral over observables iset in ...
void setActiveNormSet(RooArgSet const *normSet) const
Setter for the _normSet member, which should never be set directly.
Definition RooAbsPdf.h:284
double analyticalIntegralWN(Int_t code, const RooArgSet *normSet, const char *rangeName=nullptr) const override
Analytical integral with normalization (see RooAbsReal::analyticalIntegralWN() for further informatio...
void setNormRangeOverride(const char *rangeName)
virtual RooFit::OwningPtr< RooDataSet > generateSimGlobal(const RooArgSet &whatVars, Int_t nEvents)
Special generator interface for generation of 'global observables' – for RooStats tools.
double normalizeWithNaNPacking(double rawVal, double normVal) const
virtual RooAbsGenContext * autoGenContext(const RooArgSet &vars, const RooDataSet *prototype=nullptr, const RooArgSet *auxProto=nullptr, bool verbose=false, bool autoBinned=true, const char *binnedTag="") const
RooArgSet * getAllConstraints(const RooArgSet &observables, RooArgSet &constrainedParams, bool stripDisconnected=true) const
This helper function finds and collects all constraints terms of all component p.d....
const RooNumGenConfig * getGeneratorConfig() const
Return the numeric MC generator configuration used for this object.
virtual void initGenerator(Int_t code)
Interface for one-time initialization to setup the generator for the specified code.
virtual ExtendMode extendMode() const
Returns ability of PDF to provide extended likelihood terms.
Definition RooAbsPdf.h:216
RooAbsPdf()
Default constructor.
virtual RooFit::OwningPtr< RooDataHist > generateBinned(const RooArgSet &whatVars, double nEvents, const RooCmdArg &arg1, const RooCmdArg &arg2={}, const RooCmdArg &arg3={}, const RooCmdArg &arg4={}, const RooCmdArg &arg5={}) const
As RooAbsPdf::generateBinned(const RooArgSet&, const RooCmdArg&,const RooCmdArg&, const RooCmdArg&,...
Definition RooAbsPdf.h:110
bool traceEvalPdf(double value) const
Check that passed value is positive and not 'not-a-number'.
static RooNumGenConfig * defaultGeneratorConfig()
Returns the default numeric MC generator configuration for all RooAbsReals.
bool redirectServersHook(const RooAbsCollection &newServerList, bool mustReplaceAll, bool nameChange, bool isRecursiveStep) override
The cache manager.
void printValue(std::ostream &os) const override
Print value of p.d.f, also print normalization integral that was last used, if any.
virtual std::unique_ptr< RooAbsReal > createNLLImpl(RooAbsData &data, const RooLinkedList &cmdList)
Protected implementation of the NLL creation routine.
void logBatchComputationErrors(std::span< const double > &outputs, std::size_t begin) const
Scan through outputs and fix+log all nans and negative values.
virtual RooAbsGenContext * genContext(const RooArgSet &vars, const RooDataSet *prototype=nullptr, const RooArgSet *auxProto=nullptr, bool verbose=false) const
Interface function to create a generator context from a p.d.f.
void getLogProbabilities(std::span< const double > pdfValues, double *output) const
static TString _normRangeOverride
Definition RooAbsPdf.h:343
static Int_t _verboseEval
Definition RooAbsPdf.h:314
double extendedTerm(double sumEntries, double expected, double sumEntriesW2=0.0, bool doOffset=false) const
virtual Int_t getGenerator(const RooArgSet &directVars, RooArgSet &generateVars, bool staticInitOK=true) const
Load generatedVars with the subset of directVars that we can generate events for, and return a code t...
virtual RooAbsPdf * createProjection(const RooArgSet &iset)
Return a p.d.f that represent a projection of this p.d.f integrated over given observables.
virtual double getLogVal(const RooArgSet *set=nullptr) const
Return the log of the current value with given normalization An error message is printed if the argum...
bool hasRange(const char *name) const override
Check if variable has a binning with given name.
std::pair< double, double > getRange(const char *name=nullptr) const
Get low and high bound of the variable.
Abstract base class for objects that represent a real value and implements functionality common to al...
Definition RooAbsReal.h:59
RooDataHist * fillDataHist(RooDataHist *hist, const RooArgSet *nset, double scaleFactor, bool correctForBinVolume=false, bool showProgress=false) const
Fill a RooDataHist with values sampled from this function at the bin centers.
void plotOnCompSelect(RooArgSet *selNodes) const
Helper function for plotting of composite p.d.fs.
RooFit::OwningPtr< RooAbsReal > createIntegral(const RooArgSet &iset, const RooCmdArg &arg1, const RooCmdArg &arg2={}, const RooCmdArg &arg3={}, const RooCmdArg &arg4={}, const RooCmdArg &arg5={}, const RooCmdArg &arg6={}, const RooCmdArg &arg7={}, const RooCmdArg &arg8={}) const
Create an object that represents the integral of the function over one or more observables listed in ...
double getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
Definition RooAbsReal.h:103
bool plotSanityChecks(RooPlot *frame) const
Utility function for plotOn(), perform general sanity check on frame to ensure safe plotting operatio...
void printMultiline(std::ostream &os, Int_t contents, bool verbose=false, TString indent="") const override
Structure printing.
bool redirectServersHook(const RooAbsCollection &newServerList, bool mustReplaceAll, bool nameChange, bool isRecursiveStep) override
Function that is called at the end of redirectServers().
double _value
Cache for current value of object.
Definition RooAbsReal.h:537
virtual double analyticalIntegral(Int_t code, const char *rangeName=nullptr) const
Implements the actual analytical integral(s) advertised by getAnalyticalIntegral.
TString integralNameSuffix(const RooArgSet &iset, const RooArgSet *nset=nullptr, const char *rangeName=nullptr, bool omitEmpty=false) const
Construct string with unique suffix name to give to integral object that encodes integrated observabl...
virtual double evaluate() const =0
Evaluate this PDF / function / constant. Needs to be overridden by all derived classes.
void logEvalError(const char *message, const char *serverValueString=nullptr) const
Log evaluation error message.
const RooNumIntConfig * getIntegratorConfig() const
Return the numeric integration configuration used for this object.
virtual bool isBinnedDistribution(const RooArgSet &) const
Tests if the distribution is binned. Unless overridden by derived classes, this always returns false.
Definition RooAbsReal.h:347
RooFit::OwningPtr< RooAbsReal > createIntRI(const RooArgSet &iset, const RooArgSet &nset={})
Utility function for createRunningIntegral.
virtual RooPlot * plotOn(RooPlot *frame, const RooCmdArg &arg1={}, const RooCmdArg &arg2={}, const RooCmdArg &arg3={}, const RooCmdArg &arg4={}, const RooCmdArg &arg5={}, const RooCmdArg &arg6={}, const RooCmdArg &arg7={}, const RooCmdArg &arg8={}, const RooCmdArg &arg9={}, const RooCmdArg &arg10={}) const
Plot (project) PDF on specified frame.
RooArgList is a container object that can hold multiple RooAbsArg objects.
Definition RooArgList.h:22
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition RooArgSet.h:24
RooArgSet * selectByName(const char *nameList, bool verbose=false) const
Use RooAbsCollection::selectByName(), but return as RooArgSet.
Definition RooArgSet.h:144
RooArgSet * selectCommon(const RooAbsCollection &refColl) const
Use RooAbsCollection::selecCommon(), but return as RooArgSet.
Definition RooArgSet.h:149
Efficient implementation of the generator context specific for binned pdfs.
Int_t setObj(const RooArgSet *nset, T *obj, const TNamed *isetRangeName=nullptr)
Setter function without integration set.
T * getObj(const RooArgSet *nset, Int_t *sterileIndex=nullptr, const TNamed *isetRangeName=nullptr)
Getter function without integration set.
Implementation of RooAbsCachedReal that can cache any external RooAbsReal input function provided in ...
void setCacheSource(bool flag)
Named container for two doubles, two integers two object points and three string pointers that can be...
Definition RooCmdArg.h:26
void setString(Int_t idx, const char *value)
Definition RooCmdArg.h:78
Configurable parser for RooCmdArg named arguments.
void defineMutex(const char *head, Args_t &&... tail)
Define arguments where any pair is mutually exclusive.
bool process(const RooCmdArg &arg)
Process given RooCmdArg.
bool hasProcessed(const char *cmdName) const
Return true if RooCmdArg with name 'cmdName' has been processed.
double getDouble(const char *name, double defaultValue=0.0) const
Return double property registered with name 'name'.
bool defineDouble(const char *name, const char *argName, int doubleNum, double defValue=0.0)
Define double property name 'name' mapped to double in slot 'doubleNum' in RooCmdArg with name argNam...
static void stripCmdList(RooLinkedList &cmdList, const char *cmdsToPurge)
Utility function that strips command names listed (comma separated) in cmdsToPurge from cmdList.
RooArgSet * getSet(const char *name, RooArgSet *set=nullptr) const
Return RooArgSet property registered with name 'name'.
bool defineSet(const char *name, const char *argName, int setNum, const RooArgSet *set=nullptr)
Define TObject property name 'name' mapped to object in slot 'setNum' in RooCmdArg with name argName ...
bool ok(bool verbose) const
Return true of parsing was successful.
bool defineObject(const char *name, const char *argName, int setNum, const TObject *obj=nullptr, bool isArray=false)
Define TObject property name 'name' mapped to object in slot 'setNum' in RooCmdArg with name argName ...
const char * getString(const char *name, const char *defaultValue="", bool convEmptyToNull=false) const
Return string property registered with name 'name'.
bool defineString(const char *name, const char *argName, int stringNum, const char *defValue="", bool appendMode=false)
Define double property name 'name' mapped to double in slot 'stringNum' in RooCmdArg with name argNam...
bool defineInt(const char *name, const char *argName, int intNum, int defValue=0)
Define integer property name 'name' mapped to integer in slot 'intNum' in RooCmdArg with name argName...
void allowUndefined(bool flag=true)
If flag is true the processing of unrecognized RooCmdArgs is not considered an error.
int getInt(const char *name, int defaultValue=0) const
Return integer property registered with name 'name'.
TObject * getObject(const char *name, TObject *obj=nullptr) const
Return TObject property registered with name 'name'.
Container class to hold unbinned data.
Definition RooDataSet.h:33
void markAsCompiled(RooAbsArg &arg) const
void compileServers(RooAbsArg &arg, RooArgSet const &normSet)
Implements a universal generator context for all RooAbsPdf classes that do not have or need a special...
Switches the message service to a different level while the instance is alive.
Definition RooHelpers.h:37
Collection class for internal use, storing a collection of RooAbsArg pointers in a doubly linked list...
virtual void Add(TObject *arg)
TObject * FindObject(const char *name) const override
Return pointer to object with given name.
static const char * str(const TNamed *ptr)
Return C++ string corresponding to given TNamed pointer.
Definition RooNameReg.h:39
Holds the configuration parameters of the various numeric integrators used by RooRealIntegral.
static RooNumGenConfig & defaultConfig()
Return reference to instance of default numeric integrator configuration object.
Implementation of a RooCacheManager<RooAbsCacheElement> that specializes in the storage of cache elem...
void sterilize() override
Clear the cache payload but retain slot mapping w.r.t to normalization and integration sets.
Plot frame and a container for graphics objects within that frame.
Definition RooPlot.h:45
void addObject(TObject *obj, Option_t *drawOptions="", bool invisible=false)
Add a generic object to this plot.
Definition RooPlot.cxx:366
double getFitRangeNEvt() const
Return the number of events in the fit range.
Definition RooPlot.h:145
const RooArgSet * getNormVars() const
Definition RooPlot.h:152
RooAbsRealLValue * getPlotVar() const
Definition RooPlot.h:143
void updateNormVars(const RooArgSet &vars)
Install the given set of observables are reference normalization variables for this frame.
Definition RooPlot.cxx:351
double getFitRangeBinW() const
Return the bin width that is being used to normalise the PDF.
Definition RooPlot.h:148
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,...
A RooAbsPdf implementation that represent a projection of a given input p.d.f and the object returned...
static UInt_t integer(UInt_t max, TRandom *generator=randomGenerator())
Return an integer uniformly distributed from [0,n-1].
Definition RooRandom.cxx:96
static TRandom * randomGenerator()
Return a pointer to a singleton random-number generator implementation.
Definition RooRandom.cxx:48
Performs hybrid numerical/analytical integrals of RooAbsReal objects.
const RooArgSet & numIntRealVars() const
Variable that can be changed from the outside.
Definition RooRealVar.h:37
void setBins(Int_t nBins, const char *name=nullptr)
Create a uniform binning under name 'name' for this variable.
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
const char * GetName() const override
Returns name of object.
Definition TNamed.h:47
const char * GetTitle() const override
Returns title of object.
Definition TNamed.h:48
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition TObject.cxx:213
A Pave (see TPave) with text, lines or/and boxes inside.
Definition TPaveText.h:21
virtual ULong64_t Poisson(Double_t mean)
Generates a random integer N according to a Poisson law.
Definition TRandom.cxx:404
virtual Double_t Uniform(Double_t x1=1)
Returns a uniform deviate on the interval (0, x1).
Definition TRandom.cxx:682
virtual UInt_t Integer(UInt_t imax)
Returns a random integer uniformly distributed on the interval [ 0, imax-1 ].
Definition TRandom.cxx:361
Basic string class.
Definition TString.h:139
Ssiz_t Length() const
Definition TString.h:417
void Clear()
Clear string without changing its capacity.
Definition TString.cxx:1235
const char * Data() const
Definition TString.h:376
TLine * line
void box(Int_t pat, Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Definition fillpatterns.C:1
RooCmdArg SupNormSet(const RooArgSet &nset)
RooCmdArg NormRange(const char *rangeNameList)
RooCmdArg Range(const char *rangeName, bool adjustNorm=true)
RooCmdArg Normalization(double scaleFactor)
std::vector< std::string > Split(std::string_view str, std::string_view delims, bool skipEmpty=false)
Splits a string at each character in delims.
OwningPtr< T > makeOwningPtr(std::unique_ptr< T > &&ptr)
Internal helper to turn a std::unique_ptr<T> into an OwningPtr.
Definition Config.h:40
T * OwningPtr
An alias for raw pointers for indicating that the return type of a RooFit function is an owning point...
Definition Config.h:35
RooArgSet selectFromArgSet(RooArgSet const &, std::string const &names)
std::string getColonSeparatedNameString(RooArgSet const &argSet, char delim=':')
Bool_t IsNaN(Double_t x)
Definition TMath.h:892
Double_t QuietNaN()
Returns a quiet NaN as defined by IEEE 754.
Definition TMath.h:902
__roodevice__ static __roohost__ double packFloatIntoNaN(float payload)
Pack float into mantissa of a NaN.
static void output()