Struct CompactOrbit

pub struct CompactOrbit {
    pub eccentricity: f64,
    pub periapsis: f64,
    pub inclination: f64,
    pub arg_pe: f64,
    pub long_asc_node: f64,
    pub mean_anomaly: f64,
}

A minimal struct representing a Keplerian orbit.

This struct minimizes memory footprint by not caching variables.
Because of this, calculations can be slower than caching those variables.
For this reason, you might consider using the Orbit struct instead.

Example

use keplerian_sim::{CompactOrbit, OrbitTrait};
 
let orbit = CompactOrbit::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 = CompactOrbit::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.

Fields

eccentricity: f64

The eccentricity of the orbit.
e < 1: ellipse
e = 1: parabola
e > 1: hyperbola

See more: https://en.wikipedia.org/wiki/Orbital_eccentricity

periapsis: f64

The periapsis of the orbit, in meters.

The periapsis of an orbit is the distance at the closest point to the parent body.

More simply, this is the “minimum altitude” of an orbit.

inclination: f64

The inclination of the orbit, in radians. The inclination of an orbit is the angle between the plane of the orbit and the reference plane.

In simple terms, it tells you how “tilted” the orbit is.

arg_pe: f64

The argument of periapsis of the orbit, in radians.

Wikipedia:
The argument of periapsis is the angle from the body’s ascending node to its periapsis, measured in the direction of motion.
https://en.wikipedia.org/wiki/Argument_of_periapsis

In simple terms, it tells you how, and in which direction, the orbit “tilts”.

long_asc_node: f64

The longitude of ascending node of the orbit, in radians.

Wikipedia:
The longitude of ascending node is the angle from a specified reference direction, called the origin of longitude, to the direction of the ascending node, as measured in a specified reference plane.
https://en.wikipedia.org/wiki/Longitude_of_the_ascending_node

In simple terms, it tells you how, and in which direction, the orbit “tilts”.

mean_anomaly: f64

The mean anomaly at orbit epoch, in radians.

For elliptic orbits, it’s measured in radians and so are bounded between 0 and tau; anything out of range will get wrapped around.
For hyperbolic orbits, it’s unbounded.

Wikipedia:
The mean anomaly at epoch, M_0, is defined as the instantaneous mean anomaly at a given epoch, t_0.
https://en.wikipedia.org/wiki/Mean_anomaly#Mean_anomaly_at_epoch

In simple terms, this modifies the “offset” of the orbit progression.

Implementations

impl CompactOrbit

pub fn expand(self) -> Orbit

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

impl CompactOrbit

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

Creates a new CompactOrbit instance with the given parameters.

Note: This function uses eccentricity instead of apoapsis.
If you want to provide an apoapsis instead, consider using the CompactOrbit::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, ) -> CompactOrbit

Creates a new CompactOrbit instance 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 CompactOrbit::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() -> CompactOrbit

Creates a unit orbit.

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

impl CompactOrbit

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.”

Trait Implementations

impl Clone for CompactOrbit

fn clone(&self) -> CompactOrbit

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CompactOrbit

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 CompactOrbit

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.