Logo ROOT  
Reference Guide
THnSparse.h
Go to the documentation of this file.
1// @(#)root/hist:$Id$
2// Author: Axel Naumann (2007-09-11)
3
4/*************************************************************************
5 * Copyright (C) 1995-2012, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#ifndef ROOT_THnSparse
13#define ROOT_THnSparse
14
15/*************************************************************************
16
17 THnSparse: histogramming multi-dimensional, sparse distributions in
18 a memory-efficient way.
19
20*************************************************************************/
21
22
23#include "THnBase.h"
24#include "TExMap.h"
25#include "THnSparse_Internal.h"
26
27// needed only for template instantiations of THnSparseT:
28#include "TArrayF.h"
29#include "TArrayL.h"
30#include "TArrayI.h"
31#include "TArrayS.h"
32#include "TArrayC.h"
33
35
36class THnSparse: public THnBase {
37 private:
38 Int_t fChunkSize; ///< Number of entries for each chunk
39 Long64_t fFilledBins; ///< Number of filled bins
40 TObjArray fBinContent; ///< Array of THnSparseArrayChunk
41 TExMap fBins; ///<! Filled bins
42 TExMap fBinsContinued; ///<! Filled bins for non-unique hashes, containing pairs of (bin index 0, bin index 1)
43 THnSparseCompactBinCoord *fCompactCoord; ///<! Compact coordinate
44
45 THnSparse(const THnSparse&); // Not implemented
46 THnSparse& operator=(const THnSparse&); // Not implemented
47
48 protected:
49
50 THnSparse();
51 THnSparse(const char* name, const char* title, Int_t dim,
52 const Int_t* nbins, const Double_t* xmin, const Double_t* xmax,
53 Int_t chunksize);
56 return (THnSparseArrayChunk*) fBinContent[idx]; }
57
59 void Reserve(Long64_t nbins);
60 void FillExMap();
61 virtual TArray* GenerateArray() const = 0;
63
64 /// Increment the bin content of "bin" by "w",
65 /// return the bin index.
66 void FillBin(Long64_t bin, Double_t w) {
68 chunk->AddBinContent(bin % fChunkSize, w);
69 FillBinBase(w);
70 }
71 void InitStorage(Int_t* nbins, Int_t chunkSize);
72
73 public:
74 virtual ~THnSparse();
75
76 static THnSparse* CreateSparse(const char* name, const char* title,
77 const TH1* h1, Int_t chunkSize = 1024 * 16) {
78 return (THnSparse*) CreateHnAny(name, title, h1, kTRUE /*sparse*/,
79 chunkSize);
80 }
81 static THnSparse* CreateSparse(const char* name, const char* title,
82 const THnBase* hn, Int_t chunkSize = 1024 * 16) {
83 return (THnSparse*) CreateHnAny(name, title, hn, kTRUE /*sparse*/,
84 chunkSize);
85 }
86
87 Int_t GetChunkSize() const { return fChunkSize; }
89
90 ROOT::Internal::THnBaseBinIter* CreateIter(Bool_t respectAxisRange) const;
91
92 Long64_t GetNbins() const { return fFilledBins; }
93 void SetFilledBins(Long64_t nbins) { fFilledBins = nbins; }
94
95 Long64_t GetBin(const Int_t* idx) const { return const_cast<THnSparse*>(this)->GetBin(idx, kFALSE); }
96 Long64_t GetBin(const Double_t* x) const { return const_cast<THnSparse*>(this)->GetBin(x, kFALSE); }
97 Long64_t GetBin(const char* name[]) const { return const_cast<THnSparse*>(this)->GetBin(name, kFALSE); }
98 Long64_t GetBin(const Int_t* idx, Bool_t allocate = kTRUE);
99 Long64_t GetBin(const Double_t* x, Bool_t allocate = kTRUE);
100 Long64_t GetBin(const char* name[], Bool_t allocate = kTRUE);
101
102 /// Forwards to THnBase::SetBinContent().
103 /// Non-virtual, CINT-compatible replacement of a using declaration.
104 void SetBinContent(const Int_t* idx, Double_t v) {
106 }
107 void SetBinContent(Long64_t bin, Double_t v);
108 void SetBinError2(Long64_t bin, Double_t e2);
109
110 /// Forwards to THnBase::SetBinContent().
111 /// Non-virtual, CINT-compatible replacement of a using declaration.
112 void AddBinContent(const Int_t* idx, Double_t v = 1.) {
114 }
115 void AddBinContent(Long64_t bin, Double_t v = 1.);
116 void AddBinError2(Long64_t bin, Double_t e2);
117
118 /// Forwards to THnBase::GetBinContent() overload.
119 /// Non-virtual, CINT-compatible replacement of a using declaration.
120 Double_t GetBinContent(const Int_t *idx) const {
121
122 return THnBase::GetBinContent(idx);
123 }
124 Double_t GetBinContent(Long64_t bin, Int_t* idx = 0) const;
125 Double_t GetBinError2(Long64_t linidx) const;
126
129
130 /// Forwards to THnBase::Projection().
131 /// Non-virtual, as a CINT-compatible replacement of a using
132 /// declaration.
133 TH1D* Projection(Int_t xDim, Option_t* option = "") const{
134 return THnBase::Projection(xDim, option);
135 }
136
137 /// Forwards to THnBase::Projection().
138 /// Non-virtual, as a CINT-compatible replacement of a using
139 /// declaration.
141 Option_t* option = "") const {
142 return THnBase::Projection(yDim, xDim, option);
143 }
144
145 /// Forwards to THnBase::Projection().
146 /// Non-virtual, as a CINT-compatible replacement of a using
147 /// declaration.
148 TH3D* Projection(Int_t xDim, Int_t yDim, Int_t zDim,
149 Option_t* option = "") const {
150 return THnBase::Projection(xDim, yDim, zDim, option);
151 }
152
153 THnSparse* Projection(Int_t ndim, const Int_t* dim,
154 Option_t* option = "") const {
155 return (THnSparse*) ProjectionND(ndim, dim, option);
156 }
157
159 return (THnSparse*) RebinBase(group);
160 }
161 THnSparse* Rebin(const Int_t* group) const {
162 return (THnSparse*) RebinBase(group);
163 }
164
165 void Reset(Option_t* option = "");
166 void Sumw2();
167
168 ClassDef(THnSparse, 3); // Interfaces of sparse n-dimensional histogram
169};
170
171
172
173//______________________________________________________________________________
174/** \class THnSparseT
175 Templated implementation of the abstract base THnSparse.
176 All functionality and the interfaces to be used are in THnSparse!
177
178 THnSparse does not know how to store any bin content itself. Instead, this
179 is delegated to the derived, templated class: the template parameter decides
180 what the format for the bin content is. In fact it even defines the array
181 itself; possible implementations probably derive from TArray.
182
183 Typedefs exist for template parameters with ROOT's generic types:
184
185 Templated name | Typedef | Bin content type
186 --------------------|--------------|--------------------
187 THnSparseT<TArrayC> | THnSparseC | Char_t
188 THnSparseT<TArrayS> | THnSparseS | Short_t
189 THnSparseT<TArrayI> | THnSparseI | Int_t
190 THnSparseT<TArrayL> | THnSparseL | Long_t
191 THnSparseT<TArrayF> | THnSparseF | Float_t
192 THnSparseT<TArrayD> | THnSparseD | Double_t
193
194 We recommend to use THnSparseC wherever possible, and to map its value space
195 of 256 possible values to e.g. float values outside the class. This saves an
196 enormous amount of memory. Only if more than 256 values need to be
197 distinguished should e.g. THnSparseS or even THnSparseF be chosen.
198
199 Implementation detail: the derived, templated class is kept extremely small
200 on purpose. That way the (templated thus inlined) uses of this class will
201 only create a small amount of machine code, in contrast to e.g. STL.
202*/
203
204
205template <class CONT>
206class THnSparseT: public THnSparse {
207 public:
209 THnSparseT(const char* name, const char* title, Int_t dim,
210 const Int_t* nbins, const Double_t* xmin = 0,
211 const Double_t* xmax = 0, Int_t chunksize = 1024 * 16):
212 THnSparse(name, title, dim, nbins, xmin, xmax, chunksize) {}
213
214 TArray* GenerateArray() const { return new CONT(GetChunkSize()); }
215 private:
216 ClassDef(THnSparseT, 1); // Sparse n-dimensional histogram with templated content
217};
218
225
226
227#endif // ROOT_THnSparse
int Int_t
Definition: RtypesCore.h:45
const Bool_t kFALSE
Definition: RtypesCore.h:101
bool Bool_t
Definition: RtypesCore.h:63
double Double_t
Definition: RtypesCore.h:59
long long Long64_t
Definition: RtypesCore.h:80
const Bool_t kTRUE
Definition: RtypesCore.h:100
const char Option_t
Definition: RtypesCore.h:66
#define ClassDef(name, id)
Definition: Rtypes.h:325
char name[80]
Definition: TGX11.cxx:110
float xmin
Definition: THbookFile.cxx:95
float xmax
Definition: THbookFile.cxx:95
THnSparseT< TArrayL > THnSparseL
Definition: THnSparse.h:221
THnSparseT< TArrayS > THnSparseS
Definition: THnSparse.h:223
THnSparseT< TArrayF > THnSparseF
Definition: THnSparse.h:220
THnSparseT< TArrayC > THnSparseC
Definition: THnSparse.h:224
THnSparseT< TArrayD > THnSparseD
Definition: THnSparse.h:219
THnSparseT< TArrayI > THnSparseI
Definition: THnSparse.h:222
Iterator over THnBase bins (internal implementation).
Definition: THnBase.h:285
Abstract array base class.
Definition: TArray.h:31
This class stores a (key,value) pair using an external hash.
Definition: TExMap.h:33
1-D histogram with a double per channel (see TH1 documentation)}
Definition: TH1.h:618
TH1 is the base class of all histogram classes in ROOT.
Definition: TH1.h:58
2-D histogram with a double per channel (see TH1 documentation)}
Definition: TH2.h:292
3-D histogram with a double per channel (see TH1 documentation)}
Definition: TH3.h:305
Multidimensional histogram base.
Definition: THnBase.h:43
void AddBinContent(const Int_t *x, Double_t v=1.)
Definition: THnBase.h:164
TH1D * Projection(Int_t xDim, Option_t *option="") const
Project all bins into a 1-dimensional histogram, keeping only axis "xDim".
Definition: THnBase.h:197
static THnBase * CreateHnAny(const char *name, const char *title, const TH1 *h1, Bool_t sparse, Int_t chunkSize=1024 *16)
Create a THn / THnSparse object from a histogram deriving from TH1.
Definition: THnBase.cxx:196
THnBase * RebinBase(Int_t group) const
Combine the content of "group" neighboring bins into a new bin and return the resulting THnBase.
Definition: THnBase.cxx:1056
THnBase * ProjectionND(Int_t ndim, const Int_t *dim, Option_t *option="") const
Definition: THnBase.h:228
Double_t GetBinContent(const Int_t *idx) const
Definition: THnBase.h:168
void SetBinContent(const Int_t *idx, Double_t v)
Definition: THnBase.h:178
void FillBinBase(Double_t w)
Increment the statistics due to filled weight "w",.
Definition: THnBase.h:84
THnSparseArrayChunk is used internally by THnSparse.
void AddBinContent(Int_t idx, Double_t v=1.)
THnSparseCompactBinCoord is a class used by THnSparse internally.
Definition: THnSparse.cxx:351
Templated implementation of the abstract base THnSparse.
Definition: THnSparse.h:206
TArray * GenerateArray() const
Definition: THnSparse.h:214
THnSparseT(const char *name, const char *title, Int_t dim, const Int_t *nbins, const Double_t *xmin=0, const Double_t *xmax=0, Int_t chunksize=1024 *16)
Definition: THnSparse.h:209
Efficient multidimensional histogram.
Definition: THnSparse.h:36
TH1D * Projection(Int_t xDim, Option_t *option="") const
Forwards to THnBase::Projection().
Definition: THnSparse.h:133
Double_t GetSparseFractionBins() const
Return the amount of filled bins over all bins.
Definition: THnSparse.cxx:854
Long64_t GetBin(const Int_t *idx) const
Definition: THnSparse.h:95
Double_t GetSparseFractionMem() const
Return the amount of used memory over memory that would be used by a non-sparse n-dimensional histogr...
Definition: THnSparse.cxx:865
THnSparse * Rebin(Int_t group) const
Definition: THnSparse.h:158
THnSparse & operator=(const THnSparse &)
Int_t GetNChunks() const
Definition: THnSparse.h:88
TH3D * Projection(Int_t xDim, Int_t yDim, Int_t zDim, Option_t *option="") const
Forwards to THnBase::Projection().
Definition: THnSparse.h:148
void SetBinContent(const Int_t *idx, Double_t v)
Forwards to THnBase::SetBinContent().
Definition: THnSparse.h:104
void InitStorage(Int_t *nbins, Int_t chunkSize)
Initialize the storage of a histogram created via Init()
Definition: THnSparse.cxx:646
THnSparseArrayChunk * GetChunk(Int_t idx) const
Definition: THnSparse.h:55
THnSparseCompactBinCoord * fCompactCoord
! Compact coordinate
Definition: THnSparse.h:43
Int_t GetChunkSize() const
Definition: THnSparse.h:87
virtual ~THnSparse()
Destruct a THnSparse.
Definition: THnSparse.cxx:616
ROOT::Internal::THnBaseBinIter * CreateIter(Bool_t respectAxisRange) const
Create an iterator over all filled bins of a THnSparse.
Definition: THnSparse.cxx:896
Double_t GetBinContent(const Int_t *idx) const
Forwards to THnBase::GetBinContent() overload.
Definition: THnSparse.h:120
Long64_t fFilledBins
Number of filled bins.
Definition: THnSparse.h:39
void Reset(Option_t *option="")
Clear the histogram.
Definition: THnSparse.cxx:962
Long64_t GetBin(const char *name[]) const
Definition: THnSparse.h:97
TObjArray fBinContent
Array of THnSparseArrayChunk.
Definition: THnSparse.h:40
THnSparseCompactBinCoord * GetCompactCoord() const
Return THnSparseCompactBinCoord object.
Definition: THnSparse.cxx:838
static THnSparse * CreateSparse(const char *name, const char *title, const TH1 *h1, Int_t chunkSize=1024 *16)
Definition: THnSparse.h:76
Double_t GetBinError2(Long64_t linidx) const
Get square of the error of bin addressed by linidx as If errors are not enabled (via Sumw2() or Calc...
Definition: THnSparse.cxx:771
THnSparse()
Construct an empty THnSparse.
Definition: THnSparse.cxx:589
THnSparseArrayChunk * AddChunk()
Create a new chunk of bin content.
Definition: THnSparse.cxx:634
virtual TArray * GenerateArray() const =0
void SetFilledBins(Long64_t nbins)
Definition: THnSparse.h:93
void FillExMap()
We have been streamed; set up fBins.
Definition: THnSparse.cxx:655
THnSparse * Rebin(const Int_t *group) const
Definition: THnSparse.h:161
TH2D * Projection(Int_t yDim, Int_t xDim, Option_t *option="") const
Forwards to THnBase::Projection().
Definition: THnSparse.h:140
void AddBinError2(Long64_t bin, Double_t e2)
Add "e" to error of bin with index "bin", enable errors if needed.
Definition: THnSparse.cxx:931
Long64_t GetBin(const Double_t *x) const
Definition: THnSparse.h:96
THnSparse(const THnSparse &)
TExMap fBins
! Filled bins
Definition: THnSparse.h:41
static THnSparse * CreateSparse(const char *name, const char *title, const THnBase *hn, Int_t chunkSize=1024 *16)
Definition: THnSparse.h:81
THnSparse * Projection(Int_t ndim, const Int_t *dim, Option_t *option="") const
Definition: THnSparse.h:153
TExMap fBinsContinued
! Filled bins for non-unique hashes, containing pairs of (bin index 0, bin index 1)
Definition: THnSparse.h:42
void Sumw2()
Enable calculation of errors.
Definition: THnSparse.cxx:948
void Reserve(Long64_t nbins)
Initialize storage for nbins.
Definition: THnSparse.cxx:689
void AddBinContent(const Int_t *idx, Double_t v=1.)
Forwards to THnBase::SetBinContent().
Definition: THnSparse.h:112
void FillBin(Long64_t bin, Double_t w)
Increment the bin content of "bin" by "w", return the bin index.
Definition: THnSparse.h:66
void SetBinError2(Long64_t bin, Double_t e2)
Set error of bin with index "bin" to "e", enable errors if needed.
Definition: THnSparse.cxx:914
Int_t fChunkSize
Number of entries for each chunk.
Definition: THnSparse.h:38
Long64_t GetNbins() const
Definition: THnSparse.h:92
Long64_t GetBinIndexForCurrentBin(Bool_t allocate)
Return the index for fCurrentBinIndex.
Definition: THnSparse.cxx:789
An array of TObjects.
Definition: TObjArray.h:37
Int_t GetEntriesFast() const
Definition: TObjArray.h:64
Double_t x[n]
Definition: legend1.C:17
TH1F * h1
Definition: legend1.C:5