Struct Trajectory 

pub struct Trajectory<T: TimeScale, O: Origin, R: ReferenceFrame> { /* private fields */ }

A time-ordered sequence of Cartesian orbital states with Hermite interpolation.

Implementations

impl<T, O, R> Trajectory<T, O, R>

where T: TimeScale + Copy, O: Origin + Copy, R: ReferenceFrame + Copy,

pub fn new(states: impl IntoIterator<Item = CartesianOrbit<T, O, R>>) -> Self

Constructs a trajectory from an iterator of Cartesian orbital states.

pub fn from_parts( epoch: Time<T>, origin: O, frame: R, data: CartesianTrajectory, ) -> Self

Constructs a trajectory from its constituent parts.

pub fn into_parts(self) -> (Time<T>, O, R, CartesianTrajectory)

Decomposes this trajectory into its constituent parts.

pub fn try_new( states: impl IntoIterator<Item = CartesianOrbit<T, O, R>>, ) -> Result<Self, TrajectorError>

Constructs a trajectory, returning an error if fewer than 2 states are provided.

pub fn at(&self, time: Time<T>) -> CartesianOrbit<T, O, R>

Interpolates the trajectory at the given absolute time.

pub fn into_frame<R1, P>( self, frame: R1, provider: &P, ) -> Result<Trajectory<T, O, R1>, Box<dyn Error>>

where R1: ReferenceFrame + Copy, P: TryRotation<R, R1, T>,

Transforms the entire trajectory into a different reference frame.

pub fn epoch(&self) -> Time<T>

Returns the reference epoch of the trajectory.

pub fn origin(&self) -> O

Returns the central body origin.

pub fn reference_frame(&self) -> R

Returns the reference frame.

pub fn start_time(&self) -> Time<T>

Returns the start time of the trajectory (same as the epoch).

pub fn end_time(&self) -> Time<T>

Returns the end time of the trajectory.

pub fn times(&self) -> Vec<Time<T>>

Returns the absolute times of all data points in the trajectory.

pub fn states(&self) -> Vec<CartesianOrbit<T, O, R>>

Returns all orbital states at the original data points.

pub fn to_vec(&self) -> Vec<Vec<f64>>

Returns the trajectory as a vector of [t, x, y, z, vx, vy, vz] rows.

pub fn interpolate(&self, dt: TimeDelta) -> CartesianOrbit<T, O, R>

Interpolates the trajectory at the given time delta from the epoch.

pub fn interpolate_at(&self, time: Time<T>) -> CartesianOrbit<T, O, R>

Interpolates the trajectory at the given absolute time.

pub fn position(&self, t: f64) -> DVec3

Returns the interpolated position at time t seconds from the epoch.

pub fn velocity(&self, t: f64) -> DVec3

Returns the interpolated velocity at time t seconds from the epoch.

pub fn find_events<F>( &self, func: F, step: TimeDelta, ) -> Result<Vec<Event<T>>, DetectError>

where F: Fn(CartesianOrbit<T, O, R>) -> f64,

Find zero-crossing events of func evaluated along this trajectory.

The closure receives the interpolated CartesianOrbit at each sample time and must return a scalar whose sign changes define events.

pub fn try_find_events<F, E>( &self, func: F, step: TimeDelta, ) -> Result<Vec<Event<T>>, DetectError>

where F: Fn(CartesianOrbit<T, O, R>) -> Result<f64, E>, E: Error + Send + Sync + 'static,

Find zero-crossing events of a fallible func evaluated along this trajectory.

pub fn find_windows<F>( &self, func: F, step: TimeDelta, ) -> Result<Vec<TimeInterval<T>>, DetectError>

where F: Fn(CartesianOrbit<T, O, R>) -> f64,

Find time intervals where func is positive, evaluated along this trajectory.

pub fn try_find_windows<F, E>( &self, func: F, step: TimeDelta, ) -> Result<Vec<TimeInterval<T>>, DetectError>

where F: Fn(CartesianOrbit<T, O, R>) -> Result<f64, E>, E: Error + Send + Sync + 'static,

Find time intervals where a fallible func is positive, evaluated along this trajectory.

impl<T, O, R> Trajectory<T, O, R>

where T: TimeScale + Copy + Into<DynTimeScale>, O: Origin + Copy + Into<DynOrigin>, R: ReferenceFrame + Copy + Into<DynFrame>,

pub fn into_dyn(self) -> DynTrajectory

Converts this trajectory into a dynamically-typed trajectory.

impl<T, O> Trajectory<T, O, Icrf>

where T: TimeScale + Copy, O: Origin + Copy, DefaultOffsetProvider: Offset<T, Tdb>,

pub fn to_origin<O1: Origin + Copy, E: Ephemeris>( &self, target: O1, ephemeris: &E, ) -> Result<Trajectory<T, O1, Icrf>, TrajectoryTransformationError>

Transforms the entire trajectory to a different central body origin using an ephemeris.

impl<O, R> Trajectory<Tai, O, R>

where O: Origin + Copy, R: ReferenceFrame + Copy,

pub fn from_csv(csv: &str, origin: O, frame: R) -> Result<Self, TrajectoryError>

Parses a trajectory from CSV data with columns [time, x, y, z, vx, vy, vz] in km and km/s.

impl Trajectory<DynTimeScale, DynOrigin, DynFrame>

pub fn from_csv_dyn( csv: &str, origin: DynOrigin, frame: DynFrame, ) -> Result<DynTrajectory, TrajectoryError>

Parses a dynamically-typed trajectory from CSV data.

Trait Implementations

impl<T: Clone + TimeScale, O: Clone + Origin, R: Clone + ReferenceFrame> Clone for Trajectory<T, O, R>

fn clone(&self) -> Trajectory<T, O, R>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + TimeScale, O: Debug + Origin, R: Debug + ReferenceFrame> Debug for Trajectory<T, O, R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, O, R> FromIterator<Orbit<Cartesian, T, O, R>> for Trajectory<T, O, R>

where T: TimeScale + Copy, O: Origin + Copy, R: ReferenceFrame + Copy,

fn from_iter<U: IntoIterator<Item = CartesianOrbit<T, O, R>>>(iter: U) -> Self

Creates a value from an iterator.

impl<T, O, R> Propagator<T, O> for Trajectory<T, O, R>

where T: TimeScale + Copy + PartialOrd, O: Origin + Copy, R: ReferenceFrame + Copy,

type Frame = R

The propagator’s native reference frame.

type Error = TrajectorError

The error type returned by propagation methods.

fn state_at( &self, time: Time<T>, ) -> Result<CartesianOrbit<T, O, R>, TrajectorError>

Evaluate the state at a single time.

fn propagate( &self, interval: TimeInterval<T>, ) -> Result<Trajectory<T, O, R>, Self::Error>

Propagate over the given interval in the native frame. The propagator chooses the time steps.

fn propagate_to( &self, times: impl IntoIterator<Item = Time<T>>, ) -> Result<Trajectory<T, O, Self::Frame>, Self::Error>

where Self::Error: From<TrajectorError>,

Propagate to an iterable of caller-chosen times.