lsst::afw::cameraGeom::TransformMap::Factory Class Reference

Inheritance diagram for lsst::afw::cameraGeom::TransformMap::Factory:

Public Member Functions
	Factory ()
std::shared_ptr< Persistable >	readOld (InputArchive const &archive, CatalogVector const &catalogs) const
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.

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.

Static Public Attributes
static Factory const	registration

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

Detailed Description

Definition at line 404 of file TransformMap.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::afw::cameraGeom::TransformMap::Factory::Factory ( )

inline

Definition at line 407 of file TransformMap.cc.

: PersistableFactory("TransformMap") {}

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()

std::shared_ptr< Persistable > lsst::afw::cameraGeom::TransformMap::Factory::read ( InputArchive const & archive, CatalogVector const & catalogs ) const

inlineoverridevirtual

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

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

Definition at line 446 of file TransformMap.cc.

                                                                                    {
        if (catalogs.size() == 2u) {
            return readOld(archive, catalogs);
        }
 
        auto const & keys = PersistenceHelper::get();
 
        LSST_ARCHIVE_ASSERT(catalogs.size() == 1u);
        auto const & cat = catalogs[0];
        LSST_ARCHIVE_ASSERT(cat.getSchema() == keys.schema);
 
        std::vector<Connection> connections;
        for (auto const & record : cat) {
            CameraSys const fromSys(record.get(keys.fromSysName), record.get(keys.fromSysDetectorName));
            CameraSys const toSys(record.get(keys.toSysName), record.get(keys.toSysDetectorName));
            auto const transform = archive.get<geom::TransformPoint2ToPoint2>(record.get(keys.transform));
            connections.push_back(Connection{transform, fromSys, toSys});
        }
 
        // Deserialized connections should already be standardized, but be
        // defensive anyway.
        auto const referenceSys = getReferenceSys(connections);
        connections = standardizeConnections(referenceSys, std::move(connections));
        return std::shared_ptr<TransformMap>(new TransformMap(std::move(connections)));
    }

readOld()

std::shared_ptr< Persistable > lsst::afw::cameraGeom::TransformMap::Factory::readOld ( InputArchive const & archive, CatalogVector const & catalogs ) const

inline

Definition at line 409 of file TransformMap.cc.

                                                                              {
        auto const & keys = OldPersistenceHelper::get();
 
        LSST_ARCHIVE_ASSERT(catalogs.size() == 2u);
        auto const & sysCat = catalogs[0];
        auto const & connectionCat = catalogs[1];
        LSST_ARCHIVE_ASSERT(sysCat.getSchema() == keys.sysSchema);
        LSST_ARCHIVE_ASSERT(connectionCat.getSchema() == keys.connectionSchema);
        LSST_ARCHIVE_ASSERT(sysCat.size() == connectionCat.size() + 1);
        LSST_ARCHIVE_ASSERT(sysCat.isSorted(keys.id));
 
        std::unordered_map<int, CameraSys> sysById;
        for (auto const & sysRecord : sysCat) {
            auto sys = keys.makeCameraSys(sysRecord);
            sysById.emplace(sysRecord.get(keys.id), sys);
        }
 
        auto const referenceSysIter = sysById.find(1);
        LSST_ARCHIVE_ASSERT(referenceSysIter != sysById.end());
        std::vector<Connection> connections;
        for (auto const & connectionRecord : connectionCat) {
            auto const fromSysIter = sysById.find(connectionRecord.get(keys.from));
            LSST_ARCHIVE_ASSERT(fromSysIter != sysById.end());
            auto const toSysIter = sysById.find(connectionRecord.get(keys.to));
            LSST_ARCHIVE_ASSERT(toSysIter != sysById.end());
            auto const transform = archive.get<geom::TransformPoint2ToPoint2>(
                connectionRecord.get(keys.transform)
            );
 
            connections.push_back(Connection{transform, fromSysIter->second, toSysIter->second});
        }
 
        connections = standardizeConnections(referenceSysIter->second, std::move(connections));
        return std::shared_ptr<TransformMap>(new TransformMap(std::move(connections)));
    }

Member Data Documentation

registration

TransformMap::Factory const lsst::afw::cameraGeom::TransformMap::Factory::registration

static

Definition at line 473 of file TransformMap.cc.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+53520f316c/src/cameraGeom/TransformMap.cc