sgp4.hpp

Go to the documentation of this file.

#pragma once
 
#include "ffi_core.hpp"
 
#include <cstdint>
#include <ostream>
#include <string_view>
#include <utility>
 
namespace siderust {
 
 
// ============================================================================
// TLE handle
// ============================================================================
 
namespace tle {
 
class Tle {
public:
  static Tle parse(std::string_view line1, std::string_view line2) {
    const std::string l1{line1};
    const std::string l2{line2};
    SiderustTle *handle = nullptr;
    check_status(siderust_tle_parse(l1.c_str(), l2.c_str(), &handle), "tle::Tle::parse");
    return Tle{handle};
  }
 
  Tle(Tle &&other) noexcept : handle_(std::exchange(other.handle_, nullptr)) {}
  Tle &operator=(Tle &&other) noexcept {
    if (this != &other) {
      siderust_tle_free(handle_);
      handle_ = std::exchange(other.handle_, nullptr);
    }
    return *this;
  }
 
  Tle(const Tle &) = delete;
  Tle &operator=(const Tle &) = delete;
 
  ~Tle() { siderust_tle_free(handle_); }
 
  std::uint32_t norad_id() const {
    std::uint32_t id = 0;
    check_status(siderust_tle_norad_id(handle_, &id), "tle::Tle::norad_id");
    return id;
  }
 
  const SiderustTle *raw() const noexcept { return handle_; }
 
private:
  explicit Tle(SiderustTle *h) : handle_(h) {}
  SiderustTle *handle_;
};
 
} // namespace tle
 
// ============================================================================
// SGP4 propagator
// ============================================================================
 
namespace sgp4 {
 
enum class GravityModel : int {
  Wgs72 = 0,    
  Wgs72Iau = 1, 
  Wgs84 = 2,    
};
 
struct State {
  double pos_km[3];  
  double vel_kms[3]; 
};
 
inline std::ostream &operator<<(std::ostream &os, const State &s) {
  os << "SGP4 TEME (pos_km=(" << s.pos_km[0] << ", " << s.pos_km[1] << ", " << s.pos_km[2]
     << "), vel_kms=(" << s.vel_kms[0] << ", " << s.vel_kms[1] << ", " << s.vel_kms[2] << "))";
  return os;
}
 
class Propagator {
public:
  explicit Propagator(const tle::Tle &tle, GravityModel model = GravityModel::Wgs72) {
    check_status(siderust_sgp4_new(tle.raw(), static_cast<int>(model), &handle_),
                 "sgp4::Propagator");
  }
 
  Propagator(Propagator &&other) noexcept : handle_(std::exchange(other.handle_, nullptr)) {}
  Propagator &operator=(Propagator &&other) noexcept {
    if (this != &other) {
      siderust_sgp4_free(handle_);
      handle_ = std::exchange(other.handle_, nullptr);
    }
    return *this;
  }
 
  Propagator(const Propagator &) = delete;
  Propagator &operator=(const Propagator &) = delete;
 
  ~Propagator() { siderust_sgp4_free(handle_); }
 
  double epoch_jd_utc() const {
    double jd = 0.0;
    check_status(siderust_sgp4_epoch_jd_utc(handle_, &jd), "sgp4::Propagator::epoch_jd_utc");
    return jd;
  }
 
  int gravity_model() const {
    int m = 0;
    check_status(siderust_sgp4_gravity_model(handle_, &m), "sgp4::Propagator::gravity_model");
    return m;
  }
 
  State propagate_at(double jd_utc) const {
    State s{};
    check_status(siderust_sgp4_propagate_at(handle_, jd_utc, s.pos_km, s.vel_kms),
                 "sgp4::Propagator::propagate_at");
    return s;
  }
 
private:
  SiderustSgp4 *handle_ = nullptr;
};
 
} // namespace sgp4
 
 
} // namespace siderust