Anp::Hist1d< T > Class Template Reference

#include <Hist1d.h>

List of all members.

Public Types

typedef std::vector< Anp::Bin
< T > >::const_iterator 
BinIter
typedef std::vector< Anp::Bin
< T > >::iterator 
BinIterator
typedef std::vector< T >
::const_iterator 
Iter
typedef std::vector< T >::iterator Iterator

Public Member Functions

 Hist1d ()
 Hist1d (unsigned int nbin, const T low, const T high)
 Hist1d (const std::vector< T > &vec)
 Hist1d (const TH1 &h)
 ~Hist1d ()
unsigned int Fill (const T value)
unsigned int Fill (const T value, const T weight)
unsigned int Fill (const T value, const T weight, const T width)
unsigned int Fill (const TH1 &h)
unsigned int Merge (const T minvalue)
unsigned int Rebin (unsigned int ngroup)
Bin< T > & operator[] (unsigned int bin)
Bin< T > & GetBin (const T value)
const Bin< T > & operator[] (unsigned int bin) const
const Bin< T > & GetBin (const T value) const
GetIntegral (const std::string &option="") const
unsigned int GetEntries (const std::string &option="") const
unsigned int GetNbins () const
const std::vector< Anp::Bin< T > > & GetBins () const
void Reset ()
void Print (std::ostream &o=std::cout) const

Private Member Functions

const Bin< T > & get_bin_const (const T value) const
Bin< T > & get_bin (const T value)
void init_bins ()
void init_bins (std::vector< T > vec)
void init_trivial ()

Private Attributes

std::vector< Anp::Bin< T > > fData
unsigned int fNBin
fLowEdge
fHighEdge
bool fSearchBin

Detailed Description

template<typename T>
class Anp::Hist1d< T >

Definition at line 85 of file Hist1d.h.


Member Typedef Documentation

template<typename T>
typedef std::vector<Anp::Bin<T> >::const_iterator Anp::Hist1d< T >::BinIter

Definition at line 90 of file Hist1d.h.

template<typename T>
typedef std::vector<Anp::Bin<T> >::iterator Anp::Hist1d< T >::BinIterator

Definition at line 91 of file Hist1d.h.

template<typename T>
typedef std::vector<T>::const_iterator Anp::Hist1d< T >::Iter

Definition at line 93 of file Hist1d.h.

template<typename T>
typedef std::vector<T>::iterator Anp::Hist1d< T >::Iterator

Definition at line 94 of file Hist1d.h.


Constructor & Destructor Documentation

template<typename T >
Anp::Hist1d< T >::Hist1d (  )  [inline]

Definition at line 349 of file Hist1d.h.

References Anp::Hist1d< T >::init_trivial().

00350       : fData(), fNBin(0), fLowEdge(), fHighEdge(), fSearchBin(false)
00351    {    
00352       init_trivial();
00353    }

template<typename T >
Anp::Hist1d< T >::Hist1d ( unsigned int  nbin,
const T  low,
const T  high 
) [inline]

Definition at line 357 of file Hist1d.h.

References Anp::Hist1d< T >::fNBin, Anp::Hist1d< T >::init_bins(), and Anp::Hist1d< T >::init_trivial().

00358       : fData(), fNBin(nbin), fLowEdge(low), fHighEdge(high), fSearchBin(false)
00359    {
00360       if(fNBin > 0)
00361       {
00362          init_bins();
00363       }
00364       else
00365       {
00366          init_trivial();
00367       }
00368    }

template<typename T >
Anp::Hist1d< T >::Hist1d ( const std::vector< T > &  vec  )  [inline, explicit]

Definition at line 372 of file Hist1d.h.

References Anp::Hist1d< T >::init_bins(), and Anp::Hist1d< T >::init_trivial().

00373       : fData(), fNBin(0), fLowEdge(), fHighEdge(), fSearchBin(true)
00374    {
00375       if(vec.size() > 1)
00376       {
00377          init_bins(vec);
00378       }
00379       else
00380       {
00381          init_trivial();
00382       }
00383    }

template<typename T >
Anp::Hist1d< T >::Hist1d ( const TH1 &  h  )  [inline, explicit]

Definition at line 387 of file Hist1d.h.

References Anp::Bin< T >::add(), and Anp::Hist1d< T >::fData.

00388      :fData(),
00389       fNBin(h.GetNbinsX()),
00390       fLowEdge(h.GetXaxis() -> GetXmin()),
00391       fHighEdge(h.GetXaxis() -> GetXmax()),
00392       fSearchBin(true)
00393    {
00394       const int nbin = h.GetNbinsX();
00395       
00396       if(nbin < 2)
00397       { 
00398          std::cerr << "Hist1d<T>::Hist1d encountered TH1 without bins" << std::endl;
00399          return;
00400       }
00401 
00402       for(int ibin = 1; ibin <= nbin + 1; ++ibin)
00403       {
00404          const double value = h.GetBinContent(ibin);
00405          const double edge  = h.GetBinLowEdge(ibin);
00406          
00407          if(ibin == 1)
00408          {
00409             fData.push_back(Bin<T>(0, edge));
00410          }
00411 
00412          Bin<T> bin(ibin, edge);
00413          bin.add(value);
00414 
00415          fData.push_back(bin);
00416       }      
00417 
00418       std::sort(fData.begin(), fData.end());
00419    }

template<typename T >
Anp::Hist1d< T >::~Hist1d (  )  [inline]

Definition at line 423 of file Hist1d.h.

00423 {}


Member Function Documentation

template<typename T >
unsigned int Anp::Hist1d< T >::Fill ( const TH1 &  h  )  [inline]

Definition at line 545 of file Hist1d.h.

References Anp::Hist1d< T >::fData, and Anp::Hist1d< T >::Fill().

00546    {      
00547       const int nbin = h.GetNbinsX();
00548       
00549       assert(nbin > 1 && "Hist1d<T>::Fill encountered TH1 without bins");
00550 
00551       for(int ibin = 0; ibin <= nbin + 1; ++ibin)
00552       {
00553          const double value  = h.GetBinContent(ibin);
00554          const double center = h.GetBinCenter(ibin);
00555          
00556          if(ibin == 0)
00557          {
00558             fData.front().add(value);
00559          }
00560          else if(ibin == nbin + 1)
00561          {
00562             fData.back().add(value);
00563          }
00564          else
00565          {
00566             Fill(center, value);
00567          }
00568       }
00569 
00570       return 0;
00571    }

template<typename T >
unsigned int Anp::Hist1d< T >::Fill ( const T  value,
const T  weight,
const T  width 
) [inline]

Definition at line 445 of file Hist1d.h.

References Anp::Bin< T >::add(), Anp::Bin< T >::bin(), Anp::Hist1d< T >::fData, Anp::Hist1d< T >::Fill(), and Anp::Hist1d< T >::fNBin.

00446    {
00447       if(!(width > 0.0) || fNBin < 1 || fData.empty())
00448       {
00449          return Fill(value, weight);
00450       }
00451 
00452       // compute boundaries for non zero kernel coontributions
00453       const T lpos = value - width;
00454       const T rpos = value + width;
00455 
00456       // Only overlap with underflow or overflow bins
00457       if(rpos < fData.front())
00458       {
00459          // rpos < underflow bin edge - no contribution to other bins
00460          Bin<T> &bin = fData.front();
00461          bin.add(weight);
00462          return bin.bin();
00463       }
00464       else if(!(lpos < fData.back()))
00465       {
00466          // lpos >= last overflow edge - no contribution to other bins
00467          Bin<T> &bin = fData.back();
00468          bin.add(weight);
00469          return bin.bin();
00470       }
00471 
00472       BinIterator lit = std::lower_bound(fData.begin(), fData.end(), lpos);
00473       if(lit == fData.end())
00474       {
00475          std::cerr << "Hist1d<T>::Fill - lower_bound has failed to find correct bin" << std::endl;
00476          return 0;
00477       }       
00478 
00479       // make copy of beg and end iterators
00480       BinIterator ibeg = fData.begin();
00481       BinIterator iend = fData.end();
00482 
00483       //
00484       // special case: compute overlap with underflow bin
00485       //
00486       if(lit == ibeg)
00487       {
00488          if(lpos < ibeg -> edge())
00489          {
00490             ibeg -> add(weight*GetKernelOverlap<T>(lpos, ibeg -> edge(), value, width));
00491          }
00492 
00493          lit++;
00494       }
00495       else
00496       {
00497          lit--;
00498          assert(lit != ibeg && "logic error finding underflow bin");
00499       }
00500 
00501       for(; lit != iend; ++lit)
00502       {  
00503          //
00504          // No more non overlapping bins
00505          //
00506          if(!(lit -> edge() < rpos))
00507          {
00508             break;
00509          }
00510 
00511          //
00512          // Overlap with this bin
00513          //
00514          T overlap = 0;
00515          
00516          const BinIterator nit = lit + 1;
00517          if(nit == iend)
00518          {
00519             overlap = Anp::GetKernelOverlap<T>(lit -> edge(), rpos, value, width);
00520          }
00521          else
00522          {
00523             //
00524             // kernel is entirely contain in a single bin
00525             //
00526             if(lit -> edge() < lpos && rpos < nit -> edge())
00527             {
00528                lit -> add(weight);
00529                break;
00530             }
00531             
00532             overlap = Anp::GetKernelOverlap<T>(std::max<T>(lit -> edge(), lpos),
00533                                                std::min<T>(nit -> edge(), rpos),
00534                                                value, width);
00535          }
00536 
00537          lit -> add(weight*overlap); // compute overlap fraction with this bin
00538       }
00539       
00540       return 0;
00541    }

template<typename T >
unsigned int Anp::Hist1d< T >::Fill ( const T  value,
const T  weight 
) [inline]

Definition at line 436 of file Hist1d.h.

References Anp::Bin< T >::add(), Anp::Bin< T >::bin(), and Anp::Hist1d< T >::get_bin().

00437    {
00438       Bin<T> &bin = get_bin(value);
00439       bin.add(weight);
00440       return bin.bin();
00441    }

template<typename T >
unsigned int Anp::Hist1d< T >::Fill ( const T  value  )  [inline]

Definition at line 427 of file Hist1d.h.

References Anp::Bin< T >::add(), Anp::Bin< T >::bin(), and Anp::Hist1d< T >::get_bin().

Referenced by Anp::Hist1d< T >::Fill(), and Anp::CountHist::Refill().

00428    {
00429       Bin<T> &bin = get_bin(value);
00430       bin.add();
00431       return bin.bin();
00432    }

template<typename T >
Bin< T > & Anp::Hist1d< T >::get_bin ( const T  value  )  [inline, private]

Definition at line 900 of file Hist1d.h.

References Anp::Hist1d< T >::get_bin_const().

Referenced by Anp::Hist1d< T >::Fill(), and Anp::Hist1d< T >::GetBin().

00901    {
00902       return const_cast<Bin<T> &>(get_bin_const(value));
00903    }

template<typename T >
const Bin< T > & Anp::Hist1d< T >::get_bin_const ( const T  value  )  const [inline, private]

Definition at line 843 of file Hist1d.h.

References Anp::Hist1d< T >::fData, Anp::Hist1d< T >::fHighEdge, Anp::Hist1d< T >::fLowEdge, Anp::Hist1d< T >::fNBin, and Anp::Hist1d< T >::fSearchBin.

Referenced by Anp::Hist1d< T >::get_bin(), and Anp::Hist1d< T >::GetBin().

00844    {
00845       assert(!fData.empty() && "Hist1d<T>::get_bin_const() - vector is empty");
00846          
00847       if(fData.size() == 1)
00848       {
00849          return fData.front();
00850       }
00851       else if(value < fData.front())
00852       {
00853          // value < underflow bin edge so return underflow bin
00854          return fData.front();
00855       }
00856       else if(!(value < fData.back()))
00857       {
00858          // value >= last overflow edge so return overflow bin
00859          return fData.back();
00860       }
00861 
00862       // this point is reached if value >= low edge AND value < high edge
00863       // use stl binary_search to find proper bin, exclude underflow bin
00864       
00865       if(fSearchBin)
00866       {
00867          BinIter bit = std::lower_bound(fData.begin() + 1, fData.end(), value);
00868          if(bit == fData.end())
00869          {
00870             std::cerr << "Hist1d<T>::get_bin_const() - lower_bound has failed to find bin" << std::endl;
00871             return fData.back();
00872          }
00873          else if(!(value < *bit) && !(*bit < value))
00874          {
00875             return *bit;
00876          }
00877          
00878          return *(bit - 1);
00879       }
00880       else
00881       {
00882          const unsigned int bin = 
00883             1 + static_cast<unsigned int>((fNBin*(value - fLowEdge))/(fHighEdge - fLowEdge));
00884 
00885          if(bin > fNBin)
00886          {
00887             std::cerr << "Hist1d<T>::get_bin_const() - logic error #1" << std::endl;
00888             return fData.back();
00889          }
00890 
00891          return fData[bin];
00892       }      
00893       
00894       std::cerr << "Hist1d<T>::get_bin_const() - logic error #2" << std::endl;
00895       return fData.front();
00896    }

template<typename T >
const Bin< T > & Anp::Hist1d< T >::GetBin ( const T  value  )  const [inline]

Definition at line 756 of file Hist1d.h.

References Anp::Hist1d< T >::get_bin_const().

00757    {
00758       return get_bin_const(value);
00759    }

template<typename T >
Bin< T > & Anp::Hist1d< T >::GetBin ( const T  value  )  [inline]

Definition at line 734 of file Hist1d.h.

References Anp::Hist1d< T >::get_bin().

00735    {
00736       return get_bin(value);
00737    }

template<typename T >
const std::vector< Anp::Bin< T > > & Anp::Hist1d< T >::GetBins (  )  const [inline]

Definition at line 829 of file Hist1d.h.

References Anp::Hist1d< T >::fData.

Referenced by Anp::CreateTH1().

00829 { return fData; }

template<typename T >
unsigned int Anp::Hist1d< T >::GetEntries ( const std::string &  option = ""  )  const [inline]

Definition at line 763 of file Hist1d.h.

References Anp::Hist1d< T >::fData.

00764    {
00765       if(fData.size() < 2)
00766       {
00767          return 0;
00768       }
00769 
00770       unsigned int entries = 0;
00771       
00772       BinIter beg = fData.begin();
00773       BinIter end = fData.end();
00774       
00775       if(option.find("U") == std::string::npos)
00776       {
00777          beg++;
00778       }
00779       if(option.find("O") == std::string::npos)
00780       {
00781          end--;
00782       }
00783       
00784       for(BinIter cit = beg; cit != end; ++cit)
00785       {  
00786          entries += cit -> entries();
00787       }
00788       
00789       return entries;
00790    }

template<typename T >
T Anp::Hist1d< T >::GetIntegral ( const std::string &  option = ""  )  const [inline]

Definition at line 794 of file Hist1d.h.

References Anp::Hist1d< T >::fData.

Referenced by Anp::CreateTH1().

00795    {
00796       if(fData.size() < 2)
00797       {
00798          return 0;
00799       }
00800 
00801       T integral = 0;
00802 
00803       BinIter beg = fData.begin();
00804       BinIter end = fData.end();
00805       
00806       if(option.find("U") == std::string::npos)
00807       {
00808          beg++;
00809       }
00810       if(option.find("O") == std::string::npos)
00811       {
00812          end--;
00813       }
00814 
00815       for(BinIter cit = beg; cit != end; ++cit)
00816       {  
00817          integral += cit -> sum();
00818       }
00819       
00820       return integral;
00821    }

template<typename T >
unsigned int Anp::Hist1d< T >::GetNbins (  )  const [inline]

Definition at line 825 of file Hist1d.h.

References Anp::Hist1d< T >::fNBin.

00825 { return fNBin; }

template<typename T >
void Anp::Hist1d< T >::init_bins ( std::vector< T >  vec  )  [inline, private]

Definition at line 938 of file Hist1d.h.

References Anp::Hist1d< T >::fData, and Anp::Hist1d< T >::fNBin.

00939    {
00940       assert(vec.size() > 1 && "Hist1d<T>::init_bins() encountered small vector");
00941 
00942       // sort bin edges
00943       std::sort(vec.begin(), vec.end());
00944       
00945       fNBin = vec.size() - 1;
00946       fData.push_back(Bin<T>(0, vec.front()));
00947 
00948       for(unsigned int ibin = 0; ibin < vec.size(); ++ibin)
00949       {
00950          fData.push_back(Bin<T>(ibin + 1, vec[ibin]));
00951       }
00952 
00953       // sort all but first overflow bin
00954       std::sort(fData.begin() + 1, fData.end());
00955    }

template<typename T >
void Anp::Hist1d< T >::init_bins (  )  [inline, private]

Definition at line 915 of file Hist1d.h.

References Anp::Hist1d< T >::fData, Anp::Hist1d< T >::fHighEdge, Anp::Hist1d< T >::fLowEdge, Anp::Hist1d< T >::fNBin, and Anp::Hist1d< T >::init_trivial().

Referenced by Anp::Hist1d< T >::Hist1d().

00916    {
00917       if(!(fLowEdge < fHighEdge))
00918       {
00919          std::cerr << "Hist1d<T>::init_bins() - minimum is not larger than maximum" << std::endl;
00920          init_trivial();
00921          return;
00922       }
00923 
00924       fData.push_back(Bin<T>(0, fLowEdge));
00925 
00926       for(unsigned int ibin = 0; ibin < fNBin + 1; ++ibin)
00927       {
00928          const T edge = fLowEdge + static_cast<T>(((fHighEdge - fLowEdge)*ibin)/fNBin);
00929          fData.push_back(Bin<T>(ibin + 1, edge));
00930       }
00931 
00932       // sort all but first overflow bin
00933       std::sort(fData.begin() + 1, fData.end());
00934    }

template<typename T >
void Anp::Hist1d< T >::init_trivial (  )  [inline, private]

Definition at line 907 of file Hist1d.h.

References Anp::Hist1d< T >::fData, and Anp::Hist1d< T >::fNBin.

Referenced by Anp::Hist1d< T >::Hist1d(), and Anp::Hist1d< T >::init_bins().

00908    {
00909       fNBin = 0;
00910       fData.push_back(Bin<T>(0, T()));
00911    }

template<typename T >
unsigned int Anp::Hist1d< T >::Merge ( const T  minvalue  )  [inline]

Definition at line 575 of file Hist1d.h.

References Anp::Hist1d< T >::fData, and Anp::Hist1d< T >::fNBin.

00576    {
00577       unsigned int nmerge = 0;
00578     
00579       typename std::vector<Bin<T> >::iterator bit = fData.begin();
00580       while(bit != fData.end())
00581       {
00582          if(bit -> sum() > minvalue)
00583          {
00584             ++bit;
00585             continue;
00586          }
00587 
00588          if(bit == fData.begin() || bit - 1 == fData.begin())
00589          {
00590             ++bit;
00591             continue;
00592          }
00593 
00594          if(bit + 1 == fData.end() || bit + 2 == fData.end())
00595          {
00596             ++bit;
00597             continue;
00598          }
00599          
00600          typename std::vector<Bin<T> >::iterator lit = bit - 1;
00601          typename std::vector<Bin<T> >::iterator hit = bit + 1;
00602         
00603          if(lit -> sum() < hit -> sum())
00604          {
00605             const Bin<T> newbin(*lit, *bit);
00606 
00607             typename std::vector<Bin<T> >::iterator pit = fData.erase(lit, bit + 1);
00608 
00609             fData.insert(pit, newbin);
00610          }
00611          else
00612          {
00613             const Bin<T> newbin(*bit, *hit);
00614 
00615             typename std::vector<Bin<T> >::iterator pit = fData.erase(bit, hit + 1);
00616 
00617             fData.insert(pit, newbin);
00618          }
00619          
00620          bit = fData.begin();
00621 
00622          ++nmerge;
00623       }
00624 
00625       BinIterator pit = fData.begin();
00626       for(BinIterator cit = fData.begin(); cit != fData.end(); ++cit)
00627       {  
00628          if(cit == fData.begin() || cit - 1 == fData.begin())
00629          {
00630             pit = cit;
00631             continue;
00632          }
00633 
00634          if(!(pit -> edge() < cit -> edge()) || !(pit -> bin() < cit -> bin()))
00635          {
00636             std::cerr << "Hist1d<T>::Merge - logic error for bin " << cit -> bin() << std::endl;
00637          }
00638 
00639          pit = cit;
00640 
00641          cit -> set_bin(std::distance(fData.begin(), cit));
00642          
00643       }
00644 
00645       fNBin = fData.size() - 2;
00646 
00647       return nmerge;
00648    }

template<typename T >
const Bin< T > & Anp::Hist1d< T >::operator[] ( unsigned int  bin  )  const [inline]

Definition at line 741 of file Hist1d.h.

References Anp::Hist1d< T >::fData.

00742    {
00743       assert(!fData.empty() && "empty bin vector in Hist1d<T>::operator[]");
00744 
00745       if(bin >= fData.size())
00746       {
00747          std::cerr << "Hist1d<T>::operator[" << bin << "] is out of range" << std::endl;
00748          return fData.back();
00749       }
00750       
00751       return fData[bin];
00752    }

template<typename T >
Bin< T > & Anp::Hist1d< T >::operator[] ( unsigned int  bin  )  [inline]

Definition at line 719 of file Hist1d.h.

References Anp::Hist1d< T >::fData.

00720    {
00721       assert(!fData.empty() && "empty bin vector in Hist1d<T>::operator[]");
00722 
00723       if(bin >= fData.size())
00724       {
00725          std::cerr << "Hist1d<T>::operator[" << bin << "] is out of range" << std::endl;
00726          return fData.back();
00727       }
00728       
00729       return fData[bin];
00730    }

template<typename T >
void Anp::Hist1d< T >::Print ( std::ostream &  o = std::cout  )  const [inline]

Definition at line 959 of file Hist1d.h.

References Anp::Hist1d< T >::fData, Anp::Hist1d< T >::fNBin, it, and print().

00960    {
00961       o << "Printing 1d histogram containing " << fNBin << " bins" << std::endl;
00962 
00963       short width = 1;      
00964       for(short i = 1; i < 10; ++i)
00965       {
00966          if(fNBin < 10^(i))
00967          {
00968             width = i;
00969             break;
00970          }
00971       }
00972       if(width < 4)
00973       {
00974          width = 4;
00975       }
00976 
00977       for(BinIter it = fData.begin(); it != fData.end(); ++it)
00978       {
00979          it -> print(o, width, width);
00980       }
00981    }

template<typename T >
unsigned int Anp::Hist1d< T >::Rebin ( unsigned int  ngroup  )  [inline]

Definition at line 652 of file Hist1d.h.

References Anp::Hist1d< T >::fData, Anp::Hist1d< T >::fNBin, Anp::Hist1d< T >::fSearchBin, and Anp::Bin< T >::set_bin().

00653    {
00654       //
00655       // rebin histogram by adding ngroup bins together
00656       //
00657 
00658       if(ngroup < 1 || ngroup >= fNBin || fData.size() < 3)
00659       {
00660          return 0;
00661       }
00662 
00663       std::vector<Anp::Bin<T> > data;
00664       bool newbin = true;
00665       Bin<T> bin;
00666 
00667       assert(int(fNBin) == int(fData.size()) - 2 && "logic error counting bins");
00668 
00669       for(unsigned int ibin = 1; ibin <= fNBin; ++ibin)
00670       {
00671          assert(ibin < fData.size() && "out of bounds access");
00672 
00673          if(newbin)
00674          {
00675             bin = fData[ibin];
00676             newbin = false;
00677             continue;
00678          }
00679 
00680          bin = Anp::Merge<T>(bin, fData[ibin]);
00681 
00682          if(ibin % ngroup == 0)
00683          {
00684             data.push_back(bin);
00685             newbin = true;
00686          }
00687       }
00688 
00689       //
00690       // Add last bin
00691       //
00692       if(!newbin) data.push_back(bin);
00693 
00694       //
00695       // sort bins
00696       //
00697       std::sort(data.begin(), data.end());
00698       
00699       //
00700       // Add overflow and underflow bins
00701       //
00702       data.insert(data.begin(), fData.front());
00703       data.insert(data.end(),   fData.back());
00704       
00705       for(unsigned int ibin = 0; ibin < data.size(); ibin++)
00706       {
00707          data[ibin].set_bin(ibin);
00708       }
00709       
00710       fData = data;
00711       fNBin = data.size() - 2;
00712       fSearchBin = true;
00713 
00714       return fNBin;
00715    }

template<typename T >
void Anp::Hist1d< T >::Reset (  )  [inline]

Definition at line 833 of file Hist1d.h.

References Anp::Hist1d< T >::fData.

Referenced by Anp::CountHist::Refill().

00834    {
00835       for(BinIterator cit = fData.begin(); cit != fData.end(); ++cit)
00836       {  
00837          cit -> reset();
00838       }
00839    }


Member Data Documentation

template<typename T>
std::vector<Anp::Bin<T> > Anp::Hist1d< T >::fData [private]
template<typename T>
T Anp::Hist1d< T >::fHighEdge [private]

Definition at line 145 of file Hist1d.h.

Referenced by Anp::Hist1d< T >::get_bin_const(), and Anp::Hist1d< T >::init_bins().

template<typename T>
T Anp::Hist1d< T >::fLowEdge [private]

Definition at line 144 of file Hist1d.h.

Referenced by Anp::Hist1d< T >::get_bin_const(), and Anp::Hist1d< T >::init_bins().

template<typename T>
unsigned int Anp::Hist1d< T >::fNBin [private]
template<typename T>
bool Anp::Hist1d< T >::fSearchBin [private]

Definition at line 147 of file Hist1d.h.

Referenced by Anp::Hist1d< T >::get_bin_const(), and Anp::Hist1d< T >::Rebin().


The documentation for this class was generated from the following file:

Generated on 11 Jan 2018 for loon by  doxygen 1.6.1