LSST Applications g0b6bd0c080+a72a5dd7e6,g1182afd7b4+2a019aa3bb,g17e5ecfddb+2b8207f7de,g1d67935e3f+06cf436103,g38293774b4+ac198e9f13,g396055baef+6a2097e274,g3b44f30a73+6611e0205b,g480783c3b1+98f8679e14,g48ccf36440+89c08d0516,g4b93dc025c+98f8679e14,g5c4744a4d9+a302e8c7f0,g613e996a0d+e1c447f2e0,g6c8d09e9e7+25247a063c,g7271f0639c+98f8679e14,g7a9cd813b8+124095ede6,g9d27549199+a302e8c7f0,ga1cf026fa3+ac198e9f13,ga32aa97882+7403ac30ac,ga786bb30fb+7a139211af,gaa63f70f4e+9994eb9896,gabf319e997+ade567573c,gba47b54d5d+94dc90c3ea,gbec6a3398f+06cf436103,gc6308e37c7+07dd123edb,gc655b1545f+ade567573c,gcc9029db3c+ab229f5caf,gd01420fc67+06cf436103,gd877ba84e5+06cf436103,gdb4cecd868+6f279b5b48,ge2d134c3d5+cc4dbb2e3f,ge448b5faa6+86d1ceac1d,gecc7e12556+98f8679e14,gf3ee170dca+25247a063c,gf4ac96e456+ade567573c,gf9f5ea5b4d+ac198e9f13,gff490e6085+8c2580be5c,w.2022.27
LSST Data Management Base Package
DetectorCollection.cc
Go to the documentation of this file.
1/*
2 * Developed for the LSST Data Management System.
3 * This product includes software developed by the LSST Project
4 * (https://www.lsst.org).
5 * See the COPYRIGHT file at the top-level directory of this distribution
6 * for details of code ownership.
7 *
8 * This program is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program. If not, see <https://www.gnu.org/licenses/>.
20 */
21
27
28namespace lsst {
29namespace afw {
30namespace cameraGeom {
31
32template <typename T>
34
35template <typename T>
36std::shared_ptr<T> DetectorCollectionBase<T>::operator[](std::string const & name) const {
37 auto det = get(name);
38 if (det == nullptr) {
40 (boost::format("Detector with name %s not found") % name).str());
41 }
42 return det;
43}
44
45template <typename T>
47 auto det = get(id);
48 if (det == nullptr) {
50 (boost::format("Detector with ID %s not found") % id).str());
51 }
52 return det;
53}
54
55template <typename T>
57 auto i = _nameDict.find(name);
58 if (i == _nameDict.end()) {
59 return def;
60 }
61 return i->second;
62}
63
64template <typename T>
66 auto i = _idDict.find(id);
67 if (i == _idDict.end()) {
68 return def;
69 }
70 return i->second;
71}
72
73template <typename T>
75 for (auto const & detector : detectorList) {
76 _nameDict[detector->getName()] = detector;
77 _idDict[detector->getId()] = detector;
78 }
79
80 if (_idDict.size() < detectorList.size()) {
81 throw LSST_EXCEPT(pex::exceptions::RuntimeError, "Detector IDs are not unique");
82 }
83 if (_nameDict.size() < detectorList.size()) {
84 throw LSST_EXCEPT(pex::exceptions::RuntimeError, "Detector names are not unique");
85 }
86}
87
88template <typename T>
90 auto idIter = _idDict.find(detector->getId());
91 auto nameIter = _nameDict.find(detector->getName());
92 if (idIter == _idDict.end()) {
93 if (nameIter == _nameDict.end()) {
94 try {
95 _idDict.emplace(detector->getId(), detector);
96 _nameDict.emplace(detector->getName(), detector);
97 } catch (...) {
98 _idDict.clear();
99 _nameDict.clear();
100 throw;
101 }
102 } else {
103 throw LSST_EXCEPT(
105 (boost::format("Detector name %s is not unique.") % detector->getName()).str()
106 );
107 }
108 } else {
109 if (nameIter == _nameDict.end()) {
112 (boost::format("Detector ID %s is not unique.") % detector->getId()).str()
113 );
114 } else {
115 if (nameIter->second != detector) {
116 assert(idIter->second != detector);
117 throw LSST_EXCEPT(
119 (boost::format("Detector name %s and ID %s are not unique.") % detector->getName()
120 % detector->getId()).str()
121 );
122 }
123 // detector is already present; do nothing
124 }
125 }
126}
127
128template <typename T>
130 auto nameIter = _nameDict.find(name);
131 if (nameIter == _nameDict.end()) {
132 throw LSST_EXCEPT(
134 (boost::format("Detector with name %s not found.") % name).str()
135 );
136 }
137 auto idIter = _idDict.find(nameIter->second->getId());
138 assert(idIter != _idDict.end());
139 _nameDict.erase(nameIter);
140 _idDict.erase(idIter);
141}
142
143template <typename T>
145 auto idIter = _idDict.find(id);
146 if (idIter == _idDict.end()) {
147 throw LSST_EXCEPT(
149 (boost::format("Detector with ID %s not found.") % id).str()
150 );
151 }
152 auto nameIter = _nameDict.find(idIter->second->getName());
153 assert(nameIter != _nameDict.end());
154 _nameDict.erase(nameIter);
155 _idDict.erase(idIter);
156}
157
160
161namespace {
162
163class PersistenceHelper {
164public:
165
166 static PersistenceHelper const & get() {
167 static PersistenceHelper const instance;
168 return instance;
169 }
170
171 table::Schema schema;
172 table::Key<int> detector;
173
174 DetectorCollection::List makeDetectorList(
175 table::io::InputArchive const & archive,
176 table::io::CatalogVector const & catalogs
177 ) const {
178 LSST_ARCHIVE_ASSERT(catalogs.size() >= 1u);
179 LSST_ARCHIVE_ASSERT(catalogs.front().getSchema() == schema);
181 result.reserve(catalogs.front().size());
182 for (auto const & record : catalogs.front()) {
183 int archiveId = record.get(detector);
184 result.push_back(archive.get<Detector>(archiveId));
185 }
186 return result;
187 }
188
189private:
190
191 PersistenceHelper() :
192 schema(),
193 detector(schema.addField<int>("detector", "archive ID of Detector in a DetectorCollection"))
194 {}
195
196 PersistenceHelper(PersistenceHelper const &) = delete;
197 PersistenceHelper(PersistenceHelper &&) = delete;
198
199 PersistenceHelper & operator=(PersistenceHelper const &) = delete;
200 PersistenceHelper & operator=(PersistenceHelper &&) = delete;
201
202};
203
204} // anonymous
205
206
207DetectorCollection::DetectorCollection(List const & detectorList) :
208 DetectorCollectionBase<Detector const>(detectorList)
209{
210 for (auto const & detector : detectorList) {
211 for (auto const & corner : detector->getCorners(FOCAL_PLANE)) {
212 _fpBBox.include(corner);
213 }
214 }
215}
216
218public:
219
220 Factory() : table::io::PersistableFactory("DetectorCollection") {}
221
223 CatalogVector const& catalogs) const override {
224 // can't use make_shared because ctor is protected
225 return std::shared_ptr<DetectorCollection>(new DetectorCollection(archive, catalogs));
226 }
227
228 static Factory const registration;
229};
230
232
233
235 table::io::InputArchive const & archive,
236 table::io::CatalogVector const & catalogs
237) : DetectorCollection(PersistenceHelper::get().makeDetectorList(archive, catalogs))
238{}
239
240DetectorCollection::~DetectorCollection() noexcept = default;
241
242std::string DetectorCollection::getPersistenceName() const {
243 return "DetectorCollection";
244}
245
247 return "lsst.afw.cameraGeom";
248}
249
251 auto const & keys = PersistenceHelper::get();
252 auto cat = handle.makeCatalog(keys.schema);
253 for (auto const & pair : getIdMap()) {
254 auto record = cat.addNew();
255 record->set(keys.detector, handle.put(pair.second));
256 }
257 handle.saveCatalog(cat);
258}
259
260} // namespace cameraGeom
261
262namespace table {
263namespace io {
264
265template class PersistableFacade<cameraGeom::DetectorCollection>;
266
267} // namespace io
268} // namespace table
269
270} // namespace afw
271} // namespace lsst
py::object result
Definition: _schema.cc:429
table::Key< std::string > name
Definition: Amplifier.cc:116
table::Schema schema
table::Key< int > detector
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
#define LSST_ARCHIVE_ASSERT(EXPR)
An assertion macro used to validate the structure of an InputArchive.
Definition: Persistable.h:48
std::shared_ptr< Persistable > read(InputArchive const &archive, CatalogVector const &catalogs) const override
Construct a new object from the given InputArchive and vector of catalogs.
An abstract base class for collections of Detectors and specific subclasses thereof.
std::vector< std::shared_ptr< Detector const > > List
std::shared_ptr< T > operator[](std::string const &name) const
Implement the [name] operator.
IdMap const & getIdMap() const noexcept
Get a map keyed and ordered by ID.
std::shared_ptr< T > get(std::string const &name, std::shared_ptr< T > def=nullptr) const
Retrieve a detector by name, or fall back to a default.
void add(std::shared_ptr< T > detector)
Add a detector to the collection.
An immutable collection of Detectors that can be accessed by name or ID.
std::string getPythonModule() const override
Return the fully-qualified Python module that should be imported to guarantee that its factory is reg...
void write(OutputArchiveHandle &handle) const override
Write the object to one or more catalogs.
A representation of a detector in a mosaic camera.
Definition: Detector.h:185
std::shared_ptr< RecordT > addNew()
Create a new record, add it to the end of the catalog, and return a pointer to it.
Definition: Catalog.h:490
A vector of catalogs used by Persistable.
Definition: CatalogVector.h:29
A multi-catalog archive object used to load table::io::Persistable objects.
Definition: InputArchive.h:31
An object passed to Persistable::write to allow it to persist itself.
void saveCatalog(BaseCatalog const &catalog)
Save a catalog in the archive.
BaseCatalog makeCatalog(Schema const &schema)
Return a new, empty catalog with the given schema.
int put(Persistable const *obj, bool permissive=false)
Save an object to the archive and return a unique ID that can be used to retrieve it from an InputArc...
A base class for factory classes used to reconstruct objects from records.
Definition: Persistable.h:228
void include(Point2D const &point) noexcept
Expand this to ensure that this->contains(point).
Definition: Box.cc:380
Reports attempts to access elements using an invalid key.
Definition: Runtime.h:151
Reports errors that are due to events beyond the control of the program.
Definition: Runtime.h:104
CameraSys const FOCAL_PLANE
Focal plane coordinates: Position on a 2-d planar approximation to the focal plane (x,...
Definition: CameraSys.cc:30
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:174
A base class for image defects.
STL namespace.
T size(T... args)