def cal_one_port(self):
dut = self.network
# Load recently measured files
meas_short = self.load("cal/cal_short")
meas_open = self.load("cal/cal_open")
meas_load = self.load("cal/cal_load")
if dut.f[-1] > meas_short.f[-1]:
dut.crop(meas_short.f[0], meas_short.f[-1])
frequency = dut.frequency
meas_short = meas_short.interpolate(frequency)
meas_open = meas_open.interpolate(frequency)
meas_load = meas_load.interpolate(frequency)
# 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 = cal_kit_short.interpolate(frequency)
cal_kit_open = cal_kit_open.interpolate(frequency)
cal_kit_load = cal_kit_load.interpolate(frequency)
cal = rf.OnePort(ideals=[cal_kit_open, cal_kit_short, cal_kit_load],
measured=[meas_open, meas_short, meas_load],
rcond=None)
cal.run()
self.network = cal.apply_cal(dut)
def slot_calibrate_twoport(self, fstart, fstop, points):
sweep_freqs = np.linspace(fstart, fstop, points) / 1e9
cal_kit = self.generate_sdrkits_cal_standard(sweep_freqs)
raw_input("connect short to port 1, then press enter to continue")
self.cal_short_p1 = self.sweep(fstart, fstop, points)
raw_input("connect load to port 1, then press enter to continue")
self.cal_load_p1 = self.sweep(fstart, fstop, points)
raw_input("connect open to port 1, then press enter to continue")
self.cal_open_p1 = self.sweep(fstart, fstop, points)
raw_input("connect short to port 2, then press enter to continue")
self.cal_short_p2 = self.sweep(fstart, fstop, points)
raw_input("connect load to port 2, then press enter to continue")
self.cal_load_p2 = self.sweep(fstart, fstop, points)
raw_input("connect open to port 2, then press enter to continue")
self.cal_open_p2 = self.sweep(fstart, fstop, points)
raw_input("connect thru, then press enter to continue")
self.cal_thru = self.sweep(fstart, fstop, points)
print('todo: finish writing two port calibration')
pdb.set_trace()
self.cal_twoport = rf.OnePort(\
ideals = cal_kit,\
measured = [self.cal_short, self.cal_open, self.cal_load])
self.cal_twoport.run()
def btn_coax_run(self):
# SHORT
if self.APP['coax_short_ideal']:
self.DATA['coax_short_ch'] = rf.Network(
frequency=self.DATA['coax_short_m'].frequency,
s=[
-1
for x in range(self.DATA['coax_short_m'].frequency.npoints)
],
z0=50,
name='coax_short_ch')
else:
self.DATA['coax_short_ch'] = self.DATA[
'coax_short_ch'].interpolate_from_f(
self.DATA['coax_short_m'].frequency)
# OPEN
if self.APP['coax_open_ideal']:
self.DATA['coax_open_ch'] = rf.Network(
frequency=self.DATA['coax_open_m'].frequency,
s=[
1
for x in range(self.DATA['coax_open_m'].frequency.npoints)
],
z0=50,
name='coax_open_ch')
else:
self.DATA['coax_open_ch'] = self.DATA[
'coax_open_ch'].interpolate_from_f(
self.DATA['coax_short_m'].frequency)
# LOAD
if self.APP['coax_load_ideal']:
self.DATA['coax_load_ch'] = rf.Network(
frequency=self.DATA['coax_load_m'].frequency,
s=[
0
for x in range(self.DATA['coax_load_m'].frequency.npoints)
],
z0=50,
name='coax_load_ch')
else:
self.DATA['coax_load_ch'] = self.DATA[
'coax_load_ch'].interpolate_from_f(
self.DATA['coax_short_m'].frequency)
self.DATA['coax_cal'] = rf.OnePort(ideals=[
self.DATA['coax_short_ch'], self.DATA['coax_open_ch'],
self.DATA['coax_load_ch']
],
measured=[
self.DATA['coax_short_m'],
self.DATA['coax_open_m'],
self.DATA['coax_load_m']
])
self.DATA['coax_cal'].run()
self.ui.frameSOL.setEnabled(False)
self.ui.btn_coax_run.setStyleSheet(self.style_btn_set)
self.ui.btn_coax_run.setEnabled(False)
self.ui.btn_coax_clear.setEnabled(True)
self.clear_plot()
def slot_calibrate_oneport(self, fstart, fstop, points):
sweep_freqs = np.linspace(fstart, fstop, points) / 1e9
cal_kit = self.sdrkits_cal_oneport(sweep_freqs)
raw_input("connect short, then press enter to continue")
self.cal_short = self.sweep(fstart, fstop, points)
raw_input("connect load, then press enter to continue")
self.cal_load = self.sweep(fstart, fstop, points)
raw_input("connect open, then press enter to continue")
self.cal_open = self.sweep(fstart, fstop, points)
self.cal_oneport = rf.OnePort(\
ideals = cal_kit,\
measured = [self.cal_short, self.cal_open, self.cal_load])
self.cal_oneport.run()
def take_simple_cal(self, load=False):
self.esp.position = 0
time.sleep(1)
'''
get networks
'''
meas = {}
for x in range(0, 6):
name = 'ds,' + str(x)
self.esp.position = -0.04 * x
time.sleep(1)
n = self.zva.get_network(name=name)
meas[name] = n
'''
get perfect load
'''
if load:
name = 'pl'
self.esp.position = 0
time.sleep(8)
n = self.zva.get_network(name=name)
meas[name] = n
delta = 40
freq = meas.values()[0].frequency
air = Freespace(frequency=freq, z0=50)
si = Freespace(frequency=freq, ep_r=11.7, z0=50)
if load:
ideals = [
air.delay_short(k * delta, 'um', name='ds,%i' % k)
for k in range(6)
] + [air.match(name='pl')]
else:
ideals = [
air.delay_short(k * delta, 'um', name='ds,%i' % k)
for k in range(6)
] #**si.delay_short(350,'um')
cal_q = rf.OnePort(measured=meas,
ideals=ideals,
sloppy_input=True,
is_reciprocal=False)
self.esp.position = 0
cal_q.plot_caled_ntwks(ls='', marker='.')
return cal_q
def setUp(self):
self.n_ports = 1
self.wg = rf.RectangularWaveguide(rf.F(75,100,NPTS), a=100*rf.mil,z0=50)
wg = self.wg
self.E = wg.random(n_ports =2, name = 'E')
ideals = [
wg.short( name='short'),
wg.delay_short( 45.,'deg',name='ew'),
wg.delay_short( 90.,'deg',name='qw'),
wg.match( name='load'),
]
measured = [self.measure(k) for k in ideals]
self.cal = rf.OnePort(
is_reciprocal = True,
ideals = ideals,
measured = measured,
)
def setUp(self):
self.n_ports = 1
self.wg = WG
wg = self.wg
self.E = wg.random(n_ports=2, name='E')
ideals = [
wg.short(name='short'),
wg.delay_short(45., 'deg', name='ew'),
wg.delay_short(90., 'deg', name='qw'),
wg.match(name='load'),
]
measured = [self.measure(k) for k in ideals]
self.cal = rf.OnePort(
is_reciprocal=True,
ideals=ideals,
measured=measured,
)
z0=50)
# read in actual vat3+
vat3_mini = rf.Network('VAT-3+___PLus25degC.s2p')
pdb.set_trace()
mini_open = rf.media.Freespace(vat3_mini.frequency).open()
vat3_mini = rf.connect(vat3_mini, 0, mini_open, 0)
#sdrkit_open.write_touchstone('ideal_open.s1p')
#sdrkit_short.write_touchstone('ideal_short.s1p')
#sdrkit_load.write_touchstone('ideal_load.s1p')
my_ideals = [sdrkit_short, sdrkit_open, sdrkit_load]
my_measured = [cal_short, cal_open, cal_load]
cal = rf.OnePort(ideals=my_ideals, measured=my_measured)
cal.run()
source_match = cal.coefs_3term_ntwks['source match']
directivity = cal.coefs_3term_ntwks['directivity']
reflection_tracking = cal.coefs_3term_ntwks['reflection tracking']
if False:
source_match.plot_s_db()
directivity.plot_s_db()
reflection_tracking.plot_s_db()
barrel_cal = cal.apply_cal(barrel)
anne_cal = cal.apply_cal(anne)
vat3_cal = cal.apply_cal(vat3)
o_i = skrf.Network(s=open_sparam, f=freqs, f_unit='Hz')
short_reactance = tline_input(np.zeros(len(freqs), dtype=np.complex), short_offset_z0, short_offset_t, freqs)
short_sparam = gamma(short_reactance, 50)
s_i = skrf.Network(s=short_sparam, f=freqs, f_unit='Hz')
l_sparam = [gamma(tline_input(50, load_offset_z0, load_offset_t, f), 50) for f in freqs]
l_i = skrf.Network(s=l_sparam, f=freqs, f_unit='Hz')
return s_i, o_i, l_i
o = skrf.Network('open.s1p')
s = skrf.Network('short.s1p')
l = skrf.Network('load.s1p')
dut = skrf.Network(sys.argv[1])
freqs = o.f
s_i, o_i, l_i = make_standards()
cal = skrf.OnePort(\
measured = [o, s, l],
ideals =[o_i, s_i, l_i]
)
plt.figure()
dut_cal = cal.apply_cal(dut)
dut_cal.plot_s_db()
plt.show(block=True)
