LSST Applications 27.0.0,g0265f82a02+469cd937ee,g02d81e74bb+21ad69e7e1,g1470d8bcf6+cbe83ee85a,g2079a07aa2+e67c6346a6,g212a7c68fe+04a9158687,g2305ad1205+94392ce272,g295015adf3+81dd352a9d,g2bbee38e9b+469cd937ee,g337abbeb29+469cd937ee,g3939d97d7f+72a9f7b576,g487adcacf7+71499e7cba,g50ff169b8f+5929b3527e,g52b1c1532d+a6fc98d2e7,g591dd9f2cf+df404f777f,g5a732f18d5+be83d3ecdb,g64a986408d+21ad69e7e1,g858d7b2824+21ad69e7e1,g8a8a8dda67+a6fc98d2e7,g99cad8db69+f62e5b0af5,g9ddcbc5298+d4bad12328,ga1e77700b3+9c366c4306,ga8c6da7877+71e4819109,gb0e22166c9+25ba2f69a1,gb6a65358fc+469cd937ee,gbb8dafda3b+69d3c0e320,gc07e1c2157+a98bf949bb,gc120e1dc64+615ec43309,gc28159a63d+469cd937ee,gcf0d15dbbd+72a9f7b576,gdaeeff99f8+a38ce5ea23,ge6526c86ff+3a7c1ac5f1,ge79ae78c31+469cd937ee,gee10cc3b42+a6fc98d2e7,gf1cff7945b+21ad69e7e1,gfbcc870c63+9a11dc8c8f
LSST Data Management Base Package
Loading...
Searching...
No Matches
FitsWriter.cc
Go to the documentation of this file.
1// -*- lsst-c++ -*-
2
3#include <memory>
4
8
9namespace lsst {
10namespace afw {
11namespace table {
12namespace io {
13
14namespace {
15
16using Fits = FitsWriter::Fits;
17
18//----- Code to write FITS headers --------------------------------------------------------------------------
19
20// The driver code is at the bottom of this section; it's easier to understand if you start there
21// and work your way up.
22
23// A Schema::forEach functor that writes FITS header keys for a field when it is called.
24struct ProcessSchema {
25 template <typename T>
26 void operator()(SchemaItem<T> const& item) const {
27 std::string name = item.field.getName();
28 int n = fits->addColumn<typename Field<T>::Element>(name, item.field.getElementCount(),
29 item.field.getDoc());
30 if (!item.field.getDoc().empty()) {
31 // We use a separate key TDOCn for documentation (in addition to the TTYPEn comments)
32 // so we can have long strings via the CONTINUE convention.
33 // When reading, if there is no TDOCn, we'll just use the TTYPEn comment.
34 fits->writeColumnKey("TDOC", n, item.field.getDoc());
35 }
36 specialize(item, n); // delegate to other member functions that are specialized on field tag types
37 }
38
39 void operator()(SchemaItem<std::string> const& item) const {
40 std::string name = item.field.getName();
41 std::size_t n = fits->addColumn<std::string>(name, item.field.getElementCount(), item.field.getDoc());
42 if (!item.field.getDoc().empty()) {
43 fits->writeColumnKey("TDOC", n, item.field.getDoc());
44 }
45 specialize(item, n);
46 }
47
48 void operator()(SchemaItem<Flag> const& item) const {
49 std::string name = item.field.getName();
50 fits->writeColumnKey("TFLAG", nFlags, name);
51 if (!item.field.getDoc().empty()) {
52 // We use a separate key TFDOCn for documentation instead of the comment on TFLAGn so
53 // we can have long strings via the CONTINUE convention.
54 // When reading, if there is no TFDOCn, we'll use the TTYPEn comment.
55 fits->writeColumnKey("TFDOC", nFlags, item.field.getDoc());
56 }
57 ++nFlags;
58 }
59
60 // Create and apply the functor to a schema.
61 static void apply(Fits& fits, Schema const& schema) {
62 ProcessSchema f = {&fits, 0};
63 schema.forEach(f);
64 }
65
66 template <typename T>
67 void specialize(SchemaItem<T> const& item, int n) const {
68 if (!item.field.getUnits().empty()) fits->writeColumnKey("TUNIT", n, item.field.getUnits());
69 fits->writeColumnKey("TCCLS", n, "Scalar", "Field template used by lsst.afw.table");
70 }
71
72 void specialize(SchemaItem<lsst::geom::Angle> const& item, int n) const {
73 // Always write units for lsst::geom::Angles as radians (in-memory lsst::geom::Angles field don't use
74 // the unit attribute, single lsst::geom::Angle abstracts that away).
75 fits->writeColumnKey("TUNIT", n, "rad");
76 fits->writeColumnKey("TCCLS", n, "Angle", "Field template used by lsst.afw.table");
77 }
78
79 template <typename T>
80 void specialize(SchemaItem<Array<T> > const& item, int n) const {
81 if (!item.field.getUnits().empty()) fits->writeColumnKey("TUNIT", n, item.field.getUnits());
82 fits->writeColumnKey("TCCLS", n, "Array", "Field template used by lsst.afw.table");
83 }
84
85 void specialize(SchemaItem<std::string> const& item, std::size_t n) const {
86 if (!item.field.getUnits().empty()) fits->writeColumnKey("TUNIT", n, item.field.getUnits());
87 fits->writeColumnKey("TCCLS", n, "String", "Field template used by lsst.afw.table");
88 }
89
90 Fits* fits;
91 mutable int nFlags;
92};
93
94void writeAliasMap(Fits& fits, AliasMap const& aliases) {
95 for (auto const &aliase : aliases) {
96 fits.writeKey("ALIAS", aliase.first + ":" + aliase.second);
97 }
98}
99
100} // namespace
101
102// the driver for all the above machinery
104 Schema schema = table->getSchema();
106 LSST_FITS_CHECK_STATUS(*_fits, "creating table");
107 std::size_t nFlags = schema.getFlagFieldCount();
108 if (nFlags > 0) {
109 int n = _fits->addColumn<bool>("flags", nFlags, "bits for all Flag fields; see also TFLAGn");
110 _fits->writeKey("FLAGCOL", n + 1, "Column number for the bitflags.");
111 }
112 ProcessSchema::apply(*_fits, schema);
113 writeAliasMap(*_fits, *schema.getAliasMap());
114 // write the version number to the fits header, plus any other metadata
115 std::shared_ptr<daf::base::PropertyList> metadata = table->getMetadata();
116 if (!metadata) {
117 metadata = std::make_shared<daf::base::PropertyList>();
118 }
119 metadata->set<int>("AFW_TABLE_VERSION", Schema::VERSION);
120 _fits->writeMetadata(*metadata);
121 // In case the metadata was attached to the table, clean it up.
122 metadata->remove("AFW_TABLE_VERSION");
123 _row = -1;
124 _fits->addRows(nRows);
125 _processor = std::make_shared<ProcessRecords>(_fits, schema, nFlags, _row);
126}
127
128//----- Code for writing FITS records -----------------------------------------------------------------------
129
130// The driver code is at the bottom of this section; it's easier to understand if you start there
131// and work your way up.
132
133// A Schema::forEach functor that writes table data for a single record when it is called.
134// We instantiate one of these, then reuse it on all the records after updating the data
135// members that tell it which record and row number it's on.
137 template <typename T>
138 void operator()(SchemaItem<T> const& item) const {
139 fits->writeTableArray(row, col, item.key.getElementCount(), record->getElement(item.key));
140 ++col;
141 }
142
143 template <typename T>
144 void operator()(SchemaItem<Array<T> > const& item) const {
145 if (item.key.isVariableLength()) {
146 ndarray::Array<T const, 1, 1> array = record->get(item.key);
147 fits->writeTableArray(row, col, array.template getSize<0>(), array.getData());
148 } else {
149 fits->writeTableArray(row, col, item.key.getElementCount(), record->getElement(item.key));
150 }
151 ++col;
152 }
153
155 // Write fixed-length and variable-length strings the same way
156 fits->writeTableScalar(row, col, record->get(item.key));
157 ++col;
158 }
159
160 void operator()(SchemaItem<Flag> const& item) const {
161 flags[bit] = record->get(item.key);
162 ++bit;
163 }
164
166 : row(row_), col(0), bit(0), nFlags(nFlags_), fits(fits_), schema(schema_) {
167 if (nFlags) flags.reset(new bool[nFlags]);
168 }
169
170 void apply(BaseRecord const* r) {
171 record = r;
172 col = 0;
173 bit = 0;
174 if (nFlags) ++col;
175 schema.forEach(*this);
176 if (nFlags) fits->writeTableArray(row, 0, nFlags, flags.get());
177 }
178
180 mutable int col;
181 mutable int bit;
187};
188
190 ++_row;
191 _processor->apply(&record);
192}
193} // namespace io
194} // namespace table
195} // namespace afw
196} // namespace lsst
table::Key< std::string > name
Definition Amplifier.cc:116
int nFlags
Definition FitsWriter.cc:91
A simple struct that combines the two arguments that must be passed to most cfitsio routines and cont...
Definition fits.h:308
void writeKey(std::string const &key, T const &value, std::string const &comment)
Add a FITS header key to the bottom of the header.
Definition fits.cc:686
void createTable()
Create a new binary table extension.
Definition fits.cc:1136
int addColumn(std::string const &ttype, int size, std::string const &comment)
Add a column to a table.
Definition fits.cc:1159
void writeMetadata(daf::base::PropertySet const &metadata)
Read a FITS header into a PropertySet or PropertyList.
Definition fits.cc:1114
std::size_t addRows(std::size_t nRows)
Append rows to a table, and return the index of the first new row.
Definition fits.cc:1168
Tag types used to declare specialized field types.
Definition misc.h:31
Base class for all records.
Definition BaseRecord.h:31
Field< T >::Value get(Key< T > const &key) const
Return the value of a field for the given key.
Definition BaseRecord.h:151
Field< T >::Element * getElement(Key< T > const &key)
Return a pointer to the underlying elements of a field (non-const).
Definition BaseRecord.h:93
Defines the fields and offsets for a table.
Definition Schema.h:51
static int const VERSION
Definition Schema.h:57
virtual void _writeRecord(BaseRecord const &source)
Write an individual record.
virtual void _writeTable(std::shared_ptr< BaseTable const > const &table, std::size_t nRows)
Write a table and its schema.
#define LSST_FITS_CHECK_STATUS(fitsObj,...)
Throw a FitsError exception if the status of the given Fits object is nonzero.
Definition fits.h:111
T get(T... args)
T reset(T... args)
A simple pair-like struct for mapping a Field (name and description) with a Key (used for actual data...
Definition SchemaImpl.h:22
void operator()(SchemaItem< Flag > const &item) const
ProcessRecords(Fits *fits_, Schema const &schema_, int nFlags_, std::size_t const &row_)
void operator()(SchemaItem< std::string > const &item) const
void operator()(SchemaItem< T > const &item) const
void operator()(SchemaItem< Array< T > > const &item) const