def setUp(self):
raise SkipTest()
self.n_ports = 2
self.wg = rf.RectangularWaveguide(rf.F(75,100,NPTS), a=100*rf.mil,z0=50)
wg = self.wg
self.Xf = wg.random(n_ports =2, name = 'Xf')
self.Yf = wg.random(n_ports =2, name='Yf')
ideals = [
wg.short(nports=2, name='short'),
wg.open(nports=2, name='open'),
wg.match(nports=2, name='load'),
wg.random(2,name='rand1'),
wg.random(2,name='rand2'),
]
measured = [ self.measure(k) for k in ideals]
self.cal = rf.TwelveTerm(
ideals = ideals,
measured = measured,
n_thrus=2,
)
def setUp(self):
self.n_ports = 2
wg= rf.wr10
wg.frequency = rf.F.from_f([100])
self.wg = wg
self.X = wg.random(n_ports =2, name = 'X')
self.Y = wg.random(n_ports =2, name='Y')
self.gamma_f = wg.random(n_ports =1, name='gamma_f')
self.gamma_r = wg.random(n_ports =1, name='gamma_r')
ideals = [
wg.short(nports=2, name='short'),
wg.open(nports=2, name='open'),
wg.match(nports=2, name='load'),
wg.thru(name='thru'),
]
measured = [ self.measure(k) for k in ideals]
self.cal = rf.TwelveTerm(
ideals = ideals,
measured = measured,
)
coefs = rf.calibration.convert_12term_2_8term(self.cal.coefs, redundant_k=1)
coefs = NetworkSet.from_s_dict(coefs,
frequency=self.cal.frequency).to_dict()
self.coefs= coefs
def setUp(self):
raise SkipTest()
self.n_ports = 2
self.wg = rf.RectangularWaveguide(rf.F(75,100,NPTS), a=100*rf.mil,z0=50)
wg= self.wg
self.X = wg.random(n_ports =2, name = 'X')
self.Y = wg.random(n_ports =2, name='Y')
ideals = [
wg.short(nports=2, name='short'),
wg.open(nports=2, name='open'),
wg.match(nports=2, name='load'),
wg.thru(name='thru'),
]
measured = [self.measure(k) for k in ideals]
cal1 = rf.TwelveTerm(
ideals = ideals,
measured = measured,
n_thrus=1,
)
#coefs = rf.convert_12term_2_8term(cal1.coefs)
#gamma_f = wg.load(coefs['forward switch term'])
gamma_f, gamma_r = (cal1.coefs_ntwks['forward switch term'],
cal1.coefs_ntwks['reverse switch term'])
self.cal = rf.EightTerm(
ideals = ideals,
measured = measured,
switch_terms = [gamma_f, gamma_r],
)
def setUp(self):
self.n_ports = 2
self.wg = WG
wg = self.wg
self.Xf = wg.random(n_ports=2, name='Xf')
self.Xr = wg.random(n_ports=2, name='Xr')
self.Yf = wg.random(n_ports=2, name='Yf')
self.Yr = wg.random(n_ports=2, name='Yr')
self.If = wg.random(n_ports=1, name='If')
self.Ir = wg.random(n_ports=1, name='Ir')
ideals = [
wg.short(nports=2, name='short'),
wg.open(nports=2, name='open'),
wg.match(nports=2, name='load'),
wg.random(2, name='rand1'),
wg.random(2, name='rand2'),
]
measured = [self.measure(k) for k in ideals]
self.cal = rf.TwelveTerm(ideals=ideals,
measured=measured,
n_thrus=2,
isolation=measured[2])
def cal_two_port(self):
dut = self.network
# Measured with VNA
meas_short = self.load("cal/cal_short")
meas_open = self.load("cal/cal_open")
meas_load = self.load("cal/cal_load")
meas_thru = rf.Network("cal/cal_thru.s2p")
if dut.f[-1] > meas_short.f[-1]:
dut.crop(meas_short.f[0], meas_short.f[-1])
frequency = dut.frequency
freqs = dut.f
meas_short = meas_short.interpolate(frequency)
meas_open = meas_open.interpolate(frequency)
meas_load = meas_load.interpolate(frequency)
meas_thru = meas_thru.interpolate(frequency)
meas_short_short = rf.two_port_reflect(meas_short, meas_short)
meas_open_open = rf.two_port_reflect(meas_open, meas_open)
meas_load_load = rf.two_port_reflect(meas_load, meas_load)
# Load cal kit files
cal_kit_short = self.load("data/cal_kit/cal_short_interp")
cal_kit_open = self.load("data/cal_kit/cal_open_interp")
cal_kit_load = self.load("data/cal_kit/cal_load_interp")
cal_kit_short_short = rf.two_port_reflect(cal_kit_short, cal_kit_short)
cal_kit_open_open = rf.two_port_reflect(cal_kit_open, cal_kit_open)
cal_kit_load_load = rf.two_port_reflect(cal_kit_load, cal_kit_load)
cal_kit_short_short = cal_kit_short_short.interpolate(frequency)
cal_kit_open_open = cal_kit_open_open.interpolate(frequency)
cal_kit_load_load = cal_kit_load_load.interpolate(frequency)
# Generate thru standard
through_delay = 51.1e-12
d = 2 * np.pi * through_delay
through_s = [[[0, np.exp(-1j * d * f)], [np.exp(-1j * d * f), 0]]
for f in freqs]
through_i = rf.Network(s=through_s, f=freqs, f_unit='Hz')
cal = rf.TwelveTerm(measured=[
meas_open_open, meas_short_short, meas_load_load, meas_thru
],
ideals=[
cal_kit_open_open, cal_kit_short_short,
cal_kit_load_load, through_i
],
n_thrus=1,
isolation=meas_load_load,
rcond=None)
cal.run()
self.network = cal.apply_cal(dut)
# rf.Network(LOAD_S22.as_posix()),
# rf.Network(THRU_S21.as_posix()),
# rf.Network(THRU_S12.as_posix()),
# ]
my_measured = [\
SHORT,
OPEN,
LOAD,
THRU
]
## create a Calibration instance
cal_TwelveTerm = rf.TwelveTerm(\
ideals = my_ideals,
measured = my_measured,
n_thrus = 1,
)
# run calibration algorithm
cal_TwelveTerm.run()
#%%
f_start = freq_low * 1E9
f_stop = freq_high * 1E9
f_npoints = n_freq
vna = PNA(address='TCPIP0::10.236.73.132::inst0::INSTR')
vna.reset()
vna.scpi.set_trigger_manual
# vna.scpi.set_delete_all()
# rf.Network(LOAD_S11.as_posix()),
# rf.Network(LOAD_S22.as_posix()),
# rf.Network(THRU_S21.as_posix()),
# rf.Network(THRU_S12.as_posix()),
# ]
my_measured = [\
SHORT,
OPEN,
LOAD,
THRU
]
## create a Calibration instance
cal = rf.TwelveTerm(\
ideals = my_ideals,
measured = my_measured,
)
# run calibration algorithm
cal.run()
#%%
# apply it to a dut
dut = THRU
dut.name = 'test'
dut_caled = cal.apply_cal(dut)
dut_caled.name = dut.name + 'corrected'
# plot results
dut_caled.frequency.unit = 'ghz'
# %matplotlib qt5
ll = cal.apply_cal(ll)
ss = cal.apply_cal(ss)
ls = cal.apply_cal(ls)
sl = cal.apply_cal(sl)
through = cal.apply_cal(through)
#plt.figure()
#cal.solved_through.plot_s_deg(m=1, n=0)
#cal.solved_reflect.plot_s_smith()
if 1:
if cal != None:
dut = cal.apply_cal(dut)
cal = skrf.TwelveTerm(\
measured = [os, so, ll, through],
ideals =[os_i, so_i, ll_i, through_i],
n_thrus = 1,
)
cal.run()
if 0:
cal = skrf.SixteenTerm(\
measured = [ss, os, so, ll, through],
ideals = [ss_i, os_i, so_i, ll_i, through_i],
)
cal.run()
coefs = cal.coefs
if 0:
cal = skrf.EightTerm(\
def main():
parser = argparse.ArgumentParser(
description='two port VNA calibration script.')
parser.add_argument('--solt',
action='store_true',
help='apply SOLT calibration')
parser.add_argument('--trl',
action='store_true',
help='apply TRL calibration')
parser.add_argument('filename', help='s2p file to process')
parser.add_argument('--title', default='$|S|$', help='plot title')
args = parser.parse_args()
cal = None
if args.solt:
# load cal measurements
cal_load = rf.Network('../cal_twoport/load.s2p')
cal_open = rf.Network('../cal_twoport/open.s2p')
cal_short = rf.Network('../cal_twoport/short.s2p')
cal_thru = rf.Network('../cal_twoport/thru.s2p')
cal_iso = rf.Network('../cal_twoport/isolation.s2p')
cal_sw_fwd = rf.Network('../cal_twoport/sw_fwd.s1p')
cal_sw_rev = rf.Network('../cal_twoport/sw_rev.s1p')
measured_cal = [cal_short, cal_open, cal_load, cal_thru]
# create ideal cal networks, SLOT calibration
ideal_cal = create_kirkby(
cal_thru.frequency) #create_sdrkits_ideal(cal_thru.frequency)
cal = rf.TwelveTerm(ideals=ideal_cal,
measured=measured_cal,
n_thrus=1,
isolation=cal_iso)
#cal = rf.EightTerm(ideals = ideal_cal, measured = measured_cal, switch_terms = (cal_sw_rev, cal_sw_fwd))
elif args.trl:
cal_reflect = rf.Network('../cal_twoport/trl_reflect.s2p')
cal_thru = rf.Network('../cal_twoport/trl_thru.s2p')
cal_line = rf.Network('../cal_twoport/trl_line.s2p')
cal_sw_fwd = rf.Network('../cal_twoport/trl_sw_fwd.s1p')
cal_sw_rev = rf.Network('../cal_twoport/trl_sw_rev.s1p')
measured_cal = [cal_thru, cal_reflect, cal_line]
media = rf.media.DefinedGammaZ0(cal_reflect.frequency, z0=50)
ideal_open = media.open(
) # TODO: simulate reflect to estimate ideal behavior.. openems?
ideal_cal = [None, ideal_open, None]
cal = rf.TRL(measured=measured_cal,
ideals=ideal_cal,
estimate_line=True,
switch_terms=(cal_sw_rev, cal_sw_fwd))
else:
print('no cal type selected..')
cal.run()
show()
subplot(2, 1, 1)
plot_s2p_file(args.filename, cal, show=False)
subplot(2, 1, 2)
plot_s2p_file(args.filename, cal, show=False, smith=True)
grid(True)
title(args.title)
show()
plot_coefs(cal, cal_line.f)
pdb.set_trace()
s_i = s_i.interpolate(frequency)
l_i = l_i.interpolate(frequency)
ll_i = skrf.two_port_reflect(l_i, l_i)
ss_i = skrf.two_port_reflect(s_i, s_i)
oo_i = skrf.two_port_reflect(o_i, o_i)
through_delay = 51.1e-12
d = 2 * np.pi * through_delay
through_s = [[[0, np.exp(-1j * d * f)], [np.exp(-1j * d * f), 0]]
for f in freqs]
through_i = skrf.Network(s=through_s, f=freqs, f_unit='Hz')
cal = skrf.TwelveTerm(\
measured = [oo, ss, ll, through],
ideals =[oo_i, ss_i, ll_i, through_i],
n_thrus = 1,
isolation=ll
)
cal.run()
if 0:
coefs = cal.coefs
for k in coefs.keys():
plt.figure()
plt.title(k)
plt.plot(freqs, 20 * np.log10(np.abs(coefs[k])))
plt.figure()
for net in sys.argv[1:]:
dut = skrf.Network(net)
dut = cal.apply_cal(dut)
