Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RooHistFunc.cxx
Go to the documentation of this file.
1/*****************************************************************************
2 * Project: RooFit *
3 * Package: RooFitCore *
4 * @(#)root/roofit:$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\file RooHistFunc.cxx
19\class RooHistFunc
20\ingroup Roofitcore
21
22A real-valued function sampled from a
23multidimensional histogram. The histogram can have an arbitrary number of real or
24discrete dimensions and may have negative values.
25**/
26
27#include "RooHistFunc.h"
28#include "RooDataHist.h"
29#include "RooMsgService.h"
30#include "RooRealVar.h"
31#include "RooCategory.h"
32#include "RooWorkspace.h"
33#include "RooHistPdf.h"
34#include "RooFitImplHelpers.h"
35
36#include "TError.h"
37#include "TBuffer.h"
38
39#include <stdexcept>
40
41
42
43
44////////////////////////////////////////////////////////////////////////////////
45/// Constructor from a RooDataHist. The variable listed in 'vars' control the dimensionality of the
46/// function. Any additional dimensions present in 'dhist' will be projected out. RooDataHist dimensions
47/// can be either real or discrete. See RooDataHist::RooDataHist for details on the binning.
48/// RooHistFunc neither owns or clone 'dhist' and the user must ensure the input histogram exists
49/// for the entire life span of this function.
50
51RooHistFunc::RooHistFunc(const char *name, const char *title, const RooArgSet& vars,
52 const RooDataHist& dhist, Int_t intOrder) :
53 RooAbsReal(name,title),
54 _depList("depList","List of dependents",this),
55 _dataHist(const_cast<RooDataHist*>(&dhist)),
56 _intOrder(intOrder)
57{
59 _depList.add(vars) ;
60
61 // Verify that vars and dhist.get() have identical contents
62 const RooArgSet* dvars = dhist.get() ;
63 if (vars.size()!=dvars->size()) {
64 coutE(InputArguments) << "RooHistFunc::ctor(" << GetName()
65 << ") ERROR variable list and RooDataHist must contain the same variables." << std::endl ;
66 throw std::invalid_argument("RooHistFunc: ERROR variable list and RooDataHist must contain the same variables.");
67 }
68
69 for (const auto arg : vars) {
70 if (!dvars->find(arg->GetName())) {
71 coutE(InputArguments) << "RooHistFunc::ctor(" << GetName()
72 << ") ERROR variable list and RooDataHist must contain the same variables." << std::endl ;
73 throw std::invalid_argument("RooHistFunc: ERROR variable list and RooDataHist must contain the same variables.");
74 }
75 }
76
77}
78
79
80
81////////////////////////////////////////////////////////////////////////////////
82/// Constructor from a RooDataHist. The variable listed in 'vars' control the dimensionality of the
83/// function. Any additional dimensions present in 'dhist' will be projected out. RooDataHist dimensions
84/// can be either real or discrete. See RooDataHist::RooDataHist for details on the binning.
85/// RooHistFunc neither owns or clone 'dhist' and the user must ensure the input histogram exists
86/// for the entire life span of this function.
87
88RooHistFunc::RooHistFunc(const char *name, const char *title, const RooArgList& funcObs, const RooArgList& histObs,
89 const RooDataHist& dhist, Int_t intOrder) :
90 RooAbsReal(name,title),
91 _depList("depList","List of dependents",this),
92 _dataHist(const_cast<RooDataHist*>(&dhist)),
93 _intOrder(intOrder)
94{
95 _histObsList.addClone(histObs) ;
96 _depList.add(funcObs) ;
97
98 // Verify that vars and dhist.get() have identical contents
99 const RooArgSet* dvars = dhist.get() ;
100 if (histObs.size()!=dvars->size()) {
101 coutE(InputArguments) << "RooHistFunc::ctor(" << GetName()
102 << ") ERROR variable list and RooDataHist must contain the same variables." << std::endl ;
103 throw std::invalid_argument("RooHistFunc: ERROR variable list and RooDataHist must contain the same variables.");
104 }
105
106 for (const auto arg : histObs) {
107 if (!dvars->find(arg->GetName())) {
108 coutE(InputArguments) << "RooHistFunc::ctor(" << GetName()
109 << ") ERROR variable list and RooDataHist must contain the same variables." << std::endl ;
110 throw std::invalid_argument("RooHistFunc: ERROR variable list and RooDataHist must contain the same variables.");
111 }
112 }
113
114}
115
116RooHistFunc::RooHistFunc(const char *name, const char *title, const RooArgSet &vars, std::unique_ptr<RooDataHist> dhist,
117 int intOrder)
118 : RooHistFunc{name, title, vars, *dhist, intOrder}
119{
120 initializeOwnedDataHist(std::move(dhist));
121}
122
123RooHistFunc::RooHistFunc(const char *name, const char *title, const RooArgList &pdfObs, const RooArgList &histObs,
124 std::unique_ptr<RooDataHist> dhist, int intOrder)
125 : RooHistFunc{name, title, pdfObs, histObs, *dhist, intOrder}
126{
127 initializeOwnedDataHist(std::move(dhist));
128}
129
130
131////////////////////////////////////////////////////////////////////////////////
132/// Copy constructor
133
134RooHistFunc::RooHistFunc(const RooHistFunc& other, const char* name) :
135 RooAbsReal(other,name),
136 _depList("depList",this,other._depList),
137 _dataHist(other._dataHist),
138 _intOrder(other._intOrder),
139 _cdfBoundaries(other._cdfBoundaries),
140 _totVolume(other._totVolume),
141 _unitNorm(other._unitNorm)
142{
143
145}
146
147
148
149////////////////////////////////////////////////////////////////////////////////
150
154
155
156
157
158////////////////////////////////////////////////////////////////////////////////
159/// Return the current value: The value of the bin enclosing the current coordinates
160/// of the dependents, normalized by the histograms contents. Interpolation
161/// is applied if the RooHistFunc is configured to do that
162
164{
165 // Transfer values from
166 if (!_depList.empty()) {
167 for (auto i = 0u; i < _histObsList.size(); ++i) {
168 const auto harg = _histObsList[i];
169 const auto parg = _depList[i];
170
171 if (harg != parg) {
172 parg->syncCache() ;
173 harg->copyCache(parg,true) ;
174 if (!harg->inRange(nullptr)) {
175 return 0 ;
176 }
177 }
178 }
179 }
180
182 return ret ;
183}
184
186{
187 std::span<double> output = ctx.output();
188 std::size_t nEvents = output.size();
189
190 if (_depList.size() == 1) {
191 auto xVals = ctx.at(_depList[0]);
192 _dataHist->weights(output.data(), xVals, _intOrder, false, _cdfBoundaries);
193 return;
194 }
195
196 std::vector<std::span<const double>> inputValues;
197 for (const auto& obs : _depList) {
198 auto realObs = dynamic_cast<const RooAbsReal*>(obs);
199 if (realObs) {
200 inputValues.push_back(ctx.at(realObs));
201 } else {
202 inputValues.emplace_back();
203 }
204 }
205
206 for (std::size_t i = 0; i < nEvents; ++i) {
207 bool skip = false;
208
209 for (auto j = 0u; j < _histObsList.size(); ++j) {
210 const auto histObs = _histObsList[j];
211
212 if (i < inputValues[j].size()) {
213 histObs->setCachedValue(inputValues[j][i], false);
214 if (!histObs->inRange(nullptr)) {
215 skip = true;
216 break;
217 }
218 }
219 }
220
221 output[i] = skip ? 0. : _dataHist->weightFast(_histObsList, _intOrder, false, _cdfBoundaries);
222 }
223}
224
225
226////////////////////////////////////////////////////////////////////////////////
227/// Only handle case of maximum in all variables
228
230{
231 std::unique_ptr<RooAbsCollection> common{_depList.selectCommon(vars)};
232 return common->size() == _depList.size() ? 1 : 0;
233}
234
235////////////////////////////////////////////////////////////////////////////////
236
237double RooHistFunc::maxVal(Int_t code) const
238{
239 R__ASSERT(code==1) ;
240
241 double max(-1) ;
242 for (Int_t i=0 ; i<_dataHist->numEntries() ; i++) {
243 double wgt = _dataHist->weight(i) ;
244 if (wgt>max) max=wgt ;
245 }
246
247 return max*1.05 ;
248}
249
251 if (_ownedDataHist) return _ownedDataHist.get();
252 _ownedDataHist.reset(static_cast<RooDataHist*>(_dataHist->Clone(newname)));
254 return _dataHist;
255}
256
257////////////////////////////////////////////////////////////////////////////////
258/// Return the total volume spanned by the observables of the RooDataHist
259
261{
262 // Return previously calculated value, if any
263 if (_totVolume>0) {
264 return _totVolume ;
265 }
266 _totVolume = 1. ;
267 for (const auto arg : _depList) {
268 RooRealVar* real = dynamic_cast<RooRealVar*>(arg) ;
269 if (real) {
270 _totVolume *= (real->getMax()-real->getMin()) ;
271 } else {
272 RooCategory* cat = dynamic_cast<RooCategory*>(arg) ;
273 if (cat) {
274 _totVolume *= cat->numTypes() ;
275 }
276 }
277 }
278
279 return _totVolume ;
280}
281
282
283////////////////////////////////////////////////////////////////////////////////
284/// Determine integration scenario. If no interpolation is used,
285/// RooHistFunc can perform all integrals over its dependents
286/// analytically via partial or complete summation of the input
287/// histogram. If interpolation is used, only the integral
288/// over all RooHistPdf observables is implemented.
289
290Int_t RooHistFunc::getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, const char* rangeName) const
291{
292 return RooHistPdf::getAnalyticalIntegral(allVars, analVars, rangeName, _histObsList, _depList, _intOrder);
293}
294
295
296////////////////////////////////////////////////////////////////////////////////
297/// Return integral identified by 'code'. The actual integration
298/// is deferred to RooDataHist::sum() which implements partial
299/// or complete summation over the histograms contents
300
301double RooHistFunc::analyticalIntegral(Int_t code, const char* rangeName) const
302{
303 return RooHistPdf::analyticalIntegral(code, rangeName, _histObsList, _depList, *_dataHist, true);
304}
305
307{
309}
310
311////////////////////////////////////////////////////////////////////////////////
312/// Return sampling hint for making curves of (projections) of this function
313/// as the recursive division strategy of RooCurve cannot deal efficiently
314/// with the vertical lines that occur in a non-interpolated histogram
315
316std::list<double>* RooHistFunc::plotSamplingHint(RooAbsRealLValue& obs, double xlo, double xhi) const
317{
319}
320
321////////////////////////////////////////////////////////////////////////////////
322/// Return the histogram bin boundaries mapped into the plot-observable
323/// coordinate. Handles the case where the function observable is a
324/// transformation (shift, scale, ...) of the plot observable so that the
325/// returned boundaries are placed at the correct positions in the plot.
326
327std::list<double>* RooHistFunc::binBoundaries(RooAbsRealLValue& obs, double xlo, double xhi) const
328{
329 // No hints are required when interpolation is used
330 if (_intOrder>1) {
331 return nullptr ;
332 }
333
334 const std::vector<double> boundaries =
336 if (boundaries.empty()) {
337 return nullptr;
338 }
339
340 auto hint = new std::list<double>;
341 const double delta = (xhi - xlo) * 1e-8;
342 for (double b : boundaries) {
343 if (b > xlo - delta && b < xhi + delta) {
344 hint->push_back(b);
345 }
346 }
347
348 return hint;
349}
350
351
352
353////////////////////////////////////////////////////////////////////////////////
354/// Check if our datahist is already in the workspace.
355/// In case of error, return true.
357{
358 // Check if dataset with given name already exists
359 RooAbsData* wsdata = ws.embeddedData(_dataHist->GetName()) ;
360
361 if (wsdata) {
362 // If our data is exactly the same, we are done:
363 if (static_cast<RooDataHist*>(wsdata) == _dataHist)
364 return false;
365
366 // Yes it exists - now check if it is identical to our internal histogram
367 if (wsdata->InheritsFrom(RooDataHist::Class())) {
368
369 // Check if histograms are identical
370 if (areIdentical(static_cast<RooDataHist&>(*wsdata),*_dataHist)) {
371
372 // Exists and is of correct type, and identical -- adjust internal pointer to WS copy
373 _dataHist = static_cast<RooDataHist*>(wsdata) ;
374 } else {
375
376 // not identical, clone rename and import
377 auto uniqueName = std::string(_dataHist->GetName()) + "_" + GetName();
378 bool flag = ws.import(*_dataHist,RooFit::Rename(uniqueName.c_str()),RooFit::Embedded()) ;
379 if (flag) {
380 coutE(ObjectHandling) << " RooHistPdf::importWorkspaceHook(" << GetName() << ") unable to import clone of underlying RooDataHist with unique name " << uniqueName << ", abort" << std::endl ;
381 return true ;
382 }
383 _dataHist = static_cast<RooDataHist*>(ws.embeddedData(uniqueName)) ;
384 }
385
386 } else {
387
388 // Exists and is NOT of correct type: clone rename and import
389 auto uniqueName = std::string(_dataHist->GetName()) + "_" + GetName();
390 bool flag = ws.import(*_dataHist,RooFit::Rename(uniqueName.c_str()),RooFit::Embedded()) ;
391 if (flag) {
392 coutE(ObjectHandling) << " RooHistPdf::importWorkspaceHook(" << GetName() << ") unable to import clone of underlying RooDataHist with unique name " << uniqueName << ", abort" << std::endl ;
393 return true ;
394 }
395 _dataHist = static_cast<RooDataHist*>(ws.embeddedData(uniqueName));
396
397 }
398 return false ;
399 }
400
401 // We need to import our datahist into the workspace
403
404 // Redirect our internal pointer to the copy in the workspace
405 _dataHist = static_cast<RooDataHist*>(ws.embeddedData(_dataHist->GetName())) ;
406 return false ;
407}
408
409
410////////////////////////////////////////////////////////////////////////////////
411
413{
414 if (std::abs(dh1.sumEntries()-dh2.sumEntries())>1e-8) return false ;
415 if (dh1.numEntries() != dh2.numEntries()) return false ;
416 for (int i=0 ; i < dh1.numEntries() ; i++) {
417 if (std::abs(dh1.weight(i)-dh2.weight(i))>1e-8) return false ;
418 }
420 if (getColonSeparatedNameString(*dh1.get()) != getColonSeparatedNameString(*dh2.get())) return false ;
421 return true ;
422}
423
424
425
426////////////////////////////////////////////////////////////////////////////////
427/// Stream an object of class RooHistFunc.
428
430{
431 if (R__b.IsReading()) {
433 // WVE - interim solution - fix proxies here
434 _proxyList.Clear() ;
436 } else {
438 }
439}
440
441
442////////////////////////////////////////////////////////////////////////////////
443/// Schema evolution: if histObsList wasn't filled from persistence (v1)
444/// then fill it here. Can't be done in regular schema evolution in LinkDef
445/// as _depList content is not guaranteed to be initialized there
446
448{
449 RooAbsReal::ioStreamerPass2(); // call the baseclass method
450
451 if (_histObsList.empty()) {
453 }
454}
455
456
457////////////////////////////////////////////////////////////////////////////////
458/// Compute bin number corresponding to current coordinates.
459/// \return If a bin is not in the current range of the observables, return -1.
461 if (!_depList.empty()) {
462 for (auto i = 0u; i < _histObsList.size(); ++i) {
463 const auto harg = _histObsList[i];
464 const auto parg = _depList[i];
465
466 if (harg != parg) {
467 parg->syncCache() ;
468 harg->copyCache(parg,true) ;
469 if (!harg->inRange(nullptr)) {
470 return -1;
471 }
472 }
473 }
474 }
475
476 return _dataHist->getIndex(_histObsList, true);
477}
478
479
480////////////////////////////////////////////////////////////////////////////////
481/// Compute bin numbers corresponding to all coordinates in `evalData`.
482/// \return Vector of bin numbers. If a bin is not in the current range of the observables, return -1.
483std::vector<Int_t> RooHistFunc::getBins(RooFit::EvalContext & ctx) const {
484 std::vector<std::span<const double>> depData;
485 for (const auto dep : _depList) {
486 auto real = dynamic_cast<const RooAbsReal*>(dep);
487 if (real) {
488 depData.push_back(ctx.at(real));
489 } else {
490 depData.emplace_back();
491 }
492 }
493
494 const auto batchSize = std::max_element(depData.begin(), depData.end(),
495 [](const std::span<const double>& a, const std::span<const double>& b){ return a.size() < b.size(); })->size();
496 std::vector<Int_t> results;
497
498 for (std::size_t evt = 0; evt < batchSize; ++evt) {
499 if (!_depList.empty()) {
500 for (auto i = 0u; i < _histObsList.size(); ++i) {
501 const auto harg = _histObsList[i];
502
503 if (evt < depData[i].size())
504 harg->setCachedValue(depData[i][evt], false);
505
506 if (!harg->inRange(nullptr)) {
507 results.push_back(-1);
508 continue;
509 }
510 }
511 }
512
513 results.push_back(_dataHist->getIndex(_histObsList, true));
514 }
515
516 return results;
517}
#define b(i)
Definition RSha256.hxx:100
#define a(i)
Definition RSha256.hxx:99
#define e(i)
Definition RSha256.hxx:103
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
#define coutE(a)
#define R__ASSERT(e)
Checks condition e and reports a fatal error if it's false.
Definition TError.h:139
char name[80]
Definition TGX11.cxx:142
Common abstract base class for objects that represent a value and a "shape" in RooFit.
Definition RooAbsArg.h:77
RooRefArray _proxyList
Definition RooAbsArg.h:550
void registerProxy(RooArgProxy &proxy)
Register an RooArgProxy in the proxy list.
friend void RooRefArray::Streamer(TBuffer &)
virtual void ioStreamerPass2()
Method called by workspace container to finalize schema evolution issues that cannot be handled in a ...
Int_t numTypes(const char *=nullptr) const
Return number of types defined (in range named rangeName if rangeName!=nullptr)
Storage_t::size_type size() const
virtual RooAbsArg * addClone(const RooAbsArg &var, bool silent=false)
Add a clone of the specified argument to list.
RooAbsArg * find(const char *name) const
Find object with given name in list.
Abstract base class for binned and unbinned datasets.
Definition RooAbsData.h:55
virtual Int_t numEntries() const
Return number of entries in dataset, i.e., count unweighted entries.
Abstract base class for objects that represent a real value that may appear on the left hand side of ...
virtual double getMax(const char *name=nullptr) const
Get maximum of currently defined range.
virtual double getMin(const char *name=nullptr) const
Get minimum of currently defined range.
Abstract base class for objects that represent a real value and implements functionality common to al...
Definition RooAbsReal.h:63
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 * selectCommon(const RooAbsCollection &refColl) const
Use RooAbsCollection::selecCommon(), but return as RooArgSet.
Definition RooArgSet.h:154
Object to represent discrete states.
Definition RooCategory.h:28
bool add(const RooAbsArg &var, bool valueServer, bool shapeServer, bool silent)
Overloaded RooCollection_t::add() method insert object into set and registers object as server to own...
Container class to hold N-dimensional binned data.
Definition RooDataHist.h:40
void weights(double *output, std::span< double const > xVals, int intOrder, bool correctForBinSize, bool cdfBoundaries)
A vectorized version of RooDataHist::weight() for one dimensional histograms with up to one dimension...
static TClass * Class()
TObject * Clone(const char *newname="") const override
Make a clone of an object using the Streamer facility.
Definition RooDataHist.h:61
Int_t getIndex(const RooAbsCollection &coord, bool fast=false) const
Calculate bin number of the given coordinates.
double weight(std::size_t i) const
Return weight of i-th bin.
double weightFast(const RooArgSet &bin, int intOrder, bool correctForBinSize, bool cdfBoundaries)
A faster version of RooDataHist::weight that assumes the passed arguments are aligned with the histog...
const RooArgSet * get() const override
Get bin centre of current bin.
Definition RooDataHist.h:82
double sumEntries() const override
Sum the weights of all bins.
std::span< const double > at(RooAbsArg const *arg, RooAbsArg const *caller=nullptr)
std::span< double > output()
A real-valued function sampled from a multidimensional histogram.
Definition RooHistFunc.h:29
bool _cdfBoundaries
Use boundary conditions for CDFs.
RooDataHist * _dataHist
Unowned pointer to underlying histogram.
double _totVolume
! Total volume of space (product of ranges of observables)
void doEval(RooFit::EvalContext &) const override
Base function for computing multiple values of a RooAbsReal.
bool forceAnalyticalInt(const RooAbsArg &dep) const override
double analyticalIntegral(Int_t code, const char *rangeName=nullptr) const override
Return integral identified by 'code'.
~RooHistFunc() override
std::list< double > * binBoundaries(RooAbsRealLValue &, double, double) const override
Return the histogram bin boundaries mapped into the plot-observable coordinate.
std::unique_ptr< RooDataHist > _ownedDataHist
! Owned pointer to underlying histogram
void ioStreamerPass2() override
Schema evolution: if histObsList wasn't filled from persistence (v1) then fill it here.
void initializeOwnedDataHist(std::unique_ptr< RooDataHist > &&dataHist)
double evaluate() const override
Return the current value: The value of the bin enclosing the current coordinates of the dependents,...
std::list< double > * plotSamplingHint(RooAbsRealLValue &obs, double xlo, double xhi) const override
Return sampling hint for making curves of (projections) of this function as the recursive division st...
Int_t getMaxVal(const RooArgSet &vars) const override
Only handle case of maximum in all variables.
double totVolume() const
Get total bin volume spanned by this hist function.
Int_t getBin() const
Compute bin number corresponding to current coordinates.
bool areIdentical(const RooDataHist &dh1, const RooDataHist &dh2)
double maxVal(Int_t code) const override
Return maximum value for set of observables identified by code assigned in getMaxVal.
std::vector< Int_t > getBins(RooFit::EvalContext &ctx) const
Compute bin numbers corresponding to all coordinates in evalData.
bool importWorkspaceHook(RooWorkspace &ws) override
Check if our datahist is already in the workspace.
Int_t getAnalyticalIntegral(RooArgSet &allVars, RooArgSet &analVars, const char *rangeName=nullptr) const override
Determine integration scenario.
RooDataHist * cloneAndOwnDataHist(const char *newname="")
Replaces underlying RooDataHist with a clone, which is now owned, and returns the clone.
Int_t _intOrder
Interpolation order.
static TClass * Class()
RooSetProxy _depList
List of observables mapped onto histogram observables.
RooArgSet _histObsList
List of observables defining dimensions of histogram.
bool forceAnalyticalInt(const RooAbsArg &dep) const override
static std::vector< double > histogramBoundariesInPlotObs(RooDataHist const &dataHist, RooArgSet const &pdfObsList, RooArgSet const &histObsList, RooAbsRealLValue &obs, double xlo, double xhi)
Return the histogram bin boundaries mapped to the coordinates of the plot observable obs.
double analyticalIntegral(Int_t code, const char *rangeName=nullptr) const override
Return integral identified by 'code'.
std::list< double > * plotSamplingHint(RooAbsRealLValue &obs, double xlo, double xhi) const override
Return sampling hint for making curves of (projections) of this function as the recursive division st...
Int_t getAnalyticalIntegral(RooArgSet &allVars, RooArgSet &analVars, const char *rangeName=nullptr) const override
Determine integration scenario.
Variable that can be changed from the outside.
Definition RooRealVar.h:37
Persistable container for RooFit projects.
RooAbsData * embeddedData(RooStringView name) const
Retrieve dataset (binned or unbinned) with given name. A null pointer is returned if not found.
bool import(const RooAbsArg &arg, 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={})
Import a RooAbsArg object, e.g.
Buffer base class used for serializing objects.
Definition TBuffer.h:43
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=nullptr)=0
Bool_t IsReading() const
Definition TBuffer.h:86
virtual Int_t WriteClassBuffer(const TClass *cl, void *pointer)=0
const char * GetName() const override
Returns name of object.
Definition TNamed.h:49
void Clear(Option_t *option="") override
Remove all objects from the array.
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition TObject.cxx:548
RooCmdArg Rename(const char *suffix)
RooCmdArg Embedded(bool flag=true)
std::string getColonSeparatedNameString(RooArgSet const &argSet, char delim=':')