Logo ROOT  
Reference Guide
RooCompositeDataStore.cxx
Go to the documentation of this file.
1 /*****************************************************************************
2  * Project: RooFit *
3  * Package: RooFitCore *
4  * @(#)root/roofitcore:$Id$
5  * Authors: *
6  * WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
7  * DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
8  * *
9  * Copyright (c) 2000-2005, Regents of the University of California *
10  * and Stanford University. All rights reserved. *
11  * *
12  * Redistribution and use in source and binary forms, *
13  * with or without modification, are permitted according to the terms *
14  * listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
15  *****************************************************************************/
16 
17 /**
18 \file RooCompositeDataStore.cxx
19 \class RooCompositeDataStore
20 \ingroup Roofitcore
21 
22 RooCompositeDataStore combines several disjunct datasets into one. This is useful for simultaneous PDFs
23 that do not depend on the same observable such as a PDF depending on `x` combined with another one depending
24 on `y`.
25 The composite storage will store two different datasets, `{x}` and `{y}`, but they can be passed as a single
26 dataset to RooFit operations. A category tag will define which dataset has to be passed to which likelihood.
27 
28 When iterated from start to finish, datasets will be traversed in the order of the category index.
29 **/
30 
31 #include "RooCompositeDataStore.h"
32 
33 #include "RooFit.h"
34 #include "RooMsgService.h"
35 #include "RooFormulaVar.h"
36 #include "RooRealVar.h"
37 #include "RooTrace.h"
38 #include "RooCategory.h"
39 
40 #include "TTree.h"
41 #include "TChain.h"
42 
43 #include <iomanip>
44 #include <iostream>
45 
46 using namespace std;
47 
49 
50 
51 ////////////////////////////////////////////////////////////////////////////////
52 
53 RooCompositeDataStore::RooCompositeDataStore() : _indexCat(0), _curStore(0), _curIndex(0), _ownComps(kFALSE)
54 {
56 }
57 
58 
59 
60 ////////////////////////////////////////////////////////////////////////////////
61 /// Convert map by label to map by index for more efficient internal use
62 
63 RooCompositeDataStore::RooCompositeDataStore(const char* name, const char* title, const RooArgSet& vars, RooCategory& indexCat,map<std::string,RooAbsDataStore*> inputData) :
64  RooAbsDataStore(name,title,RooArgSet(vars,indexCat)), _indexCat(&indexCat), _curStore(0), _curIndex(0), _ownComps(kFALSE)
65 {
66  for (const auto& iter : inputData) {
67  const RooAbsCategory::value_type idx = indexCat.lookupIndex(iter.first);
68  _dataMap[idx] = iter.second;
69  }
71 }
72 
73 
74 
75 
76 ////////////////////////////////////////////////////////////////////////////////
77 /// Convert map by label to map by index for more efficient internal use
78 
80  RooAbsDataStore(other,newname), _indexCat(other._indexCat), _curStore(other._curStore), _curIndex(other._curIndex), _ownComps(kTRUE)
81 {
82  for (map<Int_t,RooAbsDataStore*>::const_iterator iter=other._dataMap.begin() ; iter!=other._dataMap.end() ; ++iter) {
83  RooAbsDataStore* clonedata = iter->second->clone() ;
84  _dataMap[iter->first] = clonedata ;
85  }
87 }
88 
89 
90 ////////////////////////////////////////////////////////////////////////////////
91 /// Update index category pointer, if it is contained in input argument vars
92 
93 RooCompositeDataStore::RooCompositeDataStore(const RooCompositeDataStore& other, const RooArgSet& vars, const char* newname) :
94  RooAbsDataStore(other,vars,newname), _indexCat(other._indexCat), _curStore(other._curStore), _curIndex(other._curIndex), _ownComps(kTRUE)
95 {
96  RooCategory* newIdx = (RooCategory*) vars.find(other._indexCat->GetName()) ;
97  if (newIdx) {
98  _indexCat = newIdx ;
99  }
100 
101  // Convert map by label to map by index for more efficient internal use
102  for (map<Int_t,RooAbsDataStore*>::const_iterator iter=other._dataMap.begin() ; iter!=other._dataMap.end() ; ++iter) {
103  RooAbsDataStore* clonedata = iter->second->clone(vars) ;
104  _dataMap[iter->first] = clonedata ;
105  }
107 }
108 
109 
110 
111 
112 ////////////////////////////////////////////////////////////////////////////////
113 /// Destructor
114 
116 {
117  if (_ownComps) {
118  map<int,RooAbsDataStore*>::const_iterator iter ;
119  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
120  delete iter->second ;
121  }
122  }
124 }
125 
126 
127 ////////////////////////////////////////////////////////////////////////////////
128 /// Return true if currently loaded coordinate is considered valid within
129 /// the current range definitions of all observables
130 
132 {
133  return kTRUE ;
134 }
135 
136 
137 
138 
139 ////////////////////////////////////////////////////////////////////////////////
140 /// Forward recalculate request to all subsets
141 
142 void RooCompositeDataStore::recalculateCache(const RooArgSet* proj, Int_t firstEvent, Int_t lastEvent, Int_t stepSize, Bool_t skipZeroWeights)
143 {
144  map<int,RooAbsDataStore*>::const_iterator iter ;
145  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
146  iter->second->recalculateCache(proj,firstEvent,lastEvent,stepSize,skipZeroWeights) ;
147  }
148 }
149 
150 
151 ////////////////////////////////////////////////////////////////////////////////
152 
154 {
155  Bool_t ret(kFALSE) ;
156  map<int,RooAbsDataStore*>::const_iterator iter ;
157  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
158  ret |= iter->second->hasFilledCache() ;
159  }
160  return ret ;
161 }
162 
163 
164 ////////////////////////////////////////////////////////////////////////////////
165 
167 {
168  map<int,RooAbsDataStore*>::const_iterator iter ;
169  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
170  iter->second->forceCacheUpdate() ;
171  }
172 }
173 
174 
175 
176 ////////////////////////////////////////////////////////////////////////////////
177 /// Forward fill request to appropriate subset
178 
180 {
182  const_cast<RooArgSet*>((subset->get()))->assignValueOnly(_vars) ;
183  return subset->fill() ;
184 }
185 
186 
187 
188 ////////////////////////////////////////////////////////////////////////////////
189 /// Forward fill request to appropriate subset
190 
192 {
193  Double_t sum(0) ;
194 
195  map<int,RooAbsDataStore*>::const_iterator iter ;
196  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
197  sum+= iter->second->sumEntries() ;
198  }
199  return sum ;
200 }
201 
202 
203 
204 ////////////////////////////////////////////////////////////////////////////////
205 /// Load the n-th data point (n='idx') in memory
206 /// and return a pointer to the internal RooArgSet
207 /// holding its coordinates.
208 
210 {
211  Int_t offset(0) ;
212  map<int,RooAbsDataStore*>::const_iterator iter ;
213  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
214  if (idx>=(offset+iter->second->numEntries())) {
215  offset += iter->second->numEntries() ;
216  continue ;
217  }
218  const_cast<RooCompositeDataStore*>(this)->_vars = (*iter->second->get(idx-offset)) ;
219 
220  _indexCat->setIndex(iter->first) ;
221  _curStore = iter->second ;
222  _curIndex = idx-offset ;
223 
224  return &_vars ;
225  }
226  return 0 ;
227 }
228 
229 
230 
231 ////////////////////////////////////////////////////////////////////////////////
232 
234 {
235  if (!_curStore) get(0) ;
236  // coverity[FORWARD_NULL]
237  return _curStore->weight(_curIndex) ;
238 }
239 
240 
241 
242 
243 
244 ////////////////////////////////////////////////////////////////////////////////
245 
247 {
248  get(idx) ;
249  return weight() ;
250 }
251 
252 
253 
254 
255 ////////////////////////////////////////////////////////////////////////////////
256 
258 {
259  if (!_curStore) get(0) ;
260  // coverity[FORWARD_NULL]
261  return _curStore->weightError(etype) ;
262 }
263 
264 
265 
266 
267 ////////////////////////////////////////////////////////////////////////////////
268 
270 {
271  if (!_curStore) get(0) ;
272  // coverity[FORWARD_NULL]
273  return _curStore->weightError(lo,hi,etype) ;
274 }
275 
276 
277 
278 
279 ////////////////////////////////////////////////////////////////////////////////
280 
282 {
283  map<int,RooAbsDataStore*>::const_iterator iter ;
284  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
285  if (iter->second->isWeighted()) return kTRUE ;
286  }
287  return kFALSE ; ;
288 }
289 
290 
291 ////////////////////////////////////////////////////////////////////////////////
292 
293 void RooCompositeDataStore::loadValues(const RooAbsDataStore*, const RooFormulaVar*, const char*, std::size_t, std::size_t)
294 {
295  throw(std::runtime_error("RooCompositeDataSore::loadValues() NOT IMPLEMENTED")) ;
296 }
297 
298 
299 
300 ////////////////////////////////////////////////////////////////////////////////
301 /// Change name of internal observable named 'from' into 'to'
302 
303 Bool_t RooCompositeDataStore::changeObservableName(const char* from, const char* to)
304 {
305 
306  // Find observable to be changed
307  RooAbsArg* var = _vars.find(from) ;
308 
309  // Check that we found it
310  if (!var) {
311  coutE(InputArguments) << "RooCompositeDataStore::changeObservableName(" << GetName() << " no observable " << from << " in this dataset" << endl ;
312  return kTRUE ;
313  }
314 
315  // Process name change
316  var->SetName(to) ;
317 
318  // Forward name change request to component datasets
319  Bool_t ret(kFALSE) ;
320  map<int,RooAbsDataStore*>::const_iterator iter ;
321  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
322  ret |= iter->second->changeObservableName(from,to) ;
323  }
324 
325  return ret ;
326 }
327 
328 
329 
330 ////////////////////////////////////////////////////////////////////////////////
331 /// WVE ownership issue here!! Caller (a RooAbsData) should take ownership of all
332 /// arguments, but only does for the first one here...
333 
335 {
336  RooAbsArg* ret(0) ;
337  map<int,RooAbsDataStore*>::const_iterator iter ;
338  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
339  ret = iter->second->addColumn(newVar,adjustRange) ;
340  }
341  if (ret) {
342  _vars.add(*ret) ;
343  }
344  return ret ;
345 }
346 
347 
348 
349 ////////////////////////////////////////////////////////////////////////////////
350 /// WVE ownership issue here!! Caller (a RooAbsData) should take ownership of all
351 /// arguments, but only does for the first one here...
352 
354 {
355  RooArgSet* ret(0) ;
356  map<int,RooAbsDataStore*>::const_iterator iter ;
357  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
358  ret = iter->second->addColumns(varList) ;
359  }
360  if (ret) {
361  _vars.add(*ret) ;
362  }
363  return ret ;
364 }
365 
366 
367 
368 
369 ////////////////////////////////////////////////////////////////////////////////
370 
371 RooAbsDataStore* RooCompositeDataStore::merge(const RooArgSet& /*allVars*/, list<RooAbsDataStore*> /*dstoreList*/)
372 {
373  throw string("RooCompositeDataStore::merge() is not implemented yet") ;
374 }
375 
376 
377 
378 
379 
380 ////////////////////////////////////////////////////////////////////////////////
381 
383 {
384  Int_t nevt = other.numEntries() ;
385  for (int i=0 ; i<nevt ; i++) {
386  _vars = *other.get(i) ;
387  fill() ;
388  }
389 }
390 
391 
392 
393 ////////////////////////////////////////////////////////////////////////////////
394 
396 {
397  Int_t n(0) ;
398  map<int,RooAbsDataStore*>::const_iterator iter ;
399  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
400  n += iter->second->numEntries() ;
401  }
402  return n ;
403 }
404 
405 
406 
407 
408 ////////////////////////////////////////////////////////////////////////////////
409 
411 {
412  map<int,RooAbsDataStore*>::const_iterator iter ;
413  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
414  iter->second->reset() ;
415  }
416 }
417 
418 
419 
420 ////////////////////////////////////////////////////////////////////////////////
421 
422 void RooCompositeDataStore::cacheArgs(const RooAbsArg* owner, RooArgSet& newVarSet, const RooArgSet* nset, Bool_t skipZeroWeights)
423 {
424  map<int,RooAbsDataStore*>::const_iterator iter ;
425  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
426  iter->second->cacheArgs(owner,newVarSet,nset,skipZeroWeights) ;
427  }
428 }
429 
430 
431 
432 ////////////////////////////////////////////////////////////////////////////////
433 
435 {
436  map<int,RooAbsDataStore*>::const_iterator iter ;
437  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
438  RooArgSet* subset = (RooArgSet*) set.selectCommon(*iter->second->get()) ;
439  iter->second->setArgStatus(*subset,active) ;
440  delete subset ;
441  }
442  return ;
443 }
444 
445 
446 
447 ////////////////////////////////////////////////////////////////////////////////
448 /// Initialize cache of dataset: attach variables of cache ArgSet
449 /// to the corresponding TTree branches
450 
451 void RooCompositeDataStore::attachCache(const RooAbsArg* newOwner, const RooArgSet& inCachedVars)
452 {
453  map<int,RooAbsDataStore*>::const_iterator iter ;
454  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
455  iter->second->attachCache(newOwner,inCachedVars) ;
456  }
457  return ;
458 }
459 
460 
461 
462 ////////////////////////////////////////////////////////////////////////////////
463 
465 {
466  map<int,RooAbsDataStore*>::const_iterator iter ;
467  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
468  iter->second->resetCache() ;
469  }
470  return ;
471 }
472 
473 
474 
475 ////////////////////////////////////////////////////////////////////////////////
476 
478 {
479  map<int,RooAbsDataStore*>::const_iterator iter ;
480  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
481  iter->second->attachBuffers(extObs);
482  }
483  return ;
484 }
485 
486 
487 
488 ////////////////////////////////////////////////////////////////////////////////
489 
491 {
492  map<int,RooAbsDataStore*>::const_iterator iter ;
493  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
494  iter->second->resetBuffers();
495  }
496  return ;
497 }
498 
499 
500 ////////////////////////////////////////////////////////////////////////////////
501 
503 {
504  cout << "RooCompositeDataStore::dump()" << endl ;
505  map<int,RooAbsDataStore*>::const_iterator iter ;
506  for (iter = _dataMap.begin() ; iter!=_dataMap.end() ; ++iter) {
507  cout << "state number " << iter->first << " has store " << iter->second->IsA()->GetName() << " with variables " << *iter->second->get() ;
508  if (iter->second->isWeighted()) cout << " and is weighted " ;
509  cout << endl ;
510  }
511 }
512 
513 
RooFormulaVar.h
RooCompositeDataStore::~RooCompositeDataStore
virtual ~RooCompositeDataStore()
Destructor.
Definition: RooCompositeDataStore.cxx:115
n
const Int_t n
Definition: legend1.C:16
RooAbsDataStore::weightError
virtual Double_t weightError(RooAbsData::ErrorType etype=RooAbsData::Poisson) const =0
RooCompositeDataStore::attachBuffers
virtual void attachBuffers(const RooArgSet &extObs)
Definition: RooCompositeDataStore.cxx:477
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
RooCompositeDataStore::sumEntries
virtual Double_t sumEntries() const
Forward fill request to appropriate subset.
Definition: RooCompositeDataStore.cxx:191
RooCompositeDataStore::_curIndex
Int_t _curIndex
Datastore associated with current event.
Definition: RooCompositeDataStore.h:119
RooAbsDataStore::get
virtual const RooArgSet * get() const
Definition: RooAbsDataStore.h:47
RooMsgService.h
RooCompositeDataStore::fill
virtual Int_t fill()
Forward fill request to appropriate subset.
Definition: RooCompositeDataStore.cxx:179
RooCompositeDataStore::recalculateCache
virtual void recalculateCache(const RooArgSet *, Int_t, Int_t, Int_t, Bool_t)
Forward recalculate request to all subsets.
Definition: RooCompositeDataStore.cxx:142
RooCompositeDataStore::RooCompositeDataStore
RooCompositeDataStore()
Definition: RooCompositeDataStore.cxx:53
RooFit.h
RooFit::InputArguments
@ InputArguments
Definition: RooGlobalFunc.h:68
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
RooAbsCollection::assignValueOnly
RooAbsCollection & assignValueOnly(const RooAbsCollection &other, Bool_t oneSafe=kFALSE)
The assignment operator sets the value of any argument in our set that also appears in the other set.
Definition: RooAbsCollection.cxx:330
coutE
#define coutE(a)
Definition: RooMsgService.h:33
RooArgList
Definition: RooArgList.h:21
RooAbsArg::SetName
void SetName(const char *name)
Set the name of the TNamed.
Definition: RooAbsArg.cxx:2218
RooAbsCollection::find
RooAbsArg * find(const char *name) const
Find object with given name in list.
Definition: RooAbsCollection.cxx:813
RooCategory::setIndex
virtual Bool_t setIndex(Int_t index, bool printError=true) override
Set value by specifying the index code of the desired state.
Definition: RooCategory.cxx:163
RooAbsDataStore::clone
virtual RooAbsDataStore * clone(const char *newname=0) const =0
RooCompositeDataStore::_ownComps
Bool_t _ownComps
Index associated with current event.
Definition: RooCompositeDataStore.h:120
RooArgSet::add
virtual Bool_t add(const RooAbsCollection &col, Bool_t silent=kFALSE)
Add a collection of arguments to this collection by calling add() for each element in the source coll...
Definition: RooArgSet.h:88
RooCompositeDataStore::dump
virtual void dump()
Definition: RooCompositeDataStore.cxx:502
RooCompositeDataStore::weight
virtual Double_t weight() const
Definition: RooCompositeDataStore.cxx:233
TTree.h
RooCompositeDataStore::setArgStatus
virtual void setArgStatus(const RooArgSet &set, Bool_t active)
Definition: RooCompositeDataStore.cxx:434
RooAbsData::ErrorType
ErrorType
Definition: RooAbsData.h:96
RooCompositeDataStore::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())
Definition: RooCompositeDataStore.cxx:293
bool
RooCompositeDataStore::hasFilledCache
virtual Bool_t hasFilledCache() const
Definition: RooCompositeDataStore.cxx:153
RooCompositeDataStore::resetCache
virtual void resetCache()
Definition: RooCompositeDataStore.cxx:464
RooCompositeDataStore
Definition: RooCompositeDataStore.h:33
RooCompositeDataStore::numEntries
virtual Int_t numEntries() const
Definition: RooCompositeDataStore.cxx:395
RooTrace.h
hi
float type_of_call hi(const int &, const int &)
TChain.h
RooFormulaVar
Definition: RooFormulaVar.h:30
TRACE_DESTROY
#define TRACE_DESTROY
Definition: RooTrace.h:24
RooCompositeDataStore::_dataMap
std::map< Int_t, RooAbsDataStore * > _dataMap
Definition: RooCompositeDataStore.h:116
RooCompositeDataStore::forceCacheUpdate
virtual void forceCacheUpdate()
Definition: RooCompositeDataStore.cxx:166
RooCompositeDataStore::resetBuffers
virtual void resetBuffers()
Definition: RooCompositeDataStore.cxx:490
RooAbsDataStore::_vars
RooArgSet _vars
Definition: RooAbsDataStore.h:122
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:92
RooAbsCollection::selectCommon
RooAbsCollection * selectCommon(const RooAbsCollection &refColl) const
Create a subset of the current collection, consisting only of those elements that are contained as we...
Definition: RooAbsCollection.cxx:700
RooCompositeDataStore::addColumns
virtual RooArgSet * addColumns(const RooArgList &varList)
WVE ownership issue here!! Caller (a RooAbsData) should take ownership of all arguments,...
Definition: RooCompositeDataStore.cxx:353
TRACE_CREATE
#define TRACE_CREATE
Definition: RooTrace.h:23
RooCompositeDataStore::weightError
virtual Double_t weightError(RooAbsData::ErrorType etype=RooAbsData::Poisson) const
Definition: RooCompositeDataStore.cxx:257
RooCategory.h
RooRealVar.h
RooAbsDataStore::get
virtual const RooArgSet * get(Int_t index) const =0
RooCompositeDataStore::append
virtual void append(RooAbsDataStore &other)
Definition: RooCompositeDataStore.cxx:382
RooAbsDataStore::weight
virtual Double_t weight() const =0
RooAbsDataStore::numEntries
virtual Int_t numEntries() const =0
sum
static long int sum(long int i)
Definition: Factory.cxx:2272
RooCompositeDataStore::addColumn
virtual RooAbsArg * addColumn(RooAbsArg &var, Bool_t adjustRange=kTRUE)
WVE ownership issue here!! Caller (a RooAbsData) should take ownership of all arguments,...
Definition: RooCompositeDataStore.cxx:334
Double_t
double Double_t
Definition: RtypesCore.h:59
RooCompositeDataStore::cacheArgs
virtual void cacheArgs(const RooAbsArg *owner, RooArgSet &varSet, const RooArgSet *nset=0, Bool_t skipZeroWeights=kFALSE)
Definition: RooCompositeDataStore.cxx:422
RooCategory
Definition: RooCategory.h:27
RooCompositeDataStore::_indexCat
RooCategory * _indexCat
Definition: RooCompositeDataStore.h:117
RooAbsCategory::lookupIndex
value_type lookupIndex(const std::string &stateName) const
Find the index number corresponding to the state name.
Definition: RooAbsCategory.cxx:283
name
char name[80]
Definition: TGX11.cxx:110
RooCompositeDataStore::_curStore
RooAbsDataStore * _curStore
Definition: RooCompositeDataStore.h:118
RooAbsArg
Definition: RooAbsArg.h:73
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:53
RooCompositeDataStore::changeObservableName
virtual Bool_t changeObservableName(const char *from, const char *to)
Change name of internal observable named 'from' into 'to'.
Definition: RooCompositeDataStore.cxx:303
RooCompositeDataStore::isWeighted
virtual Bool_t isWeighted() const
Definition: RooCompositeDataStore.cxx:281
RooAbsDataStore
Definition: RooAbsDataStore.h:31
RooAbsDataStore::fill
virtual Int_t fill()=0
RooCompositeDataStore::reset
virtual void reset()
Definition: RooCompositeDataStore.cxx:410
RooCategory::getCurrentIndex
virtual value_type getCurrentIndex() const override final
Return current index.
Definition: RooCategory.h:39
RooCompositeDataStore::valid
virtual Bool_t valid() const
Return true if currently loaded coordinate is considered valid within the current range definitions o...
Definition: RooCompositeDataStore.cxx:131
RooCompositeDataStore::merge
RooAbsDataStore * merge(const RooArgSet &allvars, std::list< RooAbsDataStore * > dstoreList)
Definition: RooCompositeDataStore.cxx:371
RooCompositeDataStore.h
RooCompositeDataStore::attachCache
void attachCache(const RooAbsArg *newOwner, const RooArgSet &cachedVars)
Initialize cache of dataset: attach variables of cache ArgSet to the corresponding TTree branches.
Definition: RooCompositeDataStore.cxx:451
RooArgSet
Definition: RooArgSet.h:28
int