SourceCluster.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
/* 
 * LSST Data Management System
 * Copyright 2012 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/>.
 */

// THIS FILE IS AUTOMATICALLY GENERATED, AND WILL BE OVERWRITTEN IF EDITED MANUALLY.

#ifndef LSST_AP_CLUSTER_SOURCECLUSTER_H
#define LSST_AP_CLUSTER_SOURCECLUSTER_H

#include "lsst/tr1/unordered_map.h"

#include "lsst/afw/geom.h"
#include "lsst/afw/coord.h"
#include "lsst/afw/table/Source.h"
#include "lsst/afw/table/IdFactory.h"
#include "lsst/afw/table/Catalog.h"
#include "lsst/afw/table/BaseColumnView.h"
#include "lsst/afw/table/io/FitsWriter.h"


namespace lsst { namespace ap { namespace cluster {

class SourceClusterTable;

template <typename RecordT> class SourceClusterColumnViewT;


#if !defined(SWIG)

template <typename MeasurementT>
struct KeyTuple {
    typename MeasurementT::MeasKey mean; 
    typename MeasurementT::ErrKey err;   
    lsst::afw::table::Key<int> count;    

    KeyTuple() {}

    KeyTuple(
        typename MeasurementT::MeasKey const & mean_,
        typename MeasurementT::ErrKey const & err_,
        lsst::afw::table::Key<int> const & count_
    ) : mean(mean_), err(err_), count(count_) { }
};

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

KeyTuple<lsst::afw::table::Flux> addFluxFields(
    lsst::afw::table::Schema & schema,
    std::string const & filter,
    std::string const & name,
    std::string const & doc,
    std::string const & unit);

#endif // !SWIG


class SourceClusterRecord : public lsst::afw::table::SimpleRecord {
public:
    typedef SourceClusterTable Table;
    typedef SourceClusterColumnViewT<SourceClusterRecord> ColumnView;
    typedef lsst::afw::table::SortedCatalogT<SourceClusterRecord> Catalog;
    typedef lsst::afw::table::SortedCatalogT<SourceClusterRecord const> ConstCatalog;

    CONST_PTR(SourceClusterTable) getTable() const {
        return boost::static_pointer_cast<SourceClusterTable const>(
            lsst::afw::table::BaseRecord::getTable());
    }


    Eigen::Matrix<float,2,2> const getCoordErr() const;
    void setCoordErr(Eigen::Matrix<float,2,2> const & value);

    lsst::afw::coord::IcrsCoord const getWeightedMeanCoord() const;
    void setWeightedMeanCoord(lsst::afw::coord::IcrsCoord const & value);

    Eigen::Matrix<float,2,2> const getWeightedMeanCoordErr() const;
    void setWeightedMeanCoordErr(Eigen::Matrix<float,2,2> const & value);

    int const getWeightedMeanCoordCount() const;
    void setWeightedMeanCoordCount(int const & value);

    int const getNumSources() const;
    void setNumSources(int const & value);

    double const getTimeMin() const;
    void setTimeMin(double const & value);

    double const getTimeMean() const;
    void setTimeMean(double const & value);

    double const getTimeMax() const;
    void setTimeMax(double const & value);




    int const getNumSources(std::string const & filter) const;
    void setNumSources(std::string const & filter, int const & value);

    double const getTimeMin(std::string const & filter) const;
    void setTimeMin(std::string const & filter, double const & value);

    double const getTimeMax(std::string const & filter) const;
    void setTimeMax(std::string const & filter, double const & value);


    lsst::afw::table::Flux::MeasValue const getPsfFlux(std::string const & filter) const;
    void setPsfFlux(std::string const & filter, lsst::afw::table::Flux::MeasValue const & value);

    lsst::afw::table::Flux::ErrValue const getPsfFluxErr(std::string const & filter) const;
    void setPsfFluxErr(std::string const & filter, lsst::afw::table::Flux::ErrValue const & value);

    int const getPsfFluxCount(std::string const & filter) const;
    void setPsfFluxCount(std::string const & filter, int const & value);


    lsst::afw::table::Flux::MeasValue const getModelFlux(std::string const & filter) const;
    void setModelFlux(std::string const & filter, lsst::afw::table::Flux::MeasValue const & value);

    lsst::afw::table::Flux::ErrValue const getModelFluxErr(std::string const & filter) const;
    void setModelFluxErr(std::string const & filter, lsst::afw::table::Flux::ErrValue const & value);

    int const getModelFluxCount(std::string const & filter) const;
    void setModelFluxCount(std::string const & filter, int const & value);


    lsst::afw::table::Flux::MeasValue const getApFlux(std::string const & filter) const;
    void setApFlux(std::string const & filter, lsst::afw::table::Flux::MeasValue const & value);

    lsst::afw::table::Flux::ErrValue const getApFluxErr(std::string const & filter) const;
    void setApFluxErr(std::string const & filter, lsst::afw::table::Flux::ErrValue const & value);

    int const getApFluxCount(std::string const & filter) const;
    void setApFluxCount(std::string const & filter, int const & value);


    lsst::afw::table::Flux::MeasValue const getInstFlux(std::string const & filter) const;
    void setInstFlux(std::string const & filter, lsst::afw::table::Flux::MeasValue const & value);

    lsst::afw::table::Flux::ErrValue const getInstFluxErr(std::string const & filter) const;
    void setInstFluxErr(std::string const & filter, lsst::afw::table::Flux::ErrValue const & value);

    int const getInstFluxCount(std::string const & filter) const;
    void setInstFluxCount(std::string const & filter, int const & value);


    lsst::afw::table::Shape::MeasValue const getShape(std::string const & filter) const;
    void setShape(std::string const & filter, lsst::afw::table::Shape::MeasValue const & value);

    lsst::afw::table::Shape::ErrValue const getShapeErr(std::string const & filter) const;
    void setShapeErr(std::string const & filter, lsst::afw::table::Shape::ErrValue const & value);

    int const getShapeCount(std::string const & filter) const;
    void setShapeCount(std::string const & filter, int const & value);


    double getIxx(std::string const & filter) const;

    double getIyy(std::string const & filter) const;

    double getIxy(std::string const & filter) const;


protected:
    SourceClusterRecord(PTR(SourceClusterTable) const & table);
};


class SourceClusterTable : public lsst::afw::table::SimpleTable {
public:
    typedef SourceClusterRecord Record;
    typedef SourceClusterColumnViewT<SourceClusterRecord> ColumnView;
    typedef lsst::afw::table::SortedCatalogT<Record> Catalog;
    typedef lsst::afw::table::SortedCatalogT<Record const> ConstCatalog;

    static PTR(SourceClusterTable) make(lsst::afw::table::Schema const & schema,
                                        PTR(lsst::afw::table::IdFactory) const & idFactory);

    static PTR(SourceClusterTable) make(lsst::afw::table::Schema const & schema) {
        return make(schema, lsst::afw::table::IdFactory::makeSimple());
    }

    ~SourceClusterTable();

    PTR(SourceClusterTable) clone() const {
        return boost::static_pointer_cast<SourceClusterTable>(_clone());
    }

    PTR(SourceClusterRecord) makeRecord() {
        return boost::static_pointer_cast<SourceClusterRecord>(_makeRecord());
    }

    PTR(SourceClusterRecord) copyRecord(lsst::afw::table::BaseRecord const & other) {
        return boost::static_pointer_cast<SourceClusterRecord>(
            lsst::afw::table::BaseTable::copyRecord(other));
    }

    PTR(SourceClusterRecord) copyRecord(lsst::afw::table::BaseRecord const & other,
                                        lsst::afw::table::SchemaMapper const & mapper) {
        return boost::static_pointer_cast<SourceClusterRecord>(
            lsst::afw::table::BaseTable::copyRecord(other, mapper));
    }


    void defineCoordErr(lsst::afw::table::Key<lsst::afw::table::Covariance<lsst::afw::table::Point<float> > > const & key) {
        _keyCoordErr = key;
    }
    void defineCoordErr(std::string const & name) {
        lsst::afw::table::Schema schema = getSchema();
        _keyCoordErr = schema[name];
    }
    std::string const getCoordErrDefinition() const {
        return getSchema().find(_keyCoordErr).field.getName();
    }
    lsst::afw::table::Key<lsst::afw::table::Covariance<lsst::afw::table::Point<float> > > const getCoordErrKey() const {
        return _keyCoordErr;
    }

    void defineWeightedMeanCoord(lsst::afw::table::Key<lsst::afw::coord::Coord> const & key) {
        _keyWeightedMeanCoord = key;
    }
    void defineWeightedMeanCoord(std::string const & name) {
        lsst::afw::table::Schema schema = getSchema();
        _keyWeightedMeanCoord = schema[name];
    }
    std::string const getWeightedMeanCoordDefinition() const {
        return getSchema().find(_keyWeightedMeanCoord).field.getName();
    }
    lsst::afw::table::Key<lsst::afw::coord::Coord> const getWeightedMeanCoordKey() const {
        return _keyWeightedMeanCoord;
    }

    void defineWeightedMeanCoordErr(lsst::afw::table::Key<lsst::afw::table::Covariance<lsst::afw::table::Point<float> > > const & key) {
        _keyWeightedMeanCoordErr = key;
    }
    void defineWeightedMeanCoordErr(std::string const & name) {
        lsst::afw::table::Schema schema = getSchema();
        _keyWeightedMeanCoordErr = schema[name];
    }
    std::string const getWeightedMeanCoordErrDefinition() const {
        return getSchema().find(_keyWeightedMeanCoordErr).field.getName();
    }
    lsst::afw::table::Key<lsst::afw::table::Covariance<lsst::afw::table::Point<float> > > const getWeightedMeanCoordErrKey() const {
        return _keyWeightedMeanCoordErr;
    }

    void defineWeightedMeanCoordCount(lsst::afw::table::Key<int> const & key) {
        _keyWeightedMeanCoordCount = key;
    }
    void defineWeightedMeanCoordCount(std::string const & name) {
        lsst::afw::table::Schema schema = getSchema();
        _keyWeightedMeanCoordCount = schema[name];
    }
    std::string const getWeightedMeanCoordCountDefinition() const {
        return getSchema().find(_keyWeightedMeanCoordCount).field.getName();
    }
    lsst::afw::table::Key<int> const getWeightedMeanCoordCountKey() const {
        return _keyWeightedMeanCoordCount;
    }

    void defineNumSources(lsst::afw::table::Key<int> const & key) {
        _keyNumSources = key;
    }
    void defineNumSources(std::string const & name) {
        lsst::afw::table::Schema schema = getSchema();
        _keyNumSources = schema[name];
    }
    std::string const getNumSourcesDefinition() const {
        return getSchema().find(_keyNumSources).field.getName();
    }
    lsst::afw::table::Key<int> const getNumSourcesKey() const {
        return _keyNumSources;
    }

    void defineTimeMin(lsst::afw::table::Key<double> const & key) {
        _keyTimeMin = key;
    }
    void defineTimeMin(std::string const & name) {
        lsst::afw::table::Schema schema = getSchema();
        _keyTimeMin = schema[name];
    }
    std::string const getTimeMinDefinition() const {
        return getSchema().find(_keyTimeMin).field.getName();
    }
    lsst::afw::table::Key<double> const getTimeMinKey() const {
        return _keyTimeMin;
    }

    void defineTimeMean(lsst::afw::table::Key<double> const & key) {
        _keyTimeMean = key;
    }
    void defineTimeMean(std::string const & name) {
        lsst::afw::table::Schema schema = getSchema();
        _keyTimeMean = schema[name];
    }
    std::string const getTimeMeanDefinition() const {
        return getSchema().find(_keyTimeMean).field.getName();
    }
    lsst::afw::table::Key<double> const getTimeMeanKey() const {
        return _keyTimeMean;
    }

    void defineTimeMax(lsst::afw::table::Key<double> const & key) {
        _keyTimeMax = key;
    }
    void defineTimeMax(std::string const & name) {
        lsst::afw::table::Schema schema = getSchema();
        _keyTimeMax = schema[name];
    }
    std::string const getTimeMaxDefinition() const {
        return getSchema().find(_keyTimeMax).field.getName();
    }
    lsst::afw::table::Key<double> const getTimeMaxKey() const {
        return _keyTimeMax;
    }


    std::vector<std::string> const getFilters() const;


    void defineNumSources(std::string const & filter,
                  lsst::afw::table::Key<int> const & key) {
        _filterSlots[filter].keyNumSources = key;
    }
    void defineNumSources(std::string const & filter, std::string const & name) {
        lsst::afw::table::Schema schema = getSchema();
        _filterSlots[filter].keyNumSources = schema[filter][name];
    }
    std::string const getNumSourcesDefinition(std::string const & filter) const {
        return getSchema().find(getFilterSlots(filter).keyNumSources).field.getName();
    }
    lsst::afw::table::Key<int> const getNumSourcesKey(std::string const & filter) const {
        return getFilterSlots(filter).keyNumSources;
    }

    void defineTimeMin(std::string const & filter,
                  lsst::afw::table::Key<double> const & key) {
        _filterSlots[filter].keyTimeMin = key;
    }
    void defineTimeMin(std::string const & filter, std::string const & name) {
        lsst::afw::table::Schema schema = getSchema();
        _filterSlots[filter].keyTimeMin = schema[filter][name];
    }
    std::string const getTimeMinDefinition(std::string const & filter) const {
        return getSchema().find(getFilterSlots(filter).keyTimeMin).field.getName();
    }
    lsst::afw::table::Key<double> const getTimeMinKey(std::string const & filter) const {
        return getFilterSlots(filter).keyTimeMin;
    }

    void defineTimeMax(std::string const & filter,
                  lsst::afw::table::Key<double> const & key) {
        _filterSlots[filter].keyTimeMax = key;
    }
    void defineTimeMax(std::string const & filter, std::string const & name) {
        lsst::afw::table::Schema schema = getSchema();
        _filterSlots[filter].keyTimeMax = schema[filter][name];
    }
    std::string const getTimeMaxDefinition(std::string const & filter) const {
        return getSchema().find(getFilterSlots(filter).keyTimeMax).field.getName();
    }
    lsst::afw::table::Key<double> const getTimeMaxKey(std::string const & filter) const {
        return getFilterSlots(filter).keyTimeMax;
    }

    void definePsfFlux(std::string const & filter,
                    lsst::afw::table::Flux::MeasKey const & mean,
                    lsst::afw::table::Flux::ErrKey const & err,
                    lsst::afw::table::Key<int> const & count) {
        _filterSlots[filter].keyPsfFlux = KeyTuple<lsst::afw::table::Flux>(mean, err, count);
    }
    void definePsfFlux(std::string const & filter, std::string const & name) {
        lsst::afw::table::Schema schema = getSchema();
        _filterSlots[filter].keyPsfFlux = KeyTuple<lsst::afw::table::Flux>(
            schema[filter][name],
            schema[filter][name]["err"],
            schema[filter][name]["count"]);
    }
    std::string const getPsfFluxDefinition(std::string const & filter) const {
        return getSchema().find(getFilterSlots(filter).keyPsfFlux.mean).field.getName();
    }
    lsst::afw::table::Flux::MeasKey const getPsfFluxKey(std::string const & filter) const {
        return getFilterSlots(filter).keyPsfFlux.mean;
    }
    lsst::afw::table::Flux::ErrKey const getPsfFluxErrKey(std::string const & filter) const {
        return getFilterSlots(filter).keyPsfFlux.err;
    }
    lsst::afw::table::Key<int> const getPsfFluxCountKey(std::string const & filter) const {
        return getFilterSlots(filter).keyPsfFlux.count;
    }

    void defineModelFlux(std::string const & filter,
                    lsst::afw::table::Flux::MeasKey const & mean,
                    lsst::afw::table::Flux::ErrKey const & err,
                    lsst::afw::table::Key<int> const & count) {
        _filterSlots[filter].keyModelFlux = KeyTuple<lsst::afw::table::Flux>(mean, err, count);
    }
    void defineModelFlux(std::string const & filter, std::string const & name) {
        lsst::afw::table::Schema schema = getSchema();
        _filterSlots[filter].keyModelFlux = KeyTuple<lsst::afw::table::Flux>(
            schema[filter][name],
            schema[filter][name]["err"],
            schema[filter][name]["count"]);
    }
    std::string const getModelFluxDefinition(std::string const & filter) const {
        return getSchema().find(getFilterSlots(filter).keyModelFlux.mean).field.getName();
    }
    lsst::afw::table::Flux::MeasKey const getModelFluxKey(std::string const & filter) const {
        return getFilterSlots(filter).keyModelFlux.mean;
    }
    lsst::afw::table::Flux::ErrKey const getModelFluxErrKey(std::string const & filter) const {
        return getFilterSlots(filter).keyModelFlux.err;
    }
    lsst::afw::table::Key<int> const getModelFluxCountKey(std::string const & filter) const {
        return getFilterSlots(filter).keyModelFlux.count;
    }

    void defineApFlux(std::string const & filter,
                    lsst::afw::table::Flux::MeasKey const & mean,
                    lsst::afw::table::Flux::ErrKey const & err,
                    lsst::afw::table::Key<int> const & count) {
        _filterSlots[filter].keyApFlux = KeyTuple<lsst::afw::table::Flux>(mean, err, count);
    }
    void defineApFlux(std::string const & filter, std::string const & name) {
        lsst::afw::table::Schema schema = getSchema();
        _filterSlots[filter].keyApFlux = KeyTuple<lsst::afw::table::Flux>(
            schema[filter][name],
            schema[filter][name]["err"],
            schema[filter][name]["count"]);
    }
    std::string const getApFluxDefinition(std::string const & filter) const {
        return getSchema().find(getFilterSlots(filter).keyApFlux.mean).field.getName();
    }
    lsst::afw::table::Flux::MeasKey const getApFluxKey(std::string const & filter) const {
        return getFilterSlots(filter).keyApFlux.mean;
    }
    lsst::afw::table::Flux::ErrKey const getApFluxErrKey(std::string const & filter) const {
        return getFilterSlots(filter).keyApFlux.err;
    }
    lsst::afw::table::Key<int> const getApFluxCountKey(std::string const & filter) const {
        return getFilterSlots(filter).keyApFlux.count;
    }

    void defineInstFlux(std::string const & filter,
                    lsst::afw::table::Flux::MeasKey const & mean,
                    lsst::afw::table::Flux::ErrKey const & err,
                    lsst::afw::table::Key<int> const & count) {
        _filterSlots[filter].keyInstFlux = KeyTuple<lsst::afw::table::Flux>(mean, err, count);
    }
    void defineInstFlux(std::string const & filter, std::string const & name) {
        lsst::afw::table::Schema schema = getSchema();
        _filterSlots[filter].keyInstFlux = KeyTuple<lsst::afw::table::Flux>(
            schema[filter][name],
            schema[filter][name]["err"],
            schema[filter][name]["count"]);
    }
    std::string const getInstFluxDefinition(std::string const & filter) const {
        return getSchema().find(getFilterSlots(filter).keyInstFlux.mean).field.getName();
    }
    lsst::afw::table::Flux::MeasKey const getInstFluxKey(std::string const & filter) const {
        return getFilterSlots(filter).keyInstFlux.mean;
    }
    lsst::afw::table::Flux::ErrKey const getInstFluxErrKey(std::string const & filter) const {
        return getFilterSlots(filter).keyInstFlux.err;
    }
    lsst::afw::table::Key<int> const getInstFluxCountKey(std::string const & filter) const {
        return getFilterSlots(filter).keyInstFlux.count;
    }

    void defineShape(std::string const & filter,
                    lsst::afw::table::Shape::MeasKey const & mean,
                    lsst::afw::table::Shape::ErrKey const & err,
                    lsst::afw::table::Key<int> const & count) {
        _filterSlots[filter].keyShape = KeyTuple<lsst::afw::table::Shape>(mean, err, count);
    }
    void defineShape(std::string const & filter, std::string const & name) {
        lsst::afw::table::Schema schema = getSchema();
        _filterSlots[filter].keyShape = KeyTuple<lsst::afw::table::Shape>(
            schema[filter][name],
            schema[filter][name]["err"],
            schema[filter][name]["count"]);
    }
    std::string const getShapeDefinition(std::string const & filter) const {
        return getSchema().find(getFilterSlots(filter).keyShape.mean).field.getName();
    }
    lsst::afw::table::Shape::MeasKey const getShapeKey(std::string const & filter) const {
        return getFilterSlots(filter).keyShape.mean;
    }
    lsst::afw::table::Shape::ErrKey const getShapeErrKey(std::string const & filter) const {
        return getFilterSlots(filter).keyShape.err;
    }
    lsst::afw::table::Key<int> const getShapeCountKey(std::string const & filter) const {
        return getFilterSlots(filter).keyShape.count;
    }


protected:
    SourceClusterTable(lsst::afw::table::Schema const & schema,
                       PTR(lsst::afw::table::IdFactory) const & idFactory);

    SourceClusterTable(SourceClusterTable const & other);

private:
    struct FilterSlots {
        lsst::afw::table::Key<double>     keyTimeMin;
        lsst::afw::table::Key<double>     keyTimeMax;
        lsst::afw::table::Key<int>        keyNumSources;
        KeyTuple<lsst::afw::table::Flux>  keyPsfFlux;
        KeyTuple<lsst::afw::table::Flux>  keyModelFlux;
        KeyTuple<lsst::afw::table::Flux>  keyApFlux;
        KeyTuple<lsst::afw::table::Flux>  keyInstFlux;
        KeyTuple<lsst::afw::table::Shape> keyShape;

        FilterSlots();
        ~FilterSlots();
    };

    typedef std::tr1::unordered_map<std::string, FilterSlots> FilterSlotsMap;

    // Return a writer object that knows how to save in FITS format.
    virtual PTR(lsst::afw::table::io::FitsWriter) makeFitsWriter(
        lsst::afw::table::io::FitsWriter::Fits * fits, int flags) const;

    FilterSlots const & getFilterSlots(std::string const & filter) const;

    lsst::afw::table::Key<lsst::afw::table::Covariance<lsst::afw::table::Point<float> > > _keyCoordErr;
    lsst::afw::table::Key<lsst::afw::coord::Coord> _keyWeightedMeanCoord;
    lsst::afw::table::Key<lsst::afw::table::Covariance<lsst::afw::table::Point<float> > > _keyWeightedMeanCoordErr;
    lsst::afw::table::Key<int> _keyWeightedMeanCoordCount;
    lsst::afw::table::Key<int> _keyNumSources;
    lsst::afw::table::Key<double> _keyTimeMin;
    lsst::afw::table::Key<double> _keyTimeMean;
    lsst::afw::table::Key<double> _keyTimeMax;

    FilterSlotsMap _filterSlots;

    friend class lsst::afw::table::io::FitsWriter;
};


template <typename RecordT>
class SourceClusterColumnViewT : public lsst::afw::table::ColumnViewT<RecordT> {
public:

    typedef RecordT Record;
    typedef typename RecordT::Table Table;

    ndarray::Array<int const,1> const getNumSources() const {
        return this->operator[](this->getTable()->getNumSourcesKey());
    }
    ndarray::Array<double const,1> const getTimeMin() const {
        return this->operator[](this->getTable()->getTimeMinKey());
    }
    ndarray::Array<double const,1> const getTimeMean() const {
        return this->operator[](this->getTable()->getTimeMeanKey());
    }
    ndarray::Array<double const,1> const getTimeMax() const {
        return this->operator[](this->getTable()->getTimeMaxKey());
    }

    ndarray::Array<int const,1> const getNumSources(std::string const & filter) const {
        return this->operator[](this->getTable()->getNumSourcesKey(filter));
    }
    ndarray::Array<double const,1> const getTimeMin(std::string const & filter) const {
        return this->operator[](this->getTable()->getTimeMinKey(filter));
    }
    ndarray::Array<double const,1> const getTimeMax(std::string const & filter) const {
        return this->operator[](this->getTable()->getTimeMaxKey(filter));
    }

    ndarray::Array<double const,1> const getPsfFlux(std::string const & filter) const {
        return this->operator[](this->getTable()->getPsfFluxKey(filter));
    }
    ndarray::Array<double const,1> const getApFlux(std::string const & filter) const {
        return this->operator[](this->getTable()->getApFluxKey(filter));
    }
    ndarray::Array<double const,1> const getModelFlux(std::string const & filter) const {
        return this->operator[](this->getTable()->getModelFluxKey(filter));
    }
    ndarray::Array<double const,1> const getInstFlux(std::string const & filter) const {
        return this->operator[](this->getTable()->getInstFluxKey(filter));
    }

    ndarray::Array<double const,1> const getIxx(std::string const & filter) const {
        return this->operator[](this->getTable()->getShapeKey(filter).getIxx());
    }
    ndarray::Array<double const,1> const getIyy(std::string const & filter) const {
        return this->operator[](this->getTable()->getShapeKey(filter).getIyy());
    }
    ndarray::Array<double const,1> const getIxy(std::string const & filter) const {
        return this->operator[](this->getTable()->getShapeKey(filter).getIxy());
    }

    template <typename InputIterator>
    static SourceClusterColumnViewT make(PTR(Table) const & table,
                                         InputIterator first,
                                         InputIterator last) {
        return SourceClusterColumnViewT(
            lsst::afw::table::BaseColumnView::make(table, first, last));
    }

protected:
    explicit SourceClusterColumnViewT(lsst::afw::table::BaseColumnView const & base) :
        lsst::afw::table::ColumnViewT<RecordT>(base) { }
};

typedef SourceClusterColumnViewT<SourceClusterRecord> SourceClusterColumnView;


class SourceClusterIdFactory : public lsst::afw::table::IdFactory {
public:
    SourceClusterIdFactory(int skyTileId);
    virtual ~SourceClusterIdFactory();

    virtual lsst::afw::table::RecordId operator()();

    // Always throws!
    virtual void notify(lsst::afw::table::RecordId id);

    virtual PTR(lsst::afw::table::IdFactory) clone() const {
        return boost::make_shared<SourceClusterIdFactory>(*this);
    }

private:
    lsst::afw::table::RecordId _id;
    int _skyTileId;
};


#ifndef SWIG

typedef lsst::afw::table::SortedCatalogT<SourceClusterRecord> SourceClusterCatalog;
typedef lsst::afw::table::SortedCatalogT<SourceClusterRecord const> ConstSourceClusterCatalog;

inline Eigen::Matrix<float,2,2> const SourceClusterRecord::getCoordErr() const {
     return this->get(getTable()->getCoordErrKey());
}
inline void SourceClusterRecord::setCoordErr(Eigen::Matrix<float,2,2> const & value) {
     this->set(getTable()->getCoordErrKey(), value);
}

inline lsst::afw::coord::IcrsCoord const SourceClusterRecord::getWeightedMeanCoord() const {
     return this->get(getTable()->getWeightedMeanCoordKey());
}
inline void SourceClusterRecord::setWeightedMeanCoord(lsst::afw::coord::IcrsCoord const & value) {
     this->set(getTable()->getWeightedMeanCoordKey(), value);
}

inline Eigen::Matrix<float,2,2> const SourceClusterRecord::getWeightedMeanCoordErr() const {
     return this->get(getTable()->getWeightedMeanCoordErrKey());
}
inline void SourceClusterRecord::setWeightedMeanCoordErr(Eigen::Matrix<float,2,2> const & value) {
     this->set(getTable()->getWeightedMeanCoordErrKey(), value);
}

inline int const SourceClusterRecord::getWeightedMeanCoordCount() const {
     return this->get(getTable()->getWeightedMeanCoordCountKey());
}
inline void SourceClusterRecord::setWeightedMeanCoordCount(int const & value) {
     this->set(getTable()->getWeightedMeanCoordCountKey(), value);
}

inline int const SourceClusterRecord::getNumSources() const {
     return this->get(getTable()->getNumSourcesKey());
}
inline void SourceClusterRecord::setNumSources(int const & value) {
     this->set(getTable()->getNumSourcesKey(), value);
}

inline double const SourceClusterRecord::getTimeMin() const {
     return this->get(getTable()->getTimeMinKey());
}
inline void SourceClusterRecord::setTimeMin(double const & value) {
     this->set(getTable()->getTimeMinKey(), value);
}

inline double const SourceClusterRecord::getTimeMean() const {
     return this->get(getTable()->getTimeMeanKey());
}
inline void SourceClusterRecord::setTimeMean(double const & value) {
     this->set(getTable()->getTimeMeanKey(), value);
}

inline double const SourceClusterRecord::getTimeMax() const {
     return this->get(getTable()->getTimeMaxKey());
}
inline void SourceClusterRecord::setTimeMax(double const & value) {
     this->set(getTable()->getTimeMaxKey(), value);
}


inline int const SourceClusterRecord::getNumSources(std::string const & filter) const {
     return this->get(getTable()->getNumSourcesKey(filter));
}
inline void SourceClusterRecord::setNumSources(std::string const & filter, int const & value) {
     this->set(getTable()->getNumSourcesKey(filter), value);
}

inline double const SourceClusterRecord::getTimeMin(std::string const & filter) const {
     return this->get(getTable()->getTimeMinKey(filter));
}
inline void SourceClusterRecord::setTimeMin(std::string const & filter, double const & value) {
     this->set(getTable()->getTimeMinKey(filter), value);
}

inline double const SourceClusterRecord::getTimeMax(std::string const & filter) const {
     return this->get(getTable()->getTimeMaxKey(filter));
}
inline void SourceClusterRecord::setTimeMax(std::string const & filter, double const & value) {
     this->set(getTable()->getTimeMaxKey(filter), value);
}


inline lsst::afw::table::Flux::MeasValue const SourceClusterRecord::getPsfFlux(std::string const & filter) const {
     return this->get(getTable()->getPsfFluxKey(filter));
}
inline void SourceClusterRecord::setPsfFlux(std::string const & filter, lsst::afw::table::Flux::MeasValue const & value) {
     this->set(getTable()->getPsfFluxKey(filter), value);
}

inline lsst::afw::table::Flux::ErrValue const SourceClusterRecord::getPsfFluxErr(std::string const & filter) const {
     return this->get(getTable()->getPsfFluxErrKey(filter));
}
inline void SourceClusterRecord::setPsfFluxErr(std::string const & filter, lsst::afw::table::Flux::ErrValue const & value) {
     this->set(getTable()->getPsfFluxErrKey(filter), value);
}

inline int const SourceClusterRecord::getPsfFluxCount(std::string const & filter) const {
     return this->get(getTable()->getPsfFluxCountKey(filter));
}
inline void SourceClusterRecord::setPsfFluxCount(std::string const & filter, int const & value) {
     this->set(getTable()->getPsfFluxCountKey(filter), value);
}


inline lsst::afw::table::Flux::MeasValue const SourceClusterRecord::getModelFlux(std::string const & filter) const {
     return this->get(getTable()->getModelFluxKey(filter));
}
inline void SourceClusterRecord::setModelFlux(std::string const & filter, lsst::afw::table::Flux::MeasValue const & value) {
     this->set(getTable()->getModelFluxKey(filter), value);
}

inline lsst::afw::table::Flux::ErrValue const SourceClusterRecord::getModelFluxErr(std::string const & filter) const {
     return this->get(getTable()->getModelFluxErrKey(filter));
}
inline void SourceClusterRecord::setModelFluxErr(std::string const & filter, lsst::afw::table::Flux::ErrValue const & value) {
     this->set(getTable()->getModelFluxErrKey(filter), value);
}

inline int const SourceClusterRecord::getModelFluxCount(std::string const & filter) const {
     return this->get(getTable()->getModelFluxCountKey(filter));
}
inline void SourceClusterRecord::setModelFluxCount(std::string const & filter, int const & value) {
     this->set(getTable()->getModelFluxCountKey(filter), value);
}


inline lsst::afw::table::Flux::MeasValue const SourceClusterRecord::getApFlux(std::string const & filter) const {
     return this->get(getTable()->getApFluxKey(filter));
}
inline void SourceClusterRecord::setApFlux(std::string const & filter, lsst::afw::table::Flux::MeasValue const & value) {
     this->set(getTable()->getApFluxKey(filter), value);
}

inline lsst::afw::table::Flux::ErrValue const SourceClusterRecord::getApFluxErr(std::string const & filter) const {
     return this->get(getTable()->getApFluxErrKey(filter));
}
inline void SourceClusterRecord::setApFluxErr(std::string const & filter, lsst::afw::table::Flux::ErrValue const & value) {
     this->set(getTable()->getApFluxErrKey(filter), value);
}

inline int const SourceClusterRecord::getApFluxCount(std::string const & filter) const {
     return this->get(getTable()->getApFluxCountKey(filter));
}
inline void SourceClusterRecord::setApFluxCount(std::string const & filter, int const & value) {
     this->set(getTable()->getApFluxCountKey(filter), value);
}


inline lsst::afw::table::Flux::MeasValue const SourceClusterRecord::getInstFlux(std::string const & filter) const {
     return this->get(getTable()->getInstFluxKey(filter));
}
inline void SourceClusterRecord::setInstFlux(std::string const & filter, lsst::afw::table::Flux::MeasValue const & value) {
     this->set(getTable()->getInstFluxKey(filter), value);
}

inline lsst::afw::table::Flux::ErrValue const SourceClusterRecord::getInstFluxErr(std::string const & filter) const {
     return this->get(getTable()->getInstFluxErrKey(filter));
}
inline void SourceClusterRecord::setInstFluxErr(std::string const & filter, lsst::afw::table::Flux::ErrValue const & value) {
     this->set(getTable()->getInstFluxErrKey(filter), value);
}

inline int const SourceClusterRecord::getInstFluxCount(std::string const & filter) const {
     return this->get(getTable()->getInstFluxCountKey(filter));
}
inline void SourceClusterRecord::setInstFluxCount(std::string const & filter, int const & value) {
     this->set(getTable()->getInstFluxCountKey(filter), value);
}


inline lsst::afw::table::Shape::MeasValue const SourceClusterRecord::getShape(std::string const & filter) const {
     return this->get(getTable()->getShapeKey(filter));
}
inline void SourceClusterRecord::setShape(std::string const & filter, lsst::afw::table::Shape::MeasValue const & value) {
     this->set(getTable()->getShapeKey(filter), value);
}

inline lsst::afw::table::Shape::ErrValue const SourceClusterRecord::getShapeErr(std::string const & filter) const {
     return this->get(getTable()->getShapeErrKey(filter));
}
inline void SourceClusterRecord::setShapeErr(std::string const & filter, lsst::afw::table::Shape::ErrValue const & value) {
     this->set(getTable()->getShapeErrKey(filter), value);
}

inline int const SourceClusterRecord::getShapeCount(std::string const & filter) const {
     return this->get(getTable()->getShapeCountKey(filter));
}
inline void SourceClusterRecord::setShapeCount(std::string const & filter, int const & value) {
     this->set(getTable()->getShapeCountKey(filter), value);
}


inline double SourceClusterRecord::getIxx(std::string const & filter) const {
    return get(getTable()->getShapeKey(filter).getIxx());
}
inline double SourceClusterRecord::getIyy(std::string const & filter) const {
    return get(getTable()->getShapeKey(filter).getIyy());
}
inline double SourceClusterRecord::getIxy(std::string const & filter) const {
    return get(getTable()->getShapeKey(filter).getIxy());
}

#endif // !SWIG

}}} // namespace lsst::ap::cluster

#endif // !LSST_AP_CLUSTER_SOURCECLUSTER_H