Calib.h

Go to the documentation of this file.

// -*- lsst-c++ -*-

/*
 * LSST Data Management System
 * Copyright 2008, 2009, 2010 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/>.
 */

//
/*
 * Classes to support calibration (e.g. photometric zero points, exposure times)
 */
#ifndef LSST_AFW_IMAGE_CALIB_H
#define LSST_AFW_IMAGE_CALIB_H

#include <cmath>
#include <utility>
#include <memory>
#include "ndarray_fwd.h"
#include "lsst/base.h"
#include "lsst/daf/base/DateTime.h"
#include "lsst/pex/exceptions.h"
#include "lsst/geom/Point.h"
#include "lsst/afw/table/io/Persistable.h"

namespace lsst {
namespace daf {
namespace base {
class PropertySet;
}
}  // namespace daf

namespace afw {
namespace cameraGeom {
class Detector;
}
namespace image {

static double const JanskysPerABFlux = 3631.0;

inline double abMagFromFlux(double flux) { return -2.5 * std::log10(flux / JanskysPerABFlux); }

inline double abMagErrFromFluxErr(double fluxErr, double flux) {
    return std::abs(fluxErr / (-0.4 * flux * std::log(10)));
}

inline double fluxFromABMag(double mag) noexcept { return std::pow(10.0, -0.4 * mag) * JanskysPerABFlux; }

inline double fluxErrFromABMagErr(double magErr, double mag) noexcept {
    return std::abs(-0.4 * magErr * fluxFromABMag(mag) * std::log(10.0));
}

template <typename T>
ndarray::Array<T, 1> abMagFromFlux(ndarray::Array<T const, 1> const& flux);

template <typename T>
ndarray::Array<T, 1> abMagErrFromFluxErr(ndarray::Array<T const, 1> const& fluxErr,
                                         ndarray::Array<T const, 1> const& flux);

template <typename T>
ndarray::Array<T, 1> fluxFromABMag(ndarray::Array<T const, 1> const& mag);

template <typename T>
ndarray::Array<T, 1> fluxErrFromABMagErr(ndarray::Array<T const, 1> const& magErr,
                                         ndarray::Array<T const, 1> const& mag);

class Calib : public table::io::PersistableFacade<Calib>, public table::io::Persistable {
public:
    explicit Calib() noexcept;
    explicit Calib(double fluxMag0);
    explicit Calib(std::vector<std::shared_ptr<Calib const>> const& calibs);
    explicit Calib(std::shared_ptr<lsst::daf::base::PropertySet const>);

    Calib(Calib const&) noexcept;
    Calib(Calib&&) noexcept;
    Calib& operator=(Calib const&) noexcept;
    Calib& operator=(Calib&&) noexcept;
    ~Calib() noexcept override;

    void setFluxMag0(double fluxMag0, double fluxMag0Err = 0.0);
    void setFluxMag0(std::pair<double, double> fluxMag0AndErr);
    std::pair<double, double> getFluxMag0() const;

    double getFlux(double const mag) const;

    std::pair<double, double> getFlux(double const mag, double const magErr) const;

    ndarray::Array<double, 1> getFlux(ndarray::Array<double const, 1> const& mag) const;

    std::pair<ndarray::Array<double, 1>, ndarray::Array<double, 1>> getFlux(
            ndarray::Array<double const, 1> const& mag, ndarray::Array<double const, 1> const& magErr) const;

    double getMagnitude(double const flux) const;

    std::pair<double, double> getMagnitude(double const flux, double const fluxErr) const;

    ndarray::Array<double, 1> getMagnitude(ndarray::Array<double const, 1> const& flux) const;

    std::pair<ndarray::Array<double, 1>, ndarray::Array<double, 1>> getMagnitude(
            ndarray::Array<double const, 1> const& flux,
            ndarray::Array<double const, 1> const& fluxErr) const;

    static void setThrowOnNegativeFlux(bool raiseException) noexcept;
    static bool getThrowOnNegativeFlux() noexcept;
    bool operator==(Calib const& rhs) const noexcept;
    bool operator!=(Calib const& rhs) const noexcept { return !(*this == rhs); }

    std::size_t hash_value() const noexcept;

    Calib& operator*=(double const scale);
    Calib& operator/=(double const scale) {
        (*this) *= 1.0 / scale;
        return *this;
    }

    bool isPersistable() const noexcept override { return true; }

protected:
    std::string getPersistenceName() const override;

    void write(OutputArchiveHandle& handle) const override;

private:
    double _fluxMag0;
    double _fluxMag0Err;
    static bool _throwOnNegativeFlux;
};

namespace detail {
int stripCalibKeywords(std::shared_ptr<lsst::daf::base::PropertySet> metadata);
}  // namespace detail
}  // namespace image
}  // namespace afw
}  // namespace lsst

namespace std {
template <>
struct hash<lsst::afw::image::Calib> {
    using argument_type = lsst::afw::image::Calib;
    using result_type = size_t;
    size_t operator()(argument_type const& obj) const noexcept { return obj.hash_value(); }
};
}  // namespace std

#endif  // LSST_AFW_IMAGE_CALIB_H