paramrf 0.28.2__tar.gz → 0.28.3__tar.gz

{paramrf-0.28.2/paramrf.egg-info → paramrf-0.28.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paramrf
-Version: 0.28.2
+Version: 0.28.3
 Summary: Parametric radio frequency modeling
 Author-email: Gary Allen <gvcallen@gmail.com>
 Project-URL: homepage, https://github.com/gvcallen/paramrf

{paramrf-0.28.2 → paramrf-0.28.3}/docs/skrf_comparison/index.rst

@@ -3,7 +3,7 @@ scikit-rf Comparison
 
 ParamRF aims to complement and not replace scikit-rf. While scikit-rf excels at static network manipulation, it does not take a parameter-first modeling approach, and also suffers from Python interpreter overhead and finite difference approximations which JAX eleviates.
 
-This section provides a brief comparison between the core philosophies of scikit-rf and ParamRF, and also demonstrates a short benchmarking scripting showing the performance benefits when using JAX.
+This section provides a brief comparison between the core philosophies of scikit-rf and ParamRF, and also demonstrates a short benchmarking script showing the performance benefits when using JAX.
 
 .. toctree::
    :maxdepth: 2

{paramrf-0.28.2 → paramrf-0.28.3}/docs/skrf_comparison/overview.rst

@@ -1,4 +1,4 @@
-scikit-rf Comparison
+Overview
 =====================
 **ParamRF** is designed to complement **scikit-rf** and not replace it, offering a fundamentally different approach to RF modeling. A very brief summary of the differences, strengths and weakness of the libraries is presented below.
 

{paramrf-0.28.2 → paramrf-0.28.3}/docs/skrf_comparison/performance.rst

@@ -181,18 +181,18 @@ Running this script on a standard modern CPU yields results similar to the follo
     =======================================================
     FORWARD PASS EXECUTION TIMES (2001 Points)
     =======================================================
-    scikit-rf (Baseline)           |   20.799 ms | 1.00x
+    scikit-rf (Baseline)           |   25.343 ms | 1.00x
     -------------------------------------------------------
-    ParamRF Scattering Solver      |    6.458 ms | 3.22x
-    ParamRF MNA Solver             |    3.139 ms | 6.63x
+    ParamRF Scattering Solver      |    4.823 ms | 5.25x
+    ParamRF MNA Solver             |    2.979 ms | 8.51x
     =======================================================
 
-By vectorizing the linear matrix solutions and bypassing the Python interpreter via JIT compilation, ParamRF's MNA solver evaluates nearly 7x faster 
+By vectorizing the linear matrix solutions and bypassing the Python interpreter via JIT compilation, ParamRF's MNA solver evaluates nearly 9x faster, while the scattering solver evaluates 5x faster (which is most similar to the scattering algorithm in scikit-rf's Circuit).
 
 The Autodiff Advantage
 ----------------------
-While a 6x speedup on the forward pass is significant, the true performance gain of ParamRF is realized during gradient-based optimization (the *backward pass*). 
+While a 5-10x speedup on the forward pass is significant, the true performance gain of ParamRF is realized during gradient-based optimization (the *backward pass*). 
 
-In traditional libraries, calculating the gradient for an $N$-parameter circuit requires Finite Differences (FD), meaning the circuit must be simulated $N+1$ times per iteration. For a 50-parameter model, this means a single gradient step in ``scikit-rf`` would take over **1.3 seconds** (``51 * 26.7 ms``). 
+In traditional libraries, calculating the gradient for an $N$-parameter circuit requires Finite Differences (FD), meaning the circuit must be simulated $N+1$ times per iteration. For a 50-parameter model, this means a single gradient step in ``scikit-rf`` would take **1.3 seconds** (``51 * 25.3 ms``). 
 
-In ParamRF, because the entire circuit math is traced, calling ``jax.value_and_grad`` yields the exact analytic gradients for all 50 parameters simultaneously in a single, compiled backward pass—often executing in **less than 15 ms**. This results in a massive speedup (often 40x to 100x) when optimizing complex circuits.
+In ParamRF, because the entire circuit math is traced, calling ``jax.value_and_grad`` yields the exact analytic gradients for all 50 parameters simultaneously in a single, compiled backward pass—often executing in **less than 10 ms**. This results in a massive speedup (often 40x to 100x) when optimizing complex circuits.

{paramrf-0.28.2 → paramrf-0.28.3/paramrf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paramrf
-Version: 0.28.2
+Version: 0.28.3
 Summary: Parametric radio frequency modeling
 Author-email: Gary Allen <gvcallen@gmail.com>
 Project-URL: homepage, https://github.com/gvcallen/paramrf

{paramrf-0.28.2 → paramrf-0.28.3}/paramrf.egg-info/SOURCES.txt

@@ -13,7 +13,6 @@ docs/conf.py
 docs/index.rst
 docs/license.rst
 docs/make.bat
-docs/skrf_comparison.rst
 docs/_static/custom.css
 docs/_templates/autosummary/class.rst
 docs/_templates/autosummary/function.rst

{paramrf-0.28.2 → paramrf-0.28.3}/pmrf/models/components/ideal.py

@@ -104,7 +104,10 @@ class Port(Model):
     """
     Represents a circuit port with a specific characteristic impedance.
     
-    This class serves as a placeholder or marker for external connections in a :class:`pmrf.models.Circuit` definition.
+    This class serves as a placeholder or marker for external connections
+    in a :class:`pmrf.models.Circuit` definition, though can also be used
+    as a simple tagged load in other types of models.
+    
     Calling `build` returns a matched load model.
     """
     #: Port characteristic impedance

{paramrf-0.28.2 → paramrf-0.28.3}/pmrf/models/composite/interconnected/circuit/base.py

@@ -69,25 +69,19 @@ class MNARepresentation(eqx.Module):
     def num_aux(self) -> int:
         """The total number of global auxiliary variables."""
         return self.aux_idx.shape[0]
-
-
+ 
+    
 class PortRepresentation(eqx.Module):
-    """
-    Static topological representation for scattering parameter connection and reduction.
-    """
-    #: A 1D array of port indices designated as external (unconnected or specifically retained).
-    ext_idx: np.ndarray
-
-    #: A 1D array of port indices designated as internal (connected to other ports).
-    int_idx: np.ndarray
-
-    #: A 1D array of length `num_ports` mapping each port to the integer ID of its connected net.
+    #: Array mapping each active device port to a net ID
     port_to_net_map: np.ndarray
 
+    #: Ordered array of net IDs that act as external ports
+    ext_net_ids: np.ndarray
+
     @property
     def num_ports(self) -> int:
         """The total number of ports across all components in the topology."""
-        return self.port_to_net_map.shape[0]    
+        return self.port_to_net_map.shape[0]        
 
 
 class ScatteringResult(eqx.Module):

{paramrf-0.28.2 → paramrf-0.28.3}/pmrf/models/composite/interconnected/circuit/circuit.py

@@ -14,7 +14,7 @@ from pmrf.frequency import Frequency
 from collections import defaultdict
 from pmrf.utils import field
 from pmrf.types import ArrayLike
-from pmrf.rf import y2s, s2y
+from pmrf.rf import y2s, s2y, renormalize_s
 
 from pmrf.models.composite.interconnected.circuit.base import (
     AbstractCircuitSolver,
@@ -175,72 +175,77 @@ class Circuit(Model):
     @cached_property
     def port_representation(self) -> PortRepresentation:
         """Generates the static topological map for scattering connection and reduction."""
-        port_to_net_map = compute_unique_nets(self.circuit, self.indexed_connections)
+        global_net_map = compute_unique_nets(self.circuit, self.indexed_connections)
 
-        ext_idx, int_idx = [], []
+        ext_net_ids = []
+        
         offset = 0
         for model in self.circuit:
-            for p in range(model.nports):
-                if isinstance(model, Port):
-                    ext_idx.append(offset + p)
-                else:
-                    int_idx.append(offset + p)
+            if isinstance(model, Port):
+                ext_net_ids.append(global_net_map[offset])
             offset += model.nports
 
+        active_net_map = []
+        offset = 0
+        for model in self.circuit:
+            n = model.nports
+            if not isinstance(model, Port):
+                active_net_map.extend(global_net_map[offset : offset + n])
+            offset += n
+
         return PortRepresentation(
-            ext_idx=np.array(ext_idx, dtype=int),
-            int_idx=np.array(int_idx, dtype=int),
-            port_to_net_map=port_to_net_map
+            ext_net_ids=np.array(ext_net_ids, dtype=int),
+            port_to_net_map=np.array(active_net_map, dtype=int)
         )
         
     @cached_property
     def nodal_representation(self) -> NodalRepresentation:
         """Generates the static topological map for nodal admittance assembly and reduction."""
-        port_rep = self.port_representation
-        port_to_net_map = port_rep.port_to_net_map
+        global_net_map = compute_unique_nets(self.circuit, self.indexed_connections)
         
-        r_idx, c_idx = [], []
-        offset = 0
-        for model in self.circuit:
-            n = model.nports
-            nets = port_to_net_map[offset:offset+n]
-            R, C = np.meshgrid(nets, nets, indexing='ij')
-            r_idx.append(R.flatten())
-            c_idx.append(C.flatten())
-            offset += n
-            
-        unique_ext_nets = np.unique(port_to_net_map[port_rep.ext_idx])
-        unique_int_nets = np.setdiff1d(np.unique(port_to_net_map), unique_ext_nets)
-
-        # Drop ground nodes
         ground_nets = set()
+        ext_nets = set()
         offset = 0
         for model in self.circuit:
+            nets = global_net_map[offset : offset + model.nports]
             if isinstance(model, Ground):
-                ground_nets.update(port_to_net_map[offset:offset+model.nports])
+                ground_nets.update(nets)
+            elif isinstance(model, Port):
+                ext_nets.update(nets)
             offset += model.nports
             
-        unique_all_nets = np.unique(port_to_net_map)
+        unique_all_nets = np.unique(global_net_map)
         active_nets = np.array([n for n in unique_all_nets if n not in ground_nets], dtype=int)
         
-        # Create mapping: active nodes -> 0..N-1. Ground nodes -> N (to be safely dropped)
         N_active = len(active_nets)
         mapping = np.full(np.max(unique_all_nets) + 1, N_active, dtype=int)
         mapping[active_nets] = np.arange(N_active)
         
-        # Remap local rows/cols
-        r_idx_mapped = mapping[np.concatenate(r_idx).astype(int)]
-        c_idx_mapped = mapping[np.concatenate(c_idx).astype(int)]
+        r_idx, c_idx = [], []
+        offset = 0
+        for model in self.circuit:
+            n = model.nports
+            if not isinstance(model, (Port, Ground)):
+                nets = global_net_map[offset : offset + n]
+                R, C = np.meshgrid(nets, nets, indexing='ij')
+                r_idx.append(R.flatten())
+                c_idx.append(C.flatten())
+            offset += n
+            
+        def _safe_cat(lst):
+            return np.concatenate(lst).astype(int) if lst else np.array([], dtype=int)
+            
+        r_idx_mapped = mapping[_safe_cat(r_idx)]
+        c_idx_mapped = mapping[_safe_cat(c_idx)]
         
-        unique_ext_nets = np.unique(port_to_net_map[port_rep.ext_idx])
-        ext_active = np.array([n for n in unique_ext_nets if n not in ground_nets], dtype=int)
+        ext_active = np.array([n for n in ext_nets if n not in ground_nets], dtype=int)
         int_active = np.setdiff1d(active_nets, ext_active)
 
         return NodalRepresentation(
             r_idx=r_idx_mapped,
             c_idx=c_idx_mapped,
-            ext_idx=mapping[ext_active],   # mapped external indices
-            int_idx=mapping[int_active]    # mapped internal indices
+            ext_idx=mapping[ext_active],
+            int_idx=mapping[int_active]
         )
 
     @property
@@ -257,7 +262,8 @@ class Circuit(Model):
         offset_y = 0  # Tracks the index in the flattened n*n nodal arrays
         freq_dummy = Frequency(1, 2, 2)
         
-        for model in self.circuit:
+        nodal_components = [m for m in self.circuit if not isinstance(m, (Port, Ground))]
+        for model in nodal_components:
             stamp_shape = jax.eval_shape(lambda m=model: m.mna(freq_dummy))
             k = stamp_shape.D.shape[1]
             n = model.nports
@@ -301,47 +307,50 @@ class Circuit(Model):
 
     # --- DATA EVALUATION ---
 
-    def _evaluate_scattering(self, freq: Frequency, z0: ArrayLike = 50.0) -> tuple[jnp.ndarray, jnp.ndarray]:
+    def _evaluate_scattering(self, freq: Frequency, z0: ArrayLike = 50.0) -> tuple[jnp.ndarray, jnp.ndarray, jnp.ndarray]:
         """Evaluates and block-diagonalizes the scattering matrices of all contained components."""
-        S_blocks = [c.s(freq, z0=z0) for c in self.circuit] 
+        scattering_components = [c for c in self.circuit if not isinstance(c, Port)]
+        S_blocks = [c.s(freq, z0=z0) for c in scattering_components] 
         
-        batched_S = jax.vmap(block_diag)(*S_blocks)
+        if S_blocks:
+            batched_S = jax.vmap(block_diag)(*S_blocks)
+        else:
+            batched_S = jnp.zeros((freq.npoints, 0, 0), dtype=jnp.complex128)
+            
         num_ports = batched_S.shape[-1]
         dtype = batched_S.dtype
         z0_ports = jnp.broadcast_to(jnp.asarray(z0, dtype=dtype), (num_ports,))
 
-        return batched_S, z0_ports
+        # Dynamically extract the specific z0 constraints of the external ports
+        ext_z0_list = [jnp.asarray(getattr(c, 'z0', EVAL_Z0), dtype=dtype) for c in self.circuit if isinstance(c, Port)]
+        z0_ext = jnp.stack(ext_z0_list) if ext_z0_list else jnp.zeros((0,), dtype=dtype)
+
+        return batched_S, z0_ports, z0_ext
 
     def _evaluate_admittance(self, freq: Frequency) -> jnp.ndarray:
         """Evaluates and flattens the admittance matrices of all contained components."""
-        Y_blocks = []
-        for c in self.circuit:
-            if isinstance(c, Port):
-                Y_blocks.append(jnp.zeros((freq.npoints, c.nports, c.nports), dtype=jnp.complex128))
-            else:
-                Y_blocks.append(c.y(freq))
-                
+        nodal_components = [c for c in self.circuit if not isinstance(c, (Port, Ground))]
+        Y_blocks = [c.y(freq) for c in nodal_components]
+            
         flat_Y_list = []
         for Y in Y_blocks:
             Nf, n, _ = Y.shape
             flat_Y_list.append(Y.reshape(Nf, n * n))
-        return jnp.concatenate(flat_Y_list, axis=1)
+            
+        if flat_Y_list:
+            return jnp.concatenate(flat_Y_list, axis=1)
+        else:
+            return jnp.zeros((freq.npoints, 0), dtype=jnp.complex128)
 
     def _evaluate_mna(self, freq: Frequency) -> tuple[jnp.ndarray, jnp.ndarray, jnp.ndarray, jnp.ndarray]:
         """Evaluates and flattens the MNA stamps of all contained components."""
         flat_Y, flat_B, flat_C, flat_D = [], [], [], []
         
-        for c in self.circuit:
+        nodal_components = [c for c in self.circuit if not isinstance(c, (Port, Ground))]
+        for c in nodal_components:
             stamp = c.mna(freq)
-            # FIX: Zero out virtual topological markers (Ports)
-            if isinstance(c, Port):
-                Y = jnp.zeros_like(stamp.Y)
-                B = jnp.zeros_like(stamp.B)
-                C = jnp.zeros_like(stamp.C)
-                D = jnp.zeros_like(stamp.D)
-            else:
-                Y, B, C, D = stamp.Y, stamp.B, stamp.C, stamp.D
-                
+            Y, B, C, D = stamp.Y, stamp.B, stamp.C, stamp.D
+            
             Nf, n, _ = Y.shape
             k = D.shape[1]
             
@@ -366,9 +375,9 @@ class Circuit(Model):
             flat = self
         
         if isinstance(flat.solver, AbstractScatteringCircuitSolver):
-            s_bdiag, z0_ports = flat._evaluate_scattering(freq, z0)
-            run_vmap = jax.vmap(flat.solver.run, in_axes=(0, None, None))
-            return run_vmap(s_bdiag, z0_ports, flat.port_representation)
+            s_bdiag, z0_ports, z0_ext = flat._evaluate_scattering(freq, z0)
+            run_vmap = jax.vmap(flat.solver.run, in_axes=(0, None, None, None))
+            return run_vmap(s_bdiag, z0_ports, z0_ext, flat.port_representation)
             
         elif isinstance(flat.solver, AbstractAdmittanceCircuitSolver):
             y_flat = flat._evaluate_admittance(freq)
@@ -386,8 +395,10 @@ class Circuit(Model):
     def s(self, freq: Frequency, z0: ArrayLike = 50.0) -> jnp.ndarray:
         """Evaluates the composite scattering parameters of the circuit."""
         result = self._solve(freq, z0)
+        
         if isinstance(result, ScatteringResult):
-            return result.s
+            # Renormalize from native port z0 to the requested measurement z0
+            return renormalize_s(result.s, z_old=result.z0, z_new=z0)
         elif isinstance(result, AdmittanceResult):
             return y2s(result.y, z0=z0)
         else:

{paramrf-0.28.2 → paramrf-0.28.3}/pmrf/models/composite/interconnected/circuit/solvers/scattering.py

@@ -15,7 +15,6 @@ from pmrf.models.composite.interconnected.circuit.base import (
 
 from pmrf.rf.conversions import s2s
 
-
 class GlobalScatteringCircuitSolver(AbstractScatteringCircuitSolver):
     """
     Global S-parameter reduction solver.
@@ -32,30 +31,32 @@ class GlobalScatteringCircuitSolver(AbstractScatteringCircuitSolver):
     linear_solver: lx.AbstractLinearSolver = eqx.field(
         default=lx.AutoLinearSolver(well_posed=None), static=True
     )
-
-    def run(
-        self, 
-        s_block_diagonal: jax.Array, 
-        z0_ports: jax.Array, 
-        topology: PortRepresentation, 
-    ) -> ScatteringResult:
+    
+    def run(self, s_block_diagonal: jax.Array, z0_ports: jax.Array, z0_ext: jax.Array, topology: PortRepresentation) -> ScatteringResult:
+        N_act = s_block_diagonal.shape[-1]
+        N_ext = len(topology.ext_net_ids)
         
-        s_bd, z0, ext_idx_np, int_idx_np, net_map_np = inject_virtual_probes(
-            s_block_diagonal, z0_ports, 
-            np.array(topology.ext_idx), 
-            np.array(topology.int_idx), 
-            np.array(topology.port_to_net_map)
-        )
-
-        S_trav = s2s(s_bd, z0, 'traveling', 'power')
-        X = build_connection_matrix(net_map_np, z0, S_trav.dtype)
+        # Statically inject the VNA probes (S=0)
+        pad_width = ((0, N_ext), (0, N_ext))
+        s_bd = jnp.pad(s_block_diagonal, pad_width, mode='constant')
         
-        T = jnp.eye(net_map_np.shape[0], dtype=S_trav.dtype) - S_trav @ X
+        z0 = jnp.concatenate([z0_ports, z0_ext])
         
-        S_ext_trav = reduce_to_external(T, X, jnp.array(ext_idx_np), self.eps, self.linear_solver)
+        # Wire the active topology and the VNA probes together
+        # The active ports use port_to_net_map. The VNA probes connect to ext_net_ids.
+        net_map = jnp.concatenate([topology.port_to_net_map, topology.ext_net_ids])
         
-        z0_ext = z0[ext_idx_np]
-        return ScatteringResult(s=s2s(S_ext_trav, z0_ext, 'power', 'traveling'), z0=z0_ext)
+        # The external indices are simply the newly added probes at the end of the array
+        ext_idx = jnp.arange(N_act, N_act + N_ext)
+        
+        # Standard Hallbjörner generalized wave reduction
+        S_trav = s2s(s_bd, z0, 'traveling', 'power')
+        X = build_connection_matrix(net_map, z0, S_trav.dtype)
+        T = jnp.eye(net_map.shape[0], dtype=S_trav.dtype) - S_trav @ X
+        
+        S_ext_trav = reduce_to_external(T, X, ext_idx, self.eps, self.linear_solver)
+        
+        return ScatteringResult(s=s2s(S_ext_trav, z0_ext, 'power', 'traveling'), z0=z0_ext)    
 
 
 class HierarchicalScatteringCircuitSolver(AbstractScatteringCircuitSolver):
@@ -79,18 +80,26 @@ class HierarchicalScatteringCircuitSolver(AbstractScatteringCircuitSolver):
         self, 
         s_block_diagonal: jax.Array, 
         z0_ports: jax.Array, 
+        z0_ext: jax.Array,
         topology: PortRepresentation, 
     ) -> ScatteringResult:
         
-        s_bd, z0, ext_idx_np, _, net_map_np = inject_virtual_probes(
-            s_block_diagonal, z0_ports, 
-            np.array(topology.ext_idx), 
-            np.array(topology.int_idx), 
-            np.array(topology.port_to_net_map)
-        )
+        N_act = s_block_diagonal.shape[-1]
+        N_ext = len(topology.ext_net_ids)
+        
+        # Statically inject the VNA probes (S=0)
+        pad_width = ((0, N_ext), (0, N_ext))
+        s_bd = jnp.pad(s_block_diagonal, pad_width, mode='constant')
+        
+        z0 = jnp.concatenate([z0_ports, z0_ext])
+        
+        # Wire the active topology and the VNA probes together
+        net_map_np = np.concatenate([topology.port_to_net_map, topology.ext_net_ids])
+        ext_idx_np = np.arange(N_act, N_act + N_ext)
         
+        # Map the nets
         all_net_ids = np.unique(net_map_np)
-        ext_net_ids = np.unique(net_map_np[ext_idx_np])
+        ext_net_ids = np.unique(topology.ext_net_ids)
         pure_int_net_ids = np.setdiff1d(all_net_ids, ext_net_ids)
 
         S = s2s(s_bd, z0, 'traveling', 'power')
@@ -129,7 +138,6 @@ class HierarchicalScatteringCircuitSolver(AbstractScatteringCircuitSolver):
         
         S_ext_trav = reduce_to_external(T, X, jnp.array(ext_idx_np), self.eps, self.linear_solver)
         
-        z0_ext = z0[ext_idx_np]
         return ScatteringResult(s=s2s(S_ext_trav, z0_ext, 'power', 'traveling'), z0=z0_ext)
 
 
@@ -145,7 +153,6 @@ class SequentialScatteringCircuitSolver(AbstractScatteringCircuitSolver):
 
     Best suited for long chain-like/separated networks,
     though consider using an explicit Cascade if possible.
-    
     """
     eps: float = eqx.field(default=1e-12, static=True)
     linear_solver: lx.AbstractLinearSolver = eqx.field(
@@ -156,21 +163,28 @@ class SequentialScatteringCircuitSolver(AbstractScatteringCircuitSolver):
         self, 
         s_block_diagonal: jax.Array, 
         z0_ports: jax.Array, 
+        z0_ext: jax.Array,
         topology: PortRepresentation, 
     ) -> ScatteringResult:
         
-        s_bd, z0, ext_idx_np, _, net_map_np = inject_virtual_probes(
-            s_block_diagonal, z0_ports, 
-            np.array(topology.ext_idx), 
-            np.array(topology.int_idx), 
-            np.array(topology.port_to_net_map)
-        )
+        N_act = s_block_diagonal.shape[-1]
+        N_ext = len(topology.ext_net_ids)
+        
+        # Statically inject the VNA probes (S=0)
+        pad_width = ((0, N_ext), (0, N_ext))
+        s_bd = jnp.pad(s_block_diagonal, pad_width, mode='constant')
+        
+        z0 = jnp.concatenate([z0_ports, z0_ext])
+        
+        # Wire the active topology and the VNA probes together
+        net_map_np = np.concatenate([topology.port_to_net_map, topology.ext_net_ids])
+        ext_idx_np = np.arange(N_act, N_act + N_ext)
         
         S = s2s(s_bd, z0, 'traveling', 'power')
         active_ports = list(range(S.shape[-1]))
         
         all_net_ids = np.unique(net_map_np)
-        ext_net_ids = np.unique(net_map_np[ext_idx_np])
+        ext_net_ids = np.unique(topology.ext_net_ids)
         pure_int_net_ids = np.setdiff1d(all_net_ids, ext_net_ids)
         
         # Sequentially contract purely internal nets
@@ -222,39 +236,7 @@ class SequentialScatteringCircuitSolver(AbstractScatteringCircuitSolver):
         
         S_ext_trav = reduce_to_external(T, X, local_ext_idx, self.eps, self.linear_solver)
         
-        z0_ext = z0[ext_idx_np]
         return ScatteringResult(s=s2s(S_ext_trav, z0_ext, 'power', 'traveling'), z0=z0_ext)
-    
-
-def inject_virtual_probes(
-    s_block_diagonal: jax.Array, 
-    z0_ports: jax.Array, 
-    ext_idx: np.ndarray, 
-    int_idx: np.ndarray, 
-    net_map: np.ndarray
-) -> Tuple[jax.Array, jax.Array, np.ndarray, np.ndarray, np.ndarray]:
-    """Handles dangling external ports by injecting virtual matched probes."""
-    net_counts = np.bincount(net_map)
-    ext_net_counts = net_counts[net_map[ext_idx]]
-    
-    dangling_mask = ext_net_counts == 1
-    num_dangling = np.sum(dangling_mask)
-    
-    if num_dangling > 0:
-        N_orig = s_block_diagonal.shape[-1]
-        pad_width = ((0, num_dangling), (0, num_dangling))
-        s_block_diagonal = jnp.pad(s_block_diagonal, pad_width, mode='constant')
-        
-        dangling_ext_indices = ext_idx[dangling_mask]
-        z0_new = z0_ports[dangling_ext_indices]
-        z0_ports = jnp.concatenate([z0_ports, z0_new])
-        
-        new_port_indices = np.arange(N_orig, N_orig + num_dangling)
-        net_map = np.concatenate([net_map, net_map[dangling_ext_indices]])
-        int_idx = np.concatenate([int_idx, dangling_ext_indices])
-        ext_idx[dangling_mask] = new_port_indices
-        
-    return s_block_diagonal, z0_ports, ext_idx, int_idx, net_map
 
 
 def build_connection_matrix(

{paramrf-0.28.2 → paramrf-0.28.3}/pmrf/rf/conversions.py

@@ -722,13 +722,14 @@ def a2mna(a: ArrayLike) -> MNAStamp:
     else:
         raise ValueError(f"ABCD parameters must be 2D or 3D. Got {a_arr.ndim}D.")
 
-def s2mna(s: ArrayLike, z0: ArrayLike) -> MNAStamp:
+def s2mna(s: ArrayLike, z0: ArrayLike, s_def: str = 'power') -> MNAStamp:
     """
     Convert S-parameters to a Modified Nodal Analysis (MNA) stamp.
     
-    This formulation maps the incident voltage waves as the auxiliary 
+    This formulation maps the incident waves as the auxiliary 
     variables, allowing raw S-parameters to be stamped directly into 
-    the MNA system without any matrix inversions.
+    the MNA system without any matrix inversions. Natively supports both
+    traveling and power wave definitions.
     
     Parameters
     ----------
@@ -737,6 +738,9 @@ def s2mna(s: ArrayLike, z0: ArrayLike) -> MNAStamp:
     z0 : ArrayLike
         The characteristic impedance. Can be a scalar or an array broadcastable
         to `(nports,)` or `(nfreqs, nports)`.
+    s_def : str, optional
+        The wave definition used for the S-parameters. Options are 'traveling' 
+        (pseudo-voltage) or 'power' (Kurokawa). Default is 'traveling'.
         
     Returns
     -------
@@ -748,22 +752,29 @@ def s2mna(s: ArrayLike, z0: ArrayLike) -> MNAStamp:
     if s_arr.ndim == 3:
         nfreqs, nports, _ = s_arr.shape
         z0_fixed = fix_z0_shape(z0, nfreqs, nports)
-        return jax.vmap(s2mna, in_axes=(0, 0))(s_arr, z0_fixed)
+        return jax.vmap(s2mna, in_axes=(0, 0, None))(s_arr, z0_fixed, s_def)
+        
     elif s_arr.ndim == 2:
         nports = s_arr.shape[0]
         z0_arr = fix_z0_shape(z0, 1, nports)[0]
         
-        # Calculate Y0 and expand dims to broadcast across the columns of (I - S)
-        y0 = 1.0 / z0_arr
-        y0 = jnp.expand_dims(y0, axis=-1) 
-        
         I = jnp.eye(nports, dtype=s_arr.dtype)
-        
-        # Universal S-parameter MNA derivation
         Y = jnp.zeros_like(s_arr)
-        B = y0 * (I - s_arr)
         C = I
-        D = -(I + s_arr)
+        
+        if s_def.lower() == 'traveling':
+            pre_B = jnp.expand_dims(1.0 / z0_arr, axis=-1)
+            pre_D = 1.0
+            
+        elif s_def.lower() == 'power':
+            pre_B = jnp.expand_dims(1.0 / jnp.sqrt(z0_arr), axis=-1)
+            pre_D = jnp.expand_dims(jnp.sqrt(z0_arr), axis=-1)
+            
+        else:
+            raise ValueError(f"s_def must be 'traveling' or 'power'. Got: '{s_def}'")
+        
+        B = pre_B * (I - s_arr)
+        D = -(pre_D * (I + s_arr))
         
         return MNAStamp(Y=Y, B=B, C=C, D=D)
     else:

{paramrf-0.28.2 → paramrf-0.28.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "paramrf"
-version = "0.28.2"
+version = "0.28.3"
 description = "Parametric radio frequency modeling"
 readme = "README.rst"
 authors = [