lsst::afw::cameraGeom::Detector::Factory Class Reference

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

Public Member Functions
	Factory (std::string const &name)
std::shared_ptr< table::io::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 225 of file Detector.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::Detector::Factory::Factory ( std::string const & name )

inlineexplicit

Definition at line 228 of file Detector.cc.

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

std::shared_ptr< table::io::Persistable > lsst::afw::cameraGeom::Detector::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 230 of file Detector.cc.

                     {
        LSST_ARCHIVE_ASSERT(catalogs.size() == 2u);
        LSST_ARCHIVE_ASSERT(catalogs.front().size() == 1u);
        auto const & record = catalogs.front().front();
        int version = getVersion(catalogs);
        if (version > SERIALIZATION_VERSION) {
            throw LSST_EXCEPT(
                pex::exceptions::TypeError,
                "Cannot read Detector FITS version > " +
                std::to_string(SERIALIZATION_VERSION)
            );
        }
        auto const & keys = DetectorSchema(version);
 
        AmpVector amps;
        amps.reserve(catalogs.back().size());
        for (auto const & record : catalogs.back()) {
            amps.push_back(Amplifier::Builder::fromRecord(record).finish());
        }
 
        auto flattenedMatrix = record.get(keys.crosstalk);
        ndarray::Array<float, 2, 2> crosstalk;
        if (!flattenedMatrix.isEmpty()) {
            crosstalk = ndarray::allocate(amps.size(), amps.size());
            ndarray::flatten<1>(crosstalk) = flattenedMatrix;
        }
 
        // get values for not-always-present fields if present
        const auto physicalType = (version >= 1) ? record.get(keys.physicalType) : "";
 
        lsst::geom::Point3D fpPosition;
        if (version >= 2) {
            fpPosition = record.get(keys.fpPosition);
        } else {
            lsst::geom::Point2D fpPosition2(record.get(keys.fpPosition2));
            fpPosition = lsst::geom::Point3D(fpPosition2[0], fpPosition2[1], 0.0);
        }
 
        Fields fields = {
            record.get(keys.name),
            record.get(keys.id),
            static_cast<DetectorType>(record.get(keys.type)),
            record.get(keys.serial),
            record.get(keys.bbox),
            Orientation(
                fpPosition,
                record.get(keys.refPoint),
                record.get(keys.yaw),
                record.get(keys.pitch),
                record.get(keys.roll)
            ),
            lsst::geom::Extent2D(record.get(keys.pixelSize)),
            crosstalk,
            physicalType
        };
 
        return std::shared_ptr<Detector>(
            new Detector(
                std::move(fields),
                archive.get<TransformMap>(record.get(keys.transformMap)),
                std::move(amps)
            )
        );
    }

Member Data Documentation

registration

Detector::Factory const lsst::afw::cameraGeom::Detector::Factory::registration

static

Definition at line 298 of file Detector.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+66d966b544/src/cameraGeom/Detector.cc