lsst::afw::table::io::FitsSchemaInputMapper Class Reference

A class that describes a mapping from a FITS binary table to an afw::table Schema. More...

#include <FitsSchemaInputMapper.h>

Classes
class	Impl

Public Types
using	Item = FitsSchemaItem

Public Member Functions
	FitsSchemaInputMapper (daf::base::PropertyList &metadata, bool stripMetadata)
	Construct a mapper from a PropertyList of FITS header values, stripping recognized keys if desired.
	FitsSchemaInputMapper (FitsSchemaInputMapper const &)
	FitsSchemaInputMapper (FitsSchemaInputMapper &&)
FitsSchemaInputMapper &	operator= (FitsSchemaInputMapper const &)
FitsSchemaInputMapper &	operator= (FitsSchemaInputMapper &&)
	~FitsSchemaInputMapper ()
void	setArchive (std::shared_ptr< InputArchive > archive)
	Set the Archive to an externally-provided one, overriding any that may have been read.
bool	readArchive (afw::fits::Fits &fits)
	Set the Archive by reading from the HDU specified by the AR_HDU header entry.
bool	hasArchive () const
	Return true if the mapper has an InputArchive.
Item const *	find (std::string const &ttype) const
	Find an item with the given column name (ttype), returning nullptr if no such column exists.
Item const *	find (int column) const
	Find an item with the given column number, returning nullptr if no such column exists.
void	erase (Item const *item)
	Remove the given item (which should have been retrieved via find()) from the mapping, preventing it from being included in the regular fields added by finalize().
void	erase (std::string const &ttype)
	Remove the item with the given column name (ttype) from the mapping, preventing it from being included in the regular fields added by finalize().
void	erase (int column)
	Remove the item at the given column position from the mapping, preventing it from being included in the regular fields added by finalize().
void	customize (std::unique_ptr< FitsColumnReader > reader)
	Customize a mapping by providing a FitsColumnReader instance that will be invoked by readRecords().
Schema	finalize ()
	Map any remaining items into regular Schema items, and return the final Schema.
void	readRecord (BaseRecord &record, afw::fits::Fits &fits, std::size_t row)
	Fill a record from a FITS binary table row.

Static Public Attributes
static std::size_t	PREPPED_ROWS_FACTOR = 1 << 15
	When processing each column, divide this number by the record size (in bytes) and ask CFITSIO to read this many that of values from that column in a single call.

Detailed Description

A class that describes a mapping from a FITS binary table to an afw::table Schema.

A FitsSchemaInputMapper is created every time a FITS binary table is read into an afw::table catalog, allowing limited customization of the mapping between on-disk FITS table columns an in-memory fields by subclasses of BaseTable.

The object is constructed from a daf::base::PropertyList that represents the FITS header, which is used to populate a custom container of FitsSchemaItems. These can then be retrieved by name or column number via the find() methods, allowing the user to create custom readers for columns or groups of columns via addColumnReader(). They can also be removed from the "regular" fields via the erase() method. Those regular fields are filled in by the finalize() method, which automatically generates mappings for any FitsSchemaItems that have not been removed by calls to erase(). Once finalize() has been called, readRecord() may be called repeatedly to read FITS rows into record objects according to the mapping that has been defined.

Definition at line 91 of file FitsSchemaInputMapper.h.

Member Typedef Documentation

Item

using lsst::afw::table::io::FitsSchemaInputMapper::Item = FitsSchemaItem

Definition at line 93 of file FitsSchemaInputMapper.h.

Constructor & Destructor Documentation

FitsSchemaInputMapper() [1/3]

lsst::afw::table::io::FitsSchemaInputMapper::FitsSchemaInputMapper	(	daf::base::PropertyList &	metadata,
		bool	stripMetadata )

Construct a mapper from a PropertyList of FITS header values, stripping recognized keys if desired.

Definition at line 89 of file FitsSchemaInputMapper.cc.

        : _impl(std::make_shared<Impl>()) {
    // Set the table version.  If AFW_TABLE_VERSION tag exists, use that
    // If not, set to 0 if it has an AFW_TYPE, Schema default otherwise (DM-590)
    if (!metadata.exists("AFW_TYPE")) {
        _impl->version = lsst::afw::table::Schema::VERSION;
    }
    _impl->version = metadata.get("AFW_TABLE_VERSION", _impl->version);
    _impl->type = metadata.get("AFW_TYPE", _impl->type);
    if (stripMetadata) {
        metadata.remove("AFW_TABLE_VERSION");
    }
    if (stripMetadata) {
        metadata.remove("AFW_TYPE");
    }
 
    // Find a key that indicates an Archive stored on other HDUs
    _impl->archiveHdu = metadata.get("AR_HDU", -1);
    if (_impl->archiveHdu > 0) {
        --_impl->archiveHdu;  // AR_HDU is 1-indexed for historical reasons (RFC-304; see Source.cc)
        if (stripMetadata) {
            metadata.remove("AR_HDU");
        }
    }
 
    // Read aliases, stored as header entries with key 'ALIAS'
    try {
        std::vector<std::string> rawAliases = metadata.getArray<std::string>("ALIAS");
        for (auto const &rawAliase : rawAliases) {
            std::size_t pos = rawAliase.find_first_of(':');
            if (pos == std::string::npos) {
                throw LSST_EXCEPT(afw::fits::FitsError,
                                  (boost::format("Malformed alias definition: '%s'") % rawAliase).str());
            }
            _impl->schema.getAliasMap()->set(rawAliase.substr(0, pos), rawAliase.substr(pos + 1, std::string::npos));
        }
        if (stripMetadata) {
            metadata.remove("ALIAS");
        }
    } catch (pex::exceptions::NotFoundError &) {
        // if there are no aliases, just move on
    }
 
    if (_impl->version == 0) {
        // Read slots saved using an old mechanism in as aliases, since the new slot mechanism delegates
        // slot definition to the AliasMap.
        static std::array<std::pair<std::string, std::string>, 7> oldSlotKeys = {
                {std::make_pair("PSF_FLUX", "slot_PsfFlux"), std::make_pair("AP_FLUX", "slot_ApFlux"),
                 std::make_pair("INST_FLUX", "slot_GaussianFlux"),
                 std::make_pair("MODEL_FLUX", "slot_ModelFlux"),
                 std::make_pair("CALIB_FLUX", "slot_CalibFlux"), std::make_pair("CENTROID", "slot_Centroid"),
                 std::make_pair("SHAPE", "slot_Shape")}};
        for (auto const &oldSlotKey : oldSlotKeys) {
            std::string target = metadata.get(oldSlotKey.first + "_SLOT", std::string(""));
            if (!target.empty()) {
                _impl->schema.getAliasMap()->set(oldSlotKey.second, target);
                if (stripMetadata) {
                    metadata.remove(oldSlotKey.first);
                    metadata.remove(oldSlotKey.first + "_ERR_SLOT");
                    metadata.remove(oldSlotKey.first + "_FLAG_SLOT");
                }
            }
        }
    }
 
    // Read the rest of the header into the intermediate inputs container.
    std::vector<std::string> keyList = metadata.getOrderedNames();
    for (auto const &key : keyList) {
        if (key.compare(0, 5, "TTYPE") == 0) {
            int column = std::stoi(key.substr(5)) - 1;
            auto iter = _impl->byColumn().lower_bound(column);
            if (iter == _impl->byColumn().end() || iter->column != column) {
                iter = _impl->byColumn().insert(iter, FitsSchemaItem(column, -1));
            }
            std::string v = metadata.get<std::string>(key);
            _impl->byColumn().modify(iter, Impl::SetTTYPE(v));
            if (iter->doc.empty()) {  // don't overwrite if already set with TDOCn
                _impl->byColumn().modify(iter, Impl::SetDoc(metadata.getComment(key)));
            }
            if (stripMetadata) {
                metadata.remove(key);
            }
        } else if (key.compare(0, 5, "TFLAG") == 0) {
            int bit = std::stoi(key.substr(5)) - 1;
            auto iter = _impl->byBit().lower_bound(bit);
            if (iter == _impl->byBit().end() || iter->bit != bit) {
                iter = _impl->byBit().insert(iter, FitsSchemaItem(-1, bit));
            }
            std::string v = metadata.get<std::string>(key);
            _impl->byBit().modify(iter, Impl::SetTTYPE(v));
            if (iter->doc.empty()) {  // don't overwrite if already set with TFDOCn
                _impl->byBit().modify(iter, Impl::SetDoc(metadata.getComment(key)));
            }
            if (stripMetadata) {
                metadata.remove(key);
            }
        } else if (key.compare(0, 4, "TDOC") == 0) {
            int column = std::stoi(key.substr(4)) - 1;
            auto iter = _impl->byColumn().lower_bound(column);
            if (iter == _impl->byColumn().end() || iter->column != column) {
                iter = _impl->byColumn().insert(iter, FitsSchemaItem(column, -1));
            }
            _impl->byColumn().modify(iter, Impl::SetDoc(metadata.get<std::string>(key)));
            if (stripMetadata) {
                metadata.remove(key);
            }
        } else if (key.compare(0, 5, "TFDOC") == 0) {
            int bit = std::stoi(key.substr(5)) - 1;
            auto iter = _impl->byBit().lower_bound(bit);
            if (iter == _impl->byBit().end() || iter->bit != bit) {
                iter = _impl->byBit().insert(iter, FitsSchemaItem(-1, bit));
            }
            _impl->byBit().modify(iter, Impl::SetDoc(metadata.get<std::string>(key)));
            if (stripMetadata) {
                metadata.remove(key);
            }
        } else if (key.compare(0, 5, "TUNIT") == 0) {
            int column = std::stoi(key.substr(5)) - 1;
            auto iter = _impl->byColumn().lower_bound(column);
            if (iter == _impl->byColumn().end() || iter->column != column) {
                iter = _impl->byColumn().insert(iter, FitsSchemaItem(column, -1));
            }
            _impl->byColumn().modify(iter, Impl::SetTUNIT(metadata.get<std::string>(key)));
            if (stripMetadata) {
                metadata.remove(key);
            }
        } else if (key.compare(0, 5, "TCCLS") == 0) {
            int column = std::stoi(key.substr(5)) - 1;
            auto iter = _impl->byColumn().lower_bound(column);
            if (iter == _impl->byColumn().end() || iter->column != column) {
                iter = _impl->byColumn().insert(iter, FitsSchemaItem(column, -1));
            }
            _impl->byColumn().modify(iter, Impl::SetTCCLS(metadata.get<std::string>(key)));
            if (stripMetadata) {
                metadata.remove(key);
            }
        } else if (key.compare(0, 5, "TFORM") == 0) {
            int column = std::stoi(key.substr(5)) - 1;
            auto iter = _impl->byColumn().lower_bound(column);
            if (iter == _impl->byColumn().end() || iter->column != column) {
                iter = _impl->byColumn().insert(iter, FitsSchemaItem(column, -1));
            }
            _impl->byColumn().modify(iter, Impl::SetTFORM(metadata.get<std::string>(key)));
            if (stripMetadata) {
                metadata.remove(key);
            }
        } else if (key.compare(0, 5, "TZERO") == 0) {
            if (stripMetadata) {
                metadata.remove(key);
            }
        } else if (key.compare(0, 5, "TSCAL") == 0) {
            if (stripMetadata) {
                metadata.remove(key);
            }
        } else if (key.compare(0, 5, "TNULL") == 0) {
            if (stripMetadata) {
                metadata.remove(key);
            }
        } else if (key.compare(0, 5, "TDISP") == 0) {
            if (stripMetadata) {
                metadata.remove(key);
            }
        }
    }
 
    // Find the column used to store flags, and setup the flag-handling data members from it.
    _impl->flagColumn = metadata.get("FLAGCOL", 0);
    if (_impl->flagColumn > 0) {
        if (stripMetadata) {
            metadata.remove("FLAGCOL");
        }
        --_impl->flagColumn;  // switch from 1-indexed to 0-indexed
        auto iter = _impl->byColumn().find(_impl->flagColumn);
        if (iter == _impl->byColumn().end()) {
            throw LSST_EXCEPT(
                    afw::fits::FitsError,
                    (boost::format("Column for flag data not found; FLAGCOL=%d") % _impl->flagColumn).str());
        }
        // Regex to unpack a FITS TFORM value for a bit array column (TFORM code 'X').  The number
        // that precedes the code is the size of the array; the number that follows it (if present)
        // is ignored.
        static std::regex const regex("(\\d+)?X\\(?(\\d)*\\)?");
        std::smatch m;
        if (!std::regex_match(iter->tform, m, regex)) {
            throw LSST_EXCEPT(
                    afw::fits::FitsError,
                    (boost::format("Invalid TFORM key for flags column: '%s'") % iter->tform).str());
        }
        int nFlags = 1;
        if (m[1].matched) {
            nFlags = std::stoi(m[1].str());
        }
        _impl->flagKeys.resize(nFlags);
        _impl->flagWorkspace.reset(new bool[nFlags]);
        // Delete the flag column from the input list so we don't interpret it as a
        // regular field.
        _impl->byColumn().erase(iter);
    }
}

FitsSchemaInputMapper() [2/3]

lsst::afw::table::io::FitsSchemaInputMapper::FitsSchemaInputMapper ( FitsSchemaInputMapper const & )

default

FitsSchemaInputMapper() [3/3]

lsst::afw::table::io::FitsSchemaInputMapper::FitsSchemaInputMapper ( FitsSchemaInputMapper && )

default

~FitsSchemaInputMapper()

lsst::afw::table::io::FitsSchemaInputMapper::~FitsSchemaInputMapper ( )

default

Member Function Documentation

customize()

void lsst::afw::table::io::FitsSchemaInputMapper::customize

(

std::unique_ptr< FitsColumnReader >

reader

)

Customize a mapping by providing a FitsColumnReader instance that will be invoked by readRecords().

Definition at line 353 of file FitsSchemaInputMapper.cc.

                                                                            {
    _impl->readers.push_back(std::move(reader));
}

erase() [1/3]

void lsst::afw::table::io::FitsSchemaInputMapper::erase

(

int

column

)

Remove the item at the given column position from the mapping, preventing it from being included in the regular fields added by finalize().

Definition at line 344 of file FitsSchemaInputMapper.cc.

                                            {
    auto iter = _impl->byColumn().lower_bound(column);
    if (iter != _impl->byColumn().end() && iter->column == column) {
        _impl->byColumn().erase(iter);
    }
}

erase() [2/3]

void lsst::afw::table::io::FitsSchemaInputMapper::erase

(

Item const *

item

)

Remove the given item (which should have been retrieved via find()) from the mapping, preventing it from being included in the regular fields added by finalize().

Definition at line 331 of file FitsSchemaInputMapper.cc.

                                                  {
    auto iter = _impl->byColumn().lower_bound(item->column);
    assert(iter != _impl->byColumn().end() && iter->column == item->column);
    _impl->byColumn().erase(iter);
}

erase() [3/3]

void lsst::afw::table::io::FitsSchemaInputMapper::erase

(

std::string const &

ttype

)

Remove the item with the given column name (ttype) from the mapping, preventing it from being included in the regular fields added by finalize().

Definition at line 337 of file FitsSchemaInputMapper.cc.

                                                        {
    auto iter = _impl->byName().find(ttype);
    if (iter != _impl->byName().end() && iter->ttype == ttype) {
        _impl->byName().erase(iter);
    }
}

finalize()

Schema lsst::afw::table::io::FitsSchemaInputMapper::finalize

(

)

Map any remaining items into regular Schema items, and return the final Schema.

This method must be called before any calls to readRecords().

Definition at line 771 of file FitsSchemaInputMapper.cc.

                                       {
    if (_impl->version == 0) {
        AliasMap &aliases = *_impl->schema.getAliasMap();
        for (auto iter = _impl->asList().begin(); iter != _impl->asList().end(); ++iter) {
            std::size_t flagPos = iter->ttype.find("flags");
            if (flagPos != std::string::npos) {
                // We want to create aliases that resolve "(.*)_flag" to "$1_flags"; old schemas will have
                // the latter, but new conventions (including slots) expect the former.
                // But we can't do that, because adding that alias directly results in a cycle in the
                // aliases (since aliases do partial matches, and keep trying until there are no matches,
                // we'd have "(.*)_flag" resolve to "$1_flagssssssssssssss...").
                // Instead, we *rename* from "flags" to "flag", then create the reverse alias.
                std::string ttype = iter->ttype;
                std::string prefix = iter->ttype.substr(0, flagPos);
                ttype.replace(flagPos, 5, "flag");
                _impl->asList().modify(iter, Impl::SetTTYPE(ttype));
                // Note that we're not aliasing the full field, just the first part - if we have multiple
                // flag fields, one alias should be sufficient for all of them (because of partial matching).
                // Of course, we'll try to recreate that alias every time we handle another flag field with
                // the same prefix, but AliasMap know hows to handle that no-op set.
                aliases.set(prefix + "flags", prefix + "flag");
            } else if (isInstFlux(*iter)) {
                // Create an alias that resolves "X_instFlux" to "X" or "X_instFluxErr" to "X_err".
                if (endswith(iter->ttype, "_err")) {
                    aliases.set(replace(iter->ttype, "_err", "_instFluxErr"), iter->ttype);
                } else {
                    aliases.set(iter->ttype + "_instFlux", iter->ttype);
                }
            } else if (endswith(iter->ttype, "_err")) {
                // Create aliases that resolve "(.*)_(.*)Err" and "(.*)_(.*)_(.*)_Cov" to
                // "$1_err_$2Err" and "$1_err_$2_$3_Cov", to make centroid and shape uncertainties
                // available under the new conventions.  We don't have to create aliases for the
                // centroid and shape values themselves, as those will automatically be correct
                // after the PointConversionReader and MomentsConversionReader do their work.
                if (iter->tccls == "Covariance(Point)") {
                    aliases.set(replace(iter->ttype, "_err", "_yErr"), iter->ttype + "_yErr");
                    aliases.set(replace(iter->ttype, "_err", "_xErr"), iter->ttype + "_xErr");
                    aliases.set(replace(iter->ttype, "_err", "_x_y_Cov"), iter->ttype + "_x_y_Cov");
                } else if (iter->tccls == "Covariance(Moments)") {
                    aliases.set(replace(iter->ttype, "_err", "_xxErr"), iter->ttype + "_xxErr");
                    aliases.set(replace(iter->ttype, "_err", "_yyErr"), iter->ttype + "_yyErr");
                    aliases.set(replace(iter->ttype, "_err", "_xyErr"), iter->ttype + "_xyErr");
                    aliases.set(replace(iter->ttype, "_err", "_xx_yy_Cov"), iter->ttype + "_xx_yy_Cov");
                    aliases.set(replace(iter->ttype, "_err", "_xx_xy_Cov"), iter->ttype + "_xx_xy_Cov");
                    aliases.set(replace(iter->ttype, "_err", "_yy_xy_Cov"), iter->ttype + "_yy_xy_Cov");
                }
            }
        }
    } else if (_impl->version < 3) {
        // Version == 1 tables use Sigma when we should use Err (see RFC-333) and had no fields
        // that should have been named Sigma. So provide aliases xErr -> xSigma.
        // Version <= 2 tables used _flux when we should use _instFlux (see RFC-322).
        AliasMap &aliases = *_impl->schema.getAliasMap();
        for (auto iter = _impl->asList().begin(); iter != _impl->asList().end(); ++iter) {
            std::string name = iter->ttype;
            if (_impl->version < 2 && endswith(name, "Sigma")) {
                name = replace(std::move(name), "Sigma", "Err");
            }
            if (_impl->version < 3 && isInstFlux(*iter)) {
                name = replace(std::move(name), "flux", "instFlux");
            }
            if (name != iter->ttype) {
                aliases.set(name, iter->ttype);
            }
        }
    }
    for (auto iter = _impl->asList().begin(); iter != _impl->asList().end(); ++iter) {
        if (iter->bit < 0) {  // not a Flag column
            std::unique_ptr<FitsColumnReader> reader = makeColumnReader(_impl->schema, *iter);
            if (reader) {
                _impl->readers.push_back(std::move(reader));
            } else {
                LOGLS_WARN("lsst.afw.FitsSchemaInputMapper", "Format " << iter->tform << " for column "
                                                                  << iter->ttype
                                                                  << " not supported; skipping.");
            }
        } else {  // is a Flag column
            if (static_cast<std::size_t>(iter->bit) >= _impl->flagKeys.size()) {
                throw LSST_EXCEPT(afw::fits::FitsError,
                                  (boost::format("Flag field '%s' is is in bit %d (0-indexed) of only %d") %
                                   iter->ttype % iter->bit % _impl->flagKeys.size())
                                          .str());
            }
            _impl->flagKeys[iter->bit] = _impl->schema.addField<Flag>(iter->ttype, iter->doc);
        }
    }
    _impl->asList().clear();
    if (_impl->schema.getRecordSize() <= 0) {
        throw LSST_EXCEPT(
            pex::exceptions::LengthError,
            (boost::format("Non-positive record size: %d; file is corrupt or invalid.") %
            _impl->schema.getRecordSize()).str()
        );
    }
    _impl->nRowsToPrep = std::max(PREPPED_ROWS_FACTOR / _impl->schema.getRecordSize(), std::size_t(1));
    return _impl->schema;
}

find() [1/2]

FitsSchemaItem const * lsst::afw::table::io::FitsSchemaInputMapper::find

(

int

column

)

const

Find an item with the given column number, returning nullptr if no such column exists.

The returned pointer is owned by the mapper object, and should not be deleted. It is invalidated by calls to either erase() or finalize().

Definition at line 323 of file FitsSchemaInputMapper.cc.

                                                                  {
    auto iter = _impl->byColumn().lower_bound(column);
    if (iter == _impl->byColumn().end() || iter->column != column) {
        return nullptr;
    }
    return &(*iter);
}

find() [2/2]

FitsSchemaItem const * lsst::afw::table::io::FitsSchemaInputMapper::find

(

std::string const &

ttype

)

const

Find an item with the given column name (ttype), returning nullptr if no such column exists.

The returned pointer is owned by the mapper object, and should not be deleted. It is invalidated by calls to either erase() or finalize().

Definition at line 315 of file FitsSchemaInputMapper.cc.

                                                                              {
    auto iter = _impl->byName().find(ttype);
    if (iter == _impl->byName().end()) {
        return nullptr;
    }
    return &(*iter);
}

hasArchive()

bool lsst::afw::table::io::FitsSchemaInputMapper::hasArchive

(

)

const

Return true if the mapper has an InputArchive.

Definition at line 313 of file FitsSchemaInputMapper.cc.

{ return static_cast<bool>(_impl->archive); }

operator=() [1/2]

FitsSchemaInputMapper & lsst::afw::table::io::FitsSchemaInputMapper::operator= ( FitsSchemaInputMapper && )

default

operator=() [2/2]

FitsSchemaInputMapper & lsst::afw::table::io::FitsSchemaInputMapper::operator= ( FitsSchemaInputMapper const & )

default

readArchive()

bool lsst::afw::table::io::FitsSchemaInputMapper::readArchive

(

afw::fits::Fits &

fits

)

Set the Archive by reading from the HDU specified by the AR_HDU header entry.

Returns true on success, false if there is no AR_HDU entry.

Definition at line 297 of file FitsSchemaInputMapper.cc.

                                                         {
    int oldHdu = fits.getHdu();
    if (_impl->archiveHdu < 0) _impl->archiveHdu = oldHdu + 1;
    try {
        fits.setHdu(_impl->archiveHdu);
        _impl->archive.reset(new io::InputArchive(InputArchive::readFits(fits)));
        fits.setHdu(oldHdu);
        return true;
    } catch (afw::fits::FitsError &) {
        fits.status = 0;
        fits.setHdu(oldHdu);
        _impl->archiveHdu = -1;
        return false;
    }
}

readRecord()

void lsst::afw::table::io::FitsSchemaInputMapper::readRecord	(	BaseRecord &	record,
		afw::fits::Fits &	fits,
		std::size_t	row )

Fill a record from a FITS binary table row.

Definition at line 869 of file FitsSchemaInputMapper.cc.

                                                                                           {
    if (!_impl->flagKeys.empty()) {
        fits.readTableArray<bool>(row, _impl->flagColumn, _impl->flagKeys.size(), _impl->flagWorkspace.get());
        for (std::size_t bit = 0; bit < _impl->flagKeys.size(); ++bit) {
            record.set(_impl->flagKeys[bit], _impl->flagWorkspace[bit]);
        }
    }
    if (_impl->nRowsToPrep != 1 && row % _impl->nRowsToPrep == 0) {
        // Give readers a chance to read and cache up to nRowsToPrep rows-
        // worth of values.
        std::size_t size = std::min(_impl->nRowsToPrep, fits.countRows() - row);
        for (auto const &reader : _impl->readers) {
            reader->prepRead(row, size, fits);
        }
    }
    for (auto const & reader : _impl->readers) {
        reader->readCell(record, row, fits, _impl->archive);
    }
}

setArchive()

void lsst::afw::table::io::FitsSchemaInputMapper::setArchive

(

std::shared_ptr< InputArchive >

archive

)

Set the Archive to an externally-provided one, overriding any that may have been read.

Definition at line 295 of file FitsSchemaInputMapper.cc.

{ _impl->archive = archive; }

Member Data Documentation

PREPPED_ROWS_FACTOR

std::size_t lsst::afw::table::io::FitsSchemaInputMapper::PREPPED_ROWS_FACTOR = 1 << 15

static

When processing each column, divide this number by the record size (in bytes) and ask CFITSIO to read this many that of values from that column in a single call.

Both FITS binary tables and afw.table are stored row-major, so reading multiple rows from a single column at a time leads to nonsequential reads. But given the way the I/O code is structured, we tend to get nonsequential reads anyway, and it seems the per-call overload to CFITSIO is sufficiently high that it's best to do this anyway for all but the largest record sizes.

Definition at line 107 of file FitsSchemaInputMapper.h.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/afw/g9726552aa6+414189b318/include/lsst/afw/table/io/FitsSchemaInputMapper.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/afw/g9726552aa6+414189b318/src/table/io/FitsSchemaInputMapper.cc