for group_num, (lo, f0s) in enumerate(
zip([group_1_lo, group_2_lo], [group_1_f0, group_2_f0])):
print "group", group_num, "lo", lo, "min f0", f0s.min()
ri.set_lo(lo)
nsamp = 2**16
step = 1
nstep = 128
f0binned = np.round(f0s * nsamp / 512.0) * 512.0 / nsamp
offset_bins = np.arange(-(nstep + 1), (nstep + 1)) * step
offsets = offset_bins * 512.0 / nsamp
measured_freqs = sweeps.prepare_sweep(ri, f0binned, offsets, nsamp=nsamp)
for hittite_power in np.arange(-3.4, 1.1, 0.2):
hittite.set_power(hittite_power)
df = data_file.DataFile(suffix=suffix)
df.nc.mmw_atten_turns = mmw_atten_turns
for atten_index, dac_atten in enumerate([2.]):
print "at dac atten", dac_atten
ri.set_dac_atten(dac_atten)
ri.set_modulation_output('low')
df.log_hw_state(ri)
df.log_adc_snap(ri)
sweep_data = sweeps.do_prepared_sweep(ri,
nchan_per_step=atonce,
reads_per_step=2)
df.add_sweep(sweep_data)
fmins = []
for k in range(len(f0s)):
fr, s21, errors = sweep_data.select_index(k)
offsets = np.concatenate(([-40e3], offsets, [40e3])) / 1e6
offsets = offsets * 4
print f0s
print len(f0s)
start = time.time()
measured_freqs = sweeps.prepare_sweep(ri, f0s, offsets, nsamp=2**21)
print "loaded waveforms in", (time.time() - start), "seconds"
sys.stdout.flush()
time.sleep(1)
atten_list = [30] #np.linspace(27,34,8)#[30]#[35.5,33.5,46.5,43.5,40.5,37.5]
for atten in atten_list:
df = data_file.DataFile()
ri.set_dac_attenuator(atten)
sweep_data = sweeps.do_prepared_sweep(ri,
nchan_per_step=atonce,
reads_per_step=8)
df.add_sweep(sweep_data)
meas_cfs = []
idxs = []
for m in range(len(f0s)):
fr, s21, errors = sweep_data.select_by_freq(f0s[m])
thiscf = f0s[m]
res = Resonator(fr, s21, errors=errors)
fmin = fr[np.abs(s21).argmin()]
print "s21 fmin", fmin, "original guess", thiscf, "this fit", res.f_0
if abs(res.f_0 - thiscf) > 0.1:
if abs(fmin - thiscf) > 0.1:
offset_bins = np.array([-8, -4, -2, -1, 0, 1, 2, 4]) #np.arange(-4,4)*step
offset_bins = np.concatenate(([-40, -20], offset_bins, [20, 40]))
offsets = offset_bins * 512.0 / nsamp
meas_cfs = np.array(meas_cfs)
f0binned = np.round(meas_cfs * nsamp / 512.0) * 512.0 / nsamp
f0s = f0binned
measured_freqs = sweeps.prepare_sweep(ri, f0binned, offsets, nsamp=nsamp)
print "loaded updated waveforms in", (time.time() - start), "seconds"
sys.stdout.flush()
time.sleep(1)
#for heater_voltage in heater_voltages:
df = data_file.DataFile(suffix='net_compressor_onoff')
df.log_hw_state(ri)
sweep_data = sweeps.do_prepared_sweep(ri,
nchan_per_step=atonce,
reads_per_step=8,
sweep_data=orig_sweep_data)
df.add_sweep(sweep_data)
meas_cfs = []
idxs = []
for m in range(len(f0s)):
fr, s21, errors = sweep_data.select_by_freq(f0s[m])
thiscf = f0s[m]
s21 = s21 * np.exp(2j * np.pi * delay * fr)
res = fit_best_resonator(
fr, s21, errors=errors) #Resonator(fr,s21,errors=errors)
fmin = fr[np.abs(s21).argmin()]
offset_bins = np.concatenate(([-40,-20],offset_bins,[20,40]))
offsets = offset_bins*512.0/nsamp
meas_cfs = np.array(meas_cfs)
f0binned_meas = np.round(meas_cfs*nsamp/512.0)*512.0/nsamp
f0s = f0binned_meas
measured_freqs = sweeps.prepare_sweep(ri,f0binned_meas,offsets,nsamp=nsamp)
print "loaded updated waveforms in", (time.time()-start),"seconds"
sys.stdout.flush()
time.sleep(1)
df = data_file.DataFile(suffix=suffix+'_offon')
df.nc.mmw_atten_turns=mmw_atten_turns
df.log_hw_state(ri)
sweep_data = sweeps.do_prepared_sweep(ri, nchan_per_step=atonce, reads_per_step=1, sweep_data=orig_sweep_data)
df.add_sweep(sweep_data)
meas_cfs = []
idxs = []
for m in range(len(f0s)):
fr,s21,errors = sweep_data.select_by_freq(f0s[m])
thiscf = f0s[m]
s21 = s21*np.exp(2j*np.pi*delay*fr)
res = fit_best_resonator(fr,s21,errors=errors) #Resonator(fr,s21,errors=errors)
fmin = fr[np.abs(s21).argmin()]
print "s21 fmin", fmin, "original guess",thiscf,"this fit", res.f_0
if use_fmin:
meas_cfs.append(fmin)
offset_bins = np.array([-8, -4, -2, -1, 0, 1, 2, 4]) #np.arange(-4,4)*step
offset_bins = np.concatenate(([-40, -20], offset_bins, [20, 40]))
offsets = offset_bins * 512.0 / nsamp
meas_cfs = np.array(meas_cfs)
f0binned = np.round(meas_cfs * nsamp / 512.0) * 512.0 / nsamp
f0s = f0binned
measured_freqs = sweeps.prepare_sweep(ri, f0binned, offsets, nsamp=nsamp)
print "loaded updated waveforms in", (time.time() - start), "seconds"
sys.stdout.flush()
time.sleep(1)
#for heater_voltage in heater_voltages:
df = data_file.DataFile(suffix='led')
df.log_hw_state(ri)
df.nc.led_voltage = ('%.3f V' % heater_voltage)
sweep_data = sweeps.do_prepared_sweep(ri,
nchan_per_step=atonce,
reads_per_step=8,
sweep_data=orig_sweep_data)
df.add_sweep(sweep_data)
meas_cfs = []
idxs = []
for m in range(len(f0s)):
fr, s21, errors = sweep_data.select_by_freq(f0s[m])
thiscf = f0s[m]
s21 = s21 * np.exp(2j * np.pi * delay * fr)
res = fit_best_resonator(
fr, s21, errors=errors) #Resonator(fr,s21,errors=errors)
def main(f_initial,
attenuation,
stream_time=30,
suffix='compressor_noise',
coarse_exponent=19,
fine_exponent=21,
modulation_state='high',
modulation_rate=7,
transient_wait=10,
f_mmw_source=0,
mmw_atten_turns=(np.nan, np.nan),
num_streams=1):
roach = baseband.RoachBaseband()
roach.set_modulation_output(modulation_state)
roach.set_dac_attenuator(attenuation)
df = data_file.DataFile(suffix=suffix)
df.log_hw_state(roach)
def prompt():
raw_input("Turn off the compressor and hit Enter to begin.")
if modulation_state == 'low':
lockin = lockin_controller.lockinController()
df.nc.mmw_atten_turns = mmw_atten_turns
# Compressor on
coarse_sweep_on = acquire.sweep(roach,
f_initial,
coarse_exponent,
transient_wait=transient_wait)
f_coarse_on = np.array(
[r.f_0 for r in acquire.fit_sweep_data(coarse_sweep_on)])
print("Compressor on: coarse - initial [Hz]: " + ', '.join([
'{:.0f}'.format(1e6 * delta_f) for delta_f in f_coarse_on - f_initial
]))
df.log_hw_state(roach)
fine_sweep_on = acquire.sweep(roach,
f_coarse_on,
fine_exponent,
transient_wait=transient_wait)
f_fine_on = np.array(
[r.f_0 for r in acquire.fit_sweep_data(fine_sweep_on)])
print("Compressor on: fine - coarse [Hz]: " + ', '.join([
'{:.0f}'.format(1e6 * delta_f) for delta_f in f_fine_on - f_coarse_on
]))
df.add_sweep(fine_sweep_on)
df.log_hw_state(roach)
on_start_time = time.time()
stream_on, address = acquire.timestream(roach,
f_fine_on,
stream_time,
transient_wait=transient_wait)
if modulation_state == 'low':
roach.set_modulation_output(modulation_rate)
time.sleep(5)
x, y, r, theta = lockin.get_data()
roach.set_modulation_output('low')
else:
x = 0
df.add_timestream_data(stream_on,
roach,
on_start_time,
mmw_source_freq=f_mmw_source,
zbd_voltage=x)
# Compressor off
print("Preparing fine sweep with compressor off.")
df.log_hw_state(roach)
fine_sweep_off = acquire.sweep(roach,
f_coarse_on,
fine_exponent,
transient_wait=transient_wait,
run=prompt)
print("Done with fine sweep. Turn on the compressor.")
f_fine_off = np.array(
[r.f_0 for r in acquire.fit_sweep_data(fine_sweep_off)])
print("off - on [Hz]: " + ', '.join(
['{:.0f}'.format(1e6 * delta_f)
for delta_f in f_fine_off - f_fine_on]))
df.add_sweep(fine_sweep_off)
df.log_hw_state(roach)
off_start_time = time.time()
stream_off, address = acquire.timestream(roach,
f_fine_on,
stream_time,
transient_wait=transient_wait,
run=prompt)
print("Done with stream. Turn on the compressor.")
if modulation_state == 'low':
roach.set_modulation_output(modulation_rate)
time.sleep(5)
x, y, r, theta = lockin.get_data()
roach.set_modulation_output('high')
else:
x = np.nan
df.add_timestream_data(stream_off,
roach,
off_start_time,
mmw_source_freq=f_mmw_source,
zbd_voltage=x)
df.sync()
df.close()
print("Wrote {}".format(df.filename))
dummy_frequency = 90
probe_detuning = 2
hittite_power = -18
#hittite_powers = [0]
#probe_channels = [0]
#dummy_frequencies = [90] * len(probe_channels) # MHz
#probe_detunings = [2] * len(probe_channels) # MHz
suffix = 'electrical_crosstalk_channel_{}_power_{:.1f}_dBm'.format(
probe_channel, hittite_power)
approximate_stream_length = 30 # in seconds
coarse_exponent = 19
fine_exponent = 21
# Start
start_time = time.time()
tuned = data_file.DataFile(suffix=suffix + '_tuned')
detuned = data_file.DataFile(suffix=suffix + '_detuned')
off = data_file.DataFile(suffix=suffix + '_off')
hittite = hittite_controller.hittiteController()
hittite.off()
roach = roach_interface.RoachBaseband()
# Drop the 31st point so as to not force the added points to occupy the 32nd memory slot, which may not work.
coarse_n_samples = 2**coarse_exponent
coarse_frequency_resolution = roach.fs / coarse_n_samples # about 1 kHz
coarse_offset_integers = acquire.offset_integers[coarse_exponent][:-1] - 32
coarse_offset_frequencies = coarse_frequency_resolution * coarse_offset_integers
fine_n_samples = 2**fine_exponent
fine_frequency_resolution = roach.fs / fine_n_samples # about 0.25 kHz
fine_offset_integers = acquire.offset_integers[fine_exponent][:-1]
fine_offset_frequencies = fine_frequency_resolution * fine_offset_integers
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))
offset_bins = np.array([-8, -4, -2, -1, 0, 1, 2, 4]) #np.arange(-4,4)*step
offset_bins = np.concatenate(([-40, -20], offset_bins, [20, 40]))
offsets = offset_bins * 512.0 / nsamp
meas_cfs = np.array(meas_cfs)
f0binned = np.round(meas_cfs * nsamp / 512.0) * 512.0 / nsamp
f0s = f0binned
measured_freqs = sweeps.prepare_sweep(ri, f0binned, offsets, nsamp=nsamp)
print "loaded updated waveforms in", (time.time() - start), "seconds"
sys.stdout.flush()
time.sleep(1)
#for heater_voltage in heater_voltages:
df = data_file.DataFile(suffix='net')
df.log_hw_state(ri)
sweep_data = sweeps.do_prepared_sweep(ri,
nchan_per_step=atonce,
reads_per_step=8,
sweep_data=orig_sweep_data)
df.add_sweep(sweep_data)
meas_cfs = []
idxs = []
for m in range(len(f0s)):
fr, s21, errors = sweep_data.select_by_freq(f0s[m])
thiscf = f0s[m]
s21 = s21 * np.exp(2j * np.pi * delay * fr)
res = fit_best_resonator(
fr, s21, errors=errors) #Resonator(fr,s21,errors=errors)
fmin = fr[np.abs(s21).argmin()]
