Orbit.h

#pragma once

#include <thrust/device_vector.h>
#include <vector>

#include <isce3/core/DateTime.h>
#include <isce3/core/Linspace.h>
#include <isce3/core/Orbit.h>
#include <isce3/core/StateVector.h>
#include <isce3/core/TimeDelta.h>
#include <isce3/core/Vector.h>

namespace isce3 { namespace cuda { namespace core {

class Orbit {
public:

    Orbit() = default;

    Orbit(const isce3::core::Orbit &);

    Orbit(const std::vector<isce3::core::StateVector> & statevecs,
          isce3::core::OrbitInterpMethod interp_method = isce3::core::OrbitInterpMethod::Hermite);

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

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

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

    const isce3::core::DateTime & referenceEpoch() const { return _reference_epoch; }

    void referenceEpoch(const isce3::core::DateTime &);

    isce3::core::OrbitInterpMethod interpMethod() const { return _interp_method; }

    void interpMethod(isce3::core::OrbitInterpMethod interp_method) { _interp_method = interp_method; }

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

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

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

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

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

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

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

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

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

    const thrust::device_vector<isce3::core::Vec3> & position() const { return _position; }

    const thrust::device_vector<isce3::core::Vec3> & velocity() const { return _velocity; }

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

    isce3::core::Vec3 position(int idx) const { return _position[idx]; }

    isce3::core::Vec3 velocity(int idx) const { return _velocity[idx]; }

    isce3::error::ErrorCode
    interpolate(isce3::core::Vec3* position, isce3::core::Vec3* velocity,
                double t,
                isce3::core::OrbitInterpBorderMode border_mode =
                        isce3::core::OrbitInterpBorderMode::Error) const;

private:
    isce3::core::DateTime _reference_epoch;
    isce3::core::Linspace<double> _time;
    thrust::device_vector<isce3::core::Vec3> _position;
    thrust::device_vector<isce3::core::Vec3> _velocity;
    isce3::core::OrbitInterpMethod _interp_method = isce3::core::OrbitInterpMethod::Hermite;
};

bool operator==(const Orbit &, const Orbit &);
bool operator!=(const Orbit &, const Orbit &);

}}}