one-indexed-vec 0.2.0

A one-based (1-indexed) wrapper around Vec<T>: element at position N is accessed via vec[N].
Documentation
//! Thermodynamics: blackbody radiation and molecular speed distribution.

use crate::Vec1;

/// Planck constant in J*s.
pub const PLANCK: f64 = 6.626_070_15e-34;

/// Speed of light in m/s.
pub const C: f64 = 299_792_458.0;

/// Boltzmann constant in J/K.
pub const K_B: f64 = 1.380_649e-23;

impl Vec1<f64> {
    /// Planck blackbody spectral radiance `B_nu(T)`.
    ///
    /// `B_nu(T) = (2 h nu^3 / c^2) / (exp(h nu / (k_B T)) - 1)`
    ///
    /// `self` holds frequencies `nu` in Hz.
    ///
    /// ```rust
    /// use one_indexed_vec::{vec1, Vec1};
    ///
    /// let nu: Vec1<f64> = vec1![1e14, 2e14, 3e14];
    /// let b = nu.planck_spectrum(300.0);
    /// assert!(b[1] > 0.0);
    /// ```
    pub fn planck_spectrum(&self, temperature: f64) -> Vec1<f64> {
        assert!(temperature > 0.0, "planck_spectrum: T must be > 0");
        let mut out = Vec1::with_capacity(self.len());
        for i in 1..=self.len() {
            let nu = self[i];
            let x = PLANCK * nu / (K_B * temperature);
            if x > 700.0 {
                out.push(0.0);
            } else {
                let num = 2.0 * PLANCK * nu * nu * nu / (C * C);
                out.push(num / (libm::exp(x) - 1.0));
            }
        }
        out
    }

    /// Wien displacement law: peak wavelength for a given temperature.
    ///
    /// `lambda_max = b / T` with `b = 2.897771955e-3 m*K`.
    ///
    /// ```rust
    /// use one_indexed_vec::{vec1, Vec1};
    ///
    /// let t: Vec1<f64> = vec1![300.0, 5778.0];
    /// let wl = t.wien_peak_wavelength();
    /// // Sun's surface ~5778 K -> peak ~500 nm
    /// assert!((wl[2] * 1e9 - 501.0).abs() < 5.0);
    /// ```
    pub fn wien_peak_wavelength(&self) -> Vec1<f64> {
        const WIEN_B: f64 = 2.897_771_955e-3;
        let mut out = Vec1::with_capacity(self.len());
        for i in 1..=self.len() {
            assert!(self[i] > 0.0, "wien_peak_wavelength: temperature must be > 0");
            out.push(WIEN_B / self[i]);
        }
        out
    }

    /// Stefan-Boltzmann total radiated power per unit area: `sigma * T^4`.
    ///
    /// ```rust
    /// use one_indexed_vec::{vec1, Vec1};
    ///
    /// let t: Vec1<f64> = vec1![300.0];
    /// let p = t.stefan_boltzmann_flux();
    /// assert!(p[1] > 0.0);
    /// ```
    pub fn stefan_boltzmann_flux(&self) -> Vec1<f64> {
        const SIGMA: f64 = 5.670_374_419e-8;
        let mut out = Vec1::with_capacity(self.len());
        for i in 1..=self.len() {
            let t = self[i];
            out.push(SIGMA * t * t * t * t);
        }
        out
    }

    /// Maxwell-Boltzmann speed distribution `f(v)`.
    ///
    /// `f(v) = 4*pi * (m / (2*pi*k_B*T))^(3/2) * v^2 * exp(-m*v^2 / (2*k_B*T))`
    ///
    /// `self` holds speeds in m/s.
    ///
    /// ```rust
    /// use one_indexed_vec::{vec1, Vec1};
    ///
    /// let v: Vec1<f64> = vec1![100.0, 500.0, 1000.0];
    /// let f = v.maxwell_boltzmann_speed(300.0, 4.65e-26);
    /// assert!(f[1] > 0.0);
    /// assert!(f[2] > 0.0);
    /// assert!(f[3] > 0.0);
    /// ```
    pub fn maxwell_boltzmann_speed(&self, temperature: f64, mass: f64) -> Vec1<f64> {
        assert!(temperature > 0.0, "maxwell_boltzmann_speed: T must be > 0");
        assert!(mass > 0.0, "maxwell_boltzmann_speed: mass must be > 0");
        let a = mass / (2.0 * K_B * temperature);
        let norm = 4.0 * core::f64::consts::PI * libm::pow(a / core::f64::consts::PI, 1.5);
        let mut out = Vec1::with_capacity(self.len());
        for i in 1..=self.len() {
            let speed = self[i];
            out.push(norm * speed * speed * libm::exp(-a * speed * speed));
        }
        out
    }
}

#[cfg(test)]
mod tests {
    use crate::vec1;

    #[test]
    fn planck_positive() {
        let nu = vec1![1e14, 2e14, 3e14];
        let b = nu.planck_spectrum(300.0);
        assert!(b[1] > 0.0);
        assert!(b[2] > 0.0);
        assert!(b[3] > 0.0);
    }

    #[test]
    fn wien_sun() {
        let t = vec1![5778.0];
        let wl = t.wien_peak_wavelength();
        assert!((wl[1] * 1e9 - 501.0).abs() < 5.0);
    }

    #[test]
    fn stefan_boltzmann_basic() {
        let t = vec1![300.0];
        let p = t.stefan_boltzmann_flux();
        assert!(p[1] > 0.0);
    }

    #[test]
    fn maxwell_boltzmann_basic() {
        let v = vec1![100.0, 500.0, 1000.0];
        let f = v.maxwell_boltzmann_speed(300.0, 4.65e-26);
        assert!(f[1] > 0.0);
        assert!(f[2] > 0.0);
        assert!(f[3] > 0.0);
    }
}