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 daf::base

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(int version) const {
        return (version > 0 ? "slot_" : "slot.") + _name;
    }

protected:
    std::string _name;
};

class FluxSlotDefinition : public SlotDefinition {
public:

    typedef double MeasValue;    
    typedef double ErrValue;     
    typedef Key<double> MeasKey; 
    typedef Key<double> ErrKey;  

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

private:
    MeasKey _measKey;
    ErrKey _errKey;
    Key<Flag> _flagKey;
};

class CentroidSlotDefinition : public SlotDefinition {
public:

    typedef geom::Point2D MeasValue;             
    typedef Eigen::Matrix<float,2,2> ErrValue;   
    typedef Point2DKey MeasKey;                  
    typedef CovarianceMatrixKey<float,2> ErrKey; 

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

private:
    MeasKey _measKey;
    ErrKey _errKey;
    Key<Flag> _flagKey;
};

class ShapeSlotDefinition : public SlotDefinition {
public:

    typedef geom::ellipses::Quadrupole MeasValue; 
    typedef Eigen::Matrix<float,3,3> ErrValue;    
    typedef QuadrupoleKey MeasKey;                
    typedef CovarianceMatrixKey<float,3> ErrKey;  

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

private:
    MeasKey _measKey;
    ErrKey _errKey;
    Key<Flag> _flagKey;
};

struct SlotSuite {
    FluxSlotDefinition defPsfFlux;
    FluxSlotDefinition defApFlux;
    FluxSlotDefinition defInstFlux;
    FluxSlotDefinition defModelFlux;
    CentroidSlotDefinition defCentroid;
    ShapeSlotDefinition defShape;

    void handleAliasChange(std::string const & alias, Schema const & schema);

    explicit SlotSuite(Schema const & schema);
};



#ifndef SWIG

template <typename MeasTagT, typename ErrTagT>
struct Measurement {
    typedef MeasTagT MeasTag;  
    typedef ErrTagT ErrTag;    
    typedef typename Field<MeasTag>::Value MeasValue; 
    typedef typename Field<ErrTag>::Value ErrValue;   
    typedef Key<MeasTag> MeasKey;  
    typedef Key<ErrTag> ErrKey;    
};

struct Flux : public Measurement<double, double> {};

struct Centroid : public Measurement< Point<double>, Covariance< Point<float> > > {};

struct Shape : public Measurement< Moments<double>, Covariance< Moments<float> > > {};

template <typename MeasurementT>
struct KeyTuple {
    typename MeasurementT::MeasKey meas; 
    typename MeasurementT::ErrKey err;   
    Key<Flag> flag;                      

    KeyTuple() {}

    KeyTuple(
        typename MeasurementT::MeasKey const & meas_,
        typename MeasurementT::ErrKey const & err_,
        Key<Flag> const & flag_
    ) : meas(meas_), err(err_), flag(flag_) {}

};

KeyTuple<Centroid> addCentroidFields(Schema & schema, std::string const & name, std::string const & doc);

KeyTuple<Shape> addShapeFields(Schema & schema, std::string const & name, std::string const & doc);

KeyTuple<Flux> addFluxFields(Schema & schema, std::string const & name, std::string const & doc);

#endif // !SWIG

//@

}}} // lsst::afw::table

#endif // !LSST_AFW_TABLE_slots_h_INCLUDED