use crate::SIGMA;
use crate::error::ClimateError;
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Band {
pub weight: f64,
pub absorption: f64,
pub path_length: f64,
}
impl Band {
pub fn new(weight: f64, absorption: f64, path_length: f64) -> Result<Self, ClimateError> {
if weight < 0.0 {
return Err(ClimateError::InvalidModel(
"band weight must be >= 0".into(),
));
}
if absorption < 0.0 {
return Err(ClimateError::InvalidModel(
"band absorption must be >= 0".into(),
));
}
if path_length < 0.0 {
return Err(ClimateError::InvalidModel(
"band path length must be >= 0".into(),
));
}
Ok(Self {
weight,
absorption,
path_length,
})
}
#[must_use]
pub fn emissivity(&self) -> f64 {
let tau = (self.absorption * self.path_length).min(700.0);
1.0 - (-tau).exp()
}
#[must_use]
pub fn transmittance(&self) -> f64 {
let tau = (self.absorption * self.path_length).min(700.0);
(-tau).exp()
}
}
#[derive(Debug, Clone)]
pub struct MultiBandRadiativeTransfer {
bands: Vec<Band>,
pub t_atm: f64,
}
impl MultiBandRadiativeTransfer {
pub fn new(bands: Vec<Band>, t_atm: f64) -> Result<Self, ClimateError> {
if bands.is_empty() {
return Err(ClimateError::InvalidModel("need at least one band".into()));
}
if t_atm <= 0.0 {
return Err(ClimateError::InvalidModel(
"emitting-layer temperature must be > 0".into(),
));
}
let wsum: f64 = bands.iter().map(|b| b.weight).sum();
if (wsum - 1.0).abs() > 1e-6 {
return Err(ClimateError::InvalidModel(format!(
"band weights must sum to 1 (got {wsum})"
)));
}
Ok(Self { bands, t_atm })
}
#[must_use]
pub fn effective_emissivity(&self) -> f64 {
self.bands.iter().map(|b| b.weight * b.emissivity()).sum()
}
#[must_use]
pub fn band_olr(&self, t_surf: f64) -> Vec<f64> {
let sst4 = SIGMA * t_surf.powi(4);
let sat4 = SIGMA * self.t_atm.powi(4);
self.bands
.iter()
.map(|b| b.weight * (b.transmittance() * sst4 + b.emissivity() * sat4))
.collect()
}
#[must_use]
pub fn olr(&self, t_surf: f64) -> f64 {
self.band_olr(t_surf).iter().sum()
}
#[must_use]
pub fn downward_flux(&self) -> f64 {
let sat4 = SIGMA * self.t_atm.powi(4);
self.bands
.iter()
.map(|b| b.weight * b.emissivity() * sat4)
.sum()
}
}
#[derive(Debug, Clone)]
pub struct CorrelatedKBand {
pub weight: f64,
pub k_g: Vec<f64>,
pub w_g: Vec<f64>,
}
impl CorrelatedKBand {
pub fn new(weight: f64, k_g: Vec<f64>, w_g: Vec<f64>) -> Result<Self, ClimateError> {
if weight < 0.0 {
return Err(ClimateError::InvalidModel(
"band weight must be >= 0".into(),
));
}
if k_g.len() != w_g.len() {
return Err(ClimateError::InvalidModel(
"k_g and w_g must have equal length".into(),
));
}
if k_g.iter().any(|&k| k < 0.0) || w_g.iter().any(|&w| w < 0.0) {
return Err(ClimateError::InvalidModel(
"k_g/w_g weights must be >= 0".into(),
));
}
let wsum: f64 = w_g.iter().sum();
if (wsum - 1.0).abs() > 1e-6 {
return Err(ClimateError::InvalidModel(format!(
"g-point weights must sum to 1 (got {wsum})"
)));
}
Ok(Self { weight, k_g, w_g })
}
#[must_use]
pub fn transmittance(&self, path_length: f64) -> f64 {
self.k_g
.iter()
.zip(&self.w_g)
.map(|(&k, &w)| w * (-(k * path_length).min(700.0)).exp())
.sum()
}
#[must_use]
pub fn emissivity(&self, path_length: f64) -> f64 {
1.0 - self.transmittance(path_length)
}
}
#[derive(Debug, Clone)]
pub struct CorrelatedKRt {
bands: Vec<CorrelatedKBand>,
pub t_atm: f64,
pub path_length: f64,
}
impl CorrelatedKRt {
pub fn new(
bands: Vec<CorrelatedKBand>,
t_atm: f64,
path_length: f64,
) -> Result<Self, ClimateError> {
if bands.is_empty() {
return Err(ClimateError::InvalidModel("need at least one band".into()));
}
if t_atm <= 0.0 {
return Err(ClimateError::InvalidModel(
"emitting-layer temperature must be > 0".into(),
));
}
let wsum: f64 = bands.iter().map(|b| b.weight).sum();
if (wsum - 1.0).abs() > 1e-6 {
return Err(ClimateError::InvalidModel(format!(
"band weights must sum to 1 (got {wsum})"
)));
}
Ok(Self {
bands,
t_atm,
path_length,
})
}
#[must_use]
pub fn olr(&self, t_surf: f64) -> f64 {
let sst4 = SIGMA * t_surf.powi(4);
let sat4 = SIGMA * self.t_atm.powi(4);
self.bands
.iter()
.map(|b| {
let tau = b.transmittance(self.path_length);
let eps = 1.0 - tau;
b.weight * (tau * sst4 + eps * sat4)
})
.sum()
}
}
#[cfg(test)]
mod tests {
use super::*;
use approx::assert_abs_diff_eq;
#[test]
fn band_emissivity_monotonic_in_path() {
let b = Band::new(1.0, 0.1, 1.0).unwrap();
assert!(b.emissivity() > 0.0 && b.emissivity() < 1.0);
assert_abs_diff_eq!(b.transmittance(), 1.0 - b.emissivity(), epsilon = 1e-12);
let thick = Band::new(1.0, 0.1, 100.0).unwrap();
assert!(thick.emissivity() > b.emissivity());
}
#[test]
fn single_band_reduces_to_grey() {
let eps = 0.6f64;
let kappa = -((1.0f64 - eps).ln()); let b = Band::new(1.0, kappa, 1.0).unwrap();
let rt = MultiBandRadiativeTransfer::new(vec![b], 250.0).unwrap();
let ts = 288.0;
let f = rt.olr(ts);
let expected = (1.0 - eps) * SIGMA * ts.powi(4) + eps * SIGMA * 250.0_f64.powi(4);
assert_abs_diff_eq!(f, expected, epsilon = 1e-6);
}
#[test]
fn multi_band_olr_exceeds_grey_for_same_mean_eps() {
let kappa = 0.05;
let b1 = Band::new(0.5, kappa, 10.0).unwrap();
let b2 = Band::new(0.5, kappa, 10.0).unwrap();
let split = MultiBandRadiativeTransfer::new(vec![b1, b2], 250.0).unwrap();
let whole = Band::new(1.0, kappa, 10.0).unwrap();
let whole_rt = MultiBandRadiativeTransfer::new(vec![whole], 250.0).unwrap();
assert_abs_diff_eq!(split.olr(288.0), whole_rt.olr(288.0), epsilon = 1e-9);
}
#[test]
fn correlated_k_matches_single_grey_at_one_point() {
let kappa = 0.07;
let ck = CorrelatedKBand::new(1.0, vec![kappa], vec![1.0]).unwrap();
let rt = CorrelatedKRt::new(vec![ck], 250.0, 10.0).unwrap();
let grey = Band::new(1.0, kappa, 10.0).unwrap();
let grey_rt = MultiBandRadiativeTransfer::new(vec![grey], 250.0).unwrap();
assert_abs_diff_eq!(rt.olr(288.0), grey_rt.olr(288.0), epsilon = 1e-9);
}
#[test]
fn correlated_k_is_monotonic_in_path() {
let ck = CorrelatedKBand::new(1.0, vec![0.02, 0.1, 0.5], vec![0.5, 0.3, 0.2]).unwrap();
let thin = CorrelatedKRt::new(vec![ck.clone()], 250.0, 1.0).unwrap();
let thick = CorrelatedKRt::new(vec![ck], 250.0, 50.0).unwrap();
assert!(thick.olr(288.0) < thin.olr(288.0));
}
#[test]
fn weights_must_sum_to_one() {
let b = Band::new(0.4, 0.1, 1.0).unwrap();
let r = MultiBandRadiativeTransfer::new(vec![b], 250.0);
assert!(r.is_err());
}
}