#![forbid(unsafe_code)]
mod error;
pub use error::KineticsError;
mod arrhenius;
mod constants;
mod coverage;
mod coverage_dependent;
mod eley_rideal;
mod problem;
pub use arrhenius::ArrheniusRate;
pub use constants::R_GAS;
pub use coverage::{langmuir_hinshelwood_coverages, multi_site_langmuir_hinshelwood_coverages};
pub use coverage_dependent::CoverageDependentArrheniusRate;
pub use eley_rideal::EleyRideal;
pub use problem::KineticsProblem;
#[cfg(test)]
mod tests {
use super::*;
use approx::assert_abs_diff_eq;
#[test]
fn arrhenius_rises_with_temperature() {
let r = ArrheniusRate::new(1.0e13, 80_000.0).unwrap();
let k_low = r.rate_constant(600.0);
let k_high = r.rate_constant(900.0);
assert!(k_high > k_low);
assert!(k_low.is_finite() && k_high.is_finite());
}
#[test]
fn arrhenius_rejects_invalid() {
assert!(ArrheniusRate::new(0.0, 1.0).is_err());
assert!(ArrheniusRate::new(1.0, -1.0).is_err());
}
#[test]
fn langmuir_hinshelwood_sums_to_one() {
let theta = langmuir_hinshelwood_coverages(&[2.0, 3.0], &[1.0, 1.0]).unwrap();
let sum: f64 = theta.iter().sum();
assert!(sum <= 1.0 + 1e-12);
assert_abs_diff_eq!(sum, 5.0 / 6.0, epsilon = 1e-12);
assert!(theta[1] > theta[0]);
}
#[test]
fn langmuir_hinshelwood_empty_sites() {
let theta = langmuir_hinshelwood_coverages(&[5.0], &[0.0]).unwrap();
assert_abs_diff_eq!(theta[0], 0.0, epsilon = 1e-12);
}
#[test]
fn kinetics_problem_resolves_constants() {
let prob = KineticsProblem::new(vec![
ArrheniusRate::new(1.0e13, 80_000.0).unwrap(),
ArrheniusRate::new(1.0e10, 40_000.0).unwrap(),
])
.unwrap();
let ks = prob.rate_constants(800.0);
assert_eq!(ks.len(), 2);
assert!(ks[0] > 0.0 && ks[1] > 0.0);
assert!(KineticsProblem::new(vec![]).is_err());
}
#[test]
fn multi_site_reduces_to_single_site() {
let ks = [2.0, 3.0];
let ps = [1.0, 1.0];
let single = langmuir_hinshelwood_coverages(&ks, &ps).unwrap();
let multi = multi_site_langmuir_hinshelwood_coverages(&ks, &ps, &[0, 0]).unwrap();
for (s, m) in single.iter().zip(multi.iter()) {
assert_abs_diff_eq!(s, m, epsilon = 1e-12);
}
}
#[test]
fn multi_site_normalizes_independently_per_site_type() {
let theta = multi_site_langmuir_hinshelwood_coverages(
&[2.0, 3.0, 5.0],
&[1.0, 1.0, 1.0],
&[0, 0, 1],
)
.unwrap();
assert_abs_diff_eq!(theta[0], 2.0 / 6.0, epsilon = 1e-12);
assert_abs_diff_eq!(theta[1], 3.0 / 6.0, epsilon = 1e-12);
assert_abs_diff_eq!(theta[2], 5.0 / 6.0, epsilon = 1e-12);
let site0_sum = theta[0] + theta[1];
assert!(site0_sum <= 1.0 + 1e-12);
assert!(theta[2] <= 1.0 + 1e-12);
}
#[test]
fn multi_site_rejects_mismatched_lengths_and_bad_values() {
assert!(multi_site_langmuir_hinshelwood_coverages(&[1.0], &[1.0, 2.0], &[0, 0]).is_err());
assert!(multi_site_langmuir_hinshelwood_coverages(&[-1.0], &[1.0], &[0]).is_err());
assert!(multi_site_langmuir_hinshelwood_coverages(&[1.0], &[-1.0], &[0]).is_err());
}
#[test]
fn eley_rideal_zero_when_either_factor_zero() {
let er = EleyRideal::new(3.0).unwrap();
assert_eq!(er.rate(0.0, 5.0), 0.0);
assert_eq!(er.rate(0.5, 0.0), 0.0);
assert_eq!(er.rate(0.0, 0.0), 0.0);
}
#[test]
fn eley_rideal_linear_in_gas_phase_concentration() {
let er = EleyRideal::new(2.0).unwrap();
let r1 = er.rate(0.4, 1.0);
let r2 = er.rate(0.4, 3.0);
assert_abs_diff_eq!(r2, 3.0 * r1, epsilon = 1e-12);
assert_abs_diff_eq!(r1, 2.0 * 0.4 * 1.0, epsilon = 1e-12);
}
#[test]
fn eley_rideal_rejects_invalid_rate() {
assert!(EleyRideal::new(-1.0).is_err());
assert!(EleyRideal::new(f64::NAN).is_err());
}
#[test]
fn eley_rideal_into_rate_law_matches_direct_rate() {
use tpt_sci_reaction_network::ReactionNetwork;
let er = EleyRideal::new(1.5).unwrap();
let mut net = ReactionNetwork::new();
let theta_a = net.species("theta_A");
let gas_b = net.species("B_gas");
let c = net.species("C");
net.reaction(
&[(theta_a, 1.0), (gas_b, 1.0)],
&[(c, 1.0)],
er.into_rate_law(0, 1),
);
let sys = net.build().unwrap();
let y = [0.3, 2.0, 0.0];
let rates = sys.reaction_rates(&y);
assert_abs_diff_eq!(rates[0], er.rate(0.3, 2.0), epsilon = 1e-12);
}
#[test]
fn coverage_dependent_matches_plain_arrhenius_when_alpha_zero() {
let plain = ArrheniusRate::new(1.0e13, 80_000.0).unwrap();
let cov = CoverageDependentArrheniusRate::new(1.0e13, 80_000.0, 0.0).unwrap();
for theta in [0.0, 0.3, 1.0] {
assert_abs_diff_eq!(
cov.rate_constant(800.0, theta),
plain.rate_constant(800.0),
epsilon = 1e-6
);
}
}
#[test]
fn coverage_dependent_rate_constant_monotonic_in_theta() {
let repulsive = CoverageDependentArrheniusRate::new(1.0e13, 80_000.0, 20_000.0).unwrap();
let k_low = repulsive.rate_constant(800.0, 0.0);
let k_high = repulsive.rate_constant(800.0, 1.0);
assert!(k_high < k_low);
let promoting = CoverageDependentArrheniusRate::new(1.0e13, 80_000.0, -20_000.0).unwrap();
let k_low = promoting.rate_constant(800.0, 0.0);
let k_high = promoting.rate_constant(800.0, 1.0);
assert!(k_high > k_low);
}
#[test]
fn coverage_dependent_rejects_invalid() {
assert!(CoverageDependentArrheniusRate::new(0.0, 1.0, 0.0).is_err());
assert!(CoverageDependentArrheniusRate::new(1.0, -1.0, 0.0).is_err());
assert!(CoverageDependentArrheniusRate::new(1.0, 1.0, f64::NAN).is_err());
}
}