Struct Ejection 

#[non_exhaustive]
pub struct Ejection {
    pub trigger: Trigger,
    pub parting: Parting,
    pub impulse_n_s: f64,
}

A piece of the airframe leaving the rest on a trigger: the airframe parts at a joint, or lets a payload out.

The piece it makes flies on as a body of its own, numbered after the separation’s aft body: with a Separation the first ejection makes body 2, without one body 1, and each ejection after it the next number, in the order given. A body is the pieces still joined, and it is numbered by the piece nearest the nose among them, so the body that keeps the nose is always body 0. Pieces joined by a shock cord fly as one, so a joint whose pieces stay tied together is not an ejection at all.

When the airframe first comes apart each body starts at its own center of mass with the velocity that point had. A body already flying as a point mass has no attitude to place its pieces by, so they start where it was, at its velocity. Every motor must have burned out by the time an ejection fires. The decision record on ejected pieces, ADR-085, has the reasoning.

An ejection can push its two sides apart with an impulse J (Self::with_impulse), the charge’s or spring’s: the side forward of the joint, or a payload, which leaves forward, takes +J along the airframe’s axis toward the nose, and the other side −J, so each changes velocity by J/m for its own mass m and the momentum is unchanged. The axis is the airframe’s while it flies with nothing open. A body with no attitude of its own (a point mass, or a stack whose attitude froze when a device opened earlier) is taken to point its forward end against its velocity through the air if it hangs from a device, any but a tumble, open just before that instant, and along it, as a stable airframe does, if nothing is open or it only tumbles; below 1 mm/s through the air, up (ADR-086). Partings at one instant part a body together. A separation adds no impulse, and a pushed payload in the nose’s piece is refused.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

trigger: Trigger

When the piece leaves: the same triggers as a recovery device’s.

parting: Parting

Where the airframe parts.

impulse_n_s: f64

The impulse J that pushes the two sides apart, N·s: zero (the default) for none.

Implementations

impl Ejection

pub fn aft_of(trigger: Trigger, component: impl Into<String>) -> Self

The airframe parting at the joint aft of body component component, on trigger.

pub fn payload(trigger: Trigger, component: impl Into<String>) -> Self

Internal component component and what it holds leaving the airframe, on trigger.

pub fn with_impulse(self, impulse_n_s: f64) -> Self

The same ejection, pushing its two sides apart with the impulse impulse_n_s, N·s: the side forward of the joint, or the payload, gets it toward the nose, and the other side its opposite. crate::Simulation::with_ejections refuses one that is negative or not finite. A pushed payload needs a way out forward: one in the nose’s piece is refused when the flight starts, and one whose section’s forward joint hasn’t parted when it leaves is an error in flight.

Trait Implementations

impl Clone for Ejection

fn clone(&self) -> Ejection

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ejection

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Ejection

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Ejection

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

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 Ejection