Struct Landing 

pub struct Landing {
    pub body: Option<usize>,
    pub time_s: f64,
    pub latitude_deg: f64,
    pub longitude_deg: f64,
    pub east_m: f64,
    pub north_m: f64,
    pub distance_m: f64,
    pub ground_hit_speed_m_s: f64,
    pub descent_rate_m_s: f64,
}

Where something landed: the center of mass as it reached the launch site’s ellipsoidal height.

Fields

body: Option<usize>

Which separated body (crate::BodyFlight::body), or None for the flight itself: the stack, or after a powered separation the sustainer.

time_s: f64

When, s after launch.

latitude_deg: f64

Geodetic latitude, degrees north (WGS 84).

longitude_deg: f64

Longitude, degrees east (WGS 84).

east_m: f64

East of the launch site in its local frame, m.

north_m: f64

North of the launch site, m.

distance_m: f64

The horizontal distance from the launch site, m.

ground_hit_speed_m_s: f64

The speed of the center of mass at the ground hit, relative to the ground, m/s.

descent_rate_m_s: f64

Its downward speed then, m/s.

Implementations

impl Landing

pub fn at( body: Option<usize>, sample: &BodySample, environment: &Environment, ) -> Result<Self, SimError>

The landing at sample, for body, located on environment’s ellipsoid.

Errors

SimError::Core if the position has no geodetic coordinates.

Trait Implementations

impl Clone for Landing

fn clone(&self) -> Landing

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Landing

impl Debug for Landing

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Landing

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Landing

fn eq(&self, other: &Landing) -> 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 Serialize for Landing

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Landing