#![forbid(unsafe_code)]
mod coupling;
mod error;
mod womersley;
pub use coupling::{CfdCoupling, Windkessel, couple};
pub use error::HemodynamicsError;
pub use womersley::{
bessel_j0, bessel_j1, womersley_complex_velocity, womersley_factor,
womersley_flow_rate_analytic, womersley_flow_rate_numeric, womersley_number,
womersley_velocity_profile,
};
#[must_use]
pub fn tube_law_beta(e: f64, h: f64, a0: f64) -> f64 {
assert!(a0 > 0.0, "A0 must be > 0");
assert!(e >= 0.0, "E must be >= 0");
assert!(h >= 0.0, "h must be >= 0");
(std::f64::consts::PI * e * h).sqrt() / (2.0 * a0.sqrt())
}
#[derive(Debug, Clone)]
pub struct Vessel {
pub area: f64,
pub flow: f64,
pub area0: f64,
pub beta: f64,
}
impl Vessel {
pub fn new(area: f64, flow: f64, area0: f64, beta: f64) -> Result<Self, HemodynamicsError> {
if area <= 0.0 || area0 <= 0.0 {
return Err(HemodynamicsError::InvalidVessel(
"area and area0 must be > 0".into(),
));
}
if !beta.is_finite() {
return Err(HemodynamicsError::InvalidVessel("non-finite beta".into()));
}
Ok(Self {
area,
flow,
area0,
beta,
})
}
#[must_use]
pub fn pressure(&self) -> f64 {
self.beta * (self.area.sqrt() - self.area0.sqrt())
}
#[must_use]
pub fn wave_speed(&self, rho: f64) -> f64 {
(self.beta * self.area0.sqrt() / (2.0 * rho * self.area.sqrt())).sqrt()
}
}
#[must_use]
pub fn womersley_velocity(r: f64, r0: f64, omega: f64, nu: f64) -> f64 {
assert!(r0 > 0.0, "r0 must be > 0");
assert!(nu > 0.0, "nu must be > 0");
assert!(omega >= 0.0, "omega must be >= 0");
assert!((0.0..=r0).contains(&r), "r must be in [0, r0]");
let alpha = r0 * (omega / nu).sqrt();
let parabolic = 2.0 * (1.0 - (r / r0).powi(2));
let flatten = 0.5 + 0.5 / (1.0 + alpha / 3.0);
parabolic * flatten
}
#[must_use]
pub fn casson_viscosity(mu_inf: f64, tau_y: f64, gamma_dot: f64) -> f64 {
assert!(mu_inf > 0.0, "mu_inf must be > 0");
assert!(tau_y >= 0.0, "tau_y must be >= 0");
assert!(gamma_dot >= 0.0, "gamma_dot must be >= 0");
if gamma_dot == 0.0 {
return mu_inf;
}
let sq = mu_inf.sqrt() + (tau_y / gamma_dot.sqrt());
sq * sq
}
#[derive(Debug, Clone)]
pub struct Network {
pub vessels: Vec<Vessel>,
pub rho: f64,
pub friction: f64,
}
impl Network {
pub fn new(vessel: Vessel, rho: f64, friction: f64) -> Result<Self, HemodynamicsError> {
if rho <= 0.0 {
return Err(HemodynamicsError::InvalidNetwork("rho must be > 0".into()));
}
if friction <= 0.0 {
return Err(HemodynamicsError::InvalidNetwork(
"friction must be > 0".into(),
));
}
Ok(Self {
vessels: vec![vessel],
rho,
friction,
})
}
fn flow_at(&self, j: isize) -> f64 {
let n = self.vessels.len() as isize;
if j < 0 {
self.vessels[0].flow
} else if j >= n {
-self.vessels[(n - 1) as usize].flow
} else {
self.vessels[j as usize].flow
}
}
fn pressure_at(&self, j: isize) -> f64 {
let n = self.vessels.len() as isize;
self.vessels[j.clamp(0, n - 1) as usize].pressure()
}
pub fn rhs(&self, i: usize, out: &mut [f64; 2]) {
let v = &self.vessels[i];
let ii = i as isize;
let dq_dx = (self.flow_at(ii + 1) - self.flow_at(ii - 1)) / 2.0;
let dp_dx = (self.pressure_at(ii + 1) - self.pressure_at(ii - 1)) / 2.0;
out[0] = -dq_dx;
out[1] = -(v.area / self.rho) * dp_dx - self.friction * v.flow / v.area;
}
pub fn step(&mut self, dt: f64) {
let n = self.vessels.len();
let old = self.vessels.clone();
let mut next = old.clone();
for i in 0..n {
let ii = i as isize;
let v = &old[i];
let dq_dx = (self.flow_at(ii + 1) - self.flow_at(ii - 1)) / 2.0;
let dp_dx = (self.pressure_at(ii + 1) - self.pressure_at(ii - 1)) / 2.0;
let a_left = old[(ii - 1).max(0) as usize].area;
let a_right = old[(ii + 1).min(n as isize - 1) as usize].area;
let q_avg = 0.5 * (self.flow_at(ii - 1) + self.flow_at(ii + 1));
next[i].area = (0.5 * (a_left + a_right) - dt * dq_dx).max(1e-6);
let pressure_force = -(v.area / self.rho) * dp_dx;
next[i].flow = (q_avg + dt * pressure_force) / (1.0 + dt * self.friction / v.area);
}
self.vessels = next;
}
}
#[cfg(test)]
mod tests {
use super::*;
use approx::assert_abs_diff_eq;
#[test]
fn vessel_pressure_zero_at_reference() {
let beta = tube_law_beta(1.0e5, 0.1, 1.0);
let v = Vessel::new(1.0, 0.0, 1.0, beta).unwrap();
assert_abs_diff_eq!(v.pressure(), 0.0, epsilon = 1e-12);
}
#[test]
fn wave_speed_increases_with_stiffness() {
let soft = Vessel::new(1.0, 0.0, 1.0, tube_law_beta(1.0e4, 0.1, 1.0)).unwrap();
let stiff = Vessel::new(1.0, 0.0, 1.0, tube_law_beta(1.0e6, 0.1, 1.0)).unwrap();
assert!(stiff.wave_speed(1.06) > soft.wave_speed(1.06));
}
#[test]
fn womersley_parabolic_at_centerline() {
let u = womersley_velocity(0.0, 1.0, 1e-4, 0.04);
assert!(u > 1.0);
}
#[test]
fn casson_reduces_under_shear() {
let mu = casson_viscosity(0.04, 0.1, 100.0);
assert!(mu >= 0.04);
assert_abs_diff_eq!(casson_viscosity(0.04, 0.0, 100.0), 0.04, epsilon = 1e-9);
}
#[test]
fn network_step_stays_finite() {
let beta = tube_law_beta(1.0e5, 0.1, 1.0);
let v = Vessel::new(1.0, 1.0, 1.0, beta).unwrap();
let mut net = Network::new(v, 1.06, 8.0).unwrap();
for _ in 0..50 {
net.step(0.001);
}
assert!(net.vessels[0].area.is_finite());
assert!(net.vessels[0].flow.is_finite());
}
}