include/root/THnSparse.h

0001 // @(#)root/hist:$Id$
0002 // Author: Axel Naumann (2007-09-11)
0003
0004 /*************************************************************************
0005  * Copyright (C) 1995-2012, Rene Brun and Fons Rademakers.               *
0006  * All rights reserved.                                                  *
0007  *                                                                       *
0008  * For the licensing terms see $ROOTSYS/LICENSE.                         *
0009  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
0010  *************************************************************************/
0011
0012 #ifndef ROOT_THnSparse
0013 #define ROOT_THnSparse
0014
0015 /*************************************************************************
0016
0017  THnSparse: histogramming multi-dimensional, sparse distributions in
0018  a memory-efficient way.
0019
0020 *************************************************************************/
0021
0022
0023 #include "THnBase.h"
0024 #include "TExMap.h"
0025 #include "THnSparse_Internal.h"
0026
0027 // needed only for template instantiations of THnSparseT:
0028 #include "TArrayF.h"
0029 #include "TArrayL.h"
0030 #include "TArrayL64.h"
0031 #include "TArrayI.h"
0032 #include "TArrayS.h"
0033 #include "TArrayC.h"
0034
0035 class THnSparseCompactBinCoord;
0036
0037 class THnSparse: public THnBase {
0038  private:
0039    Int_t      fChunkSize;                   ///<  Number of entries for each chunk
0040    Long64_t   fFilledBins;                  ///<  Number of filled bins
0041    TObjArray  fBinContent;                  ///<  Array of THnSparseArrayChunk
0042    TExMap     fBins;                        ///<! Filled bins
0043    TExMap     fBinsContinued;               ///<! Filled bins for non-unique hashes, containing pairs of (bin index 0, bin index 1)
0044    THnSparseCompactBinCoord *fCompactCoord; ///<! Compact coordinate
0045
0046    THnSparse(const THnSparse&) = delete;
0047    THnSparse& operator=(const THnSparse&) = delete;
0048
0049  protected:
0050
0051    THnSparse();
0052    THnSparse(const char* name, const char* title, Int_t dim,
0053              const Int_t* nbins, const Double_t* xmin, const Double_t* xmax,
0054              Int_t chunksize);
0055    THnSparseCompactBinCoord* GetCompactCoord() const;
0056    THnSparseArrayChunk* GetChunk(Int_t idx) const {
0057       return (THnSparseArrayChunk*) fBinContent[idx]; }
0058
0059    THnSparseArrayChunk* AddChunk();
0060    void Reserve(Long64_t nbins) override;
0061    void FillExMap();
0062    virtual TArray* GenerateArray() const = 0;
0063    Long64_t GetBinIndexForCurrentBin(Bool_t allocate);
0064
0065    /// Increment the bin content of "bin" by "w",
0066    /// return the bin index.
0067    void FillBin(Long64_t bin, Double_t w) override {
0068       THnSparseArrayChunk* chunk = GetChunk(bin / fChunkSize);
0069       chunk->AddBinContent(bin % fChunkSize, w);
0070       FillBinBase(w);
0071    }
0072    void InitStorage(Int_t* nbins, Int_t chunkSize) override;
0073
0074  public:
0075    ~THnSparse() override;
0076
0077    static THnSparse* CreateSparse(const char* name, const char* title,
0078                                   const TH1* h1, Int_t chunkSize = 1024 * 16) {
0079       return (THnSparse*) CreateHnAny(name, title, h1, kTRUE /*sparse*/,
0080                                        chunkSize);
0081    }
0082    static THnSparse* CreateSparse(const char* name, const char* title,
0083                                   const THnBase* hn, Int_t chunkSize = 1024 * 16) {
0084       return (THnSparse*) CreateHnAny(name, title, hn, kTRUE /*sparse*/,
0085                                        chunkSize);
0086    }
0087
0088    Int_t GetChunkSize() const { return fChunkSize; }
0089    Int_t GetNChunks() const { return fBinContent.GetEntriesFast(); }
0090
0091    ROOT::Internal::THnBaseBinIter* CreateIter(Bool_t respectAxisRange) const override;
0092
0093    Long64_t GetNbins() const override { return fFilledBins; }
0094    void SetFilledBins(Long64_t nbins) override { fFilledBins = nbins; }
0095
0096    Long64_t GetBin(const Int_t* idx) const override { return const_cast<THnSparse*>(this)->GetBin(idx, kFALSE); }
0097    Long64_t GetBin(const Double_t* x) const override { return const_cast<THnSparse*>(this)->GetBin(x, kFALSE); }
0098    Long64_t GetBin(const char* name[]) const override { return const_cast<THnSparse*>(this)->GetBin(name, kFALSE); }
0099    Long64_t GetBin(const Int_t* idx, Bool_t allocate = kTRUE) override;
0100    Long64_t GetBin(const Double_t* x, Bool_t allocate = kTRUE) override;
0101    Long64_t GetBin(const char* name[], Bool_t allocate = kTRUE) override;
0102
0103    /// Forwards to THnBase::SetBinContent().
0104    /// Non-virtual, CINT-compatible replacement of a using declaration.
0105    void SetBinContent(const Int_t* idx, Double_t v) {
0106       THnBase::SetBinContent(idx, v);
0107    }
0108    void SetBinContent(Long64_t bin, Double_t v) override;
0109    void SetBinError2(Long64_t bin, Double_t e2) override;
0110
0111    /// Forwards to THnBase::AddBinContent().
0112    /// Non-virtual, CINT-compatible replacement of a using declaration.
0113    void AddBinContent(const Int_t* idx, Double_t v = 1.) {
0114       THnBase::AddBinContent(idx, v);
0115    }
0116    void AddBinContent(Long64_t bin, Double_t v = 1.) override;
0117    void AddBinError2(Long64_t bin, Double_t e2) override;
0118
0119    /// Forwards to THnBase::GetBinContent() overload.
0120    /// Non-virtual, CINT-compatible replacement of a using declaration.
0121    Double_t GetBinContent(const Int_t *idx) const {
0122
0123       return THnBase::GetBinContent(idx);
0124    }
0125    Double_t GetBinContent(Long64_t bin, Int_t* idx = nullptr) const override;
0126    Double_t GetBinError2(Long64_t linidx) const override;
0127
0128    Double_t GetSparseFractionBins() const;
0129    Double_t GetSparseFractionMem() const;
0130
0131    /// Forwards to THnBase::Projection().
0132    /// Non-virtual, as a CINT-compatible replacement of a using
0133    /// declaration.
0134    TH1D*      Projection(Int_t xDim, Option_t* option = "") const{
0135       return THnBase::Projection(xDim, option);
0136    }
0137
0138    /// Forwards to THnBase::Projection().
0139    /// Non-virtual, as a CINT-compatible replacement of a using
0140    /// declaration.
0141    TH2D*      Projection(Int_t yDim, Int_t xDim,
0142                          Option_t* option = "") const {
0143       return THnBase::Projection(yDim, xDim, option);
0144    }
0145
0146    /// Forwards to THnBase::Projection().
0147    /// Non-virtual, as a CINT-compatible replacement of a using
0148    /// declaration.
0149    TH3D*      Projection(Int_t xDim, Int_t yDim, Int_t zDim,
0150                          Option_t* option = "") const {
0151       return THnBase::Projection(xDim, yDim, zDim, option);
0152    }
0153
0154    THnSparse* Projection(Int_t ndim, const Int_t* dim,
0155                          Option_t* option = "") const {
0156       return (THnSparse*) ProjectionND(ndim, dim, option);
0157    }
0158
0159    THnSparse* Rebin(Int_t group) const {
0160       return (THnSparse*) RebinBase(group);
0161    }
0162    THnSparse* Rebin(const Int_t* group) const {
0163       return (THnSparse*) RebinBase(group);
0164    }
0165
0166    void Reset(Option_t* option = "") override;
0167    void Sumw2() override;
0168
0169    ClassDefOverride(THnSparse, 3); // Interfaces of sparse n-dimensional histogram
0170 };
0171
0172
0173
0174 //______________________________________________________________________________
0175 /** \class THnSparseT
0176  Templated implementation of the abstract base THnSparse.
0177  All functionality and the interfaces to be used are in THnSparse!
0178
0179  THnSparse does not know how to store any bin content itself. Instead, this
0180  is delegated to the derived, templated class: the template parameter decides
0181  what the format for the bin content is. In fact it even defines the array
0182  itself; possible implementations probably derive from TArray.
0183
0184  Typedefs exist for template parameters with ROOT's generic types:
0185
0186  Templated name        |    Typedef    |    Bin content type
0187  ----------------------|---------------|--------------------
0188  THnSparseT<TArrayC>   |  THnSparseC   |  Char_t
0189  THnSparseT<TArrayS>   |  THnSparseS   |  Short_t
0190  THnSparseT<TArrayI>   |  THnSparseI   |  Int_t
0191  THnSparseT<TArrayL64> |  THnSparseL   |  Long64_t
0192  THnSparseT<TArrayF>   |  THnSparseF   |  Float_t
0193  THnSparseT<TArrayD>   |  THnSparseD   |  Double_t
0194
0195  We recommend to use THnSparseC wherever possible, and to map its value space
0196  of 256 possible values to e.g. float values outside the class. This saves an
0197  enormous amount of memory. Only if more than 256 values need to be
0198  distinguished should e.g. THnSparseS or even THnSparseF be chosen.
0199
0200  Implementation detail: the derived, templated class is kept extremely small
0201  on purpose. That way the (templated thus inlined) uses of this class will
0202  only create a small amount of machine code, in contrast to e.g. STL.
0203 */
0204
0205
0206 template <class CONT>
0207 class THnSparseT: public THnSparse {
0208  public:
0209    THnSparseT() {}
0210    THnSparseT(const char* name, const char* title, Int_t dim,
0211               const Int_t* nbins, const Double_t* xmin = nullptr,
0212               const Double_t* xmax = nullptr, Int_t chunksize = 1024 * 16):
0213       THnSparse(name, title, dim, nbins, xmin, xmax, chunksize) {}
0214
0215    TArray* GenerateArray() const override { return new CONT(GetChunkSize()); }
0216  private:
0217    ClassDefOverride(THnSparseT, 1); // Sparse n-dimensional histogram with templated content
0218 };
0219
0220 typedef THnSparseT<TArrayD> THnSparseD;
0221 typedef THnSparseT<TArrayF> THnSparseF;
0222 typedef THnSparseT<TArrayL64> THnSparseL;
0223 typedef THnSparseT<TArrayI> THnSparseI;
0224 typedef THnSparseT<TArrayS> THnSparseS;
0225 typedef THnSparseT<TArrayC> THnSparseC;
0226
0227
0228 #endif //  ROOT_THnSparse