lsst::afw::image::ExposureFitsReader::ArchiveReader Class Reference

Public Types
enum	Component {   PSF = 0 , WCS , COADD_INPUTS , AP_CORR_MAP ,   VALID_POLYGON , TRANSMISSION_CURVE , DETECTOR , PHOTOCALIB ,   N_ARCHIVE_COMPONENTS }

Public Member Functions
	ArchiveReader (daf::base::PropertyList &metadata)
template<typename T >
std::shared_ptr< T >	readComponent (afw::fits::Fits *fitsFile, Component c)
	Read a known component, if available.
template<typename T >
std::shared_ptr< T >	readComponent (afw::fits::Fits *fitsFile, std::string c)
	Read an arbitrary component, if available.
std::map< std::string, std::shared_ptr< table::io::Persistable > >	readExtraComponents (afw::fits::Fits *fitsFile)
	Read the components that are stored using arbitrary-component support.

Detailed Description

Definition at line 217 of file ExposureFitsReader.cc.

Member Enumeration Documentation

Component

enum lsst::afw::image::ExposureFitsReader::ArchiveReader::Component

Enumerator
PSF
WCS
COADD_INPUTS
AP_CORR_MAP
VALID_POLYGON
TRANSMISSION_CURVE
DETECTOR
PHOTOCALIB
N_ARCHIVE_COMPONENTS

Definition at line 219 of file ExposureFitsReader.cc.

                   {
        PSF = 0,
        WCS,
        COADD_INPUTS,
        AP_CORR_MAP,
        VALID_POLYGON,
        TRANSMISSION_CURVE,
        DETECTOR,
        PHOTOCALIB,
        N_ARCHIVE_COMPONENTS
    };

Constructor & Destructor Documentation

ArchiveReader()

lsst::afw::image::ExposureFitsReader::ArchiveReader::ArchiveReader ( daf::base::PropertyList & metadata )

inlineexplicit

Definition at line 231 of file ExposureFitsReader.cc.

                                                          {
        auto popInt = [&metadata](std::string const& name) {
            // The default of zero will cause archive.get to return a
            // null/empty pointer, just as if a null/empty pointer was
            // originally written to the archive.
            int r = 0;
            if (metadata.exists(name)) {
                r = metadata.get<int>(name);
                // We remove metadata entries to maintaing our practice
                // of stripped metadata entries that have been used to
                // construct more structured components.
                metadata.remove(name);
            }
            return r;
        };
        _hdu = popInt("AR_HDU");
        if (_hdu == 0) {
            _state = ArchiveState::MISSING;
        } else {
            --_hdu;  // Switch from FITS 1-indexed convention to LSST 0-indexed convention.
            _state = ArchiveState::PRESENT;
        }
        // Read in traditional components using old-style IDs, for backwards compatibility
        _ids[PSF] = popInt("PSF_ID");
        _ids[WCS] = popInt("SKYWCS_ID");
        _ids[COADD_INPUTS] = popInt("COADD_INPUTS_ID");
        _ids[AP_CORR_MAP] = popInt("AP_CORR_MAP_ID");
        _ids[VALID_POLYGON] = popInt("VALID_POLYGON_ID");
        _ids[TRANSMISSION_CURVE] = popInt("TRANSMISSION_CURVE_ID");
        _ids[DETECTOR] = popInt("DETECTOR_ID");
        _ids[PHOTOCALIB] = popInt("PHOTOCALIB_ID");
 
        // "Extra" components use a different keyword convention to avoid collisions with non-persistence IDs
        std::vector<std::string> toStrip;
        for (std::string const& headerKey : metadata) {
            static std::string const PREFIX = "ARCHIVE_ID_";
            if (headerKey.substr(0, PREFIX.size()) == PREFIX) {
                std::string componentName = headerKey.substr(PREFIX.size());
                int archiveId = metadata.get<int>(headerKey);
                _genericIds.emplace(componentName, archiveId);
                if (!_contains(_ids, archiveId)) {
                    _extraIds.emplace(componentName);
                }
                toStrip.push_back(headerKey);
                toStrip.push_back(componentName + "_ID");  // strip corresponding old-style ID, if it exists
            }
        }
        for (std::string const& key : toStrip) {
            metadata.remove(key);
        }
    }

Member Function Documentation

readComponent() [1/2]

template<typename T >

std::shared_ptr< T > lsst::afw::image::ExposureFitsReader::ArchiveReader::readComponent ( afw::fits::Fits * fitsFile, Component c )

inline

Read a known component, if available.

Parameters

fitsFile	The file from which to read the component. Must match the metadata used to construct this object.
c	The component to read. Must be convertible to T.

Returns

The desired component, or nullptr if the file could not be read.

Definition at line 293 of file ExposureFitsReader.cc.

                                                                       {
        if (!_ensureLoaded(fitsFile)) {
            return nullptr;
        }
        return _archive.get<T>(_ids[c]);
    }

readComponent() [2/2]

template<typename T >

std::shared_ptr< T > lsst::afw::image::ExposureFitsReader::ArchiveReader::readComponent ( afw::fits::Fits * fitsFile, std::string c )

inline

Read an arbitrary component, if available.

Parameters

fitsFile	The file from which to read the component. Must match the metadata used to construct this object.
c	The archive ID of the component to read.

Returns

The desired component, or nullptr if the file could not be read.

Exceptions

pex::exceptions::NotFoundError

Thrown if the component is registered in the file metadata but could not be found.

Note

When accessing from python, components with derived subclasses, such as TransmissionCurve, are not properly type converted and thus the specialized reader must be used instead of readComponent.

Definition at line 320 of file ExposureFitsReader.cc.

                                                                       {
        if (!_ensureLoaded(fitsFile)) {
            return nullptr;
        }
 
        if (_genericIds.count(c) > 0) {
            int archiveId = _genericIds.at(c);
            return _archive.get<T>(archiveId);
        } else {
            return nullptr;
        }
    }

readExtraComponents()

std::map< std::string, std::shared_ptr< table::io::Persistable > > lsst::afw::image::ExposureFitsReader::ArchiveReader::readExtraComponents ( afw::fits::Fits * fitsFile )

inline

Read the components that are stored using arbitrary-component support.

Parameters

fitsFile

The file from which to read the components. Must match the metadata used to construct this object.

Returns

a map from string IDs to components, or an empty map if the file could not be read.

Definition at line 342 of file ExposureFitsReader.cc.

                                   {
        std::map<std::string, std::shared_ptr<table::io::Persistable>> result;
 
        if (!_ensureLoaded(fitsFile)) {
            return result;
        }
 
        // Not safe to call getAll if a component cannot be unpersisted
        // Instead, look for the archives registered in the metadata
        for (std::string const& componentName : _extraIds) {
            try {
                result.emplace(componentName, readComponent<table::io::Persistable>(fitsFile, componentName));
            } catch (pex::exceptions::NotFoundError const& err) {
                LOGLS_WARN(_log,
                           "Could not read component " << componentName << "; skipping: " << err.what());
            }
        }
        return result;
    }

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+66d966b544/src/image/ExposureFitsReader.cc