Struct FopdtModel 

pub struct FopdtModel<T> { /* private fields */ }

First-Order Plus Dead Time (FOPDT) process model.

Models a process as:

G(s) = K · e^(-Ls) / (τs + 1)

where K is the static gain, τ is the time constant, and L is the dead time (transport delay).

Example

use numeris::control::FopdtModel;

let model = FopdtModel::new(2.5_f64, 3.0, 0.5).unwrap();
assert_eq!(model.gain(), 2.5);
assert_eq!(model.tau(), 3.0);
assert_eq!(model.delay(), 0.5);

Implementations

impl<T: FloatScalar> FopdtModel<T>

pub fn new(gain: T, tau: T, delay: T) -> Result<Self, ControlError>

Create a new FOPDT model.

Parameters

• gain: static process gain K (non-zero, finite)
• tau: time constant τ (positive, finite)
• delay: dead time L (non-negative, finite)

Errors

Returns ControlError::InvalidFrequency if parameters are out of range.

pub fn gain(&self) -> T

Static process gain K.

pub fn tau(&self) -> T

Time constant τ.

pub fn delay(&self) -> T

Dead time (transport delay) L.

pub fn ziegler_nichols(&self) -> PidGains<T>

Ziegler-Nichols open-loop tuning (reaction curve method).

Based on the process reaction curve (step response). Gives aggressive tuning with ~25% overshoot.

Panics

Panics if L == 0 (Ziegler-Nichols requires non-zero dead time).

Example

use numeris::control::FopdtModel;

let model = FopdtModel::new(1.0_f64, 1.0, 0.2).unwrap();
let gains = model.ziegler_nichols();
// Kp = 1.2·τ/(K·L), Ti = 2L, Td = L/2
assert!((gains.kp - 6.0).abs() < 1e-10);

pub fn cohen_coon(&self) -> PidGains<T>

Cohen-Coon tuning rule.

Better than Ziegler-Nichols for processes with large dead time (L/τ > 0.5). Targets quarter-decay ratio.

Panics

Panics if L == 0.

Example

use numeris::control::FopdtModel;

let model = FopdtModel::new(1.0_f64, 1.0, 0.5).unwrap();
let gains = model.cohen_coon();
assert!(gains.kp > 0.0);
assert!(gains.ki > 0.0);
assert!(gains.kd > 0.0);

pub fn simc(&self, tau_c: T) -> PidGains<T>

SIMC (Skogestad Internal Model Control) tuning rule.

Provides a good balance between performance and robustness. The tau_c parameter controls the closed-loop time constant: larger values give more conservative (robust) tuning.

A common starting point is tau_c = L (aggressive) or tau_c = τ (conservative).

Parameters

• tau_c: desired closed-loop time constant (positive)

Panics

Panics if tau_c <= 0.

Example

use numeris::control::FopdtModel;

let model = FopdtModel::new(1.0_f64, 2.0, 0.3).unwrap();
let gains = model.simc(0.3); // tau_c = L (aggressive)
assert!(gains.kp > 0.0);

Trait Implementations

impl<T: Clone> Clone for FopdtModel<T>

fn clone(&self) -> FopdtModel<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for FopdtModel<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Copy> Copy for FopdtModel<T>