FluxUtilities.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_MEAS_BASE_FluxUtilities_h_INCLUDED
#define LSST_MEAS_BASE_FluxUtilities_h_INCLUDED
 
#include "lsst/meas/base/constants.h"
#include "lsst/meas/base/Transform.h"
#include "lsst/afw/geom/SkyWcs.h"
#include "lsst/afw/image/PhotoCalib.h"
#include "lsst/afw/table/FunctorKey.h"
#include "lsst/afw/table/Schema.h"
 
namespace lsst {
namespace meas {
namespace base {

struct FluxResult {
    meas::base::Flux instFlux;               
    meas::base::FluxErrElement instFluxErr;  

    FluxResult();

    explicit FluxResult(meas::base::Flux instFlux_, meas::base::FluxErrElement instFluxErr_)
            : instFlux(instFlux_), instFluxErr(instFluxErr_) {}
    explicit FluxResult(meas::base::Flux instFlux_, meas::base::FluxErrElement instFluxErr_) {…}
};
struct FluxResult {…};

class FluxResultKey : public afw::table::FunctorKey<FluxResult> {
public:
    static FluxResultKey addFields(afw::table::Schema& schema, std::string const& name,
                                   std::string const& doc);

    FluxResultKey() : _instFlux(), _instFluxErr() {}

    FluxResultKey(
            afw::table::Key<meas::base::Flux> const& instFlux,  // namespace qualification to unconfuse swig
            afw::table::Key<meas::base::FluxErrElement> const& instFluxErr)
            : _instFlux(instFlux), _instFluxErr(instFluxErr) {}
    FluxResultKey( {…}

    FluxResultKey(afw::table::SubSchema const& s)
            : _instFlux(s["instFlux"]), _instFluxErr(s["instFluxErr"]) {}
    FluxResultKey(afw::table::SubSchema const& s) {…}

    virtual FluxResult get(afw::table::BaseRecord const& record) const;

    virtual void set(afw::table::BaseRecord& record, FluxResult const& other) const;


    bool operator==(FluxResultKey const& other) const {
        return _instFlux == other._instFlux && _instFluxErr == other._instFluxErr;
    }
    bool operator==(FluxResultKey const& other) const  {…}
    bool operator!=(FluxResultKey const& other) const { return !(*this == other); }

    bool isValid() const { return _instFlux.isValid() && _instFluxErr.isValid(); }

    afw::table::Key<meas::base::Flux> getInstFlux() const { return _instFlux; }

    afw::table::Key<FluxErrElement> getInstFluxErr() const { return _instFluxErr; }
 
private:
    afw::table::Key<meas::base::Flux> _instFlux;
    afw::table::Key<FluxErrElement> _instFluxErr;
};
class FluxResultKey : public afw::table::FunctorKey<FluxResult> {…};

struct MagResult {
    Mag mag;
    MagErrElement magErr;
};
struct MagResult {…};

class MagResultKey : public afw::table::FunctorKey<MagResult> {
public:
    static MagResultKey addFields(afw::table::Schema& schema, std::string const& name);

    MagResultKey() : _magKey(), _magErrKey() {}

    MagResultKey(afw::table::SubSchema const& s) : _magKey(s["mag"]), _magErrKey(s["magErr"]) {}

    virtual MagResult get(afw::table::BaseRecord const& record) const;

    virtual void set(afw::table::BaseRecord& record, MagResult const& magResult) const;

    virtual void set(afw::table::BaseRecord& record, afw::image::Measurement const& magnitude) const;
 
private:
    afw::table::Key<Mag> _magKey;
    afw::table::Key<MagErrElement> _magErrKey;
};
class MagResultKey : public afw::table::FunctorKey<MagResult> {…};

class FluxTransform : public BaseTransform {
public:
    FluxTransform(std::string const& name, afw::table::SchemaMapper& mapper);
 
    /*
     * @brief Perform transformation from inputCatalog to outputCatalog.
     *
     * @param[in]     inputCatalog   Source of data to be transformed
     * @param[in,out] outputCatalog  Container for transformed results
     * @param[in]     wcs            World coordinate system under which transformation will take place
     * @param[in]     photoCalib     Photometric calibration under which transformation will take place
     * @throws        LengthError    Catalog sizes do not match
     */
    virtual void operator()(afw::table::SourceCatalog const& inputCatalog,
                            afw::table::BaseCatalog& outputCatalog, afw::geom::SkyWcs const& wcs,
                            afw::image::PhotoCalib const& photoCalib) const;
 
private:
    MagResultKey _magKey;
};
class FluxTransform : public BaseTransform {…};
 
}  // namespace base
}  // namespace meas
}  // namespace lsst
 
#endif  // !LSST_MEAS_BASE_FluxUtilities_h_INCLUDED