import time
import numpy as np
from kid_readout.interactive import *
from kid_readout.equipment import hardware
from kid_readout.measurement import acquire
from kid_readout.roach import analog, hardware_tools, attenuator, r2heterodyne
from kid_readout.equipment import agilent_33220
fg = agilent_33220.FunctionGenerator(addr=('192.168.0.202', 5025))
fg.set_load_ohms(1000)
fg.set_dc_voltage(0)
fg.enable_output(False)
ifboard = analog.HeterodyneMarkII()
setup = hardware.Hardware(ifboard)
ri = hardware_tools.r2_with_mk2()
ri.initialize()
#setup = hardware.Hardware()
#ri = hardware_tools.r2h14_with_mk2(initialize=True, use_config=False)
ri.iq_delay=-1
ri.set_fft_gain(6)
initial_f0s = np.load('/data/readout/resonances/2018-05-04-medley-efield-2GHz.npy')/1e6
#ilo = 3200.
ilo = 2370.
from kid_readout.interactive import *
import time
from kid_readout.equipment import agilent_33220
fg = agilent_33220.FunctionGenerator()
fg.set_load_ohms(1000)
fg.set_dc_voltage(0)
fg.enable_output(False)
#setup = hardware.Hardware()
ri = Roach2Baseband()
initial_f0s = np.load(
'/data/readout/resonances/2016-10-04-JPL-8x8-LF-2_firstcooldown_resonances.npy'
) / 1e6
nf = len(initial_f0s)
atonce = 128
if nf % atonce > 0:
print "extending list of resonators to make a multiple of ", atonce
initial_f0s = np.concatenate(
(initial_f0s,
np.arange(1, 1 + atonce - (nf % atonce)) + initial_f0s.max()))
nsamp = 2**18 #going above 2**18 with 128 simultaneous tones doesn't quite work yet
offsets = np.arange(-16, 16) * 512. / nsamp
for heater_voltage in np.sqrt(np.linspace(0, 5**2, 16)):
fg.set_dc_voltage(heater_voltage)
fg.enable_output(True)
def main(f_initial,
attenuations,
suffix="magnetic_pickup",
stream_time=30,
coarse_exponent=19,
fine_exponent=21,
transient_wait=10):
roach = roach_interface.RoachBaseband()
fg = agilent_33220.FunctionGenerator()
n_coarse_samples = 2**coarse_exponent
n_fine_samples = 2**fine_exponent
coarse_frequency_resolution = roach.fs / n_coarse_samples
fine_frequency_resolution = roach.fs / n_fine_samples
coarse_offset_integers = legacy_acquire.offset_integers[coarse_exponent]
fine_offset_integers = legacy_acquire.offset_integers[fine_exponent]
f_coarse_offset = coarse_frequency_resolution * coarse_offset_integers
f_fine_offset = fine_frequency_resolution * fine_offset_integers
start_time = time.time()
df = data_file.DataFile(suffix=suffix)
for attenuation in attenuations:
fg.enable_output(False)
roach.set_dac_attenuator(attenuation)
print("Set DAC attenuator to {:.1f} dB".format(attenuation))
df.log_hw_state(roach)
coarse_sweep = legacy_acquire.sweep(roach, f_initial, f_coarse_offset,
n_coarse_samples)
df.add_sweep(coarse_sweep)
f_coarse_fit = np.array(
[r.f_0 for r in legacy_acquire.fit_sweep_data(coarse_sweep)])
print("coarse [MHz]: " +
', '.join(['{:.3f}'.format(f) for f in f_coarse_fit]))
df.log_hw_state(roach)
fine_sweep = legacy_acquire.sweep(roach, f_coarse_fit, f_fine_offset,
n_fine_samples)
df.add_sweep(fine_sweep)
f_fine_fit = np.array(
[r.f_0 for r in legacy_acquire.fit_sweep_data(fine_sweep)])
print("coarse - fine [Hz]: " + ', '.join([
'{:.3f}'.format(1e6 * diff) for diff in f_fine_fit - f_coarse_fit
]))
f_measured = roach.add_tone_freqs(f_fine_fit)
roach.select_fft_bins(np.arange(roach.tone_bins.shape[1])) # Why?
roach.select_bank(roach.fft_bins.shape[0] - 1)
roach._sync()
time.sleep(
transient_wait
) # The above commands somehow create a transient that takes about 5 seconds to decay.
df.log_hw_state(roach)
off_start_time = time.time()
off_stream, addresses = roach.get_data_seconds(stream_time, pow2=True)
df.add_timestream_data(off_stream, roach, off_start_time)
fg.enable_output(True)
df.log_hw_state(roach)
on_start_time = time.time()
on_stream, addresses = roach.get_data_seconds(stream_time, pow2=True)
df.add_timestream_data(on_stream, roach, on_start_time)
fg.enable_output(False)
df.close()
print("Completed in {:.0f} minutes: {}".format(
(time.time() - start_time) / 60, df.filename))