LSSTApplications  20.0.0
LSSTDataManagementBasePackage
arrays.cc
Go to the documentation of this file.
1 // -*- lsst-c++ -*-
2 /*
3  * LSST Data Management System
4  * Copyright 2008-2016 LSST Corporation.
5  *
6  * This product includes software developed by the
7  * LSST Project (http://www.lsst.org/).
8  *
9  * This program is free software: you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation, either version 3 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the LSST License Statement and
20  * the GNU General Public License along with this program. If not,
21  * see <http://www.lsstcorp.org/LegalNotices/>.
22  */
23 
24 #include <string>
25 
27 #include "lsst/afw/table/arrays.h"
29 
30 namespace lsst {
31 namespace afw {
32 namespace table {
33 
34 template <typename T>
36  std::string const &unit, std::vector<T> const &docData) {
38  if (docData.empty()) return result;
39  result._size = docData.size();
40  result._begin = schema.addField<T>(
41  schema.join(name, "0"), // we use getPrefix in order to get the version-dependent delimiter
42  (boost::format(doc) % docData.front()).str(), unit);
43  for (int i = 1; i < result._size; ++i) {
44  schema.addField<T>(schema.join(name, std::to_string(i)), (boost::format(doc) % docData[i]).str(),
45  unit);
46  }
47  return result;
48 }
49 
50 template <typename T>
52  std::string const &unit, int size) {
54  if (size == 0) return result;
55  result._size = size;
56  result._begin = schema.addField<T>(
57  schema.join(name, "0"), // we use getPrefix in order to get the version-dependent delimiter
58  doc, unit);
59  for (int i = 1; i < result._size; ++i) {
60  schema.addField<T>(schema.join(name, std::to_string(i)), doc, unit);
61  }
62  return result;
63 }
64 
65 template <typename T>
66 ArrayKey<T>::ArrayKey(std::vector<Key<T> > const &keys) : _begin(), _size(keys.size()) {
67  if (keys.empty()) return;
68  _begin = keys.front();
69  for (int i = 1; i < _size; ++i) {
70  if (keys[i].getOffset() - _begin.getOffset() != static_cast<int>(i * sizeof(T))) {
72  "Keys passed to ArrayKey constructor are not contiguous");
73  }
74  }
75 }
76 
77 template <typename T>
78 ArrayKey<T>::ArrayKey(Key<Array<T> > const &other) noexcept : _begin(other[0]), _size(other.getSize()) {}
79 
80 template <typename T>
81 ArrayKey<T>::ArrayKey(SubSchema const &s) : _begin(s["0"]), _size(1) {
82  Key<T> current;
83  while (true) {
84  try {
85  current = s[std::to_string(_size)];
86  } catch (pex::exceptions::NotFoundError &) {
87  return;
88  }
89  if (current.getOffset() - _begin.getOffset() != static_cast<int>(_size * sizeof(T))) {
91  "Keys discovered in Schema are not contiguous");
92  }
93  ++_size;
94  }
95 }
96 
97 template <typename T>
98 ArrayKey<T>::ArrayKey(ArrayKey const &) noexcept = default;
99 template <typename T>
100 ArrayKey<T>::ArrayKey(ArrayKey &&) noexcept = default;
101 template <typename T>
102 ArrayKey<T> &ArrayKey<T>::operator=(ArrayKey const &) noexcept = default;
103 template <typename T>
104 ArrayKey<T> &ArrayKey<T>::operator=(ArrayKey &&) noexcept = default;
105 template <typename T>
106 ArrayKey<T>::~ArrayKey() noexcept = default;
107 
108 template <typename T>
109 ndarray::Array<T const, 1, 1> ArrayKey<T>::get(BaseRecord const &record) const {
110  return ndarray::external(record.getElement(_begin), ndarray::makeVector(_size), ndarray::ROW_MAJOR,
111  record.getManager());
112 }
113 
114 template <typename T>
115 void ArrayKey<T>::set(BaseRecord &record, ndarray::Array<T const, 1, 1> const &value) const {
116  LSST_THROW_IF_NE(value.template getSize<0>(), static_cast<std::size_t>(_size),
118  "Size of input array (%d) does not match size of array field (%d)");
119  std::copy(value.begin(), value.end(), record.getElement(_begin));
120 }
121 
122 template <typename T>
123 ndarray::ArrayRef<T, 1, 1> ArrayKey<T>::getReference(BaseRecord &record) const {
124  return ndarray::external(record.getElement(_begin), ndarray::makeVector(_size), ndarray::ROW_MAJOR,
125  record.getManager());
126 }
127 
128 template <typename T>
129 ndarray::ArrayRef<T const, 1, 1> ArrayKey<T>::getConstReference(BaseRecord const &record) const {
130  return ndarray::external(record.getElement(_begin), ndarray::makeVector(_size), ndarray::ROW_MAJOR,
131  record.getManager());
132 }
133 
134 template <typename T>
136  if (i < 0 || i >= _size) {
137  throw LSST_EXCEPT(pex::exceptions::LengthError, "ArrayKey index does not fit within valid range");
138  }
139  return detail::Access::makeKey<T>(_begin.getOffset() + i * sizeof(T));
140 }
141 
142 template <typename T>
143 ArrayKey<T> ArrayKey<T>::slice(int begin, int end) const {
144  if (begin < 0 || end > _size) {
146  "ArrayKey slice range does not fit within valid range");
147  }
148  return ArrayKey((*this)[begin], end - begin);
149 }
150 
151 template class ArrayKey<float>;
152 template class ArrayKey<double>;
153 } // namespace table
154 } // namespace afw
155 } // namespace lsst
schema
table::Schema schema
Definition: Amplifier.cc:115
LSST_THROW_IF_NE
#define LSST_THROW_IF_NE(N1, N2, EXC_CLASS, MSG)
Check whether the given values are equal, and throw an LSST Exception if they are not.
Definition: asserts.h:38
std::string
STL class.
lsst::meas::modelfit::ArrayKey
afw::table::Key< afw::table::Array< Scalar > > ArrayKey
Definition: common.h:48
std::vector
STL class.
std::vector::size
T size(T... args)
lsst::pex::exceptions::NotFoundError
Reports attempts to access elements using an invalid key.
Definition: Runtime.h:151
pex.config.history.format
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:174
lsst::afw
Definition: imageAlgorithm.dox:1
astshim.keyMap.keyMapContinued.keys
def keys(self)
Definition: keyMapContinued.py:6
lsst::afw::table::Schema
Defines the fields and offsets for a table.
Definition: Schema.h:50
lsst::afw::geom.transform.transformContinued.name
string name
Definition: transformContinued.py:32
lsst::afw::table::BaseRecord::getManager
ndarray::Manager::Ptr getManager() const
Definition: BaseRecord.h:200
std::vector::front
T front(T... args)
lsst::afw::table::BaseRecord::getElement
Field< T >::Element * getElement(Key< T > const &key)
Return a pointer to the underlying elements of a field (non-const).
Definition: BaseRecord.h:93
lsst::afw::table::ArrayKey
A FunctorKey used to get or set a ndarray::Array from a sequence of scalar Keys.
Definition: arrays.h:45
end
int end
Definition: BoundedField.cc:105
BaseRecord.h
_size
table::Key< table::Array< int > > _size
Definition: PsfexPsf.cc:364
ndarray
Definition: SpanSetFunctorGetters.h:303
lsst::afw::table::ArrayKey::ArrayKey
ArrayKey() noexcept
Default constructor; instance will not be usable unless subsequently assigned to.
Definition: arrays.h:78
lsst::pex::exceptions::LengthError
Reports attempts to exceed implementation-defined length limits for some classes.
Definition: Runtime.h:76
other
ItemVariant const * other
Definition: Schema.cc:56
lsst::afw::table::BaseRecord
Base class for all records.
Definition: BaseRecord.h:31
std::to_string
T to_string(T... args)
lsst::afw::table::Key
A class used as a handle to a particular field in a table.
Definition: fwd.h:45
std::copy
T copy(T... args)
lsst::afw::table::Array
Tag types used to declare specialized field types.
Definition: misc.h:32
result
py::object result
Definition: _schema.cc:429
lsst
A base class for image defects.
Definition: imageAlgorithm.dox:1
LSST_EXCEPT
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
arrays.h
lsst::pex::exceptions::InvalidParameterError
Reports invalid arguments.
Definition: Runtime.h:66
lsst::afw::table::SubSchema
A proxy type for name lookups in a Schema.
Definition: Schema.h:357
std::vector::empty
T empty(T... args)
std::size_t
lsst::afw::table::ArrayKey::addFields
static ArrayKey addFields(Schema &schema, std::string const &name, std::string const &doc, std::string const &unit, std::vector< T > const &docData)
Add an array of fields to a Schema, and return an ArrayKey that points to them.
Definition: arrays.cc:35
set
daf::base::PropertySet * set
Definition: fits.cc:912
lsst::afw::table::Key::getOffset
int getOffset() const noexcept
Return the offset (in bytes) of this field within a record.
Definition: Key.h:87
Access.h