LSST Applications  21.0.0-172-gfb10e10a+18fedfabac,22.0.0+297cba6710,22.0.0+80564b0ff1,22.0.0+8d77f4f51a,22.0.0+a28f4c53b1,22.0.0+dcf3732eb2,22.0.1-1-g7d6de66+2a20fdde0d,22.0.1-1-g8e32f31+297cba6710,22.0.1-1-geca5380+7fa3b7d9b6,22.0.1-12-g44dc1dc+2a20fdde0d,22.0.1-15-g6a90155+515f58c32b,22.0.1-16-g9282f48+790f5f2caa,22.0.1-2-g92698f7+dcf3732eb2,22.0.1-2-ga9b0f51+7fa3b7d9b6,22.0.1-2-gd1925c9+bf4f0e694f,22.0.1-24-g1ad7a390+a9625a72a8,22.0.1-25-g5bf6245+3ad8ecd50b,22.0.1-25-gb120d7b+8b5510f75f,22.0.1-27-g97737f7+2a20fdde0d,22.0.1-32-gf62ce7b1+aa4237961e,22.0.1-4-g0b3f228+2a20fdde0d,22.0.1-4-g243d05b+871c1b8305,22.0.1-4-g3a563be+32dcf1063f,22.0.1-4-g44f2e3d+9e4ab0f4fa,22.0.1-42-gca6935d93+ba5e5ca3eb,22.0.1-5-g15c806e+85460ae5f3,22.0.1-5-g58711c4+611d128589,22.0.1-5-g75bb458+99c117b92f,22.0.1-6-g1c63a23+7fa3b7d9b6,22.0.1-6-g50866e6+84ff5a128b,22.0.1-6-g8d3140d+720564cf76,22.0.1-6-gd805d02+cc5644f571,22.0.1-8-ge5750ce+85460ae5f3,master-g6e05de7fdc+babf819c66,master-g99da0e417a+8d77f4f51a,w.2021.48
LSST Data Management Base Package
Public Member Functions | List of all members
lsst::jointcal::SparseHisto4d Class Reference

A class to histogram in 4 dimensions. More...

#include <Histo4d.h>

Public Member Functions

 SparseHisto4d ()
 
 SparseHisto4d (const int n1, double min1, double max1, const int n2, double min2, double max2, const int n3, double min3, double max3, const int n4, double min4, double max4, const int nEntries)
 
void fill (const double x[4])
 
void fill (const double x1, const double x2, const double x3, const double x4)
 
int maxBin (double x[4])
 
void zeroBin (double x[4])
 
void binLimits (const double x[4], const int idim, double &xMin, double &xMax) const
 return the bin limits of dimension idim (0<=idim<4), around point X. More...
 
int getNEntries () const
 
 ~SparseHisto4d ()
 
int code_value (const double x[4]) const
 
void inverse_code (const int code, double x[4]) const
 
void sort ()
 
void print () const
 

Detailed Description

A class to histogram in 4 dimensions.

Uses Sparse storage. The number of bin is limited to 256 per dimension. Used in ListMatch.cc

Definition at line 33 of file Histo4d.h.

Constructor & Destructor Documentation

◆ SparseHisto4d() [1/2]

lsst::jointcal::SparseHisto4d::SparseHisto4d ( )
inline

Definition at line 35 of file Histo4d.h.

35 {}

◆ SparseHisto4d() [2/2]

lsst::jointcal::SparseHisto4d::SparseHisto4d ( const int  n1,
double  min1,
double  max1,
const int  n2,
double  min2,
double  max2,
const int  n3,
double  min3,
double  max3,
const int  n4,
double  min4,
double  max4,
const int  nEntries 
)

Definition at line 41 of file Histo4d.cc.

44  : _data(nEntries, 0) {
45  double indexMax = n1 * n2 * n3 * n4;
46  if (indexMax > double(INT_MAX))
47  LOGLS_WARN(_log, "Cannot hold a 4D histo with more than " << INT_MAX << " values.");
48  _n[0] = n1;
49  _n[1] = n2;
50  _n[2] = n3;
51  _n[3] = n4;
52  _minVal[0] = min1;
53  _minVal[1] = min2;
54  _minVal[2] = min3;
55  _minVal[3] = min4;
56  _maxVal[0] = max1;
57  _maxVal[1] = max2;
58  _maxVal[2] = max3;
59  _maxVal[3] = max4;
60 
61  for (int i = 0; i < 4; ++i) _scale[i] = _n[i] / (_maxVal[i] - _minVal[i]);
62  _dataSize = nEntries;
63  _ndata = 0;
64  _sorted = false;
65 }
#define LOGLS_WARN(logger, message)
Log a warn-level message using an iostream-based interface.
Definition: Log.h:659

◆ ~SparseHisto4d()

lsst::jointcal::SparseHisto4d::~SparseHisto4d ( )
inline

Definition at line 56 of file Histo4d.h.

56 {}

Member Function Documentation

◆ binLimits()

void lsst::jointcal::SparseHisto4d::binLimits ( const double  x[4],
const int  idim,
double &  xMin,
double &  xMax 
) const

return the bin limits of dimension idim (0<=idim<4), around point X.

Definition at line 151 of file Histo4d.cc.

151  {
152  int code = code_value(x);
153  double xCenter[4];
154  inverse_code(code, xCenter);
155  xMin = xCenter[iDim] - 0.5 / _scale[iDim];
156  xMax = xCenter[iDim] + 0.5 / _scale[iDim];
157 }
double x
void inverse_code(const int code, double x[4]) const
Definition: Histo4d.cc:77
int code_value(const double x[4]) const
Definition: Histo4d.cc:67

◆ code_value()

int lsst::jointcal::SparseHisto4d::code_value ( const double  x[4]) const

Definition at line 67 of file Histo4d.cc.

67  {
68  int index = 0;
69  for (int idim = 0; idim < 4; ++idim) {
70  int i = (int)std::floor((x[idim] - _minVal[idim]) * _scale[idim]);
71  if (i < 0 || i >= _n[idim]) return -1;
72  index = index * _n[idim] + i;
73  }
74  return index;
75 }
T floor(T... args)

◆ fill() [1/2]

void lsst::jointcal::SparseHisto4d::fill ( const double  x1,
const double  x2,
const double  x3,
const double  x4 
)

Definition at line 105 of file Histo4d.cc.

105  {
106  static double x[4];
107  x[0] = x1;
108  x[1] = x2;
109  x[2] = x3;
110  x[3] = x4;
111  fill(x);
112 }
void fill(const double x[4])
Definition: Histo4d.cc:92

◆ fill() [2/2]

void lsst::jointcal::SparseHisto4d::fill ( const double  x[4])

Definition at line 92 of file Histo4d.cc.

94 {
95  int code = code_value(x);
96  if (code < 0) return;
97  if (_ndata == _dataSize) {
98  _dataSize *= 2;
99  _data.resize(_dataSize);
100  }
101  _data[_ndata++] = code;
102  _sorted = false;
103 }
T resize(T... args)

◆ getNEntries()

int lsst::jointcal::SparseHisto4d::getNEntries ( ) const
inline

Definition at line 54 of file Histo4d.h.

54 { return _ndata; }

◆ inverse_code()

void lsst::jointcal::SparseHisto4d::inverse_code ( const int  code,
double  x[4] 
) const

Definition at line 77 of file Histo4d.cc.

77  {
78  for (int i = 3; i >= 0; --i) {
79  int bin = code % _n[i];
80  code /= _n[i];
81  x[i] = _minVal[i] + ((double)bin + 0.5) / _scale[i];
82  }
83 }

◆ maxBin()

int lsst::jointcal::SparseHisto4d::maxBin ( double  x[4])

Definition at line 114 of file Histo4d.cc.

114  {
115  sort();
116  if (_ndata == 0) return 0;
117  int maxval = _data[0];
118  int maxCount = 1;
119  int oldval = _data[0];
120  int currentCount = 1;
121  for (int i = 1; i < _ndata; ++i) {
122  if (_data[i] == oldval)
123  currentCount++;
124  else
125  currentCount = 1;
126  if (currentCount > maxCount) {
127  maxCount = currentCount;
128  maxval = _data[i];
129  }
130  oldval = _data[i];
131  }
132  inverse_code(maxval, x);
133  return maxCount;
134 }

◆ print()

void lsst::jointcal::SparseHisto4d::print ( ) const

Definition at line 159 of file Histo4d.cc.

159  {
160  for (int i = 0; i < _ndata; ++i) // DEBUG
161  std::cout << _data[i] << ' ';
162  std::cout << std::endl;
163 }
T endl(T... args)

◆ sort()

void lsst::jointcal::SparseHisto4d::sort ( )

Definition at line 85 of file Histo4d.cc.

85  {
86  if (!_sorted) {
87  std::sort(_data.begin(), _data.end());
88  _sorted = true;
89  }
90 }
T begin(T... args)
T end(T... args)
T sort(T... args)

◆ zeroBin()

void lsst::jointcal::SparseHisto4d::zeroBin ( double  x[4])

Definition at line 136 of file Histo4d.cc.

136  {
137  sort();
138  int code = code_value(x);
139  // inefficient locator...
140  int start = 0;
141  while ((_data[start] < code) && start < _ndata) start++;
142  // find how many identical entries we have
143  int end = std::min(start + 1, _ndata);
144  while (end < _ndata && _data[start] == _data[end]) end++;
145  int shift = end - start;
146  int lastShift = _ndata - (end - start);
147  for (int i = start; i < lastShift; ++i) _data[i] = _data[i + shift];
148  _ndata -= shift;
149 }
int end
T min(T... args)

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