use std::collections::BTreeMap;
use general_mna::MnaSystem;
use general_spice_core::ast::Statement;
use pwl_devices::IdealDiode;
use crate::{
classify_segments, fold_and_solve, is_ringing, DaeError, OperatingPoint, Scheme, Segment,
};
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum TimeStep {
Fixed(f64),
Adaptive(AdaptiveConfig),
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct AdaptiveConfig {
pub dt_init: f64,
pub dt_min: f64,
pub dt_max: f64,
pub reltol: f64,
pub abstol: f64,
}
impl AdaptiveConfig {
pub fn from_t_final(t_final: f64) -> Self {
let dt_max = t_final / 1000.0;
AdaptiveConfig {
dt_init: dt_max / 100.0,
dt_min: dt_max * 1e-9,
dt_max,
reltol: 1e-3,
abstol: 1e-9,
}
}
}
pub(crate) struct LteAttempt {
pub point: OperatingPoint,
pub used_backward_euler: bool,
pub accept: bool,
pub suggested_dt_next: f64,
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn lte_attempt(
system: &MnaSystem,
statements: &[Statement],
diodes: &BTreeMap<String, IdealDiode>,
x_prev_prev: Option<&[f64]>,
x_prev: &[f64],
dt: f64,
prev_diode_raw_ioff: &BTreeMap<String, f64>,
prev_segments: &Option<Vec<Segment>>,
force_backward_euler: bool,
config: &AdaptiveConfig,
t_start: f64,
extra_values: &BTreeMap<String, f64>,
extra_values_prev: &BTreeMap<String, f64>,
) -> Result<LteAttempt, DaeError> {
let t = t_start + dt;
if force_backward_euler {
let point = fold_and_solve(
system,
statements,
diodes,
&Scheme::BackwardEuler { x_prev, dt },
t,
extra_values,
extra_values_prev,
)?;
let suggested_dt_next = (dt * 0.5).clamp(config.dt_min, config.dt_max);
return Ok(LteAttempt {
point,
used_backward_euler: true,
accept: true,
suggested_dt_next,
});
}
let be = fold_and_solve(
system,
statements,
diodes,
&Scheme::BackwardEuler { x_prev, dt },
t,
extra_values,
extra_values_prev,
)?;
let trap = fold_and_solve(
system,
statements,
diodes,
&Scheme::Trapezoidal {
x_prev,
dt,
prev_diode_raw_ioff,
},
t,
extra_values,
extra_values_prev,
)?;
let trial_segments = classify_segments(&trap);
let segments_changed = Some(&trial_segments) != prev_segments.as_ref();
let ringing = x_prev_prev.is_some_and(|xpp| is_ringing(xpp, x_prev, &trap.x));
if segments_changed || ringing {
let suggested_dt_next = (dt * 0.5).clamp(config.dt_min, config.dt_max);
return Ok(LteAttempt {
point: be,
used_backward_euler: true,
accept: true,
suggested_dt_next,
});
}
let err = trap.x.iter().zip(&be.x).fold(0.0_f64, |acc, (&xt, &xb)| {
let scale = config.abstol + config.reltol * xt.abs().max(xb.abs());
acc.max((xt - xb).abs() / scale)
});
let at_floor = dt <= config.dt_min * (1.0 + 1e-9);
if err <= 1.0 || at_floor {
let growth = if err > 1e-12 { (1.0 / err).sqrt() } else { 5.0 };
let suggested_dt_next =
(dt * (growth.clamp(0.2, 5.0)) * 0.9).clamp(config.dt_min, config.dt_max);
Ok(LteAttempt {
point: trap,
used_backward_euler: false,
accept: true,
suggested_dt_next,
})
} else {
let shrink = (1.0 / err).sqrt().clamp(0.1, 0.5);
let suggested_dt_next = (dt * shrink).max(config.dt_min);
Ok(LteAttempt {
point: trap,
used_backward_euler: false,
accept: false,
suggested_dt_next,
})
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn adaptive_step(
system: &MnaSystem,
statements: &[Statement],
diodes: &BTreeMap<String, IdealDiode>,
x_prev_prev: Option<&[f64]>,
x_prev: &[f64],
dt_trial: f64,
prev_diode_raw_ioff: &BTreeMap<String, f64>,
prev_segments: &Option<Vec<Segment>>,
force_backward_euler: bool,
config: &AdaptiveConfig,
t_start: f64,
) -> Result<(OperatingPoint, bool, f64, f64), DaeError> {
let mut dt = dt_trial.clamp(config.dt_min, config.dt_max);
let empty = BTreeMap::new();
loop {
let attempt = lte_attempt(
system,
statements,
diodes,
x_prev_prev,
x_prev,
dt,
prev_diode_raw_ioff,
prev_segments,
force_backward_euler,
config,
t_start,
&empty,
&empty,
)?;
if attempt.accept {
return Ok((
attempt.point,
attempt.used_backward_euler,
dt,
attempt.suggested_dt_next,
));
}
dt = attempt.suggested_dt_next;
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn from_t_final_orders_the_three_step_sizes_sensibly() {
let config = AdaptiveConfig::from_t_final(1e-3);
assert!(config.dt_min < config.dt_init);
assert!(config.dt_init < config.dt_max);
assert_eq!(config.dt_max, 1e-6);
}
}