Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
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
float xmax
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:312
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:191
TH1D * Projection(Int_t xDim, Option_t *option="") const
Project all bins into a 1-dimensional histogram, keeping only axis "xDim".
Definition THnBase.h:224
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:296
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:1168
THnBase * ProjectionND(Int_t ndim, const Int_t *dim, Option_t *option="") const
Definition THnBase.h:255
Double_t GetBinContent(const Int_t *idx) const
Definition THnBase.h:195
void SetBinContent(const Int_t *idx, Double_t v)
Definition THnBase.h:205
void FillBinBase(Double_t w)
Increment the statistics due to filled weight "w",.
Definition THnBase.h:89
THnSparseArrayChunk is used internally by THnSparse.
void AddBinContent(Int_t idx, Double_t v=1.)
THnSparseCompactBinCoord is a class used by THnSparse internally.
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.
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...
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()
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.
ROOT::Internal::THnBaseBinIter * CreateIter(Bool_t respectAxisRange) const
Create an iterator over all filled bins of a THnSparse.
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.
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.
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...
THnSparse()
Construct an empty THnSparse.
THnSparseArrayChunk * AddChunk()
Create a new chunk of bin content.
virtual TArray * GenerateArray() const =0
void SetFilledBins(Long64_t nbins)
Definition THnSparse.h:93
void FillExMap()
We have been streamed; set up fBins.
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.
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.
void Reserve(Long64_t nbins)
Initialize storage for nbins.
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.
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.
An array of TObjects.
Definition TObjArray.h:31
Int_t GetEntriesFast() const
Definition TObjArray.h:58
Double_t x[n]
Definition legend1.C:17
TH1F * h1
Definition legend1.C:5