/usr/include/root/THn.h is in libroot-hist-dev 5.34.19+dfsg-1.2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 | // @(#)root/hist:$Id$
// Author: Axel Naumann, Nov 2011
/*************************************************************************
* Copyright (C) 1995-2012, Rene Brun and Fons Rademakers. *
* All rights reserved. *
* *
* For the licensing terms see $ROOTSYS/LICENSE. *
* For the list of contributors see $ROOTSYS/README/CREDITS. *
*************************************************************************/
#ifndef ROOT_THN
#define ROOT_THN
#ifndef ROOT_THnBase
#include "THnBase.h"
#endif
#ifndef ROOT_TNDArray
#include "TNDArray.h"
#endif
#ifndef ROOT_TArrayD
#include "TArrayD.h"
#endif
#ifndef ROOT_TObjArray
#include "TObjArray.h"
#endif
#ifndef ROOT_TAxis
#include "TAxis.h"
#endif
#ifndef ROOT_TMath
#include "TMath.h"
#endif
class TH1;
class TH1D;
class TH2D;
class TH3D;
class THnSparse;
class TF1;
class THn: public THnBase {
private:
THn(const THn&); // Not implemented
THn& operator=(const THn&); // Not implemented
protected:
void FillBin(Long64_t bin, Double_t w) {
// Increment the bin content of "bin" by "w",
// return the bin index.
GetArray().AddAt(bin, w);
if (GetCalculateErrors()) {
fSumw2.AddAt(bin, w * w);
}
FillBinBase(w);
}
void AllocCoordBuf() const;
void InitStorage(Int_t* nbins, Int_t chunkSize);
THn(): fCoordBuf() {}
THn(const char* name, const char* title, Int_t dim, const Int_t* nbins,
const Double_t* xmin, const Double_t* xmax);
public:
virtual ~THn();
static THn* CreateHn(const char* name, const char* title, const TH1* h1) {
return (THn*) CreateHnAny(name, title, h1, kFALSE /*THn*/, -1);
}
static THn* CreateHn(const char* name, const char* title, const THnBase* hn) {
return (THn*) CreateHnAny(name, title, hn, kFALSE /*THn*/, -1);
}
ROOT::THnBaseBinIter* CreateIter(Bool_t respectAxisRange) const;
Long64_t GetNbins() const { return GetArray().GetNbins(); }
Long64_t GetBin(const Int_t* idx) const {
return GetArray().GetBin(idx);
}
Long64_t GetBin(const Double_t* x) const {
if (!fCoordBuf) AllocCoordBuf();
for (Int_t d = 0; d < fNdimensions; ++d) {
fCoordBuf[d] = GetAxis(d)->FindFixBin(x[d]);
}
return GetArray().GetBin(fCoordBuf);
}
Long64_t GetBin(const char* name[]) const {
if (!fCoordBuf) AllocCoordBuf();
for (Int_t d = 0; d < fNdimensions; ++d) {
fCoordBuf[d] = GetAxis(d)->FindBin(name[d]);
}
return GetArray().GetBin(fCoordBuf);
}
Long64_t GetBin(const Int_t* idx, Bool_t /*allocate*/ = kTRUE) {
return const_cast<const THn*>(this)->GetBin(idx);
}
Long64_t GetBin(const Double_t* x, Bool_t /*allocate*/ = kTRUE) {
return const_cast<const THn*>(this)->GetBin(x);
}
Long64_t GetBin(const char* name[], Bool_t /*allocate*/ = kTRUE) {
return const_cast<const THn*>(this)->GetBin(name);
}
void SetBinContent(const Int_t* idx, Double_t v) {
// Forwards to THnBase::SetBinContent().
// Non-virtual, CINT-compatible replacement of a using declaration.
THnBase::SetBinContent(idx, v);
}
void SetBinContent(Long64_t bin, Double_t v) {
GetArray().SetAsDouble(bin, v);
}
void SetBinError2(Long64_t bin, Double_t e2) {
if (!GetCalculateErrors()) Sumw2();
fSumw2.At(bin) = e2;
}
void AddBinContent(const Int_t* idx, Double_t v = 1.) {
// Forwards to THnBase::SetBinContent().
// Non-virtual, CINT-compatible replacement of a using declaration.
THnBase::AddBinContent(idx, v);
}
void AddBinContent(Long64_t bin, Double_t v = 1.) {
GetArray().AddAt(bin, v);
}
void AddBinError2(Long64_t bin, Double_t e2) {
fSumw2.At(bin) += e2;
}
Double_t GetBinContent(const Int_t *idx) const {
// Forwards to THnBase::GetBinContent() overload.
// Non-virtual, CINT-compatible replacement of a using declaration.
return THnBase::GetBinContent(idx);
}
Double_t GetBinContent(Long64_t bin, Int_t* idx = 0) const {
// Get the content of bin, and set its index if idx is != 0.
if (idx) {
const TNDArray& arr = GetArray();
Long64_t prevCellSize = arr.GetNbins();
for (Int_t i = 0; i < GetNdimensions(); ++i) {
Long64_t cellSize = arr.GetCellSize(i);
idx[i] = (bin % prevCellSize) / cellSize;
prevCellSize = cellSize;
}
}
return GetArray().AtAsDouble(bin);
}
Double_t GetBinError2(Long64_t linidx) const {
return GetCalculateErrors() ? fSumw2.At(linidx) : GetBinContent(linidx);
}
virtual const TNDArray& GetArray() const = 0;
virtual TNDArray& GetArray() = 0;
void Sumw2();
TH1D* Projection(Int_t xDim, Option_t* option = "") const {
// Forwards to THnBase::Projection().
// Non-virtual, as a CINT-compatible replacement of a using
// declaration.
return THnBase::Projection(xDim, option);
}
TH2D* Projection(Int_t yDim, Int_t xDim,
Option_t* option = "") const {
// Forwards to THnBase::Projection().
// Non-virtual, as a CINT-compatible replacement of a using
// declaration.
return THnBase::Projection(yDim, xDim, option);
}
TH3D* Projection(Int_t xDim, Int_t yDim, Int_t zDim,
Option_t* option = "") const {
// Forwards to THnBase::Projection().
// Non-virtual, as a CINT-compatible replacement of a using
// declaration.
return THnBase::Projection(xDim, yDim, zDim, option);
}
THn* Projection(Int_t ndim, const Int_t* dim,
Option_t* option = "") const {
return (THn*) ProjectionND(ndim, dim, option);
}
THn* Rebin(Int_t group) const {
return (THn*) RebinBase(group);
}
THn* Rebin(const Int_t* group) const {
return (THn*) RebinBase(group);
}
void Reset(Option_t* option = "");
protected:
TNDArrayT<Double_t> fSumw2; // bin error, lazy allocation happens in TNDArrayT
mutable Int_t* fCoordBuf; //! Temporary buffer
ClassDef(THn, 1); //Base class for multi-dimensional histogram
};
//______________________________________________________________________________
//
// Templated implementation of the abstract base THn.
// All functionality and the interfaces to be used are in THn!
//
// THn does not know how to store any bin content itself. Instead, this
// is delegated to the derived, templated class: the template parameter decides
// what the format for the bin content is. The actual storage is delegated to
// TNDArrayT<T>.
//
// Typedefs exist for template parematers with ROOT's generic types:
//
// Templated name Typedef Bin content type
// THnT<Char_t> THnC Char_t
// THnT<Short_t> THnS Short_t
// THnT<Int_t> THnI Int_t
// THnT<Long_t> THnL Long_t
// THnT<Float_t> THnF Float_t
// THnT<Double_t> THnD Double_t
//
// We recommend to use THnC wherever possible, and to map its value space
// of 256 possible values to e.g. float values outside the class. This saves an
// enourmous amount of memory. Only if more than 256 values need to be
// distinguished should e.g. THnS or even THnF be chosen.
//
// Implementation detail: the derived, templated class is kept extremely small
// on purpose. That way the (templated thus inlined) uses of this class will
// only create a small amount of machine code, in contrast to e.g. STL.
//______________________________________________________________________________
template <typename T>
class THnT: public THn {
public:
THnT() {}
THnT(const char* name, const char* title,
Int_t dim, const Int_t* nbins,
const Double_t* xmin, const Double_t* xmax):
THn(name, title, dim, nbins, xmin, xmax),
fArray(dim, nbins, true) {}
const TNDArray& GetArray() const { return fArray; }
TNDArray& GetArray() { return fArray; }
protected:
TNDArrayT<T> fArray; // bin content
ClassDef(THnT, 1); // multi-dimensional histogram with templated storage
};
typedef THnT<Float_t> THnF;
typedef THnT<Double_t> THnD;
typedef THnT<Char_t> THnC;
typedef THnT<Short_t> THnS;
typedef THnT<Int_t> THnI;
typedef THnT<Long_t> THnL;
typedef THnT<Long64_t> THnL64;
#endif // ROOT_THN
|