scikit-rf: S-parameter calculation incorrect for 3-port circuit

For $S_{ij}$ it should be remembered that it is a power divider. The remaining power that go through after the reflection is split according to the port’s impedances (e.g. if they are equal the power is split in equal parts).

$$ 1 = S_{ii}^2 + \sum_{j=1…n} S_{ij}^2 $$

The power that remains to be split is

$$ \sum_{j=1…n} S_{ij}^2 = 1 - S_{ii}^2 $$

Which is satisfied by

$$ S_{ij} = \frac{2\sqrt{Y_i \cdot Y_j}}{\sum_{k=1…n} Y_{k}} $$

The case of $S_{ii}$ is quite trivial, the port has a mismatch with the equivalent impedance of the other port in parallel, which is more easily computed in terms of admittance.

$$ S_{ii} = \frac{Y_i - \sum_{j\neq i} Y_j}{Y_i + \sum_{j\neq i} Y_j} = \frac{2Y_i}{\sum_{j=1…n} Y_j} - 1 $$

Which is coherent with rf.Circuit # formula (1)

Great! So it confirms that the equation (3) is incorrect in the generalized case of different impedances.

I was working in parallel on this too 😉 I made a new implementation of renormalize_s which reduces the numerical noise when renormalizing the S-param of a N-port junction. But it only supports power waves.

Non-efficient code:

def _Xk(self, cnx_k: list[tuple]) -> np.ndarray:
        """
        Return the scattering matrices [X]_k of the individual intersections k.

        Parameters
        ----------
        cnx_k : list of tuples
            each tuple contains (network, port)

        Returns
        -------
        Xs : :class:`numpy.ndarray`
            shape `f x n x n`
        """
        # Xnn = self._Xnn_k(cnx_k)  # shape: (nb_freq, nb_n)
        # Xmn = self._Xmn_k(cnx_k)  # shape: (nb_freq, nb_n)
        # # for loop version
        # Xs = []
        # for (_Xnn, _Xmn) in zip(Xnn, Xmn):  # for all frequencies
        #       # repeat Xmn along the lines
        #     _X = np.tile(_Xmn, (len(_Xmn), 1))
        #     _X[np.diag_indices(len(_Xmn))] = _Xnn
        #     Xs.append(_X)

        # return np.array(Xs) # shape : nb_freq, nb_n, nb_n

        # vectorized version
        # nb_n = Xnn.shape[1]
        # Xs = np.tile(Xmn, (nb_n, 1, 1)).swapaxes(1, 0)
        # Xs[:, np.arange(nb_n), np.arange(nb_n)] = Xnn

        # return Xs # shape : nb_freq, nb_n, nb_n

        # TEST : Could we use media.splitter() instead ? -> does not work
        # _media = media.DefinedGammaZ0(frequency=self.frequency)
        # Xs = _media.splitter(len(cnx_k), z0=self._cnx_z0(cnx_k))
        # return Xs.s
        n_port = len(cnx_k)
        s = np.zeros((self.frequency.npoints, n_port, n_port), dtype = complex)
        y_k = self._Y_k(cnx_k)
        # sii
        for i in range(n_port):
            (ntw_i, port_i) = cnx_k[i]
            s[:,i,i] = 2. / (ntw_i.z0[:,port_i] * y_k) - 1
            #sji
            for j in range(n_port):
                if j != i:
                    (ntw_j, port_j) = cnx_k[j]
                    y_eq = np.sqrt((1./ntw_i.z0[:,port_i]) \
                                   * (1./ntw_j.z0[:,port_j]))
                    s[:,j,i] = 2. *y_eq / y_k
                    s[:,i,j] = s[:,j,i]
        return s

Let’s take the 50 ohm 2-port splitter. It is lossless, reciprocal and matched. As a matter of fact, it is just a zero-length thru. The scattering parameters are:

$$ S = \begin{bmatrix} 0 & 1\ 1 & 0\ \end{bmatrix} $$

Which are normalized to the port impedance:

$$Z_1 = 50, Z_2 = 50$$

The impedance parameters do not need to normalize to a port impedance, we can convert to them like skrf.network.s2z. Behind the hood, when using renormalize_s, scikit-rf just do z2s(s2z()) with z_old and z_new.

$$ Z = \begin{bmatrix} \frac{1}{2\sqrt{|\Re(Z_1)|}} & 0 \ 0 & \frac{1}{2\sqrt{|\Re(Z_2)|}} \end{bmatrix}^{-1} \left(1 - S \right)^{-1} \left(S \begin{bmatrix}Z_1 & 0 \ 0 & Z_2 \end{bmatrix} + \begin{bmatrix}Z_1 & 0 \ 0 & Z_2 \end{bmatrix}^{*} \right) \begin{bmatrix} \frac{1}{2\sqrt{|\Re(Z_1)|}} & 0 \ 0 & \frac{1}{2\sqrt{|\Re(Z_2)|}} \end{bmatrix} $$

Which gives

$$ Z = \left(\left(\begin{bmatrix} 1 & 0 \ 0 & 1 \end{bmatrix} - \begin{bmatrix} 0 & 1 \ 1 & 0 \end{bmatrix} \right) \begin{bmatrix} 2\sqrt{50} & 0 \ 0 & 2\sqrt{50} \end{bmatrix}\right)^{-1} \left(\begin{bmatrix} 0 & 1 \ 1 & 0 \end{bmatrix} \begin{bmatrix}50 & 0 \ 0 & 50 \end{bmatrix} + \begin{bmatrix}50 & 0 \ 0 & 50 \end{bmatrix} \right) \begin{bmatrix} \frac{1}{2\sqrt{50}} & 0 \ 0 & \frac{1}{2\sqrt{50}} \end{bmatrix} $$

$$ Z = \begin{bmatrix} 2\sqrt{50} & -2\sqrt{50} \ -2\sqrt{50} & 2\sqrt{50} \end{bmatrix}^{-1} \begin{bmatrix} \frac{\sqrt{50}}{2} & \frac{\sqrt{50}}{2} \ \frac{\sqrt{50}}{2} &\frac{\sqrt{50}}{2} \end{bmatrix} $$

And here tadaaa, the left matrix is singular and cannot be inverted ! s2z will still return a result because this matrix is added a small offset by nudge to avoid singularity and gives a matrix with big numbers. Hence probably the loss of precision when using z2s on this result.

I think the z0_port=None provided a kind of backward compatibility. In #651 , a group of users who did electromagnetic simulations were interested in raw impedance. Most users however probably think in terms of 50-ohm measurements.

What is strange to me in the above example is that the transmission line networks are not renormalized when connected to the rf.Circuit.Port impedances. In ADS, the “port” component explicitly solves the impedance problem in S-Parameter simulations.

The issue that we mostly face in scikit-rf is that we want to plot a line network as if has been measured, without cascading explicitly with ports. This is not the case in this example with rf.Circuit.

There is two open questions: what should z0_port default be and why the above example does not renormalize when z0_port=None.