space_units/quantities/

propulsion.rs

use super::mechanics::G0_MPS2;
use super::mechanics::KG_PER_POUND;
use super::DisplayWithUnit;
use super::Velocity;

// -------------------------
// Specific impulse
// -------------------------

/// A specific impulse quantity, stored canonically in seconds (s).
///
/// # Construction
/// ```
/// use space_units::SpecificImpulse;
/// let isp = SpecificImpulse::from_s(311.0); // RS-25 sea level
/// ```
///
/// # Special methods
/// - [`SpecificImpulse::effective_exhaust_velocity`] returns Isp * g0 as a [`Velocity`](crate::Velocity).
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct SpecificImpulse(pub(crate) f64);

/// Display/conversion units for [`SpecificImpulse`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SpecificImpulseUnit {
    /// Seconds (s) -- conventional Isp unit.
    Second,
    /// Newton-seconds per kilogram (N-s/kg) -- equivalent to effective exhaust velocity.
    NewtonSecondPerKg,
}

impl SpecificImpulseUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::Second => "s",
            Self::NewtonSecondPerKg => "N*s/kg",
        }
    }
}

impl SpecificImpulse {
    /// Create from seconds (s).
    pub const fn from_s(val: f64) -> Self {
        Self(val)
    }

    /// Create from N-s/kg (divide by g0 to get seconds).
    pub const fn from_n_s_per_kg(val: f64) -> Self {
        Self(val / G0_MPS2)
    }

    /// Get value in seconds (s).
    pub const fn in_s(self) -> f64 {
        self.0
    }

    /// Get value in N-s/kg (multiply by g0).
    pub const fn in_n_s_per_kg(self) -> f64 {
        self.0 * G0_MPS2
    }

    /// Effective exhaust velocity: Isp * g0, returned as a [`Velocity`](crate::Velocity).
    pub const fn effective_exhaust_velocity(self) -> Velocity {
        Velocity::from_mps(self.0 * G0_MPS2)
    }

    /// Return a display wrapper that formats this specific impulse in the given unit.
    pub const fn display_as(self, unit: SpecificImpulseUnit) -> DisplayWithUnit {
        match unit {
            SpecificImpulseUnit::Second => DisplayWithUnit {
                value: self.0,
                symbol: unit.symbol(),
            },
            SpecificImpulseUnit::NewtonSecondPerKg => DisplayWithUnit {
                value: self.in_n_s_per_kg(),
                symbol: unit.symbol(),
            },
        }
    }

    /// Return the absolute value of this specific impulse.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(SpecificImpulse, "s");

impl_common_ops!(SpecificImpulse);

// -------------------------
// Mass flow rate
// -------------------------

/// A mass flow rate quantity, stored canonically in kilograms per second (kg/s).
///
/// # Construction
/// ```
/// use space_units::MassFlowRate;
/// let mdot = MassFlowRate::from_kgps(514.0); // RS-25 propellant flow
/// ```
///
/// # Typed arithmetic
/// - [`MassFlowRate`] × [`Velocity`](crate::Velocity) → [`Force`](crate::Force)
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct MassFlowRate(pub(crate) f64);

/// Display/conversion units for [`MassFlowRate`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MassFlowRateUnit {
    /// Kilograms per second (kg/s) -- SI derived unit.
    KgPerS,
    /// Grams per second (g/s).
    GramPerS,
    /// Pounds per second (lb/s).
    PoundPerS,
    /// Kilograms per hour (kg/h).
    KgPerH,
}

impl MassFlowRateUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::KgPerS => "kg/s",
            Self::GramPerS => "g/s",
            Self::PoundPerS => "lb/s",
            Self::KgPerH => "kg/h",
        }
    }

    const fn kgps_per_unit(self) -> f64 {
        match self {
            Self::KgPerS => 1.0,
            Self::GramPerS => 1e-3,
            Self::PoundPerS => KG_PER_POUND,
            Self::KgPerH => 1.0 / 3_600.0,
        }
    }
}

impl MassFlowRate {
    /// Create from kilograms per second (kg/s).
    pub const fn from_kgps(val: f64) -> Self {
        Self(val)
    }

    /// Create from grams per second (g/s).
    pub const fn from_gps(val: f64) -> Self {
        Self(val * 1e-3)
    }

    /// Create from pounds per second (lb/s).
    pub const fn from_lbps(val: f64) -> Self {
        Self(val * KG_PER_POUND)
    }

    /// Create from kilograms per hour (kg/h).
    pub const fn from_kgph(val: f64) -> Self {
        Self(val / 3_600.0)
    }

    /// Get value in kilograms per second (kg/s).
    pub const fn in_kgps(self) -> f64 {
        self.0
    }

    /// Get value in grams per second (g/s).
    pub const fn in_gps(self) -> f64 {
        self.0 / 1e-3
    }

    /// Get value in pounds per second (lb/s).
    pub const fn in_lbps(self) -> f64 {
        self.0 / KG_PER_POUND
    }

    /// Get value in kilograms per hour (kg/h).
    pub const fn in_kgph(self) -> f64 {
        self.0 * 3_600.0
    }

    /// Get value in the specified [`MassFlowRateUnit`].
    pub fn in_unit(self, unit: MassFlowRateUnit) -> f64 {
        self.0 / unit.kgps_per_unit()
    }

    /// Return a display wrapper that formats this mass flow rate in the given unit.
    pub fn display_as(self, unit: MassFlowRateUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Return the absolute value of this mass flow rate.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(MassFlowRate, "kg/s");

impl_common_ops!(MassFlowRate);