Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
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
22Container 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 under the hood. Note that the TTree is not
51attached to any currently-opened TFile in order to avoid double-ownership.
52 - Enable tree-backed storage similar to this:
53 ```
54 TFile outputFile("filename.root", "RECREATE");
55 RooAbsData::setDefaultStorageType(RooAbsData::Tree);
56 RooDataSet mydata(...);
57 ```
58 - Or convert an existing memory-backed data storage:
59 ```
60 RooDataSet mydata(...);
61
62 TFile outputFile("filename.root", "RECREATE");
63 mydata.convertToTreeStore();
64 ```
65
66For the inverse conversion, see `RooAbsData::convertToVectorStore()`.
67
68
69### Creating a dataset using RDataFrame
70See RooAbsDataHelper, rf408_RDataFrameToRooFit.C
71
72### Uniquely identifying RooDataSet objects
73
74\warning Before v6.28, it was ensured that no RooDataSet objects on the heap
75were located at an address that had already been used for a RooDataSet before.
76With v6.28, this is not guaranteed anymore. Hence, if your code uses pointer
77comparisons to uniquely identify RooDataSet instances, please consider using
78the new `RooAbsData::uniqueId()`.
79
80
81**/
82
83#include "RooDataSet.h"
84
85#include "RooPlot.h"
86#include "RooAbsReal.h"
87#include "Roo1DTable.h"
88#include "RooCategory.h"
89#include "RooFormula.h"
90#include "RooFormulaVar.h"
91#include "RooArgList.h"
92#include "RooRealVar.h"
93#include "RooDataHist.h"
94#include "RooMsgService.h"
95#include "RooCmdConfig.h"
96#include "RooHist.h"
97#include "RooTreeDataStore.h"
98#include "RooVectorDataStore.h"
100#include "RooSentinel.h"
101#include "RooTrace.h"
102#include "RooFitImplHelpers.h"
103
104#include "ROOT/StringUtils.hxx"
105
106#include "Math/Util.h"
107#include "TTree.h"
108#include "TFile.h"
109#include "TBuffer.h"
110#include "strlcpy.h"
111#include "snprintf.h"
112
113#include <iostream>
114#include <memory>
115#include <fstream>
116
117
118using std::endl, std::string, std::map, std::list, std::ifstream, std::ofstream, std::ostream;
119
120
122
123////////////////////////////////////////////////////////////////////////////////
124/// Default constructor for persistence
125
130
131namespace {
132
133struct FinalizeVarsOutput {
134 RooArgSet finalVars;
135 std::unique_ptr<RooRealVar> weight;
136 std::string weightVarName;
137 RooArgSet errorSet;
138};
139
140FinalizeVarsOutput finalizeVars(RooArgSet const &vars,
141 RooAbsArg * indexCat,
142 const char* wgtVarName,
145 RooArgSet * errorSet)
146{
147 FinalizeVarsOutput out;
148 out.finalVars.add(vars);
149
150 // Gather all imported weighted datasets to infer the weight variable name
151 // and whether we need weight errors
152 std::vector<RooAbsData*> weightedImpDatasets;
153 if(impData && impData->isWeighted()) weightedImpDatasets.push_back(impData);
155 if(data->isWeighted()) {
156 weightedImpDatasets.push_back(data);
157 }
158 }
159
160 bool needsWeightErrors = false;
161
162 // Figure out if the weight needs to store errors
164 if(dynamic_cast<RooDataHist const*>(data)) {
165 needsWeightErrors = true;
166 }
167 }
168
169 if (indexCat) {
170 out.finalVars.add(*indexCat, true);
171 }
172
173 out.weightVarName = wgtVarName ? wgtVarName : "";
174
175 if(out.weightVarName.empty()) {
176 // Even if no weight variable is specified, we want to have one if we are
177 // importing weighted datasets
179 if(auto ds = dynamic_cast<RooDataSet const*>(data)) {
180 // If the imported data is a RooDataSet, we take over its weight variable name
181 out.weightVarName = ds->weightVar()->GetName();
182 break;
183 } else {
185 // Don't break here! The next imported data might be a RooDataSet,
186 // and in that case we want to take over its weight name instead of
187 // using the default one.
188 }
189 }
190 }
191
192 // If the weight variable is required but is not in the set, create and add
193 // it on the fly
194 RooAbsArg * wgtVar = out.finalVars.find(out.weightVarName.c_str());
195 if (!out.weightVarName.empty() && !wgtVar) {
196 const char* name = out.weightVarName.c_str();
197 out.weight = std::make_unique<RooRealVar>(name, name, 1.0);
198 wgtVar = out.weight.get();
199 out.finalVars.add(*out.weight);
200 }
201
203 out.errorSet.add(*wgtVar);
204 }
205
206 // Combine the error set figured out by finalizeVars and the ones passed by the user
207 if(errorSet) out.errorSet.add(*errorSet, /*silent=*/true);
208
209 return out;
210}
211
212// generating an unbinned dataset from a binned one
213std::unique_ptr<RooDataSet> makeDataSetFromDataHist(RooDataHist const &hist)
214{
215 using namespace RooFit;
216
218 const char* wgtName = wgtVarCmdArg.getString(0);
219 // Instantiate weight variable here such that we can pass it to StoreError()
221
222 RooArgSet vars{*hist.get(), wgtVar};
223
224 // We have to explicitly store the errors that are implied by the sum of weights squared.
225 auto data = std::make_unique<RooDataSet>(hist.GetName(), hist.GetTitle(), vars, wgtVarCmdArg, StoreError(wgtVar));
226 for (int i = 0; i < hist.numEntries(); ++i) {
227 data->add(*hist.get(i), hist.weight(i), std::sqrt(hist.weightSquared(i)));
228 }
229
230 return data;
231}
232
233} // namespace
234
235////////////////////////////////////////////////////////////////////////////////
236/// Construct an unbinned dataset from a RooArgSet defining the dimensions of the data space. Optionally, data
237/// can be imported at the time of construction.
238///
239/// <table>
240/// <tr><th> %RooCmdArg <th> Effect
241/// <tr><td> Import(TTree&) <td> Import contents of given TTree. Only branches of the TTree that have names
242/// corresponding to those of the RooAbsArgs that define the RooDataSet are
243/// imported.
244/// <tr><td> ImportFromFile(const char* fileName, const char* treeName) <td> Import tree with given name from file with given name.
245/// <tr><td> Import(RooAbsData&)
246/// <td> Import contents of given RooDataSet or RooDataHist. Only observables that are common with the definition of this dataset will be imported
247/// <tr><td> Index(RooCategory&) <td> Prepare import of datasets into a N+1 dimensional RooDataSet
248/// where the extra discrete dimension labels the source of the imported histogram.
249/// <tr><td> Import(const char*, RooAbsData&)
250/// <td> Import a RooDataSet or RooDataHist to be associated with the given state name of the index category
251/// specified in Index(). If the given state name is not yet defined in the index
252/// category it will be added on the fly. The import command can be specified multiple times.
253/// <tr><td> Link(const char*, RooDataSet&) <td> Link contents of supplied RooDataSet to this dataset for given index category state name.
254/// In this mode, no data is copied and the linked dataset must be remain live for the duration
255/// of this dataset. Note that link is active for both reading and writing, so modifications
256/// to the aggregate dataset will also modify its components. Link() and Import() are mutually exclusive.
257/// <tr><td> OwnLinked() <td> Take ownership of all linked datasets
258/// <tr><td> Import(std::map<string,RooAbsData*>&) <td> As above, but allows specification of many imports in a single operation
259/// <tr><td> Link(std::map<string,RooDataSet*>&) <td> As above, but allows specification of many links in a single operation
260/// <tr><td> Cut(const char*) <br>
261/// Cut(RooFormulaVar&)
262/// <td> Apply the given cut specification when importing data
263/// <tr><td> CutRange(const char*) <td> Only accept events in the observable range with the given name
264/// <tr><td> WeightVar(const char*) <br>
265/// WeightVar(const RooAbsArg&)
266/// <td> Interpret the given variable as event weight rather than as observable
267/// <tr><td> StoreError(const RooArgSet&) <td> Store symmetric error along with value for given subset of observables
268/// <tr><td> StoreAsymError(const RooArgSet&) <td> Store asymmetric error along with value for given subset of observables
269/// <tr><td> `GlobalObservables(const RooArgSet&)` <td> Define the set of global observables to be stored in this RooDataSet.
270/// A snapshot of the passed RooArgSet is stored, meaning the values wont't change unexpectedly.
271/// </table>
272///
273
275 const RooCmdArg& arg4,const RooCmdArg& arg5,const RooCmdArg& arg6,const RooCmdArg& arg7,const RooCmdArg& arg8) :
276 RooAbsData(name,title,{})
277{
279
280 // Define configuration for this method
281 RooCmdConfig pc("RooDataSet::ctor(" + std::string(GetName()) + ")");
282 pc.defineInt("ownLinked","OwnLinked",0) ;
283 pc.defineObject("impTree","ImportTree",0) ;
284 pc.defineObject("impData","ImportData",0) ;
285 pc.defineObject("indexCat","IndexCat",0) ;
286 pc.defineObject("impSliceData","ImportDataSlice",0,nullptr,true) ; // array
287 pc.defineString("impSliceState","ImportDataSlice",0,"",true) ; // array
288 pc.defineObject("lnkSliceData","LinkDataSlice",0,nullptr,true) ; // array
289 pc.defineString("lnkSliceState","LinkDataSlice",0,"",true) ; // array
290 pc.defineString("cutSpec","CutSpec",0,"") ;
291 pc.defineObject("cutVar","CutVar",0) ;
292 pc.defineString("cutRange","CutRange",0,"") ;
293 pc.defineString("wgtVarName","WeightVarName",0,"") ;
294 pc.defineInt("newWeight1","WeightVarName",0,0) ;
295 pc.defineString("fname","ImportFromFile",0,"") ;
296 pc.defineString("tname","ImportFromFile",1,"") ;
297 pc.defineObject("wgtVar","WeightVar",0) ;
298 pc.defineInt("newWeight2","WeightVar",0,0) ;
299 pc.defineObject("dummy1","ImportDataSliceMany",0) ;
300 pc.defineObject("dummy2","LinkDataSliceMany",0) ;
301 pc.defineSet("errorSet","StoreError",0) ;
302 pc.defineSet("asymErrSet","StoreAsymError",0) ;
303 pc.defineSet("glObs","GlobalObservables",0,nullptr) ;
304 pc.defineMutex("ImportTree","ImportData","ImportDataSlice","LinkDataSlice","ImportFromFile") ;
305 pc.defineMutex("CutSpec","CutVar") ;
306 pc.defineMutex("WeightVarName","WeightVar") ;
307 pc.defineDependency("ImportDataSlice","IndexCat") ;
308 pc.defineDependency("LinkDataSlice","IndexCat") ;
309 pc.defineDependency("OwnLinked","LinkDataSlice") ;
310
311
313 l.Add((TObject*)&arg1) ; l.Add((TObject*)&arg2) ;
314 l.Add((TObject*)&arg3) ; l.Add((TObject*)&arg4) ;
315 l.Add((TObject*)&arg5) ; l.Add((TObject*)&arg6) ;
316 l.Add((TObject*)&arg7) ; l.Add((TObject*)&arg8) ;
317
318 // Process & check varargs
319 pc.process(l) ;
320 if (!pc.ok(true)) {
321 const std::string errMsg = "Error in RooDataSet constructor: command argument list could not be processed";
322 coutE(InputArguments) << errMsg << std::endl;
323 throw std::invalid_argument(errMsg);
324 }
325
326 if(pc.getSet("glObs")) setGlobalObservables(*pc.getSet("glObs"));
327
328 // Extract relevant objects
329 TTree* impTree = static_cast<TTree*>(pc.getObject("impTree")) ;
330 auto impData = static_cast<RooAbsData*>(pc.getObject("impData")) ;
331 RooFormulaVar* cutVar = static_cast<RooFormulaVar*>(pc.getObject("cutVar")) ;
332 const char* cutSpec = pc.getString("cutSpec","",true) ;
333 const char* cutRange = pc.getString("cutRange","",true) ;
334 const char* wgtVarName = pc.getString("wgtVarName","",true) ;
335 RooRealVar* wgtVar = static_cast<RooRealVar*>(pc.getObject("wgtVar")) ;
336 const char* impSliceNames = pc.getString("impSliceState","",true) ;
337 const RooLinkedList& impSliceData = pc.getObjectList("impSliceData") ;
338 const char* lnkSliceNames = pc.getString("lnkSliceState","",true) ;
339 const RooLinkedList& lnkSliceData = pc.getObjectList("lnkSliceData") ;
340 RooCategory* indexCat = static_cast<RooCategory*>(pc.getObject("indexCat")) ;
341 RooArgSet* asymErrorSet = pc.getSet("asymErrSet") ;
342 const char* fname = pc.getString("fname") ;
343 const char* tname = pc.getString("tname") ;
344 Int_t ownLinked = pc.getInt("ownLinked") ;
345 Int_t newWeight = pc.getInt("newWeight1") + pc.getInt("newWeight2") ;
346
347 // Lookup name of weight variable if it was specified by object reference
348 if(wgtVar) {
349 wgtVarName = wgtVar->GetName();
350 }
351
352 auto finalVarsInfo = finalizeVars(vars,indexCat,wgtVarName,impData,impSliceData, pc.getSet("errorSet"));
353 initializeVars(finalVarsInfo.finalVars);
354 if(!finalVarsInfo.weightVarName.empty()) {
355 wgtVarName = finalVarsInfo.weightVarName.c_str();
356 }
357
358 RooArgSet* errorSet = finalVarsInfo.errorSet.empty() ? nullptr : &finalVarsInfo.errorSet;
359
360 // Case 1 --- Link multiple dataset as slices
361 if (lnkSliceNames) {
362
363 // Make import mapping if index category is specified
365 if (indexCat) {
366 char tmp[64000];
367 strlcpy(tmp, lnkSliceNames, 64000);
368 char *token = strtok(tmp, ",");
369 auto hiter = lnkSliceData.begin();
370 while (token) {
371 hmap[token] = static_cast<RooAbsData *>(*hiter);
372 token = strtok(nullptr, ",");
373 ++hiter;
374 }
375 }
376
377 appendToDir(this,true) ;
378
379 // Initialize RooDataSet with optional weight variable
380 initialize(nullptr) ;
381
383 RooCategory* icat = static_cast<RooCategory*> (indexCat ? _vars.find(indexCat->GetName()) : nullptr ) ;
384 if (!icat) {
385 throw std::string("RooDataSet::RooDataSet() ERROR in constructor, cannot find index category") ;
386 }
387 for (map<string,RooAbsData*>::iterator hiter = hmap.begin() ; hiter!=hmap.end() ; ++hiter) {
388 // Define state labels in index category (both in provided indexCat and in internal copy in dataset)
389 if (indexCat && !indexCat->hasLabel(hiter->first)) {
390 indexCat->defineType(hiter->first) ;
391 coutI(InputArguments) << "RooDataSet::ctor(" << GetName() << ") defining state \"" << hiter->first << "\" in index category " << indexCat->GetName() << std::endl ;
392 }
393 if (icat && !icat->hasLabel(hiter->first)) {
394 icat->defineType(hiter->first) ;
395 }
396 icat->setLabel(hiter->first.c_str()) ;
397 storeMap[icat->getCurrentLabel()]=hiter->second->store() ;
398
399 // Take ownership of slice if requested
400 if (ownLinked) {
401 addOwnedComponent(hiter->first.c_str(),*hiter->second) ;
402 }
403 }
404
405 // Create composite datastore
406 _dstore = std::make_unique<RooCompositeDataStore>(name,title,_vars,*icat,storeMap) ;
407
408 return;
409 }
410
411 // Create empty datastore
412 RooTreeDataStore* tstore = nullptr;
413 if (defaultStorageType==Tree) {
414 _dstore = std::make_unique<RooTreeDataStore>(name,title,_vars,wgtVarName) ;
415 tstore = static_cast<RooTreeDataStore*>(_dstore.get());
416 } else if (defaultStorageType==Vector) {
417 if (wgtVarName && newWeight) {
418 RooAbsArg* wgttmp = _vars.find(wgtVarName) ;
419 if (wgttmp) {
420 wgttmp->setAttribute("NewWeight") ;
421 }
422 }
423 _dstore = std::make_unique<RooVectorDataStore>(name,title,_vars,wgtVarName) ;
424 }
425
426
427 // Make import mapping if index category is specified
428 std::map<string,RooAbsData*> hmap ;
429 if (indexCat) {
430 auto hiter = impSliceData.begin() ;
431 for (const auto& token : ROOT::Split(impSliceNames, ",")) {
432 hmap[token] = static_cast<RooDataSet*>(*hiter);
433 ++hiter;
434 }
435 }
436
437 // process StoreError requests
438 if (errorSet) {
439 std::unique_ptr<RooArgSet> intErrorSet{_vars.selectCommon(*errorSet)};
440 intErrorSet->setAttribAll("StoreError") ;
441 for(RooAbsArg* arg : *intErrorSet) {
442 arg->attachToStore(*_dstore) ;
443 }
444 }
445 if (asymErrorSet) {
446 std::unique_ptr<RooArgSet> intAsymErrorSet{_vars.selectCommon(*asymErrorSet)};
447 intAsymErrorSet->setAttribAll("StoreAsymError") ;
448 for(RooAbsArg* arg : *intAsymErrorSet) {
449 arg->attachToStore(*_dstore) ;
450 }
451 }
452
453 appendToDir(this,true) ;
454
455 // Initialize RooDataSet with optional weight variable
457
458 // Import one or more datasets
459 std::unique_ptr<RooFormulaVar> cutVarTmp;
460
461 if (indexCat) {
462 // Case 2 --- Import multiple RooDataSets as slices
463 loadValuesFromSlices(*indexCat, hmap, cutRange, cutVar, cutSpec);
464 } else if (impData) {
465 // Case 3 --- Import RooDataSet
466 std::unique_ptr<RooDataSet> impDataSet;
467
468 // If we are importing a RooDataHist, first convert it to a RooDataSet
469 if(impData->InheritsFrom(RooDataHist::Class())) {
470 impDataSet = makeDataSetFromDataHist(static_cast<RooDataHist const &>(*impData));
471 impData = impDataSet.get();
472 }
473 if (cutSpec) {
474 cutVarTmp = std::make_unique<RooFormulaVar>(cutSpec, cutSpec, *impData->get(), /*checkVariables=*/false);
475 cutVar = cutVarTmp.get();
476 }
477 _dstore->loadValues(impData->store(), cutVar, cutRange);
478
479 } else if (impTree || (fname && strlen(fname))) {
480 // Case 4 --- Import TTree from memory / file
481 std::unique_ptr<TFile> file;
482
483 if (impTree == nullptr) {
484 file.reset(TFile::Open(fname));
485 if (!file) {
486 std::stringstream ss;
487 ss << "RooDataSet::ctor(" << GetName() << ") ERROR file '" << fname
488 << "' cannot be opened or does not exist";
489 const std::string errMsg = ss.str();
490 coutE(InputArguments) << errMsg << std::endl;
491 throw std::invalid_argument(errMsg);
492 }
493
494 file->GetObject(tname, impTree);
495 if (!impTree) {
496 std::stringstream ss;
497 ss << "RooDataSet::ctor(" << GetName() << ") ERROR file '" << fname
498 << "' does not contain a TTree named '" << tname << "'";
499 const std::string errMsg = ss.str();
500 coutE(InputArguments) << errMsg << std::endl;
501 throw std::invalid_argument(errMsg);
502 }
503 }
504
505 if (cutSpec) {
506 cutVarTmp = std::make_unique<RooFormulaVar>(cutSpec, cutSpec, _vars, /*checkVariables=*/false);
507 cutVar = cutVarTmp.get();
508 }
509
510 if (tstore) {
511 tstore->loadValues(impTree, cutVar, cutRange);
512 } else {
514 tmpstore.loadValues(impTree, cutVar, cutRange);
515 _dstore->append(tmpstore);
516 }
517 }
518}
519
520////////////////////////////////////////////////////////////////////////////////
521/// Copy constructor
522
525{
526 appendToDir(this,true) ;
527 initialize(other._wgtVar?other._wgtVar->GetName():nullptr);
529}
530
531
532////////////////////////////////////////////////////////////////////////////////
533/// Return an empty clone of this dataset. If vars is not null, only the variables in vars
534/// are added to the definition of the empty clone
535
536RooFit::OwningPtr<RooAbsData> RooDataSet::emptyClone(const char* newName, const char* newTitle, const RooArgSet* vars, const char* wgtVarName) const
537{
538 bool useOldWeight = _wgtVar && (wgtVarName == nullptr || strcmp(wgtVarName, _wgtVar->GetName()) == 0);
539
540 if(newName == nullptr) newName = GetName();
541 if(newTitle == nullptr) newTitle = GetTitle();
543
545 if(vars == nullptr) {
546 vars2.add(_vars);
547 } else {
548 for(RooAbsArg *var : *vars) {
549 // We should take the variables from the original dataset if
550 // available, such that we can query the "StoreError" and
551 // "StoreAsymError" attributes.
552 auto varInData = _vars.find(*var);
553 vars2.add(varInData ? *varInData : *var);
554 }
555 // We also need to add the weight variable of the original dataset if
556 // it's not added yet, again to query the error attributes correctly.
557 if(useOldWeight && !vars2.find(wgtVarName)) vars2.add(*_wgtVar);
558 }
559
560 RooArgSet errorSet;
562
563 for(RooAbsArg *var : vars2) {
564 if(var->getAttribute("StoreError")) errorSet.add(*var);
565 if(var->getAttribute("StoreAsymError")) asymErrorSet.add(*var);
566 }
567
568 using namespace RooFit;
569 return RooFit::makeOwningPtr<RooAbsData>(std::make_unique<RooDataSet>(
570 newName, newTitle, vars2, WeightVar(wgtVarName), StoreError(errorSet), StoreAsymError(asymErrorSet)));
571}
572
573
574
575////////////////////////////////////////////////////////////////////////////////
576/// Initialize the dataset. If wgtVarName is not null, interpret the observable
577/// with that name as event weight
578
580{
583 _wgtVar = nullptr ;
584 if (wgtVarName) {
586 if (!wgt) {
587 coutE(DataHandling) << "RooDataSet::RooDataSet(" << GetName() << "): designated weight variable "
588 << wgtVarName << " not found in set of variables, no weighting will be assigned" << std::endl ;
589 throw std::invalid_argument("RooDataSet::initialize() weight variable could not be initialised.");
590 } else if (!dynamic_cast<RooRealVar*>(wgt)) {
591 coutE(DataHandling) << "RooDataSet::RooDataSet(" << GetName() << "): designated weight variable "
592 << wgtVarName << " is not of type RooRealVar, no weighting will be assigned" << std::endl ;
593 throw std::invalid_argument("RooDataSet::initialize() weight variable could not be initialised.");
594 } else {
596 _wgtVar = static_cast<RooRealVar*>(wgt) ;
597 }
598 }
599}
600
601
602
603////////////////////////////////////////////////////////////////////////////////
604/// Implementation of RooAbsData virtual method that drives the RooAbsData::reduce() methods
605
606std::unique_ptr<RooAbsData> RooDataSet::reduceEng(const RooArgSet &varSubset, const RooFormulaVar *cutVar,
607 const char *cutRange, std::size_t nStart, std::size_t nStop) const
608{
609 checkInit();
610 RooArgSet tmp(varSubset);
611 if (_wgtVar) {
612 tmp.add(*_wgtVar);
613 }
614
615 auto createEmptyClone = [&]() { return emptyClone(GetName(), GetTitle(), &tmp); };
616
617 std::unique_ptr<RooAbsData> out{createEmptyClone()};
618
619 if (!cutRange || strchr(cutRange, ',') == nullptr) {
620 auto &ds = static_cast<RooDataSet &>(*out);
621 ds._dstore = _dstore->reduce(ds.GetName(), ds.GetTitle(), ds._vars, cutVar, cutRange, nStart, nStop);
622 ds._cachedVars.add(_dstore->cachedVars());
623 } else {
624 // Composite case: multiple ranges
625 auto tokens = ROOT::Split(cutRange, ",");
627 std::stringstream errMsg;
628 errMsg << "Error in RooAbsData::reduce! The ranges " << cutRange << " are overlapping!";
629 throw std::runtime_error(errMsg.str());
630 }
631 for (const auto &token : tokens) {
632 std::unique_ptr<RooAbsData> appendedData{createEmptyClone()};
633 auto &ds = static_cast<RooDataSet &>(*appendedData);
634 ds._dstore = _dstore->reduce(ds.GetName(), ds.GetTitle(), ds._vars, cutVar, token.c_str(), nStart, nStop);
635 ds._cachedVars.add(_dstore->cachedVars());
636 static_cast<RooDataSet &>(*out).append(ds);
637 }
638 }
639 return out;
640}
641
642
643
644////////////////////////////////////////////////////////////////////////////////
645/// Destructor
646
652
653
654
655////////////////////////////////////////////////////////////////////////////////
656/// Return binned clone of this dataset
657
659{
660 std::string title;
661 std::string name;
662 if (newName) {
663 name = newName ;
664 } else {
665 name = std::string(GetName()) + "_binned" ;
666 }
667 if (newTitle) {
668 title = newTitle ;
669 } else {
670 title = std::string(GetTitle()) + "_binned" ;
671 }
672
673 return RooFit::makeOwningPtr(std::make_unique<RooDataHist>(name,title,*get(),*this));
674}
675
676
677
678////////////////////////////////////////////////////////////////////////////////
679/// Return event weight of current event
680
681double RooDataSet::weight() const
682{
683 return store()->weight() ;
684}
685
686
687
688////////////////////////////////////////////////////////////////////////////////
689/// Return squared event weight of the current event. If this RooDataSet has no
690/// weight errors set, this will be the same as `weight() * weight()`, like
691/// expected for an unbinned dataset. When weight errors are set, it is assumed
692/// that the RooDataSet represents a weighted binned dataset and
693/// weightSquared() is the corresponding sum of weight squares for the bin.
694
696{
697 const double w = store()->weight();
698 const double e = weightError();
699 return e > 0.0 ? e * e : w * w;
700}
701
702
703////////////////////////////////////////////////////////////////////////////////
704/// \see RooAbsData::getWeightBatch().
705std::span<const double> RooDataSet::getWeightBatch(std::size_t first, std::size_t len, bool sumW2 /*=false*/) const {
706
707 std::size_t nEntries = this->numEntries(); // for the casting to std::size_t
708
709 if(first + len > nEntries) {
710 throw std::runtime_error("RooDataSet::getWeightBatch(): requested range not valid for dataset.");
711 }
712
713 std::span<const double> allWeights = _dstore->getWeightBatch(0, numEntries());
714 if(allWeights.empty()) return {};
715
716 if(!sumW2) return {&*(std::cbegin(allWeights) + first), len};
717
718 // Treat the sumW2 case with a result buffer, first reset buffer if the
719 // number of entries doesn't match with the dataset anymore
720 if(_sumW2Buffer && _sumW2Buffer->size() != nEntries) _sumW2Buffer.reset();
721
722 if (!_sumW2Buffer) {
723 _sumW2Buffer = std::make_unique<std::vector<double>>();
724 _sumW2Buffer->reserve(nEntries);
725
726 for (std::size_t i = 0; i < nEntries; ++i) {
727 get(i);
728 _sumW2Buffer->push_back(weightSquared());
729 }
730 }
731
732 return std::span<const double>(&*(_sumW2Buffer->begin() + first), len);
733}
734
735
736////////////////////////////////////////////////////////////////////////////////
737/// \copydoc RooAbsData::weightError(double&,double&,RooAbsData::ErrorType) const
738/// \param etype error type
739void RooDataSet::weightError(double& lo, double& hi, ErrorType etype) const
740{
741 store()->weightError(lo,hi,etype) ;
742}
743
744
745////////////////////////////////////////////////////////////////////////////////
746/// \copydoc RooAbsData::weightError(ErrorType)
747/// \param etype error type
749{
750 return store()->weightError(etype) ;
751}
752
753
754////////////////////////////////////////////////////////////////////////////////
755/// Return RooArgSet with coordinates of event 'index'
756
758{
760 return ret ? &_varsNoWgt : nullptr ;
761}
762
763
764////////////////////////////////////////////////////////////////////////////////
765
767{
768 return store()->sumEntries() ;
769}
770
771
772////////////////////////////////////////////////////////////////////////////////
773/// Return the sum of weights in all entries matching cutSpec (if specified)
774/// and in named range cutRange (if specified)
775
776double RooDataSet::sumEntries(const char* cutSpec, const char* cutRange) const
777{
778 // Setup RooFormulaVar for cutSpec if it is present
779 std::unique_ptr<RooFormula> select = nullptr ;
780 if (cutSpec && strlen(cutSpec) > 0) {
781 select = std::make_unique<RooFormula>("select",cutSpec,*get()) ;
782 }
783
784 // Shortcut for unweighted unselected datasets
785 if (!select && !cutRange && !isWeighted()) {
786 return numEntries() ;
787 }
788
789 // Otherwise sum the weights in the event
791 for (int i = 0 ; i<numEntries() ; i++) {
792 get(i) ;
793 if (select && select->eval()==0.) continue ;
794 if (cutRange && !_vars.allInRange(cutRange)) continue ;
795 sumw += weight();
796 }
797
798 return sumw.Sum() ;
799}
800
801
802
803
804////////////////////////////////////////////////////////////////////////////////
805/// Return true if dataset contains weighted events
806
808{
809 return store() ? store()->isWeighted() : false;
810}
811
812
813
814////////////////////////////////////////////////////////////////////////////////
815/// Returns true if histogram contains bins with entries with a non-integer weight
816
818{
819 // Return false if we have no weights
820 if (!_wgtVar) return false ;
821
822 // Now examine individual weights
823 for (int i=0 ; i<numEntries() ; i++) {
824 get(i) ;
825 if (std::abs(weight()-Int_t(weight()))>1e-10) return true ;
826 }
827 // If sum of weights is less than number of events there are negative (integer) weights
828 if (sumEntries()<numEntries()) return true ;
829
830 return false ;
831}
832
833
834
835
836////////////////////////////////////////////////////////////////////////////////
837/// Return a RooArgSet with the coordinates of the current event
838
840{
841 return &_varsNoWgt ;
842}
843
844
845
846////////////////////////////////////////////////////////////////////////////////
847/// Add a data point, with its coordinates specified in the 'data' argset, to the data set.
848/// Any variables present in 'data' but not in the dataset will be silently ignored.
849/// \param[in] data Data point.
850/// \param[in] wgt Event weight. Defaults to 1. The current value of the weight variable is
851/// ignored.
852/// \note To obtain weighted events, a variable must be designated `WeightVar` in the constructor.
853/// \param[in] wgtError Optional weight error.
854/// \note This requires including the weight variable in the set of `StoreError` variables when constructing
855/// the dataset.
856
857void RooDataSet::add(const RooArgSet& data, double wgt, double wgtError)
858{
859 checkInit() ;
860
861 const double oldW = _wgtVar ? _wgtVar->getVal() : 0.;
862
864
865 if (_wgtVar) {
866 _wgtVar->setVal(wgt) ;
867 if (wgtError!=0.) {
869 }
870 } else if ((wgt != 1. || wgtError != 0.) && _errorMsgCount < 5) {
871 ccoutE(DataHandling) << "An event weight/error was passed but no weight variable was defined"
872 << " in the dataset '" << GetName() << "'. The weight will be ignored." << std::endl;
874 }
875
877 && wgtError != 0.
878 && std::abs(wgt*wgt - wgtError)/wgtError > 1.E-15 //Exception for standard wgt^2 errors, which need not be stored.
879 && _errorMsgCount < 5 && !_wgtVar->getAttribute("StoreError")) {
880 coutE(DataHandling) << "An event weight error was passed to the RooDataSet '" << GetName()
881 << "', but the weight variable '" << _wgtVar->GetName()
882 << "' does not store errors. Check `StoreError` in the RooDataSet constructor." << std::endl;
884 }
885
886 fill();
887
888 // Restore weight state
889 if (_wgtVar) {
892 }
893}
894
895
896
897
898////////////////////////////////////////////////////////////////////////////////
899/// Add a data point, with its coordinates specified in the 'data' argset, to the data set.
900/// Any variables present in 'data' but not in the dataset will be silently ignored.
901/// \param[in] indata Data point.
902/// \param[in] inweight Event weight. The current value of the weight variable is ignored.
903/// \note To obtain weighted events, a variable must be designated `WeightVar` in the constructor.
904/// \param[in] weightErrorLo Asymmetric weight error.
905/// \param[in] weightErrorHi Asymmetric weight error.
906/// \note This requires including the weight variable in the set of `StoreAsymError` variables when constructing
907/// the dataset.
908
910{
911 checkInit() ;
912
913 const double oldW = _wgtVar ? _wgtVar->getVal() : 0.;
914
916 if (_wgtVar) {
919 } else if (inweight != 1. && _errorMsgCount < 5) {
920 ccoutE(DataHandling) << "An event weight was given but no weight variable was defined"
921 << " in the dataset '" << GetName() << "'. The weight will be ignored." << std::endl;
923 }
924
926 && _errorMsgCount < 5 && !_wgtVar->getAttribute("StoreAsymError")) {
927 coutE(DataHandling) << "An event weight error was passed to the RooDataSet '" << GetName()
928 << "', but the weight variable '" << _wgtVar->GetName()
929 << "' does not store errors. Check `StoreAsymError` in the RooDataSet constructor." << std::endl;
931 }
932
933 fill();
934
935 // Restore weight state
936 if (_wgtVar) {
939 }
940}
941
942
943
944
945
946////////////////////////////////////////////////////////////////////////////////
947/// Add a data point, with its coordinates specified in the 'data' argset, to the data set.
948/// \attention The order and type of the input variables are **assumed** to be the same as
949/// for the RooArgSet returned by RooDataSet::get(). Input values will just be written
950/// into the internal data columns by ordinal position.
951/// \param[in] data Data point.
952/// \param[in] wgt Event weight. Defaults to 1. The current value of the weight variable is
953/// ignored.
954/// \note To obtain weighted events, a variable must be designated `WeightVar` in the constructor.
955/// \param[in] wgtError Optional weight error.
956/// \note This requires including the weight variable in the set of `StoreError` variables when constructing
957/// the dataset.
958
959void RooDataSet::addFast(const RooArgSet& data, double wgt, double wgtError)
960{
961 checkInit() ;
962
963 const double oldW = _wgtVar ? _wgtVar->getVal() : 0.;
964
965 _varsNoWgt.assignFast(data,_dstore->dirtyProp());
966 if (_wgtVar) {
967 _wgtVar->setVal(wgt) ;
968 if (wgtError!=0.) {
970 }
971 } else if (wgt != 1. && _errorMsgCount < 5) {
972 ccoutE(DataHandling) << "An event weight was given but no weight variable was defined"
973 << " in the dataset '" << GetName() << "'. The weight will be ignored." << std::endl;
975 }
976
977 fill();
978
980 && wgtError != 0. && wgtError != wgt*wgt //Exception for standard weight error, which need not be stored
981 && _errorMsgCount < 5 && !_wgtVar->getAttribute("StoreError")) {
982 coutE(DataHandling) << "An event weight error was passed to the RooDataSet '" << GetName()
983 << "', but the weight variable '" << _wgtVar->GetName()
984 << "' does not store errors. Check `StoreError` in the RooDataSet constructor." << std::endl;
986 }
988 _doWeightErrorCheck = false;
989 }
990
991 if (_wgtVar) {
994 }
995}
996
997
998
999////////////////////////////////////////////////////////////////////////////////
1000
1003{
1004 checkInit() ;
1006 if (data1) dsetList.push_back(data1) ;
1007 if (data2) dsetList.push_back(data2) ;
1008 if (data3) dsetList.push_back(data3) ;
1009 if (data4) dsetList.push_back(data4) ;
1010 if (data5) dsetList.push_back(data5) ;
1011 if (data6) dsetList.push_back(data6) ;
1012 return merge(dsetList) ;
1013}
1014
1015
1016
1017////////////////////////////////////////////////////////////////////////////////
1018/// Merge columns of supplied data set(s) with this data set. All
1019/// data sets must have equal number of entries. In case of
1020/// duplicate columns the column of the last dataset in the list
1021/// prevails
1022
1024{
1025
1026 checkInit() ;
1027 // Sanity checks: data sets must have the same size
1028 for (list<RooDataSet*>::iterator iter = dsetList.begin() ; iter != dsetList.end() ; ++iter) {
1029 if (numEntries()!=(*iter)->numEntries()) {
1030 coutE(InputArguments) << "RooDataSet::merge(" << GetName() << ") ERROR: datasets have different size" << std::endl ;
1031 return true ;
1032 }
1033 }
1034
1035 // Extend vars with elements of other dataset
1037 for (list<RooDataSet*>::iterator iter = dsetList.begin() ; iter != dsetList.end() ; ++iter) {
1038 _vars.addClone((*iter)->_vars,true) ;
1039 dstoreList.push_back((*iter)->store()) ;
1040 }
1041
1042 // Merge data stores
1044 mergedStore->SetName(_dstore->GetName()) ;
1045 mergedStore->SetTitle(_dstore->GetTitle()) ;
1046
1047 // Replace current data store with merged store
1048 _dstore.reset(mergedStore);
1049
1050 initialize(_wgtVar?_wgtVar->GetName():nullptr) ;
1051 return false ;
1052}
1053
1054
1055////////////////////////////////////////////////////////////////////////////////
1056/// Add all data points of given data set to this data set.
1057/// Observable in 'data' that are not in this dataset
1058/// with not be transferred
1059
1061{
1062 checkInit() ;
1063 _dstore->append(*data._dstore) ;
1064}
1065
1066
1067
1068////////////////////////////////////////////////////////////////////////////////
1069/// Add a column with the values of the given (function) argument
1070/// to this dataset. The function value is calculated for each
1071/// event using the observable values of each event in case the
1072/// function depends on variables with names that are identical
1073/// to the observable names in the dataset
1074
1076{
1077 checkInit() ;
1078 std::unique_ptr<RooAbsArg> ret{_dstore->addColumn(var,adjustRange)};
1079 RooAbsArg* retPtr = ret.get();
1080 _vars.addOwned(std::move(ret));
1081 initialize(_wgtVar?_wgtVar->GetName():nullptr) ;
1082 return retPtr;
1083}
1084
1085
1086////////////////////////////////////////////////////////////////////////////////
1087/// Special plot method for 'X-Y' datasets used in \f$ \chi^2 \f$ fitting.
1088/// For general plotting, see RooAbsData::plotOn().
1089///
1090/// These datasets
1091/// have one observable (X) and have weights (Y) and associated errors.
1092/// <table>
1093/// <tr><th> Contents options <th> Effect
1094/// <tr><td> YVar(RooRealVar& var) <td> Designate specified observable as 'y' variable
1095/// If not specified, the event weight will be the y variable
1096/// <tr><th> Histogram drawing options <th> Effect
1097/// <tr><td> DrawOption(const char* opt) <td> Select ROOT draw option for resulting TGraph object
1098/// <tr><td> LineStyle(Int_t style) <td> Select line style by ROOT line style code, default is solid
1099/// <tr><td> LineColor(Int_t color) <td> Select line color by ROOT color code, default is black
1100/// <tr><td> LineWidth(Int_t width) <td> Select line with in pixels, default is 3
1101/// <tr><td> MarkerStyle(Int_t style) <td> Select the ROOT marker style, default is 21
1102/// <tr><td> MarkerColor(Int_t color) <td> Select the ROOT marker color, default is black
1103/// <tr><td> MarkerSize(double size) <td> Select the ROOT marker size
1104/// <tr><td> Rescale(double factor) <td> Apply global rescaling factor to histogram
1105/// <tr><th> Misc. other options <th> Effect
1106/// <tr><td> Name(const chat* name) <td> Give curve specified name in frame. Useful if curve is to be referenced later
1107/// <tr><td> Invisible(bool flag) <td> Add curve to frame, but do not display. Useful in combination AddTo()
1108/// </table>
1109
1111 const RooCmdArg& arg3, const RooCmdArg& arg4,
1112 const RooCmdArg& arg5, const RooCmdArg& arg6,
1113 const RooCmdArg& arg7, const RooCmdArg& arg8) const
1114{
1115 checkInit() ;
1116
1117 RooLinkedList argList ;
1118 argList.Add((TObject*)&arg1) ; argList.Add((TObject*)&arg2) ;
1119 argList.Add((TObject*)&arg3) ; argList.Add((TObject*)&arg4) ;
1120 argList.Add((TObject*)&arg5) ; argList.Add((TObject*)&arg6) ;
1121 argList.Add((TObject*)&arg7) ; argList.Add((TObject*)&arg8) ;
1122
1123 // Process named arguments
1124 RooCmdConfig pc("RooDataSet::plotOnXY(" + std::string(GetName()) + ")");
1125 pc.defineString("drawOption","DrawOption",0,"P") ;
1126 pc.defineString("histName","Name",0,"") ;
1127 pc.defineInt("lineColor","LineColor",0,-999) ;
1128 pc.defineInt("lineStyle","LineStyle",0,-999) ;
1129 pc.defineInt("lineWidth","LineWidth",0,-999) ;
1130 pc.defineInt("markerColor","MarkerColor",0,-999) ;
1131 pc.defineInt("markerStyle","MarkerStyle",0,8) ;
1132 pc.defineDouble("markerSize","MarkerSize",0,-999) ;
1133 pc.defineInt("fillColor","FillColor",0,-999) ;
1134 pc.defineInt("fillStyle","FillStyle",0,-999) ;
1135 pc.defineInt("histInvisible","Invisible",0,0) ;
1136 pc.defineDouble("scaleFactor","Rescale",0,1.) ;
1137 pc.defineObject("xvar","XVar",0,nullptr) ;
1138 pc.defineObject("yvar","YVar",0,nullptr) ;
1139
1140
1141 // Process & check varargs
1142 pc.process(argList) ;
1143 if (!pc.ok(true)) {
1144 return frame ;
1145 }
1146
1147 // Extract values from named arguments
1148 const char* drawOptions = pc.getString("drawOption") ;
1149 Int_t histInvisible = pc.getInt("histInvisible") ;
1150 const char* histName = pc.getString("histName",nullptr,true) ;
1151 double scaleFactor = pc.getDouble("scaleFactor") ;
1152
1153 RooRealVar* xvar = static_cast<RooRealVar*>(_vars.find(frame->getPlotVar()->GetName())) ;
1154
1155 // Determine Y variable (default is weight, if present)
1156 RooRealVar* yvar = static_cast<RooRealVar*>(pc.getObject("yvar")) ;
1157
1158 // Sanity check. XY plotting only applies to weighted datasets if no YVar is specified
1159 if (!_wgtVar && !yvar) {
1160 coutE(InputArguments) << "RooDataSet::plotOnXY(" << GetName() << ") ERROR: no YVar() argument specified and dataset is not weighted" << std::endl ;
1161 return nullptr ;
1162 }
1163
1164 RooRealVar* dataY = yvar ? static_cast<RooRealVar*>(_vars.find(yvar->GetName())) : nullptr ;
1165 if (yvar && !dataY) {
1166 coutE(InputArguments) << "RooDataSet::plotOnXY(" << GetName() << ") ERROR on YVar() argument, dataset does not contain a variable named " << yvar->GetName() << std::endl ;
1167 return nullptr ;
1168 }
1169
1170
1171 // Make RooHist representing XY contents of data
1172 RooHist* graph = new RooHist ;
1173 if (histName) {
1174 graph->SetName(histName) ;
1175 } else {
1176 graph->SetName(("hxy_" + std::string(GetName())).c_str());
1177 }
1178
1179 for (int i=0 ; i<numEntries() ; i++) {
1180 get(i) ;
1181 double x = xvar->getVal() ;
1182 double exlo = xvar->getErrorLo() ;
1183 double exhi = xvar->getErrorHi() ;
1184 double y;
1185 double eylo;
1186 double eyhi;
1187 if (!dataY) {
1188 y = weight() ;
1190 } else {
1191 y = dataY->getVal() ;
1192 eylo = dataY->getErrorLo() ;
1193 eyhi = dataY->getErrorHi() ;
1194 }
1195 graph->addBinWithXYError(x,y,-1*exlo,exhi,-1*eylo,eyhi,scaleFactor) ;
1196 }
1197
1198 // Adjust style options according to named arguments
1199 Int_t lineColor = pc.getInt("lineColor") ;
1200 Int_t lineStyle = pc.getInt("lineStyle") ;
1201 Int_t lineWidth = pc.getInt("lineWidth") ;
1202 Int_t markerColor = pc.getInt("markerColor") ;
1203 Int_t markerStyle = pc.getInt("markerStyle") ;
1204 Size_t markerSize = pc.getDouble("markerSize") ;
1205 Int_t fillColor = pc.getInt("fillColor") ;
1206 Int_t fillStyle = pc.getInt("fillStyle") ;
1207
1208 if (lineColor!=-999) graph->SetLineColor(lineColor) ;
1209 if (lineStyle!=-999) graph->SetLineStyle(lineStyle) ;
1210 if (lineWidth!=-999) graph->SetLineWidth(lineWidth) ;
1211 if (markerColor!=-999) graph->SetMarkerColor(markerColor) ;
1212 if (markerStyle!=-999) graph->SetMarkerStyle(markerStyle) ;
1213 if (markerSize!=-999) graph->SetMarkerSize(markerSize) ;
1214 if (fillColor!=-999) graph->SetFillColor(fillColor) ;
1215 if (fillStyle!=-999) graph->SetFillStyle(fillStyle) ;
1216
1217 // Add graph to frame
1218 frame->addPlotable(graph,drawOptions,histInvisible) ;
1219
1220 return frame ;
1221}
1222
1223
1224
1225
1226////////////////////////////////////////////////////////////////////////////////
1227/// Read given list of ascii files, and construct a data set, using the given
1228/// ArgList as structure definition.
1229/// \param fileList Multiple file names, comma separated. Each
1230/// file is optionally prefixed with 'commonPath' if such a path is
1231/// provided
1232///
1233/// \param varList Specify the dimensions of the dataset to be built.
1234/// This list describes the order in which these dimensions appear in the
1235/// ascii files to be read.
1236/// Each line in the ascii file should contain N white-space separated
1237/// tokens, with N the number of args in `varList`. Any text beyond
1238/// N tokens will be ignored with a warning message.
1239/// (NB: This is the default output of RooArgList::writeToStream())
1240///
1241/// \param verbOpt `Q` be quiet, `D` debug mode (verbose)
1242///
1243/// \param commonPath All filenames in `fileList` will be prefixed with this optional path.
1244///
1245/// \param indexCatName Interpret the data as belonging to category `indexCatName`.
1246/// When multiple files are read, a RooCategory arg in `varList` can
1247/// optionally be designated to hold information about the source file
1248/// of each data point. This feature is enabled by giving the name
1249/// of the (already existing) category variable in `indexCatName`.
1250///
1251/// \attention If the value of any of the variables on a given line exceeds the
1252/// fit range associated with that dimension, the entire line will be
1253/// ignored. A warning message is printed in each case, unless the
1254/// `Q` verbose option is given. The number of events read and skipped
1255/// is always summarized at the end.
1256///
1257/// If no further information is given a label name 'fileNNN' will
1258/// be assigned to each event, where NNN is the sequential number of
1259/// the source file in `fileList`.
1260///
1261/// Alternatively, it is possible to override the default label names
1262/// of the index category by specifying them in the fileList string:
1263/// When instead of `file1.txt,file2.txt` the string
1264/// `file1.txt:FOO,file2.txt:BAR` is specified, a state named "FOO"
1265/// is assigned to the index category for each event originating from
1266/// file1.txt. The labels FOO,BAR may be predefined in the index
1267/// category via defineType(), but don't have to be.
1268///
1269/// Finally, one can also assign the same label to multiple files,
1270/// either by specifying `file1.txt:FOO,file2,txt:FOO,file3.txt:BAR`
1271/// or `file1.txt,file2.txt:FOO,file3.txt:BAR`.
1272///
1273
1275 const char *verbOpt, const char* commonPath,
1276 const char* indexCatName) {
1277 // Make working copy of variables list
1278 RooArgList variables(varList) ;
1279
1280 // Append blinding state category to variable list if not already there
1281 bool ownIsBlind(true) ;
1282 RooAbsArg* blindState = variables.find("blindState") ;
1283 if (!blindState) {
1284 blindState = new RooCategory("blindState","Blinding State") ;
1285 variables.add(*blindState) ;
1286 } else {
1287 ownIsBlind = false ;
1288 if (blindState->IsA()!=RooCategory::Class()) {
1289 oocoutE(nullptr,DataHandling) << "RooDataSet::read: ERROR: variable list already contains"
1290 << "a non-RooCategory blindState member" << std::endl ;
1291 return nullptr ;
1292 }
1293 oocoutW(nullptr,DataHandling) << "RooDataSet::read: WARNING: recycling existing "
1294 << "blindState category in variable list" << std::endl ;
1295 }
1296 RooCategory* blindCat = static_cast<RooCategory*>(blindState) ;
1297
1298 // Configure blinding state category
1299 blindCat->setAttribute("Dynamic") ;
1300 blindCat->defineType("Normal",0) ;
1301 blindCat->defineType("Blind",1) ;
1302
1303 // parse the option string
1305 opts.ToLower();
1306 bool verbose= !opts.Contains("q");
1307 bool debug= opts.Contains("d");
1308
1309 auto data = std::make_unique<RooDataSet>("dataset", fileList, variables);
1310 if (ownIsBlind) { variables.remove(*blindState) ; delete blindState ; }
1311 if(!data) {
1312 oocoutE(nullptr,DataHandling) << "RooDataSet::read: unable to create a new dataset"
1313 << std::endl;
1314 return nullptr;
1315 }
1316
1317 // Redirect blindCat to point to the copy stored in the data set
1318 blindCat = static_cast<RooCategory*>(data->_vars.find("blindState")) ;
1319
1320 // Find index category, if requested
1321 RooCategory *indexCat = nullptr;
1322 //RooCategory *indexCatOrig = 0;
1323 if (indexCatName) {
1324 RooAbsArg* tmp = nullptr;
1325 tmp = data->_vars.find(indexCatName) ;
1326 if (!tmp) {
1327 oocoutE(data.get(),DataHandling) << "RooDataSet::read: no index category named "
1328 << indexCatName << " in supplied variable list" << std::endl ;
1329 return nullptr;
1330 }
1331 if (tmp->IsA()!=RooCategory::Class()) {
1332 oocoutE(data.get(),DataHandling) << "RooDataSet::read: variable " << indexCatName
1333 << " is not a RooCategory" << std::endl ;
1334 return nullptr;
1335 }
1336 indexCat = static_cast<RooCategory*>(tmp);
1337
1338 // Prevent RooArgSet from attempting to read in indexCat
1339 indexCat->setAttribute("Dynamic") ;
1340 }
1341
1342
1343 Int_t outOfRange(0) ;
1344
1345 // Loop over all names in comma separated list
1346 Int_t fileSeqNum(0);
1347 for (const auto& filename : ROOT::Split(std::string(fileList), ", ")) {
1348 // Determine index category number, if this option is active
1349 if (indexCat) {
1350
1351 // Find and detach optional file category name
1352 const char *catname = strchr(filename.c_str(),':');
1353
1354 if (catname) {
1355 // Use user category name if provided
1356 catname++ ;
1357
1358 if (indexCat->hasLabel(catname)) {
1359 // Use existing category index
1360 indexCat->setLabel(catname);
1361 } else {
1362 // Register cat name
1363 indexCat->defineType(catname,fileSeqNum) ;
1364 indexCat->setIndex(fileSeqNum) ;
1365 }
1366 } else {
1367 // Assign autogenerated name
1368 char newLabel[128] ;
1369 snprintf(newLabel,128,"file%03d",fileSeqNum) ;
1370 if (indexCat->defineType(newLabel,fileSeqNum)) {
1371 oocoutE(data.get(), DataHandling) << "RooDataSet::read: Error, cannot register automatic type name " << newLabel
1372 << " in index category " << indexCat->GetName() << std::endl ;
1373 return nullptr ;
1374 }
1375 // Assign new category number
1376 indexCat->setIndex(fileSeqNum) ;
1377 }
1378 }
1379
1380 oocoutI(data.get(), DataHandling) << "RooDataSet::read: reading file " << filename << std::endl ;
1381
1382 // Prefix common path
1384 fullName.Append(filename) ;
1385 ifstream file(fullName) ;
1386
1387 if (!file.good()) {
1388 oocoutE(data.get(), DataHandling) << "RooDataSet::read: unable to open '"
1389 << filename << "'. Returning nullptr now." << std::endl;
1390 return nullptr;
1391 }
1392
1393 // double value;
1394 Int_t line(0) ;
1395 bool haveBlindString(false) ;
1396
1397 while(file.good() && !file.eof()) {
1398 line++;
1399 if(debug) oocxcoutD(data.get(),DataHandling) << "reading line " << line << std::endl;
1400
1401 // process comment lines
1402 if (file.peek() == '#') {
1403 if(debug) oocxcoutD(data.get(),DataHandling) << "skipping comment on line " << line << std::endl;
1404 } else {
1405 // Read single line
1406 bool readError = variables.readFromStream(file,true,verbose) ;
1407 data->_vars.assign(variables) ;
1408
1409 // Stop on read error
1410 if(!file.good()) {
1411 oocoutE(data.get(), DataHandling) << "RooDataSet::read(static): read error at line " << line << std::endl ;
1412 break;
1413 }
1414
1415 if (readError) {
1416 outOfRange++ ;
1417 } else {
1418 blindCat->setIndex(haveBlindString) ;
1419 data->fill(); // store this event
1420 }
1421 }
1422
1423 // Skip all white space (including empty lines).
1424 while (isspace(file.peek())) {
1425 char dummy;
1426 file >> std::noskipws >> dummy >> std::skipws;
1427 }
1428 }
1429
1430 file.close();
1431
1432 // get next file name
1433 fileSeqNum++ ;
1434 }
1435
1436 if (indexCat) {
1437 // Copy dynamically defined types from new data set to indexCat in original list
1438 assert(dynamic_cast<RooCategory*>(variables.find(indexCatName)));
1439 const auto origIndexCat = static_cast<RooCategory*>(variables.find(indexCatName));
1440 for (const auto& nameIdx : *indexCat) {
1441 origIndexCat->defineType(nameIdx.first, nameIdx.second);
1442 }
1443 }
1444 oocoutI(data.get(),DataHandling) << "RooDataSet::read: read " << data->numEntries()
1445 << " events (ignored " << outOfRange << " out of range events)" << std::endl;
1446
1447 return data.release();
1448}
1449
1450
1451
1452
1453////////////////////////////////////////////////////////////////////////////////
1454/// Write the contents of this dataset to an ASCII file with the specified name.
1455/// Each event will be written as a single line containing the written values
1456/// of each observable in the order they were declared in the dataset and
1457/// separated by whitespaces
1458
1459bool RooDataSet::write(const char* filename) const
1460{
1461 // Open file for writing
1462 ofstream ofs(filename) ;
1463 if (ofs.fail()) {
1464 coutE(DataHandling) << "RooDataSet::write(" << GetName() << ") cannot create file " << filename << std::endl ;
1465 return true ;
1466 }
1467
1468 // Write all lines as arglist in compact mode
1469 coutI(DataHandling) << "RooDataSet::write(" << GetName() << ") writing ASCII file " << filename << std::endl ;
1470 return write(ofs);
1471}
1472
1473////////////////////////////////////////////////////////////////////////////////
1474/// Write the contents of this dataset to the stream.
1475/// Each event will be written as a single line containing the written values
1476/// of each observable in the order they were declared in the dataset and
1477/// separated by whitespaces
1478
1479bool RooDataSet::write(ostream & ofs) const {
1480 checkInit();
1481
1482 for (Int_t i=0; i<numEntries(); ++i) {
1483 get(i)->writeToStream(ofs,true);
1484 }
1485
1486 if (ofs.fail()) {
1487 coutW(DataHandling) << "RooDataSet::write(" << GetName() << "): WARNING error(s) have occurred in writing" << std::endl ;
1488 }
1489
1490 return ofs.fail() ;
1491}
1492
1493
1494////////////////////////////////////////////////////////////////////////////////
1495/// Print info about this dataset to the specified output stream.
1496///
1497/// Standard: number of entries
1498/// Shape: list of variables we define & were generated with
1499
1500void RooDataSet::printMultiline(ostream& os, Int_t contents, bool verbose, TString indent) const
1501{
1502 checkInit() ;
1503 RooAbsData::printMultiline(os,contents,verbose,indent) ;
1504 if (_wgtVar) {
1505 os << indent << " Dataset variable \"" << _wgtVar->GetName() << "\" is interpreted as the event weight" << std::endl ;
1506 }
1507}
1508
1509
1510////////////////////////////////////////////////////////////////////////////////
1511/// Print value of the dataset, i.e. the sum of weights contained in the dataset
1512
1513void RooDataSet::printValue(ostream& os) const
1514{
1515 os << numEntries() << " entries" ;
1516 if (isWeighted()) {
1517 os << " (" << sumEntries() << " weighted)" ;
1518 }
1519}
1520
1521
1522
1523////////////////////////////////////////////////////////////////////////////////
1524/// Print argument of dataset, i.e. the observable names
1525
1526void RooDataSet::printArgs(ostream& os) const
1527{
1528 os << "[" ;
1529 bool first(true) ;
1530 for(RooAbsArg* arg : _varsNoWgt) {
1531 if (first) {
1532 first=false ;
1533 } else {
1534 os << "," ;
1535 }
1536 os << arg->GetName() ;
1537 }
1538 if (_wgtVar) {
1539 os << ",weight:" << _wgtVar->GetName() ;
1540 }
1541 os << "]" ;
1542}
1543
1544
1545
1546////////////////////////////////////////////////////////////////////////////////
1547/// Change the name of this dataset into the given name
1548
1549void RooDataSet::SetName(const char *name)
1550{
1551 if (_dir) _dir->GetList()->Remove(this);
1552 // We need to use the function from RooAbsData, because it already overrides TNamed::SetName
1554 if (_dir) _dir->GetList()->Add(this);
1555}
1556
1557
1558////////////////////////////////////////////////////////////////////////////////
1559/// Change the title of this dataset into the given name
1560
1561void RooDataSet::SetNameTitle(const char *name, const char* title)
1562{
1563 SetName(name);
1564 SetTitle(title);
1565}
1566
1567
1568////////////////////////////////////////////////////////////////////////////////
1569/// Stream an object of class RooDataSet.
1570
1572{
1573 if (R__b.IsReading()) {
1574
1575 UInt_t R__s;
1576 UInt_t R__c;
1577 Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
1578
1579 if (R__v > 1) {
1580
1581 // Use new-style streaming for version >1
1582 R__b.ReadClassBuffer(RooDataSet::Class(), this, R__v, R__s, R__c);
1583
1584 } else {
1585
1586 // Legacy dataset conversion happens here. Legacy RooDataSet inherits from RooTreeData
1587 // which in turn inherits from RooAbsData. Manually stream RooTreeData contents on
1588 // file here and convert it into a RooTreeDataStore which is installed in the
1589 // new-style RooAbsData base class
1590
1591 // --- This is the contents of the streamer code of RooTreeData version 1 ---
1592 UInt_t R__s1;
1593 UInt_t R__c1;
1594 Version_t R__v1 = R__b.ReadVersion(&R__s1, &R__c1);
1595 if (R__v1) {
1596 }
1597
1599 TTree *X_tree(nullptr);
1600 R__b >> X_tree;
1602 X_truth.Streamer(R__b);
1604 X_blindString.Streamer(R__b);
1605 R__b.CheckByteCount(R__s1, R__c1, TClass::GetClass("RooTreeData"));
1606 // --- End of RooTreeData-v1 streamer
1607
1608 // Construct RooTreeDataStore from X_tree and complete initialization of new-style RooAbsData
1609 _dstore = std::make_unique<RooTreeDataStore>(X_tree, _vars);
1610 _dstore->SetName(GetName());
1611 _dstore->SetTitle(GetTitle());
1612 _dstore->checkInit();
1613
1614 // This is the contents of the streamer code of RooDataSet version 1
1617 R__b >> _wgtVar;
1618 R__b.CheckByteCount(R__s, R__c, RooDataSet::IsA());
1619 }
1620 } else {
1621 R__b.WriteClassBuffer(RooDataSet::Class(), this);
1622 }
1623}
1624
1625
1626
1627////////////////////////////////////////////////////////////////////////////////
1628/// Convert vector-based storage to tree-based storage. This implementation overrides the base class
1629/// implementation because the latter doesn't transfer weights.
1631{
1633 _dstore = std::make_unique<RooTreeDataStore>(GetName(), GetTitle(), _vars, *_dstore, nullptr, _wgtVar ? _wgtVar->GetName() : nullptr);
1635 }
1636}
1637
1638
1639namespace {
1640
1641 // Compile-time test if we can still use TStrings for the constructors of
1642 // RooDataClasses, either for both name and title or for only one of them.
1643 TString tstr = "tstr";
1644 const char * cstr = "cstr";
1645 RooRealVar x{"x", "x", 1.0};
1646 RooArgSet vars{x};
1647 RooDataSet d1(tstr, tstr, vars);
1648 RooDataSet d2(tstr, cstr, vars);
1649 RooDataSet d3(cstr, tstr, vars);
1650
1651} // namespace
1652
1653
1654void RooDataSet::loadValuesFromSlices(RooCategory &indexCat, std::map<std::string, RooAbsData *> const &slices,
1655 const char *rangeName, RooFormulaVar const *cutVar, const char *cutSpec)
1656{
1657
1658 if (cutVar && cutSpec) {
1659 throw std::invalid_argument("Only one of cutVar or cutSpec should be not a nullptr!");
1660 }
1661
1662 auto &indexCatInData = *static_cast<RooCategory *>(_vars.find(indexCat.GetName()));
1663
1664 for (auto const &item : slices) {
1665 std::unique_ptr<RooDataSet> sliceDataSet;
1666 RooAbsData* sliceData = item.second;
1667
1668 // If we are importing a RooDataHist, first convert it to a RooDataSet
1669 if(sliceData->InheritsFrom(RooDataHist::Class())) {
1671 sliceData = sliceDataSet.get();
1672 }
1673
1674 // Define state labels in index category (both in provided indexCat and in internal copy in dataset)
1675 if (!indexCat.hasLabel(item.first)) {
1676 indexCat.defineType(item.first);
1677 coutI(InputArguments) << "RooDataSet::ctor(" << GetName() << ") defining state \"" << item.first
1678 << "\" in index category " << indexCat.GetName() << std::endl;
1679 }
1680 if (!indexCatInData.hasLabel(item.first)) {
1681 indexCatInData.defineType(item.first);
1682 }
1683 indexCatInData.setLabel(item.first.c_str());
1684 std::unique_ptr<RooFormulaVar> cutVarTmp;
1685 if (cutSpec) {
1686 cutVarTmp = std::make_unique<RooFormulaVar>(cutSpec, cutSpec, *sliceData->get(), /*checkVariables=*/false);
1687 cutVar = cutVarTmp.get();
1688 }
1689 _dstore->loadValues(sliceData->store(), cutVar, rangeName);
1690 }
1691}
#define e(i)
Definition RSha256.hxx:103
ROOT::RRangeCast< T, false, Range_t > static_range_cast(Range_t &&coll)
#define coutI(a)
#define ccoutE(a)
#define oocoutW(o, a)
#define oocxcoutD(o, a)
#define coutW(a)
#define oocoutE(o, a)
#define oocoutI(o, a)
#define coutE(a)
#define TRACE_DESTROY
Definition RooTrace.h:24
#define TRACE_CREATE
Definition RooTrace.h:23
int Int_t
Signed integer 4 bytes (int)
Definition RtypesCore.h:59
float Size_t
Attribute size (float)
Definition RtypesCore.h:103
short Version_t
Class version identifier (short)
Definition RtypesCore.h:79
static void indent(ostringstream &buf, int indent_level)
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char filename
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t index
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t UChar_t len
char name[80]
Definition TGX11.cxx:110
#define hi
#define snprintf
Definition civetweb.c:1579
The Kahan summation is a compensated summation algorithm, which significantly reduces numerical error...
Definition Util.h:136
const_iterator begin() const
const_iterator end() const
Common abstract base class for objects that represent a value and a "shape" in RooFit.
Definition RooAbsArg.h:76
void setAttribute(const Text_t *name, bool value=true)
Set (default) or clear a named boolean attribute of this object.
bool hasLabel(const std::string &label) const
Check if a state with name label exists.
virtual void removeAll()
Remove all arguments from our set, deleting them if we own them.
virtual bool remove(const RooAbsArg &var, bool silent=false, bool matchByNameOnly=false)
Remove the specified argument from our list.
bool allInRange(const char *rangeSpec) const
Return true if all contained object report to have their value inside the specified range.
void assignFast(const RooAbsCollection &other, bool setValDirty=true) const
Functional equivalent of assign() but assumes this and other collection have same layout.
virtual bool add(const RooAbsArg &var, bool silent=false)
Add the specified argument to list.
void assign(const RooAbsCollection &other) const
Sets the value, cache and constant attribute of any argument in our set that also appears in the othe...
virtual bool addOwned(RooAbsArg &var, bool silent=false)
Add an argument and transfer the ownership to the collection.
virtual RooAbsArg * addClone(const RooAbsArg &var, bool silent=false)
Add a clone of the specified argument to list.
RooAbsArg * find(const char *name) const
Find object with given name in list.
Abstract base class for a data collection.
virtual bool isWeighted() const =0
virtual double sumEntries() const
virtual double weightError(RooAbsData::ErrorType etype=RooAbsData::Poisson) const =0
virtual double weight() const =0
Abstract base class for binned and unbinned datasets.
Definition RooAbsData.h:57
virtual const RooArgSet * get() const
Definition RooAbsData.h:101
void printMultiline(std::ostream &os, Int_t contents, bool verbose=false, TString indent="") const override
Interface for detailed printing of object.
void SetName(const char *name) override
Set the name of the TNamed.
RooAbsDataStore * store()
Definition RooAbsData.h:77
void checkInit() const
std::unique_ptr< RooAbsDataStore > _dstore
Data storage implementation.
Definition RooAbsData.h:353
virtual void fill()
RooArgSet _vars
Dimensions of this data set.
Definition RooAbsData.h:350
virtual Int_t numEntries() const
Return number of entries in dataset, i.e., count unweighted entries.
StorageType storageType
Definition RooAbsData.h:316
void Streamer(TBuffer &) override
Stream an object of class RooAbsData.
double getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
Definition RooAbsReal.h:107
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:24
void Streamer(TBuffer &) override
Stream an object of class TObject.
Object to represent discrete states.
Definition RooCategory.h:28
bool setIndex(Int_t index, bool printError=true) override
Set value by specifying the index code of the desired state.
bool defineType(const std::string &label)
Define a state with given name.
bool setLabel(const char *label, bool printError=true) override
Set value by specifying the name of the desired state.
static TClass * Class()
Named container for two doubles, two integers two object points and three string pointers that can be...
Definition RooCmdArg.h:26
const char * getString(Int_t idx) const
Return string stored in slot idx.
Definition RooCmdArg.h:96
Configurable parser for RooCmdArg named arguments.
bool process(const RooCmdArg &arg)
Process given RooCmdArg.
double getDouble(const char *name, double defaultValue=0.0) const
Return double property registered with name 'name'.
bool defineDouble(const char *name, const char *argName, int doubleNum, double defValue=0.0)
Define double property name 'name' mapped to double in slot 'doubleNum' in RooCmdArg with name argNam...
bool ok(bool verbose) const
Return true of parsing was successful.
bool defineObject(const char *name, const char *argName, int setNum, const TObject *obj=nullptr, bool isArray=false)
Define TObject property name 'name' mapped to object in slot 'setNum' in RooCmdArg with name argName ...
const char * getString(const char *name, const char *defaultValue="", bool convEmptyToNull=false) const
Return string property registered with name 'name'.
bool defineString(const char *name, const char *argName, int stringNum, const char *defValue="", bool appendMode=false)
Define double property name 'name' mapped to double in slot 'stringNum' in RooCmdArg with name argNam...
bool defineInt(const char *name, const char *argName, int intNum, int defValue=0)
Define integer property name 'name' mapped to integer in slot 'intNum' in RooCmdArg with name argName...
int getInt(const char *name, int defaultValue=0) const
Return integer property registered with name 'name'.
TObject * getObject(const char *name, TObject *obj=nullptr) const
Return TObject property registered with name 'name'.
Container class to hold N-dimensional binned data.
Definition RooDataHist.h:40
static TClass * Class()
double weight(std::size_t i) const
Return weight of i-th bin.
double weightSquared(std::size_t i) const
Return squared weight sum of i-th bin.
const RooArgSet * get() const override
Get bin centre of current bin.
Definition RooDataHist.h:82
Container class to hold unbinned data.
Definition RooDataSet.h:32
RooFit::OwningPtr< RooAbsData > emptyClone(const char *newName=nullptr, const char *newTitle=nullptr, const RooArgSet *vars=nullptr, const char *wgtVarName=nullptr) const override
Return an empty clone of this dataset.
RooRealVar * _wgtVar
Pointer to weight variable (if set)
Definition RooDataSet.h:123
bool _doWeightErrorCheck
! When adding events with weights, check that weights can actually be stored.
Definition RooDataSet.h:131
static void cleanup()
RooArgSet _varsNoWgt
Vars without weight variable.
Definition RooDataSet.h:122
void loadValuesFromSlices(RooCategory &indexCat, std::map< std::string, RooAbsData * > const &slices, const char *rangeName, RooFormulaVar const *cutVar, const char *cutSpec)
RooFit::OwningPtr< RooDataHist > binnedClone(const char *newName=nullptr, const char *newTitle=nullptr) const
Return binned clone of this dataset.
void weightError(double &lo, double &hi, ErrorType etype=SumW2) const override
Return the asymmetric errors on the current weight.
const RooArgSet * get() const override
Return a RooArgSet with the coordinates of the current event.
virtual RooPlot * plotOnXY(RooPlot *frame, const RooCmdArg &arg1={}, const RooCmdArg &arg2={}, const RooCmdArg &arg3={}, const RooCmdArg &arg4={}, const RooCmdArg &arg5={}, const RooCmdArg &arg6={}, const RooCmdArg &arg7={}, const RooCmdArg &arg8={}) const
Special plot method for 'X-Y' datasets used in fitting.
void initialize(const char *wgtVarName)
Initialize the dataset.
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 void addFast(const RooArgSet &row, double weight=1.0, double weightError=0.0)
Add a data point, with its coordinates specified in the 'data' argset, to the data set.
bool merge(RooDataSet *data1, RooDataSet *data2=nullptr, RooDataSet *data3=nullptr, RooDataSet *data4=nullptr, RooDataSet *data5=nullptr, RooDataSet *data6=nullptr)
TClass * IsA() const override
Definition RooDataSet.h:135
virtual RooAbsArg * addColumn(RooAbsArg &var, bool adjustRange=true)
Add a column with the values of the given (function) argument to this dataset.
bool write(const char *filename) const
Write the contents of this dataset to an ASCII file with the specified name.
double sumEntries() const override
Return effective number of entries in dataset, i.e., sum all weights.
std::span< const double > getWeightBatch(std::size_t first, std::size_t len, bool sumW2) const override
~RooDataSet() override
Destructor.
bool isNonPoissonWeighted() const override
Returns true if histogram contains bins with entries with a non-integer weight.
void SetNameTitle(const char *name, const char *title) override
Change the title of this dataset into the given name.
void printValue(std::ostream &os) const override
Print value of the dataset, i.e. the sum of weights contained in the dataset.
void append(RooDataSet &data)
Add all data points of given data set to this data set.
RooDataSet()
Default constructor for persistence.
std::unique_ptr< std::vector< double > > _sumW2Buffer
! Buffer for sumW2 in case a batch of values is requested.
Definition RooDataSet.h:133
void Streamer(TBuffer &) override
Stream an object of class RooDataSet.
void add(const RooArgSet &row, double weight, double weightError)
Add one ore more rows of data.
unsigned short _errorMsgCount
! Counter to silence error messages when filling dataset.
Definition RooDataSet.h:130
static TClass * Class()
std::unique_ptr< RooAbsData > reduceEng(const RooArgSet &varSubset, const RooFormulaVar *cutVar, const char *cutRange=nullptr, std::size_t nStart=0, std::size_t nStop=std::numeric_limits< std::size_t >::max()) const override
Implementation of RooAbsData virtual method that drives the RooAbsData::reduce() methods.
void convertToTreeStore() override
Convert vector-based storage to tree-based storage.
void printMultiline(std::ostream &os, Int_t contents, bool verbose=false, TString indent="") const override
Print info about this dataset to the specified output stream.
double weightSquared() const override
Return squared event weight of the current event.
double weight() const override
Return event weight of current event.
static RooDataSet * read(const char *filename, const RooArgList &variables, const char *opts="", const char *commonPath="", const char *indexCatName=nullptr)
Read data from a text file and create a dataset from it.
bool isWeighted() const override
Return true if dataset contains weighted events.
Utility base class for RooFit objects that are to be attached to ROOT directories.
Definition RooDirItem.h:22
virtual void Streamer(TBuffer &)
void removeFromDir(TObject *obj)
Remove object from directory it was added to.
TDirectory * _dir
! Associated directory
Definition RooDirItem.h:33
void appendToDir(TObject *obj, bool forceMemoryResident=false)
Append object to directory.
A RooFormulaVar is a generic implementation of a real-valued object, which takes a RooArgList of serv...
Graphical representation of binned data based on the TGraphAsymmErrors class.
Definition RooHist.h:29
void addBinWithXYError(Axis_t binCenter, double n, double exlow, double exhigh, double eylow, double eyhigh, double scaleFactor=1.0)
Add a bin to this histogram with the specified bin contents and error.
Definition RooHist.cxx:497
Collection class for internal use, storing a collection of RooAbsArg pointers in a doubly linked list...
virtual void Add(TObject *arg)
Plot frame and a container for graphics objects within that frame.
Definition RooPlot.h:43
RooAbsRealLValue * getPlotVar() const
Definition RooPlot.h:137
void addPlotable(RooPlotable *plotable, Option_t *drawOptions="", bool invisible=false, bool refreshNorm=false)
Add the specified plotable object to our plot.
Definition RooPlot.cxx:475
Variable that can be changed from the outside.
Definition RooRealVar.h:37
void setVal(double value) override
Set value of variable to 'value'.
void setError(double value)
Definition RooRealVar.h:61
void removeAsymError()
Definition RooRealVar.h:66
void setAsymError(double lo, double hi)
Definition RooRealVar.h:67
void removeError()
Definition RooRealVar.h:62
The RooStringView is a wrapper around a C-style string that can also be constructed from a std::strin...
TTree-backed data storage.
virtual void SetFillColor(Color_t fcolor)
Set the fill area color.
Definition TAttFill.h:38
virtual void SetFillStyle(Style_t fstyle)
Set the fill area style.
Definition TAttFill.h:40
virtual void SetLineStyle(Style_t lstyle)
Set the line style.
Definition TAttLine.h:44
virtual void SetLineWidth(Width_t lwidth)
Set the line width.
Definition TAttLine.h:45
virtual void SetLineColor(Color_t lcolor)
Set the line color.
Definition TAttLine.h:42
virtual void SetMarkerColor(Color_t mcolor=1)
Set the marker color.
Definition TAttMarker.h:39
virtual void SetMarkerStyle(Style_t mstyle=1)
Set the marker style.
Definition TAttMarker.h:41
virtual void SetMarkerSize(Size_t msize=1)
Set the marker size.
Definition TAttMarker.h:46
Buffer base class used for serializing objects.
Definition TBuffer.h:43
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:2974
virtual TList * GetList() const
Definition TDirectory.h:223
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:3765
void SetName(const char *name="") override
Set graph name.
Definition TGraph.cxx:2330
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition TNamed.cxx:174
const char * GetName() const override
Returns name of object.
Definition TNamed.h:49
const char * GetTitle() const override
Returns title of object.
Definition TNamed.h:50
Mother of all ROOT objects.
Definition TObject.h:41
Basic string class.
Definition TString.h:138
A TTree represents a columnar dataset.
Definition TTree.h:89
TLine * line
RooCmdArg StoreError(const RooArgSet &aset)
RooCmdArg WeightVar(const char *name="weight", bool reinterpretAsWeight=false)
Double_t y[n]
Definition legend1.C:17
Double_t x[n]
Definition legend1.C:17
Namespace for new ROOT classes and functions.
std::vector< std::string > Split(std::string_view str, std::string_view delims, bool skipEmpty=false)
Splits a string at each character in delims.
The namespace RooFit contains mostly switches that change the behaviour of functions of PDFs (or othe...
Definition CodegenImpl.h:67
T * OwningPtr
An alias for raw pointers for indicating that the return type of a RooFit function is an owning point...
Definition Config.h:35
OwningPtr< T > makeOwningPtr(std::unique_ptr< T > &&ptr)
Internal helper to turn a std::unique_ptr<T> into an OwningPtr.
Definition Config.h:40
bool checkIfRangesOverlap(RooArgSet const &observables, std::vector< std::string > const &rangeNames)
void initialize(typename Architecture_t::Matrix_t &A, EInitialization m)
Definition Functions.h:282
TLine l
Definition textangle.C:4