pydynamicestimator.devices.pss

Attributes

PSS_REGISTRY

Classes

`PSS`	Abstract base class for Power System Stabilizer models (pluggable strategy).
`PSSKundur`	Single-input (speed) power system stabilizer: gain, washout, and two

Module Contents

class pydynamicestimator.devices.pss.PSS[source]

Bases: abc.ABC

Abstract base class for Power System Stabilizer models (pluggable strategy).

A PSS adds a supplementary stabilizing signal ‘Vs’ to the AVR’s voltage summing junction (the regulator error becomes Vf_ref - Vt + Vs). Unlike the AVR and governor, whose outputs couple directly into the machine, the PSS couples into another strategy (the AVR). This is kept host-mediated: the PSS declares ‘Vs’ as its coupling variable, the host exposes it via Synchronous.pss_signal (which returns 0 when no PSS is present), and each AVR reads host.pss_signal(dae) at its summing junction. The PSS never references the AVR directly – the host is the wiring hub.

‘Vs’ may be a differential state or, more typically, a device-private algebraic (a washout + lead-lag chain has direct feedthrough on the input, so its output is algebraic). Symmetric to AVR and Governor: the PSS declares what states / private algebraics / parameters it needs and the host registers them on itself. It reads the machine’s absolute per-unit speed via host.omega (1.0 at synchronism) and forms the deviation from nominal (dae.omega_net = 1 p.u.) itself.

There is NO default PSS: a machine without one supplies no signal to its AVR.

abstract states() → List[str][source]

Return ordered list of differential-state names.

Return type:: List[str]

algebs() → List[str][source]

Return ordered list of device-private algebraic variable names.

A washout + lead-lag PSS returns [‘Vs’] here (its output has direct feedthrough on the speed deviation, hence is algebraic) and writes the defining residual 0 = -Vs + <expr> into dae.g in fgcall().

Return type:: List[str]

algebs_units() → Dict[str, str][source]

Units for each private algebraic (mirrors units()).

Return type:: Dict[str, str]

algebs_noise() → Dict[str, float][source]

Relative process-noise weight for each private algebraic.

Return type:: Dict[str, float]

algebs_x0() → Dict[str, float][source]

Initial guess for each private algebraic (Newton guess in finit).

Return type:: Dict[str, float]

abstract units() → List[str][source]

Return units for each state, same length as states().

Return type:: List[str]

abstract params() → Dict[str, float][source]

Return dict of parameter names -> default values.

Return type:: Dict[str, float]

abstract states_noise() → Dict[str, float][source]

Return noise specification for each state.

Return type:: Dict[str, float]

abstract states_init_error() → Dict[str, float][source]

Return initial error for each state.

Return type:: Dict[str, float]

abstract x0() → Dict[str, float][source]

Return default initial guess for each state.

Return type:: Dict[str, float]

abstract descriptions() → Dict[str, str][source]

Return descriptions for states and params.

Return type:: Dict[str, str]

setpoints() → Dict[str, float][source]

Return setpoint names -> defaults. A speed-input PSS has none.

Return type:: Dict[str, float]

abstract fgcall(host, dae: pydynamicestimator.system.Dae) → None[source]

Write the PSS’s differential equations into dae.f and, if it declares private algebraics (e.g. an algebraic ‘Vs’), their defining residuals into dae.g.

Parameters:

host – The Synchronous machine instance. Access state/algebraic indices via host.vw, host.Vs, etc., parameters via host.K_stab, host.Tw, …, and the absolute per-unit speed via host.omega (form the deviation as host.omega - dae.omega_net).
dae (pydynamicestimator.system.Dae) – The DAE system object.

Return type:

None

class pydynamicestimator.devices.pss.PSSKundur[source]

Bases: PSS

Single-input (speed) power system stabilizer: gain, washout, and two lead-lag stages, as in Kundur (Power System Stability and Control, 1994).

Vs(s) = K_stab * [ s*Tw / (1 + s*Tw) ] # washout (DC block)

[ (1 + s*T1) / (1 + s*T2) ] # lead-lag 1

[ (1 + s*T3) / (1 + s*T4) ] # lead-lag 2

domega # input: SPEED DEVIATION

IMPORTANT: host.omega is the absolute per-unit rotor speed (= 1.0 at synchronism), NOT the deviation. The PSS input is the deviation from nominal, domega = omega - omega_net with omega_net = 1 p.u. (dae.omega_net); it is formed explicitly here so the model does not rely on the washout to subtract the DC offset.

The output ‘Vs’ is summed into the AVR voltage error. Each block contributes one lag-pole state; the two lead-lags (and the washout’s high-pass) give the output a direct feedthrough on domega, so ‘Vs’ is declared as a private ALGEBRAIC variable (read by the AVR via Synchronous.pss_signal -> var_sym('Vs')). This is the PSS-side counterpart of the algebraic-Efd lead-lag exciter and the algebraic-pm droop governor.

Realization (vw, vl1, vl2 are the three lag-pole states):

domega = omega - omega_net ; speed deviation (omega_net = 1 p.u.) u = K_stab * domega vw_dot = (u - vw) / Tw ; washout output w = u - vw vl1_dot = (w - vl1) / T2 ; lead-lag 1 out y1 = vl1(1-T1/T2) + (T1/T2) w vl2_dot = (y1 - vl2) / T4 0 = -Vs + vl2(1-T3/T4) + (T3/T4) y1

At equilibrium omega = omega_net so domega = 0 and vw = vl1 = vl2 = Vs = 0: the washout blocks DC, hence the PSS does not shift the operating point.

states() → List[str][source]