LSSTApplications  18.0.0+106,18.0.0+50,19.0.0,19.0.0+1,19.0.0+10,19.0.0+11,19.0.0+13,19.0.0+17,19.0.0+2,19.0.0-1-g20d9b18+6,19.0.0-1-g425ff20,19.0.0-1-g5549ca4,19.0.0-1-g580fafe+6,19.0.0-1-g6fe20d0+1,19.0.0-1-g7011481+9,19.0.0-1-g8c57eb9+6,19.0.0-1-gb5175dc+11,19.0.0-1-gdc0e4a7+9,19.0.0-1-ge272bc4+6,19.0.0-1-ge3aa853,19.0.0-10-g448f008b,19.0.0-12-g6990b2c,19.0.0-2-g0d9f9cd+11,19.0.0-2-g3d9e4fb2+11,19.0.0-2-g5037de4,19.0.0-2-gb96a1c4+3,19.0.0-2-gd955cfd+15,19.0.0-3-g2d13df8,19.0.0-3-g6f3c7dc,19.0.0-4-g725f80e+11,19.0.0-4-ga671dab3b+1,19.0.0-4-gad373c5+3,19.0.0-5-ga2acb9c+2,19.0.0-5-gfe96e6c+2,w.2020.01
LSSTDataManagementBasePackage
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 dump () 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.

43  {
44  double indexMax = n1 * n2 * n3 * n4;
45  _data.reset();
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  _data.reset(new int[nEntries]);
63  _dataSize = nEntries;
64  _ndata = 0;
65  _sorted = false;
66 }
LOGLS_WARN
#define LOGLS_WARN(logger, message)
Log a warn-level message using an iostream-based interface.
Definition: Log.h:648
std::unique_ptr::reset
T reset(T... args)

◆ ~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 154 of file Histo4d.cc.

154  {
155  int code = code_value(x);
156  double xCenter[4];
157  inverse_code(code, xCenter);
158  xMin = xCenter[iDim] - 0.5 / _scale[iDim];
159  xMax = xCenter[iDim] + 0.5 / _scale[iDim];
160 }
lsst::jointcal::SparseHisto4d::code_value
int code_value(const double x[4]) const
Definition: Histo4d.cc:68
lsst::jointcal::SparseHisto4d::inverse_code
void inverse_code(const int code, double x[4]) const
Definition: Histo4d.cc:78
x
double x
Definition: ChebyshevBoundedField.cc:277

◆ code_value()

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

Definition at line 68 of file Histo4d.cc.

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

◆ dump()

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

Definition at line 162 of file Histo4d.cc.

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

◆ fill() [1/2]

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

Definition at line 93 of file Histo4d.cc.

95 {
96  int code = code_value(x);
97  if (code < 0) return;
98  if (_ndata == _dataSize) {
99  std::unique_ptr<int[]> newData(new int[_dataSize * 2]);
100  memcpy(newData.get(), _data.get(), _dataSize * sizeof(_data[0]));
101  _data.swap(newData);
102  _dataSize *= 2;
103  }
104  _data[_ndata++] = code;
105  _sorted = false;
106 }
lsst::jointcal::SparseHisto4d::code_value
int code_value(const double x[4]) const
Definition: Histo4d.cc:68
std::unique_ptr::swap
T swap(T... args)
std::memcpy
T memcpy(T... args)
x
double x
Definition: ChebyshevBoundedField.cc:277
std::unique_ptr::get
T get(T... args)

◆ fill() [2/2]

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

Definition at line 108 of file Histo4d.cc.

108  {
109  static double x[4];
110  x[0] = x1;
111  x[1] = x2;
112  x[2] = x3;
113  x[3] = x4;
114  fill(x);
115 }
lsst::jointcal::SparseHisto4d::fill
void fill(const double x[4])
Definition: Histo4d.cc:93
x
double x
Definition: ChebyshevBoundedField.cc:277

◆ 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 78 of file Histo4d.cc.

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

◆ maxBin()

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

Definition at line 117 of file Histo4d.cc.

117  {
118  sort();
119  if (_ndata == 0) return 0;
120  int maxval = _data[0];
121  int maxCount = 1;
122  int oldval = _data[0];
123  int currentCount = 1;
124  for (int i = 1; i < _ndata; ++i) {
125  if (_data[i] == oldval)
126  currentCount++;
127  else
128  currentCount = 1;
129  if (currentCount > maxCount) {
130  maxCount = currentCount;
131  maxval = _data[i];
132  }
133  oldval = _data[i];
134  }
135  inverse_code(maxval, x);
136  return maxCount;
137 }
lsst::jointcal::SparseHisto4d::inverse_code
void inverse_code(const int code, double x[4]) const
Definition: Histo4d.cc:78
x
double x
Definition: ChebyshevBoundedField.cc:277

◆ sort()

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

Definition at line 86 of file Histo4d.cc.

86  {
87  if (!_sorted) {
88  std::sort(_data.get(), _data.get() + _ndata);
89  _sorted = true;
90  }
91 }
std::unique_ptr::get
T get(T... args)
std::sort
T sort(T... args)

◆ zeroBin()

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

Definition at line 139 of file Histo4d.cc.

139  {
140  sort();
141  int code = code_value(x);
142  // inefficient locator...
143  int start = 0;
144  while ((_data[start] < code) && start < _ndata) start++;
145  // find how many identical entries we have
146  int end = std::min(start + 1, _ndata);
147  while (end < _ndata && _data[start] == _data[end]) end++;
148  int shift = end - start;
149  int lastShift = _ndata - (end - start);
150  for (int i = start; i < lastShift; ++i) _data[i] = _data[i + shift];
151  _ndata -= shift;
152 }
lsst::jointcal::SparseHisto4d::code_value
int code_value(const double x[4]) const
Definition: Histo4d.cc:68
std::min
T min(T... args)
x
double x
Definition: ChebyshevBoundedField.cc:277
end
int end
Definition: BoundedField.cc:105
The documentation for this class was generated from the following files:
Generated on Wed Jan 8 2020 09:12:28 for LSSTApplications by   doxygen 1.8.13