FunctorKeys.h

Go to the documentation of this file.

// -*- LSST-C++ -*-
/*
 * LSST Data Management System
 * Copyright 2008-2014 LSST Corporation.
 *
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the LSST License Statement and
 * the GNU General Public License along with this program.  If not,
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */
 
#ifndef LSST_AFW_MATH_SHAPELETS_FunctorKeys_h_INCLUDED
#define LSST_AFW_MATH_SHAPELETS_FunctorKeys_h_INCLUDED
 
#include "lsst/afw/table/FunctorKey.h"
#include "lsst/afw/table/aggregates.h"
#include "lsst/afw/table/arrays.h"
#include "lsst/shapelet/ShapeletFunction.h"
#include "lsst/shapelet/MultiShapeletFunction.h"
 
namespace lsst { namespace shapelet {
 
class ShapeletFunctionKey : public afw::table::FunctorKey< ShapeletFunction > {
public:
 
    static ShapeletFunctionKey addFields(
        afw::table::Schema & schema,
        std::string const & name,
        std::string const & doc,
        std::string const & ellipseUnit,
        std::string const & coeffUnit,
        int order,
        BasisTypeEnum basisType=HERMITE
    );
 
    ShapeletFunctionKey() : _ellipseKey(), _coefficientsKey(), _order(-1), _basisType(HERMITE) {}
 
    ShapeletFunctionKey(
        afw::table::EllipseKey const & ellipse,
        afw::table::ArrayKey<double> const & coefficients,
        BasisTypeEnum basisType=HERMITE
    ) :
        _ellipseKey(ellipse),
        _coefficientsKey(coefficients),
        _order(computeOrder(coefficients.getSize())),
        _basisType(basisType)
    {}
 
    ShapeletFunctionKey(afw::table::SubSchema const & s, BasisTypeEnum basisType=HERMITE) :
        _ellipseKey(s), _coefficientsKey(s),
        _order(computeOrder(_coefficientsKey.getSize())),
        _basisType(basisType)
    {}
 
    virtual ShapeletFunction get(afw::table::BaseRecord const & record) const;
 
    virtual void set(afw::table::BaseRecord & record, ShapeletFunction const & value) const;
 
 
    bool operator==(ShapeletFunctionKey const & other) const {
        return _order == other._order && _ellipseKey == other._ellipseKey
            && _coefficientsKey == other._coefficientsKey;
    }
    bool operator!=(ShapeletFunctionKey const & other) const { return !(*this == other); }
 
    bool isValid() const { return _ellipseKey.isValid() && _coefficientsKey.isValid(); }
 
    afw::table::EllipseKey const & getEllipse() const { return _ellipseKey; }
 
    afw::table::ArrayKey<double> const & getCoefficients() const { return _coefficientsKey; }
 
    int getOrder() const { return _order; }
 
    BasisTypeEnum getBasisType() const { return _basisType; }
 
private:
    afw::table::EllipseKey _ellipseKey;
    afw::table::ArrayKey<double> _coefficientsKey;
    int _order;
    BasisTypeEnum _basisType;
};
 
 
class MultiShapeletFunctionKey : public afw::table::FunctorKey< MultiShapeletFunction > {
public:
 
    static MultiShapeletFunctionKey addFields(
        afw::table::Schema & schema,
        std::string const & name,
        std::string const & doc,
        std::string const & ellipseUnit,
        std::string const & coeffUnit,
        std::vector<int> const & orders,
        BasisTypeEnum basisType=HERMITE
    );
 
    MultiShapeletFunctionKey() {}
 
    explicit MultiShapeletFunctionKey(std::vector<std::shared_ptr<ShapeletFunctionKey>> const & components) :
        _components(components)
    {}
 
    MultiShapeletFunctionKey(afw::table::SubSchema const & s, BasisTypeEnum basisType=HERMITE);
 
    virtual MultiShapeletFunction get(afw::table::BaseRecord const & record) const;
 
    virtual void set(afw::table::BaseRecord & record, MultiShapeletFunction const & value) const;
 
 
    bool operator==(MultiShapeletFunctionKey const & other) const;
    bool operator!=(MultiShapeletFunctionKey const & other) const { return !(*this == other); }
 
    bool isValid() const;
 
    std::shared_ptr<ShapeletFunctionKey> operator[](int n) { return _components[n]; }
 
    std::shared_ptr<ShapeletFunctionKey const> operator[](int n) const { return _components[n]; }
 
private:
    std::vector<std::shared_ptr<ShapeletFunctionKey>> _components;
};
 
}} // namespace lsst::shapelet
 
#endif // !defined(LSST_AFW_MATH_SHAPELETS_FunctorKeys_h_INCLUDED)