Example #1
0
def extract_rlcg_from_measurement(freq,
                                  length_m,
                                  abcd_pad_inv,
                                  abcd_meas,
                                  z0_probe=50,
                                  method="distributed",
                                  skip_deembed=False):
    # (freq, R, L, G, C) = extract_rlcg_from_measurement( freq, length_m, abcd_pad_inv, abcd_dut, z0_probe = 50, method="distributed")
    # if skip_deembed = True then abcd_pad_inv is not used -- just pass an empty array (or whatever)

    if not skip_deembed:
        (abcd_dut, Sri_dut, Sdb_dut,
         Sdeg_dut) = deembed_pads_from_measurement(abcd_pad_inv, abcd_meas,
                                                   z0_probe)
    else:
        Sri_dut = rfs.abcd2s(abcd_meas, z0_probe, z0_probe)
        (Sdb_dut, Sdeg_dut) = rfs.sri2sdb(Sri_dut)

    if method == "distributed":
        (freq, R, L, G, C, gamma, attenuation, losstan,
         Zc) = distributed_rlgc_from_sdb(length_m, freq, Sdb_dut, Sdeg_dut,
                                         z0_probe)
    elif method == "lumped":
        #		net_dut = rf.Network( f=freq*1e-9, s=Sri_dut, z0=z0_probe)
        #		(freq, R, L, G, C, Zdiff, Ycomm, net) = lumped_rlgc_from_Network(net_dut, z0_probe)
        print("ERROR: NOT IMPLEMENTED")
    else:
        print("ERROR: NOT IMPLEMENTED")

    return (freq, R, L, G, C)
Example #2
0
def deembed_pads_from_measurement(abcd_pad_inv, abcd_dut, z0_probe=50):
    # (abcd_dut_deembedded, Sri_dut, Sdb_dut, Sdeg_dut) = deembed_pads_from_measurement(abcd_pad_inv, abcd_dut, z0_probe = 50)

    num_freqs = len(abcd_dut)
    abcd_dut_deembedded = np.zeros((num_freqs, 2, 2), dtype=complex)
    Sri_dut_deembedded = np.zeros((num_freqs, 2, 2), dtype=complex)

    for idx, Pinv in enumerate(abcd_pad_inv):
        abcd_dut_deembedded_f = np.dot(Pinv, np.dot(abcd_dut[idx], Pinv))
        abcd_dut_deembedded[idx] = abcd_dut_deembedded_f

    Sri_dut_deembedded = rfs.abcd2s(abcd_dut_deembedded, z0_probe, z0_probe)
    (Sdb_dut_deembedded, Sdeg_dut_deembedded) = rfs.sri2sdb(Sri_dut_deembedded)
    #Sri_dut_deembedded[idx] = Sri_dut_deembedded_f

    #Sri_dut = abcd2s(abcd_dut, z0_probe, z0_probe)
    #(Sdb_dut, Sdeg_dut) = sri2sdb(Sri_dut)

    return (abcd_dut_deembedded, Sri_dut_deembedded, Sdb_dut_deembedded,
            Sdeg_dut_deembedded)
Example #3
0
def get_pad_abcd(pad_L_s2p_filename,
                 pad_2L_s2p_filename,
                 z0_probe=complex(50, 0)):

    (freq_L, Sdb_L, Sdeg_L) = rfs.get_sdb_from_vna_csv(pad_L_s2p_filename)
    (freq_2L, Sdb_2L, Sdeg_2L) = rfs.get_sdb_from_vna_csv(pad_2L_s2p_filename)

    # ABCD matrices
    S_L = rfs.sdb2sri(Sdb_L, Sdeg_L)
    S_2L = rfs.sdb2sri(Sdb_2L, Sdeg_2L)

    abcd_L = rfs.s2abcd(S_L, z0_probe)
    abcd_2L = rfs.s2abcd(S_2L, z0_probe)

    abcd_pad = np.zeros(np.shape(abcd_L),
                        dtype=complex)  # ABCD matrix structure for pad
    abcd_pad_inv = np.zeros(
        np.shape(abcd_L),
        dtype=complex)  # inverse abcd matrix structure for pad

    # iterating across each frequency point
    for idx, abcd_L_mat in enumerate(abcd_L):
        abcd_2L_mat = abcd_2L[idx]

        abcd_L_inv = la.inv(abcd_L_mat)
        abcd_P_squared = la.inv(
            np.dot(abcd_L_inv,
                   np.dot(abcd_2L_mat,
                          abcd_L_inv)))  # PP = ( ML^-1 * M2L * ML^-1 )^-1
        abcd_P = la.sqrtm(
            abcd_P_squared
        )  # ABCD matrix of the pad (single pad) for this frequency
        abcd_P_inv = la.inv(abcd_P)

        abcd_pad[idx] = abcd_P
        abcd_pad_inv[idx] = abcd_P_inv

    Sri_pad = rfs.abcd2s(abcd_pad, z0_probe, z0_probe)
    (Sdb_pad, Sdeg_pad) = rfs.sri2sdb(Sri_pad)

    return (freq_L, abcd_pad, abcd_pad_inv, Sri_pad, Sdb_pad, Sdeg_pad)