lsst::meas::algorithms::CoaddPsf::Factory Class Reference

Inheritance diagram for lsst::meas::algorithms::CoaddPsf::Factory:

Public Member Functions
virtual std::shared_ptr< afw::table::io::Persistable >	read (InputArchive const &archive, CatalogVector const &catalogs) const
	Construct a new object from the given InputArchive and vector of catalogs.
std::shared_ptr< afw::table::io::Persistable >	readV0 (InputArchive const &archive, CatalogVector const &catalogs) const
	Factory (std::string const &name)

Static Public Member Functions
static PersistableFactory const &	lookup (std::string const &name, std::string const &module="")
	Return the factory that has been registered with the given name.

Protected Types
using	InputArchive = io::InputArchive
using	CatalogVector = io::CatalogVector

Detailed Description

Definition at line 375 of file CoaddPsf.cc.

Member Typedef Documentation

CatalogVector

using lsst::afw::table::io::PersistableFactory::CatalogVector = io::CatalogVector

protectedinherited

Definition at line 231 of file Persistable.h.

InputArchive

using lsst::afw::table::io::PersistableFactory::InputArchive = io::InputArchive

protectedinherited

Definition at line 230 of file Persistable.h.

Constructor & Destructor Documentation

Factory()

lsst::meas::algorithms::CoaddPsf::Factory::Factory ( std::string const & name )

inline

Definition at line 419 of file CoaddPsf.cc.

: afw::table::io::PersistableFactory(name) {}

Member Function Documentation

lookup()

PersistableFactory const & lsst::afw::table::io::PersistableFactory::lookup ( std::string const & name, std::string const & module = "" )

staticinherited

Return the factory that has been registered with the given name.

If the lookup fails and module is not an empty string, we will attempt to import a Python module with that name (this will only work when the C++ is being called from Python) and try again.

Definition at line 76 of file Persistable.cc.

                                                                                                   {
    RegistryMap::const_iterator i = getRegistry().find(name);
    if (i == getRegistry().end()) {
        if (!module.empty()) {
            bool success = base::ModuleImporter::import(module);
            if (!success) {
                throw LSST_EXCEPT(
                        pex::exceptions::NotFoundError,
                        (boost::format(
                                 "PersistableFactory with name '%s' not found, and import of module "
                                 "'%s' failed (possibly because Python calls were not available from C++).") %
                         name % module)
                                .str());
            }
            i = getRegistry().find(name);
            if (i == getRegistry().end()) {
                throw LSST_EXCEPT(
                        pex::exceptions::LogicError,
                        (boost::format(
                                 "PersistableFactory with name '%s' not found even after successful import "
                                 "of module '%s'.  Please report this as a bug in the persistence "
                                 "implementation for this object.") %
                         name % module)
                                .str());
            }
        } else {
            throw LSST_EXCEPT(
                    pex::exceptions::LogicError,
                    (boost::format(
                             "PersistableFactory with name '%s' not found, and no Python module to import "
                             "was provided.  Please report this as a bug in the persistence implementation "
                             "for this object.") %
                     name)
                            .str());
        }
    }
    return *i->second;
}

read()

virtual std::shared_ptr< afw::table::io::Persistable > lsst::meas::algorithms::CoaddPsf::Factory::read ( InputArchive const & archive, CatalogVector const & catalogs ) const

inlinevirtual

Construct a new object from the given InputArchive and vector of catalogs.

Implements lsst::afw::table::io::PersistableFactory.

Definition at line 378 of file CoaddPsf.cc.

                                                                                   {
        if (catalogs.size() == 1u) {
            // Old CoaddPsfs were saved in only one catalog, because we didn't
            // save the warping parameters and average position, and we could
            // save the coadd Wcs in a special final record.
            return readV0(archive, catalogs);
        }
        LSST_ARCHIVE_ASSERT(catalogs.size() == 2u);
        CoaddPsfPersistenceHelper const &keys1 = CoaddPsfPersistenceHelper::get();
        LSST_ARCHIVE_ASSERT(catalogs.front().getSchema() == keys1.schema);
        afw::table::BaseRecord const &record1 = catalogs.front().front();
        return std::shared_ptr<CoaddPsf>(
                new CoaddPsf(afw::table::ExposureCatalog::readFromArchive(archive, catalogs.back()),
                             *archive.get<afw::geom::SkyWcs>(record1.get(keys1.coaddWcs)),
                             record1.get(keys1.averagePosition), record1.get(keys1.warpingKernelName),
                             record1.get(keys1.cacheSize)));
    }

readV0()

std::shared_ptr< afw::table::io::Persistable > lsst::meas::algorithms::CoaddPsf::Factory::readV0 ( InputArchive const & archive, CatalogVector const & catalogs ) const

inline

Definition at line 401 of file CoaddPsf.cc.

                                                                                             {
        auto internalCat = afw::table::ExposureCatalog::readFromArchive(archive, catalogs.front());
        // Coadd WCS is stored in a special last record.
        auto coaddWcs = internalCat.back().getWcs();
        internalCat.pop_back();
        // Attempt to reconstruct the average position.  We can't do this
        // exactly, since the catalog we saved isn't the same one that was
        // used to compute the original average position.
        afw::table::Key<double> weightKey;
        try {
            weightKey = internalCat.getSchema()["weight"];
        } catch (pex::exceptions::NotFoundError &) {
        }
        auto averagePos = computeAveragePosition(internalCat, *coaddWcs, weightKey);
        return std::shared_ptr<CoaddPsf>(new CoaddPsf(internalCat, *coaddWcs, averagePos));
    }

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-12.1.0/Linux/meas_algorithms/gcc769fe2a4+97d0256649/src/CoaddPsf.cc