DipoleAlgorithms.h

Go to the documentation of this file.

// -*- LSST-C++ -*-
 
/*
 * LSST Data Management System
 * Copyright 2008-2015 AURA/LSST
 *
 * 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_IP_DIFFIM_DIPOLEALGORITHMS_H
#define LSST_IP_DIFFIM_DIPOLEALGORITHMS_H
// Control/algorithm hierarchy for dipole measurement.
//
 
#include <stdio.h>
#include <execinfo.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <array>
 
#include "lsst/base.h"
#include "lsst/pex/config.h"
#include "ndarray/eigen.h"
#include "lsst/afw/table/Source.h"
#include "lsst/meas/base/Algorithm.h"
#include "lsst/meas/base/FluxUtilities.h"
#include "lsst/meas/base/CentroidUtilities.h"
#include "lsst/meas/base/FlagHandler.h"
#include "lsst/meas/base/InputUtilities.h"
 
namespace lsst {
namespace ip {
namespace diffim {
 
class DipoleCentroidControl {
public:
 
    explicit DipoleCentroidControl() {}
};
 
class DipoleFluxControl {
public:
 
    explicit DipoleFluxControl() {}
};

class PsfDipoleFluxControl : public DipoleFluxControl {
public:
    LSST_CONTROL_FIELD(stepSizeCoord, float, "Default initial step size for coordinates in non-linear fitter");
    LSST_CONTROL_FIELD(stepSizeFlux, float, "Default initial step size for flux in non-linear fitter");
    LSST_CONTROL_FIELD(errorDef, double, "How many sigma the error bars of the non-linear fitter represent");
    LSST_CONTROL_FIELD(maxFnCalls, int, "Maximum function calls for non-linear fitter; 0 = unlimited");
    PsfDipoleFluxControl() : DipoleFluxControl(),
                             stepSizeCoord(0.1), stepSizeFlux(1.0), errorDef(1.0), maxFnCalls(100000) {}
};

class DipoleCentroidAlgorithm : public meas::base::SimpleAlgorithm {
public:
 
    static meas::base::FlagDefinition const FAILURE;
    static meas::base::FlagDefinition const POS_FLAG;
    static meas::base::FlagDefinition const NEG_FLAG;
    static meas::base::FlagDefinitionList const & getFlagDefinitions();
 
    typedef DipoleCentroidControl Control;
 
    DipoleCentroidAlgorithm(Control const & ctrl, std::string const & name,
        afw::table::Schema & schema, std::string const & doc);
 
    typedef meas::base::CentroidResultKey ResultKey;

    ResultKey const & getPositiveKeys() const { return _positiveKeys; }
    ResultKey const & getNegativeKeys() const { return _negativeKeys; }
 
protected:
    DipoleCentroidAlgorithm(Control const & ctrl, std::string const & name, afw::table::Schema & schema,
       std::string const & doc, ResultKey const & positiveKeys, ResultKey const & negativeKeys);
 
    Control _ctrl;
    meas::base::FluxResultKey _fluxResultKey;
    meas::base::FlagHandler _flagHandler;
    ResultKey _centerKeys;
    ResultKey _positiveKeys;
    ResultKey _negativeKeys;
};

class DipoleFluxAlgorithm : public meas::base::SimpleAlgorithm {
public:
 
    static meas::base::FlagDefinition const FAILURE;
    static meas::base::FlagDefinition const POS_FLAG;
    static meas::base::FlagDefinition const NEG_FLAG;
    static meas::base::FlagDefinitionList const & getFlagDefinitions();

    typedef DipoleFluxControl Control;
 
    DipoleFluxAlgorithm(Control const & ctrl, std::string const & name, afw::table::Schema & schema,
        std::string const & doc);
 
    // A typedef for the FunctorKey which returns the result of this algorithm
    typedef meas::base::FluxResultKey ResultKey;
    ResultKey const & getPositiveKeys() const { return _positiveKeys; }
    ResultKey const & getNegativeKeys() const { return _negativeKeys; }
 
protected:

    DipoleFluxAlgorithm(Control const & ctrl, std::string const & name,
                        afw::table::Schema & schema, std::string const & doc,
                        ResultKey const & positiveKeys, ResultKey const & negativeKeys);
 
    Control _ctrl;
    meas::base::FluxResultKey _fluxResultKey;
    meas::base::FlagHandler _flagHandler;
 
    ResultKey _positiveKeys;
    ResultKey _negativeKeys;
};
 
inline DipoleCentroidAlgorithm::DipoleCentroidAlgorithm(
    Control const & ctrl, std::string const & name, afw::table::Schema & schema, std::string const & doc
    ) :
    _ctrl(ctrl)
{
    _flagHandler = meas::base::FlagHandler::addFields(schema, name, getFlagDefinitions());
    meas::base::CentroidResultKey::addFields(schema, name, doc+": overall centroid", meas::base::SIGMA_ONLY);
    meas::base::CentroidResultKey::addFields(schema, name+"_pos", doc+": positive lobe", meas::base::SIGMA_ONLY);
    meas::base::CentroidResultKey::addFields(schema, name+"_neg", doc+": negative lobe", meas::base::SIGMA_ONLY);
    _centerKeys = ResultKey(schema[name]);
    _positiveKeys = ResultKey(schema[name+"_pos"]);
    _negativeKeys = ResultKey(schema[name+"_neg"]);
}
 
inline DipoleCentroidAlgorithm::DipoleCentroidAlgorithm(
        Control const & ctrl, std::string const & name, afw::table::Schema & schema, std::string const & doc,
        ResultKey const & positiveKeys, ResultKey const & negativeKeys
    ) :
    _ctrl(ctrl)
{
    _flagHandler = meas::base::FlagHandler::addFields(schema, name, getFlagDefinitions());
    meas::base::CentroidResultKey::addFields(schema, name, doc+": overall centroid", meas::base::SIGMA_ONLY);
    meas::base::CentroidResultKey::addFields(schema, name+"_pos", doc + ": positive lobe", meas::base::SIGMA_ONLY);
    meas::base::CentroidResultKey::addFields(schema, name+"_neg", doc + ": negative lobe", meas::base::SIGMA_ONLY);
    _centerKeys = ResultKey(schema[name]);
 
    _positiveKeys = ResultKey(schema[name+"_pos"]);
    _negativeKeys = ResultKey(schema[name+"_neg"]);
}
 
inline DipoleFluxAlgorithm::DipoleFluxAlgorithm(
    Control const & ctrl, std::string const & name, afw::table::Schema & schema,
        std::string const & doc, ResultKey const & positiveKeys, ResultKey const & negativeKeys
    ) :
    _ctrl(ctrl)
{
    _flagHandler = meas::base::FlagHandler::addFields(schema, name, getFlagDefinitions());
    meas::base::FluxResultKey::addFields(schema, name+"_pos", doc+": positive lobe");
    meas::base::FluxResultKey::addFields(schema, name+"_neg", doc+": negative lobe");
    _positiveKeys = ResultKey(positiveKeys);
    _negativeKeys = ResultKey(negativeKeys);
}
 
inline DipoleFluxAlgorithm::DipoleFluxAlgorithm(
    Control const & ctrl, std::string const & name, afw::table::Schema & schema,
        std::string const & doc
    ) :
    _ctrl(ctrl)
{
    _flagHandler = meas::base::FlagHandler::addFields(schema, name, getFlagDefinitions());
    meas::base::FluxResultKey::addFields(schema, name+"_pos", doc+": positive lobe");
    meas::base::FluxResultKey::addFields(schema, name+"_neg", doc+": negative lobe");
    _positiveKeys = ResultKey(schema[name+"_pos"]);
    _negativeKeys = ResultKey(schema[name+"_neg"]);
}
 

class PsfDipoleFlux : public DipoleFluxAlgorithm {
public:
 
    typedef PsfDipoleFluxControl Control;
 
    PsfDipoleFlux(PsfDipoleFluxControl const & ctrl, std::string const & name, afw::table::Schema & schema) :
        DipoleFluxAlgorithm(ctrl, name, schema, "jointly fitted psf flux counts"),
        _ctrl(ctrl),
        _chi2dofKey(schema.addField<float>(name+"_chi2dof",
                                           "chi2 per degree of freedom of fit"))
    {
        meas::base::CentroidResultKey::addFields(schema, name+"_pos_centroid", "psf fitted center of positive lobe", meas::base::SIGMA_ONLY);
        meas::base::CentroidResultKey::addFields(schema, name+"_neg_centroid", "psf fitted center of negative lobe", meas::base::SIGMA_ONLY);
        meas::base::CentroidResultKey::addFields(schema, name, "average of negative and positive lobe positions", meas::base::SIGMA_ONLY);
        _posCentroid = meas::base::CentroidResultKey(schema[name+"_pos_centroid"]);
        _negCentroid = meas::base::CentroidResultKey(schema[name+"_neg_centroid"]);
        _avgCentroid = meas::base::CentroidResultKey(schema[name]);
    }
    std::pair<double,int> chi2(afw::table::SourceRecord & source,
                afw::image::Exposure<float> const & exposure,
                double negCenterX, double negCenterY, double negFlux,
                double posCenterX, double poCenterY, double posFlux
                ) const;
 
    void measure(
        afw::table::SourceRecord & measRecord,
        afw::image::Exposure<float> const & exposure
    ) const;
 
    void fail(
        afw::table::SourceRecord & measRecord,
        meas::base::MeasurementError * error=NULL
    ) const;
 
private:
 
    Control _ctrl;
    afw::table::Key<float> _chi2dofKey;
    meas::base::CentroidResultKey  _avgCentroid;
    meas::base::CentroidResultKey  _negCentroid;
    meas::base::CentroidResultKey  _posCentroid;
 
};
 
}}}// namespace lsst::ip::diffim
 
#endif // !LSST_IP_DIFFIM_DIPOLEALGORITHMS_H