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