232 lines
6.6 KiB
Rust
232 lines
6.6 KiB
Rust
//! Kelvin-Maxwell viscoelastic material model.
|
||
//!
|
||
//! This is the standard viscoelastic material model used by LS-DYNA
|
||
//! (MAT_KELVIN-MAXWELL_VISCOELASTIC, MAT_076).
|
||
|
||
use crate::viscoelastic::prony::PronyCoefficients;
|
||
use serde::{Deserialize, Serialize};
|
||
|
||
/// Kelvin-Maxwell viscoelastic material for LS-DYNA.
|
||
///
|
||
/// This represents a first-order Kelvin-Maxwell model with:
|
||
/// - Bulk modulus (K) for volumetric response
|
||
/// - Long-term shear modulus (G0)
|
||
/// - Short-term shear modulus (Gi)
|
||
/// - Decay constant (βi)
|
||
///
|
||
/// The shear relaxation function is:
|
||
/// G(t) = G0 + Gi * exp(-βi * t)
|
||
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
|
||
pub struct KelvinMaxwell {
|
||
/// Density (RO) in kg/m³
|
||
pub density: f64,
|
||
/// Bulk modulus (K) in Pa
|
||
pub bulk_modulus: f64,
|
||
/// Long-term shear modulus (G0) in Pa
|
||
pub g0: f64,
|
||
/// Short-term shear modulus (GI) in Pa
|
||
pub gi: f64,
|
||
/// Decay constant (BETAI) in 1/s
|
||
pub beta_i: f64,
|
||
}
|
||
|
||
impl KelvinMaxwell {
|
||
/// Create a new Kelvin-Maxwell material.
|
||
///
|
||
/// # Arguments
|
||
/// * `density` - Density in kg/m³
|
||
/// * `bulk_modulus` - Bulk modulus (K) in Pa
|
||
/// * `g0` - Long-term shear modulus in Pa
|
||
/// * `gi` - Short-term shear modulus in Pa
|
||
/// * `beta_i` - Decay constant in 1/s
|
||
pub fn new(density: f64, bulk_modulus: f64, g0: f64, gi: f64, beta_i: f64) -> Self {
|
||
Self {
|
||
density,
|
||
bulk_modulus,
|
||
g0,
|
||
gi,
|
||
beta_i,
|
||
}
|
||
}
|
||
|
||
/// Create from Prony series coefficients.
|
||
///
|
||
/// # Arguments
|
||
/// * `prony` - Prony series coefficients
|
||
/// * `density` - Material density in kg/m³
|
||
/// * `bulk_modulus` - Bulk modulus in Pa (or computed from Poisson's ratio)
|
||
pub fn from_prony(prony: &PronyCoefficients, density: f64, bulk_modulus: f64) -> Self {
|
||
Self {
|
||
density,
|
||
bulk_modulus,
|
||
g0: prony.ginf,
|
||
gi: prony.g1,
|
||
beta_i: 1.0 / prony.tau,
|
||
}
|
||
}
|
||
|
||
/// Create from Prony coefficients with Poisson's ratio.
|
||
///
|
||
/// The bulk modulus is calculated assuming the instantaneous response.
|
||
pub fn from_prony_with_poisson(prony: &PronyCoefficients, density: f64, nu: f64) -> Self {
|
||
// G_instantaneous = G∞ + G1
|
||
let g_inst = prony.g0();
|
||
|
||
// E = 2G(1 + ν)
|
||
let e = 2.0 * g_inst * (1.0 + nu);
|
||
|
||
// K = E / (3(1 - 2ν))
|
||
let k = e / (3.0 * (1.0 - 2.0 * nu));
|
||
|
||
Self::from_prony(prony, density, k)
|
||
}
|
||
|
||
/// Convert to Prony series coefficients.
|
||
pub fn to_prony(&self) -> PronyCoefficients {
|
||
PronyCoefficients {
|
||
ginf: self.g0,
|
||
g1: self.gi,
|
||
tau: 1.0 / self.beta_i,
|
||
}
|
||
}
|
||
|
||
/// Calculate the instantaneous shear modulus: G_inst = G0 + Gi
|
||
pub fn g_instantaneous(&self) -> f64 {
|
||
self.g0 + self.gi
|
||
}
|
||
|
||
/// Calculate shear modulus at time t.
|
||
pub fn g_at_time(&self, t: f64) -> f64 {
|
||
self.g0 + self.gi * (-self.beta_i * t).exp()
|
||
}
|
||
|
||
/// Calculate relaxation time τ = 1/β.
|
||
pub fn relaxation_time(&self) -> f64 {
|
||
1.0 / self.beta_i
|
||
}
|
||
|
||
/// Calculate complex shear modulus at angular frequency ω.
|
||
pub fn complex_modulus(&self, omega: f64) -> (f64, f64) {
|
||
self.to_prony().complex_modulus(omega)
|
||
}
|
||
|
||
/// Estimate Poisson's ratio from bulk and shear moduli.
|
||
///
|
||
/// Uses the instantaneous shear modulus.
|
||
pub fn poissons_ratio(&self) -> f64 {
|
||
let g = self.g_instantaneous();
|
||
let k = self.bulk_modulus;
|
||
(3.0 * k - 2.0 * g) / (6.0 * k + 2.0 * g)
|
||
}
|
||
|
||
/// Calculate Young's modulus from bulk and shear moduli.
|
||
pub fn youngs_modulus(&self) -> f64 {
|
||
let g = self.g_instantaneous();
|
||
let k = self.bulk_modulus;
|
||
9.0 * k * g / (3.0 * k + g)
|
||
}
|
||
}
|
||
|
||
impl Default for KelvinMaxwell {
|
||
fn default() -> Self {
|
||
// Typical brain tissue values
|
||
Self {
|
||
density: 1040.0,
|
||
bulk_modulus: 2.19e9, // Nearly incompressible
|
||
g0: 1000.0,
|
||
gi: 2000.0,
|
||
beta_i: 100.0,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// LS-DYNA material card representation.
|
||
///
|
||
/// This generates the format needed for *MAT_KELVIN-MAXWELL_VISCOELASTIC.
|
||
impl KelvinMaxwell {
|
||
/// Generate LS-DYNA material card lines.
|
||
///
|
||
/// Returns the card data as would appear in a .k file.
|
||
pub fn to_lsdyna_card(&self, mid: u32) -> String {
|
||
// Card 1: MID, RO, K, N
|
||
// Card 2: GI, BETAI (repeated for each term)
|
||
|
||
let n = 1; // Number of terms (we only support 1-term)
|
||
|
||
format!(
|
||
"*MAT_KELVIN-MAXWELL_VISCOELASTIC\n\
|
||
${:>9},{:>9},{:>9},{:>9},{:>9},{:>9},{:>9},{:>9}\n\
|
||
{:>10},{:>10.4E},{:>10.4E},{:>10}\n\
|
||
{:>10.4E},{:>10.4E}\n\
|
||
{:>10.4E},{:>10.4E}",
|
||
"MID",
|
||
"RO",
|
||
"BULK",
|
||
"G0",
|
||
"",
|
||
"",
|
||
"",
|
||
"",
|
||
mid,
|
||
self.density,
|
||
self.bulk_modulus,
|
||
self.g0,
|
||
self.gi,
|
||
self.beta_i,
|
||
0.0,
|
||
0.0 // Extra terms (not used)
|
||
)
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn test_kelvin_maxwell_creation() {
|
||
let mat = KelvinMaxwell::new(1040.0, 2.19e9, 1000.0, 2000.0, 100.0);
|
||
assert_eq!(mat.density, 1040.0);
|
||
assert_eq!(mat.g0, 1000.0);
|
||
assert_eq!(mat.gi, 2000.0);
|
||
assert_eq!(mat.beta_i, 100.0);
|
||
}
|
||
|
||
#[test]
|
||
fn test_from_prony() {
|
||
let prony = PronyCoefficients::new(1000.0, 2000.0, 0.01);
|
||
let mat = KelvinMaxwell::from_prony(&prony, 1040.0, 2.19e9);
|
||
|
||
assert_eq!(mat.g0, prony.ginf);
|
||
assert_eq!(mat.gi, prony.g1);
|
||
assert!((mat.beta_i - 100.0).abs() < 1e-10); // 1/0.01 = 100
|
||
}
|
||
|
||
#[test]
|
||
fn test_to_prony() {
|
||
let mat = KelvinMaxwell::new(1040.0, 2.19e9, 1000.0, 2000.0, 100.0);
|
||
let prony = mat.to_prony();
|
||
|
||
assert_eq!(prony.ginf, 1000.0);
|
||
assert_eq!(prony.g1, 2000.0);
|
||
assert!((prony.tau - 0.01).abs() < 1e-10);
|
||
}
|
||
|
||
#[test]
|
||
fn test_g_at_time() {
|
||
let mat = KelvinMaxwell::new(1040.0, 2.19e9, 1000.0, 2000.0, 100.0);
|
||
|
||
// At t=0, G = G0 + Gi = 3000
|
||
assert!((mat.g_at_time(0.0) - 3000.0).abs() < 1e-10);
|
||
|
||
// At t->∞, G = G0 = 1000
|
||
assert!((mat.g_at_time(1.0) - 1000.0).abs() < 1.0);
|
||
}
|
||
|
||
#[test]
|
||
fn test_instantaneous_modulus() {
|
||
let mat = KelvinMaxwell::new(1040.0, 2.19e9, 1000.0, 2000.0, 100.0);
|
||
assert_eq!(mat.g_instantaneous(), 3000.0);
|
||
}
|
||
}
|