slots.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
#ifndef LSST_AFW_TABLE_slots_h_INCLUDED
#define LSST_AFW_TABLE_slots_h_INCLUDED
 
#include "lsst/afw/table/aggregates.h"
 
namespace lsst {
 
namespace daf {
namespace base {
class PropertySet;
}
namespace base {…}
}  // namespace daf
namespace daf {…}
 
namespace afw {
 
namespace fits {
class Fits;
};  // namespace fits
 
namespace table {
 
class SlotDefinition {
public:
    explicit SlotDefinition(std::string const &name) : _name(name) {}
 
    std::string getName() const { return _name; }
 
    std::string getAlias() const { return "slot_" + _name; }
 
    SlotDefinition(SlotDefinition const &) = default;
    SlotDefinition(SlotDefinition &&) = default;
    SlotDefinition &operator=(SlotDefinition const &) = default;
    SlotDefinition &operator=(SlotDefinition &&) = default;
    ~SlotDefinition() = default;
 
protected:
    std::string _name;
};
class SlotDefinition {…};
 
class FluxSlotDefinition : public SlotDefinition {
public:
    using MeasValue = double;     
    using ErrValue = double;      
    using MeasKey = Key<double>;  
    using ErrKey = Key<double>;   
 
    explicit FluxSlotDefinition(std::string const &name) : SlotDefinition(name) {}
 
    bool isValid() const { return _measKey.isValid(); }
 
    MeasKey getMeasKey() const { return _measKey; }
 
    ErrKey getErrKey() const { return _errKey; }
 
    Key<Flag> getFlagKey() const { return _flagKey; }
 
    void setKeys(std::string const &alias, Schema const &schema);
 
    FluxSlotDefinition(FluxSlotDefinition const &) = default;
    FluxSlotDefinition(FluxSlotDefinition &&) = default;
    FluxSlotDefinition &operator=(FluxSlotDefinition const &) = default;
    FluxSlotDefinition &operator=(FluxSlotDefinition &&) = default;
    ~FluxSlotDefinition() = default;
 
private:
    MeasKey _measKey;
    ErrKey _errKey;
    Key<Flag> _flagKey;
};
class FluxSlotDefinition : public SlotDefinition {…};
 
class CentroidSlotDefinition : public SlotDefinition {
public:
    using MeasValue = lsst::geom::Point2D;         
    using ErrValue = Eigen::Matrix<float, 2, 2>;   
    using MeasKey = Point2DKey;                    
    using ErrKey = CovarianceMatrixKey<float, 2>;  
 
    explicit CentroidSlotDefinition(std::string const &name) : SlotDefinition(name) {}
 
    bool isValid() const { return _measKey.isValid(); }
 
    MeasKey getMeasKey() const { return _measKey; }
 
    ErrKey getErrKey() const { return _errKey; }
 
    Key<Flag> getFlagKey() const { return _flagKey; }
 
    void setKeys(std::string const &alias, Schema const &schema);
 
    CentroidSlotDefinition(CentroidSlotDefinition const &) = default;
    CentroidSlotDefinition(CentroidSlotDefinition &&) = default;
    CentroidSlotDefinition &operator=(CentroidSlotDefinition const &) = default;
    CentroidSlotDefinition &operator=(CentroidSlotDefinition &&) = default;
    ~CentroidSlotDefinition() = default;
 
private:
    MeasKey _measKey;
    ErrKey _errKey;
    Key<Flag> _flagKey;
};
class CentroidSlotDefinition : public SlotDefinition {…};
 
class ShapeSlotDefinition : public SlotDefinition {
public:
    using MeasValue = geom::ellipses::Quadrupole;  
    using ErrValue = Eigen::Matrix<float, 3, 3>;   
    using MeasKey = QuadrupoleKey;                 
    using ErrKey = CovarianceMatrixKey<float, 3>;  
 
    explicit ShapeSlotDefinition(std::string const &name) : SlotDefinition(name) {}
 
    bool isValid() const { return _measKey.isValid(); }
 
    MeasKey getMeasKey() const { return _measKey; }
 
    ErrKey getErrKey() const { return _errKey; }
 
    Key<Flag> getFlagKey() const { return _flagKey; }
 
    void setKeys(std::string const &alias, Schema const &schema);
 
    ShapeSlotDefinition(ShapeSlotDefinition const &) = default;
    ShapeSlotDefinition(ShapeSlotDefinition &&) = default;
    ShapeSlotDefinition &operator=(ShapeSlotDefinition const &) = default;
    ShapeSlotDefinition &operator=(ShapeSlotDefinition &&) = default;
    ~ShapeSlotDefinition() = default;
 
private:
    MeasKey _measKey;
    ErrKey _errKey;
    Key<Flag> _flagKey;
};
class ShapeSlotDefinition : public SlotDefinition {…};
 
struct SlotSuite {
    FluxSlotDefinition defPsfFlux;
    FluxSlotDefinition defApFlux;
    FluxSlotDefinition defGaussianFlux;
    FluxSlotDefinition defModelFlux;
    FluxSlotDefinition defCalibFlux;
    CentroidSlotDefinition defCentroid;
    ShapeSlotDefinition defShape;
 
    void handleAliasChange(std::string const &alias, Schema const &schema);
 
    explicit SlotSuite(Schema const &schema);
};
struct SlotSuite {…};
}  // namespace table
}  // namespace afw
}  // namespace lsst
 
#endif  // !LSST_AFW_TABLE_slots_h_INCLUDED