Logo ROOT  
Reference Guide
RooVectorDataStore.h
Go to the documentation of this file.
1 /*****************************************************************************
2  * Project: RooFit *
3  * Package: RooFitCore *
4  * File: $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 #ifndef ROO_VECTOR_DATA_STORE
17 #define ROO_VECTOR_DATA_STORE
18 
19 #include "RooAbsDataStore.h"
20 #include "RooAbsCategory.h"
21 #include "RooAbsReal.h"
22 #include "RooChangeTracker.h"
23 
24 #include <list>
25 #include <vector>
26 #include <algorithm>
27 
28 class RooAbsArg ;
29 class RooArgList ;
30 class TTree ;
31 class RooFormulaVar ;
32 class RooArgSet ;
33 
34 #define VECTOR_BUFFER_SIZE 1024
35 
37 public:
38 
40 
41  // Empty ctor
42  RooVectorDataStore(const char* name, const char* title, const RooArgSet& vars, const char* wgtVarName=0) ;
43  virtual RooAbsDataStore* clone(const char* newname=0) const override { return new RooVectorDataStore(*this,newname) ; }
44  virtual RooAbsDataStore* clone(const RooArgSet& vars, const char* newname=0) const override { return new RooVectorDataStore(*this,vars,newname) ; }
45 
46  RooVectorDataStore(const RooVectorDataStore& other, const char* newname=0) ;
47  RooVectorDataStore(const RooTreeDataStore& other, const RooArgSet& vars, const char* newname=0) ;
48  RooVectorDataStore(const RooVectorDataStore& other, const RooArgSet& vars, const char* newname=0) ;
49 
50 
51  RooVectorDataStore(const char *name, const char *title, RooAbsDataStore& tds,
52  const RooArgSet& vars, const RooFormulaVar* cutVar, const char* cutRange,
53  std::size_t nStart, std::size_t nStop, Bool_t /*copyCache*/, const char* wgtVarName=0) ;
54 
55  virtual ~RooVectorDataStore() ;
56 
57 private:
58  RooArgSet varsNoWeight(const RooArgSet& allVars, const char* wgtName);
59  RooRealVar* weightVar(const RooArgSet& allVars, const char* wgtName);
60 
61  // reserve storage for nEvt entries
62  void reserve(Int_t nEvt);
63 
64 public:
65  // Write current row
66  virtual Int_t fill() override;
67 
68  // Retrieve a row
70  virtual const RooArgSet* get(Int_t index) const override;
71 
72  virtual const RooArgSet* getNative(Int_t index) const;
73 
74  virtual Double_t weight() const override;
75  virtual Double_t weightError(RooAbsData::ErrorType etype=RooAbsData::Poisson) const override;
76  virtual void weightError(Double_t& lo, Double_t& hi, RooAbsData::ErrorType etype=RooAbsData::Poisson) const override;
77  virtual Double_t weight(Int_t index) const override;
78  virtual Bool_t isWeighted() const override { return (_wgtVar!=0||_extWgtArray!=0) ; }
79 
80  BatchHelpers::RunContext getBatches(std::size_t first, std::size_t len) const override;
81  virtual RooSpan<const double> getWeightBatch(std::size_t first, std::size_t len) const override;
82 
83  // Change observable name
84  virtual Bool_t changeObservableName(const char* from, const char* to) override;
85 
86  // Add one or more columns
87  virtual RooAbsArg* addColumn(RooAbsArg& var, Bool_t adjustRange=kTRUE) override;
88  virtual RooArgSet* addColumns(const RooArgList& varList) override;
89 
90  // Merge column-wise
91  RooAbsDataStore* merge(const RooArgSet& allvars, std::list<RooAbsDataStore*> dstoreList) override;
92 
93  // Add rows
94  virtual void append(RooAbsDataStore& other) override;
95 
96  // General & bookkeeping methods
97  virtual Bool_t valid() const override;
98  virtual Int_t numEntries() const override { return static_cast<int>(size()); }
99  virtual Double_t sumEntries() const override { return _sumWeight ; }
100  /// Get size of stored dataset.
101  std::size_t size() const {
102  if (!_realStoreList.empty()) {
103  return _realStoreList.front()->size();
104  } else if (!_realfStoreList.empty()) {
105  return _realfStoreList.front()->size();
106  } else if (!_catStoreList.empty()) {
107  return _catStoreList.front()->size();
108  }
109 
110  return 0;
111  }
112  virtual void reset() override;
113 
114  // Buffer redirection routines used in inside RooAbsOptTestStatistics
115  virtual void attachBuffers(const RooArgSet& extObs) override;
116  virtual void resetBuffers() override;
117 
118 
119  // Constant term optimizer interface
120  virtual const RooAbsArg* cacheOwner() override { return _cacheOwner ; }
121  virtual void cacheArgs(const RooAbsArg* owner, RooArgSet& varSet, const RooArgSet* nset=0, Bool_t skipZeroWeights=kTRUE) override;
122  virtual void attachCache(const RooAbsArg* newOwner, const RooArgSet& cachedVars) override;
123  virtual void resetCache() override;
124  virtual void recalculateCache(const RooArgSet* /*proj*/, Int_t firstEvent, Int_t lastEvent, Int_t stepSize, Bool_t skipZeroWeights) override;
125 
126  virtual void setArgStatus(const RooArgSet& set, Bool_t active) override;
127 
128  const RooVectorDataStore* cache() const { return _cache ; }
129 
130  void loadValues(const RooAbsDataStore *tds, const RooFormulaVar* select=0, const char* rangeName=0, std::size_t nStart=0, std::size_t nStop = std::numeric_limits<std::size_t>::max()) override;
131 
132  void dump() override;
133 
134  void setExternalWeightArray(const Double_t* arrayWgt, const Double_t* arrayWgtErrLo,
135  const Double_t* arrayWgtErrHi, const Double_t* arraySumW2) override {
136  _extWgtArray = arrayWgt ;
137  _extWgtErrLoArray = arrayWgtErrLo ;
138  _extWgtErrHiArray = arrayWgtErrHi ;
139  _extSumW2Array = arraySumW2 ;
140  }
141 
142  virtual void setDirtyProp(Bool_t flag) override {
143  _doDirtyProp = flag ;
144  if (_cache) {
145  _cache->setDirtyProp(flag) ;
146  }
147  }
148 
149  const RooArgSet& row() { return _varsww ; }
150 
151  class RealVector {
152  public:
153 
154  RealVector(UInt_t initialCapacity=(VECTOR_BUFFER_SIZE / sizeof(Double_t))) :
155  _nativeReal(0), _real(0), _buf(0), _nativeBuf(0), _tracker(0), _nset(0) {
156  _vec.reserve(initialCapacity);
157  }
158 
159  RealVector(RooAbsReal* arg, UInt_t initialCapacity=(VECTOR_BUFFER_SIZE / sizeof(Double_t))) :
160  _nativeReal(arg), _real(0), _buf(0), _nativeBuf(0), _tracker(0), _nset(0) {
161  _vec.reserve(initialCapacity);
162  }
163 
164  virtual ~RealVector() {
165  delete _tracker;
166  if (_nset) delete _nset ;
167  }
168 
169  RealVector(const RealVector& other, RooAbsReal* real=0) :
170  _vec(other._vec), _nativeReal(real?real:other._nativeReal), _real(real?real:other._real), _buf(other._buf), _nativeBuf(other._nativeBuf), _nset(0) {
171  if (other._tracker) {
172  _tracker = new RooChangeTracker(Form("track_%s",_nativeReal->GetName()),"tracker",other._tracker->parameters()) ;
173  } else {
174  _tracker = 0 ;
175  }
176  if (other._nset) {
177  _nset = new RooArgSet(*other._nset) ;
178  }
179  }
180 
181  RealVector& operator=(const RealVector& other) {
182  if (&other==this) return *this;
183  _nativeReal = other._nativeReal;
184  _real = other._real;
185  _buf = other._buf;
186  _nativeBuf = other._nativeBuf;
187  if (other._vec.size() <= _vec.capacity() / 2 && _vec.capacity() > (VECTOR_BUFFER_SIZE / sizeof(Double_t))) {
188  std::vector<Double_t> tmp;
189  tmp.reserve(std::max(other._vec.size(), VECTOR_BUFFER_SIZE / sizeof(Double_t)));
190  tmp.assign(other._vec.begin(), other._vec.end());
191  _vec.swap(tmp);
192  } else {
193  _vec = other._vec;
194  }
195 
196  return *this;
197  }
198 
199  void setNset(RooArgSet* newNset) { _nset = newNset ? new RooArgSet(*newNset) : 0 ; }
200 
201  RooArgSet* nset() const { return _nset ; }
202 
203  void setBufArg(RooAbsReal* arg) { _nativeReal = arg ; }
204  const RooAbsReal* bufArg() const { return _nativeReal ; }
205 
206  void setBuffer(RooAbsReal* real, Double_t* newBuf) {
207  _real = real ;
208  _buf = newBuf ;
209  if (_nativeBuf==0) {
210  _nativeBuf=newBuf ;
211  }
212  }
213 
214  void setNativeBuffer(Double_t* newBuf=0) {
215  _nativeBuf = newBuf ? newBuf : _buf ;
216  }
217 
218  void setDependents(const RooArgSet& deps) {
219  if (_tracker) {
220  delete _tracker ;
221  }
222  _tracker = new RooChangeTracker(Form("track_%s",_nativeReal->GetName()),"tracker",deps) ;
223  }
224 
226  if (!_tracker) return kFALSE ;
227  return _tracker->hasChanged(kTRUE) ;
228  }
229 
230  void fill() {
231  _vec.push_back(*_buf);
232  }
233 
234  void write(Int_t i) {
235  assert(static_cast<std::size_t>(i) < _vec.size());
236  _vec[i] = *_buf ;
237  }
238 
239  void reset() {
240  _vec.clear();
241  }
242 
243  inline void load(std::size_t idx) const {
244  assert(idx < _vec.size());
245  *_buf = *(_vec.begin() + idx) ;
246  }
247 
248  RooSpan<const double> getRange(std::size_t first, std::size_t last) const {
249  auto beg = std::min(_vec.cbegin() + first, _vec.cend());
250  auto end = std::min(_vec.cbegin() + last, _vec.cend());
251 
252  return RooSpan<const double>(beg, end);
253  }
254 
255  inline void loadToNative(std::size_t idx) const {
256  *_nativeBuf = *(_vec.begin() + idx) ;
257  }
258 
259  std::size_t size() const { return _vec.size() ; }
260 
261  void resize(Int_t siz) {
262  if (siz < Int_t(_vec.capacity()) / 2 && _vec.capacity() > (VECTOR_BUFFER_SIZE / sizeof(Double_t))) {
263  // do an expensive copy, if we save at least a factor 2 in size
264  std::vector<Double_t> tmp;
265  tmp.reserve(std::max(siz, Int_t(VECTOR_BUFFER_SIZE / sizeof(Double_t))));
266  if (!_vec.empty())
267  tmp.assign(_vec.begin(), std::min(_vec.end(), _vec.begin() + siz));
268  if (Int_t(tmp.size()) != siz)
269  tmp.resize(siz);
270  _vec.swap(tmp);
271  } else {
272  _vec.resize(siz);
273  }
274  }
275 
276  void reserve(Int_t siz) {
277  _vec.reserve(siz);
278  }
279 
280  const std::vector<double>& data() const {
281  return _vec;
282  }
283 
284  protected:
285  std::vector<double> _vec;
286 
287  private:
288  friend class RooVectorDataStore ;
289  RooAbsReal* _nativeReal ; // Instance which our data belongs to. This is the variable in the dataset.
290  RooAbsReal* _real ; // Instance where we should write data into when load() is called.
291  Double_t* _buf ; //!
294  RooArgSet* _nset ; //!
295  ClassDef(RealVector,1) // STL-vector-based Data Storage class
296  } ;
297 
298 
299  class RealFullVector : public RealVector {
300  public:
301  RealFullVector(UInt_t initialCapacity=(VECTOR_BUFFER_SIZE / sizeof(Double_t))) : RealVector(initialCapacity),
302  _bufE(0), _bufEL(0), _bufEH(0),
304  _vecE(0), _vecEL(0), _vecEH(0) {
305  }
306 
307  RealFullVector(RooAbsReal* arg, UInt_t initialCapacity=(VECTOR_BUFFER_SIZE / sizeof(Double_t))) :
308  RealVector(arg,initialCapacity),
309  _bufE(0), _bufEL(0), _bufEH(0),
311  _vecE(0), _vecEL(0), _vecEH(0) {
312  }
313 
314  virtual ~RealFullVector() {
315  if (_vecE) delete _vecE ;
316  if (_vecEL) delete _vecEL ;
317  if (_vecEH) delete _vecEH ;
318  }
319 
320  RealFullVector(const RealFullVector& other, RooAbsReal* real=0) : RealVector(other,real),
321  _bufE(other._bufE), _bufEL(other._bufEL), _bufEH(other._bufEH),
323  _vecE = (other._vecE) ? new std::vector<Double_t>(*other._vecE) : 0 ;
324  _vecEL = (other._vecEL) ? new std::vector<Double_t>(*other._vecEL) : 0 ;
325  _vecEH = (other._vecEH) ? new std::vector<Double_t>(*other._vecEH) : 0 ;
326  }
327 
328  RealFullVector(const RealVector& other, RooAbsReal* real=0) : RealVector(other,real),
329  _bufE(0), _bufEL(0), _bufEH(0),
331  _vecE = 0 ;
332  _vecEL = 0 ;
333  _vecEH = 0 ;
334  }
335 
337  if (&other==this) return *this;
338  RealVector::operator=(other);
339  _bufE = other._bufE;
340  _bufEL = other._bufEL;
341  _bufEH = other._bufEH;
342  _nativeBufE = other._nativeBufE;
343  _nativeBufEL = other._nativeBufEL;
344  _nativeBufEH = other._nativeBufEH;
345  std::vector<Double_t>* src[3] = { other._vecE, other._vecEL, other._vecEH };
346  std::vector<Double_t>* dst[3] = { _vecE, _vecEL, _vecEH };
347  for (unsigned i = 0; i < 3; ++i) {
348  if (src[i]) {
349  if (dst[i]) {
350  if (dst[i]->size() <= src[i]->capacity() / 2 &&
351  src[i]->capacity() > (VECTOR_BUFFER_SIZE / sizeof(Double_t))) {
352  std::vector<Double_t> tmp;
353  tmp.reserve(std::max(src[i]->size(), VECTOR_BUFFER_SIZE / sizeof(Double_t)));
354  tmp.assign(src[i]->begin(), src[i]->end());
355  dst[i]->swap(tmp);
356  } else {
357  *dst[i] = *src[i];
358  }
359  } else {
360  dst[i] = new std::vector<Double_t>(*src[i]);
361  }
362  } else {
363  delete dst[i];
364  dst[i] = 0;
365  }
366  }
367  return *this;
368  }
369 
370  void setErrorBuffer(Double_t* newBuf) {
371  /* std::cout << "setErrorBuffer(" << _nativeReal->GetName() << ") newBuf = " << newBuf << std::endl ; */
372  _bufE = newBuf ;
373  if (!_vecE) _vecE = new std::vector<Double_t> ;
374  _vecE->reserve(_vec.capacity()) ;
375  if (!_nativeBufE) _nativeBufE = _bufE ;
376  }
377  void setAsymErrorBuffer(Double_t* newBufL, Double_t* newBufH) {
378  _bufEL = newBufL ; _bufEH = newBufH ;
379  if (!_vecEL) {
380  _vecEL = new std::vector<Double_t> ;
381  _vecEH = new std::vector<Double_t> ;
382  _vecEL->reserve(_vec.capacity()) ;
383  _vecEH->reserve(_vec.capacity()) ;
384  }
385  if (!_nativeBufEL) {
386  _nativeBufEL = _bufEL ;
387  _nativeBufEH = _bufEH ;
388  }
389  }
390 
391  inline void loadToNative(Int_t idx) const {
393  if (_vecE) {
394  *_nativeBufE = (*_vecE)[idx] ;
395  }
396  if (_vecEL) {
397  *_nativeBufEL = (*_vecEL)[idx] ;
398  *_nativeBufEH = (*_vecEH)[idx] ;
399  }
400  }
401 
402  void fill() {
403  RealVector::fill() ;
404  if (_vecE) _vecE->push_back(*_bufE) ;
405  if (_vecEL) _vecEL->push_back(*_bufEL) ;
406  if (_vecEH) _vecEH->push_back(*_bufEH) ;
407  } ;
408 
409  void write(Int_t i) {
410  RealVector::write(i) ;
411  if (_vecE) (*_vecE)[i] = *_bufE ;
412  if (_vecEL) (*_vecEL)[i] = *_bufEL ;
413  if (_vecEH) (*_vecEH)[i] = *_bufEH ;
414  }
415 
416  void reset() {
418  if (_vecE) {
419  std::vector<Double_t> tmp;
420  _vecE->swap(tmp);
421  }
422  if (_vecEL) {
423  std::vector<Double_t> tmp;
424  _vecEL->swap(tmp);
425  }
426  if (_vecEH) {
427  std::vector<Double_t> tmp;
428  _vecEH->swap(tmp);
429  }
430  }
431 
432  inline void get(Int_t idx) const {
433  RealVector::load(idx) ;
434  if (_vecE) *_bufE = (*_vecE)[idx];
435  if (_vecEL) *_bufEL = (*_vecEL)[idx] ;
436  if (_vecEH) *_bufEH = (*_vecEH)[idx] ;
437  }
438 
439  void resize(Int_t siz) {
440  RealVector::resize(siz);
441  std::vector<Double_t>* vlist[3] = { _vecE, _vecEL, _vecEH };
442  for (unsigned i = 0; i < 3; ++i) {
443  if (!vlist[i]) continue;
444  if (vlist[i]) {
445  if (siz < Int_t(vlist[i]->capacity()) / 2 && vlist[i]->capacity() > (VECTOR_BUFFER_SIZE / sizeof(Double_t))) {
446  // if we gain a factor of 2 in memory, we copy and swap
447  std::vector<Double_t> tmp;
448  tmp.reserve(std::max(siz, Int_t(VECTOR_BUFFER_SIZE / sizeof(Double_t))));
449  if (!vlist[i]->empty())
450  tmp.assign(vlist[i]->begin(),
451  std::min(_vec.end(), _vec.begin() + siz));
452  if (Int_t(tmp.size()) != siz)
453  tmp.resize(siz);
454  vlist[i]->swap(tmp);
455  } else {
456  vlist[i]->resize(siz);
457  }
458  }
459  }
460  }
461 
462  void reserve(Int_t siz) {
463  RealVector::reserve(siz);
464  if (_vecE) _vecE->reserve(siz);
465  if (_vecEL) _vecEL->reserve(siz);
466  if (_vecEH) _vecEH->reserve(siz);
467  }
468 
469  private:
470  friend class RooVectorDataStore ;
477  std::vector<double> *_vecE, *_vecEL, *_vecEH ;
478  ClassDef(RealFullVector,1) // STL-vector-based Data Storage class
479  } ;
480 
481 
482  class CatVector {
483  public:
484  CatVector(UInt_t initialCapacity = VECTOR_BUFFER_SIZE) :
485  _cat(nullptr), _buf(nullptr), _nativeBuf(nullptr)
486  {
487  _vec.reserve(initialCapacity);
488  }
489 
491  _cat(cat), _buf(nullptr), _nativeBuf(nullptr)
492  {
493  _vec.reserve(initialCapacity);
494  }
495 
496  virtual ~CatVector() {
497  }
498 
499  CatVector(const CatVector& other, RooAbsCategory* cat = nullptr) :
500  _cat(cat?cat:other._cat), _buf(other._buf), _nativeBuf(other._nativeBuf), _vec(other._vec)
501  {
502 
503  }
504 
505  CatVector& operator=(const CatVector& other) {
506  if (&other==this) return *this;
507  _cat = other._cat;
508  _buf = other._buf;
509  _nativeBuf = other._nativeBuf;
510  if (other._vec.size() <= _vec.capacity() / 2 && _vec.capacity() > VECTOR_BUFFER_SIZE) {
511  std::vector<RooAbsCategory::value_type> tmp;
512  tmp.reserve(std::max(other._vec.size(), std::size_t(VECTOR_BUFFER_SIZE)));
513  tmp.assign(other._vec.begin(), other._vec.end());
514  _vec.swap(tmp);
515  } else {
516  _vec = other._vec;
517  }
518 
519  return *this;
520  }
521 
523  _buf = newBuf ;
524  if (!_nativeBuf) _nativeBuf = newBuf;
525  }
526 
527  void setNativeBuffer(RooAbsCategory::value_type* newBuf = nullptr) {
528  _nativeBuf = newBuf ? newBuf : _buf;
529  }
530 
531  void fill() {
532  _vec.push_back(*_buf) ;
533  }
534 
535  void write(std::size_t i) {
536  _vec[i] = *_buf;
537  }
538 
539  void reset() {
540  // make sure the vector releases the underlying memory
541  std::vector<RooAbsCategory::value_type> tmp;
542  _vec.swap(tmp);
543  }
544 
545  inline void load(std::size_t idx) const {
546  *_buf = _vec[idx];
547  }
548 
549  inline void loadToNative(std::size_t idx) const {
550  *_nativeBuf = _vec[idx];
551  }
552 
553  std::size_t size() const { return _vec.size() ; }
554 
555  void resize(Int_t siz) {
556  if (siz < Int_t(_vec.capacity()) / 2 && _vec.capacity() > VECTOR_BUFFER_SIZE) {
557  // do an expensive copy, if we save at least a factor 2 in size
558  std::vector<RooAbsCategory::value_type> tmp;
559  tmp.reserve(std::max(siz, VECTOR_BUFFER_SIZE));
560  if (!_vec.empty())
561  tmp.assign(_vec.begin(), std::min(_vec.end(), _vec.begin() + siz));
562  if (Int_t(tmp.size()) != siz)
563  tmp.resize(siz);
564  _vec.swap(tmp);
565  } else {
566  _vec.resize(siz);
567  }
568  }
569 
570  void reserve(Int_t siz) {
571  _vec.reserve(siz);
572  }
573 
574  void setBufArg(RooAbsCategory* arg) { _cat = arg; }
575  const RooAbsCategory* bufArg() const { return _cat; }
576 
577  private:
578  friend class RooVectorDataStore ;
582  std::vector<RooAbsCategory::value_type> _vec;
583  ClassDef(CatVector,2) // STL-vector-based Data Storage class
584  } ;
585 
586 
587  protected:
588 
589  friend class RooAbsReal ;
590  friend class RooAbsCategory ;
591  friend class RooRealVar ;
592  std::vector<RealVector*>& realStoreList() { return _realStoreList ; }
593  std::vector<RealFullVector*>& realfStoreList() { return _realfStoreList ; }
594  std::vector<CatVector*>& catStoreList() { return _catStoreList ; }
595 
596  CatVector* addCategory(RooAbsCategory* cat);
597 
598  RealVector* addReal(RooAbsReal* real);
599 
601 
602  Bool_t hasError(RooAbsReal* real);
603 
605 
606  RealFullVector* addRealFull(RooAbsReal* real);
607 
608  virtual Bool_t hasFilledCache() const override { return _cache ? kTRUE : kFALSE ; }
609 
610  void forceCacheUpdate() override;
611 
612  private:
614  RooRealVar* _wgtVar ; // Pointer to weight variable (if set)
615 
616  std::vector<RealVector*> _realStoreList ;
617  std::vector<RealFullVector*> _realfStoreList ;
618  std::vector<CatVector*> _catStoreList ;
619  std::vector<double> _weights;
620 
621  void setAllBuffersNative() ;
622 
625 
626  const Double_t* _extWgtArray ; //! External weight array
627  const Double_t* _extWgtErrLoArray ; //! External weight array - low error
628  const Double_t* _extWgtErrHiArray ; //! External weight array - high error
629  const Double_t* _extSumW2Array ; //! External sum of weights array
630 
631  mutable Double_t _curWgt ; // Weight of current event
632  mutable Double_t _curWgtErrLo ; // Weight of current event
633  mutable Double_t _curWgtErrHi ; // Weight of current event
634  mutable Double_t _curWgtErr ; // Weight of current event
635 
636  RooVectorDataStore* _cache ; //! Optimization cache
637  RooAbsArg* _cacheOwner ; //! Cache owner
638 
639  Bool_t _forcedUpdate ; //! Request for forced cache update
640 
641  ClassDefOverride(RooVectorDataStore,4) // STL-vector-based Data Storage class
642 };
643 
644 
645 #endif
RooVectorDataStore::loadValues
void loadValues(const RooAbsDataStore *tds, const RooFormulaVar *select=0, const char *rangeName=0, std::size_t nStart=0, std::size_t nStop=std::numeric_limits< std::size_t >::max()) override
Definition: RooVectorDataStore.cxx:672
RooVectorDataStore::cacheOwner
virtual const RooAbsArg * cacheOwner() override
Definition: RooVectorDataStore.h:120
RooVectorDataStore::_curWgt
Double_t _curWgt
External sum of weights array.
Definition: RooVectorDataStore.h:631
RooVectorDataStore::_extSumW2Array
const Double_t * _extSumW2Array
External weight array - high error.
Definition: RooVectorDataStore.h:629
RooVectorDataStore::addReal
RealVector * addReal(RooAbsReal *real)
Definition: RooVectorDataStore.cxx:1511
RooVectorDataStore::RealFullVector::reset
void reset()
Definition: RooVectorDataStore.h:416
RooVectorDataStore::RealVector::size
std::size_t size() const
Definition: RooVectorDataStore.h:259
RooVectorDataStore::append
virtual void append(RooAbsDataStore &other) override
Definition: RooVectorDataStore.cxx:978
RooVectorDataStore::isWeighted
virtual Bool_t isWeighted() const override
Definition: RooVectorDataStore.h:78
RooVectorDataStore::_curWgtErrHi
Double_t _curWgtErrHi
Definition: RooVectorDataStore.h:633
first
Definition: first.py:1
RooAbsDataStore::cachedVars
const RooArgSet & cachedVars() const
Definition: RooAbsDataStore.h:109
RooVectorDataStore::RealVector::reserve
void reserve(Int_t siz)
Definition: RooVectorDataStore.h:276
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
RooAbsReal.h
RooVectorDataStore::RealFullVector::_nativeBufEL
Double_t * _nativeBufEL
Definition: RooVectorDataStore.h:475
RooVectorDataStore::~RooVectorDataStore
virtual ~RooVectorDataStore()
Destructor.
Definition: RooVectorDataStore.cxx:364
RooAbsDataStore::get
virtual const RooArgSet * get() const
Definition: RooAbsDataStore.h:50
RooVectorDataStore::RealVector::_tracker
RooChangeTracker * _tracker
Definition: RooVectorDataStore.h:293
RooVectorDataStore::setExternalWeightArray
void setExternalWeightArray(const Double_t *arrayWgt, const Double_t *arrayWgtErrLo, const Double_t *arrayWgtErrHi, const Double_t *arraySumW2) override
Definition: RooVectorDataStore.h:134
RooVectorDataStore::RealFullVector::_vecEL
std::vector< double > * _vecEL
Definition: RooVectorDataStore.h:477
RooVectorDataStore::RealFullVector::write
void write(Int_t i)
Definition: RooVectorDataStore.h:409
RooVectorDataStore::recalculateCache
virtual void recalculateCache(const RooArgSet *, Int_t firstEvent, Int_t lastEvent, Int_t stepSize, Bool_t skipZeroWeights) override
Definition: RooVectorDataStore.cxx:1190
RooVectorDataStore::RealVector::load
void load(std::size_t idx) const
Definition: RooVectorDataStore.h:243
RooVectorDataStore::CatVector::size
std::size_t size() const
Definition: RooVectorDataStore.h:553
RooVectorDataStore::changeObservableName
virtual Bool_t changeObservableName(const char *from, const char *to) override
Definition: RooVectorDataStore.cxx:769
RooVectorDataStore::_realStoreList
std::vector< RealVector * > _realStoreList
Definition: RooVectorDataStore.h:616
RooVectorDataStore::row
const RooArgSet & row()
Definition: RooVectorDataStore.h:149
RooVectorDataStore::addColumns
virtual RooArgSet * addColumns(const RooArgList &varList) override
Utility function to add multiple columns in one call See addColumn() for details.
Definition: RooVectorDataStore.cxx:853
RooVectorDataStore::RealVector::_real
RooAbsReal * _real
Definition: RooVectorDataStore.h:290
Form
char * Form(const char *fmt,...)
RooVectorDataStore::cacheArgs
virtual void cacheArgs(const RooAbsArg *owner, RooArgSet &varSet, const RooArgSet *nset=0, Bool_t skipZeroWeights=kTRUE) override
Cache given RooAbsArgs: The tree is given direct write access of the args internal cache the args val...
Definition: RooVectorDataStore.cxx:1022
RooVectorDataStore::CatVector::setNativeBuffer
void setNativeBuffer(RooAbsCategory::value_type *newBuf=nullptr)
Definition: RooVectorDataStore.h:527
RooVectorDataStore::weightVar
RooRealVar * weightVar(const RooArgSet &allVars, const char *wgtName)
Utility function for constructors Return pointer to weight variable if it is defined.
Definition: RooVectorDataStore.cxx:153
RooVectorDataStore::CatVector::write
void write(std::size_t i)
Definition: RooVectorDataStore.h:535
RooVectorDataStore::RealFullVector::_nativeBufE
Double_t * _nativeBufE
Definition: RooVectorDataStore.h:474
RooVectorDataStore::RooVectorDataStore
RooVectorDataStore()
Definition: RooVectorDataStore.cxx:60
RooArgList
RooArgList is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgList.h:21
TTree
A TTree represents a columnar dataset.
Definition: TTree.h:79
RooVectorDataStore::RealVector::setDependents
void setDependents(const RooArgSet &deps)
Definition: RooVectorDataStore.h:218
RooVectorDataStore::CatVector::setBuffer
void setBuffer(RooAbsCategory::value_type *newBuf)
Definition: RooVectorDataStore.h:522
RooVectorDataStore::CatVector::loadToNative
void loadToNative(std::size_t idx) const
Definition: RooVectorDataStore.h:549
RooVectorDataStore::RealFullVector::_nativeBufEH
Double_t * _nativeBufEH
Definition: RooVectorDataStore.h:476
RooVectorDataStore::cache
const RooVectorDataStore * cache() const
Definition: RooVectorDataStore.h:128
RooVectorDataStore::RealVector::needRecalc
Bool_t needRecalc()
Definition: RooVectorDataStore.h:225
RooVectorDataStore::RealFullVector::fill
void fill()
Definition: RooVectorDataStore.h:402
Int_t
int Int_t
Definition: RtypesCore.h:45
RooVectorDataStore::CatVector::resize
void resize(Int_t siz)
Definition: RooVectorDataStore.h:555
RooVectorDataStore::_cacheOwner
RooAbsArg * _cacheOwner
Optimization cache.
Definition: RooVectorDataStore.h:637
RooVectorDataStore::RealFullVector::RealFullVector
RealFullVector(const RealFullVector &other, RooAbsReal *real=0)
Definition: RooVectorDataStore.h:320
RooAbsReal
RooAbsReal is the common abstract base class for objects that represent a real value and implements f...
Definition: RooAbsReal.h:61
RooVectorDataStore::realfStoreList
std::vector< RealFullVector * > & realfStoreList()
Definition: RooVectorDataStore.h:593
RooVectorDataStore::getBatches
BatchHelpers::RunContext getBatches(std::size_t first, std::size_t len) const override
Return batches of the data columns for the requested events.
Definition: RooVectorDataStore.cxx:1426
RooVectorDataStore::_curWgtErrLo
Double_t _curWgtErrLo
Definition: RooVectorDataStore.h:632
RooVectorDataStore::CatVector::load
void load(std::size_t idx) const
Definition: RooVectorDataStore.h:545
RooVectorDataStore::size
std::size_t size() const
Get size of stored dataset.
Definition: RooVectorDataStore.h:101
RooVectorDataStore::RealVector::data
const std::vector< double > & data() const
Definition: RooVectorDataStore.h:280
RooVectorDataStore::RealVector::setNset
void setNset(RooArgSet *newNset)
Definition: RooVectorDataStore.h:199
RooVectorDataStore::CatVector::_nativeBuf
RooAbsCategory::value_type * _nativeBuf
Definition: RooVectorDataStore.h:581
RooVectorDataStore::RealFullVector::~RealFullVector
virtual ~RealFullVector()
Definition: RooVectorDataStore.h:314
ClassDefOverride
#define ClassDefOverride(name, id)
Definition: Rtypes.h:329
RooVectorDataStore::_sumWeightCarry
Double_t _sumWeightCarry
Definition: RooVectorDataStore.h:624
RooAbsData::ErrorType
ErrorType
Definition: RooAbsData.h:97
RooVectorDataStore::_curWgtErr
Double_t _curWgtErr
Definition: RooVectorDataStore.h:634
RooVectorDataStore::CatVector::~CatVector
virtual ~CatVector()
Definition: RooVectorDataStore.h:496
RooVectorDataStore::CatVector::_cat
RooAbsCategory * _cat
Definition: RooVectorDataStore.h:579
RooVectorDataStore::setAllBuffersNative
void setAllBuffersNative()
Definition: RooVectorDataStore.cxx:113
RooVectorDataStore::_extWgtErrLoArray
const Double_t * _extWgtErrLoArray
External weight array.
Definition: RooVectorDataStore.h:627
RooVectorDataStore::hasAsymError
Bool_t hasAsymError(RooAbsReal *real)
Definition: RooVectorDataStore.cxx:1559
bool
BatchHelpers::RunContext
Data that has to be passed around when evaluating functions / PDFs.
Definition: RunContext.h:32
RooVectorDataStore::RealVector::fill
void fill()
Definition: RooVectorDataStore.h:230
RooVectorDataStore::dump
void dump() override
Definition: RooVectorDataStore.cxx:1334
RooVectorDataStore::_extWgtErrHiArray
const Double_t * _extWgtErrHiArray
External weight array - low error.
Definition: RooVectorDataStore.h:628
RooChangeTracker
RooChangeTracker is a meta object that tracks value changes in a given set of RooAbsArgs by registeri...
Definition: RooChangeTracker.h:26
RooVectorDataStore::realStoreList
std::vector< RealVector * > & realStoreList()
Definition: RooVectorDataStore.h:592
RooAbsCategory
RooAbsCategory is the base class for objects that represent a discrete value with a finite number of ...
Definition: RooAbsCategory.h:38
RooVectorDataStore::isFullReal
Bool_t isFullReal(RooAbsReal *real)
Definition: RooVectorDataStore.cxx:1535
RooVectorDataStore::RealFullVector::RealFullVector
RealFullVector(RooAbsReal *arg, UInt_t initialCapacity=(VECTOR_BUFFER_SIZE/sizeof(Double_t)))
Definition: RooVectorDataStore.h:307
RooVectorDataStore::reset
virtual void reset() override
Definition: RooVectorDataStore.cxx:996
RooVectorDataStore::RealVector::bufArg
const RooAbsReal * bufArg() const
Definition: RooVectorDataStore.h:204
hi
float type_of_call hi(const int &, const int &)
RooVectorDataStore::RealFullVector::_bufEL
Double_t * _bufEL
Definition: RooVectorDataStore.h:472
RooVectorDataStore::RealFullVector::operator=
RealFullVector & operator=(const RealFullVector &other)
Definition: RooVectorDataStore.h:336
RooChangeTracker::parameters
RooArgSet parameters() const
Definition: RooChangeTracker.cxx:216
RooVectorDataStore::_forcedUpdate
Bool_t _forcedUpdate
Cache owner.
Definition: RooVectorDataStore.h:639
RooVectorDataStore::catStoreList
std::vector< CatVector * > & catStoreList()
Definition: RooVectorDataStore.h:594
VECTOR_BUFFER_SIZE
#define VECTOR_BUFFER_SIZE
Definition: RooVectorDataStore.h:34
RooVectorDataStore::CatVector::_vec
std::vector< RooAbsCategory::value_type > _vec
Definition: RooVectorDataStore.h:582
RooVectorDataStore::valid
virtual Bool_t valid() const override
Return true if currently loaded coordinate is considered valid within the current range definitions o...
Definition: RooVectorDataStore.cxx:389
RooVectorDataStore::attachCache
virtual void attachCache(const RooAbsArg *newOwner, const RooArgSet &cachedVars) override
Initialize cache of dataset: attach variables of cache ArgSet to the corresponding TTree branches.
Definition: RooVectorDataStore.cxx:1250
RooFormulaVar
A RooFormulaVar is a generic implementation of a real-valued object, which takes a RooArgList of serv...
Definition: RooFormulaVar.h:30
RooVectorDataStore::_realfStoreList
std::vector< RealFullVector * > _realfStoreList
Definition: RooVectorDataStore.h:617
RooVectorDataStore::RealFullVector::setErrorBuffer
void setErrorBuffer(Double_t *newBuf)
Definition: RooVectorDataStore.h:370
RooVectorDataStore::CatVector::reserve
void reserve(Int_t siz)
Definition: RooVectorDataStore.h:570
RooVectorDataStore::weightError
virtual Double_t weightError(RooAbsData::ErrorType etype=RooAbsData::Poisson) const override
Return the error of the current weight.
Definition: RooVectorDataStore.cxx:572
RooVectorDataStore::hasFilledCache
virtual Bool_t hasFilledCache() const override
Definition: RooVectorDataStore.h:608
RooVectorDataStore::addCategory
CatVector * addCategory(RooAbsCategory *cat)
Definition: RooVectorDataStore.cxx:1495
RooVectorDataStore::addColumn
virtual RooAbsArg * addColumn(RooAbsArg &var, Bool_t adjustRange=kTRUE) override
Add a new column to the data set which holds the pre-calculated values of 'newVar'.
Definition: RooVectorDataStore.cxx:797
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:92
RooVectorDataStore::RealVector::~RealVector
virtual ~RealVector()
Definition: RooVectorDataStore.h:164
RooVectorDataStore::RealVector::_buf
Double_t * _buf
Definition: RooVectorDataStore.h:291
RooVectorDataStore::RealVector::operator=
RealVector & operator=(const RealVector &other)
Definition: RooVectorDataStore.h:181
RooVectorDataStore::weight
virtual Double_t weight() const override
Return the weight of the n-th data point (n='index') in memory.
Definition: RooVectorDataStore.cxx:561
RooVectorDataStore::setDirtyProp
virtual void setDirtyProp(Bool_t flag) override
Definition: RooVectorDataStore.h:142
RooVectorDataStore::CatVector::reset
void reset()
Definition: RooVectorDataStore.h:539
RooVectorDataStore::RealFullVector::_bufE
Double_t * _bufE
Definition: RooVectorDataStore.h:471
RooVectorDataStore::RealFullVector::reserve
void reserve(Int_t siz)
Definition: RooVectorDataStore.h:462
RooVectorDataStore::RealVector::write
void write(Int_t i)
Definition: RooVectorDataStore.h:234
RooVectorDataStore::CatVector::setBufArg
void setBufArg(RooAbsCategory *arg)
Definition: RooVectorDataStore.h:574
RooVectorDataStore::RealVector
Definition: RooVectorDataStore.h:151
RooChangeTracker::hasChanged
Bool_t hasChanged(Bool_t clearState)
Returns true if state has changed since last call with clearState=kTRUE.
Definition: RooChangeTracker.cxx:120
RooVectorDataStore::RealVector::reset
void reset()
Definition: RooVectorDataStore.h:239
RooVectorDataStore::getWeightBatch
virtual RooSpan< const double > getWeightBatch(std::size_t first, std::size_t len) const override
Return the weights of all events in the range [first, first+len).
Definition: RooVectorDataStore.cxx:1470
RooVectorDataStore::_cache
RooVectorDataStore * _cache
Definition: RooVectorDataStore.h:636
RooVectorDataStore::RealFullVector::_bufEH
Double_t * _bufEH
Definition: RooVectorDataStore.h:473
RooVectorDataStore::RealFullVector::_vecEH
std::vector< double > * _vecEH
Definition: RooVectorDataStore.h:477
RooVectorDataStore::CatVector
Definition: RooVectorDataStore.h:482
RooTreeDataStore
RooTreeDataStore is a TTree-backed data storage.
Definition: RooTreeDataStore.h:31
RooAbsDataStore.h
RooAbsData::Poisson
@ Poisson
Definition: RooAbsData.h:97
RooVectorDataStore::RealVector::setNativeBuffer
void setNativeBuffer(Double_t *newBuf=0)
Definition: RooVectorDataStore.h:214
unsigned int
RooVectorDataStore::RealVector::_vec
std::vector< double > _vec
Definition: RooVectorDataStore.h:285
RooVectorDataStore::merge
RooAbsDataStore * merge(const RooArgSet &allvars, std::list< RooAbsDataStore * > dstoreList) override
Merge columns of supplied data set(s) with this data set.
Definition: RooVectorDataStore.cxx:937
RooVectorDataStore::hasError
Bool_t hasError(RooAbsReal *real)
Definition: RooVectorDataStore.cxx:1547
RooVectorDataStore::clone
virtual RooAbsDataStore * clone(const char *newname=0) const override
Definition: RooVectorDataStore.h:43
RooVectorDataStore::numEntries
virtual Int_t numEntries() const override
Definition: RooVectorDataStore.h:98
RooVectorDataStore::RealFullVector::get
void get(Int_t idx) const
Definition: RooVectorDataStore.h:432
RooVectorDataStore::RealVector::resize
void resize(Int_t siz)
Definition: RooVectorDataStore.h:261
RooAbsDataStore::_doDirtyProp
Bool_t _doDirtyProp
Definition: RooAbsDataStore.h:133
RooVectorDataStore::RealVector::getRange
RooSpan< const double > getRange(std::size_t first, std::size_t last) const
Definition: RooVectorDataStore.h:248
RooVectorDataStore::RealVector::setBufArg
void setBufArg(RooAbsReal *arg)
Definition: RooVectorDataStore.h:203
RooVectorDataStore::RealFullVector::loadToNative
void loadToNative(Int_t idx) const
Definition: RooVectorDataStore.h:391
RooVectorDataStore::RealVector::_nativeBuf
Double_t * _nativeBuf
Definition: RooVectorDataStore.h:292
RooVectorDataStore::RealVector::setBuffer
void setBuffer(RooAbsReal *real, Double_t *newBuf)
Definition: RooVectorDataStore.h:206
RooVectorDataStore::get
virtual const RooArgSet * get(Int_t index) const=0
Double_t
double Double_t
Definition: RtypesCore.h:59
RooAbsCategory.h
RooVectorDataStore::_varsww
RooArgSet _varsww
Definition: RooVectorDataStore.h:613
RooVectorDataStore::CatVector::bufArg
const RooAbsCategory * bufArg() const
Definition: RooVectorDataStore.h:575
RooChangeTracker.h
RooVectorDataStore::addRealFull
RealFullVector * addRealFull(RooAbsReal *real)
Definition: RooVectorDataStore.cxx:1571
RooVectorDataStore::_weights
std::vector< double > _weights
Definition: RooVectorDataStore.h:619
RooVectorDataStore::RealFullVector::resize
void resize(Int_t siz)
Definition: RooVectorDataStore.h:439
RooVectorDataStore::CatVector::CatVector
CatVector(RooAbsCategory *cat, UInt_t initialCapacity=VECTOR_BUFFER_SIZE)
Definition: RooVectorDataStore.h:490
RooVectorDataStore::RealFullVector
Definition: RooVectorDataStore.h:299
RooVectorDataStore::RealVector::loadToNative
void loadToNative(std::size_t idx) const
Definition: RooVectorDataStore.h:255
RooVectorDataStore
RooVectorDataStore uses std::vectors to store data columns.
Definition: RooVectorDataStore.h:36
RooVectorDataStore::resetBuffers
virtual void resetBuffers() override
Definition: RooVectorDataStore.cxx:1323
RooVectorDataStore::getNative
virtual const RooArgSet * getNative(Int_t index) const
Load the n-th data point (n='index') into the variables of this dataset, and return a pointer to the ...
Definition: RooVectorDataStore.cxx:488
ClassDef
#define ClassDef(name, id)
Definition: Rtypes.h:325
name
char name[80]
Definition: TGX11.cxx:110
RooVectorDataStore::CatVector::CatVector
CatVector(const CatVector &other, RooAbsCategory *cat=nullptr)
Definition: RooVectorDataStore.h:499
RooVectorDataStore::RealVector::_nativeReal
RooAbsReal * _nativeReal
Definition: RooVectorDataStore.h:289
RooVectorDataStore::_wgtVar
RooRealVar * _wgtVar
Definition: RooVectorDataStore.h:614
RooVectorDataStore::resetCache
virtual void resetCache() override
Definition: RooVectorDataStore.cxx:1283
RooVectorDataStore::CatVector::fill
void fill()
Definition: RooVectorDataStore.h:531
RooAbsArg
RooAbsArg is the common abstract base class for objects that represent a value and a "shape" in RooFi...
Definition: RooAbsArg.h:72
RooVectorDataStore::CatVector::CatVector
CatVector(UInt_t initialCapacity=VECTOR_BUFFER_SIZE)
Definition: RooVectorDataStore.h:484
RooVectorDataStore::RealVector::RealVector
RealVector(RooAbsReal *arg, UInt_t initialCapacity=(VECTOR_BUFFER_SIZE/sizeof(Double_t)))
Definition: RooVectorDataStore.h:159
RooVectorDataStore::sumEntries
virtual Double_t sumEntries() const override
Definition: RooVectorDataStore.h:99
RooVectorDataStore::reserve
void reserve(Int_t nEvt)
Definition: RooVectorDataStore.cxx:961
RooVectorDataStore::RealFullVector::setAsymErrorBuffer
void setAsymErrorBuffer(Double_t *newBufL, Double_t *newBufH)
Definition: RooVectorDataStore.h:377
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
RooAbsDataStore
RooAbsDataStore is the abstract base class for data collection that use a TTree as internal storage m...
Definition: RooAbsDataStore.h:34
RooVectorDataStore::RealFullVector::_vecE
std::vector< double > * _vecE
Definition: RooVectorDataStore.h:477
RooVectorDataStore::clone
virtual RooAbsDataStore * clone(const RooArgSet &vars, const char *newname=0) const override
Definition: RooVectorDataStore.h:44
RooVectorDataStore::RealVector::RealVector
RealVector(const RealVector &other, RooAbsReal *real=0)
Definition: RooVectorDataStore.h:169
RooVectorDataStore::fill
virtual Int_t fill() override
Interface function to TTree::Fill.
Definition: RooVectorDataStore.cxx:400
RooVectorDataStore::RealFullVector::RealFullVector
RealFullVector(const RealVector &other, RooAbsReal *real=0)
Definition: RooVectorDataStore.h:328
RooRealVar
RooRealVar represents a variable that can be changed from the outside.
Definition: RooRealVar.h:37
RooVectorDataStore::CatVector::_buf
RooAbsCategory::value_type * _buf
Definition: RooVectorDataStore.h:580
RooVectorDataStore::attachBuffers
virtual void attachBuffers(const RooArgSet &extObs) override
Definition: RooVectorDataStore.cxx:1309
RooVectorDataStore::RealVector::nset
RooArgSet * nset() const
Definition: RooVectorDataStore.h:201
RooVectorDataStore::_extWgtArray
const Double_t * _extWgtArray
Definition: RooVectorDataStore.h:626
RooVectorDataStore::RealVector::RealVector
RealVector(UInt_t initialCapacity=(VECTOR_BUFFER_SIZE/sizeof(Double_t)))
Definition: RooVectorDataStore.h:154
RooVectorDataStore::_catStoreList
std::vector< CatVector * > _catStoreList
Definition: RooVectorDataStore.h:618
RooVectorDataStore::forceCacheUpdate
void forceCacheUpdate() override
Definition: RooVectorDataStore.cxx:1181
RooVectorDataStore::setArgStatus
virtual void setArgStatus(const RooArgSet &set, Bool_t active) override
Disabling of branches is (intentionally) not implemented in vector data stores (as the doesn't result...
Definition: RooVectorDataStore.cxx:1299
RooVectorDataStore::CatVector::operator=
CatVector & operator=(const CatVector &other)
Definition: RooVectorDataStore.h:505
RooSpan
A simple container to hold a batch of data values.
Definition: RooSpan.h:34
RooVectorDataStore::RealVector::_nset
RooArgSet * _nset
Definition: RooVectorDataStore.h:294
RooVectorDataStore::varsNoWeight
RooArgSet varsNoWeight(const RooArgSet &allVars, const char *wgtName)
Utility function for constructors Return RooArgSet that is copy of allVars minus variable matching wg...
Definition: RooVectorDataStore.cxx:135
RooArgSet
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:29
int
RooVectorDataStore::_sumWeight
Double_t _sumWeight
Definition: RooVectorDataStore.h:623
RooVectorDataStore::RealFullVector::RealFullVector
RealFullVector(UInt_t initialCapacity=(VECTOR_BUFFER_SIZE/sizeof(Double_t)))
Definition: RooVectorDataStore.h:301