From 29644f612f3f0543cb7bbac958853a884d7e7cf5 Mon Sep 17 00:00:00 2001
From: Pimss <44709590+Pimss@users.noreply.github.com>
Date: Tue, 27 Oct 2026 17:32:57 +0100
Subject: [PATCH 1/7] Added NetlistCircuit class for sparse spice-like circuit
 simulation

NetlistCircuit leverage ElecSolver netlist parser and system building to formalise S2, S1 and B matrices compatible with SparseLinearDAE. Meanwhile, C and D are generated using imput parameters matching netlist style notation
---
 src/pathsim_rf/__init__.py |  50 +++---
 src/pathsim_rf/circuit.py  | 333 +++++++++++++++++++++++++++++++++++++
 2 files changed, 360 insertions(+), 23 deletions(-)
 create mode 100644 src/pathsim_rf/circuit.py

diff --git a/src/pathsim_rf/__init__.py b/src/pathsim_rf/__init__.py
index c3fe14b..afbe3cc 100644
--- a/src/pathsim_rf/__init__.py
+++ b/src/pathsim_rf/__init__.py
@@ -1,23 +1,27 @@
-"""
-PathSim-RF: RF Engineering toolbox for PathSim
-
-A toolbox providing specialized blocks for RF and microwave engineering
-simulations in the PathSim framework.
-"""
-
-try:
-    from ._version import version as __version__
-except ImportError:
-    __version__ = "unknown"
-
-__all__ = ["__version__"]
-
-from .transmission_line import *
-from .amplifier import *
-from .mixer import *
-from .netlist_to_statespace import NetlistStateSpace
-
-try:
-    from .network import *
-except ImportError:
-    pass
+"""
+PathSim-RF: RF Engineering toolbox for PathSim
+
+A toolbox providing specialized blocks for RF and microwave engineering
+simulations in the PathSim framework.
+"""
+
+try:
+    from ._version import version as __version__
+except ImportError:
+    __version__ = "unknown"
+
+__all__ = ["__version__"]
+
+from .transmission_line import *
+from .amplifier import *
+from .mixer import *
+from .netlist_to_statespace import NetlistStateSpace
+
+try: # test if scikit-rf is present in env (pip install scikit-rf)
+    from .network import *
+except ImportError:
+    pass
+try: # test if Elecsolver is present in env (pip install ElecSolver>=2.2.1)
+    from .circuit import *
+except ImportError:
+    pass
\ No newline at end of file
diff --git a/src/pathsim_rf/circuit.py b/src/pathsim_rf/circuit.py
new file mode 100644
index 0000000..c8f63af
--- /dev/null
+++ b/src/pathsim_rf/circuit.py
@@ -0,0 +1,333 @@
+#########################################################################################
+##
+##                          SPARSE ELECTRICAL CIRCUIT BLOCK
+##
+#########################################################################################
+
+# IMPORTS ===============================================================================
+
+import numpy as np
+import scipy.sparse as sp
+
+from pathsim.blocks.dae import SparseLinearDAE
+
+
+# HELPERS ===============================================================================
+
+def _source_matrix(builder):
+    """Superposition matrix 'B' of an ElecSolver 'TemporalSystemBuilder'.
+
+    Column 'k' is the right hand side of source 'k' at unit amplitude (current
+    sources first, then voltage sources, each in the order they were added), so
+    that 'rhs(t) = B @ u(t)'. The columns are taken from the 'build_second_member'
+    method of the builder, so the removed node equations and the ground handling
+    stay consistent with the system matrices. The source amplitudes of the
+    builder are restored afterwards.
+
+    Parameters
+    ----------
+    builder : TemporalSystemBuilder
+        circuit builder, after 'build_system()'
+
+    Returns
+    -------
+    B : scipy.sparse.csr_matrix, shape (n, number of sources)
+        superposition matrix, one column per source
+    """
+    n = builder.number_intensities + builder.size
+    n_cs = builder.current_source_data.shape[0]
+    n_vs = builder.voltage_source_data.shape[0]
+
+    saved = builder.current_source_data.copy(), builder.voltage_source_data.copy()
+    cols = []
+    try:
+        for k in range(n_cs + n_vs):
+            cs, vs = np.zeros(n_cs), np.zeros(n_vs)
+            if k < n_cs: cs[k] = 1.0
+            else:        vs[k - n_cs] = 1.0
+            builder.current_source_data, builder.voltage_source_data = cs, vs
+            data, (rows,) = builder.build_second_member(check=False)
+            col = np.zeros(n)
+            np.add.at(col, rows, data)
+            cols.append(sp.csc_matrix(col.reshape(-1, 1)))
+    finally:
+        builder.current_source_data, builder.voltage_source_data = saved
+        builder.build_second_member(check=False)
+
+    return sp.hstack(cols, format="csr") if cols else sp.csr_matrix((n, 0))
+
+
+# BLOCKS ================================================================================
+
+def _import_elecsolver():
+    """Import the netlist parser of `ElecSolver`"""
+    try:
+        from ElecSolver import NetlistParser
+    except ImportError as exc:
+        raise ImportError(
+            "'NetlistCircuit' needs the optional dependency 'ElecSolver', "
+            "install it with 'pip install ElecSolver'"
+            ) from exc
+    return NetlistParser
+
+
+class NetlistCircuit(SparseLinearDAE):
+    """Sparse linear circuit block from a SPICE-like netlist, parsed and solved
+    with `ElecSolver`.
+
+    The block behaves like a state space model of the netlist, where all the
+    independent sources are inputs and the node voltages and element currents
+    are outputs, all of them addressable by their netlist names. The netlist is
+    parsed by the ``NetlistParser`` of `ElecSolver` and the resulting circuit is
+    integrated as a sparse linear DAE by :class:`.SparseLinearDAE`. Nothing is
+    converted to a dense matrix, so large circuits are possible, and the
+    integration is done by the engine of the simulation, with any solver.
+
+    Supported elements are resistors ``R``, inductors ``L``, capacitors ``C``,
+    magnetic couplings ``K`` and independent voltage ``V`` and current ``I``
+    sources (SPICE syntax, SI prefixes and ``.param`` expressions are handled by
+    the `ElecSolver` parser). Behavioral sources ``B<name> n1 n2 I=...`` or
+    ``V=...`` are inputs as well, their expression is ignored, the signal is
+    provided by the simulation. Everything else, such as ``.tran``, is ignored.
+    Node ``0`` is the ground.
+
+    **Inputs** are all the independent sources, named like in the netlist, all
+    voltage sources first, then all current sources, each in netlist order. For
+    a voltage source ``V1 a b`` the input is :math:`V_a - V_b` in V and for a
+    current source ``I1 a b`` it is the current in A that flows from ``a`` to
+    ``b`` through the source (SPICE convention).
+
+    **Outputs** are all node voltages (without ground) named ``V(node)``,
+    followed by all element currents named ``I(name)`` for all resistors,
+    inductors, capacitors, voltage sources and current sources. The currents
+    are positive when they flow from ``n1`` to ``n2`` as in the declaration of
+    the element. The outputs can be restricted with `output_voltages` and
+    `output_currents`.
+
+    So the block is wired by name, for example ``circuit["V1"]`` for an input
+    and ``circuit["V(n1)"]`` or ``circuit["I(Rload)"]`` for an output, see the
+    example.
+
+    Note
+    ----
+    The initial condition is chosen by the user and zero by default (no current
+    in the inductors, no charge in the capacitors), see `initial_value`. The
+    initial condition solver of `ElecSolver` is not used.
+
+    The reduction of the DAE needs an index-1 circuit. Capacitor loops, such as
+    parallel capacitors or a capacitor directly across an ideal voltage source,
+    and inductor cut-sets, such as inductors in series without a resistive
+    path, are rejected with a ``ValueError``, as are ideal magnetic couplings
+    with :math:`|k| \\geq 1`, which make the inductance matrix singular
+    (:math:`|k| < 1`, even very close to 1, is fine). Every part of the circuit needs a
+    connection to ground ``0``.
+
+    Example
+    -------
+    An LC filter with a resistive load, driven by a pulse source. The load is
+    wired as a behavioral current source from the measured node voltage (an
+    algebraic loop that the simulation resolves):
+
+    .. code-block:: python
+
+        from pathsim import Simulation, Connection
+        from pathsim.blocks import NetlistCircuit, PulseSource, Amplifier, Scope
+
+        netlist = \"\"\"
+        V1 in 0 DC 0
+        Lfilter in n1 0.5e-3
+        Cfilter n1 0 50e-6
+        Bload n1 0 I=V(n1)/50
+        \"\"\"
+
+        circuit = NetlistCircuit(netlist)
+
+        src  = PulseSource(T=1/9000, amplitude=1, duty=0.5)
+        load = Amplifier(gain=1/50)
+        sco  = Scope(labels=["V(n1)", "I(Lfilter)"])
+
+        sim = Simulation(
+            [src, circuit, load, sco],
+            [
+                Connection(src, circuit["V1"]),
+                Connection(circuit["V(n1)"], load, sco[0]),
+                Connection(load, circuit["Bload"]),
+                Connection(circuit["I(Lfilter)"], sco[1]),
+            ]
+        )
+
+    Parameters
+    ----------
+    netlist : str, Path
+        path of a netlist file (``.net``, ``.cir``, ``.sp``) or the netlist as
+        text, a `str` that is an existing file or has one of these extensions
+        is read as a file
+    output_voltages : list[str], None
+        nodes exposed as ``V(node)`` outputs, all nodes except ground if `None`
+    output_currents : list[str], None
+        elements exposed as ``I(name)`` outputs, all resistors, inductors,
+        capacitors and sources if `None`
+    initial_value : dict[str, float], None
+        initial condition by name, for example ``{"V(n1)": 1.0, "I(Lfilter)":
+        0.5}`` for a precharged capacitor and a current in the inductor. The
+        keys are ``V(node)`` and ``I(name)`` of inductors, capacitors, resistors
+        and voltage sources, everything that is not given is zero. Only the
+        quantities that are states of the circuit have an effect (capacitor
+        voltages through the node potentials, inductor currents). Zero if `None`
+    x0 : array[float], None
+        initial condition as the full `ElecSolver` vector (all branch currents,
+        followed by all node potentials), takes precedence over `initial_value`
+
+    Attributes
+    ----------
+    parser : NetlistParser
+        the `ElecSolver` parser with the mapped netlist
+    builder : TemporalSystemBuilder
+        the `ElecSolver` circuit builder
+    input_names : list[str]
+        names of the inputs
+    output_names : list[str]
+        names of the outputs
+    """
+
+    def __init__(
+        self,
+        netlist,
+        output_voltages=None,
+        output_currents=None,
+        initial_value=None,
+        x0=None
+        ):
+
+        NetlistParser = _import_elecsolver()
+
+        parser = NetlistParser(netlist)
+        parser.map_netlist()
+        self.parser = parser
+
+        node_map = parser.node_map
+        dipoles = parser.dipole_map
+
+        for node in node_map:
+            if node.lower() == "gnd":
+                raise ValueError(
+                    f"node '{node}' is not the ground, use node '0' as ground"
+                    )
+
+        cur = list(parser.current)
+        vol = list(parser.voltage)
+
+        if not cur and not vol:
+            raise ValueError(
+                "circuit must contain at least one independent voltage or current source"
+                )
+
+        #ideal coupling |k| >= 1 makes the inductance matrix singular
+        for name, c in parser.coupling_map.items():
+            i, j = c["L_coords"]
+            Li = dipoles[list(parser.inductors)[i]]["value"]
+            Lj = dipoles[list(parser.inductors)[j]]["value"]
+            k = c["value"] / np.sqrt(Li * Lj)
+            if abs(k) >= 1.0:
+                raise ValueError(
+                    f"coupling '{name}' has |k| = {abs(k):.6g} >= 1, the inductance "
+                    f"matrix is singular, use |k| < 1"
+                    )
+
+        if not any(0 in d["nodes"] for d in dipoles.values()):
+            raise ValueError("circuit has no connection to the ground node '0'")
+
+        #circuit with sources, SPICE conventions: 'I a b' conducts from a to b
+        #through the source, so it injects into b, and 'V a b' is V(a) - V(b)
+        builder = parser.generate_temporal_system()
+        for name in cur:
+            a, b = dipoles[name]["nodes"]
+            builder.add_current_source(1.0, b, a)
+        for name in vol:
+            a, b = dipoles[name]["nodes"]
+            builder.add_voltage_source(1.0, a, b)
+        builder.set_ground(0)
+        builder.build_system()
+        self.builder = builder
+
+        S1, S2, _ = builder.get_system()
+        n = S1.shape[0]
+
+        #inputs in the order voltage sources, then current sources, the builder
+        #superposition matrix has them as current sources, then voltage sources
+        B = _source_matrix(builder)
+        ncs = len(cur)
+        B = sp.hstack([B[:, ncs:], B[:, :ncs]], format="csr")
+        self.input_names = vol + cur
+        col_in = {name: i for i, name in enumerate(self.input_names)}
+
+        #layout of the solution vector
+        nI = builder.number_intensities
+        nL, nR, nC = len(parser.inductors), len(parser.resistors), len(parser.capacitors)
+        sign = np.sign(builder.all_coords[1] - builder.all_coords[0]).astype(float)
+
+        #index and sign of the branch currents in the solution vector
+        branch = {}
+        for kind, names, offset in (
+            ("L", parser.inductors, 0),
+            ("R", parser.resistors, nL),
+            ("C", parser.capacitors, nL + nR),
+            ("V", parser.voltage, nL + nR + nC)
+            ):
+            for k, name in enumerate(names):
+                branch[name] = (offset + k, sign[offset + k])
+
+        #outputs
+        if output_voltages is None:
+            output_voltages = [node for node in node_map if node != "0"]
+        if output_currents is None:
+            output_currents = (
+                list(parser.resistors) + list(parser.inductors) +
+                list(parser.capacitors) + vol + cur
+                )
+
+        rows, cols, vals = [], [], []
+        drows, dcols = [], []
+        labels = []
+
+        for node in output_voltages:
+            if node == "0":
+                raise ValueError("the ground voltage 'V(0)' is not an output")
+            if node not in node_map:
+                raise ValueError(f"unknown node '{node}'")
+            rows.append(len(labels)); cols.append(nI + node_map[node]); vals.append(1.0)
+            labels.append(f"V({node})")
+
+        for name in output_currents:
+            if name in branch:
+                idx, sgn = branch[name]
+                rows.append(len(labels)); cols.append(idx); vals.append(sgn)
+            elif name in parser.current:
+                drows.append(len(labels)); dcols.append(col_in[name])
+            else:
+                raise ValueError(f"unknown element '{name}'")
+            labels.append(f"I({name})")
+
+        ny = len(labels)
+        C = sp.csr_matrix((vals, (rows, cols)), shape=(ny, n))
+        D = sp.csr_matrix((np.ones(len(drows)), (drows, dcols)), shape=(ny, len(self.input_names)))
+        self.output_names = labels
+
+        #initial condition by name
+        if x0 is None and initial_value is not None:
+            x0 = np.zeros(n)
+            for key, val in dict(initial_value).items():
+                if key.startswith("V(") and key.endswith(")") and key[2:-1] in node_map:
+                    x0[nI + node_map[key[2:-1]]] = val
+                elif key.startswith("I(") and key.endswith(")") and key[2:-1] in branch:
+                    idx, sgn = branch[key[2:-1]]
+                    x0[idx] = val * sgn
+                else:
+                    raise ValueError(f"unknown initial condition '{key}'")
+
+        super().__init__(
+            S1, S2, B, C, D,
+            x0=x0,
+            input_labels=self.input_names,
+            output_labels=labels
+            )

From 971deddf3eea2e87dabc8c66826ab3f0f9978a2d Mon Sep 17 00:00:00 2001
From: Pimss <44709590+Pimss@users.noreply.github.com>
Date: Tue, 27 Oct 2026 17:34:11 +0100
Subject: [PATCH 2/7] Added tests for NetlistCircuit

---
 tests/test_circuit.py | 284 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 284 insertions(+)
 create mode 100644 tests/test_circuit.py

diff --git a/tests/test_circuit.py b/tests/test_circuit.py
new file mode 100644
index 0000000..9d9fd19
--- /dev/null
+++ b/tests/test_circuit.py
@@ -0,0 +1,284 @@
+########################################################################################
+##
+##                                  TESTS FOR
+##                         'NetlistCircuit' in 'blocks/circuit.py'
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import os
+import tempfile
+import unittest
+import numpy as np
+
+from pathsim import Simulation, Connection
+from pathsim.blocks import Source, Scope, Amplifier, PulseSource
+from pathsim.solvers import BDF2, ESDIRK43, EUB
+from pathsim_rf import NetlistCircuit
+
+try:
+    import ElecSolver
+    HAS_ELECSOLVER = True
+except ImportError:
+    HAS_ELECSOLVER = False
+
+
+# HELPERS ==============================================================================
+
+R, C = 1e3, 1e-6
+TAU = R * C
+
+RC = """
+V1 in 0 1
+R1 in out 1k
+C1 out 0 1u
+"""
+
+LC_LOAD = """
+V1 in 0 1
+Lfilter in n1 0.5e-3
+Cfilter n1 0 50e-6
+Bload n1 0 I=V(n1)/50
+"""
+
+
+def simulate(block, wiring, sources, T=5e-3, dt=1e-5, Solver=BDF2, **kw):
+    """Simulate a circuit block, 'sources' is a dict input name -> callable and
+    'wiring' a list of output names that are recorded."""
+    srcs = [Source(f) for f in sources.values()]
+    sco = Scope()
+    conns = [Connection(s, block[name]) for s, name in zip(srcs, sources)]
+    conns += [Connection(block[name], sco[i]) for i, name in enumerate(wiring)]
+    sim = Simulation([block, sco] + srcs, conns, Solver=Solver, dt=dt, log=False, **kw)
+    sim.run(T)
+    return sco.read()
+
+
+# TESTS ================================================================================
+
+@unittest.skipUnless(HAS_ELECSOLVER, "ElecSolver not installed")
+class TestNetlistCircuitPorts(unittest.TestCase):
+
+    def test_default_ports(self):
+        blk = NetlistCircuit(RC)
+        self.assertEqual(blk.input_names, ["V1"])
+        self.assertEqual(
+            blk.output_names, ["V(in)", "V(out)", "I(R1)", "I(C1)", "I(V1)"]
+            )
+        self.assertEqual(len(blk.inputs), 1)
+        self.assertEqual(len(blk.outputs), 5)
+
+    def test_input_order_voltage_then_current_sources(self):
+        net = RC + "I1 0 out 1m\nV2 x 0 0\nRx x out 1\n"
+        blk = NetlistCircuit(net)
+        self.assertEqual(blk.input_names, ["V1", "V2", "I1"])
+
+    def test_restricted_outputs(self):
+        blk = NetlistCircuit(RC, output_voltages=["out"], output_currents=["C1"])
+        self.assertEqual(blk.output_names, ["V(out)", "I(C1)"])
+
+        none = NetlistCircuit(RC, output_voltages=[], output_currents=["R1"])
+        self.assertEqual(none.output_names, ["I(R1)"])
+
+    def test_ports_addressable_by_name(self):
+        blk = NetlistCircuit(RC)
+        blk["V1"]
+        blk["V(out)"]
+        blk["I(R1)"]
+
+    def test_netlist_from_file(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = os.path.join(d, "rc.cir")
+            with open(path, "w") as f:
+                f.write(RC)
+            for arg in (path, __import__("pathlib").Path(path)):
+                blk = NetlistCircuit(arg)
+                self.assertEqual(blk.input_names, ["V1"])
+
+    def test_params_and_si_prefixes(self):
+        net = ".param Rv = {2*500}\nV1 in 0 1\nR1 in out {Rv}\nC1 out 0 1u\n"
+        t, y = simulate(NetlistCircuit(net, output_voltages=["out"], output_currents=[]),
+                        ["V(out)"], {"V1": lambda t: 1.0})
+        self.assertLess(np.abs(y[0] - (1 - np.exp(-t / TAU))).max(), 1e-4)
+
+
+@unittest.skipUnless(HAS_ELECSOLVER, "ElecSolver not installed")
+class TestNetlistCircuitResponse(unittest.TestCase):
+
+    def test_rc_step_response_and_currents(self):
+        blk = NetlistCircuit(RC)
+        names = ["V(in)", "V(out)", "I(R1)", "I(C1)", "I(V1)"]
+        t, y = simulate(blk, names, {"V1": lambda t: 1.0}, Solver=ESDIRK43,
+                        tolerance_lte_rel=1e-9, tolerance_lte_abs=1e-12)
+        v = 1.0 - np.exp(-t / TAU)
+        i = np.exp(-t / TAU) / R
+        np.testing.assert_allclose(y[0], 1.0, atol=1e-9)
+        np.testing.assert_allclose(y[1], v, atol=1e-6)
+        #currents are positive from n1 to n2 of each element
+        np.testing.assert_allclose(y[2], i, atol=1e-9)
+        np.testing.assert_allclose(y[3], i, atol=1e-9)
+        #the source current flows through the source from n1 to n2, so the circuit is fed with -I(V1)
+        np.testing.assert_allclose(y[4], -i, atol=1e-9)
+
+    def test_current_source_sign_and_output(self):
+        #'I1 0 n 2m' conducts from node 0 to node n through the source, injecting into n
+        net = "I1 0 n 1\nR1 n 0 10\nC1 n 0 1u\n"
+        blk = NetlistCircuit(net)
+        self.assertEqual(blk.input_names, ["I1"])
+        t, y = simulate(blk, ["V(n)", "I(I1)", "I(R1)"], {"I1": lambda t: 2.0},
+                        Solver=ESDIRK43, T=1e-3, dt=1e-6,
+                        tolerance_lte_rel=1e-9, tolerance_lte_abs=1e-12)
+        np.testing.assert_allclose(y[1], 2.0, atol=1e-12)                 #I(I1) is the input
+        np.testing.assert_allclose(y[0][-1], 20.0, rtol=1e-3)             #V(n) -> I R
+        np.testing.assert_allclose(y[2], y[0] / 10.0, atol=1e-9)         #R1 n -> 0
+
+    def test_reversed_node_order_signs(self):
+        #elements declared from the higher node index to the lower one
+        net = "V1 a 0 1\nR1 b a 1k\nC1 0 b 1u\n"     #'R1 b a': current b -> a, 'C1 0 b': 0 -> b
+        blk = NetlistCircuit(net)
+        t, y = simulate(blk, ["V(b)", "I(R1)", "I(C1)"], {"V1": lambda t: 1.0},
+                        Solver=ESDIRK43, tolerance_lte_rel=1e-9, tolerance_lte_abs=1e-12)
+        i = np.exp(-t / TAU) / R
+        np.testing.assert_allclose(y[0], 1 - np.exp(-t / TAU), atol=1e-6)
+        #current charges the cap from a through R: R1 declared b -> a is negative
+        np.testing.assert_allclose(y[1], -i, atol=1e-9)
+        #C1 declared 0 -> b, the charging current flows b -> 0 through it: negative
+        np.testing.assert_allclose(y[2], -i, atol=1e-9)
+
+    def test_initial_value_by_name(self):
+        net = "V1 in 0 0\nR1 in out 1k\nC1 out 0 1u\n"
+        blk = NetlistCircuit(net, output_voltages=["out"], output_currents=[],
+                             initial_value={"V(out)": 2.0})
+        t, y = simulate(blk, ["V(out)"], {"V1": lambda t: 0.0})
+        self.assertLess(np.abs(y[0] - 2.0 * np.exp(-t / TAU)).max(), 1e-3)
+
+        #default is all zeros
+        t, y = simulate(NetlistCircuit(net, output_voltages=["out"], output_currents=[]),
+                        ["V(out)"], {"V1": lambda t: 0.0})
+        self.assertEqual(np.abs(y[0]).max(), 0.0)
+
+    def test_inductor_initial_current(self):
+        net = "V1 in 0 0\nR1 in n 10\nL1 n 0 10m\n"      #tau = L/R = 1ms
+        blk = NetlistCircuit(net, output_voltages=[], output_currents=["L1"],
+                             initial_value={"I(L1)": 3.0})
+        t, y = simulate(blk, ["I(L1)"], {"V1": lambda t: 0.0}, T=3e-3, dt=1e-6)
+        self.assertLess(np.abs(y[0] - 3.0 * np.exp(-t / 1e-3)).max(), 1e-3)
+
+    def test_full_x0_vector(self):
+        net = "V1 in 0 0\nR1 in out 1k\nC1 out 0 1u\n"
+        blk = NetlistCircuit(net)
+        x0 = np.zeros(blk.n)
+        x0[blk.builder.number_intensities + blk.parser.node_map["out"]] = 1.0
+        blk2 = NetlistCircuit(net, x0=x0)
+        np.testing.assert_allclose(blk2.initial_value, NetlistCircuit(
+            net, initial_value={"V(out)": 1.0}).initial_value)
+
+    def test_load_loop_wired_by_name(self):
+        #behavioral load source fed back from the measured node voltage, same circuit as
+        #an explicit load resistor
+        explicit = LC_LOAD.replace("Bload n1 0 I=V(n1)/50", "Rload n1 0 50")
+
+        def pulse():
+            return PulseSource(T=1 / 9000, amplitude=1, duty=0.5, t_rise=1e-8, t_fall=1e-8)
+
+        #reference: explicit resistor
+        ref = NetlistCircuit(explicit, output_voltages=["n1"], output_currents=["Lfilter"])
+        src, sco = pulse(), Scope()
+        sim = Simulation(
+            [src, ref, sco],
+            [Connection(src, ref["V1"]), Connection(ref["V(n1)"], sco[0]),
+             Connection(ref["I(Lfilter)"], sco[1])],
+            Solver=EUB, dt=5e-7, log=False
+            )
+        sim.run(1e-3)
+        _, y_ref = sco.read()
+
+        #behavioral source closed through an amplifier with the algebraic loop
+        blk = NetlistCircuit(LC_LOAD)
+        src, load, sco = pulse(), Amplifier(gain=1 / 50), Scope()
+        sim = Simulation(
+            [src, blk, load, sco],
+            [Connection(src, blk["V1"]),
+             Connection(blk["V(n1)"], load, sco[0]),
+             Connection(load, blk["Bload"]),
+             Connection(blk["I(Lfilter)"], sco[1])],
+            Solver=EUB, dt=5e-7, log=False
+            )
+        sim.run(1e-3)
+        _, y = sco.read()
+
+        np.testing.assert_allclose(y[0], y_ref[0], atol=1e-9)
+        np.testing.assert_allclose(y[1], y_ref[1], atol=1e-9)
+
+    def test_mutual_coupling_transient(self):
+        #magnetically coupled inductors, the second one is excited through the coupling
+        a = "V1 in 0 0\nR1 in p 1\nL1 p 0 1m\nL2 q 0 1m\nR2 q 0 1\nK1 L1 L2 0.5\n"
+        blk = NetlistCircuit(a, output_voltages=[], output_currents=["L1", "L2"])
+        t, y = simulate(blk, ["I(L1)", "I(L2)"], {"V1": lambda t: 1.0}, T=30e-3, dt=1e-4)
+        #steady state: L1 is a DC short, so i1 = V / R1, the mutual coupling only drives
+        #a transient in the second inductor, which decays to zero
+        self.assertAlmostEqual(y[0][-1], 1.0, places=3)
+        self.assertAlmostEqual(y[1][-1], 0.0, places=3)
+        self.assertGreater(np.abs(y[1]).max(), 1e-3)
+
+
+@unittest.skipUnless(HAS_ELECSOLVER, "ElecSolver not installed")
+class TestNetlistCircuitErrors(unittest.TestCase):
+
+    def test_no_sources(self):
+        with self.assertRaises(ValueError):
+            NetlistCircuit("R1 a 0 1k\nC1 a 0 1u\n")
+
+    def test_gnd_alias_rejected(self):
+        with self.assertRaises(ValueError):
+            NetlistCircuit("V1 a gnd 1\nR1 a gnd 1k\nC1 a gnd 1u\n")
+
+    def test_no_ground_connection(self):
+        with self.assertRaises(ValueError):
+            NetlistCircuit("V1 a b 1\nR1 a b 1k\nC1 a b 1u\n")
+
+    def test_unknown_outputs(self):
+        with self.assertRaises(ValueError):
+            NetlistCircuit(RC, output_voltages=["nope"])
+        with self.assertRaises(ValueError):
+            NetlistCircuit(RC, output_currents=["Rnope"])
+        with self.assertRaises(ValueError):
+            NetlistCircuit(RC, output_voltages=["0"])
+
+    def test_unknown_initial_condition(self):
+        with self.assertRaises(ValueError):
+            NetlistCircuit(RC, initial_value={"V(nope)": 1.0})
+        with self.assertRaises(ValueError):
+            NetlistCircuit(RC, initial_value={"foo": 1.0})
+
+    def test_parallel_capacitors_rejected(self):
+        net = "V1 in 0 1\nR1 in a 1k\nC1 a 0 1u\nC2 a 0 1u\n"
+        with self.assertRaises(ValueError):
+            NetlistCircuit(net)
+
+    def test_ideal_coupling_rejected(self):
+        net = "V1 in 0 1\nR1 in p 1\nL1 p 0 1m\nL2 q 0 1m\nR2 q 0 1\nK1 L1 L2 {k}\n"
+        for k in ("1", "-1", "1.2"):
+            with self.assertRaises(ValueError):
+                NetlistCircuit(net.format(k=k))
+        #strong but not ideal coupling works
+        NetlistCircuit(net.format(k="0.999999"))
+
+    def test_wrong_type(self):
+        with self.assertRaises(TypeError):
+            NetlistCircuit(42)
+
+
+class TestNetlistCircuitDependency(unittest.TestCase):
+
+    @unittest.skipIf(HAS_ELECSOLVER, "ElecSolver installed")
+    def test_missing_elecsolver(self):
+        with self.assertRaises(ImportError):
+            NetlistCircuit(RC)
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

From fe6f4bbece39a49f470339b0d046a4a4c83a8bed Mon Sep 17 00:00:00 2001
From: Pimss <44709590+Pimss@users.noreply.github.com>
Date: Tue, 27 Oct 2026 17:35:10 +0100
Subject: [PATCH 3/7] Add ElecSolver dependency version 2.2.1

---
 pyproject.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pyproject.toml b/pyproject.toml
index 104e1ff..55f6716 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -30,6 +30,7 @@ dependencies = [
     "numpy>=1.15",
     "scipy>=1.2",
     "scikit-rf>=0.30",
+    "ElecSolver>=2.2.1",
     # If a dependency ships native code that can't be installed in Pyodide,
     # tag it with `; sys_platform != 'emscripten'` so a normal pip install
     # still pulls it eagerly but micropip in the browser skips it. Pair

From 1aa17367dab2631f1ca64adbae4ab53cd9629461 Mon Sep 17 00:00:00 2001
From: Pimss <44709590+Pimss@users.noreply.github.com>
Date: Tue, 27 Oct 2026 17:38:00 +0100
Subject: [PATCH 4/7] Add sparse netlist circuit example notebook

This notebook demonstrates a pulse-driven LC low-pass filter simulation using the NetlistCircuit block, including setup instructions and simulation results.
---
 .../examples/sparse_netlist_circuit.ipynb     | 224 ++++++++++++++++++
 1 file changed, 224 insertions(+)
 create mode 100644 docs/source/examples/sparse_netlist_circuit.ipynb

diff --git a/docs/source/examples/sparse_netlist_circuit.ipynb b/docs/source/examples/sparse_netlist_circuit.ipynb
new file mode 100644
index 0000000..d48b0de
--- /dev/null
+++ b/docs/source/examples/sparse_netlist_circuit.ipynb
@@ -0,0 +1,224 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9949413d",
+   "metadata": {},
+   "source": [
+    "# Sparse Circuit from a Netlist\n",
+    "\n",
+    "This example simulates a pulse-driven LC low-pass filter with a resistive load using the `NetlistCircuit` block. [ElecSolver](https://github.com/williampiat3/ElecSolver) parses the SPICE-like netlist; PathSim then integrates the circuit as a sparse linear differential-algebraic equation (DAE).\n",
+    "\n",
+    "The block behaves like a state space model of the netlist:\n",
+    "\n",
+    "- the **inputs** are the independent sources, named like in the netlist (`V1`, `Bload`, ...)\n",
+    "- the **outputs** are all node voltages `V(node)` and all element currents `I(name)`\n",
+    "\n",
+    "so the circuit is wired to other blocks by name.\n",
+    "\n",
+    "**Before running:** select a Python environment with `pathsim`, `pathsim_rf`, `matplotlib`, and the optional dependency `ElecSolver` (`pip install ElecSolver`). If you use local source checkouts, keep their directories on `PYTHONPATH`. Run the cells from top to bottom: inspect the available ports, select the measurements, connect the blocks, and run the simulation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7f789358",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from pathsim import Simulation, Connection\n",
+    "from pathsim.blocks import PulseSource, Amplifier, Scope\n",
+    "from pathsim.solvers import BDF2\n",
+    "from pathsim_rf import NetlistCircuit"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cd74bc6b",
+   "metadata": {},
+   "source": [
+    "## Netlist\n",
+    "\n",
+    "The source `V1` drives node `in` through a 0.5 mH series inductor (`Lfilter`). A 50 µF capacitor (`Cfilter`) connects the output node `n1` to ground, node `0`.\n",
+    "\n",
+    "The 50 Ω load is represented by a behavioral current source, `Bload`. Its expression `I=V(n1)/50` describes the intended load, but the block does **not** evaluate it: the current is an input supplied by the PathSim feedback connection below.\n",
+    "\n",
+    "Likewise, the `PULSE(...)` waveform and `.tran` directive do not control the PathSim run. We set the matching pulse parameters in `PulseSource` and the timestep and duration in the simulation cells."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0d28cb83",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "netlist = \"\"\"\n",
+    "*validation netlist for pathsim\n",
+    ".param FREQ = 9k\n",
+    ".param DUTY = 0.5\n",
+    ".param V_LOW = 0\n",
+    ".param V_HIGH = 1\n",
+    ".param T_PER = {1/FREQ}\n",
+    ".param T_ON = {T_PER * DUTY}\n",
+    ".param T_RISE = 10n\n",
+    ".param T_FALL = 10n\n",
+    "\n",
+    "V1 in 0 PULSE({V_LOW} {V_HIGH} 0 {T_RISE} {T_FALL} {T_ON} {T_PER})\n",
+    "Bload n1 0 I=V(n1)/50\n",
+    "Lfilter in n1 0.5e-3\n",
+    "Cfilter n1 0 50e-6\n",
+    ".tran 0.5e-6 40e-3 0 0.00001\n",
+    ".end\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2bf01163",
+   "metadata": {},
+   "source": [
+    "## Circuit block\n",
+    "\n",
+    "First, create a block with all outputs exposed and print the available port names. Inputs list voltage sources first, then current sources. Outputs list node voltages relative to ground (ground itself is excluded), then element currents. A current is positive from the first node to the second node in that element's netlist declaration.\n",
+    "\n",
+    "The default initial state is zero: the capacitor is uncharged and the inductor carries no current. You can set these quantities by name with `initial_value`, for example `{\"V(n1)\": 1.0, \"I(Lfilter)\": 0.5}` (volts and amperes)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "023c710b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "circuit = NetlistCircuit(netlist)\n",
+    "\n",
+    "print(\"inputs :\", circuit.input_names)\n",
+    "print(\"outputs:\", circuit.output_names)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "77692372",
+   "metadata": {},
+   "source": [
+    "Now replace the inspection block with one exposing only the two measurements used below: `V(n1)` for the load feedback and plot, and `I(Lfilter)` for the plot. The selection lists take bare node and element names, not the formatted port labels.\n",
+    "\n",
+    "This reduces the rows of the sparse output matrices `C` and `D` inherited from `SparseLinearDAE`; it does not remove components or reduce the internal circuit state. Selecting outputs without direct feedthrough can also avoid unnecessary algebraic dependencies, but output selection alone does not guarantee that a feedback loop disappears."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3a03c84e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "circuit = NetlistCircuit(netlist, output_voltages=[\"n1\"], output_currents=[\"Lfilter\"])\n",
+    "\n",
+    "print(\"inputs :\", circuit.input_names)\n",
+    "print(\"outputs:\", circuit.output_names)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6c82fba0",
+   "metadata": {},
+   "source": [
+    "## Blocks and connections\n",
+    "\n",
+    "The load feedback is implemented outside the circuit: `V(n1)` passes through a gain of `1/50` A/V and returns to the input `Bload`. This implements Ohm's law, drawing current from `n1` to ground just like a 50 Ω resistor.\n",
+    "\n",
+    "`PulseSource` drives `V1` with a 0-to-1 V pulse at 9 kHz and 50% duty cycle, matching the netlist. The scope records the source voltage, filtered output voltage, and inductor current. Named circuit ports make these connections independent of their numeric port indices."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7682fbde",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Src = PulseSource(T=1/9000, amplitude=1, duty=0.5, t_rise=10e-9, t_fall=10e-9)\n",
+    "Load = Amplifier(1/50)\n",
+    "Sco = Scope(labels=[\"pulse V1\", \"V(n1)\", \"I(Lfilter)\"])\n",
+    "\n",
+    "blocks = [Src, circuit, Load, Sco]\n",
+    "\n",
+    "connections = [\n",
+    "    Connection(Src, circuit[\"V1\"], Sco[0]),\n",
+    "    Connection(circuit[\"V(n1)\"], Load, Sco[1]),\n",
+    "    Connection(Load, circuit[\"Bload\"]),\n",
+    "    Connection(circuit[\"I(Lfilter)\"], Sco[2]),\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ccf4cd9a",
+   "metadata": {},
+   "source": [
+    "## Simulation\n",
+    "\n",
+    "Use the implicit BDF2 solver to integrate the circuit DAE, with an initial timestep of 0.5 µs. The simulation starts from the zero initial state described above; `log=True` enables progress logging. The next cell constructs the simulation; the final cell advances it for 40 ms."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ddf8d3bb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Sim = Simulation(blocks, connections, Solver=BDF2, dt=0.5e-6, log=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "20aaee67",
+   "metadata": {},
+   "source": [
+    "## Results\n",
+    "\n",
+    "Run the simulation and plot the three recorded signals. `pulse V1` and `V(n1)` are in volts, while `I(Lfilter)` is in amperes, so their plotted magnitudes have different units.\n",
+    "\n",
+    "Look for the LC startup oscillation and the smoothing of the input pulses at `V(n1)`. With a 0-to-1 V input and 50% duty cycle, the long-term mean output should be near 0.5 V; zoom in on the end of the trace to inspect the remaining switching ripple."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Sim.run(40e-3)\n",
+    "Sco.plot(lw=1.5)\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.x"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 0e34e37266250ab1dee538916a6e9ad06253c3d8 Mon Sep 17 00:00:00 2001
From: Pimss <44709590+Pimss@users.noreply.github.com>
Date: Tue, 27 Oct 2026 17:42:17 +0100
Subject: [PATCH 5/7] Add NetlistCircuit class to README

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 638adbe..f9775c1 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,7 @@ PathSim-RF extends the [PathSim](https://github.com/pathsim/pathsim) simulation
 |-------|-------------|----------------|
 | `RFNetwork` | N-port network from S-parameter data (Touchstone) via vector fitting | `ntwk`, `auto_fit` |
 | `NetlistStateSpace` | Conversion of spice netlist into pathsim StateSpace | `netlist`, `output_voltages`, `output_currents` |
+| `NetlistCircuit` | Inherited class of SparseLinearDAE, importing spice netlist | `netlist`, `output_voltages`, `output_currents`, `initial_value` |
 | `TransmissionLine` | Lossy delay-based transmission line (scattering domain) | `length`, `er`, `attenuation`, `Z0` |
 | `RFAmplifier` | Amplifier with optional IP3 nonlinearity | `gain` [dB], `IIP3` [dBm], `P1dB` [dBm], `Z0` |
 | `RFMixer` | Ideal frequency converter (time-domain multiplication) | `conversion_gain` [dB], `Z0` |

From d6c3a0e937a21df7e02f91cd2efb8b43b9454ee4 Mon Sep 17 00:00:00 2001
From: Pimss <44709590+Pimss@users.noreply.github.com>
Date: Thu, 29 Oct 2026 16:37:41 +0100
Subject: [PATCH 6/7] Add transformer example with thermal model

`NetlistCircuit` can be used in any physics given a circuit equivalence can be used. This example feature coupled inductors and a second order thermal model.
---
 .../transformer_thermal_pathsim.ipynb         | 240 ++++++++++++++++++
 1 file changed, 240 insertions(+)
 create mode 100644 docs/source/examples/transformer_thermal_pathsim.ipynb

diff --git a/docs/source/examples/transformer_thermal_pathsim.ipynb b/docs/source/examples/transformer_thermal_pathsim.ipynb
new file mode 100644
index 0000000..4317e9b
--- /dev/null
+++ b/docs/source/examples/transformer_thermal_pathsim.ipynb
@@ -0,0 +1,240 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "intro",
+   "metadata": {},
+   "source": [
+    "# Transformer with a thermal model in PathSim (`NetlistCircuit`)\n",
+    "\n",
+    "> **Note:** the component values used in this notebook are **not representative of a real transformer**; they are chosen for illustration only (visible losses, short simulation time).\n",
+    "\n",
+    "1. **Part 1** - a two-winding transformer, simulated with `pathsim_rf.NetlistCircuit`.\n",
+    "2. **Part 2** - a second-order thermal model (3 R, 2 C), also a `NetlistCircuit`, heated by the winding losses."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathsim import Connection, Simulation\n",
+    "from pathsim.blocks import Function, Scope, SinusoidalSource\n",
+    "from pathsim.solvers import RK4\n",
+    "from pathsim_rf import NetlistCircuit"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "part1-md",
+   "metadata": {},
+   "source": [
+    "## Part 1 - the transformer\n",
+    "\n",
+    "```\n",
+    "    in   ┌───────────────┐   a                            b    ┌───────────────┐    c\n",
+    "     ┌───┤ R1 = 0.1 ohm  ├───●                            ●────┤ R2 = 0.5 ohm  ├────●\n",
+    "     │   └───────────────┘   │          k = 0.9           │    └───────────────┘    │\n",
+    " ╭───┴───╮              ┌────┴────┐     ◄─ K1 ─►     ┌────┴────┐               ┌────┴────┐\n",
+    "(   V1    )             │  L1  ●  │                  │  L2  ●  │               │   R3    │\n",
+    "( ~ 100 V )             │  60 mH  │                  │  30 mH  │               │ 50 ohm  │\n",
+    "(  50 Hz  )             └─────────┘                  └─────────┘               └─────────┘\n",
+    " ╰───┬───╯                   │                            │                         │\n",
+    "     │                       │                            │                         │\n",
+    "     └───────────────────────┴────────────────────────────┴─────────────────────────┘ GND (0)\n",
+    "```\n",
+    "\n",
+    "`V1` is a 50 Hz sine source, `R1` / `R2` are the winding resistances, `L1` / `L2` the coupled inductances (`K1`, coefficient 0.9; `●` = polarity dot, at the top of both inductors) and `R3` the load. `GND (0)` is the reference node.\n",
+    "\n",
+    "The schematic is written as a SPICE netlist, one line per element:\n",
+    "\n",
+    "| Netlist line | Meaning |\n",
+    "|---|---|\n",
+    "| `V1 in 0` | voltage source between node `in` and ground `0` |\n",
+    "| `R1 in a {R1}` | primary winding resistance |\n",
+    "| `L1 a 0 {L1}` / `L2 b 0 {L2}` | the two inductors (dot = first node) |\n",
+    "| `K1 L1 L2 0.9` | coupling coefficient between `L1` and `L2` |\n",
+    "| `R2 b c {R2}`, `R3 c 0 {Rload}` | secondary winding resistance and load |\n",
+    "\n",
+    "How it plugs into PathSim:\n",
+    "\n",
+    "- `NetlistCircuit` is a normal block. Its **inputs** are the sources of the netlist (here `V1`), driven by a `SinusoidalSource`; its **outputs** are the signals asked for with `output_voltages` / `output_currents`.\n",
+    "- Only the used outputs are requested. Exporting every node and current can create direct feedthrough, which PathSim treats as an algebraic loop and makes the run much slower (see the *Performance* section of `3phase_pathsim_walkthrough.ipynb`).\n",
+    "- The simulation covers 3 cycles of the 50 Hz source (60 ms)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "part1-model",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "FREQ = 50.0 # Hz\n",
+    "\n",
+    "def transformer_netlist(R1, L1, L2, k, R2, Rload):\n",
+    "    return f'''\n",
+    ".param R1 = {R1!r}\n",
+    ".param L1 = {L1!r}\n",
+    ".param L2 = {L2!r}\n",
+    ".param R2 = {R2!r}\n",
+    ".param Rload = {Rload!r}\n",
+    "V1 in 0 DC 0\n",
+    "R1 in a {{R1}}\n",
+    "L1 a 0 {{L1}}\n",
+    "L2 b 0 {{L2}}\n",
+    "K1 L1 L2 {k!r}\n",
+    "R2 b c {{R2}}\n",
+    "R3 c 0 {{Rload}}\n",
+    "'''\n",
+    "\n",
+    "def make_transformer(params):\n",
+    "    return NetlistCircuit(transformer_netlist(**params),\n",
+    "                          output_voltages=[\"c\"],              # load voltage\n",
+    "                          output_currents=[\"R1\", \"R2\", \"R3\"]) # primary, secondary and load currents\n",
+    "\n",
+    "PARAMS = dict(R1=0.1, L1=60e-3, L2=30e-3, k=0.9, R2=0.5, Rload=50.0)   # ohm, H, H, - , ohm, ohm\n",
+    "AMPLITUDE = 100.0                                                      # V\n",
+    "\n",
+    "source = SinusoidalSource(frequency=FREQ, amplitude=AMPLITUDE)\n",
+    "transformer = make_transformer(PARAMS)\n",
+    "scope = Scope(labels=[\"load current [A]\", \"primary current [A]\"])\n",
+    "blocks = [source, transformer, scope]\n",
+    "connections =[Connection(source, transformer[\"V1\"]),\n",
+    "              Connection(transformer[\"I(R3)\"], scope[0]),\n",
+    "              Connection(transformer[\"I(R1)\"], scope[1])]\n",
+    "sim = Simulation(blocks, connections, dt=1e-4, Solver=RK4, log=False)\n",
+    "sim.run(0.06, adaptive=False)       # 3 cycles\n",
+    "scope.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "part2-md",
+   "metadata": {},
+   "source": [
+    "## Part 2 - add the thermal model\n",
+    "\n",
+    "The thermal network is the electrical analogy, written as a second `NetlistCircuit`: temperature rise above ambient = node voltage, heat flow = current, thermal resistance = resistor, heat capacity = capacitor, ambient = ground.\n",
+    "\n",
+    "```\n",
+    "             w (winding)                         ┌───────────────┐   c (core)\n",
+    "       ┌───────────●───────────●───────────●─────┤ Rwc = 7.0 K/W ├───────────●───────────┐\n",
+    "       ▲           ▲           │           │     └───────────────┘           │           │\n",
+    "   ╭───┴───╮   ╭───┴───╮  ─────┴───── ┌────┴────┐                       ─────┴───── ┌────┴────┐\n",
+    "  (   Ip1   ) (   Ip2   )     Cw      │   Rwa   │                           Cc      │   Rca   │\n",
+    "  (  = P1   ) (  = P2   )   0.2 J/K   │ 40 K/W  │                         0.8 J/K   │ 5.5 K/W │\n",
+    "   ╰───────╯   ╰───────╯  ─────┬───── └─────────┘                       ─────┬───── └─────────┘\n",
+    "       │           │           │           │                                 │           │\n",
+    "       │           │           │           │                                 │           │\n",
+    "       │           │           │           │                                 │           │\n",
+    "       └───────────┴───────────┴───────────┴─────────────────────────────────┴───────────┘ ambient (0 K)\n",
+    "```\n",
+    "\n",
+    "- `w` = windings, `c` = core / housing; `Cw`, `Cc` make it **second order**; `Rwc`, `Rca`, `Rwa` are the 3 thermal resistances.\n",
+    "- `Ip1` and `Ip2` are current sources (heat flow in W) injecting the winding losses `P1 = R1 i1^2` and `P2 = R2 i2^2` into the winding node `w`. They are computed by `Function` blocks from the currents `I(R1)` and `I(R2)` of the transformer block.\n",
+    "\n",
+    "**Small heat capacities.** A real transformer heats up over minutes to hours, whereas the electrical side needs 20 ms steps per cycle. To keep the run short, `Cw` and `Cc` are about **1000 times smaller** than realistic values (about 200 and 800 J/K): the thermal time constants are about **1 s and 5 s** instead of about 17 min and 83 min. The steady-state temperatures depend only on the thermal resistances and the losses, so they are **not** affected; only the thermal transient is compressed (20 s simulated ~ 5.6 h real)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "run-coupled",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "T_AMBIENT = 25.0  # degC (the thermal network works with the rise above it)\n",
+    "\n",
+    "# thermal network: K/W and J/K\n",
+    "THERMAL = dict(Rwc=7.0, Rca=5.5, Rwa=40.0, Cw=0.2, Cc=0.8)\n",
+    "\n",
+    "THERMAL_NETLIST = f'''\n",
+    ".param Rwc = {THERMAL[\"Rwc\"]}\n",
+    ".param Rca = {THERMAL[\"Rca\"]}\n",
+    ".param Rwa = {THERMAL[\"Rwa\"]}\n",
+    ".param Cw = {THERMAL[\"Cw\"]}\n",
+    ".param Cc = {THERMAL[\"Cc\"]}\n",
+    "Ip1 0 w 0\n",
+    "Ip2 0 w 0\n",
+    "Cw w 0 {{Cw}}\n",
+    "Cc c 0 {{Cc}}\n",
+    "Rwc w c {{Rwc}}\n",
+    "Rca c 0 {{Rca}}\n",
+    "Rwa w 0 {{Rwa}}\n",
+    "'''\n",
+    "\n",
+    "source = SinusoidalSource(frequency=FREQ, amplitude=AMPLITUDE)\n",
+    "transformer = make_transformer(PARAMS)\n",
+    "thermal = NetlistCircuit(THERMAL_NETLIST, output_voltages=[\"w\", \"c\"], output_currents=[])\n",
+    "# Loss could also be computed using U*I, or in this case, R*I²\n",
+    "loss_primary = Function(lambda i: PARAMS[\"R1\"] * i * i)       # P1 = R1 i1^2\n",
+    "loss_secondary = Function(lambda i: PARAMS[\"R2\"] * i * i)     # P2 = R2 i2^2\n",
+    "\n",
+    "scope_current = Scope(labels=[\"load current [A]\"], t_wait=19.94)   # record only the last 3 cycles\n",
+    "scope_temp = Scope(labels=[\"winding rise [K]\", \"core rise [K]\"])\n",
+    "blocks_th = [source, transformer, thermal, loss_primary, loss_secondary, scope_current, scope_temp]\n",
+    "connections_th = [Connection(source, transformer[\"V1\"]),\n",
+    "                  Connection(transformer[\"I(R1)\"], loss_primary),\n",
+    "                  Connection(transformer[\"I(R2)\"], loss_secondary),\n",
+    "                  Connection(transformer[\"I(R3)\"], scope_current),\n",
+    "                  Connection(loss_primary, thermal[\"Ip1\"]),\n",
+    "                  Connection(loss_secondary, thermal[\"Ip2\"]),\n",
+    "                  Connection(thermal[\"V(w)\"], scope_temp[0]),\n",
+    "                  Connection(thermal[\"V(c)\"], scope_temp[1])]\n",
+    "\n",
+    "sim = Simulation(blocks_th, connections_th, dt=1e-4, Solver=RK4, log=False)\n",
+    "sim.run(20.0, adaptive=False)                     # 20 s = 1000 cycles\n",
+    "\n",
+    "scope_current.plot()\n",
+    "scope_temp.plot()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 1dabcc8662867cc3d0fb7bb0b3275c4df4fd536b Mon Sep 17 00:00:00 2001
From: Pimss <44709590+Pimss@users.noreply.github.com>
Date: Thu, 29 Oct 2026 16:47:48 +0100
Subject: [PATCH 7/7] Remove ambient temperature definition from example

Removed the ambient temperature definition from the thermal path simulation example.
---
 docs/source/examples/transformer_thermal_pathsim.ipynb | 1 -
 1 file changed, 1 deletion(-)

diff --git a/docs/source/examples/transformer_thermal_pathsim.ipynb b/docs/source/examples/transformer_thermal_pathsim.ipynb
index 4317e9b..323ea7b 100644
--- a/docs/source/examples/transformer_thermal_pathsim.ipynb
+++ b/docs/source/examples/transformer_thermal_pathsim.ipynb
@@ -178,7 +178,6 @@
     }
    ],
    "source": [
-    "T_AMBIENT = 25.0  # degC (the thermal network works with the rise above it)\n",
     "\n",
     "# thermal network: K/W and J/K\n",
     "THERMAL = dict(Rwc=7.0, Rca=5.5, Rwa=40.0, Cw=0.2, Cc=0.8)\n",