Struct Orbit

pub struct Orbit { /* private fields */ }

A struct representing a Keplerian orbit with some cached values.

This struct consumes significantly more memory because of the cache.
However, this will speed up orbital calculations.
If memory efficiency is your goal, you may consider using the CompactOrbit struct instead.

Example

use keplerian_sim::{Orbit, OrbitTrait};
 
let orbit = Orbit::new(
    // Initialize using eccentricity, periapsis, inclination,
    // argument of periapsis, longitude of ascending node,
    // and mean anomaly at epoch
 
    // Eccentricity
    0.0,
 
    // Periapsis
    1.0,
 
    // Inclination
    0.0,
 
    // Argument of periapsis
    0.0,
 
    // Longitude of ascending node
    0.0,
 
    // Mean anomaly at epoch
    0.0,
);
 
let orbit = Orbit::with_apoapsis(
    // Initialize using apoapsis in place of eccentricity
     
    // Apoapsis
    2.0,
 
    // Periapsis
    1.0,
 
    // Inclination
    0.0,
 
    // Argument of periapsis
    0.0,
 
    // Longitude of ascending node
    0.0,
 
    // Mean anomaly at epoch
    0.0,
);

See Orbit::new and Orbit::with_apoapsis for more information.

Implementations

impl Orbit

pub fn new( eccentricity: f64, periapsis: f64, inclination: f64, arg_pe: f64, long_asc_node: f64, mean_anomaly: f64, ) -> Orbit

Creates a new orbit with the given parameters.

Note: This function uses eccentricity instead of apoapsis.
If you want to provide an apoapsis instead, consider using the Orbit::with_apoapsis function instead.

Parameters

• eccentricity: The eccentricity of the orbit.
• periapsis: The periapsis of the orbit, in meters.
• inclination: The inclination of the orbit, in radians.
• arg_pe: The argument of periapsis of the orbit, in radians.
• long_asc_node: The longitude of ascending node of the orbit, in radians.
• mean_anomaly: The mean anomaly of the orbit, in radians.

pub fn with_apoapsis( apoapsis: f64, periapsis: f64, inclination: f64, arg_pe: f64, long_asc_node: f64, mean_anomaly: f64, ) -> Orbit

Creates a new orbit with the given parameters.

Note: This function uses apoapsis instead of eccentricity.
Because of this, it’s not recommended to initialize parabolic or hyperbolic ‘orbits’ with this function.
If you’re looking to initialize a parabolic or hyperbolic trajectory, consider using the Orbit::new function instead.

Parameters

• apoapsis: The apoapsis of the orbit, in meters.
• periapsis: The periapsis of the orbit, in meters.
• inclination: The inclination of the orbit, in radians.
• arg_pe: The argument of periapsis of the orbit, in radians.
• long_asc_node: The longitude of ascending node of the orbit, in radians.
• mean_anomaly: The mean anomaly of the orbit, in radians.

pub fn new_default() -> Orbit

Creates a unit orbit.

The unit orbit is a perfect circle of radius 1 and no “tilt”.

impl Orbit

pub fn get_approx_hyp_ecc_anomaly(&self, mean_anomaly: f64) -> f64

Get an initial guess for the hyperbolic eccentric anomaly of an orbit.

Returns a tuple containing the initial guess and the approximate error of the guess.

From the paper:
“A new method for solving the hyperbolic Kepler equation”
by Baisheng Wu et al.
Quote: “we divide the hyperbolic eccentric anomaly interval into two parts: a finite interval and an infinite interval. For the finite interval, we apply a piecewise Pade approximation to establish an initial approximate solution of HKE. For the infinite interval, an analytical initial approximate solution is constructed.”

impl Orbit

pub fn compactify(self) -> CompactOrbit

Compactify the cached orbit into a compact orbit to increase memory efficiency while sacrificing calculation speed.

Trait Implementations

impl Clone for Orbit

fn clone(&self) -> Orbit

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Orbit

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

Formats the value using the given formatter.

impl From<CompactOrbit> for Orbit

fn from(compact: CompactOrbit) -> Self

Converts to this type from the input type.

impl From<Orbit> for CompactOrbit

fn from(cached: Orbit) -> Self

Converts to this type from the input type.

impl OrbitTrait for Orbit

fn get_semi_major_axis(&self) -> f64

Gets the semi-major axis of the orbit.

fn get_semi_minor_axis(&self) -> f64

Gets the semi-minor axis of the orbit.

fn get_linear_eccentricity(&self) -> f64

Gets the linear eccentricity of the orbit, in meters.

fn get_apoapsis(&self) -> f64

Gets the apoapsis of the orbit.
Returns infinity for parabolic orbits.
Returns negative values for hyperbolic orbits.

fn set_apoapsis(&mut self, apoapsis: f64) -> Result<(), ApoapsisSetterError>

Sets the apoapsis of the orbit.
Errors when the apoapsis is less than the periapsis, or less than zero.
If you want a setter that does not error, use set_apoapsis_force, which will try its best to interpret what you might have meant, but may have undesirable behavior.

fn set_apoapsis_force(&mut self, apoapsis: f64)

Sets the apoapsis of the orbit, with a best-effort attempt at interpreting possibly-invalid values.
This function will not error, but may have undesirable behavior:

fn get_transformation_matrix(&self) -> Matrix3x2<f64>

Gets the transformation matrix needed to tilt a 2D vector into the tilted orbital plane.

fn get_eccentric_anomaly(&self, mean_anomaly: f64) -> f64

Gets the eccentric anomaly at a given mean anomaly in the orbit.

fn get_true_anomaly_at_eccentric_anomaly(&self, eccentric_anomaly: f64) -> f64

Gets the true anomaly at a given eccentric anomaly in the orbit.

fn get_semi_latus_rectum(&self) -> f64

Gets the semi-latus rectum of the orbit.

fn get_altitude_at_angle(&self, true_anomaly: f64) -> f64

Gets the altitude of the body from its parent at a given angle (true anomaly) in the orbit.

fn get_mean_anomaly_at_time(&self, t: f64) -> f64

Gets the mean anomaly at a given time in the orbit.

fn get_eccentricity(&self) -> f64

Gets the eccentricity of the orbit.

fn get_periapsis(&self) -> f64

Gets the periapsis of the orbit.

fn get_inclination(&self) -> f64

Gets the inclination of the orbit in radians.

fn get_arg_pe(&self) -> f64

Gets the argument of periapsis of the orbit in radians.

fn get_long_asc_node(&self) -> f64

Gets the longitude of ascending node of the orbit in radians.

fn get_mean_anomaly_at_epoch(&self) -> f64

Gets the mean anomaly of the orbit at a certain epoch.

fn set_eccentricity(&mut self, value: f64)

Sets the eccentricity of the orbit.

fn set_periapsis(&mut self, value: f64)

Sets the periapsis of the orbit.

fn set_inclination(&mut self, value: f64)

Sets the inclination of the orbit in radians.

fn set_arg_pe(&mut self, value: f64)

Sets the argument of periapsis of the orbit in radians.

fn set_long_asc_node(&mut self, value: f64)

Sets the longitude of ascending node of the orbit in radians.

fn set_mean_anomaly_at_epoch(&mut self, value: f64)

Sets the mean anomaly of the orbit at a certain epoch.

fn get_true_anomaly(&self, mean_anomaly: f64) -> f64

Gets the true anomaly at a given mean anomaly in the orbit.

fn get_eccentric_anomaly_at_time(&self, t: f64) -> f64

Gets the eccentric anomaly at a given time in the orbit.

fn get_true_anomaly_at_time(&self, t: f64) -> f64

Gets the true anomaly at a given time in the orbit.

fn get_position_at_angle(&self, angle: f64) -> (f64, f64, f64)

Gets the 3D position at a given angle (true anomaly) in the orbit.

fn get_flat_position_at_angle(&self, angle: f64) -> (f64, f64)

Gets the 2D position at a given angle (true anomaly) in the orbit.

fn get_altitude_at_time(&self, t: f64) -> f64

Gets the altitude of the body from its parent at a given time in the orbit.

fn get_position_at_time(&self, t: f64) -> (f64, f64, f64)

Gets the 3D position at a given time in the orbit.

fn get_flat_position_at_time(&self, t: f64) -> (f64, f64)

Gets the 2D position at a given time in the orbit.

fn tilt_flat_position(&self, x: f64, y: f64) -> (f64, f64, f64)

Tilts a 2D position into 3D, using the orbital parameters.

impl PartialEq for Orbit

fn eq(&self, other: &Orbit) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Orbit