space_units/quantities/

thermal.rs

use super::DisplayWithUnit;

// -------------------------
// Temperature
// -------------------------

/// A temperature quantity, stored canonically in kelvin (K).
///
/// Celsius and Fahrenheit conversions use offset formulas, not simple
/// scale factors. Addition and subtraction operate on raw kelvin values.
///
/// # Construction
/// ```
/// use space_units::Temperature;
/// let t = Temperature::from_c(20.0);
/// ```
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct Temperature(pub(crate) f64);

/// Display/conversion units for [`Temperature`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TemperatureUnit {
    /// Kelvin (K) -- SI base unit for temperature.
    Kelvin,
    /// Degrees Celsius (degC) -- offset from kelvin by 273.15.
    Celsius,
    /// Degrees Fahrenheit (degF) -- offset scale.
    Fahrenheit,
    /// Rankine (R) -- absolute scale in Fahrenheit degrees.
    Rankine,
}

impl TemperatureUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::Kelvin => "K",
            Self::Celsius => "°C",
            Self::Fahrenheit => "°F",
            Self::Rankine => "R",
        }
    }
}

impl Temperature {
    /// Create from kelvin (K).
    pub const fn from_k(val: f64) -> Self {
        Self(val)
    }

    /// Create from degrees Celsius (degC) -- applies +273.15 offset.
    pub const fn from_c(val: f64) -> Self {
        Self(val + 273.15)
    }

    /// Create from degrees Fahrenheit (degF) -- applies offset conversion.
    pub const fn from_f(val: f64) -> Self {
        Self((val - 32.0) * 5.0 / 9.0 + 273.15)
    }

    /// Create from Rankine (R).
    pub const fn from_r(val: f64) -> Self {
        Self(val * 5.0 / 9.0)
    }

    /// Get value in kelvin (K).
    pub const fn in_k(self) -> f64 {
        self.0
    }

    /// Get value in degrees Celsius (degC).
    pub const fn in_c(self) -> f64 {
        self.0 - 273.15
    }

    /// Get value in degrees Fahrenheit (degF).
    pub const fn in_f(self) -> f64 {
        (self.0 - 273.15) * 9.0 / 5.0 + 32.0
    }

    /// Get value in Rankine (R).
    pub const fn in_r(self) -> f64 {
        self.0 * 9.0 / 5.0
    }

    /// Return a display wrapper that formats this temperature in the given unit.
    pub const fn display_as(self, unit: TemperatureUnit) -> DisplayWithUnit {
        let value = match unit {
            TemperatureUnit::Kelvin => self.0,
            TemperatureUnit::Celsius => self.in_c(),
            TemperatureUnit::Fahrenheit => self.in_f(),
            TemperatureUnit::Rankine => self.in_r(),
        };
        DisplayWithUnit {
            value,
            symbol: unit.symbol(),
        }
    }

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

impl_quantity_display!(Temperature, "K");

impl_common_ops!(Temperature);

// -------------------------
// Heat flux
// -------------------------

/// A heat flux quantity, stored canonically in watts per square meter (W/m²).
///
/// # Construction
/// ```
/// use space_units::HeatFlux;
/// let q = HeatFlux::from_solar_flux(1.0); // ~1361 W/m²
/// ```
///
/// # Typed arithmetic
/// - [`Power`](crate::Power) / [`Area`](crate::Area) → [`HeatFlux`]
/// - [`HeatFlux`] × [`Area`](crate::Area) → [`Power`](crate::Power)
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct HeatFlux(pub(crate) f64);

/// Display/conversion units for [`HeatFlux`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HeatFluxUnit {
    /// Watts per square meter (W/m²) -- SI derived unit.
    WattPerM2,
    /// Kilowatts per square meter (kW/m²).
    KiloWattPerM2,
    /// Solar flux units (~1361 W/m² at 1 AU).
    SolarFlux,
}

impl HeatFluxUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::WattPerM2 => "W/m^2",
            Self::KiloWattPerM2 => "kW/m^2",
            Self::SolarFlux => "solar_flux",
        }
    }

    const fn wpm2_per_unit(self) -> f64 {
        match self {
            Self::WattPerM2 => 1.0,
            Self::KiloWattPerM2 => 1e3,
            Self::SolarFlux => 1_361.0,
        }
    }
}

impl HeatFlux {
    /// Create from watts per square meter (W/m²).
    pub const fn from_wpm2(val: f64) -> Self {
        Self(val)
    }

    /// Create from kilowatts per square meter (kW/m²).
    pub const fn from_kwpm2(val: f64) -> Self {
        Self(val * 1e3)
    }

    /// Create from solar flux units (~1361 W/m² at 1 AU).
    pub const fn from_solar_flux(val: f64) -> Self {
        Self(val * 1_361.0)
    }

    /// Get value in watts per square meter (W/m²).
    pub const fn in_wpm2(self) -> f64 {
        self.0
    }

    /// Get value in kilowatts per square meter (kW/m²).
    pub const fn in_kwpm2(self) -> f64 {
        self.0 / 1e3
    }

    /// Get value in solar flux units.
    pub const fn in_solar_flux(self) -> f64 {
        self.0 / 1_361.0
    }

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

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

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

impl_quantity_display!(HeatFlux, "W/m²");

impl_common_ops!(HeatFlux);