motulator-export 0.7.0__py3-none-any.whl

motulator_export/__init__.py

@@ -0,0 +1,13 @@
+"""
+Export motulator systems to PLECS and Simulink, and simulate them natively.
+
+The subpackages `plecs` and `simulink` write the models of a system built in
+motulator, and `native` simulates the system in C. All of them run the same C port of
+the control algorithms of motulator.
+
+"""
+
+from motulator_export import native, plecs, simulink
+from motulator_export.plecs._common import StepSignal
+
+__all__ = ["StepSignal", "native", "plecs", "simulink"]

motulator_export/c/README.md

@@ -0,0 +1,60 @@
+# C port
+
+C port of the *motulator* control algorithms and models, run in the C-Script blocks of the PLECS models, in the S-functions of the Simulink models, and in the libraries of the native simulation (`motulator_export.native`).
+The code follows the Python code of *motulator* closely, including the order of the state updates, and each header lists its Python counterparts.
+Optional parameters (`None` in *motulator*) are represented by `NAN`, and their defaults are resolved in the C code, as in *motulator*.
+
+Each class is a type with its functions (e.g., `FluxObserver` with `flux_observer_init`, `flux_observer_compute_output`, and `flux_observer_update`), which the blocks of the classes of the control systems run.
+The measurements, the feedback signals, and the references between the blocks are signal vectors (meas, fbk, and ref), whose layouts are defined in the headers of the control methods (e.g., `MEAS_WIDTH` and `FBK_w_M` in `sm_flux_vector.h`) with their pack and unpack functions.
+The whole-system functions (e.g., `vector_control_system_compute_output`) run the control system in one block; they are used by the reference control systems of the tests.
+Their gate enable (`ControlSystem.set_enable` of *motulator*) selects the standby output of the controllers (e.g., `flux_vector_ctrl_compute_standby_output`) with the measured converter voltage, as in *motulator*; in the blocks of the classes, the block `compute_standby_output` of each controller selects the references.
+
+| File                   | Contents                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `common.c`             | `PIController`, `ComplexPIController`, `SpeedController`, `SpeedObserver`, `CurrentLimiter`, `PowerReferenceLimiter`, `RateLimiter`, `PWM` (MPE or MME overmodulation, double or single update) (with the duty-ratio error model `InverterNonlinearity` of the dead time and the threshold voltage, the current direction given by `np.sign` or `tanh(i/i_0)`), the discretization of the observers (`hold_equivalent` and `matched_pole`), root finding (`brentq`), and utility functions |
+| `gradnet.c`            | GradNet inference (`FluxMap`, `CurrentMap`, and `CurrentMapWithHarmonics`)                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `sm_parameters.c`      | `SynchronousMachinePars` and `SaturatedSynchronousMachinePars` (flux linkage, incremental inductances, and current iteration)                                                                                                                                                                                                                                                                                                                                                              |
+| `sm_control_loci.c`    | `ControlLoci` (MTPA, MTPV, and current-limit loci)                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `sm_flux_vector.c`     | `FluxObserver`, `SpeedFluxObserver`, `ReferenceGenerator`, `FluxTorqueController`, `FluxVectorController`, and `VectorControlSystem` for synchronous machines                                                                                                                                                                                                                                                                                                                              |
+| `sm_machine.c`         | `SynchronousMachine` with `SpatialSaturatedSynchronousMachinePars` and `MechanicalSystem`                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `im_current_vector.c`  | `FluxObserver`, `SpeedFluxObserver`, `CurrentReferenceGenerator`, `CurrentController`, `CurrentVectorController`, and `VectorControlSystem` for induction machines                                                                                                                                                                                                                                                                                                                         |
+| `im_flux_vector.c`     | `FluxTorqueController`, `ReferenceGenerator`, `ObserverBasedVHzController` (including open-loop V/Hz control with `L_M = inf`), and `VHzControlSystem` with the `RateLimiter` of the speed reference for induction machines                                                                                                                                                                                                                                                                |
+| `gfl_current_vector.c` | Grid-following `CurrentVectorController` (`PLL`, `CurrentController`, and the current and power references) and `GridConverterControlSystem`                                                                                                                                                                                                                                                                                                                                               |
+| `gfm_observer.c`       | Disturbance-observer-based grid-forming control (the discrete-time `Observer` and `ObserverBasedGridFormingController`) and `GridConverterControlSystem`                                                                                                                                                                                                                                                                                                                                   |
+| `sim.c`                | Native simulation: `Simulation` (the simulation loop, a single model and control system, the gates enabled) with the RK45 solver of scipy, the computational delay (`Delay`), the PWM models `ZOH` and `CarrierComparison`, `VoltageSourceConverter` with a constant DC-bus voltage or a DC-bus model (`DCBus` or `DiodeBridgeDCBus`), `StepSignal`, and the logs of the results                                                                                                           |
+| `drive.c`              | Native simulation: `Drive` with `SynchronousMachine` (`SynchronousMachinePars` or `SpatialSaturatedSynchronousMachinePars` with a GradNet current map with spatial harmonics) or `InductionMachine` (constant parameters), and `MechanicalSystem`                                                                                                                                                                                                                                          |
+| `grid.c`               | Native simulation: `GridConverterSystem` with `LFilter` or `LCLFilter` and `ThreePhaseSource`                                                                                                                                                                                                                                                                                                                                                                                              |
+| `native_sm.c`          | Native simulation: the library of synchronous machine drives with flux-vector control (`sm_flux_vector.c` and `drive.c`), with its API for Python                                                                                                                                                                                                                                                                                                                                          |
+| `native_im.c`          | Native simulation: the library of induction machine drives with current-vector control or observer-based V/Hz control (`im_current_vector.c`, `im_flux_vector.c`, and `drive.c`)                                                                                                                                                                                                                                                                                                           |
+| `native_gfl.c`         | Native simulation: the library of grid converter systems with grid-following control (`gfl_current_vector.c` and `grid.c`)                                                                                                                                                                                                                                                                                                                                                                 |
+| `native_gfm.c`         | Native simulation: the library of grid converter systems with grid-forming control (`gfm_observer.c` and `grid.c`)                                                                                                                                                                                                                                                                                                                                                                         |
+| `native.c`             | Native simulation: the helpers of the libraries (the limited voltage reference and the settings of the PWM)                                                                                                                                                                                                                                                                                                                                                                                |
+
+## Native simulation
+
+The libraries of the native simulation (`native_<name>.c`) combine the C port of a control system with C models of the system, which `sim.c` simulates as the simulation of *motulator* (`Simulation.simulate`): the control system is run at its sampling instants, the duty ratios pass through the computational delay and the PWM model, and the states are integrated between the sampling and switching instants by a port of the RK45 solver of scipy, taking the same steps.
+A model (`Model` in `sim.h`) and a control system (`ControlSystem`) are interfaces of function pointers, embedded as the first members of the concrete types (e.g., `Drive` in `drive.h`).
+The API functions setting the converter, its DC bus, and its modulator are in `sim.c`, those of the models in `drive.c` and `grid.c`, and those of the control systems in the libraries.
+The states are complex and in the order of *motulator*, and the control system logs the signal groups of *motulator* (`ref` and `fbk`), described by a string of their fields (e.g., `FVC_FIELDS` in `native_sm.c`), so that the Python module fills the time series of the *motulator* objects and post-processes them as *motulator* does.
+A new type of system needs its C model (e.g., a machine in `drive.c`), a library combining the model with the C port of its control system, and a Python module setting the parameters (e.g., `motulator_export/native/_im.py`).
+
+The native simulation takes the same solver steps as *motulator*, so the results agree to the rounding errors: about 1e-12 relative to the signal magnitudes, also with the GradNet models, see `tests/test_native.py`.
+With the carrier comparison (`pwm=True`), a rounding error can change a quantized duty ratio and thereby a switching instant, after which the solutions differ more; with a fine quantization (`CarrierComparison(N=2**24)`), they agree to about 1e-7.
+Similarly, the diode bridge (`DiodeBridgeDCBus`) clamps its inductor current at zero, which makes the step sizes sensitive to the rounding errors (differences of about 1e-7 to 1e-5, depending on the system and the simulated time).
+The closed-loop simulations of *motulator* itself are equally sensitive to the rounding errors.
+
+## Tests
+
+The tests in `tests/` compile the C sources with gcc and compare the results with *motulator* step by step, without PLECS.
+They run in GitHub Actions on every push and weekly against the main branch of *motulator*, to detect changes in *motulator* that must be mirrored here.
+
+## GradNets
+
+Both *motulator* and the C port evaluate the GradNets in double precision, and the incremental inductances are computed from the analytic Jacobian of the flux map in both, so the tests compare the C port with *motulator* using the relative tolerance of 1e-9.
+The sizes of the networks are limited by `GRADNET_MAX_IN_DIM` and `GRADNET_MAX_EMBED_DIM` in `gradnet.h`, which are checked both when a model is written and at the start of the simulation.
+
+## Portability
+
+The C port uses the C99 complex type (`complex.h`) in double precision, mirroring the complex space vectors of *motulator*.
+It compiles with gcc, clang, MinGW-w64 (e.g., for `mex` in MATLAB), and the compiler bundled with PLECS, but not with MSVC, and embedded compilers may lack `complex.h`.
+A conversion to a custom complex type or to single precision is straightforward with the C-port tests, but it is left until a concrete embedded target exists.

motulator_export/c/common.c

@@ -0,0 +1,546 @@
+/*
+ * Common control functions and classes, ported from motulator. See common.h.
+ */
+
+#include "common.h"
+
+/* Utility functions -------------------------------------------------------- */
+
+static double complex abc2complex(const double u[3])
+{
+    return (2.0 / 3.0) * u[0] - (u[1] + u[2]) / 3.0 + I * (u[1] - u[2]) / sqrt(3.0);
+}
+
+static void complex2abc(double complex u, double u_abc[3])
+{
+    u_abc[0] = creal(u);
+    u_abc[1] = 0.5 * (-creal(u) + sqrt(3.0) * cimag(u));
+    u_abc[2] = 0.5 * (-creal(u) - sqrt(3.0) * cimag(u));
+}
+
+static double complex line2complex(const double u[2])
+{
+    return (2.0 * u[0] + u[1]) / 3.0 + I * u[1] / sqrt(3.0);
+}
+
+static double complex complex_from(double re, double im)
+{
+    /* A complex number has the representation of an array of its real and imaginary
+     * parts (C99 6.2.5) */
+    double complex z;
+    ((double *)&z)[0] = re;
+    ((double *)&z)[1] = im;
+    return z;
+}
+
+static double wrap(double theta)
+{
+    /* Limit the angle into the range [-pi, pi), as numpy.mod does */
+    double x = fmod(theta + M_PI, 2.0 * M_PI);
+    if (x < 0.0) {
+        x += 2.0 * M_PI;
+    }
+    return x - M_PI;
+}
+
+static double clip(double value, double min_value, double max_value)
+{
+    return fmax(fmin(value, max_value), min_value);
+}
+
+static double sign(double x)
+{
+    return (x < 0.0) ? -1.0 : ((x > 0.0) ? 1.0 : 0.0);
+}
+
+static double lut_interp(const LUT *lut, double x)
+{
+    int n = lut->n;
+    if (x <= lut->x[0]) {
+        return lut->y[0];
+    }
+    if (x >= lut->x[n - 1]) {
+        return lut->y[n - 1];
+    }
+    /* Binary search for the interval x[k] <= x < x[k + 1] */
+    int lo = 0, hi = n - 1;
+    while (hi - lo > 1) {
+        int mid = (lo + hi) / 2;
+        if (lut->x[mid] <= x) {
+            lo = mid;
+        } else {
+            hi = mid;
+        }
+    }
+    double slope = (lut->y[hi] - lut->y[lo]) / (lut->x[hi] - lut->x[lo]);
+    return slope * (x - lut->x[lo]) + lut->y[lo];
+}
+
+/* Port of scipy/optimize/Zeros/brentq.c with xtol = 2e-12, rtol = 4*eps, and
+ * maxiter = 100 (the defaults of scipy.optimize.brentq). The function values at the
+ * bracket ends must have opposite signs (or be zero). */
+static double brentq(ScalarFunction f, double xa, double xb, void *data)
+{
+    const double xtol = 2e-12;
+    const double rtol = 8.881784197001252e-16;
+    const int iter = 100;
+    double xpre = xa, xcur = xb;
+    double xblk = 0.0, fblk = 0.0, spre = 0.0, scur = 0.0;
+    double fpre = f(xpre, data);
+    double fcur = f(xcur, data);
+
+    if (fpre == 0.0) {
+        return xpre;
+    }
+    if (fcur == 0.0) {
+        return xcur;
+    }
+    if (signbit(fpre) == signbit(fcur)) {
+        return NAN; /* No sign change */
+    }
+    for (int i = 0; i < iter; i++) {
+        if (fpre != 0.0 && fcur != 0.0 && signbit(fpre) != signbit(fcur)) {
+            xblk = xpre;
+            fblk = fpre;
+            spre = scur = xcur - xpre;
+        }
+        if (fabs(fblk) < fabs(fcur)) {
+            xpre = xcur;
+            xcur = xblk;
+            xblk = xpre;
+            fpre = fcur;
+            fcur = fblk;
+            fblk = fpre;
+        }
+        double delta = (xtol + rtol * fabs(xcur)) / 2.0;
+        double sbis = (xblk - xcur) / 2.0;
+        if (fcur == 0.0 || fabs(sbis) < delta) {
+            return xcur;
+        }
+        if (fabs(spre) > delta && fabs(fcur) < fabs(fpre)) {
+            double stry;
+            if (xpre == xblk) {
+                /* Interpolate */
+                stry = -fcur * (xcur - xpre) / (fcur - fpre);
+            } else {
+                /* Extrapolate */
+                double dpre = (fpre - fcur) / (xpre - xcur);
+                double dblk = (fblk - fcur) / (xblk - xcur);
+                stry = -fcur * (fblk * dblk - fpre * dpre) / (dblk * dpre * (fblk - fpre));
+            }
+            if (2.0 * fabs(stry) < fmin(fabs(spre), 3.0 * fabs(sbis) - delta)) {
+                /* Good short step */
+                spre = scur;
+                scur = stry;
+            } else {
+                /* Bisect */
+                spre = sbis;
+                scur = sbis;
+            }
+        } else {
+            /* Bisect */
+            spre = sbis;
+            scur = sbis;
+        }
+        xpre = xcur;
+        fpre = fcur;
+        if (fabs(scur) > delta) {
+            xcur += scur;
+        } else {
+            xcur += (sbis > 0.0 ? delta : -delta);
+        }
+        fcur = f(xcur, data);
+    }
+    return xcur;
+}
+
+/* PIController ------------------------------------------------------------- */
+
+static void pi_init(PIController *self, double k_p, double k_t, double alpha_i,
+                    double u_max)
+{
+    self->k_p = k_p;
+    self->k_t = k_t;
+    self->alpha_i = alpha_i;
+    self->u_max = u_max;
+    self->u_i = 0.0;
+    self->v = 0.0;
+}
+
+static double pi_compute_output(PIController *self, double y_ref, double y,
+                                double u_ff)
+{
+    /* Estimate of a disturbance input */
+    self->v = self->u_i - (self->k_p - self->k_t) * y + u_ff;
+    double u = self->k_t * (y_ref - y) + self->v;
+    /* Limit the controller output */
+    return clip(u, -self->u_max, self->u_max);
+}
+
+static void pi_update(PIController *self, double T_s, double u)
+{
+    self->u_i += T_s * self->alpha_i * (u - self->v);
+}
+
+/* ComplexPIController ------------------------------------------------------ */
+
+static void complex_pi_init(ComplexPIController *self, double k_p, double k_i,
+                            double k_t)
+{
+    self->k_p = k_p;
+    self->k_t = k_t;
+    self->alpha_i = k_i / k_t;
+    self->u_i = 0.0;
+    self->v = 0.0;
+}
+
+static double complex complex_pi_compute_output(ComplexPIController *self,
+                                                double complex i_ref,
+                                                double complex i,
+                                                double complex u_ff)
+{
+    /* Disturbance input estimate */
+    self->v = self->u_i - (self->k_p - self->k_t) * i + u_ff;
+    return self->k_t * (i_ref - i) + self->v;
+}
+
+static void complex_pi_update(ComplexPIController *self, double T_s,
+                              double complex u, double w_c)
+{
+    self->u_i += T_s * (self->alpha_i + I * w_c) * (u - self->v);
+}
+
+/* CurrentLimiter ----------------------------------------------------------- */
+
+static double complex current_limiter(double i_max, double complex i)
+{
+    if (cabs(i) > i_max) {
+        i = i_max * i / cabs(i);
+    }
+    return i;
+}
+
+/* PowerReferenceLimiter ---------------------------------------------------- */
+
+static void power_reference_limiter_init(PowerReferenceLimiter *self, double i_d_max,
+                                         double alpha_l, double u_nom)
+{
+    self->i_d_max = i_d_max;
+    self->alpha_l = alpha_l;
+    self->p_max = 1.5 * u_nom * i_d_max;
+}
+
+static double power_reference_limiter_compute_output(const PowerReferenceLimiter *self,
+                                                     double p_g_ref)
+{
+    return copysign(fmin(fabs(p_g_ref), self->p_max), p_g_ref);
+}
+
+static void power_reference_limiter_update(PowerReferenceLimiter *self, double T_s,
+                                           double complex u_c, double complex i_c,
+                                           double complex i_cn)
+{
+    double abs_u_c = fmax(cabs(u_c), 1e-6);
+    double i_q = cimag(u_c * conj(i_c)) / abs_u_c;
+    double i_d_max = fmax(self->i_d_max - cabs(i_cn), 0.0);
+    double i_d_lim_sqr = fmax(i_d_max * i_d_max - i_q * i_q, 0.0);
+    double p_max = 1.5 * abs_u_c * sqrt(i_d_lim_sqr);
+    self->p_max += T_s * self->alpha_l * (p_max - self->p_max);
+}
+
+/* SpeedController ---------------------------------------------------------- */
+
+static PIController speed_controller(double J, double alpha_s, double alpha_i,
+                                     double tau_M_max)
+{
+    PIController ctrl;
+    alpha_i = isnan(alpha_i) ? alpha_s : alpha_i;
+    double k_p = (alpha_s + alpha_i) * J;
+    double k_i = alpha_s * alpha_i * J;
+    double k_t = alpha_s * J;
+    pi_init(&ctrl, k_p, k_t, k_i / k_t, tau_M_max);
+    return ctrl;
+}
+
+/* SpeedObserver ------------------------------------------------------------ */
+
+static void speed_observer_init(SpeedObserver *self, double k_w, double k_tau,
+                                double J)
+{
+    self->k_w = k_w;
+    self->k_tau = k_tau;
+    self->J = J;
+    self->w_M = 0.0;
+    self->tau_L = 0.0;
+}
+
+static void speed_observer_update(SpeedObserver *self, double T_s, double eps,
+                                  double tau_M)
+{
+    double d_w_M, d_tau_L;
+    if (self->J <= 0.0) {
+        d_w_M = self->k_w * eps;
+        d_tau_L = 0.0;
+    } else {
+        d_w_M = (tau_M - self->tau_L) / self->J + self->k_w * eps;
+        d_tau_L = -self->k_tau * eps;
+    }
+    self->w_M += T_s * d_w_M;
+    self->tau_L += T_s * d_tau_L;
+}
+
+/* Discretization ----------------------------------------------------------- */
+
+static void hold_equivalent(double T_s, double w_c, double complex *Phi,
+                            double complex *Gamma)
+{
+    /* Half-angle form, requiring a single sine-cosine pair. The sinc function is
+     * computed as numpy.sinc(x/pi). */
+    double x = 0.5 * w_c * T_s;
+    double complex exp_jx = cexp(-I * x);
+    double y = M_PI * ((x != 0.0) ? x / M_PI : 1e-20);
+    *Phi = exp_jx * exp_jx;
+    *Gamma = T_s * (sin(y) / y) * exp_jx;
+}
+
+static double matched_pole(double alpha, double T_s)
+{
+    return -expm1(-alpha * T_s) / T_s;
+}
+
+/* RateLimiter -------------------------------------------------------------- */
+
+static void rate_limiter_init(RateLimiter *self, double rate_limit)
+{
+    self->rate_limit = rate_limit;
+    self->old_y = 0.0;
+}
+
+static double rate_limiter_compute_output(const RateLimiter *self, double T_s,
+                                          double u)
+{
+    double rate = (u - self->old_y) / T_s;
+    if (rate > self->rate_limit) {
+        return self->old_y + T_s * self->rate_limit;
+    }
+    if (rate < -self->rate_limit) {
+        return self->old_y - T_s * self->rate_limit;
+    }
+    return u;
+}
+
+static void rate_limiter_update(RateLimiter *self, double y)
+{
+    self->old_y = y;
+}
+
+/* Inverter nonlinearity ------------------------------------------------------ */
+
+static void inverter_nonlinearity(double t_d, double u_th, double i_0,
+                                  const double i_abc[3], const double d_abc[3],
+                                  double u_dc, double T_half, double d_err[3])
+{
+    for (int k = 0; k < 3; k++) {
+        /* Switching-cycle averaged on-times of the upper and lower switches
+         * (averaged_gate_signals) */
+        double d = d_abc[k];
+        double delta = (d > 0.0 && d < 1.0) ? t_d / (2.0 * T_half) : 0.0;
+        double q_hi = fmax(d - delta, 0.0);
+        double q_lo = fmax(1.0 - d - delta, 0.0);
+        double b = 1.0 - q_hi - q_lo;
+        /* Current direction: tanh(i/i_0), or the signum function if i_0 = 0 */
+        double s = (i_0 > 0.0) ? tanh(i_abc[k] / i_0) : sign(i_abc[k]);
+        d_err[k] = d - q_hi - 0.5 * b * (1.0 - s) + s * u_th / u_dc;
+    }
+}
+
+/* PWM ---------------------------------------------------------------------- */
+
+static void pwm_init(PWM *self, double k_pred)
+{
+    self->k_pred = k_pred;
+    self->mme = 0;
+    self->t_d = 0.0;
+    self->u_th = 0.0;
+    self->i_0 = 0.0;
+    self->feedforward = 1;
+    self->d_min = 0.0;
+    self->single_update = 0;
+    for (int k = 0; k < 3; k++) {
+        self->d_abc[0][k] = 0.0;
+        self->d_abc[1][k] = 0.0;
+    }
+    /* Before the first duty ratios, the legs do not switch, and the infinite period
+     * gives no dead-time error */
+    self->T_half = INFINITY;
+}
+
+static void pwm_set_nonlinearity(PWM *self, double t_d, double u_th, double i_0,
+                                 int feedforward)
+{
+    self->t_d = t_d;
+    self->u_th = u_th;
+    self->i_0 = i_0;
+    self->feedforward = feedforward;
+}
+
+static void pwm_set_overmodulation(PWM *self, int mme)
+{
+    self->mme = mme;
+}
+
+static void pwm_set_min_pulse(PWM *self, double d_min)
+{
+    self->d_min = d_min;
+}
+
+static void pwm_set_single_update(PWM *self, int single_update)
+{
+    self->single_update = single_update;
+}
+
+/* Error model of the PWM in use (d_err is not None) */
+static int pwm_has_error_model(const PWM *self)
+{
+    return self->t_d > 0.0 || self->u_th > 0.0;
+}
+
+/* Half carrier period (s) corresponding to the sampling period */
+static double pwm_half_period(const PWM *self, double T_s)
+{
+    return self->single_update ? T_s / 2.0 : T_s;
+}
+
+static void pwm_limit_pulses(const PWM *self, double d_abc[3], const double d_ref[3],
+                             const double *i_abc, double u_dc, double T_half)
+{
+    for (int k = 0; k < 3; k++) {
+        double candidates[2]; /* The leg switching, the leg clamped */
+        if (d_abc[k] > 0.0 && d_abc[k] < self->d_min) {
+            candidates[0] = self->d_min;
+            candidates[1] = 0.0;
+        } else if (d_abc[k] > 1.0 - self->d_min && d_abc[k] < 1.0) {
+            candidates[0] = 1.0 - self->d_min;
+            candidates[1] = 1.0;
+        } else {
+            continue;
+        }
+        double errors[2];
+        for (int j = 0; j < 2; j++) {
+            d_abc[k] = candidates[j];
+            double realized = candidates[j];
+            if (i_abc != NULL) {
+                double d_err[3];
+                inverter_nonlinearity(self->t_d, self->u_th, self->i_0, i_abc, d_abc,
+                                      u_dc, T_half, d_err);
+                realized -= d_err[k];
+            }
+            errors[j] = fabs(realized - d_ref[k]);
+        }
+        d_abc[k] = (errors[1] < errors[0]) ? candidates[1] : candidates[0];
+    }
+}
+
+static double complex pwm_realized_voltage(const PWM *self, double complex i_c_ab,
+                                           double u_dc, int average)
+{
+    /* A discharged DC bus, e.g., with blocked gates */
+    if (u_dc <= 0.0) {
+        return 0.0;
+    }
+    double i_abc[3];
+    complex2abc(i_c_ab, i_abc);
+    int k0 = average ? 0 : 1;
+    double complex q_ab = 0.0;
+    for (int k = k0; k < 2; k++) {
+        double d[3] = {self->d_abc[k][0], self->d_abc[k][1], self->d_abc[k][2]};
+        if (pwm_has_error_model(self)) {
+            double d_err[3];
+            inverter_nonlinearity(self->t_d, self->u_th, self->i_0, i_abc, d, u_dc,
+                                  self->T_half, d_err);
+            for (int j = 0; j < 3; j++) {
+                d[j] -= d_err[j];
+            }
+        }
+        q_ab += abc2complex(d);
+    }
+    return u_dc * q_ab / (double)(2 - k0);
+}
+
+static void pwm_duty_ratios(double complex u_c_ref_ab, double u_dc, int mme,
+                            double d_abc[3])
+{
+    double u_abc[3];
+    complex2abc(u_c_ref_ab, u_abc);
+
+    /* Zero-sequence voltage resulting in space-vector PWM */
+    double u_max = fmax(fmax(u_abc[0], u_abc[1]), u_abc[2]);
+    double u_min = fmin(fmin(u_abc[0], u_abc[1]), u_abc[2]);
+    double u_0 = 0.5 * (u_max + u_min);
+    for (int k = 0; k < 3; k++) {
+        u_abc[k] -= u_0;
+    }
+
+    /* MPE overmodulation (MME results from limiting the duty ratios) */
+    double m = (2.0 / u_dc) * fmax(fmax(u_abc[0], u_abc[1]), u_abc[2]);
+    if (!mme && m > 1.0) {
+        for (int k = 0; k < 3; k++) {
+            u_abc[k] = u_abc[k] / m;
+        }
+    }
+
+    /* Duty ratios */
+    for (int k = 0; k < 3; k++) {
+        d_abc[k] = fmax(fmin(u_abc[k] / u_dc + 0.5, 1.0), 0.0);
+    }
+}
+
+static double complex pwm_compute_output(const PWM *self, double T_s,
+                                         double complex u_c_ref_ab, double u_dc,
+                                         double w, double complex i_c_ab,
+                                         double d_abc[3])
+{
+    /* A discharged DC bus, e.g., with blocked gates before the precharge */
+    if (u_dc <= 0.0) {
+        for (int k = 0; k < 3; k++) {
+            d_abc[k] = 0.5;
+        }
+        return 0.0;
+    }
+
+    /* Duty ratios */
+    pwm_duty_ratios(u_c_ref_ab, u_dc, self->mme, d_abc);
+    double d_ref[3] = {d_abc[0], d_abc[1], d_abc[2]};
+
+    /* Compensate for the duty-ratio error using the predicted currents */
+    int compensate = pwm_has_error_model(self) && self->feedforward;
+    double T_half = pwm_half_period(self, T_s);
+    double i_c_abc[3];
+    if (compensate) {
+        double d_err[3];
+        complex2abc(cexp(I * self->k_pred * T_s * w) * i_c_ab, i_c_abc);
+        inverter_nonlinearity(self->t_d, self->u_th, self->i_0, i_c_abc, d_abc, u_dc,
+                              T_half, d_err);
+        for (int k = 0; k < 3; k++) {
+            d_abc[k] = clip(d_abc[k] + d_err[k], 0.0, 1.0);
+        }
+    }
+
+    /* Minimum pulses */
+    if (self->d_min > 0.0) {
+        pwm_limit_pulses(self, d_abc, d_ref, compensate ? i_c_abc : NULL, u_dc,
+                         T_half);
+    }
+
+    /* Limited voltage reference, including the compensation */
+    return abc2complex(d_abc) * u_dc;
+}
+
+static void pwm_update(PWM *self, double T_s, const double d_abc[3])
+{
+    for (int k = 0; k < 3; k++) {
+        self->d_abc[0][k] = self->d_abc[1][k];
+        self->d_abc[1][k] = d_abc[k];
+    }
+    self->T_half = pwm_half_period(self, T_s);
+}