SpecFrame.h

Go to the documentation of this file.

/*
 * LSST Data Management System
 * Copyright 2017 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 <https://www.lsstcorp.org/LegalNotices/>.
 */
#ifndef ASTSHIM_SPECFRAME_H
#define ASTSHIM_SPECFRAME_H
 
#include <memory>
#include <vector>
 
#include "astshim/base.h"
#include "astshim/detail/utils.h"
#include "astshim/Frame.h"
 
namespace ast {

class SpecFrame : public Frame {
    friend class Object;
 
public:
    explicit SpecFrame(std::string const &options = "")
            : Frame(reinterpret_cast<AstFrame *>(astSpecFrame("%s", options.c_str()))) {}
 
    virtual ~SpecFrame() {}

    SpecFrame(SpecFrame const &) = default;
    SpecFrame(SpecFrame &&) = default;
    SpecFrame &operator=(SpecFrame const &) = delete;
    SpecFrame &operator=(SpecFrame &&) = default;

    std::shared_ptr<SpecFrame> copy() const {
        return std::static_pointer_cast<SpecFrame>(copyPolymorphic());
    }

    bool getAlignSpecOffset() const { return getB("AlignSpecOffset"); }

    std::string getAlignStdOfRest() const { return getC("AlignStdOfRest"); }

    std::string getRefDec() const { return getC("RefDec"); }

    std::string getRefRA() const { return getC("RefRA"); }

    std::vector<double> getRefPos(SkyFrame const &frm) const {
        std::vector<double> ret(2);
        astGetRefPos(getRawPtr(), frm.getRawPtr(), &ret[0], &ret[1]);
        assertOK();
        detail::astBadToNan(ret);
        return ret;
    }

    std::vector<double> getRefPos() const {
        std::vector<double> ret(2);
        // using NULL instead of nullptr avoids a compiler warning about comparing NULL to nullptr_t
        astGetRefPos(getRawPtr(), NULL, &ret[0], &ret[1]);
        assertOK();
        detail::astBadToNan(ret);
        return ret;
    }

    double getRestFreq() const { return getD("RestFreq"); }

    std::string getSourceSys() const { return getC("SourceSys"); }

    double getSourceVel() const { return getD("SourceVel"); }

    std::string getSourceVRF() const { return getC("SourceVRF"); }

    double getSpecOrigin() const { return getD("SpecOrigin"); }

    std::string getStdOfRest() const { return getC("StdOfRest"); }

    void setAlignSpecOffset(bool align) { setB("AlignSpecOffset", align); }

    void setAlignStdOfRest(std::string const &stdOfRest) { setC("AlignStdOfRest", stdOfRest); }

    void setRefDec(std::string const &refDec) { setC("RefDec", refDec); }

    void setRefRA(std::string const &refRA) { setC("RefRA", refRA); }

    void setRefPos(SkyFrame const &frm, double lon, double lat) {
        astSetRefPos(getRawPtr(), frm.getRawPtr(), lon, lat);
        assertOK();
    }

    void setRefPos(double ra, double dec) {
        // using NULL instead of nullptr avoids a compiler warning about comparing NULL to nullptr_t
        astSetRefPos(getRawPtr(), NULL, ra, dec);
        assertOK();
    }

    void setRestFreq(double freq) { setD("RestFreq", freq); }

    void setRestFreq(std::string const &freq) { setC("RestFreq", freq); }

    void setSourceSys(std::string const &system) { setC("SourceSys", system); }

    void setSourceVel(double vel) { setD("SourceVel", vel); }

    void setSourceVRF(std::string const &vrf) { setC("SourceVRF", vrf); }

    void setSpecOrigin(double origin) { setD("SpecOrigin", origin); }

    void setStdOfRest(std::string const &stdOfRest) { setC("StdOfRest", stdOfRest); }
 
protected:
    virtual std::shared_ptr<Object> copyPolymorphic() const override {
        return copyImpl<SpecFrame, AstSpecFrame>();
    }

    explicit SpecFrame(AstSpecFrame *rawptr) : Frame(reinterpret_cast<AstFrame *>(rawptr)) {
        if (!astIsASpecFrame(getRawPtr())) {
            std::ostringstream os;
            os << "this is a " << getClassName() << ", which is not a SpecFrame";
            throw std::invalid_argument(os.str());
        }
    }
};
 
}  // namespace ast
 
#endif