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