Logo ROOT  
Reference Guide
RooAbsReal.h
Go to the documentation of this file.
1 /*****************************************************************************
2  * Project: RooFit *
3  * Package: RooFitCore *
4  * File: $Id: RooAbsReal.h,v 1.75 2007/07/13 21:50:24 wouter Exp $
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 #ifndef ROO_ABS_REAL
17 #define ROO_ABS_REAL
18 
19 #include "RooAbsArg.h"
20 #include "RooCmdArg.h"
21 #include "RooCurve.h"
22 #include "RooArgSet.h"
23 #include "RooArgList.h"
24 #include "RooGlobalFunc.h"
25 #include "RooSpan.h"
26 #include <map>
27 
28 class RooArgList ;
29 class RooDataSet ;
30 class RooPlot;
31 class RooRealVar;
32 class RooAbsFunc;
34 class RooCategory ;
35 class RooLinkedList ;
36 class RooNumIntConfig ;
37 class RooDataHist ;
38 class RooFunctor ;
39 class RooGenFunction ;
40 class RooMultiGenFunction ;
41 class RooFitResult ;
42 class RooAbsMoment ;
43 class RooDerivative ;
44 class RooVectorDataStore ;
45 namespace RooBatchCompute{
47 struct RunContext;
48 }
49 struct TreeReadBuffer; /// A space to attach TBranches
50 
51 class TH1;
52 class TH1F;
53 class TH2F;
54 class TH3F;
55 
56 #include <list>
57 #include <string>
58 #include <iostream>
59 #include <sstream>
60 
61 class RooAbsReal : public RooAbsArg {
62 public:
63  using value_type = double;
64 
65  // Constructors, assignment etc
66  RooAbsReal() ;
67  RooAbsReal(const char *name, const char *title, const char *unit= "") ;
68  RooAbsReal(const char *name, const char *title, Double_t minVal, Double_t maxVal,
69  const char *unit= "") ;
70  RooAbsReal(const RooAbsReal& other, const char* name=0);
71  RooAbsReal& operator=(const RooAbsReal& other);
72  virtual ~RooAbsReal();
73 
74 
75 
76 
77  //////////////////////////////////////////////////////////////////////////////////
78  /// Evaluate object. Returns either cached value or triggers a recalculation.
79  /// The recalculation happens by calling getValV(), which in the end calls the
80  /// virtual evaluate() functions of the respective PDFs.
81  /// \param[in] normalisationSet getValV() reacts differently depending on the value of the normalisation set.
82  /// If the set is `nullptr`, an unnormalised value is returned.
83  /// \note The normalisation is arbitrary, because it is up to the implementation
84  /// of the PDF to e.g. leave out normalisation constants for speed reasons. The range
85  /// of the variables is also ignored.
86  ///
87  /// To normalise the result properly, a RooArgSet has to be passed, which contains
88  /// the variables to normalise over.
89  /// These are integrated over their current ranges to compute the normalisation constant,
90  /// and the unnormalised result is divided by this value.
91  inline Double_t getVal(const RooArgSet* normalisationSet = nullptr) const {
92  // Sometimes, the calling code uses an empty RooArgSet to request evaluation
93  // without normalization set instead of following the `nullptr` convention.
94  // To remove this ambiguity which might not always be correctly handled in
95  // downstream code, we set `normalisationSet` to nullptr if it is pointing
96  // to an empty set.
97  if(normalisationSet && normalisationSet->empty()) {
98  normalisationSet = nullptr;
99  }
100 #ifdef ROOFIT_CHECK_CACHED_VALUES
101  return _DEBUG_getVal(normalisationSet);
102 #else
103 
104 #ifndef _WIN32
105  return (_fast && !_inhibitDirty) ? _value : getValV(normalisationSet) ;
106 #else
107  return (_fast && !inhibitDirty()) ? _value : getValV(normalisationSet) ;
108 #endif
109 
110 #endif
111  }
112 
113  /// Like getVal(const RooArgSet*), but always requires an argument for normalisation.
114  inline Double_t getVal(const RooArgSet& normalisationSet) const {
115  // Sometimes, the calling code uses an empty RooArgSet to request evaluation
116  // without normalization set instead of following the `nullptr` convention.
117  // To remove this ambiguity which might not always be correctly handled in
118  // downstream code, we set `normalisationSet` to nullptr if it is an empty set.
119  return _fast ? _value : getValV(normalisationSet.empty() ? nullptr : &normalisationSet) ;
120  }
121 
122  virtual Double_t getValV(const RooArgSet* normalisationSet = nullptr) const ;
123 
124  /// \deprecated getValBatch() has been removed in favour of the faster getValues(). If your code is affected
125  /// by this change, please consult the release notes for ROOT 6.24 for guidance on how to make this transition.
126  /// https://root.cern/doc/v624/release-notes.html
127 #ifndef R__MACOSX
128  virtual RooSpan<const double> getValBatch(std::size_t /*begin*/, std::size_t /*maxSize*/, const RooArgSet* /*normSet*/ = nullptr) = delete;
129 #else
130  //AppleClang in MacOS10.14 has a linker bug and fails to link programs that create objects of classes containing virtual deleted methods.
131  //This can be safely deleted when MacOS10.14 is no longer supported by ROOT. See https://reviews.llvm.org/D37830
132  virtual RooSpan<const double> getValBatch(std::size_t /*begin*/, std::size_t /*maxSize*/, const RooArgSet* /*normSet*/ = nullptr) final {
133  throw std::logic_error("Deprecated getValBatch() has been removed in favour of the faster getValues(). If your code is affected by this change, please consult the release notes for ROOT 6.24 for guidance on how to make this transition. https://root.cern/doc/v624/release-notes.html");
134  }
135 #endif
136  /// by this change, please consult the release notes for ROOT 6.24 for guidance on how to make this transition.
137  virtual RooSpan<const double> getValues(RooBatchCompute::RunContext& evalData, const RooArgSet* normSet = nullptr) const;
138 
139  Double_t getPropagatedError(const RooFitResult &fr, const RooArgSet &nset = RooArgSet()) const;
140 
141  Bool_t operator==(Double_t value) const ;
142  virtual Bool_t operator==(const RooAbsArg& other) const;
143  virtual Bool_t isIdentical(const RooAbsArg& other, Bool_t assumeSameType=kFALSE) const;
144 
145 
146  inline const Text_t *getUnit() const {
147  // Return string with unit description
148  return _unit.Data();
149  }
150  inline void setUnit(const char *unit) {
151  // Set unit description to given string
152  _unit= unit;
153  }
154  TString getTitle(Bool_t appendUnit= kFALSE) const;
155 
156  // Lightweight interface adaptors (caller takes ownership)
157  RooAbsFunc *bindVars(const RooArgSet &vars, const RooArgSet* nset=0, Bool_t clipInvalid=kFALSE) const;
158 
159  // Create a fundamental-type object that can hold our value.
160  RooAbsArg *createFundamental(const char* newname=0) const;
161 
162  // Analytical integration support
163  virtual Int_t getAnalyticalIntegralWN(RooArgSet& allVars, RooArgSet& analVars, const RooArgSet* normSet, const char* rangeName=0) const ;
164  virtual Double_t analyticalIntegralWN(Int_t code, const RooArgSet* normSet, const char* rangeName=0) const ;
165  virtual Int_t getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, const char* rangeName=0) const ;
166  virtual Double_t analyticalIntegral(Int_t code, const char* rangeName=0) const ;
167  virtual Bool_t forceAnalyticalInt(const RooAbsArg& /*dep*/) const {
168  // Interface to force RooRealIntegral to offer given observable for internal integration
169  // even if this is deemed unsafe. This default implementation returns always flase
170  return kFALSE ;
171  }
172  virtual void forceNumInt(Bool_t flag=kTRUE) {
173  // If flag is true, all advertised analytical integrals will be ignored
174  // and all integrals are calculated numerically
175  _forceNumInt = flag ;
176  }
177  Bool_t getForceNumInt() const { return _forceNumInt ; }
178 
179  // Chi^2 fits to histograms
180  virtual RooFitResult* chi2FitTo(RooDataHist& data, const RooCmdArg& arg1=RooCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),
181  const RooCmdArg& arg3=RooCmdArg::none(), const RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::none(),
182  const RooCmdArg& arg6=RooCmdArg::none(), const RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::none()) ;
183  virtual RooFitResult* chi2FitTo(RooDataHist& data, const RooLinkedList& cmdList) ;
184 
185  virtual RooAbsReal* createChi2(RooDataHist& data, const RooLinkedList& cmdList) ;
186  virtual RooAbsReal* createChi2(RooDataHist& data, const RooCmdArg& arg1=RooCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),
187  const RooCmdArg& arg3=RooCmdArg::none(), const RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::none(),
188  const RooCmdArg& arg6=RooCmdArg::none(), const RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::none()) ;
189 
190  // Chi^2 fits to X-Y datasets
191  virtual RooFitResult* chi2FitTo(RooDataSet& xydata, const RooCmdArg& arg1=RooCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),
192  const RooCmdArg& arg3=RooCmdArg::none(), const RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::none(),
193  const RooCmdArg& arg6=RooCmdArg::none(), const RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::none()) ;
194  virtual RooFitResult* chi2FitTo(RooDataSet& xydata, const RooLinkedList& cmdList) ;
195 
196  virtual RooAbsReal* createChi2(RooDataSet& data, const RooLinkedList& cmdList) ;
197  virtual RooAbsReal* createChi2(RooDataSet& data, const RooCmdArg& arg1=RooCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),
198  const RooCmdArg& arg3=RooCmdArg::none(), const RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::none(),
199  const RooCmdArg& arg6=RooCmdArg::none(), const RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::none()) ;
200 
201 
202  virtual RooAbsReal* createProfile(const RooArgSet& paramsOfInterest) ;
203 
204 
205  RooAbsReal* createIntegral(const RooArgSet& iset, const RooCmdArg& arg1, const RooCmdArg& arg2=RooCmdArg::none(),
206  const RooCmdArg& arg3=RooCmdArg::none(), const RooCmdArg& arg4=RooCmdArg::none(),
207  const RooCmdArg& arg5=RooCmdArg::none(), const RooCmdArg& arg6=RooCmdArg::none(),
208  const RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::none()) const ;
209 
210  /// Create integral over observables in iset in range named rangeName.
211  RooAbsReal* createIntegral(const RooArgSet& iset, const char* rangeName) const {
212  return createIntegral(iset,0,0,rangeName) ;
213  }
214  /// Create integral over observables in iset in range named rangeName with integrand normalized over observables in nset
215  RooAbsReal* createIntegral(const RooArgSet& iset, const RooArgSet& nset, const char* rangeName=0) const {
216  return createIntegral(iset,&nset,0,rangeName) ;
217  }
218  /// Create integral over observables in iset in range named rangeName with integrand normalized over observables in nset while
219  /// using specified configuration for any numeric integration.
220  RooAbsReal* createIntegral(const RooArgSet& iset, const RooArgSet& nset, const RooNumIntConfig& cfg, const char* rangeName=0) const {
221  return createIntegral(iset,&nset,&cfg,rangeName) ;
222  }
223  /// Create integral over observables in iset in range named rangeName using specified configuration for any numeric integration.
224  RooAbsReal* createIntegral(const RooArgSet& iset, const RooNumIntConfig& cfg, const char* rangeName=0) const {
225  return createIntegral(iset,0,&cfg,rangeName) ;
226  }
227  virtual RooAbsReal* createIntegral(const RooArgSet& iset, const RooArgSet* nset=0, const RooNumIntConfig* cfg=0, const char* rangeName=0) const ;
228 
229 
230  void setParameterizeIntegral(const RooArgSet& paramVars) ;
231 
232  // Create running integrals
233  RooAbsReal* createRunningIntegral(const RooArgSet& iset, const RooArgSet& nset=RooArgSet()) ;
234  RooAbsReal* createRunningIntegral(const RooArgSet& iset, const RooCmdArg& arg1, const RooCmdArg& arg2=RooCmdArg::none(),
235  const RooCmdArg& arg3=RooCmdArg::none(), const RooCmdArg& arg4=RooCmdArg::none(),
236  const RooCmdArg& arg5=RooCmdArg::none(), const RooCmdArg& arg6=RooCmdArg::none(),
237  const RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::none()) ;
238  RooAbsReal* createIntRI(const RooArgSet& iset, const RooArgSet& nset=RooArgSet()) ;
239  RooAbsReal* createScanRI(const RooArgSet& iset, const RooArgSet& nset, Int_t numScanBins, Int_t intOrder) ;
240 
241 
242  // Optimized accept/reject generator support
243  virtual Int_t getMaxVal(const RooArgSet& vars) const ;
244  virtual Double_t maxVal(Int_t code) const ;
245  virtual Int_t minTrialSamples(const RooArgSet& /*arGenObs*/) const { return 0 ; }
246 
247 
248  // Plotting options
249  void setPlotLabel(const char *label);
250  const char *getPlotLabel() const;
251 
252  virtual Double_t defaultErrorLevel() const {
253  // Return default level for MINUIT error analysis
254  return 1.0 ;
255  }
256 
257  const RooNumIntConfig* getIntegratorConfig() const ;
262  void setIntegratorConfig() ;
263  void setIntegratorConfig(const RooNumIntConfig& config) ;
264 
265  virtual void fixAddCoefNormalization(const RooArgSet& addNormSet=RooArgSet(),Bool_t force=kTRUE) ;
266  virtual void fixAddCoefRange(const char* rangeName=0,Bool_t force=kTRUE) ;
267 
268  virtual void preferredObservableScanOrder(const RooArgSet& obs, RooArgSet& orderedObs) const ;
269 
270  // User entry point for plotting
271  virtual RooPlot* plotOn(RooPlot* frame,
272  const RooCmdArg& arg1=RooCmdArg(), const RooCmdArg& arg2=RooCmdArg(),
273  const RooCmdArg& arg3=RooCmdArg(), const RooCmdArg& arg4=RooCmdArg(),
274  const RooCmdArg& arg5=RooCmdArg(), const RooCmdArg& arg6=RooCmdArg(),
275  const RooCmdArg& arg7=RooCmdArg(), const RooCmdArg& arg8=RooCmdArg(),
276  const RooCmdArg& arg9=RooCmdArg(), const RooCmdArg& arg10=RooCmdArg()
277  ) const ;
278 
279 
281 
282  // Forwarder function for backward compatibility
283  virtual RooPlot *plotSliceOn(RooPlot *frame, const RooArgSet& sliceSet, Option_t* drawOptions="L",
284  Double_t scaleFactor=1.0, ScaleType stype=Relative, const RooAbsData* projData=0) const;
285 
286  // Fill an existing histogram
287  TH1 *fillHistogram(TH1 *hist, const RooArgList &plotVars,
288  Double_t scaleFactor= 1, const RooArgSet *projectedVars= 0, Bool_t scaling=kTRUE,
289  const RooArgSet* condObs=0, Bool_t setError=kTRUE) const;
290 
291  // Create 1,2, and 3D histograms from and fill it
292  TH1 *createHistogram(const char* varNameList, Int_t xbins=0, Int_t ybins=0, Int_t zbins=0) const ;
293  TH1* createHistogram(const char *name, const RooAbsRealLValue& xvar, RooLinkedList& argList) const ;
294  TH1 *createHistogram(const char *name, const RooAbsRealLValue& xvar,
295  const RooCmdArg& arg1=RooCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),
296  const RooCmdArg& arg3=RooCmdArg::none(), const RooCmdArg& arg4=RooCmdArg::none(),
297  const RooCmdArg& arg5=RooCmdArg::none(), const RooCmdArg& arg6=RooCmdArg::none(),
298  const RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::none()) const ;
299 
300  // Fill a RooDataHist
301  RooDataHist* fillDataHist(RooDataHist *hist, const RooArgSet* nset, Double_t scaleFactor,
302  Bool_t correctForBinVolume=kFALSE, Bool_t showProgress=kFALSE) const ;
303 
304  // I/O streaming interface (machine readable)
305  virtual Bool_t readFromStream(std::istream& is, Bool_t compact, Bool_t verbose=kFALSE) ;
306  virtual void writeToStream(std::ostream& os, Bool_t compact) const ;
307 
308  // Printing interface (human readable)
309  virtual void printValue(std::ostream& os) const ;
310  virtual void printMultiline(std::ostream& os, Int_t contents, Bool_t verbose=kFALSE, TString indent="") const ;
311 
312  inline void setCachedValue(double value, bool notifyClients = true) final;
313 
314  // Evaluation error logging
315  class EvalError {
316  public:
317  EvalError() { }
318  EvalError(const EvalError& other) : _msg(other._msg), _srvval(other._srvval) { }
319  void setMessage(const char* tmp) { std::string s(tmp); s.swap(_msg); }
320  void setServerValues(const char* tmp) { std::string s(tmp); s.swap(_srvval); }
321  std::string _msg;
322  std::string _srvval;
323  } ;
324 
328  void logEvalError(const char* message, const char* serverValueString=0) const ;
329  static void logEvalError(const RooAbsReal* originator, const char* origName, const char* message, const char* serverValueString=0) ;
330  static void printEvalErrors(std::ostream&os=std::cout, Int_t maxPerNode=10000000) ;
331  static Int_t numEvalErrors() ;
332  static Int_t numEvalErrorItems() ;
333 
334 
335  typedef std::map<const RooAbsArg*,std::pair<std::string,std::list<EvalError> > >::const_iterator EvalErrorIter ;
336  static EvalErrorIter evalErrorIter() ;
337 
338  static void clearEvalErrorLog() ;
339 
340  /// Tests if the distribution is binned. Unless overridden by derived classes, this always returns false.
341  virtual Bool_t isBinnedDistribution(const RooArgSet& /*obs*/) const { return kFALSE ; }
342  virtual std::list<Double_t>* binBoundaries(RooAbsRealLValue& obs, Double_t xlo, Double_t xhi) const;
343  virtual std::list<Double_t>* plotSamplingHint(RooAbsRealLValue& obs, Double_t xlo, Double_t xhi) const;
344 
346  RooMultiGenFunction* iGenFunction(const RooArgSet& observables, const RooArgSet& nset=RooArgSet()) ;
347 
348  RooFunctor* functor(const RooArgList& obs, const RooArgList& pars=RooArgList(), const RooArgSet& nset=RooArgSet()) const ;
349  TF1* asTF(const RooArgList& obs, const RooArgList& pars=RooArgList(), const RooArgSet& nset=RooArgSet()) const ;
350 
351  RooDerivative* derivative(RooRealVar& obs, Int_t order=1, Double_t eps=0.001) ;
352  RooDerivative* derivative(RooRealVar& obs, const RooArgSet& normSet, Int_t order, Double_t eps=0.001) ;
353 
354  RooAbsMoment* moment(RooRealVar& obs, Int_t order, Bool_t central, Bool_t takeRoot) ;
355  RooAbsMoment* moment(RooRealVar& obs, const RooArgSet& normObs, Int_t order, Bool_t central, Bool_t takeRoot, Bool_t intNormObs) ;
356 
357  RooAbsMoment* mean(RooRealVar& obs) { return moment(obs,1,kFALSE,kFALSE) ; }
358  RooAbsMoment* mean(RooRealVar& obs, const RooArgSet& nset) { return moment(obs,nset,1,kFALSE,kFALSE,kTRUE) ; }
359  RooAbsMoment* sigma(RooRealVar& obs) { return moment(obs,2,kTRUE,kTRUE) ; }
360  RooAbsMoment* sigma(RooRealVar& obs, const RooArgSet& nset) { return moment(obs,nset,2,kTRUE,kTRUE,kTRUE) ; }
361 
363 
364 
365  virtual Bool_t setData(RooAbsData& /*data*/, Bool_t /*cloneData*/=kTRUE) { return kTRUE ; }
366 
367  virtual void enableOffsetting(Bool_t) {} ;
368  virtual Bool_t isOffsetting() const { return kFALSE ; }
369  virtual Double_t offset() const { return 0 ; }
370 
371  static void setHideOffset(Bool_t flag);
372  static Bool_t hideOffset() ;
373 
374 protected:
375  // Hook for objects with normalization-dependent parameters interperetation
376  virtual void selectNormalization(const RooArgSet* depSet=0, Bool_t force=kFALSE) ;
377  virtual void selectNormalizationRange(const char* rangeName=0, Bool_t force=kFALSE) ;
378 
379  // Helper functions for plotting
380  Bool_t plotSanityChecks(RooPlot* frame) const ;
381  void makeProjectionSet(const RooAbsArg* plotVar, const RooArgSet* allVars,
382  RooArgSet& projectedVars, Bool_t silent) const ;
383 
384  TString integralNameSuffix(const RooArgSet& iset, const RooArgSet* nset=0, const char* rangeName=0, Bool_t omitEmpty=kFALSE) const ;
385 
386 
387  Bool_t isSelectedComp() const ;
388 
389 
390  public:
391  const RooAbsReal* createPlotProjection(const RooArgSet& depVars, const RooArgSet& projVars, RooArgSet*& cloneSet) const ;
392  const RooAbsReal *createPlotProjection(const RooArgSet &dependentVars, const RooArgSet *projectedVars,
393  RooArgSet *&cloneSet, const char* rangeName=0, const RooArgSet* condObs=0) const;
394  protected:
395 
397 
398  void plotOnCompSelect(RooArgSet* selNodes) const ;
399  RooPlot* plotOnWithErrorBand(RooPlot* frame,const RooFitResult& fr, Double_t Z, const RooArgSet* params, const RooLinkedList& argList, Bool_t method1) const ;
400 
401  // Support interface for subclasses to advertise their analytic integration
402  // and generator capabilities in their analyticalIntegral() and generateEvent()
403  // implementations.
404  Bool_t matchArgs(const RooArgSet& allDeps, RooArgSet& numDeps,
405  const RooArgProxy& a) const ;
406  Bool_t matchArgs(const RooArgSet& allDeps, RooArgSet& numDeps,
407  const RooArgProxy& a, const RooArgProxy& b) const ;
408  Bool_t matchArgs(const RooArgSet& allDeps, RooArgSet& numDeps,
409  const RooArgProxy& a, const RooArgProxy& b, const RooArgProxy& c) const ;
410  Bool_t matchArgs(const RooArgSet& allDeps, RooArgSet& numDeps,
411  const RooArgProxy& a, const RooArgProxy& b,
412  const RooArgProxy& c, const RooArgProxy& d) const ;
413 
414  Bool_t matchArgs(const RooArgSet& allDeps, RooArgSet& numDeps,
415  const RooArgSet& set) const ;
416 
417 
418  RooAbsReal* createIntObj(const RooArgSet& iset, const RooArgSet* nset, const RooNumIntConfig* cfg, const char* rangeName) const ;
419  void findInnerMostIntegration(const RooArgSet& allObs, RooArgSet& innerObs, const char* rangeName) const ;
420 
421 
422  // Internal consistency checking (needed by RooDataSet)
423  /// Check if current value is valid.
424  virtual bool isValid() const { return isValidReal(_value); }
425  /// Interface function to check if given value is a valid value for this object. Returns true unless overridden.
426  virtual bool isValidReal(double /*value*/, bool printError = false) const { (void)printError; return true; }
427 
428 
429  // Function evaluation and error tracing
430  Double_t traceEval(const RooArgSet* set) const ;
431 
432  /// Evaluate this PDF / function / constant. Needs to be overridden by all derived classes.
433  virtual Double_t evaluate() const = 0;
434 
435  /// \deprecated evaluateBatch() has been removed in favour of the faster evaluateSpan(). If your code is affected
436  /// by this change, please consult the release notes for ROOT 6.24 for guidance on how to make this transition.
437  /// https://root.cern/doc/v624/release-notes.html
438 #ifndef R__MACOSX
439  virtual RooSpan<double> evaluateBatch(std::size_t /*begin*/, std::size_t /*maxSize*/) = delete;
440 #else
441  //AppleClang in MacOS10.14 has a linker bug and fails to link programs that create objects of classes containing virtual deleted methods.
442  //This can be safely deleted when MacOS10.14 is no longer supported by ROOT. See https://reviews.llvm.org/D37830
443  virtual RooSpan<double> evaluateBatch(std::size_t /*begin*/, std::size_t /*maxSize*/) final {
444  throw std::logic_error("Deprecated evaluatedBatch() has been removed in favour of the faster evaluateSpan(). If your code is affected by this change, please consult the release notes for ROOT 6.24 for guidance on how to make this transition. https://root.cern/doc/v624/release-notes.html");
445  }
446 #endif
447 
448  virtual RooSpan<double> evaluateSpan(RooBatchCompute::RunContext& evalData, const RooArgSet* normSet) const;
449 
450  //---------- Interface to access batch data ---------------------------
451  //
453 
454  private:
455  void checkBatchComputation(const RooBatchCompute::RunContext& evalData, std::size_t evtNo, const RooArgSet* normSet = nullptr, double relAccuracy = 1.E-13) const;
456 
457  /// Debug version of getVal(), which is slow and does error checking.
458  Double_t _DEBUG_getVal(const RooArgSet* normalisationSet) const;
459 
460  //--------------------------------------------------------------------
461 
462  protected:
463  // Hooks for RooDataSet interface
464  friend class RooRealIntegral ;
465  friend class RooVectorDataStore ;
466  virtual void syncCache(const RooArgSet* set=0) { getVal(set) ; }
467  virtual void copyCache(const RooAbsArg* source, Bool_t valueOnly=kFALSE, Bool_t setValDirty=kTRUE) ;
468  virtual void attachToTree(TTree& t, Int_t bufSize=32000) ;
469  virtual void attachToVStore(RooVectorDataStore& vstore) ;
470  virtual void setTreeBranchStatus(TTree& t, Bool_t active) ;
471  virtual void fillTreeBranch(TTree& t) ;
472 
473  friend class RooRealBinding ;
474  Double_t _plotMin ; // Minimum of plot range
475  Double_t _plotMax ; // Maximum of plot range
476  Int_t _plotBins ; // Number of plot bins
477  mutable Double_t _value ; // Cache for current value of object
478  TString _unit ; // Unit for objects value
479  TString _label ; // Plot label for objects value
480  Bool_t _forceNumInt ; // Force numerical integration if flag set
481 
482  friend class RooAbsPdf ;
483  friend class RooAbsAnaConvPdf ;
484 
485  RooNumIntConfig* _specIntegratorConfig ; // Numeric integrator configuration specific for this object
486 
487  friend class RooDataProjBinding ;
488  friend class RooAbsOptGoodnessOfFit ;
489 
490  struct PlotOpt {
504  const char* normRangeName ;
509  const char* projectionRangeName ;
511  const char* curveName ;
512  const char* addToCurveName ;
517  const char* curveNameSuffix ;
523  } ;
524 
525  // Plot implementation functions
526  virtual RooPlot *plotOn(RooPlot* frame, PlotOpt o) const;
527 
528 public:
529  // PlotOn with command list
530  virtual RooPlot* plotOn(RooPlot* frame, RooLinkedList& cmdList) const ;
531 
532  protected:
533  virtual RooPlot *plotAsymOn(RooPlot *frame, const RooAbsCategoryLValue& asymCat, PlotOpt o) const;
534 
535 
536 private:
537 
539  static std::map<const RooAbsArg*,std::pair<std::string,std::list<EvalError> > > _evalErrorList ;
541 
542  Bool_t matchArgsByName(const RooArgSet &allArgs, RooArgSet &matchedArgs, const TList &nameList) const;
543 
544  std::unique_ptr<TreeReadBuffer> _treeReadBuffer; //! A buffer for reading values from trees
545 
546 protected:
547 
548 
549  friend class RooRealSumPdf ;
550  friend class RooRealSumFunc;
551  friend class RooAddPdf ;
552  friend class RooAddModel ;
553  void selectComp(Bool_t flag) {
554  // If flag is true, only selected component will be included in evaluates of RooAddPdf components
555  _selectComp = flag ;
556  }
557  static void globalSelectComp(Bool_t flag) ;
558  Bool_t _selectComp ; //! Component selection flag for RooAbsPdf::plotCompOn
559  static Bool_t _globalSelectComp ; // Global activation switch for component selection
560  // This struct can be used to flip the global switch to select components.
561  // Doing this with RAII prevents forgetting to reset the state.
565  if (state != RooAbsReal::_globalSelectComp)
567  }
568 
572  }
573 
574  bool _oldState;
575  };
576 
577 
578  mutable RooArgSet* _lastNSet ; //!
579  static Bool_t _hideOffset ; // Offset hiding flag
580 
581  ClassDef(RooAbsReal,2) // Abstract real-valued variable
582 };
583 
584 
585 /// Helper class to access a batch-related part of RooAbsReal's interface, which should not leak to the outside world.
587  public:
588  static void checkBatchComputation(const RooAbsReal& theReal, const RooBatchCompute::RunContext& evalData, std::size_t evtNo,
589  const RooArgSet* normSet = nullptr, double relAccuracy = 1.E-13) {
590  theReal.checkBatchComputation(evalData, evtNo, normSet, relAccuracy);
591  }
592 };
593 
594 
595 ////////////////////////////////////////////////////////////////////////////////
596 /// Overwrite the value stored in this object's cache.
597 /// This can be used to fake a computation that resulted in `value`.
598 /// \param[in] value Value to write.
599 /// \param[in] setValDirty If true, notify users of this object that its value changed.
600 /// This is the default.
601 void RooAbsReal::setCachedValue(double value, bool notifyClients) {
602  _value = value;
603 
604  if (notifyClients) {
605  setValueDirty();
606  _valueDirty = false;
607  }
608 }
609 
610 
611 #endif
RooAbsReal::analyticalIntegral
virtual Double_t analyticalIntegral(Int_t code, const char *rangeName=0) const
Implements the actual analytical integral(s) advertised by getAnalyticalIntegral.
Definition: RooAbsReal.cxx:429
c
#define c(i)
Definition: RSha256.hxx:101
RooAbsReal::EvalError
Definition: RooAbsReal.h:315
RooAbsReal::setData
virtual Bool_t setData(RooAbsData &, Bool_t=kTRUE)
Definition: RooAbsReal.h:365
m
auto * m
Definition: textangle.C:8
RooAbsReal::copyCache
virtual void copyCache(const RooAbsArg *source, Bool_t valueOnly=kFALSE, Bool_t setValDirty=kTRUE)
Copy the cached value of another RooAbsArg to our cache.
Definition: RooAbsReal.cxx:3211
RooAbsReal::EvalError::_srvval
std::string _srvval
Definition: RooAbsReal.h:322
RooAbsReal::evaluateSpan
virtual RooSpan< double > evaluateSpan(RooBatchCompute::RunContext &evalData, const RooArgSet *normSet) const
Evaluate this object for a batch/span of data points.
Definition: RooAbsReal.cxx:4889
RooAbsReal::NumEvent
@ NumEvent
Definition: RooAbsReal.h:280
RooAbsReal::~RooAbsReal
virtual ~RooAbsReal()
Destructor.
Definition: RooAbsReal.cxx:213
RooAbsReal::CountErrors
@ CountErrors
Definition: RooAbsReal.h:325
RooMultiGenFunction
Lightweight interface adaptor that exports a RooAbsReal as a ROOT::Math::IMultiGenFunction.
Definition: RooMultiGenFunction.h:27
RooAbsReal::selectNormalization
virtual void selectNormalization(const RooArgSet *depSet=0, Bool_t force=kFALSE)
Interface function to force use of a given set of observables to interpret function value.
Definition: RooAbsReal.cxx:3607
RooCmdArg
RooCmdArg is a named container for two doubles, two integers two object points and three string point...
Definition: RooCmdArg.h:27
RooAbsArg::_inhibitDirty
static Bool_t _inhibitDirty
Definition: RooAbsArg.h:664
RooAbsReal::PlotOpt::curveNameSuffix
const char * curveNameSuffix
Definition: RooAbsReal.h:517
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:100
RooAbsReal::printEvalErrors
static void printEvalErrors(std::ostream &os=std::cout, Int_t maxPerNode=10000000)
Print all outstanding logged evaluation error on the given ostream.
Definition: RooAbsReal.cxx:3827
e
#define e(i)
Definition: RSha256.hxx:103
RooAbsReal::isValid
virtual bool isValid() const
Check if current value is valid.
Definition: RooAbsReal.h:424
RooAbsReal::PlotOpt::doeeval
Bool_t doeeval
Definition: RooAbsReal.h:520
RooAbsReal::setEvalErrorLoggingMode
static void setEvalErrorLoggingMode(ErrorLoggingMode m)
Set evaluation error logging mode.
Definition: RooAbsReal.cxx:4840
RooAddPdf
RooAddPdf is an efficient implementation of a sum of PDFs of the form.
Definition: RooAddPdf.h:31
RooAbsReal::getPropagatedError
Double_t getPropagatedError(const RooFitResult &fr, const RooArgSet &nset=RooArgSet()) const
Calculate error on self by linearly propagating errors on parameters using the covariance matrix from...
Definition: RooAbsReal.cxx:2677
RooAbsReal::plotSamplingHint
virtual std::list< Double_t > * plotSamplingHint(RooAbsRealLValue &obs, Double_t xlo, Double_t xhi) const
Interface for returning an optional hint for initial sampling points when constructing a curve projec...
Definition: RooAbsReal.cxx:3816
RooAbsReal::createIntegral
RooAbsReal * createIntegral(const RooArgSet &iset, const RooArgSet &nset, const char *rangeName=0) const
Create integral over observables in iset in range named rangeName with integrand normalized over obse...
Definition: RooAbsReal.h:215
Option_t
const char Option_t
Definition: RtypesCore.h:66
RooAbsReal::logEvalError
void logEvalError(const char *message, const char *serverValueString=0) const
Log evaluation error message.
Definition: RooAbsReal.cxx:3710
RooAbsData
RooAbsData is the common abstract base class for binned and unbinned datasets.
Definition: RooAbsData.h:49
RooGenFunction
Lightweight interface adaptor that exports a RooAbsReal as a ROOT::Math::IGenFunction.
Definition: RooGenFunction.h:22
RooAbsReal::_evalErrorMode
static ErrorLoggingMode _evalErrorMode
Definition: RooAbsReal.h:538
RooDerivative
RooDerivative represents the first, second, or third order derivative of any RooAbsReal as calculated...
Definition: RooDerivative.h:30
RooAbsReal::GlobalSelectComponentRAII::GlobalSelectComponentRAII
GlobalSelectComponentRAII(bool state)
Definition: RooAbsReal.h:563
RooAbsReal::functor
RooFunctor * functor(const RooArgList &obs, const RooArgList &pars=RooArgList(), const RooArgSet &nset=RooArgSet()) const
Return a RooFunctor object bound to this RooAbsReal with given definition of observables and paramete...
Definition: RooAbsReal.cxx:4150
RooAbsReal::syncCache
virtual void syncCache(const RooArgSet *set=0)
Definition: RooAbsReal.h:466
TH2F
2-D histogram with a float per channel (see TH1 documentation)}
Definition: TH2.h:251
RooArgSet.h
RooAbsReal::isBinnedDistribution
virtual Bool_t isBinnedDistribution(const RooArgSet &) const
Tests if the distribution is binned. Unless overridden by derived classes, this always returns false.
Definition: RooAbsReal.h:341
RooAbsReal::writeToStream
virtual void writeToStream(std::ostream &os, Bool_t compact) const
Write object contents to stream (dummy for now)
Definition: RooAbsReal.cxx:471
TString::Data
const char * Data() const
Definition: TString.h:369
RooAbsReal::createIntegral
RooAbsReal * createIntegral(const RooArgSet &iset, const RooNumIntConfig &cfg, const char *rangeName=0) const
Create integral over observables in iset in range named rangeName using specified configuration for a...
Definition: RooAbsReal.h:224
RooAbsReal::createPlotProjection
const RooAbsReal * createPlotProjection(const RooArgSet &depVars, const RooArgSet &projVars, RooArgSet *&cloneSet) const
Utility function for plotOn() that creates a projection of a function or p.d.f to be plotted on a Roo...
Definition: RooAbsReal.cxx:858
RooAbsReal::sigma
RooAbsMoment * sigma(RooRealVar &obs)
Definition: RooAbsReal.h:359
RooAbsReal::createIntegral
RooAbsReal * createIntegral(const RooArgSet &iset, const RooCmdArg &arg1, const RooCmdArg &arg2=RooCmdArg::none(), const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none(), const RooCmdArg &arg6=RooCmdArg::none(), const RooCmdArg &arg7=RooCmdArg::none(), const RooCmdArg &arg8=RooCmdArg::none()) const
Create an object that represents the integral of the function over one or more observables listed in ...
Definition: RooAbsReal.cxx:548
RooAbsReal::getValV
virtual Double_t getValV(const RooArgSet *normalisationSet=nullptr) const
Return value of object.
Definition: RooAbsReal.cxx:276
RooAbsReal::operator==
Bool_t operator==(Double_t value) const
Equality operator comparing to a Double_t.
Definition: RooAbsReal.cxx:223
xmax
float xmax
Definition: THbookFile.cxx:95
RooAbsReal::PlotOpt::projectionRangeName
const char * projectionRangeName
Definition: RooAbsReal.h:509
RooAbsReal::CollectErrors
@ CollectErrors
Definition: RooAbsReal.h:325
RooAbsReal::evaluateBatch
virtual RooSpan< double > evaluateBatch(std::size_t, std::size_t)=delete
RooAbsReal::binBoundaries
virtual std::list< Double_t > * binBoundaries(RooAbsRealLValue &obs, Double_t xlo, Double_t xhi) const
Retrieve bin boundaries if this distribution is binned in obs.
Definition: RooAbsReal.cxx:3805
RooAbsReal::getPlotLabel
const char * getPlotLabel() const
Get the label associated with the variable.
Definition: RooAbsReal.cxx:441
RooArgList
RooArgList is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgList.h:21
RooAbsReal::attachToTree
virtual void attachToTree(TTree &t, Int_t bufSize=32000)
Attach object to a branch of given TTree.
Definition: RooAbsReal.cxx:3267
TTree
A TTree represents a columnar dataset.
Definition: TTree.h:79
RooAbsReal::defaultErrorLevel
virtual Double_t defaultErrorLevel() const
Definition: RooAbsReal.h:252
RooAbsReal::EvalError::setServerValues
void setServerValues(const char *tmp)
Definition: RooAbsReal.h:320
RooAbsReal::PlotOpt::numCPU
Int_t numCPU
Definition: RooAbsReal.h:515
RooAbsReal::plotSanityChecks
Bool_t plotSanityChecks(RooPlot *frame) const
Utility function for plotOn(), perform general sanity check on frame to ensure safe plotting operatio...
Definition: RooAbsReal.cxx:3060
BatchInterfaceAccessor::checkBatchComputation
static void checkBatchComputation(const RooAbsReal &theReal, const RooBatchCompute::RunContext &evalData, std::size_t evtNo, const RooArgSet *normSet=nullptr, double relAccuracy=1.E-13)
Definition: RooAbsReal.h:588
RooAbsReal::getVal
Double_t getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
Definition: RooAbsReal.h:91
RooAbsReal::PlotOpt::projDataSet
const RooArgSet * projDataSet
Definition: RooAbsReal.h:503
TGeant4Unit::s
static constexpr double s
Definition: TGeant4SystemOfUnits.h:162
RooAbsArg.h
RooAbsReal::_unit
TString _unit
Definition: RooAbsReal.h:478
RooFit::MPSplit
MPSplit
Definition: RooGlobalFunc.h:63
RooAbsReal::isSelectedComp
Bool_t isSelectedComp() const
If true, the current pdf is a selected component (for use in plotting)
Definition: RooAbsReal.cxx:3163
RooAbsReal::makeProjectionSet
void makeProjectionSet(const RooAbsArg *plotVar, const RooArgSet *allVars, RooArgSet &projectedVars, Bool_t silent) const
Utility function for plotOn() that constructs the set of observables to project when plotting ourselv...
Definition: RooAbsReal.cxx:3103
RooAbsReal::getVal
Double_t getVal(const RooArgSet &normalisationSet) const
Like getVal(const RooArgSet*), but always requires an argument for normalisation.
Definition: RooAbsReal.h:114
RooCurve.h
x
Double_t x[n]
Definition: legend1.C:17
RooAbsReal::_forceNumInt
Bool_t _forceNumInt
Definition: RooAbsReal.h:480
RooAbsCollection::empty
bool empty() const
Definition: RooAbsCollection.h:218
RooAbsReal::setPlotLabel
void setPlotLabel(const char *label)
Set the label associated with this variable.
Definition: RooAbsReal.cxx:451
RooAbsReal::_treeReadBuffer
std::unique_ptr< TreeReadBuffer > _treeReadBuffer
Definition: RooAbsReal.h:544
indent
static void indent(ostringstream &buf, int indent_level)
Definition: TClingCallFunc.cxx:87
RooAbsReal
RooAbsReal is the common abstract base class for objects that represent a real value and implements f...
Definition: RooAbsReal.h:61
RooAbsReal::getIntegratorConfig
const RooNumIntConfig * getIntegratorConfig() const
Return the numeric integration configuration used for this object.
Definition: RooAbsReal.cxx:3550
RooAbsReal::evalErrorLoggingMode
static ErrorLoggingMode evalErrorLoggingMode()
Return current evaluation error logging mode.
Definition: RooAbsReal.cxx:4826
RooAbsReal::getValBatch
virtual RooSpan< const double > getValBatch(std::size_t, std::size_t, const RooArgSet *=nullptr)=delete
RooAbsMoment
RooAbsMoment represents the first, second, or third order derivative of any RooAbsReal as calculated ...
Definition: RooAbsMoment.h:27
RooAbsReal::PlotOpt::curveInvisible
Bool_t curveInvisible
Definition: RooAbsReal.h:510
RooAbsArg::inhibitDirty
Bool_t inhibitDirty() const
Delete watch flag.
Definition: RooAbsArg.cxx:116
RooAbsReal::isOffsetting
virtual Bool_t isOffsetting() const
Definition: RooAbsReal.h:368
RooAbsReal::plotOnWithErrorBand
RooPlot * plotOnWithErrorBand(RooPlot *frame, const RooFitResult &fr, Double_t Z, const RooArgSet *params, const RooLinkedList &argList, Bool_t method1) const
Plot function or PDF on frame with support for visualization of the uncertainty encoded in the given ...
Definition: RooAbsReal.cxx:2803
RooAbsReal::selectNormalizationRange
virtual void selectNormalizationRange(const char *rangeName=0, Bool_t force=kFALSE)
Interface function to force use of a given normalization range to interpret function value.
Definition: RooAbsReal.cxx:3620
RooAbsReal::mean
RooAbsMoment * mean(RooRealVar &obs)
Definition: RooAbsReal.h:357
TString
Basic string class.
Definition: TString.h:136
RooAbsReal::printValue
virtual void printValue(std::ostream &os) const
Print object value.
Definition: RooAbsReal.cxx:480
RooAbsArg::_fast
Bool_t _fast
Definition: RooAbsArg.h:680
RooAbsReal::_globalSelectComp
static Bool_t _globalSelectComp
Component selection flag for RooAbsPdf::plotCompOn.
Definition: RooAbsReal.h:559
RooCmdArg::none
static const RooCmdArg & none()
Return reference to null argument.
Definition: RooCmdArg.cxx:52
RooAbsReal::fixAddCoefNormalization
virtual void fixAddCoefNormalization(const RooArgSet &addNormSet=RooArgSet(), Bool_t force=kTRUE)
Fix the interpretation of the coefficient of any RooAddPdf component in the expression tree headed by...
Definition: RooAbsReal.cxx:3895
RooAbsReal::PlotOpt::projData
const RooAbsData * projData
Definition: RooAbsReal.h:498
b
#define b(i)
Definition: RSha256.hxx:100
RooAbsReal::clearEvalErrorLog
static void clearEvalErrorLog()
Clear the stack of evaluation error messages.
Definition: RooAbsReal.cxx:3787
RooAbsReal::RooAbsReal
RooAbsReal()
coverity[UNINIT_CTOR] Default constructor
Definition: RooAbsReal.cxx:134
bool
RooFitResult
RooFitResult is a container class to hold the input and output of a PDF fit to a dataset.
Definition: RooFitResult.h:40
RooAbsReal::ScaleType
ScaleType
Definition: RooAbsReal.h:280
RooAbsReal::PlotOpt::wmode
RooCurve::WingMode wmode
Definition: RooAbsReal.h:508
RooAbsReal::PlotOpt::scaleFactor
Double_t scaleFactor
Definition: RooAbsReal.h:496
RooAbsFunc
Abstract interface for evaluating a real-valued function of one real variable and performing numerica...
Definition: RooAbsFunc.h:27
RooAbsReal::GlobalSelectComponentRAII
Definition: RooAbsReal.h:562
RooAbsReal::numEvalErrorItems
static Int_t numEvalErrorItems()
Definition: RooAbsReal.cxx:337
RooAbsReal::fillTreeBranch
virtual void fillTreeBranch(TTree &t)
Fill the tree branch that associated with this object with its current value.
Definition: RooAbsReal.cxx:3335
RooAbsReal::PlotOpt::addToWgtOther
Double_t addToWgtOther
Definition: RooAbsReal.h:514
RooAbsReal::createIntegral
RooAbsReal * createIntegral(const RooArgSet &iset, const char *rangeName) const
Create integral over observables in iset in range named rangeName.
Definition: RooAbsReal.h:211
RooAbsReal::EvalError::setMessage
void setMessage(const char *tmp)
Definition: RooAbsReal.h:319
RooRealIntegral
RooRealIntegral performs hybrid numerical/analytical integrals of RooAbsReal objects.
Definition: RooRealIntegral.h:34
RooAbsReal::_selectComp
Bool_t _selectComp
Definition: RooAbsReal.h:558
RooAbsReal::forceAnalyticalInt
virtual Bool_t forceAnalyticalInt(const RooAbsArg &) const
Definition: RooAbsReal.h:167
RooAbsReal::value_type
double value_type
Definition: RooAbsReal.h:63
RooAbsReal::_plotMax
Double_t _plotMax
Definition: RooAbsReal.h:475
RooAbsReal::PlotOpt::numee
Int_t numee
Definition: RooAbsReal.h:518
RooAbsReal::moment
RooAbsMoment * moment(RooRealVar &obs, Int_t order, Bool_t central, Bool_t takeRoot)
Return function representing moment of function of given order.
Definition: RooAbsReal.cxx:4280
RooAbsReal::createIntObj
RooAbsReal * createIntObj(const RooArgSet &iset, const RooArgSet *nset, const RooNumIntConfig *cfg, const char *rangeName) const
Internal utility function for createIntegral() that creates the actual integral object.
Definition: RooAbsReal.cxx:619
RooAbsReal::_evalErrorList
static std::map< const RooAbsArg *, std::pair< std::string, std::list< EvalError > > > _evalErrorList
Definition: RooAbsReal.h:539
RooAbsReal::plotAsymOn
virtual RooPlot * plotAsymOn(RooPlot *frame, const RooAbsCategoryLValue &asymCat, PlotOpt o) const
Definition: RooAbsReal.cxx:2380
RooAbsReal::PlotOpt::addToCurveName
const char * addToCurveName
Definition: RooAbsReal.h:512
RooAbsReal::_label
TString _label
Definition: RooAbsReal.h:479
RooAbsReal::PlotOpt
Definition: RooAbsReal.h:490
RooDataHist
The RooDataHist is a container class to hold N-dimensional binned data.
Definition: RooDataHist.h:37
RooRealBinding
Lightweight interface adaptor that binds a RooAbsReal object to a subset of its servers and present i...
Definition: RooRealBinding.h:29
RooAbsReal::minTrialSamples
virtual Int_t minTrialSamples(const RooArgSet &) const
Definition: RooAbsReal.h:245
RooAbsReal::PlotOpt::PlotOpt
PlotOpt()
Definition: RooAbsReal.h:491
RooAbsReal::EvalError::_msg
std::string _msg
Definition: RooAbsReal.h:321
RooAbsReal::ErrorLoggingMode
ErrorLoggingMode
Definition: RooAbsReal.h:325
RooAbsReal::selectComp
void selectComp(Bool_t flag)
Definition: RooAbsReal.h:553
RooAbsReal::GlobalSelectComponentRAII::~GlobalSelectComponentRAII
~GlobalSelectComponentRAII()
Definition: RooAbsReal.h:569
TreeReadBuffer
Definition: RooAbsReal.cxx:3200
RooRealSumFunc
Definition: RooRealSumFunc.h:25
RooAbsReal::readFromStream
virtual Bool_t readFromStream(std::istream &is, Bool_t compact, Bool_t verbose=kFALSE)
Read object contents from stream (dummy for now)
Definition: RooAbsReal.cxx:461
RooAbsReal::PlotOpt::rangeLo
Double_t rangeLo
Definition: RooAbsReal.h:505
xmin
float xmin
Definition: THbookFile.cxx:95
RooCurve::WingMode
WingMode
Definition: RooCurve.h:35
RooArgProxy
RooArgProxy is the abstract interface for RooAbsArg proxy classes.
Definition: RooArgProxy.h:24
RooAbsReal::matchArgsByName
Bool_t matchArgsByName(const RooArgSet &allArgs, RooArgSet &matchedArgs, const TList &nameList) const
Check if allArgs contains matching elements for each name in nameList.
Definition: RooAbsReal.cxx:3480
RooFit::Interleave
@ Interleave
Definition: RooGlobalFunc.h:63
RooFit
The namespace RooFit contains mostly switches that change the behaviour of functions of PDFs (or othe...
Definition: RooCFunction1Binding.h:29
RooAbsReal::setTreeBranchStatus
virtual void setTreeBranchStatus(TTree &t, Bool_t active)
(De)Activate associated tree branch
Definition: RooAbsReal.cxx:3352
RooAbsReal::asTF
TF1 * asTF(const RooArgList &obs, const RooArgList &pars=RooArgList(), const RooArgSet &nset=RooArgSet()) const
Return a ROOT TF1,2,3 object bound to this RooAbsReal with given definition of observables and parame...
Definition: RooAbsReal.cxx:4176
RooAbsArg::_valueDirty
Bool_t _valueDirty
Definition: RooAbsArg.h:675
RooAbsReal::evalErrorIter
static EvalErrorIter evalErrorIter()
Definition: RooAbsReal.cxx:345
RooAbsReal::isValidReal
virtual bool isValidReal(double, bool printError=false) const
Interface function to check if given value is a valid value for this object. Returns true unless over...
Definition: RooAbsReal.h:426
RooAbsReal::setHideOffset
static void setHideOffset(Bool_t flag)
Definition: RooAbsReal.cxx:122
RooAbsReal::integralNameSuffix
TString integralNameSuffix(const RooArgSet &iset, const RooArgSet *nset=0, const char *rangeName=0, Bool_t omitEmpty=kFALSE) const
Construct string with unique suffix name to give to integral object that encodes integrated observabl...
Definition: RooAbsReal.cxx:792
RooAbsReal::getUnit
const Text_t * getUnit() const
Definition: RooAbsReal.h:146
RooAbsReal::analyticalIntegralWN
virtual Double_t analyticalIntegralWN(Int_t code, const RooArgSet *normSet, const char *rangeName=0) const
Implements the actual analytical integral(s) advertised by getAnalyticalIntegral.
Definition: RooAbsReal.cxx:415
a
auto * a
Definition: textangle.C:12
RooAbsReal::PlotOpt::drawOptions
Option_t * drawOptions
Definition: RooAbsReal.h:494
RooAbsReal::createChi2
virtual RooAbsReal * createChi2(RooDataHist &data, const RooLinkedList &cmdList)
Create a variable from a histogram and this function.
Definition: RooAbsReal.cxx:4451
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:101
RooAbsReal::derivative
RooDerivative * derivative(RooRealVar &obs, Int_t order=1, Double_t eps=0.001)
Return function representing first, second or third order derivative of this function.
Definition: RooAbsReal.cxx:4252
RooAbsReal::bindVars
RooAbsFunc * bindVars(const RooArgSet &vars, const RooArgSet *nset=0, Bool_t clipInvalid=kFALSE) const
Create an interface adaptor f(vars) that binds us to the specified variables (in arbitrary order).
Definition: RooAbsReal.cxx:3187
RooAbsReal::getTitle
TString getTitle(Bool_t appendUnit=kFALSE) const
Return this variable's title string.
Definition: RooAbsReal.cxx:258
RooLinkedList
RooLinkedList is an collection class for internal use, storing a collection of RooAbsArg pointers in ...
Definition: RooLinkedList.h:37
RooAbsReal::EvalError::EvalError
EvalError(const EvalError &other)
Definition: RooAbsReal.h:318
RooAbsReal::evaluate
virtual Double_t evaluate() const =0
Evaluate this PDF / function / constant. Needs to be overridden by all derived classes.
RooAbsReal::fillDataHist
RooDataHist * fillDataHist(RooDataHist *hist, const RooArgSet *nset, Double_t scaleFactor, Bool_t correctForBinVolume=kFALSE, Bool_t showProgress=kFALSE) const
Fill a RooDataHist with values sampled from this function at the bin centers.
Definition: RooAbsReal.cxx:1200
RooAbsReal::chi2FitDriver
RooFitResult * chi2FitDriver(RooAbsReal &fcn, RooLinkedList &cmdList)
Internal driver function for chi2 fits.
Definition: RooAbsReal.cxx:4611
RooAbsReal::PlotOpt::stype
ScaleType stype
Definition: RooAbsReal.h:497
RooAbsReal::Ignore
@ Ignore
Definition: RooAbsReal.h:325
RooAbsReal::createIntRI
RooAbsReal * createIntRI(const RooArgSet &iset, const RooArgSet &nset=RooArgSet())
Utility function for createRunningIntegral.
Definition: RooAbsReal.cxx:4084
RooAbsReal::getMaxVal
virtual Int_t getMaxVal(const RooArgSet &vars) const
Advertise capability to determine maximum value of function for given set of observables.
Definition: RooAbsReal.cxx:3633
RooAbsReal::_plotBins
Int_t _plotBins
Definition: RooAbsReal.h:476
RooAbsReal::setParameterizeIntegral
void setParameterizeIntegral(const RooArgSet &paramVars)
Definition: RooAbsReal.cxx:4848
RooPlot
A RooPlot is a plot frame and a container for graphics objects within that frame.
Definition: RooPlot.h:44
RooAbsArg::RooArgSet
friend class RooArgSet
Definition: RooAbsArg.h:599
RooAbsReal::checkBatchComputation
void checkBatchComputation(const RooBatchCompute::RunContext &evalData, std::size_t evtNo, const RooArgSet *normSet=nullptr, double relAccuracy=1.E-13) const
Walk through expression tree headed by the this object, and check a batch computation.
Definition: RooAbsReal.cxx:5023
RooAbsReal::mean
RooAbsMoment * mean(RooRealVar &obs, const RooArgSet &nset)
Definition: RooAbsReal.h:358
RooAbsReal::getAnalyticalIntegral
virtual Int_t getAnalyticalIntegral(RooArgSet &allVars, RooArgSet &analVars, const char *rangeName=0) const
Interface function getAnalyticalIntergral advertises the analytical integrals that are supported.
Definition: RooAbsReal.cxx:403
RooCurve
A RooCurve is a one-dimensional graphical representation of a real-valued function.
Definition: RooCurve.h:32
double
double
Definition: Converters.cxx:939
RooAbsReal::chi2FitTo
virtual RooFitResult * chi2FitTo(RooDataHist &data, const RooCmdArg &arg1=RooCmdArg::none(), const RooCmdArg &arg2=RooCmdArg::none(), const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none(), const RooCmdArg &arg6=RooCmdArg::none(), const RooCmdArg &arg7=RooCmdArg::none(), const RooCmdArg &arg8=RooCmdArg::none())
Perform a fit to given histogram.
Definition: RooAbsReal.cxx:4382
RooAbsReal::_value
Double_t _value
Definition: RooAbsReal.h:477
RooAbsReal::enableOffsetting
virtual void enableOffsetting(Bool_t)
Definition: RooAbsReal.h:367
RooAbsReal::RooAbsOptGoodnessOfFit
friend class RooAbsOptGoodnessOfFit
Definition: RooAbsReal.h:488
RooAbsReal::plotOnCompSelect
void plotOnCompSelect(RooArgSet *selNodes) const
Helper function for plotting of composite p.d.fs.
Definition: RooAbsReal.cxx:1521
RooAbsReal::forceNumInt
virtual void forceNumInt(Bool_t flag=kTRUE)
Definition: RooAbsReal.h:172
RooAbsReal::offset
virtual Double_t offset() const
Definition: RooAbsReal.h:369
RooAbsReal::createRunningIntegral
RooAbsReal * createRunningIntegral(const RooArgSet &iset, const RooArgSet &nset=RooArgSet())
Calls createRunningIntegral(const RooArgSet&, const RooCmdArg&, const RooCmdArg&, const RooCmdArg&,...
Definition: RooAbsReal.cxx:3961
RooAbsReal::findRoot
Double_t findRoot(RooRealVar &x, Double_t xmin, Double_t xmax, Double_t yval)
Return value of x (in range xmin,xmax) at which function equals yval.
Definition: RooAbsReal.cxx:4316
RooAbsReal::_plotMin
Double_t _plotMin
Definition: RooAbsReal.h:474
void
typedef void((*Func_t)())
RooCmdArg.h
RooAbsReal::setIntegratorConfig
void setIntegratorConfig()
Remove the specialized numeric integration configuration associated with this object.
Definition: RooAbsReal.cxx:3590
RooAbsReal::createIntegral
RooAbsReal * createIntegral(const RooArgSet &iset, const RooArgSet &nset, const RooNumIntConfig &cfg, const char *rangeName=0) const
Create integral over observables in iset in range named rangeName with integrand normalized over obse...
Definition: RooAbsReal.h:220
RooAbsReal::plotOn
virtual RooPlot * plotOn(RooPlot *frame, const RooCmdArg &arg1=RooCmdArg(), const RooCmdArg &arg2=RooCmdArg(), const RooCmdArg &arg3=RooCmdArg(), const RooCmdArg &arg4=RooCmdArg(), const RooCmdArg &arg5=RooCmdArg(), const RooCmdArg &arg6=RooCmdArg(), const RooCmdArg &arg7=RooCmdArg(), const RooCmdArg &arg8=RooCmdArg(), const RooCmdArg &arg9=RooCmdArg(), const RooCmdArg &arg10=RooCmdArg()) const
Plot (project) PDF on specified frame.
Definition: RooAbsReal.cxx:1688
TH3F
3-D histogram with a float per channel (see TH1 documentation)}
Definition: TH3.h:268
RooGlobalFunc.h
RooAbsReal::createProfile
virtual RooAbsReal * createProfile(const RooArgSet &paramsOfInterest)
Create a RooProfileLL object that eliminates all nuisance parameters in the present function.
Definition: RooAbsReal.cxx:506
RooAbsReal::_specIntegratorConfig
RooNumIntConfig * _specIntegratorConfig
Definition: RooAbsReal.h:485
RooAbsReal::maxVal
virtual Double_t maxVal(Int_t code) const
Return maximum value for set of observables identified by code assigned in getMaxVal.
Definition: RooAbsReal.cxx:3644
RooAbsReal::Raw
@ Raw
Definition: RooAbsReal.h:280
RooAbsReal::PlotOpt::normRangeName
const char * normRangeName
Definition: RooAbsReal.h:504
RooAbsReal::findInnerMostIntegration
void findInnerMostIntegration(const RooArgSet &allObs, RooArgSet &innerObs, const char *rangeName) const
Utility function for createIntObj() that aids in the construct of recursive integrals over functions ...
Definition: RooAbsReal.cxx:737
RooAbsReal::traceEval
Double_t traceEval(const RooArgSet *set) const
Calculate current value of object, with error tracing wrapper.
Definition: RooAbsReal.cxx:354
RooAbsReal::defaultIntegratorConfig
static RooNumIntConfig * defaultIntegratorConfig()
Returns the default numeric integration configuration for all RooAbsReals.
Definition: RooAbsReal.cxx:3513
RooAbsReal::createHistogram
TH1 * createHistogram(const char *varNameList, Int_t xbins=0, Int_t ybins=0, Int_t zbins=0) const
Create and fill a ROOT histogram TH1, TH2 or TH3 with the values of this function for the variables w...
Definition: RooAbsReal.cxx:1262
RooAbsReal::getAnalyticalIntegralWN
virtual Int_t getAnalyticalIntegralWN(RooArgSet &allVars, RooArgSet &analVars, const RooArgSet *normSet, const char *rangeName=0) const
Variant of getAnalyticalIntegral that is also passed the normalization set that should be applied to ...
Definition: RooAbsReal.cxx:386
Double_t
double Double_t
Definition: RtypesCore.h:59
RooFunctor
Lightweight interface adaptor that exports a RooAbsPdf as a functor.
Definition: RooFunctor.h:25
RooAbsReal::specialIntegratorConfig
RooNumIntConfig * specialIntegratorConfig() const
Returns the specialized integrator configuration for this RooAbsReal.
Definition: RooAbsReal.cxx:3523
RooAbsReal::setUnit
void setUnit(const char *unit)
Definition: RooAbsReal.h:150
RooAbsReal::operator=
RooAbsReal & operator=(const RooAbsReal &other)
Assign values, name and configs from another RooAbsReal.
Definition: RooAbsReal.cxx:186
RooAbsReal::PlotOpt::curveName
const char * curveName
Definition: RooAbsReal.h:511
RooAbsReal::EvalErrorIter
std::map< const RooAbsArg *, std::pair< std::string, std::list< EvalError > > >::const_iterator EvalErrorIter
Definition: RooAbsReal.h:335
RooDataProjBinding
adaptor that projects a real function via summation of states provided in a dataset.
Definition: RooDataProjBinding.h:25
RooAbsReal::EvalError::EvalError
EvalError()
Definition: RooAbsReal.h:317
RooAbsReal::_evalErrorCount
static Int_t _evalErrorCount
Definition: RooAbsReal.h:540
RooAbsReal::iGenFunction
RooGenFunction * iGenFunction(RooRealVar &x, const RooArgSet &nset=RooArgSet())
Definition: RooAbsReal.cxx:4328
RooAbsReal::PlotOpt::postRangeFracScale
Bool_t postRangeFracScale
Definition: RooAbsReal.h:507
RooCategory
RooCategory is an object to represent discrete states.
Definition: RooCategory.h:27
RooAbsReal::PlotOpt::precision
Double_t precision
Definition: RooAbsReal.h:501
TH1F
1-D histogram with a float per channel (see TH1 documentation)}
Definition: TH1.h:575
RooAddModel
RooAddModel is an efficient implementation of a sum of PDFs of the form.
Definition: RooAddModel.h:26
RooAbsReal::GlobalSelectComponentRAII::_oldState
bool _oldState
Definition: RooAbsReal.h:574
RooVectorDataStore
RooVectorDataStore uses std::vectors to store data columns.
Definition: RooVectorDataStore.h:37
RooAbsReal::isIdentical
virtual Bool_t isIdentical(const RooAbsArg &other, Bool_t assumeSameType=kFALSE) const
Definition: RooAbsReal.cxx:243
RooAbsReal::createScanRI
RooAbsReal * createScanRI(const RooArgSet &iset, const RooArgSet &nset, Int_t numScanBins, Int_t intOrder)
Utility function for createRunningIntegral that construct an object implementing the numeric scanning...
Definition: RooAbsReal.cxx:4067
ClassDef
#define ClassDef(name, id)
Definition: Rtypes.h:325
RooAbsReal::PlotOpt::errorFR
const RooFitResult * errorFR
Definition: RooAbsReal.h:522
RooAbsReal::getForceNumInt
Bool_t getForceNumInt() const
Definition: RooAbsReal.h:177
TH1
TH1 is the base class of all histogram classes in ROOT.
Definition: TH1.h:58
RooAbsReal::createFundamental
RooAbsArg * createFundamental(const char *newname=0) const
Create a RooRealVar fundamental object with our properties.
Definition: RooAbsReal.cxx:3366
RooAbsReal::plotSliceOn
virtual RooPlot * plotSliceOn(RooPlot *frame, const RooArgSet &sliceSet, Option_t *drawOptions="L", Double_t scaleFactor=1.0, ScaleType stype=Relative, const RooAbsData *projData=0) const
Definition: RooAbsReal.cxx:2346
name
char name[80]
Definition: TGX11.cxx:110
RooAbsReal::hideOffset
static Bool_t hideOffset()
Definition: RooAbsReal.cxx:123
RooBatchCompute
Namespace for dispatching RooFit computations to various backends.
Definition: BracketAdapter.h:24
d
#define d(i)
Definition: RSha256.hxx:102
RooAbsReal::printMultiline
virtual void printMultiline(std::ostream &os, Int_t contents, Bool_t verbose=kFALSE, TString indent="") const
Structure printing.
Definition: RooAbsReal.cxx:490
genreflex::verbose
bool verbose
Definition: rootcling_impl.cxx:133
RooDataSet
RooDataSet is a container class to hold unbinned data.
Definition: RooDataSet.h:33
RooAbsReal::preferredObservableScanOrder
virtual void preferredObservableScanOrder(const RooArgSet &obs, RooArgSet &orderedObs) const
Interface method for function objects to indicate their preferred order of observables for scanning t...
Definition: RooAbsReal.cxx:3949
RooAbsArg
RooAbsArg is the common abstract base class for objects that represent a value and a "shape" in RooFi...
Definition: RooAbsArg.h:72
RooAbsReal::getValues
virtual RooSpan< const double > getValues(RooBatchCompute::RunContext &evalData, const RooArgSet *normSet=nullptr) const
by this change, please consult the release notes for ROOT 6.24 for guidance on how to make this trans...
Definition: RooAbsReal.cxx:312
RooAbsReal::PlotOpt::addToWgtSelf
Double_t addToWgtSelf
Definition: RooAbsReal.h:513
RooNumIntConfig
RooNumIntConfig holds the configuration parameters of the various numeric integrators used by RooReal...
Definition: RooNumIntConfig.h:25
RooAbsArg::setValueDirty
void setValueDirty()
Mark the element dirty. This forces a re-evaluation when a value is requested.
Definition: RooAbsArg.h:490
RooAbsReal::_DEBUG_getVal
Double_t _DEBUG_getVal(const RooArgSet *normalisationSet) const
Debug version of getVal(), which is slow and does error checking.
Definition: RooAbsReal.cxx:4973
RooAbsReal::matchArgs
Bool_t matchArgs(const RooArgSet &allDeps, RooArgSet &numDeps, const RooArgProxy &a) const
Utility function for use in getAnalyticalIntegral().
Definition: RooAbsReal.cxx:3382
RooAbsReal::globalSelectComp
static void globalSelectComp(Bool_t flag)
Global switch controlling the activation of the selectComp() functionality.
Definition: RooAbsReal.cxx:3173
RooAbsPdf
Definition: RooAbsPdf.h:41
RooAbsReal::PlotOpt::interleave
RooFit::MPSplit interleave
Definition: RooAbsReal.h:516
RooAbsReal::PlotOpt::eeval
Double_t eeval
Definition: RooAbsReal.h:519
RooAbsReal::fixAddCoefRange
virtual void fixAddCoefRange(const char *rangeName=0, Bool_t force=kTRUE)
Fix the interpretation of the coefficient of any RooAddPdf component in the expression tree headed by...
Definition: RooAbsReal.cxx:3925
RooSpan.h
RooAbsReal::sigma
RooAbsMoment * sigma(RooRealVar &obs, const RooArgSet &nset)
Definition: RooAbsReal.h:360
RooAbsReal::Relative
@ Relative
Definition: RooAbsReal.h:280
RooAbsReal::setCachedValue
void setCachedValue(double value, bool notifyClients=true) final
Overwrite the value stored in this object's cache.
Definition: RooAbsReal.h:601
RooAbsReal::numEvalErrors
static Int_t numEvalErrors()
Return the number of logged evaluation errors since the last clearing.
Definition: RooAbsReal.cxx:3869
Text_t
char Text_t
Definition: RtypesCore.h:62
TF1
1-Dim function class
Definition: TF1.h:213
RooAbsReal::PrintErrors
@ PrintErrors
Definition: RooAbsReal.h:325
RooAbsReal::PlotOpt::binProjData
Bool_t binProjData
Definition: RooAbsReal.h:499
RooAbsCategoryLValue
RooAbsCategoryLValue is the common abstract base class for objects that represent a discrete value th...
Definition: RooAbsCategoryLValue.h:25
RooRealVar
RooRealVar represents a variable that can be changed from the outside.
Definition: RooRealVar.h:39
RooAbsRealLValue
RooAbsRealLValue is the common abstract base class for objects that represent a real value that may a...
Definition: RooAbsRealLValue.h:31
RooArgList.h
BatchInterfaceAccessor
Helper class to access a batch-related part of RooAbsReal's interface, which should not leak to the o...
Definition: RooAbsReal.h:586
RooRealSumPdf
The class RooRealSumPdf implements a PDF constructed from a sum of functions:
Definition: RooRealSumPdf.h:24
RooAbsReal::PlotOpt::projSet
const RooArgSet * projSet
Definition: RooAbsReal.h:500
RooBatchCompute::RunContext
This struct enables passing computation data around between elements of a computation graph.
Definition: RunContext.h:31
RooAbsReal::fillHistogram
TH1 * fillHistogram(TH1 *hist, const RooArgList &plotVars, Double_t scaleFactor=1, const RooArgSet *projectedVars=0, Bool_t scaling=kTRUE, const RooArgSet *condObs=0, Bool_t setError=kTRUE) const
Fill the ROOT histogram 'hist' with values sampled from this function at the bin centers.
Definition: RooAbsReal.cxx:1023
RooAbsReal::_hideOffset
static Bool_t _hideOffset
Definition: RooAbsReal.h:579
RooAbsAnaConvPdf
RooAbsAnaConvPdf is the base class for PDFs that represent a physics model that can be analytically c...
Definition: RooAbsAnaConvPdf.h:34
TList
A doubly linked list.
Definition: TList.h:44
RooSpan
A simple container to hold a batch of data values.
Definition: RooSpan.h:34
RooAbsReal::PlotOpt::shiftToZero
Bool_t shiftToZero
Definition: RooAbsReal.h:502
RooAbsReal::PlotOpt::progress
Bool_t progress
Definition: RooAbsReal.h:521
RooArgSet
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:33
fw3dlego::xbins
const double xbins[xbins_n]
Definition: collection_proxies.C:48
RooAbsReal::_lastNSet
RooArgSet * _lastNSet
Definition: RooAbsReal.h:578
RooAbsReal::RelativeExpected
@ RelativeExpected
Definition: RooAbsReal.h:280
int
RooAbsReal::PlotOpt::rangeHi
Double_t rangeHi
Definition: RooAbsReal.h:506
RooAbsReal::attachToVStore
virtual void attachToVStore(RooVectorDataStore &vstore)
Definition: RooAbsReal.cxx:3226
RooFit::Extended
RooCmdArg Extended(Bool_t flag=kTRUE)
Definition: RooGlobalFunc.cxx:167