FieldBase.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
#ifndef AFW_TABLE_FieldBase_h_INCLUDED
#define AFW_TABLE_FieldBase_h_INCLUDED

#include <cstring>
#include <iostream>

#include "boost/mpl/vector.hpp"
#include "boost/preprocessor/punctuation/paren.hpp"
#include "Eigen/Core"

#include "lsst/base.h"
#include "lsst/pex/exceptions.h"
#include "ndarray.h"
#include "lsst/afw/geom.h"
#include "lsst/afw/geom/ellipses.h"
#include "lsst/afw/coord.h"
#include "lsst/afw/table/misc.h"
#include "lsst/afw/table/KeyBase.h"
#include "lsst/afw/table/types.h"

namespace lsst { namespace afw { namespace table {

namespace detail {

class TableImpl;

inline int indexCovariance(int i, int j) {
    return (i < j) ? (i + j*(j+1)/2) : (j + i*(i+1)/2);
}

inline int computeCovariancePackedSize(int size) {
    return size * (size + 1) / 2;
}

} // namespace detail

template <typename T>
struct FieldBase {

    typedef T Value;        
    typedef T & Reference;  
    typedef T const & ConstReference;  
    typedef T Element;      

    int getElementCount() const { return 1; }

    static std::string getTypeString();

#ifndef SWIG_BUG_3465431_FIXED
    // SWIG uses this template to define the interface for the other specializations.
    // We can add other methods to full specializations using %extend, but we can't add
    // constructors that way.
    FieldBase() {}
    FieldBase(int) {
        throw LSST_EXCEPT(
            lsst::pex::exceptions::LogicError,
            "Constructor disabled (it only appears to exist as a workaround for a SWIG bug)."
        );
    }
#endif

protected:

    static FieldBase makeDefault() { return FieldBase(); }

    void stream(std::ostream & os) const {}

    Reference getReference(Element * p, ndarray::Manager::Ptr const &) const { return *p; }

    ConstReference getConstReference(Element const * p, ndarray::Manager::Ptr const &) const { return *p; }

    Value getValue(Element const * p, ndarray::Manager::Ptr const &) const { return *p; }

    void setValue(Element * p, ndarray::Manager::Ptr const &, Value v) const { *p = v; }

};

template <>
struct FieldBase< Coord > {

    typedef IcrsCoord Value;

    typedef Angle Element;

    int getElementCount() const { return 2; }

    static std::string getTypeString();

#ifndef SWIG_BUG_3465431_FIXED
    // SWIG uses this template to define the interface for the other specializations.
    // We can add other methods to full specializations using %extend, but we can't add
    // constructors that way.
    FieldBase() {}
    FieldBase(int) {
        throw LSST_EXCEPT(
            lsst::pex::exceptions::LogicError,
            "Constructor disabled (it only appears to exist as a workaround for a SWIG bug)."
        );
    }
#endif

protected:

    static FieldBase makeDefault() { return FieldBase(); }

    void stream(std::ostream & os) const {}

    Value getValue(Element const * p, ndarray::Manager::Ptr const &) const {
        return Value(p[0], p[1]);
    }

    void setValue(Element * p, ndarray::Manager::Ptr const &, Value const & v) const {
        p[0] = v.getRa();
        p[1] = v.getDec();
    }

    void setValue(Element * p, ndarray::Manager::Ptr const & m, Coord const & v) const {
        setValue(p, m, v.toIcrs());
    }
};

template <typename U>
struct FieldBase< Point<U> > {

    typedef typename boost::mpl::if_<boost::is_same<U,int>,geom::Point2I,geom::Point2D>::type Value;

    typedef U Element;

    int getElementCount() const { return 2; }

    static std::string getTypeString();

#ifndef SWIG_BUG_3465431_FIXED
    // SWIG uses this template to define the interface for the other specializations.
    // We can add other methods to full specializations using %extend, but we can't add
    // constructors that way.
    FieldBase() {}
    FieldBase(int) {
        throw LSST_EXCEPT(
            lsst::pex::exceptions::LogicError,
            "Constructor disabled (it only appears to exist as a workaround for a SWIG bug)."
        );
    }
#endif

protected:

    static FieldBase makeDefault() { return FieldBase(); }

    void stream(std::ostream & os) const {}

    Value getValue(Element const * p, ndarray::Manager::Ptr const &) const { return Value(p[0], p[1]); }

    void setValue(Element * p, ndarray::Manager::Ptr const &, Value const & v) const {
        p[0] = v.getX();
        p[1] = v.getY();
    }
};

template <typename U>
struct FieldBase< Moments<U> > {

    typedef afw::geom::ellipses::Quadrupole Value; 
    typedef U Element; 

    int getElementCount() const { return 3; }

    static std::string getTypeString();

#ifndef SWIG_BUG_3465431_FIXED
    // SWIG uses this template to define the interface for the other specializations.
    // We can add other methods to full specializations using %extend, but we can't add
    // constructors that way.
    FieldBase() {}
    FieldBase(int) {
        throw LSST_EXCEPT(
            lsst::pex::exceptions::LogicError,
            "Constructor disabled (it only appears to exist as a workaround for a SWIG bug)."
        );
    }
#endif

protected:

    static FieldBase makeDefault() { return FieldBase(); }

    void stream(std::ostream & os) const {}

    Value getValue(Element const * p, ndarray::Manager::Ptr const &) const {
        return Value(p[0], p[1], p[2]);
    }

    void setValue(Element * p, ndarray::Manager::Ptr const &, Value const & v) const {
        p[0] = v.getIxx();
        p[1] = v.getIyy();
        p[2] = v.getIxy();
    }
};

template <typename U>
struct FieldBase< Array<U> > {

    typedef ndarray::Array<U const,1,1> Value; 

    typedef ndarray::ArrayRef<U,1,1> Reference;

    typedef ndarray::ArrayRef<U const,1,1> ConstReference;

    typedef U Element;  

    FieldBase(int size=-1) : _size(size) {
        if (size < 0) throw LSST_EXCEPT(
            lsst::pex::exceptions::LengthError,
            "Size must be provided when constructing an array field."
        );
    }

    static std::string getTypeString();

    int getElementCount() const { return _size; }

    int getSize() const { return _size; }

protected:

    static FieldBase makeDefault() { return FieldBase(0); }

    void stream(std::ostream & os) const { os << ", size=" << _size; }

    Reference getReference(Element * p, ndarray::Manager::Ptr const & m) const {
        return ndarray::external(p, ndarray::makeVector(_size), ndarray::ROW_MAJOR, m);
    }

    ConstReference getConstReference(Element const * p, ndarray::Manager::Ptr const & m) const {
        return ndarray::external(p, ndarray::makeVector(_size), ndarray::ROW_MAJOR, m);
    }

    Value getValue(Element const * p, ndarray::Manager::Ptr const & m) const {
        return ndarray::external(p, ndarray::makeVector(_size), ndarray::ROW_MAJOR, m);
    }

    template <typename Derived>
    void setValue(
        Element * p, ndarray::Manager::Ptr const &, ndarray::ExpressionBase<Derived> const & value
    ) const {
        if (value.template getSize<0>() != _size) {
            throw LSST_EXCEPT(
                lsst::pex::exceptions::LengthError,
                "Incorrect size in array field assignment."
            );
        }
        for (int i = 0; i < _size; ++i) p[i] = value[i];
    }

private:
    int _size;
};

template <typename U>
struct FieldBase< Covariance<U> > {

    typedef Eigen::Matrix<U,Eigen::Dynamic,Eigen::Dynamic> Value; 

    typedef U Element;    

    FieldBase(int size=-1) : _size(size) {
        if (size < 0) throw LSST_EXCEPT(
            lsst::pex::exceptions::LengthError,
            "Size must be provided when constructing a covariance field."
        );
    }

    static std::string getTypeString();

    int getElementCount() const { return getPackedSize(); }

    int getSize() const { return _size; }
    
    int getPackedSize() const { return detail::computeCovariancePackedSize(_size); }
    
protected:

    static FieldBase makeDefault() { return FieldBase(0); }

    void stream(std::ostream & os) const { os << ", size=" << _size; }

    Value getValue(Element const * p, ndarray::Manager::Ptr const &) const {
        Value m(_size, _size);
        for (int i = 0; i < _size; ++i) {
            for (int j = 0; j < _size; ++j) {
                m(i, j) = p[detail::indexCovariance(i, j)];
            }
        }
        return m;
    }

    template <typename Derived>
    void setValue(
        Element * p, ndarray::Manager::Ptr const &, Eigen::MatrixBase<Derived> const & value
    ) const {
        if (value.rows() != _size || value.cols() != _size) {
            throw LSST_EXCEPT(
                lsst::pex::exceptions::LengthError,
                "Incorrect size in covariance field assignment."
            );
        }
        for (int i = 0; i < _size; ++i) {
            for (int j = 0; j < _size; ++j) { 
                p[detail::indexCovariance(i, j)] = value(i, j);
            }
        }
    }

    int _size;
};

template <typename U>
struct FieldBase< Covariance< Point<U> > > {

    static int const SIZE = 2;
    static int const PACKED_SIZE = 3;

    typedef Eigen::Matrix<U,SIZE,SIZE> Value; 
    typedef U Element; 

    static std::string getTypeString();

    int getElementCount() const { return getPackedSize(); }

    int getSize() const { return SIZE; }

    int getPackedSize() const { return PACKED_SIZE; }

#ifndef SWIG_BUG_3465431_FIXED
    // SWIG uses this template to define the interface for the other specializations.
    // We can add other methods to full specializations using %extend, but we can't add
    // constructors that way.
    FieldBase() {}
    FieldBase(int) {
        throw LSST_EXCEPT(
            lsst::pex::exceptions::LogicError,
            "Constructor disabled (it only appears to exist as a workaround for a SWIG bug)."
        );
    }
#endif

protected:

    static FieldBase makeDefault() { return FieldBase(); }

    void stream(std::ostream & os) const {}

    Value getValue(Element const * p, ndarray::Manager::Ptr const &) const {
        Value m;
        for (int i = 0; i < SIZE; ++i) {
            for (int j = 0; j < SIZE; ++j) {
                m(i, j) = p[detail::indexCovariance(i, j)];
            }
        }
        return m;
    }

    template <typename Derived>
    static void setValue(
        Element * p, ndarray::Manager::Ptr const &, Eigen::MatrixBase<Derived> const & value
    ) {
        BOOST_STATIC_ASSERT( Derived::RowsAtCompileTime == SIZE);
        BOOST_STATIC_ASSERT( Derived::ColsAtCompileTime == SIZE);
        for (int i = 0; i < SIZE; ++i) {
            for (int j = 0; j < SIZE; ++j) { 
                p[detail::indexCovariance(i, j)] = value(i, j);
            }
        }
    }

};

template <typename U>
struct FieldBase< Covariance< Moments<U> > > {

    static int const SIZE = 3;
    static int const PACKED_SIZE = 6;

    typedef Eigen::Matrix<U,SIZE,SIZE> Value; 
    typedef U Element; 

    static std::string getTypeString();

    int getElementCount() const { return getPackedSize(); }

    int getSize() const { return SIZE; }

    int getPackedSize() const { return PACKED_SIZE; }

#ifndef SWIG_BUG_3465431_FIXED
    // SWIG uses this template to define the interface for the other specializations.
    // We can add other methods to full specializations using %extend, but we can't add
    // constructors that way.
    FieldBase() {}
    FieldBase(int) {
        throw LSST_EXCEPT(
            lsst::pex::exceptions::LogicError,
            "Constructor disabled (it only appears to exist as a workaround for a SWIG bug)."
        );
    }
#endif

protected:

    static FieldBase makeDefault() { return FieldBase(); }

    void stream(std::ostream & os) const {}

    Value getValue(Element const * p, ndarray::Manager::Ptr const &) const {
        Value m;
        for (int i = 0; i < SIZE; ++i) {
            for (int j = 0; j < SIZE; ++j) {
                m(i, j) = p[detail::indexCovariance(i, j)];
            }
        }
        return m;
    }

    template <typename Derived>
    static void setValue(
        Element * p, ndarray::Manager::Ptr const &, Eigen::MatrixBase<Derived> const & value
    ) {
        BOOST_STATIC_ASSERT( Derived::RowsAtCompileTime == SIZE);
        BOOST_STATIC_ASSERT( Derived::ColsAtCompileTime == SIZE);
        for (int i = 0; i < SIZE; ++i) {
            for (int j = 0; j < SIZE; ++j) { 
                p[detail::indexCovariance(i, j)] = value(i, j);
            }
        }
    }

};

template <>
struct FieldBase< std::string > {

    typedef std::string Value; 

    typedef char * Reference;

    typedef char const * ConstReference;

    typedef char Element;  

    FieldBase(int size=-1);

    static std::string getTypeString();

    int getElementCount() const { return _size; }

    int getSize() const { return _size; }

protected:

    static FieldBase makeDefault() { return FieldBase(0); }

    void stream(std::ostream & os) const { os << ", size=" << _size; }

    Reference getReference(Element * p, ndarray::Manager::Ptr const & m) const {
        return p;
    }

    ConstReference getConstReference(Element const * p, ndarray::Manager::Ptr const & m) const {
        return p;
    }

    Value getValue(Element const * p, ndarray::Manager::Ptr const & m) const;

    void setValue(Element * p, ndarray::Manager::Ptr const &, std::string const & value) const;

private:
    int _size;
};

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

#endif // !AFW_TABLE_FieldBase_h_INCLUDED