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