continuous-time model for three-level NPC inverter, WIP

Author: maattaj11

.vscode/settings.json

@@ -15,5 +15,8 @@
         ".vscode/*.py",
         "docs/*"
     ],
-    "esbonio.sphinx.confDir": "${workspaceFolder}/docs/source"
+    "esbonio.sphinx.confDir": "${workspaceFolder}/docs/source",
+    "cSpell.words": [
+        "motulator"
+    ]
 }

examples/grid/grid_following/plot_gfl_3level_10kva.py

@@ -0,0 +1,87 @@
+"""
+10-kVA converter
+================
+
+This example simulates a grid-following-controlled converter connected to an L
+filter and a strong grid. The control system includes a phase-locked loop (PLL)
+to synchronize with the grid, a current reference generator, and a PI-based
+current controller.
+
+"""
+
+# %%
+import numpy as np
+
+from motulator.grid import model, control
+from motulator.grid.utils import (
+    BaseValues, ACFilterPars, NominalValues, plot)
+# from motulator.grid.utils import plot_voltage_vector
+
+# %%
+# Compute base values based on the nominal values.
+
+nom = NominalValues(U=400, I=14.5, f=50, P=10e3)
+base = BaseValues.from_nominal(nom)
+
+# %%
+# Configure the system model.
+
+# Filter and grid
+par = ACFilterPars(L_fc=.2*base.L)
+ac_filter = model.ACFilter(par)
+ac_source = model.ThreePhaseVoltageSource(w_g=base.w, abs_e_g=base.u)
+# Inverter with constant DC voltage
+converter = model.VoltageSourceConverter(u_dc=650, C_dc=1e-3)
+
+# Create system model
+mdl = model.GridConverterSystem(converter, ac_filter, ac_source)
+mdl.pwm = model.CarrierComparison(
+    return_complex=True)  # Uncomment to enable the PWM model
+
+# %%
+# Configure the control system.
+
+cfg = control.GridFollowingControlCfg(
+    L=.2*base.L, nom_u=base.u, nom_w=base.w, max_i=1.5*base.i)
+ctrl = control.GridFollowingControl(cfg)
+
+# Add the DC-bus voltage controller to the control system
+ctrl.dc_bus_voltage_ctrl = control.DCBusVoltageController(
+    C_dc=1e-3, alpha_dc=2*np.pi*30, max_p=base.p)
+
+# %%
+# Set the time-dependent reference and disturbance signals.
+
+# Set the references for DC-bus voltage and reactive power
+ctrl.ref.u_dc = lambda t: 650
+ctrl.ref.q_g = lambda t: (t > .04)*4e3
+
+# Set the external current fed to the DC bus
+mdl.converter.i_dc = lambda t: (t > .06)*10
+
+# Uncomment lines below to simulate an unbalanced fault (add negative sequence)
+# mdl.ac_source.par.abs_e_g = .75*base.u
+# mdl.ac_source.par.abs_e_g_neg = .25*base.u
+# mdl.ac_source.par.phi_neg = -np.pi/3
+
+# %%
+# Create the simulation object and simulate it.
+
+import time
+
+start_time = time.time()
+
+sim = model.Simulation(mdl, ctrl)
+sim.simulate(t_stop=.1)
+
+print(time.time() - start_time)
+
+# %%
+# Plot the results.
+
+# By default results are plotted in per-unit values. By omitting the argument
+# `base` you can plot the results in SI units.
+
+# Uncomment line below to plot locus of the grid voltage space vector
+# plot_voltage_vector(sim, base)
+plot(sim, base, plot_pcc_voltage=False)

motulator/common/model/_converter.py

@@ -99,6 +99,98 @@ def post_process_with_inputs(self):
         data.i_dc_int = 1.5*np.real(data.q_cs*np.conj(data.i_cs))
 
 
+class ThreeLevelConverter(VoltageSourceConverter):
+    """
+    Lossless three-phase, three-level voltage-source converter.
+
+    Parameters
+    ----------
+    u_dc : float
+        DC-bus voltage (V). This value is used as an initial condition for the
+        voltage across both capacitors.
+    C_dc1 : float
+        DC-bus capacitance (F), positive side.
+    C_dc2 : float
+        DC-bus capacitance (F), negative side.
+    i_dc : callable
+        External current (A) fed to the DC bus.
+
+    """
+
+    def __init__(self, u_dc, C_dc1, C_dc2, i_dc):
+        super().__init__(u_dc)
+        self.par = SimpleNamespace(C_dc1=C_dc1, C_dc2=C_dc2)
+        self.state = SimpleNamespace(u_dc1=u_dc/2, u_dc2=u_dc/2)
+        self.sol_states = SimpleNamespace(u_dc1=[], u_dc2=[])
+        self.i_dc = i_dc
+        self.inp.q_p, self.inp.q_o = []
+        self.inp.i_dc = i_dc(0)
+
+    @property
+    def u_dc(self):
+        """DC-bus voltage (V)."""
+        return self.state.u_dc1.real + self.state.u_dc2.real
+
+    @property
+    def u_cs(self):
+        """AC-side voltage (V)."""
+        state, inp = self.state, self.inp
+        u_a = (inp.q_p[0] + inp.q_o[0])*state.u_dc1 + inp.q_o[0]*state.u_dc2
+        u_b = (inp.q_p[1] + inp.q_o[1])*state.u_dc1 + inp.q_o[1]*state.u_dc2
+        u_c = (inp.q_p[2] + inp.q_o[2])*state.u_dc1 + inp.q_o[2]*state.u_dc2
+        return abc2complex([u_a, u_b, u_c])
+
+    @property
+    def i_p(self):
+        """Converter-side positive DC current (A)."""
+        i_abc = complex2abc(self.inp.i_cs)
+        q_p = self.inp.q_p
+        return (q_p[0] == 1)*i_abc[0] + (q_p[1] == 1)*i_abc[1] + (
+            q_p[2] == 1)*i_abc[2]
+
+    @property
+    def i_o(self):
+        """Converter-side neutral-point current (A)."""
+        i_abc = complex2abc(self.inp.i_cs)
+        q_o = self.inp.q_o
+        return (q_o[0] == .5)*i_abc[0] + (q_o[1] == .5)*i_abc[1] + (
+            q_o[2] == .5)*i_abc[2]
+
+    def set_outputs(self, _):
+        """Set output variables."""
+        self.out.u_cs = self.u_cs
+        self.out.u_dc = self.u_dc
+
+    def set_inputs(self, t):
+        """Set input variables."""
+        # External DC-bus current
+        self.inp.i_dc = self.i_dc(t)
+        # Switching state vectors for DC-bus positive and neutral points
+        q_abc = self.inp.q_cs
+        self.inp.q_p = [q_abc[0] == 1, q_abc[1] == 1, q_abc[2] == 1]
+        self.inp.q_o = [q_abc[0] == .5, q_abc[1] == .5, q_abc[2] == .5]
+
+    def rhs(self):
+        """Compute the state derivatives."""
+        d_u_dc1 = (self.inp.i_dc - self.i_p)/self.par.C_dc1
+        d_u_dc2 = (self.inp.i_dc - self.i_p - self.i_o)/self.par.C_dc2
+        return [d_u_dc1, d_u_dc2]
+
+    def post_process_states(self):
+        """Post-process data."""
+        data = self.data
+        data.u_dc1, data.u_dc2 = data.u_dc1.real, data.u_dc2.real
+        u_a = (data.q_cs[0] == 1)*data.u_dc1 - (data.q_cs[0] == .5)*data.u_dc2
+        u_b = (data.q_cs[1] == 1)*data.u_dc1 - (data.q_cs[1] == .5)*data.u_dc2
+        u_c = (data.q_cs[2] == 1)*data.u_dc1 - (data.q_cs[2] == .5)*data.u_dc2
+        data.u_cs = abc2complex([u_a, u_b, u_c])
+
+    def post_process_with_inputs(self):
+        """Post-process data with inputs."""
+        data = self.data
+        #data.i_o =
+
+
 # %%
 class FrequencyConverter(VoltageSourceConverter):
     """