Logo ROOT  
Reference Guide
RooDataSet.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 RooDataSet.cxx
19\class RooDataSet
20\ingroup Roofitcore
21
22RooDataSet is a container class to hold unbinned data. The binned equivalent is
23RooDataHist. In RooDataSet, each data point in N-dimensional space is represented
24by a RooArgSet of RooRealVar, RooCategory or RooStringVar objects, which can be
25retrieved using get().
26
27Since RooDataSet saves every event, it allows for fits with highest precision. With a large
28amount of data, however, it could be beneficial to represent them in binned form,
29i.e., RooDataHist. Binning the data will incur a loss of information, though.
30RooDataHist on the other hand may suffer from the curse of dimensionality if a high-dimensional
31problem with a lot of bins on each axis is tackled.
32
33### Inspecting a dataset
34Inspect a dataset using Print() with the "verbose" option:
35```
36dataset->Print("V");
37dataset->get(0)->Print("V");
38dataset->get(1)->Print("V");
39...
40```
41
42### Plotting data.
43See RooAbsData::plotOn().
44
45
46### Storage strategy
47There are two storage backends:
48- RooVectorDataStore (default): std::vectors in memory. They are fast, but they
49cannot be serialised if the dataset exceeds a size of 1 Gb
50- RooTreeDataStore: Uses a TTree, which can be file backed if a file is opened
51before creating the dataset. This significantly reduces the memory pressure, as the
52baskets of the tree can be written to a file, and only the basket that's currently
53being read stays in RAM.
54 - Enable tree-backed storage similar to this:
55 ```
56 TFile outputFile("filename.root", "RECREATE");
57 RooAbsData::setDefaultStorageType(RooAbsData::Tree);
58 RooDataSet mydata(...);
59 ```
60 - Or convert an existing memory-backed data storage:
61 ```
62 RooDataSet mydata(...);
63
64 TFile outputFile("filename.root", "RECREATE");
65 mydata.convertToTreeStore();
66 ```
67
68For the inverse conversion, see `RooAbsData::convertToVectorStore()`.
69
70
71### Creating a dataset using RDataFrame
72\see RooAbsDataHelper, rf408_RDataFrameToRooFit.C
73
74**/
75
76#include "RooDataSet.h"
77
78#include "RooPlot.h"
79#include "RooAbsReal.h"
80#include "Roo1DTable.h"
81#include "RooCategory.h"
82#include "RooFormulaVar.h"
83#include "RooArgList.h"
84#include "RooAbsRealLValue.h"
85#include "RooRealVar.h"
86#include "RooDataHist.h"
87#include "RooMsgService.h"
88#include "RooCmdConfig.h"
89#include "RooHist.h"
90#include "RooTreeDataStore.h"
91#include "RooVectorDataStore.h"
93#include "RooSentinel.h"
94#include "RooTrace.h"
95#include "RooHelpers.h"
96
97#include "Math/Util.h"
98#include "TTree.h"
99#include "TH2.h"
100#include "TFile.h"
101#include "TBuffer.h"
102#include "strlcpy.h"
103#include "snprintf.h"
104
105#include <iostream>
106#include <memory>
107#include <fstream>
108
109
110using namespace std;
111
113
114#ifndef USEMEMPOOLFORDATASET
116#else
117
118#include "MemPoolForRooSets.h"
119
122 static auto * memPool = new RooDataSet::MemPool();
123 return memPool;
124}
125
126void RooDataSet::cleanup() {
127 auto pool = memPool();
128 pool->teardown();
129
130 //The pool will have to leak if it's not empty at this point.
131 if (pool->empty())
132 delete pool;
133}
134
135
136////////////////////////////////////////////////////////////////////////////////
137/// Overloaded new operator guarantees that all RooDataSets allocated with new
138/// have a unique address, a property that is exploited in several places
139/// in roofit to quickly index contents on normalization set pointers.
140/// The memory pool only allocates space for the class itself. The elements
141/// stored in the set are stored outside the pool.
142
143void* RooDataSet::operator new (size_t bytes)
144{
145 //This will fail if a derived class uses this operator
146 assert(sizeof(RooDataSet) == bytes);
147
148 return memPool()->allocate(bytes);
149}
150
151
152
153////////////////////////////////////////////////////////////////////////////////
154/// Memory is owned by pool, we need to do nothing to release it
155
156void RooDataSet::operator delete (void* ptr)
157{
158 // Decrease use count in pool that ptr is on
159 if (memPool()->deallocate(ptr))
160 return;
161
162 std::cerr << __func__ << " " << ptr << " is not in any of the pools." << std::endl;
163
164 // Not part of any pool; use global op delete:
165 ::operator delete(ptr);
166}
167
168#endif
169
170
171////////////////////////////////////////////////////////////////////////////////
172/// Default constructor for persistence
173
175{
177}
178
179
180
181
182
183////////////////////////////////////////////////////////////////////////////////
184/// Construct an unbinned dataset from a RooArgSet defining the dimensions of the data space. Optionally, data
185/// can be imported at the time of construction.
186///
187/// <table>
188/// <tr><th> %RooCmdArg <th> Effect
189/// <tr><td> Import(TTree*) <td> Import contents of given TTree. Only braches of the TTree that have names
190/// corresponding to those of the RooAbsArgs that define the RooDataSet are
191/// imported.
192/// <tr><td> ImportFromFile(const char* fileName, const char* treeName) <td> Import tree with given name from file with given name.
193/// <tr><td> Import(RooDataSet&)
194/// <td> Import contents of given RooDataSet. Only observables that are common with the definition of this dataset will be imported
195/// <tr><td> Index(RooCategory&) <td> Prepare import of datasets into a N+1 dimensional RooDataSet
196/// where the extra discrete dimension labels the source of the imported histogram.
197/// <tr><td> Import(const char*, RooDataSet&)
198/// <td> Import a dataset to be associated with the given state name of the index category
199/// specified in Index(). If the given state name is not yet defined in the index
200/// category it will be added on the fly. The import command can be specified multiple times.
201/// <tr><td> Link(const char*, RooDataSet&) <td> Link contents of supplied RooDataSet to this dataset for given index category state name.
202/// In this mode, no data is copied and the linked dataset must be remain live for the duration
203/// of this dataset. Note that link is active for both reading and writing, so modifications
204/// to the aggregate dataset will also modify its components. Link() and Import() are mutually exclusive.
205/// <tr><td> OwnLinked() <td> Take ownership of all linked datasets
206/// <tr><td> Import(map<string,RooDataSet*>&) <td> As above, but allows specification of many imports in a single operation
207/// <tr><td> Link(map<string,RooDataSet*>&) <td> As above, but allows specification of many links in a single operation
208/// <tr><td> Cut(const char*) <br>
209/// Cut(RooFormulaVar&)
210/// <td> Apply the given cut specification when importing data
211/// <tr><td> CutRange(const char*) <td> Only accept events in the observable range with the given name
212/// <tr><td> WeightVar(const char*) <br>
213/// WeightVar(const RooAbsArg&)
214/// <td> Interpret the given variable as event weight rather than as observable
215/// <tr><td> StoreError(const RooArgSet&) <td> Store symmetric error along with value for given subset of observables
216/// <tr><td> StoreAsymError(const RooArgSet&) <td> Store asymmetric error along with value for given subset of observables
217/// </table>
218///
219
220RooDataSet::RooDataSet(std::string_view name, std::string_view title, const RooArgSet& vars, const RooCmdArg& arg1, const RooCmdArg& arg2, const RooCmdArg& arg3,
221 const RooCmdArg& arg4,const RooCmdArg& arg5,const RooCmdArg& arg6,const RooCmdArg& arg7,const RooCmdArg& arg8) :
222 RooAbsData(name,title,RooArgSet(vars,(RooAbsArg*)RooCmdConfig::decodeObjOnTheFly("RooDataSet::RooDataSet", "IndexCat",0,0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8)))
223{
224 // Define configuration for this method
225 RooCmdConfig pc(Form("RooDataSet::ctor(%s)",GetName())) ;
226 pc.defineInt("ownLinked","OwnLinked",0) ;
227 pc.defineObject("impTree","ImportTree",0) ;
228 pc.defineObject("impData","ImportData",0) ;
229 pc.defineObject("indexCat","IndexCat",0) ;
230 pc.defineObject("impSliceData","ImportDataSlice",0,0,kTRUE) ; // array
231 pc.defineString("impSliceState","ImportDataSlice",0,"",kTRUE) ; // array
232 pc.defineObject("lnkSliceData","LinkDataSlice",0,0,kTRUE) ; // array
233 pc.defineString("lnkSliceState","LinkDataSlice",0,"",kTRUE) ; // array
234 pc.defineString("cutSpec","CutSpec",0,"") ;
235 pc.defineObject("cutVar","CutVar",0) ;
236 pc.defineString("cutRange","CutRange",0,"") ;
237 pc.defineString("wgtVarName","WeightVarName",0,"") ;
238 pc.defineInt("newWeight1","WeightVarName",0,0) ;
239 pc.defineString("fname","ImportFromFile",0,"") ;
240 pc.defineString("tname","ImportFromFile",1,"") ;
241 pc.defineObject("wgtVar","WeightVar",0) ;
242 pc.defineInt("newWeight2","WeightVar",0,0) ;
243 pc.defineObject("dummy1","ImportDataSliceMany",0) ;
244 pc.defineObject("dummy2","LinkDataSliceMany",0) ;
245 pc.defineSet("errorSet","StoreError",0) ;
246 pc.defineSet("asymErrSet","StoreAsymError",0) ;
247 pc.defineMutex("ImportTree","ImportData","ImportDataSlice","LinkDataSlice","ImportFromFile") ;
248 pc.defineMutex("CutSpec","CutVar") ;
249 pc.defineMutex("WeightVarName","WeightVar") ;
250 pc.defineDependency("ImportDataSlice","IndexCat") ;
251 pc.defineDependency("LinkDataSlice","IndexCat") ;
252 pc.defineDependency("OwnLinked","LinkDataSlice") ;
253
254
256 l.Add((TObject*)&arg1) ; l.Add((TObject*)&arg2) ;
257 l.Add((TObject*)&arg3) ; l.Add((TObject*)&arg4) ;
258 l.Add((TObject*)&arg5) ; l.Add((TObject*)&arg6) ;
259 l.Add((TObject*)&arg7) ; l.Add((TObject*)&arg8) ;
260
261 // Process & check varargs
262 pc.process(l) ;
263 if (!pc.ok(kTRUE)) {
264 assert(0) ;
265 return ;
266 }
267
268 // Extract relevant objects
269 TTree* impTree = static_cast<TTree*>(pc.getObject("impTree")) ;
270 RooDataSet* impData = static_cast<RooDataSet*>(pc.getObject("impData")) ;
271 RooFormulaVar* cutVar = static_cast<RooFormulaVar*>(pc.getObject("cutVar")) ;
272 const char* cutSpec = pc.getString("cutSpec","",kTRUE) ;
273 const char* cutRange = pc.getString("cutRange","",kTRUE) ;
274 const char* wgtVarName = pc.getString("wgtVarName","",kTRUE) ;
275 RooRealVar* wgtVar = static_cast<RooRealVar*>(pc.getObject("wgtVar")) ;
276 const char* impSliceNames = pc.getString("impSliceState","",kTRUE) ;
277 const RooLinkedList& impSliceData = pc.getObjectList("impSliceData") ;
278 const char* lnkSliceNames = pc.getString("lnkSliceState","",kTRUE) ;
279 const RooLinkedList& lnkSliceData = pc.getObjectList("lnkSliceData") ;
280 RooCategory* indexCat = static_cast<RooCategory*>(pc.getObject("indexCat")) ;
281 RooArgSet* errorSet = pc.getSet("errorSet") ;
282 RooArgSet* asymErrorSet = pc.getSet("asymErrSet") ;
283 const char* fname = pc.getString("fname") ;
284 const char* tname = pc.getString("tname") ;
285 Int_t ownLinked = pc.getInt("ownLinked") ;
286 Int_t newWeight = pc.getInt("newWeight1") + pc.getInt("newWeight2") ;
287
288 // Case 1 --- Link multiple dataset as slices
289 if (lnkSliceNames) {
290
291 // Make import mapping if index category is specified
292 map<string,RooAbsData*> hmap ;
293 if (indexCat) {
294 char tmp[64000];
295 strlcpy(tmp, lnkSliceNames, 64000);
296 char *token = strtok(tmp, ",");
297 TIterator *hiter = lnkSliceData.MakeIterator();
298 while (token) {
299 hmap[token] = (RooAbsData *)hiter->Next();
300 token = strtok(0, ",");
301 }
302 delete hiter ;
303 }
304
305 // Lookup name of weight variable if it was specified by object reference
306 if (wgtVar) {
307 // coverity[UNUSED_VALUE]
308 wgtVarName = wgtVar->GetName() ;
309 }
310
311 appendToDir(this,kTRUE) ;
312
313 // Initialize RooDataSet with optional weight variable
314 initialize(0) ;
315
316 map<string,RooAbsDataStore*> storeMap ;
317 RooCategory* icat = (RooCategory*) (indexCat ? _vars.find(indexCat->GetName()) : 0 ) ;
318 if (!icat) {
319 throw std::string("RooDataSet::RooDataSet() ERROR in constructor, cannot find index category") ;
320 }
321 for (map<string,RooAbsData*>::iterator hiter = hmap.begin() ; hiter!=hmap.end() ; ++hiter) {
322 // Define state labels in index category (both in provided indexCat and in internal copy in dataset)
323 if (indexCat && !indexCat->hasLabel(hiter->first)) {
324 indexCat->defineType(hiter->first) ;
325 coutI(InputArguments) << "RooDataSet::ctor(" << GetName() << ") defining state \"" << hiter->first << "\" in index category " << indexCat->GetName() << endl ;
326 }
327 if (icat && !icat->hasLabel(hiter->first)) {
328 icat->defineType(hiter->first) ;
329 }
330 icat->setLabel(hiter->first.c_str()) ;
331 storeMap[icat->getCurrentLabel()]=hiter->second->store() ;
332
333 // Take ownership of slice if requested
334 if (ownLinked) {
335 addOwnedComponent(hiter->first.c_str(),*hiter->second) ;
336 }
337 }
338
339 // Create composite datastore
340 _dstore = new RooCompositeDataStore(name,title,_vars,*icat,storeMap) ;
341
342 } else {
343
344 if (wgtVar) {
345 wgtVarName = wgtVar->GetName() ;
346 }
347
348 // Clone weight variable of imported dataset if we are not weighted
349 if (!wgtVar && !wgtVarName && impData && impData->_wgtVar) {
352 wgtVarName = _wgtVar->GetName() ;
353 }
354
355 // Create empty datastore
356 RooTreeDataStore* tstore(0) ;
357 RooVectorDataStore* vstore(0) ;
358
360 tstore = new RooTreeDataStore(name,title,_vars,wgtVarName) ;
361 _dstore = tstore ;
362 } else if (defaultStorageType==Vector) {
363 if (wgtVarName && newWeight) {
364 RooAbsArg* wgttmp = _vars.find(wgtVarName) ;
365 if (wgttmp) {
366 wgttmp->setAttribute("NewWeight") ;
367 }
368 }
369 vstore = new RooVectorDataStore(name,title,_vars,wgtVarName) ;
370 _dstore = vstore ;
371 } else {
372 _dstore = 0 ;
373 }
374
375
376 // Make import mapping if index category is specified
377 map<string,RooDataSet*> hmap ;
378 if (indexCat) {
379 TIterator* hiter = impSliceData.MakeIterator() ;
380 for (const auto& token : RooHelpers::tokenise(impSliceNames, ",")) {
381 hmap[token] = (RooDataSet*) hiter->Next() ;
382 }
383 delete hiter ;
384 }
385
386 // process StoreError requests
387 if (errorSet) {
388 RooArgSet* intErrorSet = (RooArgSet*) _vars.selectCommon(*errorSet) ;
389 intErrorSet->setAttribAll("StoreError") ;
390 TIterator* iter = intErrorSet->createIterator() ;
391 RooAbsArg* arg ;
392 while((arg=(RooAbsArg*)iter->Next())) {
393 arg->attachToStore(*_dstore) ;
394 }
395 delete iter ;
396 delete intErrorSet ;
397 }
398 if (asymErrorSet) {
399 RooArgSet* intAsymErrorSet = (RooArgSet*) _vars.selectCommon(*asymErrorSet) ;
400 intAsymErrorSet->setAttribAll("StoreAsymError") ;
401 TIterator* iter = intAsymErrorSet->createIterator() ;
402 RooAbsArg* arg ;
403 while((arg=(RooAbsArg*)iter->Next())) {
404 arg->attachToStore(*_dstore) ;
405 }
406 delete iter ;
407 delete intAsymErrorSet ;
408 }
409
410 // Lookup name of weight variable if it was specified by object reference
411 if (wgtVar) {
412 wgtVarName = wgtVar->GetName() ;
413 }
414
415
416 appendToDir(this,kTRUE) ;
417
418 // Initialize RooDataSet with optional weight variable
419 if (wgtVarName && *wgtVarName) {
420 // Use the supplied weight column
421 initialize(wgtVarName) ;
422
423 } else {
424 if (impData && impData->_wgtVar && vars.find(impData->_wgtVar->GetName())) {
425
426 // Use the weight column of the source data set
427 initialize(impData->_wgtVar->GetName()) ;
428
429 } else if (indexCat) {
430
431 RooDataSet* firstDS = hmap.begin()->second ;
432 if (firstDS->_wgtVar && vars.find(firstDS->_wgtVar->GetName())) {
433 initialize(firstDS->_wgtVar->GetName()) ;
434 } else {
435 initialize(0) ;
436 }
437 } else {
438 initialize(0) ;
439 }
440 }
441
442 // Import one or more datasets with a cut specification
443 if (cutSpec && *cutSpec) {
444
445 // Create a RooFormulaVar cut from given cut expression
446 if (indexCat) {
447
448 // Case 2a --- Import multiple RooDataSets as slices with cutspec
449 RooCategory* icat = (RooCategory*) _vars.find(indexCat->GetName()) ;
450 for (map<string,RooDataSet*>::iterator hiter = hmap.begin() ; hiter!=hmap.end() ; ++hiter) {
451 // Define state labels in index category (both in provided indexCat and in internal copy in dataset)
452 if (!indexCat->hasLabel(hiter->first)) {
453 indexCat->defineType(hiter->first) ;
454 coutI(InputArguments) << "RooDataSet::ctor(" << GetName() << ") defining state \"" << hiter->first << "\" in index category " << indexCat->GetName() << endl ;
455 }
456 if (!icat->hasLabel(hiter->first)) {
457 icat->defineType(hiter->first) ;
458 }
459 icat->setLabel(hiter->first.c_str()) ;
460
461 RooFormulaVar cutVarTmp(cutSpec,cutSpec,hiter->second->_vars) ;
462 _dstore->loadValues(hiter->second->store(),&cutVarTmp,cutRange) ;
463 }
464
465 } else if (impData) {
466
467 // Case 3a --- Import RooDataSet with cutspec
468 RooFormulaVar cutVarTmp(cutSpec,cutSpec,impData->_vars) ;
469 _dstore->loadValues(impData->store(),&cutVarTmp,cutRange);
470 } else if (impTree) {
471
472 // Case 4a --- Import TTree from memory with cutspec
473 RooFormulaVar cutVarTmp(cutSpec,cutSpec,_vars) ;
474 if (tstore) {
475 tstore->loadValues(impTree,&cutVarTmp,cutRange);
476 } else {
477 RooTreeDataStore tmpstore(name,title,_vars,wgtVarName) ;
478 tmpstore.loadValues(impTree,&cutVarTmp,cutRange) ;
479 _dstore->append(tmpstore) ;
480 }
481 } else if (fname && strlen(fname)) {
482
483 // Case 5a --- Import TTree from file with cutspec
484 TFile *f = TFile::Open(fname) ;
485 if (!f) {
486 coutE(InputArguments) << "RooDataSet::ctor(" << GetName() << ") ERROR file '" << fname << "' cannot be opened or does not exist" << endl ;
487 throw string(Form("RooDataSet::ctor(%s) ERROR file %s cannot be opened or does not exist",GetName(),fname)) ;
488 }
489 TTree* t = dynamic_cast<TTree*>(f->Get(tname)) ;
490 if (!t) {
491 coutE(InputArguments) << "RooDataSet::ctor(" << GetName() << ") ERROR file '" << fname << "' does not contain a TTree named '" << tname << "'" << endl ;
492 throw string(Form("RooDataSet::ctor(%s) ERROR file %s does not contain a TTree named %s",GetName(),fname,tname)) ;
493 }
494 RooFormulaVar cutVarTmp(cutSpec,cutSpec,_vars) ;
495 if (tstore) {
496 tstore->loadValues(t,&cutVarTmp,cutRange);
497 } else {
498 RooTreeDataStore tmpstore(name,title,_vars,wgtVarName) ;
499 tmpstore.loadValues(t,&cutVarTmp,cutRange) ;
500 _dstore->append(tmpstore) ;
501 }
502 f->Close() ;
503
504 }
505
506 // Import one or more datasets with a cut formula
507 } else if (cutVar) {
508
509 if (indexCat) {
510
511 // Case 2b --- Import multiple RooDataSets as slices with cutvar
512
513 RooCategory* icat = (RooCategory*) _vars.find(indexCat->GetName()) ;
514 for (map<string,RooDataSet*>::iterator hiter = hmap.begin() ; hiter!=hmap.end() ; ++hiter) {
515 // Define state labels in index category (both in provided indexCat and in internal copy in dataset)
516 if (!indexCat->hasLabel(hiter->first)) {
517 indexCat->defineType(hiter->first) ;
518 coutI(InputArguments) << "RooDataSet::ctor(" << GetName() << ") defining state \"" << hiter->first << "\" in index category " << indexCat->GetName() << endl ;
519 }
520 if (!icat->hasLabel(hiter->first)) {
521 icat->defineType(hiter->first) ;
522 }
523 icat->setLabel(hiter->first.c_str()) ;
524 _dstore->loadValues(hiter->second->store(),cutVar,cutRange) ;
525 }
526
527
528 } else if (impData) {
529 // Case 3b --- Import RooDataSet with cutvar
530 _dstore->loadValues(impData->store(),cutVar,cutRange);
531 } else if (impTree) {
532 // Case 4b --- Import TTree from memory with cutvar
533 if (tstore) {
534 tstore->loadValues(impTree,cutVar,cutRange);
535 } else {
536 RooTreeDataStore tmpstore(name,title,_vars,wgtVarName) ;
537 tmpstore.loadValues(impTree,cutVar,cutRange) ;
538 _dstore->append(tmpstore) ;
539 }
540 } else if (fname && strlen(fname)) {
541 // Case 5b --- Import TTree from file with cutvar
542 TFile *f = TFile::Open(fname) ;
543 if (!f) {
544 coutE(InputArguments) << "RooDataSet::ctor(" << GetName() << ") ERROR file '" << fname << "' cannot be opened or does not exist" << endl ;
545 throw string(Form("RooDataSet::ctor(%s) ERROR file %s cannot be opened or does not exist",GetName(),fname)) ;
546 }
547 TTree* t = dynamic_cast<TTree*>(f->Get(tname)) ;
548 if (!t) {
549 coutE(InputArguments) << "RooDataSet::ctor(" << GetName() << ") ERROR file '" << fname << "' does not contain a TTree named '" << tname << "'" << endl ;
550 throw string(Form("RooDataSet::ctor(%s) ERROR file %s does not contain a TTree named %s",GetName(),fname,tname)) ;
551 }
552 if (tstore) {
553 tstore->loadValues(t,cutVar,cutRange);
554 } else {
555 RooTreeDataStore tmpstore(name,title,_vars,wgtVarName) ;
556 tmpstore.loadValues(t,cutVar,cutRange) ;
557 _dstore->append(tmpstore) ;
558 }
559
560 f->Close() ;
561 }
562
563 // Import one or more datasets without cuts
564 } else {
565
566 if (indexCat) {
567
568 RooCategory* icat = (RooCategory*) _vars.find(indexCat->GetName()) ;
569 for (map<string,RooDataSet*>::iterator hiter = hmap.begin() ; hiter!=hmap.end() ; ++hiter) {
570 // Define state labels in index category (both in provided indexCat and in internal copy in dataset)
571 if (!indexCat->hasLabel(hiter->first)) {
572 indexCat->defineType(hiter->first) ;
573 coutI(InputArguments) << "RooDataSet::ctor(" << GetName() << ") defining state \"" << hiter->first << "\" in index category " << indexCat->GetName() << endl ;
574 }
575 if (!icat->hasLabel(hiter->first)) {
576 icat->defineType(hiter->first) ;
577 }
578 icat->setLabel(hiter->first.c_str()) ;
579 // Case 2c --- Import multiple RooDataSets as slices
580 _dstore->loadValues(hiter->second->store(),0,cutRange) ;
581 }
582
583 } else if (impData) {
584 // Case 3c --- Import RooDataSet
585 _dstore->loadValues(impData->store(),0,cutRange);
586
587 } else if (impTree || (fname && strlen(fname))) {
588 // Case 4c --- Import TTree from memory / file
589 std::unique_ptr<TFile> file;
590
591 if (impTree == nullptr) {
592 file.reset(TFile::Open(fname));
593 if (!file) {
594 coutE(InputArguments) << "RooDataSet::ctor(" << GetName() << ") ERROR file '" << fname << "' cannot be opened or does not exist" << endl ;
595 throw std::invalid_argument(Form("RooDataSet::ctor(%s) ERROR file %s cannot be opened or does not exist",GetName(),fname)) ;
596 }
597
598 file->GetObject(tname, impTree);
599 if (!impTree) {
600 coutE(InputArguments) << "RooDataSet::ctor(" << GetName() << ") ERROR file '" << fname << "' does not contain a TTree named '" << tname << "'" << endl ;
601 throw std::invalid_argument(Form("RooDataSet::ctor(%s) ERROR file %s does not contain a TTree named %s",GetName(),fname,tname)) ;
602 }
603 }
604
605 if (tstore) {
606 tstore->loadValues(impTree,0,cutRange);
607 } else {
608 RooTreeDataStore tmpstore(name,title,_vars,wgtVarName) ;
609 tmpstore.loadValues(impTree,0,cutRange) ;
610 _dstore->append(tmpstore) ;
611 }
612 }
613 }
614
615 }
617}
618
619
620
621////////////////////////////////////////////////////////////////////////////////
622/// Constructor of an empty data set from a RooArgSet defining the dimensions
623/// of the data space.
624
625RooDataSet::RooDataSet(std::string_view name, std::string_view title, const RooArgSet& vars, const char* wgtVarName) :
626 RooAbsData(name,title,vars)
627{
628// cout << "RooDataSet::ctor(" << this << ") storageType = " << ((defaultStorageType==Tree)?"Tree":"Vector") << endl ;
629 _dstore = (defaultStorageType==Tree) ? ((RooAbsDataStore*) new RooTreeDataStore(name,title,_vars,wgtVarName)) :
630 ((RooAbsDataStore*) new RooVectorDataStore(name,title,_vars,wgtVarName)) ;
631
632 appendToDir(this,kTRUE) ;
633 initialize(wgtVarName) ;
635}
636
637
638////////////////////////////////////////////////////////////////////////////////
639/// Constructor of a data set from (part of) an existing data
640/// set. The dimensions of the data set are defined by the 'vars'
641/// RooArgSet, which can be identical to 'dset' dimensions, or a
642/// subset thereof. The 'cuts' string is an optional RooFormula
643/// expression and can be used to select the subset of the data
644/// points in 'dset' to be copied. The cut expression can refer to
645/// any variable in the source dataset. For cuts involving variables
646/// other than those contained in the source data set, such as
647/// intermediate formula objects, use the equivalent constructor
648/// accepting RooFormulaVar reference as cut specification.
649///
650/// This constructor will internally store the data in a TTree.
651///
652/// For most uses the RooAbsData::reduce() wrapper function, which
653/// uses this constructor, is the most convenient way to create a
654/// subset of an existing data
655///
656
658 const RooArgSet& vars, const char *cuts, const char* wgtVarName) :
659 RooAbsData(name,title,vars)
660{
661 // Initialize datastore
662 _dstore = new RooTreeDataStore(name,title,_vars,*dset->_dstore,cuts,wgtVarName) ;
663
664 appendToDir(this,kTRUE) ;
665
666 if (wgtVarName) {
667 // Use the supplied weight column
668 initialize(wgtVarName) ;
669 } else {
670 if (dset->_wgtVar && vars.find(dset->_wgtVar->GetName())) {
671 // Use the weight column of the source data set
672 initialize(dset->_wgtVar->GetName()) ;
673 } else {
674 initialize(0) ;
675 }
676 }
678}
679
680
681////////////////////////////////////////////////////////////////////////////////
682/// Constructor of a data set from (part of) an existing data
683/// set. The dimensions of the data set are defined by the 'vars'
684/// RooArgSet, which can be identical to 'dset' dimensions, or a
685/// subset thereof. The 'cutVar' formula variable is used to select
686/// the subset of data points to be copied. For subsets without
687/// selection on the data points, or involving cuts operating
688/// exclusively and directly on the data set dimensions, the
689/// equivalent constructor with a string based cut expression is
690/// recommended.
691///
692/// This constructor will internally store the data in a TTree.
693///
694/// For most uses the RooAbsData::reduce() wrapper function, which
695/// uses this constructor, is the most convenient way to create a
696/// subset of an existing data
697
699 const RooArgSet& vars, const RooFormulaVar& cutVar, const char* wgtVarName) :
700 RooAbsData(name,title,vars)
701{
702 // Initialize datastore
703 _dstore = new RooTreeDataStore(name,title,_vars,*dset->_dstore,cutVar,wgtVarName) ;
704
705 appendToDir(this,kTRUE) ;
706
707 if (wgtVarName) {
708 // Use the supplied weight column
709 initialize(wgtVarName) ;
710 } else {
711 if (dset->_wgtVar && vars.find(dset->_wgtVar->GetName())) {
712 // Use the weight column of the source data set
713 initialize(dset->_wgtVar->GetName()) ;
714 } else {
715 initialize(0) ;
716 }
717 }
719}
720
721
722
723
724////////////////////////////////////////////////////////////////////////////////
725/// Constructor of a data set from (part of) an ROOT TTRee. The dimensions
726/// of the data set are defined by the 'vars' RooArgSet. For each dimension
727/// specified, the TTree must have a branch with the same name. For category
728/// branches, this branch should contain the numeric index value. Real dimensions
729/// can be constructed from either 'Double_t' or 'Float_t' tree branches. In the
730/// latter case, an automatic conversion is applied.
731///
732/// The 'cutVar' formula variable
733/// is used to select the subset of data points to be copied.
734/// For subsets without selection on the data points, or involving cuts
735/// operating exclusively and directly on the data set dimensions, the equivalent
736/// constructor with a string based cut expression is recommended.
737
739 const RooArgSet& vars, const RooFormulaVar& cutVar, const char* wgtVarName) :
740 RooAbsData(name,title,vars)
741{
742 // Create tree version of datastore
743 RooTreeDataStore* tstore = new RooTreeDataStore(name,title,_vars,*theTree,cutVar,wgtVarName) ;
744
745 // Convert to vector datastore if needed
747 _dstore = tstore ;
748 } else if (defaultStorageType==Vector) {
749 RooVectorDataStore* vstore = new RooVectorDataStore(name,title,_vars,wgtVarName) ;
750 _dstore = vstore ;
751 _dstore->append(*tstore) ;
752 delete tstore ;
753 } else {
754 _dstore = 0 ;
755 }
756
757 appendToDir(this,kTRUE) ;
758 initialize(wgtVarName) ;
760}
761
762
763
764////////////////////////////////////////////////////////////////////////////////
765/// Constructor of a data set from (part of) a ROOT TTree.
766///
767/// \param[in] name Name of this dataset.
768/// \param[in] title Title for e.g. plotting.
769/// \param[in] theTree Tree to be imported.
770/// \param[in] vars Defines the columns of the data set. For each dimension
771/// specified, the TTree must have a branch with the same name. For category
772/// branches, this branch should contain the numeric index value. Real dimensions
773/// can be constructed from either 'Double_t' or 'Float_t' tree branches. In the
774/// latter case, an automatic conversion is applied.
775/// \param[in] cuts Optional RooFormula expression to select the subset of the data points
776/// to be imported. The cut expression can refer to any variable in `vars`.
777/// \warning The expression only evaluates variables that are also in `vars`.
778/// Passing e.g.
779/// ```
780/// RooDataSet("data", "data", tree, RooArgSet(x), "x>y")
781/// ```
782/// Will load `x` from the tree, but leave `y` at an undefined value.
783/// If other expressions are needed, such as intermediate formula objects, use
784/// RooDataSet::RooDataSet(const char*,const char*,TTree*,const RooArgSet&,const RooFormulaVar&,const char*)
785/// \param[in] wgtVarName Name of the variable in `vars` that represents an event weight.
787 const RooArgSet& vars, const char* cuts, const char* wgtVarName) :
788 RooAbsData(name,title,vars)
789{
790 // Create tree version of datastore
791 RooTreeDataStore* tstore = new RooTreeDataStore(name,title,_vars,*theTree,cuts,wgtVarName);
792
793 // Convert to vector datastore if needed
795 _dstore = tstore ;
796 } else if (defaultStorageType==Vector) {
797 RooVectorDataStore* vstore = new RooVectorDataStore(name,title,_vars,wgtVarName) ;
798 _dstore = vstore ;
799 _dstore->append(*tstore) ;
800 delete tstore ;
801 } else {
802 _dstore = 0 ;
803 }
804
805 appendToDir(this,kTRUE) ;
806
807 initialize(wgtVarName) ;
809}
810
811
812
813////////////////////////////////////////////////////////////////////////////////
814/// Copy constructor
815
816RooDataSet::RooDataSet(RooDataSet const & other, const char* newname) :
817 RooAbsData(other,newname), RooDirItem()
818{
819 appendToDir(this,kTRUE) ;
820 initialize(other._wgtVar?other._wgtVar->GetName():0) ;
822}
823
824////////////////////////////////////////////////////////////////////////////////
825/// Protected constructor for internal use only
826
828 const RooArgSet& vars, const RooFormulaVar* cutVar, const char* cutRange,
829 std::size_t nStart, std::size_t nStop, Bool_t copyCache, const char* wgtVarName) :
830 RooAbsData(name,title,vars)
831{
832 if (defaultStorageType == Tree) {
833 _dstore = new RooTreeDataStore(name, title, *dset->_dstore, _vars, cutVar, cutRange, nStart, nStop,
834 copyCache, wgtVarName);
835 } else {
836 _dstore = new RooVectorDataStore(name, title, *dset->_dstore, _vars, cutVar, cutRange, nStart,
837 nStop, copyCache, wgtVarName);
838 }
839
841
842 appendToDir(this, kTRUE);
843 initialize(dset->_wgtVar ? dset->_wgtVar->GetName() : 0);
845}
846
847
848////////////////////////////////////////////////////////////////////////////////
849/// Helper function for constructor that adds optional weight variable to construct
850/// total set of observables
851
852RooArgSet RooDataSet::addWgtVar(const RooArgSet& origVars, const RooAbsArg* wgtVar)
853{
854 RooArgSet tmp(origVars) ;
855 if (wgtVar) tmp.add(*wgtVar) ;
856 return tmp ;
857}
858
859
860
861////////////////////////////////////////////////////////////////////////////////
862/// Return a clone of this dataset containing only the cached variables
863
864RooAbsData* RooDataSet::cacheClone(const RooAbsArg* newCacheOwner, const RooArgSet* newCacheVars, const char* newName)
865{
866 RooDataSet* dset = new RooDataSet(newName?newName:GetName(),GetTitle(),this,_vars,(RooFormulaVar*)0,0,0,2000000000,kTRUE,_wgtVar?_wgtVar->GetName():0) ;
867 //if (_wgtVar) dset->setWeightVar(_wgtVar->GetName()) ;
868
869 RooArgSet* selCacheVars = (RooArgSet*) newCacheVars->selectCommon(dset->_cachedVars) ;
870 dset->attachCache(newCacheOwner, *selCacheVars) ;
871 delete selCacheVars ;
872
873 return dset ;
874}
875
876
877
878////////////////////////////////////////////////////////////////////////////////
879/// Return an empty clone of this dataset. If vars is not null, only the variables in vars
880/// are added to the definition of the empty clone
881
882RooAbsData* RooDataSet::emptyClone(const char* newName, const char* newTitle, const RooArgSet* vars, const char* wgtVarName) const
883{
884 // If variables are given, be sure to include weight variable if it exists and is not included
885 RooArgSet vars2 ;
886 RooRealVar* tmpWgtVar = _wgtVar ;
887 if (wgtVarName && vars && !_wgtVar) {
888 tmpWgtVar = (RooRealVar*) vars->find(wgtVarName) ;
889 }
890
891 if (vars) {
892 vars2.add(*vars) ;
893 if (_wgtVar && !vars2.find(_wgtVar->GetName())) {
894 vars2.add(*_wgtVar) ;
895 }
896 } else {
897 vars2.add(_vars) ;
898 }
899
900 RooDataSet* dset = new RooDataSet(newName?newName:GetName(),newTitle?newTitle:GetTitle(),vars2,tmpWgtVar?tmpWgtVar->GetName():0) ;
901 //if (_wgtVar) dset->setWeightVar(_wgtVar->GetName()) ;
902 return dset ;
903}
904
905
906
907////////////////////////////////////////////////////////////////////////////////
908/// Initialize the dataset. If wgtVarName is not null, interpret the observable
909/// with that name as event weight
910
911void RooDataSet::initialize(const char* wgtVarName)
912{
915 _wgtVar = 0 ;
916 if (wgtVarName) {
917 RooAbsArg* wgt = _varsNoWgt.find(wgtVarName) ;
918 if (!wgt) {
919 coutE(DataHandling) << "RooDataSet::RooDataSet(" << GetName() << "): designated weight variable "
920 << wgtVarName << " not found in set of variables, no weighting will be assigned" << endl ;
921 throw std::invalid_argument("RooDataSet::initialize() weight variable could not be initialised.");
922 } else if (!dynamic_cast<RooRealVar*>(wgt)) {
923 coutE(DataHandling) << "RooDataSet::RooDataSet(" << GetName() << "): designated weight variable "
924 << wgtVarName << " is not of type RooRealVar, no weighting will be assigned" << endl ;
925 throw std::invalid_argument("RooDataSet::initialize() weight variable could not be initialised.");
926 } else {
927 _varsNoWgt.remove(*wgt) ;
928 _wgtVar = (RooRealVar*) wgt ;
929 }
930 }
931}
932
933
934
935////////////////////////////////////////////////////////////////////////////////
936/// Implementation of RooAbsData virtual method that drives the RooAbsData::reduce() methods
937
938RooAbsData* RooDataSet::reduceEng(const RooArgSet& varSubset, const RooFormulaVar* cutVar, const char* cutRange,
939 std::size_t nStart, std::size_t nStop, Bool_t copyCache)
940{
941 checkInit() ;
942
943 //cout << "reduceEng varSubset = " << varSubset << " _wgtVar = " << (_wgtVar ? _wgtVar->GetName() : "") << endl;
944
945 RooArgSet tmp(varSubset) ;
946 if (_wgtVar) {
947 tmp.add(*_wgtVar) ;
948 }
949 RooDataSet* ret = new RooDataSet(GetName(), GetTitle(), this, tmp, cutVar, cutRange, nStart, nStop, copyCache,_wgtVar?_wgtVar->GetName():0) ;
950
951 // WVE - propagate optional weight variable
952 // check behaviour in plotting.
953 // if (_wgtVar) {
954 // ret->setWeightVar(_wgtVar->GetName()) ;
955 // }
956 return ret ;
957}
958
959
960
961////////////////////////////////////////////////////////////////////////////////
962/// Destructor
963
965{
966 removeFromDir(this) ;
968}
969
970
971
972////////////////////////////////////////////////////////////////////////////////
973/// Return binned clone of this dataset
974
975RooDataHist* RooDataSet::binnedClone(const char* newName, const char* newTitle) const
976{
977 std::string title;
978 std::string name;
979 if (newName) {
980 name = newName ;
981 } else {
982 name = std::string(GetName()) + "_binned" ;
983 }
984 if (newTitle) {
985 title = newTitle ;
986 } else {
987 name = std::string(GetTitle()) + "_binned" ;
988 }
989
990 return new RooDataHist(name,title,*get(),*this) ;
991}
992
993
994
995////////////////////////////////////////////////////////////////////////////////
996/// Return event weight of current event
997
999{
1000 return store()->weight() ;
1001}
1002
1003
1004
1005////////////////////////////////////////////////////////////////////////////////
1006/// Return squared event weight of current event
1007
1009{
1010 return store()->weight()*store()->weight() ;
1011}
1012
1013
1014////////////////////////////////////////////////////////////////////////////////
1015/// \see RooAbsData::getWeightBatch().
1016RooSpan<const double> RooDataSet::getWeightBatch(std::size_t first, std::size_t len) const {
1017 return _dstore->getWeightBatch(first, len);
1018}
1019
1020
1021////////////////////////////////////////////////////////////////////////////////
1022/// Write information to retrieve data columns into `evalData.spans`.
1023/// All spans belonging to variables of this dataset are overwritten. Spans to other
1024/// variables remain intact.
1025/// \param[out] evalData Store references to all data batches in this struct's `spans`.
1026/// The key to retrieve an item is the pointer of the variable that owns the data.
1027/// \param first Index of first event that ends up in the batch.
1028/// \param len Number of events in each batch.
1029void RooDataSet::getBatches(RooBatchCompute::RunContext& evalData, std::size_t begin, std::size_t len) const {
1030 for (auto&& batch : store()->getBatches(begin, len).spans) {
1031 evalData.spans[batch.first] = std::move(batch.second);
1032 }
1033}
1034
1035
1036////////////////////////////////////////////////////////////////////////////////
1037/// \copydoc RooAbsData::weightError(double&,double&,RooAbsData::ErrorType) const
1038void RooDataSet::weightError(double& lo, double& hi, ErrorType etype) const
1039{
1040 store()->weightError(lo,hi,etype) ;
1041}
1042
1043
1044////////////////////////////////////////////////////////////////////////////////
1045/// \copydoc RooAbsData::weightError(ErrorType)
1047{
1048 return store()->weightError(etype) ;
1049}
1050
1051
1052////////////////////////////////////////////////////////////////////////////////
1053/// Return RooArgSet with coordinates of event 'index'
1054
1056{
1057 const RooArgSet* ret = RooAbsData::get(index) ;
1058 return ret ? &_varsNoWgt : 0 ;
1059}
1060
1061
1062////////////////////////////////////////////////////////////////////////////////
1063
1065{
1066 return store()->sumEntries() ;
1067}
1068
1069
1070////////////////////////////////////////////////////////////////////////////////
1071/// Return the sum of weights in all entries matching cutSpec (if specified)
1072/// and in named range cutRange (if specified)
1073
1074Double_t RooDataSet::sumEntries(const char* cutSpec, const char* cutRange) const
1075{
1076 // Setup RooFormulaVar for cutSpec if it is present
1077 std::unique_ptr<RooFormula> select = nullptr ;
1078 if (cutSpec && strlen(cutSpec) > 0) {
1079 select = std::make_unique<RooFormula>("select",cutSpec,*get()) ;
1080 }
1081
1082 // Shortcut for unweighted unselected datasets
1083 if (!select && !cutRange && !isWeighted()) {
1084 return numEntries() ;
1085 }
1086
1087 // Otherwise sum the weights in the event
1089 for (int i = 0 ; i<numEntries() ; i++) {
1090 get(i) ;
1091 if (select && select->eval()==0.) continue ;
1092 if (cutRange && !_vars.allInRange(cutRange)) continue ;
1093 sumw += weight();
1094 }
1095
1096 return sumw.Sum() ;
1097}
1098
1099
1100
1101
1102////////////////////////////////////////////////////////////////////////////////
1103/// Return true if dataset contains weighted events
1104
1106{
1107 return store() ? store()->isWeighted() : false;
1108}
1109
1110
1111
1112////////////////////////////////////////////////////////////////////////////////
1113/// Returns true if histogram contains bins with entries with a non-integer weight
1114
1116{
1117 // Return false if we have no weights
1118 if (!_wgtVar) return kFALSE ;
1119
1120 // Now examine individual weights
1121 for (int i=0 ; i<numEntries() ; i++) {
1122 get(i) ;
1123 if (fabs(weight()-Int_t(weight()))>1e-10) return kTRUE ;
1124 }
1125 // If sum of weights is less than number of events there are negative (integer) weights
1126 if (sumEntries()<numEntries()) return kTRUE ;
1127
1128 return kFALSE ;
1129}
1130
1131
1132
1133
1134////////////////////////////////////////////////////////////////////////////////
1135/// Return a RooArgSet with the coordinates of the current event
1136
1138{
1139 return &_varsNoWgt ;
1140}
1141
1142
1143
1144////////////////////////////////////////////////////////////////////////////////
1145/// Add a data point, with its coordinates specified in the 'data' argset, to the data set.
1146/// Any variables present in 'data' but not in the dataset will be silently ignored.
1147/// \param[in] data Data point.
1148/// \param[in] wgt Event weight. Defaults to 1. The current value of the weight variable is
1149/// ignored.
1150/// \note To obtain weighted events, a variable must be designated `WeightVar` in the constructor.
1151/// \param[in] wgtError Optional weight error.
1152/// \note This requires including the weight variable in the set of `StoreError` variables when constructing
1153/// the dataset.
1154
1155void RooDataSet::add(const RooArgSet& data, Double_t wgt, Double_t wgtError)
1156{
1157 checkInit() ;
1158
1159 const double oldW = _wgtVar ? _wgtVar->getVal() : 0.;
1160
1161 _varsNoWgt = data;
1162
1163 if (_wgtVar) {
1164 _wgtVar->setVal(wgt) ;
1165 if (wgtError!=0.) {
1166 _wgtVar->setError(wgtError) ;
1167 }
1168 } else if ((wgt != 1. || wgtError != 0.) && _errorMsgCount < 5) {
1169 ccoutE(DataHandling) << "An event weight/error was passed but no weight variable was defined"
1170 << " in the dataset '" << GetName() << "'. The weight will be ignored." << std::endl;
1172 }
1173
1175 && wgtError != 0.
1176 && fabs(wgt*wgt - wgtError)/wgtError > 1.E-15 //Exception for standard wgt^2 errors, which need not be stored.
1177 && _errorMsgCount < 5 && !_wgtVar->getAttribute("StoreError")) {
1178 coutE(DataHandling) << "An event weight error was passed to the RooDataSet '" << GetName()
1179 << "', but the weight variable '" << _wgtVar->GetName()
1180 << "' does not store errors. Check `StoreError` in the RooDataSet constructor." << std::endl;
1182 }
1183
1184 fill();
1185
1186 // Restore weight state
1187 if (_wgtVar) {
1188 _wgtVar->setVal(oldW);
1190 }
1191}
1192
1193
1194
1195
1196////////////////////////////////////////////////////////////////////////////////
1197/// Add a data point, with its coordinates specified in the 'data' argset, to the data set.
1198/// Any variables present in 'data' but not in the dataset will be silently ignored.
1199/// \param[in] indata Data point.
1200/// \param[in] inweight Event weight. The current value of the weight variable is ignored.
1201/// \note To obtain weighted events, a variable must be designated `WeightVar` in the constructor.
1202/// \param[in] weightErrorLo Asymmetric weight error.
1203/// \param[in] weightErrorHi Asymmetric weight error.
1204/// \note This requires including the weight variable in the set of `StoreAsymError` variables when constructing
1205/// the dataset.
1206
1207void RooDataSet::add(const RooArgSet& indata, Double_t inweight, Double_t weightErrorLo, Double_t weightErrorHi)
1208{
1209 checkInit() ;
1210
1211 const double oldW = _wgtVar ? _wgtVar->getVal() : 0.;
1212
1213 _varsNoWgt = indata;
1214 if (_wgtVar) {
1215 _wgtVar->setVal(inweight) ;
1216 _wgtVar->setAsymError(weightErrorLo,weightErrorHi) ;
1217 } else if (inweight != 1. && _errorMsgCount < 5) {
1218 ccoutE(DataHandling) << "An event weight was given but no weight variable was defined"
1219 << " in the dataset '" << GetName() << "'. The weight will be ignored." << std::endl;
1221 }
1222
1224 && _errorMsgCount < 5 && !_wgtVar->getAttribute("StoreAsymError")) {
1225 coutE(DataHandling) << "An event weight error was passed to the RooDataSet '" << GetName()
1226 << "', but the weight variable '" << _wgtVar->GetName()
1227 << "' does not store errors. Check `StoreAsymError` in the RooDataSet constructor." << std::endl;
1229 }
1230
1231 fill();
1232
1233 // Restore weight state
1234 if (_wgtVar) {
1235 _wgtVar->setVal(oldW);
1237 }
1238}
1239
1240
1241
1242
1243
1244////////////////////////////////////////////////////////////////////////////////
1245/// Add a data point, with its coordinates specified in the 'data' argset, to the data set.
1246/// \attention The order and type of the input variables are **assumed** to be the same as
1247/// for the RooArgSet returned by RooDataSet::get(). Input values will just be written
1248/// into the internal data columns by ordinal position.
1249/// \param[in] data Data point.
1250/// \param[in] wgt Event weight. Defaults to 1. The current value of the weight variable is
1251/// ignored.
1252/// \note To obtain weighted events, a variable must be designated `WeightVar` in the constructor.
1253/// \param[in] wgtError Optional weight error.
1254/// \note This requires including the weight variable in the set of `StoreError` variables when constructing
1255/// the dataset.
1256
1257void RooDataSet::addFast(const RooArgSet& data, Double_t wgt, Double_t wgtError)
1258{
1259 checkInit() ;
1260
1261 const double oldW = _wgtVar ? _wgtVar->getVal() : 0.;
1262
1264 if (_wgtVar) {
1265 _wgtVar->setVal(wgt) ;
1266 if (wgtError!=0.) {
1267 _wgtVar->setError(wgtError) ;
1268 }
1269 } else if (wgt != 1. && _errorMsgCount < 5) {
1270 ccoutE(DataHandling) << "An event weight was given but no weight variable was defined"
1271 << " in the dataset '" << GetName() << "'. The weight will be ignored." << std::endl;
1273 }
1274
1275 fill();
1276
1278 && wgtError != 0. && wgtError != wgt*wgt //Exception for standard weight error, which need not be stored
1279 && _errorMsgCount < 5 && !_wgtVar->getAttribute("StoreError")) {
1280 coutE(DataHandling) << "An event weight error was passed to the RooDataSet '" << GetName()
1281 << "', but the weight variable '" << _wgtVar->GetName()
1282 << "' does not store errors. Check `StoreError` in the RooDataSet constructor." << std::endl;
1284 }
1286 _doWeightErrorCheck = false;
1287 }
1288
1289 if (_wgtVar) {
1290 _wgtVar->setVal(oldW);
1292 }
1293}
1294
1295
1296
1297////////////////////////////////////////////////////////////////////////////////
1298
1300 RooDataSet* data4, RooDataSet* data5, RooDataSet* data6)
1301{
1302 checkInit() ;
1303 list<RooDataSet*> dsetList ;
1304 if (data1) dsetList.push_back(data1) ;
1305 if (data2) dsetList.push_back(data2) ;
1306 if (data3) dsetList.push_back(data3) ;
1307 if (data4) dsetList.push_back(data4) ;
1308 if (data5) dsetList.push_back(data5) ;
1309 if (data6) dsetList.push_back(data6) ;
1310 return merge(dsetList) ;
1311}
1312
1313
1314
1315////////////////////////////////////////////////////////////////////////////////
1316/// Merge columns of supplied data set(s) with this data set. All
1317/// data sets must have equal number of entries. In case of
1318/// duplicate columns the column of the last dataset in the list
1319/// prevails
1320
1321Bool_t RooDataSet::merge(list<RooDataSet*>dsetList)
1322{
1323
1324 checkInit() ;
1325 // Sanity checks: data sets must have the same size
1326 for (list<RooDataSet*>::iterator iter = dsetList.begin() ; iter != dsetList.end() ; ++iter) {
1327 if (numEntries()!=(*iter)->numEntries()) {
1328 coutE(InputArguments) << "RooDataSet::merge(" << GetName() << ") ERROR: datasets have different size" << endl ;
1329 return kTRUE ;
1330 }
1331 }
1332
1333 // Extend vars with elements of other dataset
1334 list<RooAbsDataStore*> dstoreList ;
1335 for (list<RooDataSet*>::iterator iter = dsetList.begin() ; iter != dsetList.end() ; ++iter) {
1336 _vars.addClone((*iter)->_vars,kTRUE) ;
1337 dstoreList.push_back((*iter)->store()) ;
1338 }
1339
1340 // Merge data stores
1341 RooAbsDataStore* mergedStore = _dstore->merge(_vars,dstoreList) ;
1342 mergedStore->SetName(_dstore->GetName()) ;
1343 mergedStore->SetTitle(_dstore->GetTitle()) ;
1344
1345 // Replace current data store with merged store
1346 delete _dstore ;
1347 _dstore = mergedStore ;
1348
1350 return kFALSE ;
1351}
1352
1353
1354////////////////////////////////////////////////////////////////////////////////
1355/// Add all data points of given data set to this data set.
1356/// Observable in 'data' that are not in this dataset
1357/// with not be transferred
1358
1360{
1361 checkInit() ;
1362 _dstore->append(*data._dstore) ;
1363}
1364
1365
1366
1367////////////////////////////////////////////////////////////////////////////////
1368/// Add a column with the values of the given (function) argument
1369/// to this dataset. The function value is calculated for each
1370/// event using the observable values of each event in case the
1371/// function depends on variables with names that are identical
1372/// to the observable names in the dataset
1373
1375{
1376 checkInit() ;
1377 RooAbsArg* ret = _dstore->addColumn(var,adjustRange) ;
1378 _vars.addOwned(*ret) ;
1380 return ret ;
1381}
1382
1383
1384////////////////////////////////////////////////////////////////////////////////
1385/// Add a column with the values of the given list of (function)
1386/// argument to this dataset. Each function value is calculated for
1387/// each event using the observable values of the event in case the
1388/// function depends on variables with names that are identical to
1389/// the observable names in the dataset
1390
1392{
1393 checkInit() ;
1394 RooArgSet* ret = _dstore->addColumns(varList) ;
1395 _vars.addOwned(*ret) ;
1397 return ret ;
1398}
1399
1400
1401
1402////////////////////////////////////////////////////////////////////////////////
1403/// Create a TH2F histogram of the distribution of the specified variable
1404/// using this dataset. Apply any cuts to select which events are used.
1405/// The variable being plotted can either be contained directly in this
1406/// dataset, or else be a function of the variables in this dataset.
1407/// The histogram will be created using RooAbsReal::createHistogram() with
1408/// the name provided (with our dataset name prepended).
1409
1410TH2F* RooDataSet::createHistogram(const RooAbsRealLValue& var1, const RooAbsRealLValue& var2, const char* cuts, const char *name) const
1411{
1412 checkInit() ;
1413 return createHistogram(var1, var2, var1.getBins(), var2.getBins(), cuts, name);
1414}
1415
1416
1417
1418////////////////////////////////////////////////////////////////////////////////
1419/// Create a TH2F histogram of the distribution of the specified variable
1420/// using this dataset. Apply any cuts to select which events are used.
1421/// The variable being plotted can either be contained directly in this
1422/// dataset, or else be a function of the variables in this dataset.
1423/// The histogram will be created using RooAbsReal::createHistogram() with
1424/// the name provided (with our dataset name prepended).
1425
1427 Int_t nx, Int_t ny, const char* cuts, const char *name) const
1428{
1429 checkInit() ;
1430 static Int_t counter(0) ;
1431
1432 Bool_t ownPlotVarX(kFALSE) ;
1433 // Is this variable in our dataset?
1434 RooAbsReal* plotVarX= (RooAbsReal*)_vars.find(var1.GetName());
1435 if(0 == plotVarX) {
1436 // Is this variable a client of our dataset?
1437 if (!var1.dependsOn(_vars)) {
1438 coutE(InputArguments) << GetName() << "::createHistogram: Argument " << var1.GetName()
1439 << " is not in dataset and is also not dependent on data set" << endl ;
1440 return 0 ;
1441 }
1442
1443 // Clone derived variable
1444 plotVarX = (RooAbsReal*) var1.Clone() ;
1445 ownPlotVarX = kTRUE ;
1446
1447 //Redirect servers of derived clone to internal ArgSet representing the data in this set
1448 plotVarX->redirectServers(const_cast<RooArgSet&>(_vars)) ;
1449 }
1450
1451 Bool_t ownPlotVarY(kFALSE) ;
1452 // Is this variable in our dataset?
1453 RooAbsReal* plotVarY= (RooAbsReal*)_vars.find(var2.GetName());
1454 if(0 == plotVarY) {
1455 // Is this variable a client of our dataset?
1456 if (!var2.dependsOn(_vars)) {
1457 coutE(InputArguments) << GetName() << "::createHistogram: Argument " << var2.GetName()
1458 << " is not in dataset and is also not dependent on data set" << endl ;
1459 return 0 ;
1460 }
1461
1462 // Clone derived variable
1463 plotVarY = (RooAbsReal*) var2.Clone() ;
1464 ownPlotVarY = kTRUE ;
1465
1466 //Redirect servers of derived clone to internal ArgSet representing the data in this set
1467 plotVarY->redirectServers(const_cast<RooArgSet&>(_vars)) ;
1468 }
1469
1470 // Create selection formula if selection cuts are specified
1471 RooFormula* select = 0;
1472 if(0 != cuts && strlen(cuts)) {
1473 select=new RooFormula(cuts,cuts,_vars);
1474 if (!select || !select->ok()) {
1475 delete select;
1476 return 0 ;
1477 }
1478 }
1479
1480 TString histName(name);
1481 histName.Prepend("_");
1482 histName.Prepend(fName);
1483 histName.Append("_") ;
1484 histName.Append(Form("%08x",counter++)) ;
1485
1486 // create the histogram
1487 TH2F* histogram=new TH2F(histName.Data(), "Events", nx, var1.getMin(), var1.getMax(),
1488 ny, var2.getMin(), var2.getMax());
1489 if(!histogram) {
1490 coutE(DataHandling) << fName << "::createHistogram: unable to create a new histogram" << endl;
1491 return 0;
1492 }
1493
1494 // Dump contents
1495 Int_t nevent= numEntries() ;
1496 for(Int_t i=0; i < nevent; ++i)
1497 {
1498 get(i);
1499
1500 if (select && select->eval()==0) continue ;
1501 histogram->Fill(plotVarX->getVal(), plotVarY->getVal(),weight()) ;
1502 }
1503
1504 if (ownPlotVarX) delete plotVarX ;
1505 if (ownPlotVarY) delete plotVarY ;
1506 if (select) delete select ;
1507
1508 return histogram ;
1509}
1510
1511
1512
1513
1514
1515////////////////////////////////////////////////////////////////////////////////
1516/// Special plot method for 'X-Y' datasets used in \f$ \chi^2 \f$ fitting.
1517/// For general plotting, see RooAbsData::plotOn().
1518///
1519/// These datasets
1520/// have one observable (X) and have weights (Y) and associated errors.
1521/// <table>
1522/// <tr><th> Contents options <th> Effect
1523/// <tr><td> YVar(RooRealVar& var) <td> Designate specified observable as 'y' variable
1524/// If not specified, the event weight will be the y variable
1525/// <tr><th> Histogram drawing options <th> Effect
1526/// <tr><td> DrawOption(const char* opt) <td> Select ROOT draw option for resulting TGraph object
1527/// <tr><td> LineStyle(Int_t style) <td> Select line style by ROOT line style code, default is solid
1528/// <tr><td> LineColor(Int_t color) <td> Select line color by ROOT color code, default is black
1529/// <tr><td> LineWidth(Int_t width) <td> Select line with in pixels, default is 3
1530/// <tr><td> MarkerStyle(Int_t style) <td> Select the ROOT marker style, default is 21
1531/// <tr><td> MarkerColor(Int_t color) <td> Select the ROOT marker color, default is black
1532/// <tr><td> MarkerSize(Double_t size) <td> Select the ROOT marker size
1533/// <tr><td> Rescale(Double_t factor) <td> Apply global rescaling factor to histogram
1534/// <tr><th> Misc. other options <th> Effect
1535/// <tr><td> Name(const chat* name) <td> Give curve specified name in frame. Useful if curve is to be referenced later
1536/// <tr><td> Invisible(Bool_t flag) <td> Add curve to frame, but do not display. Useful in combination AddTo()
1537/// </table>
1538
1539RooPlot* RooDataSet::plotOnXY(RooPlot* frame, const RooCmdArg& arg1, const RooCmdArg& arg2,
1540 const RooCmdArg& arg3, const RooCmdArg& arg4,
1541 const RooCmdArg& arg5, const RooCmdArg& arg6,
1542 const RooCmdArg& arg7, const RooCmdArg& arg8) const
1543{
1544 checkInit() ;
1545
1546 RooLinkedList argList ;
1547 argList.Add((TObject*)&arg1) ; argList.Add((TObject*)&arg2) ;
1548 argList.Add((TObject*)&arg3) ; argList.Add((TObject*)&arg4) ;
1549 argList.Add((TObject*)&arg5) ; argList.Add((TObject*)&arg6) ;
1550 argList.Add((TObject*)&arg7) ; argList.Add((TObject*)&arg8) ;
1551
1552 // Process named arguments
1553 RooCmdConfig pc(Form("RooDataSet::plotOnXY(%s)",GetName())) ;
1554 pc.defineString("drawOption","DrawOption",0,"P") ;
1555 pc.defineString("histName","Name",0,"") ;
1556 pc.defineInt("lineColor","LineColor",0,-999) ;
1557 pc.defineInt("lineStyle","LineStyle",0,-999) ;
1558 pc.defineInt("lineWidth","LineWidth",0,-999) ;
1559 pc.defineInt("markerColor","MarkerColor",0,-999) ;
1560 pc.defineInt("markerStyle","MarkerStyle",0,8) ;
1561 pc.defineDouble("markerSize","MarkerSize",0,-999) ;
1562 pc.defineInt("fillColor","FillColor",0,-999) ;
1563 pc.defineInt("fillStyle","FillStyle",0,-999) ;
1564 pc.defineInt("histInvisible","Invisible",0,0) ;
1565 pc.defineDouble("scaleFactor","Rescale",0,1.) ;
1566 pc.defineObject("xvar","XVar",0,0) ;
1567 pc.defineObject("yvar","YVar",0,0) ;
1568
1569
1570 // Process & check varargs
1571 pc.process(argList) ;
1572 if (!pc.ok(kTRUE)) {
1573 return frame ;
1574 }
1575
1576 // Extract values from named arguments
1577 const char* drawOptions = pc.getString("drawOption") ;
1578 Int_t histInvisible = pc.getInt("histInvisible") ;
1579 const char* histName = pc.getString("histName",0,kTRUE) ;
1580 Double_t scaleFactor = pc.getDouble("scaleFactor") ;
1581
1582 RooRealVar* xvar = (RooRealVar*) _vars.find(frame->getPlotVar()->GetName()) ;
1583
1584 // Determine Y variable (default is weight, if present)
1585 RooRealVar* yvar = (RooRealVar*)(pc.getObject("yvar")) ;
1586
1587 // Sanity check. XY plotting only applies to weighted datasets if no YVar is specified
1588 if (!_wgtVar && !yvar) {
1589 coutE(InputArguments) << "RooDataSet::plotOnXY(" << GetName() << ") ERROR: no YVar() argument specified and dataset is not weighted" << endl ;
1590 return 0 ;
1591 }
1592
1593 RooRealVar* dataY = yvar ? (RooRealVar*) _vars.find(yvar->GetName()) : 0 ;
1594 if (yvar && !dataY) {
1595 coutE(InputArguments) << "RooDataSet::plotOnXY(" << GetName() << ") ERROR on YVar() argument, dataset does not contain a variable named " << yvar->GetName() << endl ;
1596 return 0 ;
1597 }
1598
1599
1600 // Make RooHist representing XY contents of data
1601 RooHist* graph = new RooHist ;
1602 if (histName) {
1603 graph->SetName(histName) ;
1604 } else {
1605 graph->SetName(Form("hxy_%s",GetName())) ;
1606 }
1607
1608 for (int i=0 ; i<numEntries() ; i++) {
1609 get(i) ;
1610 Double_t x = xvar->getVal() ;
1611 Double_t exlo = xvar->getErrorLo() ;
1612 Double_t exhi = xvar->getErrorHi() ;
1613 Double_t y,eylo,eyhi ;
1614 if (!dataY) {
1615 y = weight() ;
1616 weightError(eylo,eyhi) ;
1617 } else {
1618 y = dataY->getVal() ;
1619 eylo = dataY->getErrorLo() ;
1620 eyhi = dataY->getErrorHi() ;
1621 }
1622 graph->addBinWithXYError(x,y,-1*exlo,exhi,-1*eylo,eyhi,scaleFactor) ;
1623 }
1624
1625 // Adjust style options according to named arguments
1626 Int_t lineColor = pc.getInt("lineColor") ;
1627 Int_t lineStyle = pc.getInt("lineStyle") ;
1628 Int_t lineWidth = pc.getInt("lineWidth") ;
1629 Int_t markerColor = pc.getInt("markerColor") ;
1630 Int_t markerStyle = pc.getInt("markerStyle") ;
1631 Size_t markerSize = pc.getDouble("markerSize") ;
1632 Int_t fillColor = pc.getInt("fillColor") ;
1633 Int_t fillStyle = pc.getInt("fillStyle") ;
1634
1635 if (lineColor!=-999) graph->SetLineColor(lineColor) ;
1636 if (lineStyle!=-999) graph->SetLineStyle(lineStyle) ;
1637 if (lineWidth!=-999) graph->SetLineWidth(lineWidth) ;
1638 if (markerColor!=-999) graph->SetMarkerColor(markerColor) ;
1639 if (markerStyle!=-999) graph->SetMarkerStyle(markerStyle) ;
1640 if (markerSize!=-999) graph->SetMarkerSize(markerSize) ;
1641 if (fillColor!=-999) graph->SetFillColor(fillColor) ;
1642 if (fillStyle!=-999) graph->SetFillStyle(fillStyle) ;
1643
1644 // Add graph to frame
1645 frame->addPlotable(graph,drawOptions,histInvisible) ;
1646
1647 return frame ;
1648}
1649
1650
1651
1652
1653////////////////////////////////////////////////////////////////////////////////
1654/// Read given list of ascii files, and construct a data set, using the given
1655/// ArgList as structure definition.
1656/// \param fileList Multiple file names, comma separated. Each
1657/// file is optionally prefixed with 'commonPath' if such a path is
1658/// provided
1659///
1660/// \param varList Specify the dimensions of the dataset to be built.
1661/// This list describes the order in which these dimensions appear in the
1662/// ascii files to be read.
1663/// Each line in the ascii file should contain N white-space separated
1664/// tokens, with N the number of args in `varList`. Any text beyond
1665/// N tokens will be ignored with a warning message.
1666/// (NB: This is the default output of RooArgList::writeToStream())
1667///
1668/// \param verbOpt `Q` be quiet, `D` debug mode (verbose)
1669///
1670/// \param commonPath All filenames in `fileList` will be prefixed with this optional path.
1671///
1672/// \param indexCatName Interpret the data as belonging to category `indexCatName`.
1673/// When multiple files are read, a RooCategory arg in `varList` can
1674/// optionally be designated to hold information about the source file
1675/// of each data point. This feature is enabled by giving the name
1676/// of the (already existing) category variable in `indexCatName`.
1677///
1678/// \attention If the value of any of the variables on a given line exceeds the
1679/// fit range associated with that dimension, the entire line will be
1680/// ignored. A warning message is printed in each case, unless the
1681/// `Q` verbose option is given. The number of events read and skipped
1682/// is always summarized at the end.
1683///
1684/// If no further information is given a label name 'fileNNN' will
1685/// be assigned to each event, where NNN is the sequential number of
1686/// the source file in `fileList`.
1687///
1688/// Alternatively, it is possible to override the default label names
1689/// of the index category by specifying them in the fileList string:
1690/// When instead of `file1.txt,file2.txt` the string
1691/// `file1.txt:FOO,file2.txt:BAR` is specified, a state named "FOO"
1692/// is assigned to the index category for each event originating from
1693/// file1.txt. The labels FOO,BAR may be predefined in the index
1694/// category via defineType(), but don't have to be.
1695///
1696/// Finally, one can also assign the same label to multiple files,
1697/// either by specifying `file1.txt:FOO,file2,txt:FOO,file3.txt:BAR`
1698/// or `file1.txt,file2.txt:FOO,file3.txt:BAR`.
1699///
1700
1701RooDataSet *RooDataSet::read(const char *fileList, const RooArgList &varList,
1702 const char *verbOpt, const char* commonPath,
1703 const char* indexCatName) {
1704 // Make working copy of variables list
1705 RooArgList variables(varList) ;
1706
1707 // Append blinding state category to variable list if not already there
1708 Bool_t ownIsBlind(kTRUE) ;
1709 RooAbsArg* blindState = variables.find("blindState") ;
1710 if (!blindState) {
1711 blindState = new RooCategory("blindState","Blinding State") ;
1712 variables.add(*blindState) ;
1713 } else {
1714 ownIsBlind = kFALSE ;
1715 if (blindState->IsA()!=RooCategory::Class()) {
1716 oocoutE((TObject*)0,DataHandling) << "RooDataSet::read: ERROR: variable list already contains"
1717 << "a non-RooCategory blindState member" << endl ;
1718 return 0 ;
1719 }
1720 oocoutW((TObject*)0,DataHandling) << "RooDataSet::read: WARNING: recycling existing "
1721 << "blindState category in variable list" << endl ;
1722 }
1723 RooCategory* blindCat = (RooCategory*) blindState ;
1724
1725 // Configure blinding state category
1726 blindCat->setAttribute("Dynamic") ;
1727 blindCat->defineType("Normal",0) ;
1728 blindCat->defineType("Blind",1) ;
1729
1730 // parse the option string
1731 TString opts= verbOpt;
1732 opts.ToLower();
1733 Bool_t verbose= !opts.Contains("q");
1734 Bool_t debug= opts.Contains("d");
1735
1736 auto data = std::make_unique<RooDataSet>("dataset", fileList, variables);
1737 if (ownIsBlind) { variables.remove(*blindState) ; delete blindState ; }
1738 if(!data) {
1739 oocoutE((TObject*)0,DataHandling) << "RooDataSet::read: unable to create a new dataset"
1740 << endl;
1741 return nullptr;
1742 }
1743
1744 // Redirect blindCat to point to the copy stored in the data set
1745 blindCat = (RooCategory*) data->_vars.find("blindState") ;
1746
1747 // Find index category, if requested
1748 RooCategory *indexCat = 0;
1749 //RooCategory *indexCatOrig = 0;
1750 if (indexCatName) {
1751 RooAbsArg* tmp = 0;
1752 tmp = data->_vars.find(indexCatName) ;
1753 if (!tmp) {
1754 oocoutE(data.get(),DataHandling) << "RooDataSet::read: no index category named "
1755 << indexCatName << " in supplied variable list" << endl ;
1756 return nullptr;
1757 }
1758 if (tmp->IsA()!=RooCategory::Class()) {
1759 oocoutE(data.get(),DataHandling) << "RooDataSet::read: variable " << indexCatName
1760 << " is not a RooCategory" << endl ;
1761 return nullptr;
1762 }
1763 indexCat = static_cast<RooCategory*>(tmp);
1764
1765 // Prevent RooArgSet from attempting to read in indexCat
1766 indexCat->setAttribute("Dynamic") ;
1767 }
1768
1769
1770 Int_t outOfRange(0) ;
1771
1772 // Loop over all names in comma separated list
1773 Int_t fileSeqNum(0);
1774 for (const auto& filename : RooHelpers::tokenise(std::string(fileList), ", ")) {
1775 // Determine index category number, if this option is active
1776 if (indexCat) {
1777
1778 // Find and detach optional file category name
1779 const char *catname = strchr(filename.c_str(),':');
1780
1781 if (catname) {
1782 // Use user category name if provided
1783 catname++ ;
1784
1785 if (indexCat->hasLabel(catname)) {
1786 // Use existing category index
1787 indexCat->setLabel(catname);
1788 } else {
1789 // Register cat name
1790 indexCat->defineType(catname,fileSeqNum) ;
1791 indexCat->setIndex(fileSeqNum) ;
1792 }
1793 } else {
1794 // Assign autogenerated name
1795 char newLabel[128] ;
1796 snprintf(newLabel,128,"file%03d",fileSeqNum) ;
1797 if (indexCat->defineType(newLabel,fileSeqNum)) {
1798 oocoutE(data.get(), DataHandling) << "RooDataSet::read: Error, cannot register automatic type name " << newLabel
1799 << " in index category " << indexCat->GetName() << endl ;
1800 return 0 ;
1801 }
1802 // Assign new category number
1803 indexCat->setIndex(fileSeqNum) ;
1804 }
1805 }
1806
1807 oocoutI(data.get(), DataHandling) << "RooDataSet::read: reading file " << filename << endl ;
1808
1809 // Prefix common path
1810 TString fullName(commonPath) ;
1811 fullName.Append(filename) ;
1812 ifstream file(fullName) ;
1813
1814 if (!file.good()) {
1815 oocoutE(data.get(), DataHandling) << "RooDataSet::read: unable to open '"
1816 << filename << "'. Returning nullptr now." << endl;
1817 return nullptr;
1818 }
1819
1820 // Double_t value;
1821 Int_t line(0) ;
1822 Bool_t haveBlindString(false) ;
1823
1824 while(file.good() && !file.eof()) {
1825 line++;
1826 if(debug) oocxcoutD(data.get(),DataHandling) << "reading line " << line << endl;
1827
1828 // process comment lines
1829 if (file.peek() == '#') {
1830 if(debug) oocxcoutD(data.get(),DataHandling) << "skipping comment on line " << line << endl;
1831 } else {
1832 // Read single line
1833 Bool_t readError = variables.readFromStream(file,kTRUE,verbose) ;
1834 data->_vars = variables ;
1835
1836 // Stop on read error
1837 if(!file.good()) {
1838 oocoutE(data.get(), DataHandling) << "RooDataSet::read(static): read error at line " << line << endl ;
1839 break;
1840 }
1841
1842 if (readError) {
1843 outOfRange++ ;
1844 } else {
1845 blindCat->setIndex(haveBlindString) ;
1846 data->fill(); // store this event
1847 }
1848 }
1849
1850 // Skip all white space (including empty lines).
1851 while (isspace(file.peek())) {
1852 char dummy;
1853 file >> std::noskipws >> dummy >> std::skipws;
1854 }
1855 }
1856
1857 file.close();
1858
1859 // get next file name
1860 fileSeqNum++ ;
1861 }
1862
1863 if (indexCat) {
1864 // Copy dynamically defined types from new data set to indexCat in original list
1865 assert(dynamic_cast<RooCategory*>(variables.find(indexCatName)));
1866 const auto origIndexCat = static_cast<RooCategory*>(variables.find(indexCatName));
1867 for (const auto& nameIdx : *indexCat) {
1868 origIndexCat->defineType(nameIdx.first, nameIdx.second);
1869 }
1870 }
1871 oocoutI(data.get(),DataHandling) << "RooDataSet::read: read " << data->numEntries()
1872 << " events (ignored " << outOfRange << " out of range events)" << endl;
1873
1874 return data.release();
1875}
1876
1877
1878
1879
1880////////////////////////////////////////////////////////////////////////////////
1881/// Write the contents of this dataset to an ASCII file with the specified name.
1882/// Each event will be written as a single line containing the written values
1883/// of each observable in the order they were declared in the dataset and
1884/// separated by whitespaces
1885
1886Bool_t RooDataSet::write(const char* filename) const
1887{
1888 // Open file for writing
1889 ofstream ofs(filename) ;
1890 if (ofs.fail()) {
1891 coutE(DataHandling) << "RooDataSet::write(" << GetName() << ") cannot create file " << filename << endl ;
1892 return kTRUE ;
1893 }
1894
1895 // Write all lines as arglist in compact mode
1896 coutI(DataHandling) << "RooDataSet::write(" << GetName() << ") writing ASCII file " << filename << endl ;
1897 return write(ofs);
1898}
1899
1900////////////////////////////////////////////////////////////////////////////////
1901/// Write the contents of this dataset to the stream.
1902/// Each event will be written as a single line containing the written values
1903/// of each observable in the order they were declared in the dataset and
1904/// separated by whitespaces
1905
1906Bool_t RooDataSet::write(ostream & ofs) const {
1907 checkInit();
1908
1909 for (Int_t i=0; i<numEntries(); ++i) {
1910 get(i)->writeToStream(ofs,kTRUE);
1911 }
1912
1913 if (ofs.fail()) {
1914 coutW(DataHandling) << "RooDataSet::write(" << GetName() << "): WARNING error(s) have occured in writing" << endl ;
1915 }
1916
1917 return ofs.fail() ;
1918}
1919
1920
1921////////////////////////////////////////////////////////////////////////////////
1922/// Print info about this dataset to the specified output stream.
1923///
1924/// Standard: number of entries
1925/// Shape: list of variables we define & were generated with
1926
1927void RooDataSet::printMultiline(ostream& os, Int_t contents, Bool_t verbose, TString indent) const
1928{
1929 checkInit() ;
1931 if (_wgtVar) {
1932 os << indent << " Dataset variable \"" << _wgtVar->GetName() << "\" is interpreted as the event weight" << endl ;
1933 }
1934}
1935
1936
1937////////////////////////////////////////////////////////////////////////////////
1938/// Print value of the dataset, i.e. the sum of weights contained in the dataset
1939
1940void RooDataSet::printValue(ostream& os) const
1941{
1942 os << numEntries() << " entries" ;
1943 if (isWeighted()) {
1944 os << " (" << sumEntries() << " weighted)" ;
1945 }
1946}
1947
1948
1949
1950////////////////////////////////////////////////////////////////////////////////
1951/// Print argument of dataset, i.e. the observable names
1952
1953void RooDataSet::printArgs(ostream& os) const
1954{
1955 os << "[" ;
1957 RooAbsArg* arg ;
1958 Bool_t first(kTRUE) ;
1959 while((arg=(RooAbsArg*)iter->Next())) {
1960 if (first) {
1961 first=kFALSE ;
1962 } else {
1963 os << "," ;
1964 }
1965 os << arg->GetName() ;
1966 }
1967 if (_wgtVar) {
1968 os << ",weight:" << _wgtVar->GetName() ;
1969 }
1970 os << "]" ;
1971 delete iter ;
1972}
1973
1974
1975
1976////////////////////////////////////////////////////////////////////////////////
1977/// Change the name of this dataset into the given name
1978
1979void RooDataSet::SetName(const char *name)
1980{
1981 if (_dir) _dir->GetList()->Remove(this);
1983 if (_dir) _dir->GetList()->Add(this);
1984}
1985
1986
1987////////////////////////////////////////////////////////////////////////////////
1988/// Change the title of this dataset into the given name
1989
1990void RooDataSet::SetNameTitle(const char *name, const char* title)
1991{
1992 if (_dir) _dir->GetList()->Remove(this);
1993 TNamed::SetNameTitle(name,title) ;
1994 if (_dir) _dir->GetList()->Add(this);
1995}
1996
1997
1998////////////////////////////////////////////////////////////////////////////////
1999/// Stream an object of class RooDataSet.
2000
2001void RooDataSet::Streamer(TBuffer &R__b)
2002{
2003 if (R__b.IsReading()) {
2004
2005 UInt_t R__s, R__c;
2006 Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
2007
2008 if (R__v>1) {
2009
2010 // Use new-style streaming for version >1
2011 R__b.ReadClassBuffer(RooDataSet::Class(),this,R__v,R__s,R__c);
2012
2013 } else {
2014
2015 // Legacy dataset conversion happens here. Legacy RooDataSet inherits from RooTreeData
2016 // which in turn inherits from RooAbsData. Manually stream RooTreeData contents on
2017 // file here and convert it into a RooTreeDataStore which is installed in the
2018 // new-style RooAbsData base class
2019
2020 // --- This is the contents of the streamer code of RooTreeData version 1 ---
2021 UInt_t R__s1, R__c1;
2022 Version_t R__v1 = R__b.ReadVersion(&R__s1, &R__c1); if (R__v1) { }
2023
2024 RooAbsData::Streamer(R__b);
2025 TTree* X_tree(0) ; R__b >> X_tree;
2026 RooArgSet X_truth ; X_truth.Streamer(R__b);
2027 TString X_blindString ; X_blindString.Streamer(R__b);
2028 R__b.CheckByteCount(R__s1, R__c1, TClass::GetClass("RooTreeData"));
2029 // --- End of RooTreeData-v1 streamer
2030
2031 // Construct RooTreeDataStore from X_tree and complete initialization of new-style RooAbsData
2032 _dstore = new RooTreeDataStore(X_tree,_vars) ;
2033 _dstore->SetName(GetName()) ;
2035 _dstore->checkInit() ;
2036
2037 // This is the contents of the streamer code of RooDataSet version 1
2038 RooDirItem::Streamer(R__b);
2039 _varsNoWgt.Streamer(R__b);
2040 R__b >> _wgtVar;
2041 R__b.CheckByteCount(R__s, R__c, RooDataSet::IsA());
2042
2043
2044 }
2045 } else {
2047 }
2048}
2049
2050
2051
2052////////////////////////////////////////////////////////////////////////////////
2053/// Convert vector-based storage to tree-based storage. This implementation overrides the base class
2054/// implementation because the latter doesn't transfer weights.
2056{
2058 RooTreeDataStore *newStore = new RooTreeDataStore(GetName(), GetTitle(), _vars, *_dstore, nullptr, _wgtVar ? _wgtVar->GetName() : nullptr);
2059 delete _dstore;
2060 _dstore = newStore;
2062 }
2063}
2064
int Int_t
Definition: CPyCppyy.h:43
unsigned int UInt_t
Definition: CPyCppyy.h:44
void Class()
Definition: Class.C:29
#define f(i)
Definition: RSha256.hxx:104
#define e(i)
Definition: RSha256.hxx:103
#define coutI(a)
Definition: RooMsgService.h:30
#define ccoutE(a)
Definition: RooMsgService.h:41
#define oocoutW(o, a)
Definition: RooMsgService.h:47
#define oocxcoutD(o, a)
Definition: RooMsgService.h:83
#define coutW(a)
Definition: RooMsgService.h:32
#define oocoutE(o, a)
Definition: RooMsgService.h:48
#define oocoutI(o, a)
Definition: RooMsgService.h:45
#define coutE(a)
Definition: RooMsgService.h:33
#define TRACE_DESTROY
Definition: RooTrace.h:24
#define TRACE_CREATE
Definition: RooTrace.h:23
float Size_t
Definition: RtypesCore.h:96
short Version_t
Definition: RtypesCore.h:65
const Bool_t kFALSE
Definition: RtypesCore.h:101
bool Bool_t
Definition: RtypesCore.h:63
double Double_t
Definition: RtypesCore.h:59
const Bool_t kTRUE
Definition: RtypesCore.h:100
#define ClassImp(name)
Definition: Rtypes.h:364
static void indent(ostringstream &buf, int indent_level)
float type_of_call hi(const int &, const int &)
char * Form(const char *fmt,...)
#define snprintf
Definition: civetweb.c:1540
Memory pool for RooArgSet and RooDataSet.
The Kahan summation is a compensated summation algorithm, which significantly reduces numerical error...
Definition: Util.h:122
RooAbsArg is the common abstract base class for objects that represent a value and a "shape" in RooFi...
Definition: RooAbsArg.h:72
void attachToStore(RooAbsDataStore &store)
Attach this argument to the data store such that it reads data from there.
Definition: RooAbsArg.cxx:2266
Bool_t redirectServers(const RooAbsCollection &newServerList, Bool_t mustReplaceAll=kFALSE, Bool_t nameChange=kFALSE, Bool_t isRecursionStep=kFALSE)
Replace all direct servers of this object with the new servers in newServerList.
Definition: RooAbsArg.cxx:995
Bool_t dependsOn(const RooAbsCollection &serverList, const RooAbsArg *ignoreArg=0, Bool_t valueOnly=kFALSE) const
Test whether we depend on (ie, are served by) any object in the specified collection.
Definition: RooAbsArg.cxx:799
void setAttribute(const Text_t *name, Bool_t value=kTRUE)
Set (default) or clear a named boolean attribute of this object.
Definition: RooAbsArg.cxx:291
virtual TObject * Clone(const char *newname=0) const
Make a clone of an object using the Streamer facility.
Definition: RooAbsArg.h:84
bool hasLabel(const std::string &label) const
Check if a state with name label exists.
virtual const char * getCurrentLabel() const
Return label string of current state.
virtual void removeAll()
Remove all arguments from our set, deleting them if we own them.
TIterator * createIterator(Bool_t dir=kIterForward) const
TIterator-style iteration over contained elements.
virtual Bool_t addOwned(RooAbsArg &var, Bool_t silent=kFALSE)
Add the specified argument to list.
virtual RooAbsArg * addClone(const RooAbsArg &var, Bool_t silent=kFALSE)
Add a clone of the specified argument to list.
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE)
Add the specified argument to list.
Bool_t allInRange(const char *rangeSpec) const
Return true if all contained object report to have their value inside the specified range.
void setAttribAll(const Text_t *name, Bool_t value=kTRUE)
Set given attribute in each element of the collection by calling each elements setAttribute() functio...
void assignFast(const RooAbsCollection &other, bool setValDirty=true)
Functional equivalent of assign() but assumes this and other collection have same layout.
bool selectCommon(const RooAbsCollection &refColl, RooAbsCollection &outColl) const
Create a subset of the current collection, consisting only of those elements that are contained as we...
virtual Bool_t remove(const RooAbsArg &var, Bool_t silent=kFALSE, Bool_t matchByNameOnly=kFALSE)
Remove the specified argument from our list.
RooAbsArg * find(const char *name) const
Find object with given name in list.
RooAbsDataStore is the abstract base class for data collection that use a TTree as internal storage m...
virtual void append(RooAbsDataStore &other)=0
const RooArgSet & cachedVars() const
virtual Double_t sumEntries() const
Bool_t dirtyProp() const
virtual void checkInit() const
virtual RooAbsDataStore * merge(const RooArgSet &allvars, std::list< RooAbsDataStore * > dstoreList)=0
virtual RooSpan< const double > getWeightBatch(std::size_t first, std::size_t len) const =0
virtual 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())=0
virtual Double_t weight() const =0
virtual Double_t weightError(RooAbsData::ErrorType etype=RooAbsData::Poisson) const =0
virtual RooAbsArg * addColumn(RooAbsArg &var, Bool_t adjustRange=kTRUE)=0
virtual RooArgSet * addColumns(const RooArgList &varList)=0
virtual Bool_t isWeighted() const =0
RooAbsData is the common abstract base class for binned and unbinned datasets.
Definition: RooAbsData.h:67
virtual const RooArgSet * get() const
Definition: RooAbsData.h:113
void printMultiline(std::ostream &os, Int_t contents, Bool_t verbose=kFALSE, TString indent="") const
Interface for detailed printing of object.
Definition: RooAbsData.cxx:785
void checkInit() const
static StorageType defaultStorageType
Definition: RooAbsData.h:296
void addOwnedComponent(const char *idxlabel, RooAbsData &data)
virtual void fill()
Definition: RooAbsData.cxx:300
RooArgSet _vars
Definition: RooAbsData.h:331
virtual void attachCache(const RooAbsArg *newOwner, const RooArgSet &cachedVars)
Internal method – Attach dataset copied with cache contents to copied instances of functions.
Definition: RooAbsData.cxx:347
RooArgSet _cachedVars
Definition: RooAbsData.h:332
virtual Int_t numEntries() const
Return number of entries in dataset, i.e., count unweighted entries.
Definition: RooAbsData.cxx:307
StorageType storageType
Definition: RooAbsData.h:298
RooAbsDataStore * store()
Definition: RooAbsData.h:89
RooAbsDataStore * _dstore
External variables cached with this data set.
Definition: RooAbsData.h:334
RooAbsRealLValue is the common abstract base class for objects that represent a real value that may a...
virtual Double_t getMax(const char *name=0) const
Get maximum of currently defined range.
virtual Int_t getBins(const char *name=0) const
Get number of bins of currently defined range.
virtual Double_t getMin(const char *name=0) const
Get miniminum of currently defined range.
RooAbsReal is the common abstract base class for objects that represent a real value and implements f...
Definition: RooAbsReal.h:61
Double_t getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
Definition: RooAbsReal.h:91
RooAbsArg * createFundamental(const char *newname=0) const
Create a RooRealVar fundamental object with our properties.
RooArgList is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgList.h:22
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:35
virtual void writeToStream(std::ostream &os, bool compact, const char *section=0) const
Write the contents of the argset in ASCII form to given stream.
Definition: RooArgSet.cxx:343
RooCategory is an object to represent discrete states.
Definition: RooCategory.h:27
bool defineType(const std::string &label)
Define a state with given name.
virtual Bool_t setLabel(const char *label, bool printError=true) override
Set value by specifying the name of the desired state.
virtual Bool_t setIndex(Int_t index, bool printError=true) override
Set value by specifying the index code of the desired state.
RooCmdArg is a named container for two doubles, two integers two object points and three string point...
Definition: RooCmdArg.h:27
Class RooCmdConfig is a configurable parser for RooCmdArg named arguments.
Definition: RooCmdConfig.h:27
RooCompositeDataStore combines several disjunct datasets into one.
The RooDataHist is a container class to hold N-dimensional binned data.
Definition: RooDataHist.h:39
RooDataSet is a container class to hold unbinned data.
Definition: RooDataSet.h:36
virtual Bool_t isNonPoissonWeighted() const override
Returns true if histogram contains bins with entries with a non-integer weight.
virtual Bool_t isWeighted() const override
Return true if dataset contains weighted events.
RooRealVar * _wgtVar
Definition: RooDataSet.h:168
bool _doWeightErrorCheck
Counter to silence error messages when filling dataset.
Definition: RooDataSet.h:176
static void cleanup()
Definition: RooDataSet.cxx:115
RooArgSet _varsNoWgt
Definition: RooDataSet.h:167
static MemPool * memPool()
virtual RooAbsData * emptyClone(const char *newName=0, const char *newTitle=0, const RooArgSet *vars=0, const char *wgtVarName=0) const override
Return an empty clone of this dataset.
Definition: RooDataSet.cxx:882
virtual void weightError(double &lo, double &hi, ErrorType etype=SumW2) const override
Return the asymmetric errors on the current weight.
virtual const RooArgSet * get() const override
Return a RooArgSet with the coordinates of the current event.
virtual RooAbsArg * addColumn(RooAbsArg &var, Bool_t adjustRange=kTRUE)
Add a column with the values of the given (function) argument to this dataset.
virtual Double_t sumEntries() const override
Return effective number of entries in dataset, i.e., sum all weights.
Bool_t write(const char *filename) const
Write the contents of this dataset to an ASCII file with the specified name.
RooAbsData * reduceEng(const RooArgSet &varSubset, const RooFormulaVar *cutVar, const char *cutRange=0, std::size_t nStart=0, std::size_t nStop=std::numeric_limits< std::size_t >::max(), Bool_t copyCache=kTRUE) override
Implementation of RooAbsData virtual method that drives the RooAbsData::reduce() methods.
Definition: RooDataSet.cxx:938
RooArgSet addWgtVar(const RooArgSet &origVars, const RooAbsArg *wgtVar)
Helper function for constructor that adds optional weight variable to construct total set of observab...
Definition: RooDataSet.cxx:852
void initialize(const char *wgtVarName)
Initialize the dataset.
Definition: RooDataSet.cxx:911
MemPoolForRooSets< RooDataSet, 5 *150 > MemPool
Definition: RooDataSet.h:172
virtual void printArgs(std::ostream &os) const override
Print argument of dataset, i.e. the observable names.
void SetName(const char *name) override
Change the name of this dataset into the given name.
virtual Double_t weightSquared() const override
Return squared event weight of current event.
static RooDataSet * read(const char *filename, const RooArgList &variables, const char *opts="", const char *commonPath="", const char *indexCatName=0)
Read given list of ascii files, and construct a data set, using the given ArgList as structure defini...
TH2F * createHistogram(const RooAbsRealLValue &var1, const RooAbsRealLValue &var2, const char *cuts="", const char *name="hist") const
Create a TH2F histogram of the distribution of the specified variable using this dataset.
virtual RooArgSet * addColumns(const RooArgList &varList)
Add a column with the values of the given list of (function) argument to this dataset.
void SetNameTitle(const char *name, const char *title) override
Change the title of this dataset into the given name.
virtual void printValue(std::ostream &os) const override
Print value of the dataset, i.e. the sum of weights contained in the dataset.
void append(RooDataSet &data)
Add all data points of given data set to this data set.
RooDataSet()
Default constructor for persistence.
Definition: RooDataSet.cxx:174
Bool_t merge(RooDataSet *data1, RooDataSet *data2=0, RooDataSet *data3=0, RooDataSet *data4=0, RooDataSet *data5=0, RooDataSet *data6=0)
void printMultiline(std::ostream &os, Int_t contents, Bool_t verbose=kFALSE, TString indent="") const override
Print info about this dataset to the specified output stream.
virtual ~RooDataSet()
Destructor.
Definition: RooDataSet.cxx:964
virtual void add(const RooArgSet &row, Double_t weight=1.0, Double_t weightError=0) override
Add a data point, with its coordinates specified in the 'data' argset, to the data set.
void getBatches(RooBatchCompute::RunContext &evalData, std::size_t first=0, std::size_t len=std::numeric_limits< std::size_t >::max()) const override
Write information to retrieve data columns into evalData.spans.
unsigned short _errorMsgCount
Definition: RooDataSet.h:175
RooDataHist * binnedClone(const char *newName=0, const char *newTitle=0) const
Return binned clone of this dataset.
Definition: RooDataSet.cxx:975
virtual void addFast(const RooArgSet &row, Double_t weight=1.0, Double_t weightError=0)
Add a data point, with its coordinates specified in the 'data' argset, to the data set.
void convertToTreeStore() override
Convert vector-based storage to tree-based storage.
virtual RooSpan< const double > getWeightBatch(std::size_t first, std::size_t len) const override
virtual RooAbsData * cacheClone(const RooAbsArg *newCacheOwner, const RooArgSet *newCacheVars, const char *newName=0) override
Return a clone of this dataset containing only the cached variables.
Definition: RooDataSet.cxx:864
virtual RooPlot * plotOnXY(RooPlot *frame, const RooCmdArg &arg1=RooCmdArg::none(), const RooCmdArg &arg2=RooCmdArg::none(), const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none(), const RooCmdArg &arg6=RooCmdArg::none(), const RooCmdArg &arg7=RooCmdArg::none(), const RooCmdArg &arg8=RooCmdArg::none()) const
Special plot method for 'X-Y' datasets used in fitting.
virtual Double_t weight() const override
Return event weight of current event.
Definition: RooDataSet.cxx:998
RooDirItem is a utility base class for RooFit objects that are to be attached to ROOT directories.
Definition: RooDirItem.h:22
void appendToDir(TObject *obj, Bool_t forceMemoryResident=kFALSE)
Append object to directory.
Definition: RooDirItem.cxx:55
void removeFromDir(TObject *obj)
Remove object from directory it was added to.
Definition: RooDirItem.cxx:43
TDirectory * _dir
Definition: RooDirItem.h:33
A RooFormulaVar is a generic implementation of a real-valued object, which takes a RooArgList of serv...
Definition: RooFormulaVar.h:30
RooFormula internally uses ROOT's TFormula to compute user-defined expressions of RooAbsArgs.
Definition: RooFormula.h:34
Double_t eval(const RooArgSet *nset=0) const
Evalute all parameters/observables, and then evaluate formula.
Definition: RooFormula.cxx:342
Bool_t ok() const
Definition: RooFormula.h:59
A RooHist is a graphical representation of binned data based on the TGraphAsymmErrors class.
Definition: RooHist.h:27
RooLinkedList is an collection class for internal use, storing a collection of RooAbsArg pointers in ...
Definition: RooLinkedList.h:37
TIterator * MakeIterator(Bool_t forward=kTRUE) const
Create a TIterator for this list.
virtual void Add(TObject *arg)
Definition: RooLinkedList.h:64
A RooPlot is a plot frame and a container for graphics objects within that frame.
Definition: RooPlot.h:44
RooAbsRealLValue * getPlotVar() const
Definition: RooPlot.h:139
void addPlotable(RooPlotable *plotable, Option_t *drawOptions="", Bool_t invisible=kFALSE, Bool_t refreshNorm=kFALSE)
Add the specified plotable object to our plot.
Definition: RooPlot.cxx:570
RooRealVar represents a variable that can be changed from the outside.
Definition: RooRealVar.h:39
Double_t getErrorHi() const
Definition: RooRealVar.h:70
Double_t getErrorLo() const
Definition: RooRealVar.h:69
void removeAsymError()
Definition: RooRealVar.h:67
void setError(Double_t value)
Definition: RooRealVar.h:62
void setAsymError(Double_t lo, Double_t hi)
Definition: RooRealVar.h:68
void removeError()
Definition: RooRealVar.h:63
virtual void setVal(Double_t value)
Set value of variable to 'value'.
Definition: RooRealVar.cxx:257
static void activate()
Install atexit handler that calls CleanupRooFitAtExit() on program termination.
Definition: RooSentinel.cxx:55
A simple container to hold a batch of data values.
Definition: RooSpan.h:34
RooTreeDataStore is a TTree-backed data storage.
void loadValues(const TTree *t, const RooFormulaVar *select=0, const char *rangeName=0, Int_t nStart=0, Int_t nStop=2000000000)
Load values from tree 't' into this data collection, optionally selecting events using the RooFormula...
RooVectorDataStore uses std::vectors to store data columns.
Buffer base class used for serializing objects.
Definition: TBuffer.h:43
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=0)=0
virtual Version_t ReadVersion(UInt_t *start=0, UInt_t *bcnt=0, const TClass *cl=0)=0
virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss)=0
Bool_t IsReading() const
Definition: TBuffer.h:86
virtual Int_t WriteClassBuffer(const TClass *cl, void *pointer)=0
static TClass * GetClass(const char *name, Bool_t load=kTRUE, Bool_t silent=kFALSE)
Static method returning pointer to TClass of the specified class name.
Definition: TClass.cxx:2955
virtual TList * GetList() const
Definition: TDirectory.h:213
A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format.
Definition: TFile.h:54
static TFile * Open(const char *name, Option_t *option="", const char *ftitle="", Int_t compress=ROOT::RCompressionSetting::EDefaults::kUseCompiledDefault, Int_t netopt=0)
Create / open a file.
Definition: TFile.cxx:4011
2-D histogram with a float per channel (see TH1 documentation)}
Definition: TH2.h:251
Int_t Fill(Double_t)
Invalid Fill method.
Definition: TH2.cxx:358
Iterator abstract base class.
Definition: TIterator.h:30
virtual TObject * Next()=0
virtual void Add(TObject *obj)
Definition: TList.h:87
virtual TObject * Remove(TObject *obj)
Remove object from the list.
Definition: TList.cxx:822
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:164
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:48
TString fName
Definition: TNamed.h:32
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition: TNamed.cxx:140
virtual void SetNameTitle(const char *name, const char *title)
Set all the TNamed parameters (name and title).
Definition: TNamed.cxx:154
Mother of all ROOT objects.
Definition: TObject.h:37
Basic string class.
Definition: TString.h:136
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1150
TString & Prepend(const char *cs)
Definition: TString.h:661
const char * Data() const
Definition: TString.h:369
TString & Append(const char *cs)
Definition: TString.h:564
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:624
A TTree represents a columnar dataset.
Definition: TTree.h:79
TLine * line
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
basic_string_view< char > string_view
VecExpr< UnaryOp< Fabs< T >, VecExpr< A, T, D >, T >, T, D > fabs(const VecExpr< A, T, D > &rhs)
static const std::string name("name")
@ DataHandling
Definition: RooGlobalFunc.h:62
@ InputArguments
Definition: RooGlobalFunc.h:61
std::vector< std::string > tokenise(const std::string &str, const std::string &delims, bool returnEmptyToken=true)
Tokenise the string by splitting at the characters in delims.
Definition: RooHelpers.cxx:67
static constexpr double pc
void variables(TString dataset, TString fin="TMVA.root", TString dirName="InputVariables_Id", TString title="TMVA Input Variables", Bool_t isRegression=kFALSE, Bool_t useTMVAStyle=kTRUE)
Definition: file.py:1
Definition: first.py:1
Definition: graph.py:1
This struct enables passing computation data around between elements of a computation graph.
Definition: RunContext.h:31
std::unordered_map< const RooAbsReal *, RooSpan< const double > > spans
Once an object has computed its value(s), the span pointing to the results is registered here.
Definition: RunContext.h:52
auto * l
Definition: textangle.C:4