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 "ROOT/RStringView.hxx"
24
25#include <map>
26#include <vector>
27#include <string>
28#include <functional>
29#include <memory>
30#include <unordered_map>
31
32class TAxis ;
33class TObject ;
34class RooAbsArg;
35class RooCategory ;
36class RooPlot;
37class RooAbsLValue ;
38
39class RooDataHist : public RooAbsData, public RooDirItem {
40public:
41
42 // Constructors, factory methods etc.
43 RooDataHist() ;
44 RooDataHist(std::string_view name, std::string_view title, const RooArgSet& vars, const char* binningName=0) ;
45 RooDataHist(std::string_view name, std::string_view title, const RooArgSet& vars, const RooAbsData& data, Double_t initWgt=1.0) ;
46 RooDataHist(std::string_view name, std::string_view title, const RooArgList& vars, const TH1* hist, Double_t initWgt=1.0) ;
47 RooDataHist(std::string_view name, std::string_view title, const RooArgList& vars, RooCategory& indexCat, std::map<std::string,TH1*> histMap, Double_t initWgt=1.0) ;
48 RooDataHist(std::string_view name, std::string_view title, const RooArgList& vars, RooCategory& indexCat, std::map<std::string,RooDataHist*> dhistMap, Double_t wgt=1.0) ;
49 //RooDataHist(const char *name, const char *title, const RooArgList& vars, Double_t initWgt=1.0) ;
50 RooDataHist(std::string_view name, std::string_view title, const RooArgList& vars, const RooCmdArg& arg1, const RooCmdArg& arg2=RooCmdArg(), const RooCmdArg& arg3=RooCmdArg(),
51 const RooCmdArg& arg4=RooCmdArg(),const RooCmdArg& arg5=RooCmdArg(),const RooCmdArg& arg6=RooCmdArg(),const RooCmdArg& arg7=RooCmdArg(),const RooCmdArg& arg8=RooCmdArg()) ;
53
55
56 RooDataHist(const RooDataHist& other, const char* newname = 0) ;
57 TObject* Clone(const char* newname="") const override {
58 return new RooDataHist(*this, newname && newname[0] != '\0' ? newname : GetName());
59 }
60 ~RooDataHist() override ;
61
62 /// Return empty clone of this RooDataHist.
63 RooAbsData* emptyClone(const char* newName=0, const char* newTitle=0, const RooArgSet*vars=0, const char* /*wgtVarName*/=0) const override {
64 return new RooDataHist(newName?newName:GetName(),newTitle?newTitle:GetTitle(),vars?*vars:*get()) ;
65 }
66
67 /// Add `wgt` to the bin content enclosed by the coordinates passed in `row`.
68 virtual void add(const RooArgSet& row, Double_t wgt=1.0) { add(row,wgt,-1.); }
69 void add(const RooArgSet& row, Double_t weight, Double_t sumw2) override ;
70 void set(std::size_t binNumber, double weight, double wgtErr);
71 void set(const RooArgSet& row, Double_t weight, Double_t wgtErr=-1.) ;
72 void set(const RooArgSet& row, Double_t weight, Double_t wgtErrLo, Double_t wgtErrHi) ;
73
74 void add(const RooAbsData& dset, const RooFormulaVar* cutVar=0, Double_t weight=1.0 ) ;
75 void add(const RooAbsData& dset, const char* cut, Double_t weight=1.0 ) ;
76
77 /// Get bin centre of current bin.
78 const RooArgSet* get() const override { return &_vars; }
79 const RooArgSet* get(Int_t binNumber) const override;
80 virtual const RooArgSet* get(const RooArgSet& coord) const;
81 Int_t numEntries() const override;
82 Double_t sumEntries() const override;
83 Double_t sumEntries(const char* cutSpec, const char* cutRange=0) const override;
84
85 /// Always returns true as all histograms use event weights.
86 Bool_t isWeighted() const override { return true; }
87 Bool_t isNonPoissonWeighted() const override ;
88
89 RooSpan<const double> getWeightBatch(std::size_t first, std::size_t len) const override;
90 void getBatches(RooBatchCompute::RunContext& evalData, std::size_t begin, std::size_t len) const override;
91 /// Retrieve all bin volumes. Bins are indexed according to getIndex().
92 RooSpan<const double> binVolumes(std::size_t first, std::size_t len) const {
93 return {_binv + first, len};
94 }
95
96 Double_t sum(bool correctForBinSize, bool inverseCorr=false) const ;
97 Double_t sum(const RooArgSet& sumSet, const RooArgSet& sliceSet, bool correctForBinSize, bool inverseCorr=false) ;
98 Double_t sum(const RooArgSet& sumSet,
99 const RooArgSet& sliceSet,
100 bool correctForBinSize,
101 bool inverseCorr,
102 const std::map<const RooAbsArg*, std::pair<double, double> >& ranges,
103 std::function<double(int)> getBinScale = [](int){ return 1.0; } );
104
105 /// Return weight of i-th bin. \see getIndex()
106 double weight(std::size_t i) const { return _wgt[i]; }
107 double weightFast(const RooArgSet& bin, int intOrder, bool correctForBinSize, bool cdfBoundaries);
108 Double_t weight(const RooArgSet& bin, Int_t intOrder=1, Bool_t correctForBinSize=kFALSE, Bool_t cdfBoundaries=kFALSE, Bool_t oneSafe=kFALSE);
109 /// Return squared weight sum of i-th bin. \see getIndex()
110 double weightSquared(std::size_t i) const { return get_sumw2(i); }
111 /// Return bin volume of i-th bin. \see getIndex()
112 double binVolume(std::size_t i) const { return _binv[i]; }
113 double binVolume(const RooArgSet& bin) const;
114 /// Return true if bin `i` is considered valid within the current range definitions of all observables. \see getIndex()
115 bool valid(std::size_t i) const { return i <= static_cast<std::size_t>(_arrSize) && (_maskedWeights.empty() || _maskedWeights[i] != 0.);}
116
117 TIterator* sliceIterator(RooAbsArg& sliceArg, const RooArgSet& otherArgs) ;
118
119 void weightError(double& lo, double& hi, ErrorType etype=Poisson) const override;
120 /// \copydoc RooAbsData::weightError(RooAbsData::ErrorType) const
121 double weightError(ErrorType etype=Poisson) const override {
122 // Return symmetric error on current bin calculated either from Poisson statistics or from SumOfWeights
123 Double_t lo,hi ;
124 weightError(lo,hi,etype) ;
125 return (lo+hi)/2 ;
126 }
127
128 using RooAbsData::plotOn ;
129 RooPlot *plotOn(RooPlot *frame, PlotOpt o) const override;
130
131 void reset() override;
132
133 virtual void printMultiline(std::ostream& os, Int_t content, Bool_t verbose=kFALSE, TString indent="") const override;
134 virtual void printArgs(std::ostream& os) const override;
135 virtual void printValue(std::ostream& os) const override;
136 void printDataHistogram(std::ostream& os, RooRealVar* obs) const;
137
138 void SetName(const char *name) override;
139 void SetNameTitle(const char *name, const char* title) override;
140
141 Int_t getIndex(const RooAbsCollection& coord, Bool_t fast = false) const;
142 /// \copydoc getIndex(const RooAbsCollection&,Bool_t) const
143 ///
144 /// \note This overload only exists because there is an implicit conversion from RooAbsArg
145 /// to RooArgSet, and this needs to remain supported. This enables code like
146 /// ```
147 /// RooRealVar x(...);
148 /// dataHist.getIndex(x);
149 /// ```
150 /// It is, however, recommended to use
151 /// ```
152 /// dataHist.getIndex(RooArgSet(x));
153 /// ```
154 /// in this case.
155 Int_t getIndex(const RooArgSet& coord, Bool_t fast = false) const {
156 return getIndex(static_cast<const RooAbsCollection&>(coord), fast);
157 }
158
160
161 // A shortcut function only for RooAbsOptTestStatistic.
162 void cacheValidEntries();
163
164
165 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
166 /// @name Deprecated functions
167 /// These functions rely on the fact that an event has been loaded before they are called. It is advised
168 /// to switch to their counterparts that take bin numbers as arguments. In this way, code like,
169 /// ```
170 /// const RooArgSet* coordinates = dataHist.get(i); // Need this to achieve side effect on next call of weight() - bad.
171 /// const double weight = dataHist.weight();
172 /// processEvent(coordinates, weight);
173 /// ```
174 /// becomes
175 /// ```
176 /// processEvent(dataHist.get(i), dataHist.weight(i));
177 /// ```
178 /// The index of a set of coordinates can be computed using getIndex().
179 /// @{
180
181 /// Return weight of last bin that was requested with get().
182 /// \deprecated Use the safer weight(std::size_t) const.
183 Double_t weight() const override
184 R__SUGGEST_ALTERNATIVE("Use the safer weight(std::size_t) const.")
185 { return get_curWeight(); }
186 /// Return squared weight of last bin that was requested with get().
187 /// \deprecated Use the safer weightSquared(std::size_t) const.
188 Double_t weightSquared() const override
189 R__SUGGEST_ALTERNATIVE("Use the safer weightSquared(std::size_t) const.")
190 { return get_curSumW2(); }
191 /// Return volume of current bin. \deprecated Use binVolume(std::size_t) const.
193 R__SUGGEST_ALTERNATIVE("Use binVolume(std::size_t) const.")
194 { return _binv[_curIndex]; }
195 /// Write `weight` into current bin. \deprecated Use set(std::size_t,double,double)
196 void set(Double_t weight, Double_t wgtErr=-1)
197 R__SUGGEST_ALTERNATIVE("Use set(std::size_t,double,double).");
198
199 /// Return true if currently loaded coordinate is considered valid within
200 /// the current range definitions of all observables.
201 /// \deprecated Use the safer valid(std::size_t) const.
202 bool valid() const override
203 R__SUGGEST_ALTERNATIVE("Use valid(std::size_t).")
204 { return _curIndex <= static_cast<std::size_t>(_arrSize) && (_maskedWeights.empty() || _maskedWeights[_curIndex] != 0.);}
205
206 void dump2();
207
208 ///@}
209 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
210
211 /// Structure to cache information on the histogram variable that is
212 /// frequently used for histogram weights retrieval.
213 struct VarInfo {
214 size_t nRealVars = 0;
215 size_t realVarIdx1 = 0;
216 size_t realVarIdx2 = 0;
217 bool initialized = false;
218 };
219
220protected:
221
222 friend class RooAbsCachedPdf ;
223 friend class RooAbsCachedReal ;
224 friend class RooDataHistSliceIter ;
225
226 std::size_t calcTreeIndex(const RooAbsCollection& coords, bool fast) const;
227 /// Legacy overload to calculate the tree index from the current value of `_vars`.
228 /// \deprecated Use calcTreeIndex(const RooArgSet&,bool) const.
229 Int_t calcTreeIndex() const { return static_cast<Int_t>(calcTreeIndex(_vars, true)); }
230
231 void setAllWeights(Double_t value) ;
232
233 void initialize(const char* binningName=0,Bool_t fillTree=kTRUE) ;
235 const RooFormulaVar* cutVar, const char* cutRange, Int_t nStart, Int_t nStop, Bool_t copyCache) ;
236 RooAbsData* reduceEng(const RooArgSet& varSubset, const RooFormulaVar* cutVar, const char* cutRange=0,
237 std::size_t nStart=0, std::size_t nStop=std::numeric_limits<std::size_t>::max(), Bool_t copyCache=kTRUE) override;
238 double interpolateDim(int iDim, double xval, size_t centralIdx, int intOrder, bool correctForBinSize, bool cdfBoundaries) ;
239 const std::vector<double>& calculatePartialBinVolume(const RooArgSet& dimSet) const ;
240 void checkBinBounds() const;
241
242 void adjustBinning(const RooArgList& vars, const TH1& href, Int_t* offset=0) ;
243 void importTH1(const RooArgList& vars, const TH1& histo, Double_t initWgt, Bool_t doDensityCorrection) ;
244 void importTH1Set(const RooArgList& vars, RooCategory& indexCat, std::map<std::string,TH1*> hmap, Double_t initWgt, Bool_t doDensityCorrection) ;
245 void importDHistSet(const RooArgList& vars, RooCategory& indexCat, std::map<std::string,RooDataHist*> dmap, Double_t initWgt) ;
246
247 RooAbsData* cacheClone(const RooAbsArg* newCacheOwner, const RooArgSet* newCacheVars, const char* newName=0) override ;
248
249 Double_t get_wgt(std::size_t idx) const { return _wgt[idx]; }
250 Double_t get_errLo(std::size_t idx) const { return _errLo ? _errLo[idx] : -1.; }
251 Double_t get_errHi(std::size_t idx) const { return _errHi ? _errHi[idx] : -1.; }
252 // 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.
253 Double_t get_sumw2(std::size_t idx) const { return _sumw2 ? _sumw2[idx] : _wgt[idx]; }
254
259
260 Int_t get_curIndex() const { return _curIndex; }
261
262 Int_t _arrSize{0}; // Size of member arrays.
263 std::vector<Int_t> _idxMult ; // Multiplier jump table for index calculation
264
265 double* _wgt {nullptr}; //[_arrSize] Weight array
266 mutable double* _errLo{nullptr}; //[_arrSize] Low-side error on weight array
267 mutable double* _errHi{nullptr}; //[_arrSize] High-side error on weight array
268 mutable double* _sumw2{nullptr}; //[_arrSize] Sum of weights^2
269 double* _binv {nullptr}; //[_arrSize] Bin volume array
270
271 mutable std::vector<double> _maskedWeights; //! Copy of _wgtVec, but masked events have a weight of zero.
272
273 mutable std::size_t _curIndex{std::numeric_limits<std::size_t>::max()}; // Current index
274
275 mutable std::unordered_map<int,std::vector<double>> _pbinvCache ; //! Cache for arrays of partial bin volumes
276 std::vector<RooAbsLValue*> _lvvars ; //! List of observables casted as RooAbsLValue
277 std::vector<std::unique_ptr<const RooAbsBinning>> _lvbins ; //! List of used binnings associated with lvalues
278 mutable std::vector<std::vector<Double_t> > _binbounds; //! list of bin bounds per dimension
279
281 mutable Int_t _cache_sum_valid{kInvalid}; //! Is cache sum valid? Needs to be Int_t instead of CacheSumState_t for subclasses.
282 mutable Double_t _cache_sum{0.}; //! Cache for sum of entries ;
283
284private:
285 double weightInterpolated(const RooArgSet& bin, int intOrder, bool correctForBinSize, bool cdfBoundaries);
286
287 void _adjustBinning(RooRealVar &theirVar, const TAxis &axis, RooRealVar *ourVar, Int_t *offset);
289
291 VarInfo const& getVarInfo();
292
293 ClassDefOverride(RooDataHist, 6) // Binned data set
294};
295
296#endif
297
int Int_t
Definition: CPyCppyy.h:43
#define R__SUGGEST_ALTERNATIVE(ALTERNATIVE)
Definition: RConfig.hxx:523
#define h(i)
Definition: RSha256.hxx:106
#define WRITE_TSTRING_COMPATIBLE_CONSTRUCTOR(Class_t)
Definition: RooAbsData.h:60
const Bool_t kFALSE
Definition: RtypesCore.h:101
bool Bool_t
Definition: RtypesCore.h:63
double Double_t
Definition: RtypesCore.h:59
const Bool_t kTRUE
Definition: RtypesCore.h:100
#define ClassDefOverride(name, id)
Definition: Rtypes.h:329
static void indent(ostringstream &buf, int indent_level)
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
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()...
RooAbsCollection is an abstract container object that can hold multiple RooAbsArg objects.
RooAbsData is the common abstract base class for binned and unbinned datasets.
Definition: RooAbsData.h:73
RooArgSet _vars
Definition: RooAbsData.h:337
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:531
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:22
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:35
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:39
void dump2()
Debug stuff, should go...
Int_t getIndex(const RooAbsCollection &coord, Bool_t fast=false) const
Calculate bin number of the given coordinates.
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...
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:63
TObject * Clone(const char *newname="") const override
Make a clone of an object using the Streamer facility.
Definition: RooDataHist.h:57
Int_t _cache_sum_valid
Definition: RooDataHist.h:281
double interpolateDim(int iDim, double xval, size_t centralIdx, int intOrder, bool correctForBinSize, bool cdfBoundaries)
Perform boundary safe 'intOrder'-th interpolation of weights in dimension 'dim' at current value 'xva...
void printDataHistogram(std::ostream &os, RooRealVar *obs) const
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.
std::vector< double > _maskedWeights
Definition: RooDataHist.h:271
VarInfo _varInfo
Definition: RooDataHist.h:290
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:255
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:183
double weightInterpolated(const RooArgSet &bin, int intOrder, bool correctForBinSize, bool cdfBoundaries)
Cache for sum of entries ;.
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:275
void checkBinBounds() const
double weight(std::size_t i) const
Return weight of i-th bin.
Definition: RooDataHist.h:106
void set(std::size_t binNumber, double weight, double wgtErr)
Set bin content of bin that was last loaded with get(std::size_t).
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:188
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:68
void weightError(double &lo, double &hi, ErrorType etype=Poisson) const override
Return the asymmetric errors on the current weight.
double * _errHi
Definition: RooDataHist.h:267
double * _binv
Definition: RooDataHist.h:269
const RooArgSet * get() const override
Get bin centre of current bin.
Definition: RooDataHist.h:78
RooDataHist()
Default constructor.
Definition: RooDataHist.cxx:85
Double_t get_curWgtErrLo() const
Definition: RooDataHist.h:256
void removeSelfFromDir()
Definition: RooDataHist.h:159
double weightSquared(std::size_t i) const
Return squared weight sum of i-th bin.
Definition: RooDataHist.h:110
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.
Definition: RooDataHist.h:155
double weightFast(const RooArgSet &bin, int intOrder, bool correctForBinSize, bool cdfBoundaries)
A faster version of RooDataHist::weight that assumes the passed arguments are aligned with the histog...
RooPlot * plotOn(RooPlot *frame, PlotOpt o) const override
Back end function to plotting functionality.
Double_t get_curSumW2() const
Definition: RooDataHist.h:258
Double_t get_errHi(std::size_t idx) const
Definition: RooDataHist.h:251
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.
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:115
void _adjustBinning(RooRealVar &theirVar, const TAxis &axis, RooRealVar *ourVar, Int_t *offset)
Helper doing the actual work of adjustBinning().
std::vector< std::vector< Double_t > > _binbounds
List of used binnings associated with lvalues.
Definition: RooDataHist.h:278
double * _sumw2
Definition: RooDataHist.h:268
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:273
Bool_t isWeighted() const override
Always returns true as all histograms use event weights.
Definition: RooDataHist.h:86
Int_t calcTreeIndex() const
Legacy overload to calculate the tree index from the current value of _vars.
Definition: RooDataHist.h:229
Double_t get_curWgtErrHi() const
Definition: RooDataHist.h:257
~RooDataHist() override
Destructor.
void setAllWeights(Double_t value)
Set all the event weight of all bins to the specified value.
Double_t get_wgt(std::size_t idx) const
Definition: RooDataHist.h:249
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:262
double binVolume(std::size_t i) const
Return bin volume of i-th bin.
Definition: RooDataHist.h:112
std::vector< RooAbsLValue * > _lvvars
Cache for arrays of partial bin volumes.
Definition: RooDataHist.h:276
double weightError(ErrorType etype=Poisson) const override
Return the symmetric error on the current weight.
Definition: RooDataHist.h:121
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:277
RooDataHist & operator=(const RooDataHist &)=delete
Int_t get_curIndex() const
Definition: RooDataHist.h:260
bool valid() const override
Return true if currently loaded coordinate is considered valid within the current range definitions o...
Definition: RooDataHist.h:202
std::vector< Int_t > _idxMult
Definition: RooDataHist.h:263
void registerWeightArraysToDataStore() const
Hand over pointers to our weight arrays to the data store implementation.
void reset() override
Reset all bin weights to zero.
RooSpan< const double > binVolumes(std::size_t first, std::size_t len) const
Retrieve all bin volumes. Bins are indexed according to getIndex().
Definition: RooDataHist.h:92
Double_t get_errLo(std::size_t idx) const
Definition: RooDataHist.h:250
double * _errLo
Definition: RooDataHist.h:266
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:265
CacheSumState_t
list of bin bounds per dimension
Definition: RooDataHist.h:280
@ kCorrectForBinSize
Definition: RooDataHist.h:280
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:282
VarInfo const & getVarInfo()
Return reference to VarInfo struct with cached histogram variable information that is frequently used...
Double_t binVolume() const
Return volume of current bin.
Definition: RooDataHist.h:192
Double_t get_sumw2(std::size_t idx) const
Definition: RooDataHist.h:253
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 * GetName() const
Returns name of object.
Definition: TNamed.h:47
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:48
Mother of all ROOT objects.
Definition: TObject.h:37
Basic string class.
Definition: TString.h:136
basic_string_view< char > string_view
void function(const Char_t *name_, T fun, const Char_t *docstring=0)
Definition: RExports.h:151
static const std::string name("name")
Definition: first.py:1
This struct enables passing computation data around between elements of a computation graph.
Definition: RunContext.h:31
Structure to cache information on the histogram variable that is frequently used for histogram weight...
Definition: RooDataHist.h:213