def get_lnrdata(line0, line1, line2):
"""
Get the lnr data assumimg a broadband noise signal is injected.
The lnr data is the power of the input after applying the calibration
constants (rf), and the negative of the constants (lo).
:param line0: line for first axis.
:param line1: line for second axis.
:param line1: line for third axis.
:return: calibration data: a2, b2, and ab.
"""
# read data
time.sleep(pause_time)
rf = cd.read_interleave_data(roach, bram_rf, bram_addr_width,
bram_word_width, pow_data_type)
lo = cd.read_interleave_data(roach, bram_lo, bram_addr_width,
bram_word_width, pow_data_type)
# scale and dBFS data for plotting
rf_plot = cd.scale_and_dBFS_specdata(rf, acc_len, dBFS)
lo_plot = cd.scale_and_dBFS_specdata(lo, acc_len, dBFS)
# compute lnr for plotting
lnr_ratios = np.divide(lo, rf)
# plot data
line0.set_data(if_freqs, rf_plot)
line1.set_data(if_freqs, lo_plot)
line2.set_data(if_freqs, 10*np.log10(lnr_ratios))
fig.canvas.draw()
fig.canvas.flush_events()
return rf, lo
def get_caldata(rf_freqs, tone_sideband):
"""
Sweep a tone through a sideband and get the calibration data.
The calibration data is the power of each tone in both inputs (a and b)
and the cross-correlation of both inputs as a complex number (ab*).
The full sprecta measured for each tone is saved to data for debugging
purposes.
:param rf_freqs: frequencies of the tones to perform the sweep (in GHz).
:param tone_sideband: sideband of the injected test tone. Either USB or LSB
:return: calibration data: a2, b2, and ab.
"""
fig.canvas.set_window_title(tone_sideband.upper() + " Tone Sweep")
a2_arr = []; b2_arr = []; ab_arr = []
for i, chnl in enumerate(test_channels):
# set test tone
freq = rf_freqs[chnl]
rf_generator.ask("freq " + str(freq) + " ghz; *opc?")
time.sleep(pause_time)
# read data
a2 = cd.read_interleave_data(roach, bram_a2, bram_addr_width,
bram_word_width, pow_data_type)
b2 = cd.read_interleave_data(roach, bram_b2, bram_addr_width,
bram_word_width, pow_data_type)
ab_re = cd.read_interleave_data(roach, bram_ab_re, bram_addr_width,
bram_word_width, crosspow_data_type)
ab_im = cd.read_interleave_data(roach, bram_ab_im, bram_addr_width,
bram_word_width, crosspow_data_type)
# append data to arrays
a2_arr.append(a2[chnl])
b2_arr.append(b2[chnl])
ab_arr.append(ab_re[chnl] + 1j*ab_im[chnl])
# scale and dBFS data for plotting
a2_plot = cd.scale_and_dBFS_specdata(a2, acc_len, dBFS)
b2_plot = cd.scale_and_dBFS_specdata(b2, acc_len, dBFS)
# compute input ratios for plotting
ab_ratios = np.divide(ab_arr, b2_arr)
# plot data
lines[0].set_data(if_freqs, a2_plot)
lines[1].set_data(if_freqs, b2_plot)
lines[2].set_data(if_test_freqs[:i+1], np.abs(ab_ratios))
lines[3].set_data(if_test_freqs[:i+1], np.angle(ab_ratios, deg=True))
fig.canvas.draw()
fig.canvas.flush_events()
# save data
np.savez(cal_datadir+"/rawdata_tone_" + tone_sideband + "/chnl_" +
str(chnl), a2=a2, b2=b2, ab_re=ab_re, ab_im=ab_im)
# compute interpolations
a2_arr = np.interp(if_freqs, if_test_freqs, a2_arr)
b2_arr = np.interp(if_freqs, if_test_freqs, b2_arr)
ab_arr = np.interp(if_freqs, if_test_freqs, ab_arr)
return a2_arr, b2_arr, ab_arr
def get_srrdata(rf_freqs, tone_sideband):
"""
Sweep a tone through a sideband and get the srr data.
The srr data is the power of each tone after applying the calibration
constants for each sideband (usb and lsb).
The full sprecta measured for each tone is saved to data for debugging
purposes.
:param rf_freqs: frequencies of the tones to perform the sweep (in GHz).
:param tone_sideband: sideband of the injected test tone. Either USB or LSB
:return: srr data: usb and lsb.
"""
fig.canvas.set_window_title(tone_sideband.upper() + " Tone Sweep")
usb_arr = []
lsb_arr = []
for i, chnl in enumerate(test_channels):
# set test tone
freq = rf_freqs[chnl]
rf_generator.ask("freq " + str(freq) + " ghz; *opc?")
time.sleep(pause_time)
# read data
usb = cd.read_interleave_data(roach, bram_usb, bram_addr_width,
bram_word_width, pow_data_type)
lsb = cd.read_interleave_data(roach, bram_lsb, bram_addr_width,
bram_word_width, pow_data_type)
# append data to arrays
usb_arr.append(usb[chnl])
lsb_arr.append(lsb[chnl])
# scale and dBFS data for plotting
usb_plot = cd.scale_and_dBFS_specdata(usb, acc_len, dBFS)
lsb_plot = cd.scale_and_dBFS_specdata(lsb, acc_len, dBFS)
# compute srr for plotting
if tone_sideband == 'usb':
srr = np.divide(usb_arr, lsb_arr)
else: # tone_sideband=='lsb
srr = np.divide(lsb_arr, usb_arr)
# define sb plot line
line_sb = lines[2] if tone_sideband == 'usb' else lines[3]
# plot data
lines[0].set_data(if_freqs, usb_plot)
lines[1].set_data(if_freqs, lsb_plot)
line_sb.set_data(if_test_freqs[:i + 1], 10 * np.log10(srr))
fig.canvas.draw()
fig.canvas.flush_events()
# save data
np.savez(srr_datadir+"/rawdata_tone_" + tone_sideband + "/chnl_" + \
str(chnl), usb=usb, lsb=lsb)
# compute interpolations
usb_arr = np.interp(if_freqs, if_test_freqs, usb_arr)
lsb_arr = np.interp(if_freqs, if_test_freqs, lsb_arr)
return usb_arr, lsb_arr
def get_lnrdata(rf_freqs, tone_sideband):
"""
Sweep a tone through a sideband and get the lnr data.
The lnr data is the power of each tone after applying the calibration
constants (rf), and the negative of the constants (lo).
The full sprecta measured for each tone is saved to data for debugging
purposes.
:param rf_freqs: frequencies of the tones to perform the sweep.
:param tone_sideband: sideband of the injected test tone. Either USB or LSB
:return: lnr data: rf and lo.
"""
fig.canvas.set_window_title(tone_sideband.upper() + " Sweep")
rf_arr = []; lo_arr = []
for i, chnl in enumerate(test_channels):
# set test tone
freq = rf_freqs[chnl]
rf_generator.ask("freq " + str(freq*1e6) + ";*opc?") # freq must be in Hz
time.sleep(pause_time)
# read data
rf = cd.read_interleave_data(roach, bram_rf, bram_addr_width,
bram_word_width, pow_data_type)
lo = cd.read_interleave_data(roach, bram_lo, bram_addr_width,
bram_word_width, pow_data_type)
# append data to arrays
rf_arr.append(rf[chnl])
lo_arr.append(lo[chnl])
# scale and dBFS data for plotting
rf_plot = cd.scale_and_dBFS_specdata(rf, acc_len, dBFS)
lo_plot = cd.scale_and_dBFS_specdata(lo, acc_len, dBFS)
# compute lnr for plotting
lnr = np.divide(lo_arr, rf_arr)
# define sb plot line
line_sb = line2 if tone_sideband=='usb' else line3
# plot data
line0.set_data(if_freqs, rf_plot)
line1.set_data(if_freqs, lo_plot)
line_sb.set_data(if_test_freqs[:i+1], 10*np.log10(lnr))
fig.canvas.draw()
fig.canvas.flush_events()
# save data
np.savez(datadir+"/rawdata_tone_" + tone_sideband + "/chnl_" + str(chnl),
rf=rf, lo=lo)
# compute interpolations
rf_arr = np.interp(if_freqs, if_test_freqs, rf_arr)
lo_arr = np.interp(if_freqs, if_test_freqs, lo_arr)
return rf_arr, lo_arr
def animate(i):
data0 = calandigital.read_interleave_data(fpga, ['dout0_0', 'dout0_1', 'dout0_2',
'dout0_3', 'dout0_4', 'dout0_5', 'dout0_6', 'dout0_7'],
awidth=9, dwidth=64, dtype='>512Q')
data1 = calandigital.read_interleave_data(fpga, ['dout1_0', 'dout1_1', 'dout1_2',
'dout1_3', 'dout1_4', 'dout1_5', 'dout1_6', 'dout1_7'],
awidth=9, dwidth=64, dtype='>512Q')
data[0].set_data(freq, 10*np.log10(data0+1.))
data[1].set_data(freq, 10*np.log10(data1+1.))
return data
def get_caldata(rf_freqs):
"""
Sweep a tone through a sideband and get the complex ratio of first (a) and
second (b) input. It is later used to compute the adc delay using the angle
difference information.
:param rf_freqs: frequencies of the tones to perform the sweep (GHz).
:return ab_ratios: complex ratios between a and b.
"""
a2_arr = []
b2_arr = []
ab_arr = []
for i, chnl in enumerate(sync_channels):
# set test tone
freq = rf_freqs[chnl]
rf_generator.ask("freq " + str(freq) + " ghz; *opc?")
time.sleep(pause_time)
# read data
a2 = cd.read_interleave_data(roach, bram_a2, bram_addr_width,
bram_word_width, pow_data_type)
b2 = cd.read_interleave_data(roach, bram_b2, bram_addr_width,
bram_word_width, pow_data_type)
ab_re = cd.read_interleave_data(roach, bram_ab_re, bram_addr_width,
bram_word_width, crosspow_data_type)
ab_im = cd.read_interleave_data(roach, bram_ab_im, bram_addr_width,
bram_word_width, crosspow_data_type)
# append data to arrays
a2_arr.append(a2[chnl])
b2_arr.append(b2[chnl])
ab_arr.append(ab_re[chnl] + 1j * ab_im[chnl])
# scale and dBFS data for plotting
a2_plot = cd.scale_and_dBFS_specdata(a2, acc_len, dBFS)
b2_plot = cd.scale_and_dBFS_specdata(b2, acc_len, dBFS)
# compute input ratios for plotting
ab_ratios = np.divide(np.conj(ab_arr),
a2_arr) # (ab*)* /aa* = a*b / aa* = b/a
# plot data
lines[0].set_data(if_freqs, a2_plot)
lines[1].set_data(if_freqs, b2_plot)
lines[2].set_data(if_sync_freqs[:i + 1], np.abs(ab_ratios))
lines[3].set_data(if_sync_freqs[:i + 1], np.angle(ab_ratios, deg=True))
fig.canvas.draw()
fig.canvas.flush_events()
return ab_ratios
def animate(_):
for line, specbrams in zip(lines, specbrams_list):
# update acc_len
acc_len = roach.read_uint(acc_len_reg)
# get spectral data
specdata = cd.read_interleave_data(roach, specbrams,
spec_addr_width,
spec_word_width, spec_data_type)
specdata = cd.scale_and_dBFS_specdata(specdata, acc_len, dBFS)
line.set_data(freqs, specdata)
return lines
def save():
specdata_list = []
for specbrams in specbrams_list:
specdata = cd.read_interleave_data(roach, specbrams,
spec_addr_width,
spec_word_width, spec_data_type)
specdata_list.append(specdata)
np.savez("filter_data",
prim=specdata_list[0],
ref=specdata_list[1],
output=specdata_list[2])
print("Data saved")
def get_caldata():
"""
Get the calibration data assumimg a broadband noise signal is injected.
The calibration data is the power of each input (a and b)
and the cross-correlation of both inputs as a complex number (ab*).
:return: calibration data: a2, b2, and ab.
"""
# read data
time.sleep(pause_time)
a2 = cd.read_interleave_data(roach, bram_a2, bram_addr_width,
bram_word_width, pow_data_type)
b2 = cd.read_interleave_data(roach, bram_b2, bram_addr_width,
bram_word_width, pow_data_type)
ab_re = cd.read_interleave_data(roach, bram_ab_re, bram_addr_width,
bram_word_width, crosspow_data_type)
ab_im = cd.read_interleave_data(roach, bram_ab_im, bram_addr_width,
bram_word_width, crosspow_data_type)
# get crosspower as complex values
ab = ab_re + 1j * ab_im
# scale and dBFS data for plotting
a2_plot = cd.scale_and_dBFS_specdata(a2, acc_len, dBFS)
b2_plot = cd.scale_and_dBFS_specdata(b2, acc_len, dBFS)
# compute input ratios for plotting
ab_ratios = np.divide(ab, b2)
# plot data
line0.set_data(if_freqs, a2_plot)
line1.set_data(if_freqs, b2_plot)
line2.set_data(if_freqs, np.abs(ab_ratios))
line3.set_data(if_freqs, np.angle(ab_ratios, deg=True))
fig.canvas.draw()
fig.canvas.flush_events()
return a2, b2, ab
def plot_stability_data():
global a2_arr, b2_arr, anglediff_arr, magratios_arr, srr_arr, time_arr
tone_sideband = 'usb'
a2_arr = []
b2_arr = []
magratios_arr = []
anglediff_arr = []
srr_arr = []
time_arr = []
start_time = time.time()
try:
while True:
time.sleep(pause_time)
time_arr.append(time.time() - start_time)
# read cal data
a2 = cd.read_interleave_data(roach, bram_a2, bram_addr_width,
bram_word_width, pow_data_type)
b2 = cd.read_interleave_data(roach, bram_b2, bram_addr_width,
bram_word_width, pow_data_type)
ab_re = cd.read_interleave_data(roach, bram_ab_re, bram_addr_width,
bram_word_width,
crosspow_data_type)
ab_im = cd.read_interleave_data(roach, bram_ab_im, bram_addr_width,
bram_word_width,
crosspow_data_type)
# read syn data
usb = cd.read_interleave_data(roach, bram_usb, bram_addr_width,
bram_word_width, pow_data_type)
lsb = cd.read_interleave_data(roach, bram_lsb, bram_addr_width,
bram_word_width, pow_data_type)
# scale and dBFS data for plotting
a2_plot = cd.scale_and_dBFS_specdata(a2, acc_len, dBFS)
b2_plot = cd.scale_and_dBFS_specdata(b2, acc_len, dBFS)
ab = ab_re[stab_chnl] + 1j * ab_im[stab_chnl]
# compute input ratios for plotting
if tone_sideband == 'usb':
ab_ratio = np.divide(np.conj(ab),
a2) # (ab*)* /aa* = a*b / aa* = b/a
else: # tone_sideband=='lsb
ab_ratio = np.divide(ab, b2) # ab* / bb* = a/b
# append data to arrays
a2_arr.append(a2_plot[stab_chnl])
b2_arr.append(b2_plot[stab_chnl])
magratios_arr.append(np.abs(ab_ratio[stab_chnl]))
anglediff_arr.append(np.angle(ab_ratio[stab_chnl], deg=True))
# compute srr
if tone_sideband == 'usb':
srr = np.divide(usb, lsb)
else: # tone_sideband=='lsb
srr = np.divide(lsb, usb)
srr_arr.append(10 * np.log10(srr[stab_chnl]))
# plot data
if show_plots:
lines[0].set_data(time_arr, a2_arr)
lines[1].set_data(time_arr, b2_arr)
lines[2].set_data(time_arr, magratios_arr)
lines[3].set_data(time_arr, anglediff_arr)
lines[4].set_data(time_arr, srr_arr)
# update axes
axes[0].set_ylim(np.min(a2_arr), np.max(a2_arr))
axes[1].set_ylim(np.min(b2_arr), np.max(b2_arr))
axes[2].set_ylim(np.min(magratios_arr), np.max(magratios_arr))
axes[3].set_ylim(np.min(anglediff_arr), np.max(anglediff_arr))
axes[4].set_ylim(np.min(srr_arr), np.max(srr_arr))
axes[4].set_xlim(0, time_arr[-1])
fig.canvas.draw()
fig.canvas.flush_events()
except:
make_post_measurements_actions()
