Struct CatalogMotor 

pub struct CatalogMotor {

    pub motor_id: String,
    pub manufacturer: String,
    pub manufacturer_abbrev: String,
    pub designation: String,
    pub common_name: String,
    pub impulse_class: ImpulseClass,
    pub motor_type: MotorType,
    pub case_info: Option<String>,
    pub prop_info: Option<String>,
    pub delays: Option<String>,
    pub diameter_mm: f64,
    pub length_mm: f64,
    pub total_impulse_ns: f64,
    pub average_thrust_n: f64,
    pub max_thrust_n: Option<f64>,
    pub burn_time_s: f64,
    pub propellant_mass_g: Option<f64>,
    pub total_mass_g: Option<f64>,
    pub curves: Vec<CatalogCurve>,
}

One motor’s catalog entry, in the units motor files use.

Fields

motor_id: String

ThrustCurve.org’s id for the motor.

manufacturer: String

Manufacturer name.

manufacturer_abbrev: String

Manufacturer abbreviation.

designation: String

Full designation, such as 1266J760-19A.

common_name: String

Common name, such as J760.

impulse_class: ImpulseClass

Impulse class letter.

motor_type: MotorType

Single-use or reload.

case_info: Option<String>

The case a reload fits, such as Pro54-3G.

prop_info: Option<String>

The propellant.

delays: Option<String>

Available delays as written (6,10,14, 4-6, P; the bundled index copies the curve file’s header); see CatalogMotor::delays.

diameter_mm: f64

Diameter, mm.

length_mm: f64

Length, mm.

total_impulse_ns: f64

Total impulse, N·s (ThrustCurve::total_impulse_ns in the bundled index).

average_thrust_n: f64

Average thrust, N (ThrustCurve::average_thrust_n in the bundled index).

max_thrust_n: Option<f64>

Peak thrust, N (ThrustCurve::peak_thrust_n in the bundled index).

burn_time_s: f64

Burn time, s (ThrustCurve::burn_time_s, the NFPA 1125 window, in the bundled index).

propellant_mass_g: Option<f64>

Propellant mass, g.

total_mass_g: Option<f64>

Loaded mass, g.

curves: Vec<CatalogCurve>

The motor’s curves.

Implementations

impl CatalogMotor

pub fn delays(&self) -> DelayList

The delay settings read from CatalogMotor::delays; empty when none are recorded.

pub fn thrust_curve( &self, curve: &CatalogCurve, text: &str, ) -> Result<ThrustCurve, MotorError>

Reads a curve of this motor from its file’s text.

Errors

• MotorError::Inconsistent if curve is not one of this motor’s curves, or the file doesn’t hold exactly one motor.
• The format’s parse error (eng::parse, rse::parse).
• ThrustCurve::new’s errors.

pub fn motor( &self, curve: &CatalogCurve, text: &str, ) -> Result<SolidMotor, MotorError>

The motor with the curve read from text, built with SolidMotor::from_envelope from this entry’s diameter, length and masses. The curve file’s header is used only for a mass the metadata lacks.

Errors

As CatalogMotor::thrust_curve and SolidMotor::from_envelope, and MotorError::Inconsistent for a hybrid (hpr models solids only) or when neither the metadata nor the file gives the masses. The text is not checked against the curve’s SHA-256: pass the file the curve names.

pub fn bundled_motor(&self) -> Result<SolidMotor, MotorError>

The motor with its first bundled curve.

Errors

MotorError::Inconsistent if the entry has no bundled curve file, and CatalogMotor::motor’s errors.

Trait Implementations

impl Clone for CatalogMotor

fn clone(&self) -> CatalogMotor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CatalogMotor

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CatalogMotor

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CatalogMotor

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

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 CatalogMotor