Orbit.h

#pragma once
 
#include <isce3/error/ErrorCode.h>
#include <vector>
#include <string>
 
#include "DateTime.h"
#include "Linspace.h"
#include "StateVector.h"
#include "TimeDelta.h"
#include "Vector.h"
 
namespace isce3 { namespace core {

enum class OrbitInterpMethod {
    Hermite,  
    Legendre, 
};

enum class OrbitInterpBorderMode {
    Error,       
    Extrapolate, 
    FillNaN,     
};

class Orbit {
public:
 
    Orbit() = default;

    Orbit(const std::vector<StateVector> & statevecs,
          OrbitInterpMethod interp_method = OrbitInterpMethod::Hermite,
          const std::string& type = "");

    Orbit(const std::vector<StateVector> & statevecs,
          const std::string& type);

    Orbit(const std::vector<StateVector> & statevecs,
          const DateTime & reference_epoch,
          OrbitInterpMethod interp_method = OrbitInterpMethod::Hermite,
          const std::string& type = "");

    Orbit crop(const DateTime& start, const DateTime& end, int npad = 0) const;

    std::vector<StateVector> getStateVectors() const;

    void setStateVectors(const std::vector<StateVector> &);

    const DateTime & referenceEpoch() const { return _reference_epoch; }

    void referenceEpoch(const DateTime &);

    OrbitInterpMethod interpMethod() const { return _interp_method; }

    void interpMethod(OrbitInterpMethod interp_method) { _interp_method = interp_method; }

    const std::string& type() const { return _type; }

    void type(const std::string& orbit_type) { _type = orbit_type; }

    double startTime() const { return _time[0]; }

    double midTime() const { return startTime() + 0.5 * (size() - 1) * spacing(); }

    double endTime() const { return _time[size()-1]; }

    DateTime startDateTime() const { return _reference_epoch + TimeDelta(startTime()); }

    DateTime midDateTime() const { return _reference_epoch + TimeDelta(midTime()); }

    DateTime endDateTime() const { return _reference_epoch + TimeDelta(endTime()); }

    bool contains(double time) const {
        return (startTime() <= time) && (time <= endTime());
    }

    double spacing() const { return _time.spacing(); }

    int size() const { return _time.size(); }

    const Linspace<double> & time() const { return _time; }

    const std::vector<Vec3> & position() const { return _position; }

    const std::vector<Vec3> & velocity() const { return _velocity; }

    double time(int idx) const { return _time[idx]; }

    const Vec3 & position(int idx) const { return _position[idx]; }

    const Vec3 & velocity(int idx) const { return _velocity[idx]; }

    isce3::error::ErrorCode
    interpolate(Vec3* position, Vec3* velocity, double t,
                   OrbitInterpBorderMode border_mode =
                           OrbitInterpBorderMode::Error) const;
 
private:
    DateTime _reference_epoch;
    Linspace<double> _time;
    std::vector<Vec3> _position;
    std::vector<Vec3> _velocity;
    OrbitInterpMethod _interp_method = OrbitInterpMethod::Hermite;
    std::string _type = "";
};
 
bool operator==(const Orbit &, const Orbit &);
bool operator!=(const Orbit &, const Orbit &);

constexpr
int minStateVecs(OrbitInterpMethod method)
{
    switch (method) {
        case OrbitInterpMethod::Hermite  : return 4;
        case OrbitInterpMethod::Legendre : return 9;
    }
 
    return -1;
}
 
}}