runtime_ephemeris.hpp

Go to the documentation of this file.

#pragma once
 
#include "coordinates.hpp"
#include "ffi_core.hpp"
#include "time.hpp"
 
#include <cstdint>
#include <memory>
#include <string>
 
namespace siderust {
 
struct CartesianVelocity {
  double vx; 
  double vy; 
  double vz; 
  siderust_frame_t frame;
 
  static CartesianVelocity from_c(const siderust_cartesian_vel_t &v) {
    return {v.vx, v.vy, v.vz, v.frame};
  }
};
 
class RuntimeEphemeris {
public:
  // -- Constructors ----------------------------------------------------------
 
  explicit RuntimeEphemeris(const std::string &path) : handle_(nullptr) {
    siderust_runtime_ephemeris_t *h = nullptr;
    check_status(siderust_runtime_ephemeris_load_bsp(path.c_str(), &h), "RuntimeEphemeris(path)");
    handle_ = h;
  }
 
  RuntimeEphemeris(const uint8_t *data, size_t len) : handle_(nullptr) {
    siderust_runtime_ephemeris_t *h = nullptr;
    check_status(siderust_runtime_ephemeris_load_bytes(data, len, &h), "RuntimeEphemeris(bytes)");
    handle_ = h;
  }
 
  // -- Move semantics --------------------------------------------------------
 
  RuntimeEphemeris(RuntimeEphemeris &&other) noexcept : handle_(other.handle_) {
    other.handle_ = nullptr;
  }
 
  RuntimeEphemeris &operator=(RuntimeEphemeris &&other) noexcept {
    if (this != &other) {
      reset();
      handle_ = other.handle_;
      other.handle_ = nullptr;
    }
    return *this;
  }
 
  // Non-copyable
  RuntimeEphemeris(const RuntimeEphemeris &) = delete;
  RuntimeEphemeris &operator=(const RuntimeEphemeris &) = delete;
 
  // -- Destructor ------------------------------------------------------------
 
  ~RuntimeEphemeris() { reset(); }
 
  // -- Queries ---------------------------------------------------------------
 
  cartesian::position::HelioBarycentric<qtty::AstronomicalUnit>
  sun_barycentric(const Time<TT, JD> &jd) const {
    siderust_cartesian_pos_t out;
    check_status(siderust_runtime_ephemeris_sun_barycentric(handle_, jd.value(), &out),
                 "RuntimeEphemeris::sun_barycentric");
    return cartesian::position::HelioBarycentric<qtty::AstronomicalUnit>::from_c(out);
  }
 
  cartesian::position::GeoBarycentric<qtty::AstronomicalUnit>
  earth_barycentric(const Time<TT, JD> &jd) const {
    siderust_cartesian_pos_t out;
    check_status(siderust_runtime_ephemeris_earth_barycentric(handle_, jd.value(), &out),
                 "RuntimeEphemeris::earth_barycentric");
    return cartesian::position::GeoBarycentric<qtty::AstronomicalUnit>::from_c(out);
  }
 
  cartesian::position::EclipticMeanJ2000<qtty::AstronomicalUnit>
  earth_heliocentric(const Time<TT, JD> &jd) const {
    siderust_cartesian_pos_t out;
    check_status(siderust_runtime_ephemeris_earth_heliocentric(handle_, jd.value(), &out),
                 "RuntimeEphemeris::earth_heliocentric");
    return cartesian::position::EclipticMeanJ2000<qtty::AstronomicalUnit>::from_c(out);
  }
 
  cartesian::position::MoonGeocentric<qtty::Kilometer>
  moon_geocentric(const Time<TT, JD> &jd) const {
    siderust_cartesian_pos_t out;
    check_status(siderust_runtime_ephemeris_moon_geocentric(handle_, jd.value(), &out),
                 "RuntimeEphemeris::moon_geocentric");
    return cartesian::position::MoonGeocentric<qtty::Kilometer>::from_c(out);
  }
 
  CartesianVelocity earth_barycentric_velocity(const Time<TT, JD> &jd) const {
    siderust_cartesian_vel_t out{};
    check_status(siderust_runtime_ephemeris_earth_barycentric_velocity(handle_, jd.value(), &out),
                 "RuntimeEphemeris::earth_barycentric_velocity");
    return CartesianVelocity::from_c(out);
  }
 
  // -- Validity --------------------------------------------------------------
 
  explicit operator bool() const noexcept { return handle_ != nullptr; }
 
private:
  siderust_runtime_ephemeris_t *handle_;
 
  void reset() noexcept {
    if (handle_) {
      siderust_runtime_ephemeris_free(handle_);
      handle_ = nullptr;
    }
  }
};
 
} // namespace siderust