Struct MultiMachineSim 

pub struct MultiMachineSim {
    pub machines: Vec<MachineParams>,
    pub y_red: Vec<Vec<Complex64>>,
    pub use_coi: bool,
}

Multi-machine stability model (network-reduced, COI frame).

Fields

machines: Vec<MachineParams>

y_red: Vec<Vec<Complex64>>

Generator admittance matrix (n×n dense, complex)

use_coi: bool

Use COI frame for integration

Implementations

impl MultiMachineSim

pub fn new(machines: Vec<MachineParams>, y_red: Vec<Vec<Complex64>>) -> Self

Construct from machine parameters and a pre-built reduced admittance matrix.

y_red_flat is row-major: y_red[i][j] = G_ij + j·B_ij [p.u.].

pub fn two_machine(m1: MachineParams, m2: MachineParams, x_line: f64) -> Self

Build a two-machine system connected via a transfer admittance.

Y_12 = −j / (xd1’ + xline + xd2’) (pure imaginary for lossless line).

pub fn ring_network(machines: Vec<MachineParams>, x_line: f64) -> Self

Build an n-machine ring network (each machine connected to next via x_line).

pub fn electrical_power(&self, states: &[MachineState]) -> Vec<f64>

Compute electrical power output for each machine [p.u.].

P_e_i = Σ_j E_i·E_j·[G_ij·cos(δ_i−δ_j) + B_ij·sin(δ_i−δ_j)]

pub fn coi(&self, states: &[MachineState]) -> (f64, f64)

Compute the COI angle and speed.

pub fn derivatives(&self, states: &[MachineState]) -> Vec<(f64, f64)>

Compute swing-equation derivatives d(δ, ω)/dt for all machines.

In COI frame: the COI acceleration is subtracted from each machine.

pub fn step(&self, states: &[MachineState], dt: f64) -> Vec<MachineState>

Perform one RK4 integration step.

pub fn run( &self, initial: Vec<MachineState>, dt: f64, t_end: f64, fault_fn: Option<&dyn Fn(f64) -> Option<Vec<Vec<Complex64>>>>, ) -> MultiMachineResult

Run a full multi-machine transient simulation.

fault_fn is called at each step to optionally modify the Y_red (e.g., to model a fault being applied/cleared). It receives the current time and returns an optional modified admittance matrix.

pub fn is_transient_stable(result: &MultiMachineResult) -> bool

Check if the system is transiently stable.

Criterion: max(|δ_i − δ_j|) < π rad at all times.

pub fn estimate_cct( &self, initial: &[MachineState], y_red_fault: Vec<Vec<Complex64>>, dt: f64, t_sim: f64, tol: f64, ) -> f64

Estimate critical clearing time (CCT) by bisection.

Applies a fault (Y_red_fault) starting at t=0, clears at t=t_clear. Returns CCT in seconds (within tol precision).

pub fn kinetic_energy(&self, states: &[MachineState]) -> f64

Compute the kinetic energy (relative to COI) stored in generator rotors [p.u.·s].