Logo ROOT  
Reference Guide
RooDataHist.h
Go to the documentation of this file.
1/*****************************************************************************
2 * Project: RooFit *
3 * Package: RooFitCore *
4 * File: $Id: RooDataHist.h,v 1.37 2007/05/11 09:11:30 verkerke Exp $
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#ifndef ROO_DATA_HIST
17#define ROO_DATA_HIST
18
19#include "RooAbsData.h"
20#include "RooDirItem.h"
21#include "RooArgSet.h"
22
23#include <map>
24#include <vector>
25#include <string>
26#include <functional>
27#include <memory>
28#include <unordered_map>
29
30class TAxis ;
31class TObject ;
32class RooAbsArg;
33class RooCategory ;
34class RooPlot;
35class RooAbsLValue ;
36
37class RooDataHist : public RooAbsData, public RooDirItem {
38public:
39
40 // Constructors, factory methods etc.
41 RooDataHist() ;
42 RooDataHist(const char *name, const char *title, const RooArgSet& vars, const char* binningName=0) ;
43 RooDataHist(const char *name, const char *title, const RooArgSet& vars, const RooAbsData& data, Double_t initWgt=1.0) ;
44 RooDataHist(const char *name, const char *title, const RooArgList& vars, const TH1* hist, Double_t initWgt=1.0) ;
45 RooDataHist(const char *name, const char *title, const RooArgList& vars, RooCategory& indexCat, std::map<std::string,TH1*> histMap, Double_t initWgt=1.0) ;
46 RooDataHist(const char *name, const char *title, const RooArgList& vars, RooCategory& indexCat, std::map<std::string,RooDataHist*> dhistMap, Double_t wgt=1.0) ;
47 //RooDataHist(const char *name, const char *title, const RooArgList& vars, Double_t initWgt=1.0) ;
48 RooDataHist(const char *name, const char *title, const RooArgList& vars, const RooCmdArg& arg1, const RooCmdArg& arg2=RooCmdArg(), const RooCmdArg& arg3=RooCmdArg(),
49 const RooCmdArg& arg4=RooCmdArg(),const RooCmdArg& arg5=RooCmdArg(),const RooCmdArg& arg6=RooCmdArg(),const RooCmdArg& arg7=RooCmdArg(),const RooCmdArg& arg8=RooCmdArg()) ;
51
52 RooDataHist(const RooDataHist& other, const char* newname = 0) ;
53 TObject* Clone(const char* newname="") const override {
54 return new RooDataHist(*this, newname && newname[0] != '\0' ? newname : GetName());
55 }
56 ~RooDataHist() override ;
57
58 /// Return empty clone of this RooDataHist.
59 RooAbsData* emptyClone(const char* newName=0, const char* newTitle=0, const RooArgSet*vars=0, const char* /*wgtVarName*/=0) const override {
60 return new RooDataHist(newName?newName:GetName(),newTitle?newTitle:GetTitle(),vars?*vars:*get()) ;
61 }
62
63 /// Add `wgt` to the bin content enclosed by the coordinates passed in `row`.
64 virtual void add(const RooArgSet& row, Double_t wgt=1.0) { add(row,wgt,-1.); }
65 void add(const RooArgSet& row, Double_t weight, Double_t sumw2) override ;
66 void set(std::size_t binNumber, double weight, double wgtErr);
67 void set(const RooArgSet& row, Double_t weight, Double_t wgtErr=-1.) ;
68 void set(const RooArgSet& row, Double_t weight, Double_t wgtErrLo, Double_t wgtErrHi) ;
69
70 void add(const RooAbsData& dset, const RooFormulaVar* cutVar=0, Double_t weight=1.0 ) ;
71 void add(const RooAbsData& dset, const char* cut, Double_t weight=1.0 ) ;
72
73 /// Get bin centre of current bin.
74 const RooArgSet* get() const override { return &_vars; }
75 const RooArgSet* get(Int_t binNumber) const override;
76 virtual const RooArgSet* get(const RooArgSet& coord) const;
77 Int_t numEntries() const override;
78 Double_t sumEntries() const override;
79 Double_t sumEntries(const char* cutSpec, const char* cutRange=0) const override;
80
81 /// Always returns true as all histograms use event weights.
82 Bool_t isWeighted() const override { return true; }
83 Bool_t isNonPoissonWeighted() const override ;
84
85 RooSpan<const double> getWeightBatch(std::size_t first, std::size_t len) const override;
86 void getBatches(RooBatchCompute::RunContext& evalData, std::size_t begin, std::size_t len) const override;
87
88 Double_t sum(bool correctForBinSize, bool inverseCorr=false) const ;
89 Double_t sum(const RooArgSet& sumSet, const RooArgSet& sliceSet, bool correctForBinSize, bool inverseCorr=false) ;
90 Double_t sum(const RooArgSet& sumSet,
91 const RooArgSet& sliceSet,
92 bool correctForBinSize,
93 bool inverseCorr,
94 const std::map<const RooAbsArg*, std::pair<double, double> >& ranges,
95 std::function<double(int)> getBinScale = [](int){ return 1.0; } );
96
97 /// Return weight of i-th bin. \see getIndex()
98 double weight(std::size_t i) const { return _wgt[i]; }
99 Double_t weight(const RooArgSet& bin, Int_t intOrder=1, Bool_t correctForBinSize=kFALSE, Bool_t cdfBoundaries=kFALSE, Bool_t oneSafe=kFALSE);
100 /// Return squared weight sum of i-th bin. \see getIndex()
101 double weightSquared(std::size_t i) const { return get_sumw2(i); }
102 /// Return bin volume of i-th bin. \see getIndex()
103 double binVolume(std::size_t i) const { return _binv[i]; }
104 double binVolume(const RooArgSet& bin) const;
105 /// Return true if bin `i` is considered valid within the current range definitions of all observables. \see getIndex()
106 bool valid(std::size_t i) const { return i <= static_cast<std::size_t>(_arrSize) && (_maskedWeights.empty() || _maskedWeights[i] != 0.);}
107
108 TIterator* sliceIterator(RooAbsArg& sliceArg, const RooArgSet& otherArgs) ;
109
110 void weightError(Double_t& lo, Double_t& hi, ErrorType etype=Poisson) const override;
111 /// Return the error of the weight of the last-retrieved entry. See also weightError(Double_t&,Double_t&,ErrorType) const.
112 Double_t weightError(ErrorType etype=Poisson) const override {
113 // Return symmetric error on current bin calculated either from Poisson statistics or from SumOfWeights
114 Double_t lo,hi ;
115 weightError(lo,hi,etype) ;
116 return (lo+hi)/2 ;
117 }
118
119 using RooAbsData::plotOn ;
120 RooPlot *plotOn(RooPlot *frame, PlotOpt o) const override;
121
122 void reset() override;
123
124 virtual void printMultiline(std::ostream& os, Int_t content, Bool_t verbose=kFALSE, TString indent="") const override;
125 virtual void printArgs(std::ostream& os) const override;
126 virtual void printValue(std::ostream& os) const override;
127
128 void SetName(const char *name) override;
129 void SetNameTitle(const char *name, const char* title) override;
130
131 Int_t getIndex(const RooArgSet& coord, Bool_t fast = false) const;
132
134
135 // A shortcut function only for RooAbsOptTestStatistic.
136 void cacheValidEntries();
137
138
139 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
140 /// @name Deprecated functions
141 /// These functions rely on the fact that an event has been loaded before they are called. It is advised
142 /// to switch to their counterparts that take bin numbers as arguments. In this way, code like,
143 /// ```
144 /// const RooArgSet* coordinates = dataHist.get(i); // Need this to achieve side effect on next call of weight() - bad.
145 /// const double weight = dataHist.weight();
146 /// processEvent(coordinates, weight);
147 /// ```
148 /// becomes
149 /// ```
150 /// processEvent(dataHist.get(i), dataHist.weight(i));
151 /// ```
152 /// The index of a set of coordinates can be computed using getIndex().
153 /// @{
154
155 /// Return weight of last bin that was requested with get().
156 /// \deprecated Use the safer weight(std::size_t) const.
157 Double_t weight() const override
158 R__SUGGEST_ALTERNATIVE("Use the safer weight(std::size_t) const.")
159 { return get_curWeight(); }
160 /// Return squared weight of last bin that was requested with get().
161 /// \deprecated Use the safer weightSquared(std::size_t) const.
162 Double_t weightSquared() const override
163 R__SUGGEST_ALTERNATIVE("Use the safer weightSquared(std::size_t) const.")
164 { return get_curSumW2(); }
165 /// Return volume of current bin. \deprecated Use binVolume(std::size_t) const.
167 R__SUGGEST_ALTERNATIVE("Use binVolume(std::size_t) const.")
168 { return _binv[_curIndex]; }
169 /// Write `weight` into current bin. \deprecated Use set(std::size_t,double,double)
170 void set(Double_t weight, Double_t wgtErr=-1)
171 R__SUGGEST_ALTERNATIVE("Use set(std::size_t,double,double).");
172
173 /// Return true if currently loaded coordinate is considered valid within
174 /// the current range definitions of all observables.
175 /// \deprecated Use the safer valid(std::size_t) const.
176 bool valid() const override
177 R__SUGGEST_ALTERNATIVE("Use valid(std::size_t).")
178 { return _curIndex <= static_cast<std::size_t>(_arrSize) && (_maskedWeights.empty() || _maskedWeights[_curIndex] != 0.);}
179
180 void dump2();
181
182 ///@}
183 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
184
185protected:
186
187 friend class RooAbsCachedPdf ;
188 friend class RooAbsCachedReal ;
189 friend class RooDataHistSliceIter ;
190
191 std::size_t calcTreeIndex(const RooArgSet& coords, bool fast) const;
192 /// Legacy overload to calculate the tree index from the current value of `_vars`.
193 /// \deprecated Use calcTreeIndex(const RooArgSet&,bool) const.
194 Int_t calcTreeIndex() const { return static_cast<Int_t>(calcTreeIndex(_vars, true)); }
195
196 void setAllWeights(Double_t value) ;
197
198 void initialize(const char* binningName=0,Bool_t fillTree=kTRUE) ;
199 RooDataHist(const char* name, const char* title, RooDataHist* h, const RooArgSet& varSubset,
200 const RooFormulaVar* cutVar, const char* cutRange, Int_t nStart, Int_t nStop, Bool_t copyCache) ;
201 RooAbsData* reduceEng(const RooArgSet& varSubset, const RooFormulaVar* cutVar, const char* cutRange=0,
202 std::size_t nStart=0, std::size_t nStop=std::numeric_limits<std::size_t>::max(), Bool_t copyCache=kTRUE) override;
203 Double_t interpolateDim(RooRealVar& dim, const RooAbsBinning* binning, Double_t xval, Int_t intOrder, Bool_t correctForBinSize, Bool_t cdfBoundaries) ;
204 const std::vector<double>& calculatePartialBinVolume(const RooArgSet& dimSet) const ;
205 void checkBinBounds() const;
206
207 void adjustBinning(const RooArgList& vars, const TH1& href, Int_t* offset=0) ;
208 void importTH1(const RooArgList& vars, const TH1& histo, Double_t initWgt, Bool_t doDensityCorrection) ;
209 void importTH1Set(const RooArgList& vars, RooCategory& indexCat, std::map<std::string,TH1*> hmap, Double_t initWgt, Bool_t doDensityCorrection) ;
210 void importDHistSet(const RooArgList& vars, RooCategory& indexCat, std::map<std::string,RooDataHist*> dmap, Double_t initWgt) ;
211
212 RooAbsData* cacheClone(const RooAbsArg* newCacheOwner, const RooArgSet* newCacheVars, const char* newName=0) override ;
213
214 Double_t get_wgt(std::size_t idx) const { return _wgt[idx]; }
215 Double_t get_errLo(std::size_t idx) const { return _errLo ? _errLo[idx] : -1.; }
216 Double_t get_errHi(std::size_t idx) const { return _errHi ? _errHi[idx] : -1.; }
217 // If sumw2 is not being tracked, assume that all previous fill operations had a weight of 1, i.e., return the bare weight of the bin.
218 Double_t get_sumw2(std::size_t idx) const { return _sumw2 ? _sumw2[idx] : _wgt[idx]; }
219
224
225 Int_t get_curIndex() const { return _curIndex; }
226
227 Int_t _arrSize{0}; // Size of member arrays.
228 std::vector<Int_t> _idxMult ; // Multiplier jump table for index calculation
229
230 double* _wgt {nullptr}; //[_arrSize] Weight array
231 mutable double* _errLo{nullptr}; //[_arrSize] Low-side error on weight array
232 mutable double* _errHi{nullptr}; //[_arrSize] High-side error on weight array
233 mutable double* _sumw2{nullptr}; //[_arrSize] Sum of weights^2
234 double* _binv {nullptr}; //[_arrSize] Bin volume array
235
236 RooArgSet _realVars ; // Real dimensions of the dataset
237 mutable std::vector<double> _maskedWeights; //! Copy of _wgtVec, but masked events have a weight of zero.
238
239 mutable std::size_t _curIndex{std::numeric_limits<std::size_t>::max()}; // Current index
240
241 mutable std::unordered_map<int,std::vector<double>> _pbinvCache ; //! Cache for arrays of partial bin volumes
242 std::vector<RooAbsLValue*> _lvvars ; //! List of observables casted as RooAbsLValue
243 std::vector<std::unique_ptr<const RooAbsBinning>> _lvbins ; //! List of used binnings associated with lvalues
244 mutable std::vector<std::vector<Double_t> > _binbounds; //! list of bin bounds per dimension
245
247 mutable Int_t _cache_sum_valid{kInvalid}; //! Is cache sum valid? Needs to be Int_t instead of CacheSumState_t for subclasses.
248 mutable Double_t _cache_sum{0.}; //! Cache for sum of entries ;
249
250
251private:
252 void _adjustBinning(RooRealVar &theirVar, const TAxis &axis, RooRealVar *ourVar, Int_t *offset);
254
255 ClassDefOverride(RooDataHist, 5) // Binned data set
256};
257
258#endif
259
#define R__SUGGEST_ALTERNATIVE(ALTERNATIVE)
Definition: RConfig.hxx:534
#define h(i)
Definition: RSha256.hxx:106
const Bool_t kFALSE
Definition: RtypesCore.h:92
double Double_t
Definition: RtypesCore.h:59
const Bool_t kTRUE
Definition: RtypesCore.h:91
#define ClassDefOverride(name, id)
Definition: Rtypes.h:329
static void indent(ostringstream &buf, int indent_level)
char name[80]
Definition: TGX11.cxx:110
float type_of_call hi(const int &, const int &)
RooAbsArg is the common abstract base class for objects that represent a value and a "shape" in RooFi...
Definition: RooAbsArg.h:72
RooAbsBinning is the abstract base class for RooRealVar binning definitions.
Definition: RooAbsBinning.h:26
RooAbsCachedPdf is the abstract base class for p.d.f.s that need or want to cache their evaluate() ou...
RooAbsCachedReal is the abstract base class for functions that need or want to cache their evaluate()...
RooAbsData is the common abstract base class for binned and unbinned datasets.
Definition: RooAbsData.h:49
RooArgSet _vars
Definition: RooAbsData.h:291
virtual RooPlot * plotOn(RooPlot *frame, const RooCmdArg &arg1=RooCmdArg::none(), const RooCmdArg &arg2=RooCmdArg::none(), const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none(), const RooCmdArg &arg6=RooCmdArg::none(), const RooCmdArg &arg7=RooCmdArg::none(), const RooCmdArg &arg8=RooCmdArg::none()) const
Definition: RooAbsData.cxx:547
Abstract base class for objects that are lvalues, i.e.
Definition: RooAbsLValue.h:26
RooArgList is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgList.h:21
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:29
RooCategory is an object to represent discrete states.
Definition: RooCategory.h:27
RooCmdArg is a named container for two doubles, two integers two object points and three string point...
Definition: RooCmdArg.h:27
RooDataHistSliceIter iterates over all bins in a RooDataHist that occur in a slice defined by the bin...
The RooDataHist is a container class to hold N-dimensional binned data.
Definition: RooDataHist.h:37
void dump2()
Debug stuff, should go...
void initialize(const char *binningName=0, Bool_t fillTree=kTRUE)
Initialization procedure: allocate weights array, calculate multipliers needed for N-space to 1-dim a...
Double_t weightError(ErrorType etype=Poisson) const override
Return the error of the weight of the last-retrieved entry. See also weightError(Double_t&,...
Definition: RooDataHist.h:112
Int_t _cache_sum_valid
Definition: RooDataHist.h:247
void getBatches(RooBatchCompute::RunContext &evalData, std::size_t begin, std::size_t len) const override
Write information to retrieve data columns into evalData.spans.
void SetNameTitle(const char *name, const char *title) override
Change the title of this RooDataHist.
TObject * Clone(const char *newname="") const override
Make a clone of an object using the Streamer facility.
Definition: RooDataHist.h:53
std::vector< double > _maskedWeights
Definition: RooDataHist.h:237
RooAbsData * reduceEng(const RooArgSet &varSubset, const RooFormulaVar *cutVar, const char *cutRange=0, std::size_t nStart=0, std::size_t nStop=std::numeric_limits< std::size_t >::max(), Bool_t copyCache=kTRUE) override
Implementation of RooAbsData virtual method that drives the RooAbsData::reduce() methods.
Double_t get_curWeight() const
Definition: RooDataHist.h:220
const std::vector< double > & calculatePartialBinVolume(const RooArgSet &dimSet) const
Fill the transient cache with partial bin volumes with up-to-date values for the partial volume speci...
Double_t weight() const override
Return weight of last bin that was requested with get().
Definition: RooDataHist.h:157
RooAbsData * cacheClone(const RooAbsArg *newCacheOwner, const RooArgSet *newCacheVars, const char *newName=0) override
Construct a clone of this dataset that contains only the cached variables.
std::unordered_map< int, std::vector< double > > _pbinvCache
Definition: RooDataHist.h:241
void checkBinBounds() const
double weight(std::size_t i) const
Return weight of i-th bin.
Definition: RooDataHist.h:98
void set(std::size_t binNumber, double weight, double wgtErr)
Set bin content of bin that was last loaded with get(std::size_t).
RooAbsData * emptyClone(const char *newName=0, const char *newTitle=0, const RooArgSet *vars=0, const char *=0) const override
Return empty clone of this RooDataHist.
Definition: RooDataHist.h:59
Double_t sumEntries() const override
Sum the weights of all bins.
RooSpan< const double > getWeightBatch(std::size_t first, std::size_t len) const override
Return event weights of all events in range [first, first+len).
Double_t weightSquared() const override
Return squared weight of last bin that was requested with get().
Definition: RooDataHist.h:162
virtual void add(const RooArgSet &row, Double_t wgt=1.0)
Add wgt to the bin content enclosed by the coordinates passed in row.
Definition: RooDataHist.h:64
double * _errHi
Definition: RooDataHist.h:232
double * _binv
Definition: RooDataHist.h:234
RooDataHist()
Default constructor.
Definition: RooDataHist.cxx:67
Double_t get_curWgtErrLo() const
Definition: RooDataHist.h:221
void removeSelfFromDir()
Definition: RooDataHist.h:133
double weightSquared(std::size_t i) const
Return squared weight sum of i-th bin.
Definition: RooDataHist.h:101
virtual void printMultiline(std::ostream &os, Int_t content, Bool_t verbose=kFALSE, TString indent="") const override
Print the details on the dataset contents.
void importTH1Set(const RooArgList &vars, RooCategory &indexCat, std::map< std::string, TH1 * > hmap, Double_t initWgt, Bool_t doDensityCorrection)
Import data from given set of TH1/2/3 into this RooDataHist.
Int_t getIndex(const RooArgSet &coord, Bool_t fast=false) const
Calculate bin number of the given coordinates.
RooPlot * plotOn(RooPlot *frame, PlotOpt o) const override
Back end function to plotting functionality.
Double_t get_curSumW2() const
Definition: RooDataHist.h:223
Double_t get_errHi(std::size_t idx) const
Definition: RooDataHist.h:216
Bool_t isNonPoissonWeighted() const override
Returns true if dataset contains entries with a non-integer weight.
virtual void printArgs(std::ostream &os) const override
Print argument of dataset, i.e. the observable names.
Double_t interpolateDim(RooRealVar &dim, const RooAbsBinning *binning, Double_t xval, Int_t intOrder, Bool_t correctForBinSize, Bool_t cdfBoundaries)
Perform boundary safe 'intOrder'-th interpolation of weights in dimension 'dim' at current value 'xva...
bool valid(std::size_t i) const
Return true if bin i is considered valid within the current range definitions of all observables.
Definition: RooDataHist.h:106
void _adjustBinning(RooRealVar &theirVar, const TAxis &axis, RooRealVar *ourVar, Int_t *offset)
Cache for sum of entries ;.
std::vector< std::vector< Double_t > > _binbounds
List of used binnings associated with lvalues.
Definition: RooDataHist.h:244
double * _sumw2
Definition: RooDataHist.h:233
TIterator * sliceIterator(RooAbsArg &sliceArg, const RooArgSet &otherArgs)
Create an iterator over all bins in a slice defined by the subset of observables listed in sliceArg.
void importTH1(const RooArgList &vars, const TH1 &histo, Double_t initWgt, Bool_t doDensityCorrection)
Import data from given TH1/2/3 into this RooDataHist.
std::size_t _curIndex
Copy of _wgtVec, but masked events have a weight of zero.
Definition: RooDataHist.h:239
Bool_t isWeighted() const override
Always returns true as all histograms use event weights.
Definition: RooDataHist.h:82
Int_t calcTreeIndex() const
Legacy overload to calculate the tree index from the current value of _vars.
Definition: RooDataHist.h:194
Double_t get_curWgtErrHi() const
Definition: RooDataHist.h:222
~RooDataHist() override
Destructor.
void setAllWeights(Double_t value)
Set all the event weight of all bins to the specified value.
RooDataHist & operator=(const RooDataHist &)=delete
Double_t get_wgt(std::size_t idx) const
Definition: RooDataHist.h:214
void importDHistSet(const RooArgList &vars, RooCategory &indexCat, std::map< std::string, RooDataHist * > dmap, Double_t initWgt)
Import data from given set of TH1/2/3 into this RooDataHist.
Int_t _arrSize
Definition: RooDataHist.h:227
double binVolume(std::size_t i) const
Return bin volume of i-th bin.
Definition: RooDataHist.h:103
std::vector< RooAbsLValue * > _lvvars
Cache for arrays of partial bin volumes.
Definition: RooDataHist.h:242
Int_t numEntries() const override
Return the number of bins.
void cacheValidEntries()
Compute which bins of the dataset are part of the currently set fit range.
void SetName(const char *name) override
Change the name of the RooDataHist.
std::vector< std::unique_ptr< const RooAbsBinning > > _lvbins
List of observables casted as RooAbsLValue.
Definition: RooDataHist.h:243
RooArgSet _realVars
Definition: RooDataHist.h:236
Int_t get_curIndex() const
Definition: RooDataHist.h:225
bool valid() const override
Return true if currently loaded coordinate is considered valid within the current range definitions o...
Definition: RooDataHist.h:176
std::vector< Int_t > _idxMult
Definition: RooDataHist.h:228
void registerWeightArraysToDataStore() const
Hand over pointers to our weight arrays to the data store implementation.
void reset() override
Reset all bin weights to zero.
Double_t get_errLo(std::size_t idx) const
Definition: RooDataHist.h:215
double * _errLo
Definition: RooDataHist.h:231
void adjustBinning(const RooArgList &vars, const TH1 &href, Int_t *offset=0)
Adjust binning specification on first and optionally second and third observable to binning in given ...
double * _wgt
Definition: RooDataHist.h:230
CacheSumState_t
list of bin bounds per dimension
Definition: RooDataHist.h:246
@ kCorrectForBinSize
Definition: RooDataHist.h:246
virtual void printValue(std::ostream &os) const override
Print value of the dataset, i.e. the sum of weights contained in the dataset.
Double_t _cache_sum
Is cache sum valid? Needs to be Int_t instead of CacheSumState_t for subclasses.
Definition: RooDataHist.h:248
Double_t binVolume() const
Return volume of current bin.
Definition: RooDataHist.h:166
const RooArgSet * get() const override
Get bin centre of current bin.
Definition: RooDataHist.h:74
Double_t get_sumw2(std::size_t idx) const
Definition: RooDataHist.h:218
void weightError(Double_t &lo, Double_t &hi, ErrorType etype=Poisson) const override
Return the error of current weight.
Double_t sum(bool correctForBinSize, bool inverseCorr=false) const
Return the sum of the weights of all bins in the histogram.
RooDirItem is a utility base class for RooFit objects that are to be attached to ROOT directories.
Definition: RooDirItem.h:22
void removeFromDir(TObject *obj)
Remove object from directory it was added to.
Definition: RooDirItem.cxx:43
A RooFormulaVar is a generic implementation of a real-valued object, which takes a RooArgList of serv...
Definition: RooFormulaVar.h:30
A RooPlot is a plot frame and a container for graphics objects within that frame.
Definition: RooPlot.h:44
RooRealVar represents a variable that can be changed from the outside.
Definition: RooRealVar.h:39
A simple container to hold a batch of data values.
Definition: RooSpan.h:34
Class to manage histogram axis.
Definition: TAxis.h:30
TH1 is the base class of all histogram classes in ROOT.
Definition: TH1.h:58
Iterator abstract base class.
Definition: TIterator.h:30
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:48
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
Mother of all ROOT objects.
Definition: TObject.h:37
Basic string class.
Definition: TString.h:136
void function(const Char_t *name_, T fun, const Char_t *docstring=0)
Definition: RExports.h:151
Definition: first.py:1
This struct enables passing computation data around between elements of a computation graph.
Definition: RunContext.h:31