def test_baseband_sweep():
num_tones = 16
num_waveforms = 2 ** 5
num_tone_samples = 2 ** 10
length_seconds = 0.1
ri = RoachBaseband(roach=MockRoach("roach"), initialize=False, adc_valon=MockValon())
center_frequencies = np.linspace(100, 200, num_tones)
offsets = np.linspace(-20e-3, 20e-3, num_waveforms)
tone_banks = [center_frequencies + offset for offset in offsets]
state = {"something": "something state"}
# Load waveforms one at a time.
sweep = acquire.run_sweep(
ri=ri,
tone_banks=tone_banks,
num_tone_samples=num_tone_samples,
length_seconds=length_seconds,
state=state,
description="description",
)
assert len(sweep.stream_arrays) == num_waveforms
assert all([stream_array.s21_raw.shape[0] == num_tones for stream_array in sweep.stream_arrays])
# Pre-load all waveforms.
acquire.load_baseband_sweep_tones(ri, tone_banks, num_tone_samples)
sweep = acquire.run_loaded_sweep(ri=ri, length_seconds=length_seconds, state=state, description="description")
assert len(sweep.stream_arrays) == num_waveforms
assert all([stream_array.s21_raw.shape[0] == num_tones for stream_array in sweep.stream_arrays])
def fake_sweep_array(num_tones=16, num_waveforms=16, num_tone_samples=2 ** 16, length_seconds=0.01,
state={'I_am_a': 'fake sweep array'}, description='fake sweep array'):
ri = baseband.RoachBaseband(roach=mock_roach.MockRoach('roach'), adc_valon=mock_valon.MockValon(), initialize=False)
center_frequencies = np.linspace(100, 200, num_tones)
offsets = np.linspace(-100e-3, 100e-3, num_waveforms)
tone_banks = [center_frequencies + offset for offset in offsets]
return acquire.run_sweep(ri=ri, tone_banks=tone_banks, num_tone_samples=num_tone_samples,
length_seconds=length_seconds, state=state, description=description, wait_for_sync=False)
def measure_hardware_delay(ri, frequencies=np.arange(1, 9) * 24, num_tone_samples=2 ** 16, num_points=16,
make_plots=False,
verbose=False):
offsets = np.arange(-num_points // 2, num_points // 2 + 1) * ri.fs / float(num_tone_samples)
if ri.is_roach2:
sa = acquire.run_sweep(ri, ri.lo_frequency + frequencies[None, :] + offsets[:, None],
num_tone_samples=num_tone_samples, verbose=verbose)
else:
acquire.load_heterodyne_sweep_tones(ri, ri.lo_frequency + frequencies[None, :] + offsets[:, None],
num_tone_samples=num_tone_samples)
sa = acquire.run_loaded_sweep(ri, verbose=verbose)
print np.median(np.abs(sa.s21_point))
local_delays = []
for k in range(frequencies.shape[0]):
swp = sa.sweep(k)
deltaf = swp.frequency - swp.frequency.min()
phase = np.unwrap(np.angle(swp.s21_point))
rad_per_Hz, offset = np.polyfit(deltaf, phase, 1)
local_delays.append(rad_per_Hz / (2 * np.pi))
if make_plots:
plt.plot(deltaf, phase - offset, '.')
plt.plot(deltaf, rad_per_Hz * deltaf)
plt.xlabel('Offset Frequency (Hz)')
plt.ylabel('Phase (rad)')
local_delays = np.array(local_delays)
if make_plots:
plt.figure()
plt.plot(frequencies, local_delays * 1e9, 'o')
plt.axhline(np.median(local_delays * 1e9), linestyle='--', color='r')
plt.xlabel('Measurement Frequency (MHz)')
plt.ylabel('Delay (ns)')
logger.debug("median local delay: %.1f ns" % (np.median(local_delays) * 1e9))
frequency = sa.frequency
deltaf = frequency - frequency.min()
phase = np.unwrap(np.angle(sa.s21_point * np.exp(-1j * np.median(local_delays) * 2 * np.pi * deltaf)))
rad_per_Hz, offset = np.polyfit(deltaf, phase, 1)
if make_plots:
plt.figure()
plt.plot(frequency / 1e6, phase, '.')
plt.plot(frequency / 1e6, offset + rad_per_Hz * deltaf)
plt.xlabel('Frequency (MHz)')
plt.ylabel('Phase (rad)')
total_delay = np.median(local_delays) + rad_per_Hz / (2 * np.pi)
logger.debug("residual delay %.1f ns global delay = %.1f ns" % (1e9 * rad_per_Hz / (2 * np.pi), 1e9 * total_delay))
return total_delay
def measure_hardware_delay(ri, frequencies=np.arange(1, 9) * 24, num_tone_samples=2 ** 16, num_points=16,
make_plots=False,
verbose=False):
offsets = np.arange(-num_points // 2, num_points // 2 + 1) * ri.fs / float(num_tone_samples)
if ri.is_roach2:
sa = acquire.run_sweep(ri, ri.lo_frequency + frequencies[None, :] + offsets[:, None],
num_tone_samples=num_tone_samples, verbose=verbose)
else:
acquire.load_heterodyne_sweep_tones(ri, ri.lo_frequency + frequencies[None, :] + offsets[:, None],
num_tone_samples=num_tone_samples)
sa = acquire.run_loaded_sweep(ri, verbose=verbose)
print np.median(np.abs(sa.s21_point))
local_delays = []
for k in range(frequencies.shape[0]):
swp = sa.sweep(k)
deltaf = swp.frequency - swp.frequency.min()
phase = np.unwrap(np.angle(swp.s21_point))
rad_per_Hz, offset = np.polyfit(deltaf, phase, 1)
local_delays.append(rad_per_Hz / (2 * np.pi))
if make_plots:
plt.plot(deltaf, phase - offset, '.')
plt.plot(deltaf, rad_per_Hz * deltaf)
plt.xlabel('Offset Frequency (Hz)')
plt.ylabel('Phase (rad)')
local_delays = np.array(local_delays)
if make_plots:
plt.figure()
plt.plot(frequencies, local_delays * 1e9, 'o')
plt.axhline(np.median(local_delays * 1e9), linestyle='--', color='r')
plt.xlabel('Measurement Frequency (MHz)')
plt.ylabel('Delay (ns)')
logger.debug("median local delay: %.1f ns" % (np.median(local_delays) * 1e9))
frequency = sa.frequency
deltaf = frequency - frequency.min()
phase = np.unwrap(np.angle(sa.s21_point * np.exp(-1j * np.median(local_delays) * 2 * np.pi * deltaf)))
rad_per_Hz, offset = np.polyfit(deltaf, phase, 1)
if make_plots:
plt.figure()
plt.plot(frequency / 1e6, phase, '.')
plt.plot(frequency / 1e6, offset + rad_per_Hz * deltaf)
plt.xlabel('Frequency (MHz)')
plt.ylabel('Phase (rad)')
total_delay = np.median(local_delays) + rad_per_Hz / (2 * np.pi)
logger.debug("residual delay %.1f ns global delay = %.1f ns" % (1e9 * rad_per_Hz / (2 * np.pi), 1e9 * total_delay))
return total_delay
def fake_sweep_array(num_tones=16,
num_waveforms=16,
num_tone_samples=2**16,
length_seconds=0.01,
state={'I_am_a': 'fake sweep array'},
description='fake sweep array'):
ri = baseband.RoachBaseband(roach=mock_roach.MockRoach('roach'),
adc_valon=mock_valon.MockValon(),
initialize=False)
center_frequencies = np.linspace(100, 200, num_tones)
offsets = np.linspace(-100e-3, 100e-3, num_waveforms)
tone_banks = [center_frequencies + offset for offset in offsets]
return acquire.run_sweep(ri=ri,
tone_banks=tone_banks,
num_tone_samples=num_tone_samples,
length_seconds=length_seconds,
state=state,
description=description,
wait_for_sync=False)
def test_heterodyne_sweep():
num_tones = 16
num_waveforms = 2**5
num_tone_samples = 2**10
length_seconds = 0.1
ri = RoachHeterodyne(roach=MockRoach('roach'),
initialize=False,
adc_valon=MockValon())
ri.lo_frequency = 1000
center_frequencies = ri.lo_frequency + np.linspace(-100, 100, num_tones)
offsets = np.linspace(-20e-3, 20e-3, num_waveforms)
tone_banks = [center_frequencies + offset for offset in offsets]
state = {'something': 'something state'}
# Load waveforms one at a time.
sweep = acquire.run_sweep(ri=ri,
tone_banks=tone_banks,
num_tone_samples=num_tone_samples,
length_seconds=length_seconds,
state=state,
description="description")
assert len(sweep.stream_arrays) == num_waveforms
assert all([
stream_array.s21_raw.shape[0] == num_tones
for stream_array in sweep.stream_arrays
])
# Pre-load all waveforms.
acquire.load_heterodyne_sweep_tones(ri, tone_banks, num_tone_samples)
sweep = acquire.run_loaded_sweep(ri=ri,
length_seconds=length_seconds,
state=state,
description="description")
assert len(sweep.stream_arrays) == num_waveforms
assert all([
stream_array.s21_raw.shape[0] == num_tones
for stream_array in sweep.stream_arrays
])
# Run
ncf = acquire.new_nc_file(suffix=suffix)
tic = time.time()
try:
for fft_gain, attenuation in zip(fft_gains, attenuations):
ri.set_fft_gain(fft_gain)
ri.set_dac_attenuator(attenuation)
state = hw.state()
start_time = time.time(
) # Use this time to retrieve the temperature (see below).
logger.info(
"Recording {:.1f} s coarse sweep around MHz frequencies {}".format(
sweep_length_seconds, f0_MHz))
sweep_array_coarse = acquire.run_sweep(
ri=ri,
tone_banks=sweep_frequencies_coarse_MHz,
length_seconds=sweep_length_seconds,
num_tone_samples=num_tone_samples_coarse,
state=state)
ncf.write(sweep_array_coarse)
fit_f0_coarse_MHz = np.array([
1e-6 * sweep_array_coarse[n].resonator.f_0
for n in range(sweep_array_coarse.num_channels)
])
logger.info("coarse - initial [kHz]: {}".format(', '.join([
'{:.3f}'.format(1e3 * df0) for df0 in fit_f0_coarse_MHz - f0_MHz
])))
sweep_frequencies_fine_MHz = offset_frequencies_fine_MHz[:, np.
newaxis] + fit_f0_coarse_MHz[
np.
newaxis, :]
logger.info(
f_baseband = f_baseband_minimum + ri.state.adc_sample_rate / 2 ** tone_sample_exponent * np.arange(num_sweep_tones)
f_lo_center = f_lo_spacing * np.round((f_center - f_baseband.mean()) / f_lo_spacing)
logger.info("Sweep using {:d} tones spanning {:.1f} MHz with resolution {:.0f} Hz (2^{:d} samples)".format(
num_sweep_tones, 1e-6 * f_baseband.ptp(), df_baseband, tone_sample_exponent))
# Run
npd = acquire.new_npy_directory(suffix=suffix)
tic = time.time()
try:
for lo_index, f_lo in enumerate(f_lo_center):
assert np.all(ri.adc_valon.get_phase_locks())
tools.set_and_attempt_external_phase_lock(ri=ri, f_lo=1e-6 * f_lo, f_lo_spacing=1e-6 * f_lo_spacing)
for attenuation_index, attenuation in enumerate(attenuations):
ri.set_dac_attenuator(attenuation)
ri.set_tone_baseband_freqs(freqs=1e-6 * np.array([f_baseband[0]]), nsamp=2 ** tone_sample_exponent)
time.sleep(1)
npd.write(ri.get_adc_measurement())
tools.optimize_fft_gain(ri, fraction_of_maximum=0.5)
state = hw.state()
state['lo_index'] = lo_index
state['attenuation_index'] = attenuation_index
sweep = acquire.run_sweep(ri=ri, tone_banks=1e-6 * (f_lo + f_baseband[:, np.newaxis]),
num_tone_samples=2 ** tone_sample_exponent, length_seconds=sweep_length_seconds,
state=state, verbose=True)[0]
npd.write(sweep)
finally:
ri.set_modulation_output('high')
npd.close()
print("Wrote {}".format(npd.root_path))
print("Elapsed time {:.0f} minutes.".format((time.time() - tic) / 60))
tic = time.time()
try:
for lo_index, f_lo in enumerate(f_lo_center):
assert np.all(ri.adc_valon.get_phase_locks())
tools.set_and_attempt_external_phase_lock(ri=ri, f_lo=1e-6 * f_lo, f_lo_spacing=1e-6 * f_lo_spacing)
for attenuation_index, attenuation in enumerate(attenuations):
ri.set_dac_attenuator(attenuation)
#ri.set_tone_baseband_freqs(freqs=1e-6 * np.array([f_baseband[0]]), nsamp=2 ** tone_sample_exponent)
#time.sleep(1)
#tools.optimize_fft_gain(ri, fraction_of_maximum=0.5)
ri.set_fft_gain(4)
coarse_state = hw.state()
coarse_state['lo_index'] = lo_index
coarse_state['attenuation_index'] = attenuation_index
coarse_sweep = acquire.run_sweep(ri=ri, tone_banks=1e-6 * (f_lo + f_baseband[::coarse_stride, np.newaxis]),
num_tone_samples=2 ** tone_sample_exponent,
length_seconds=stream_length_seconds, state=coarse_state,
verbose=True)[0]
npd.write(coarse_sweep)
coarse_f_r = coarse_sweep.resonator.f_0
coarse_Q = coarse_sweep.resonator.Q
logger.info("Coarse sweep f_r = {:.3f} MHz +/- {:.0f} Hz".format(1e-6 * coarse_f_r,
coarse_sweep.resonator.f_0_error))
logger.info("Coarse sweep Q = {:.0f} +/- {:.0f}".format(coarse_Q, coarse_sweep.resonator.Q_error))
raise Exception()
df_filterbank = calculate.stream_sample_rate(ri_state)
f_baseband_bin_center = df_filterbank * np.round(f_baseband.mean() / df_filterbank)
f_lo_fine = f_lo_spacing * np.round((coarse_f_r - f_baseband_bin_center) / f_lo_spacing)
assert np.all(ri.adc_valon.get_phase_locks())
tools.set_and_attempt_external_phase_lock(ri=ri, f_lo=1e-6 * f_lo, f_lo_spacing=1e-6 * f_lo_spacing)
#fine_indices = np.where(np.abs(f_lo_fine + f_baseband - coarse_f_r) <=
# (fine_sweep_num_linewidths / 2) * (coarse_f_r / coarse_Q))[0]
last_f0s = initial_f0s
for heater_voltage in np.sqrt(np.linspace(0,4**2,16)):
fg.set_dc_voltage(heater_voltage)
if heater_voltage == 0:
print "heater voltage is 0 V, skipping wait"
else:
print "waiting 20 minutes", heater_voltage
time.sleep(1200)
fg.enable_output(True)
for dac_atten in [35]:
ri.set_dac_atten(dac_atten)
tic = time.time()
ncf = new_nc_file(suffix='%d_dB_load_heater_%.3f_V' % (dac_atten, heater_voltage))
swpa = acquire.run_sweep(ri, tone_banks=last_f0s[None,:] + offsets[:,None], num_tone_samples=nsamp,
length_seconds=0, verbose=True,
description='bb sweep')
print "resonance sweep done", (time.time()-tic)/60.
ncf.write(swpa)
current_f0s = []
for sidx in range(last_f0s.shape[0]):
swp = swpa.sweep(sidx)
res = swp.resonator
print res.f_0, res.Q, res.current_result.redchi, (last_f0s[sidx]*1e6-res.f_0)
if np.abs(res.f_0 - last_f0s[sidx]*1e6) > 200e3:
current_f0s.append(last_f0s[sidx]*1e6)
print "using original frequency for ",last_f0s[sidx]
else:
current_f0s.append(res.f_0)
print "fits complete", (time.time()-tic)/60.
current_f0s = np.array(current_f0s)/1e6
offset_frequencies_fine_MHz[0])))
logger.info("Fine sweep span is {:.3f} MHz".format(offset_frequencies_fine_MHz.ptp()))
raw_input("Press enter to continue or ctrl-C to abort.")
# Run
ncf = acquire.new_nc_file(suffix=suffix)
tic = time.time()
try:
for fft_gain, attenuation in zip(fft_gains, attenuations):
ri.set_fft_gain(fft_gain)
ri.set_dac_attenuator(attenuation)
state = hw.state()
start_time = time.time() # Use this time to retrieve the temperature (see below).
logger.info("Recording {:.1f} s coarse sweep around MHz frequencies {}".format(sweep_length_seconds, f0_MHz))
sweep_array_coarse = acquire.run_sweep(ri=ri, tone_banks=sweep_frequencies_coarse_MHz,
length_seconds=sweep_length_seconds,
num_tone_samples=num_tone_samples_coarse, state=state)
ncf.write(sweep_array_coarse)
fit_f0_coarse_MHz = np.array([1e-6 * sweep_array_coarse[n].resonator.f_0
for n in range(sweep_array_coarse.num_channels)])
logger.info("coarse - initial [kHz]: {}".format(', '.join(['{:.3f}'.format(1e3 * df0)
for df0 in fit_f0_coarse_MHz - f0_MHz])))
sweep_frequencies_fine_MHz = offset_frequencies_fine_MHz[:, np.newaxis] + fit_f0_coarse_MHz[np.newaxis, :]
logger.info("Recording {:.1f} s fine sweep around MHz frequencies {}".format(sweep_length_seconds,
fit_f0_coarse_MHz))
sweep_array_fine = acquire.run_sweep(ri=ri, tone_banks=sweep_frequencies_fine_MHz,
length_seconds=sweep_length_seconds,
num_tone_samples=num_tone_samples_fine)
fit_f0_fine_MHz = np.array([1e-6 * sweep_array_fine[n].resonator.f_0
for n in range(sweep_array_fine.num_channels)])
logger.info("fine - coarse [kHz]: {}".format(', '.join(['{:.3f}'.format(1e3 * df0)
#f0binned = np.round(f0s * nsamp / 512.0) * 512.0 / nsamp
offset_bins = np.arange(-(nstep), (nstep)) * step
offsets = offset_bins * 512.0 / nsamp
ri.set_modulation_output('high')
ri.set_lo(1250.)
#legacy.load_heterodyne_sweep_tones(ri,(np.arange(1,129)[None,:]*7/4.+ri.lo_frequency + offsets[:,None]),
# num_tone_samples=nsamp)
state = dict(magnetic_shield='on', cryostat='starcryo')
state.update(other=setup.state())
tic = time.time()
for lo in 880. + 190 * np.arange(0, 2):
logger.info("Measuring at LO %.1f" % lo)
df = acquire.new_nc_file(suffix='scan_lo_%.1f_MHz' % lo)
ri.set_lo(lo)
state.update(other=setup.state(fast=True))
swa = acquire.run_sweep(ri, (np.arange(1, 257)[None, :] * 7 / 8. +
ri.lo_frequency + offsets[:, None]),
num_tone_samples=nsamp,
length_seconds=0.2,
state=state,
verbose=True)
df.write(swa)
df.close()
print "elapsed:", (time.time() - tic) / 60.0, 'minutes'
nsamp = 2**15
step = 1
nstep = 24
offset_bins = np.arange(-(nstep + 1), (nstep + 1)) * step
offsets = offset_bins * 512.0 / nsamp
print (initial_f0s[1]-initial_f0s[0])*1e6, offsets.ptp()
for (lo,f0s) in [(initial_lo,initial_f0s)]:
ri.set_lo(lo)
for dac_atten in [0]:
ncf = new_nc_file(suffix='off_on_cw_%d_dB_dac' % dac_atten)
ri.set_modulation_output('high')
swpa = acquire.run_sweep(ri, tone_banks=f0s[None,:] + offsets[:,None], num_tone_samples=nsamp,
length_seconds=0.5, state=setup.state(), verbose=True,
description='source off sweep')
print "resonance sweep done", (time.time()-tic)/60.
ncf.write(swpa)
#print "sweep written", (time.time()-tic)/60.
current_f0s = []
for sidx in range(f0s.shape[0]):
swp = swpa.sweep(sidx)
res = swp.resonator
print res.f_0, res.Q, res.current_result.redchi, (f0s[sidx]*1e6-res.f_0)
if np.abs(res.f_0 - f0s[sidx]*1e6) > 0.9*(initial_f0s[1]-initial_f0s[0])*1e6:
current_f0s.append(f0s[sidx]*1e6)
print "using original frequency for ",f0s[sidx]
else:
current_f0s.append(res.f_0)
print "fits complete", (time.time()-tic)/60.
step = 1
nstep = 32
offset_bins = np.arange(-(nstep + 1), (nstep + 1)) * step
offsets = offset_bins * 512.0 / nsamp
for (lo, f0s) in [(initial_lo, initial_f0s)]:
ri.set_lo(lo)
#for dac_atten in [2,6,10,20]:
for dac_atten in [2]:
ri.set_dac_atten(dac_atten)
tic = time.time()
ncf = new_nc_file(suffix='%d_dB_dac' % dac_atten)
swpa = acquire.run_sweep(ri,
tone_banks=f0s[None, :] + offsets[:, None],
num_tone_samples=nsamp,
length_seconds=0,
state=setup.state(),
verbose=True,
description='dark sweep')
print "resonance sweep done", (time.time() - tic) / 60.
ncf.write(swpa)
#print "sweep written", (time.time()-tic)/60.
current_f0s = []
for sidx in range(f0s.shape[0]):
swp = swpa.sweep(sidx)
res = swp.resonator
print res.f_0, res.Q, res.current_result.redchi, (f0s[sidx] * 1e6 -
res.f_0)
if np.abs(res.f_0 - f0s[sidx] * 1e6) > 200e3:
current_f0s.append(f0s[sidx] * 1e6)
print "using original frequency for ", f0s[sidx]
assert np.all(ri.adc_valon.get_phase_locks())
tools.set_and_attempt_external_phase_lock(ri=ri,
f_lo=1e-6 * f_lo,
f_lo_spacing=1e-6 *
f_lo_spacing)
for attenuation_index, attenuation in enumerate(attenuations):
ri.set_dac_attenuator(attenuation)
ri.set_tone_baseband_freqs(freqs=1e-6 *
np.array([f_baseband[0, :]]),
nsamp=2**tone_sample_exponent)
time.sleep(1)
tools.optimize_fft_gain(ri, fraction_of_maximum=0.5)
time.sleep(1)
sweep_array = acquire.run_sweep(
ri=ri,
tone_banks=1e-6 * (f_lo + f_baseband),
num_tone_samples=2**tone_sample_exponent,
length_seconds=sweep_length_seconds,
state=hw.state())
fit_f_r = [
sweep_array[number].resonator.f_0
for number in range(sweep_array.num_channels)
]
logger.info("Fit resonance frequencies [MHz] {}".format(', '.join(
"{:.1f}".format(1e-6 * f_r) for f_r in fit_f_r)))
fit_Q = [
sweep_array[number].resonator.Q
for number in range(sweep_array.num_channels)
]
logger.info("Fit quality factors {}".format(', '.join(
'{:.3g}'.format(Q) for Q in fit_Q)))
ri.set_tone_freqs(freqs=1e-6 * np.array(fit_f_r),
ri.set_modulation_output('low')
#setup = hardware.Hardware()
ri = Roach2Baseband()
#turn on source
ri.set_modulation_output(7)
raw_input('set attenuator knobs to 3 turns & check lock-in range')
for dac_atten in [10]:
ri.set_dac_atten(dac_atten)
ri.set_modulation_output('low')
df = acquire.new_nc_file(suffix='vna_dac_atten_%.1f_dB_3_turns_broadband' %
dac_atten)
swa = acquire.run_sweep(
ri,
np.linspace(100, 180, 64)[None, :] +
np.arange(650, dtype='int')[:, None] * 512. / 2.**18,
2**18,
verbose=True,
length_seconds=.1,
)
df.write(swa)
df.close()
#for example
#170-230 MHz band, steps are (230-170)/128
#then sampling 480 times between each of these steps by stepping an additional 2**18
fg.set_dc_voltage(heater_voltage)
if heater_voltage == 0:
print "heater voltage is 0 V, skipping wait"
else:
print "waiting 15 minutes", heater_voltage
time.sleep(900)
fg.enable_output(True)
for dac_atten in [35]:
ri.set_dac_atten(dac_atten)
tic = time.time()
ncf = new_nc_file(suffix='%d_dB_load_heater_%.3f_V' %
(dac_atten, heater_voltage))
swpa = acquire.run_sweep(ri,
tone_banks=last_f0s[None, :] +
offsets[:, None],
num_tone_samples=nsamp,
length_seconds=0,
verbose=True,
description='bb sweep')
print "resonance sweep done", (time.time() - tic) / 60.
ncf.write(swpa)
current_f0s = []
for sidx in range(last_f0s.shape[0]):
swp = swpa.sweep(sidx)
res = swp.resonator
print res.f_0, res.Q, res.current_result.redchi, (
last_f0s[sidx] * 1e6 - res.f_0)
if np.abs(res.f_0 - last_f0s[sidx] * 1e6) > 200e3:
current_f0s.append(last_f0s[sidx] * 1e6)
print "using original frequency for ", last_f0s[sidx]
else:
ri = Roach2Baseband()
ri.set_modulation_output('low')
#setup = hardware.Hardware()
ri = Roach2Baseband()
#turn on source
ri.set_modulation_output(7)
raw_input('set attenuator knobs to 3 turns & check lock-in range')
for dac_atten in [10]:
ri.set_dac_atten(dac_atten)
ri.set_modulation_output('low')
df = acquire.new_nc_file(suffix='vna_dac_atten_%.1f_dB_3_turns_broadband' % dac_atten)
swa = acquire.run_sweep(ri,np.linspace(100,180,64)[None,:]+np.arange(650,dtype='int')[:,None]*512./2.**18,
2**18,
verbose=True,length_seconds=.1,
)
df.write(swa)
df.close()
#for example
#170-230 MHz band, steps are (230-170)/128
#then sampling 480 times between each of these steps by stepping an additional 2**18
hw = hardware.Hardware(conditioner, magnet)
ri = hardware_tools.r2_with_mk2()
ri.set_dac_atten(40)
ri.set_fft_gain(4)
ri.set_modulation_output('high')
# Run
ncf = acquire.new_nc_file(suffix='sweep_stream')
tic = time.time()
try:
for lo in progress(lo_MHz):
state = hw.state()
state['temperature'] = {'package': temps.get_temperature_at(time.time())}
tone_banks = (lo + offsets_MHz)[:, np.newaxis] # Transform to shape (num_offsets, 1)
ri.set_lo(lomhz=lo, chan_spacing=round_to_MHz)
sweep_array = acquire.run_sweep(ri, tone_banks=tone_banks, num_tone_samples=num_tone_samples,
length_seconds=sweep_length_seconds)
single_sweep = sweep_array[0]
f0_MHz = 1e-6 * single_sweep.resonator.f_0
ri.set_tone_freqs(np.array([f0_MHz]), nsamp=num_tone_samples)
ri.select_fft_bins(np.array([0]))
stream_array = ri.get_measurement(num_seconds=stream_length_seconds)
single_stream = stream_array[0]
sweep_stream = basic.SingleSweepStream(sweep=single_sweep, stream=single_stream, state=state,
description='f_0 = {:.1f}'.format(f0_MHz))
ncf.write(sweep_stream)
finally:
ncf.close()
print("Wrote {}".format(ncf.root_path))
print("Elapsed time {:.0f} minutes.".format((time.time() - tic) / 60))
scan = basic.Scan(sweep_arrays=core.IOList())
npd.write(scan)
ri.set_dac_attenuator(attenuation)
for lo_index, f_lo in enumerate(f_lo_all):
assert np.all(ri.adc_valon.get_phase_locks())
tools.set_and_attempt_external_phase_lock(ri=ri,
f_lo=1e-6 * f_lo,
f_lo_spacing=1e-6 *
f_lo_resolution)
if lo_index == 0:
ri.set_tone_baseband_freqs(freqs=1e-6 * f_baseband_all[0, :],
nsamp=2**tone_sample_exponent)
ri.select_fft_bins(
readout_selection=np.arange(ri.tone_bins.shape[1]))
time.sleep(1)
tools.optimize_fft_gain(ri)
state = hw.state()
state['lo_index'] = lo_index
#state['attenuation_index'] = attenuation_index
scan.sweep_arrays.append(
acquire.run_sweep(ri=ri,
tone_banks=1e-6 * (f_lo + f_baseband_all),
num_tone_samples=2**tone_sample_exponent,
length_seconds=length_seconds,
state=state))
npd.write(ri.get_adc_measurement())
finally:
npd.close()
print("Wrote {}".format(npd.root_path))
print("Elapsed time {:.0f} minutes.".format((time.time() - tic) / 60))
mmw_freqs = np.linspace(140e9, 165e9, 128)
ri.set_dac_atten(20)
ri.set_lo(initial_lo)
tic = time.time()
f0s = initial_f0s
#setup.hittite.off()
#high is off for initital
ri.set_modulation_output('high')
ncf_source_off = new_nc_file(suffix= 'mmw_broadband_source_off')
swpa = acquire.run_sweep(ri,tone_banks=f0s[None,:]+offsets[:,None],num_tone_samples=nsamp,
length_seconds=0.2,
verbose=True, state=setup.state())
print "resonance sweep done", (time.time()-tic)/60.
print "sweep written", (time.time()-tic)/60.
current_f0s = []
for sidx in range(swpa.num_channels):
swp = swpa.sweep(sidx)
res = swp.resonator
print res.f_0, res.Q, res.delay*1e6, res.current_result.redchi, (f0s[sidx]*1e6-res.f_0)
if np.abs(f0s[sidx]*1e6-res.f_0) > 100e3:
current_f0s.append(f0s[sidx]*1e6)
logger.info("Resonator index %d moved more than 100 kHz, keeping original value %.1f MHz" % (sidx,
f0s[sidx]))
else:
current_f0s.append(res.f_0)
num_dummy_frequencies = 2 ** int(np.ceil(np.log2(f_center.size))) - f_center.size
logger.info("Padding {:d} resonances with {:d} dummy frequencies".format(f_center.size, num_dummy_frequencies))
f_dummy = f_baseband_maximum + 4 * df_filterbank * np.arange(1, num_dummy_frequencies + 1)
f_center_baseband = np.concatenate((f_center - f_center.min() + f_baseband_minimum + f_sweep_span / 2, f_dummy))
n_center_baseband = np.round(f_center_baseband / df_baseband).astype(int)
n_sweep_offset = np.arange(-num_sweep_tones // 2, num_sweep_tones // 2)
f_baseband = df_baseband * (n_center_baseband[np.newaxis, :] + n_sweep_offset[:, np.newaxis])
assert np.all(ri.adc_valon.get_phase_locks())
tools.set_and_attempt_external_phase_lock(ri=ri, f_lo=1e-6 * f_lo, f_lo_spacing=1e-6 * f_lo_spacing)
ri.set_dac_attenuator(attenuation)
ri.set_tone_baseband_freqs(freqs=1e-6 * np.array([f_baseband[0, :]]), nsamp=2 ** tone_sample_exponent)
time.sleep(1)
tools.optimize_fft_gain(ri, fraction_of_maximum=0.5)
time.sleep(1)
sweep_array = acquire.run_sweep(ri=ri, tone_banks=1e-6 * (f_lo + f_baseband),
num_tone_samples=2 ** tone_sample_exponent,
length_seconds=sweep_length_seconds, state=hw.state())
fit_f_r = np.array([sweep_array[number].resonator.f_0 for number in range(sweep_array.num_channels)])
logger.info("Fit resonance frequencies [MHz] {}".format(', '.join(
"{:.1f}".format(1e-6 * f_r) for f_r in fit_f_r)))
fit_Q = [sweep_array[number].resonator.Q for number in range(sweep_array.num_channels)]
logger.info("Fit quality factors {}".format(', '.join(
'{:.3g}'.format(Q) for Q in fit_Q)))
ri.set_tone_freqs(freqs=1e-6 * np.array(fit_f_r), nsamp=2 ** tone_sample_exponent)
sweep_stream_list = basic.SweepStreamList(sweep=sweep_array, stream_list=core.IOList(),
state={'band_index': band_index,
'num_dummy_frequencies': num_dummy_frequencies})
npd.write(sweep_stream_list)
npd.write(ri.get_adc_measurement())
ri.set_modulation_output(7)
time.sleep(3) # Let the lock-in catch up
nsamp = 2**15
step = 1
nstep = 32
#f0binned = np.round(f0s * nsamp / 512.0) * 512.0 / nsamp
offset_bins = np.arange(-(nstep), (nstep)) * step
offsets = offset_bins * 512.0 / nsamp
ri.set_modulation_output(7)
ri.set_lo(1250.)
#legacy.load_heterodyne_sweep_tones(ri,(np.arange(1,129)[None,:]*7/4.+ri.lo_frequency + offsets[:,None]),
# num_tone_samples=nsamp)
state = dict(magnetic_shield = 'on', cryostat='starcryo')
state.update(other=setup.state())
tic = time.time()
for lo in 790.+190*np.arange(0,5):
logger.info("Measuring at LO %.1f" % lo)
df = acquire.new_nc_file(suffix='scan_lo_%.1f_MHz' % lo)
ri.set_lo(lo)
state.update(other=setup.state(fast=True))
swa = acquire.run_sweep(ri, (np.arange(1, 257)[None, :] * 7 / 8. + ri.lo_frequency + offsets[:, None]),
num_tone_samples=nsamp, length_seconds=0.2, state=state, verbose=True)
df.write(swa)
df.close()
print "elapsed:", (time.time()-tic)/60.0,'minutes'
#ri.set_tone_baseband_freqs(freqs=1e-6 * f_baseband_all, nsamp=2 ** tone_sample_exponent)
f_lo_all = f_start - f_baseband_minimum + df_lo * np.arange(num_sweeps)
# Run
npd = acquire.new_npy_directory(suffix=suffix)
tic = time.time()
try:
scan = basic.Scan(sweep_arrays=core.IOList())
npd.write(scan)
ri.set_dac_attenuator(attenuation)
for lo_index, f_lo in enumerate(f_lo_all):
assert np.all(ri.adc_valon.get_phase_locks())
tools.set_and_attempt_external_phase_lock(ri=ri, f_lo=1e-6 * f_lo, f_lo_spacing=1e-6 * f_lo_resolution)
if lo_index == 0:
ri.set_tone_baseband_freqs(freqs=1e-6 * f_baseband_all[0, :],
nsamp=2 ** tone_sample_exponent)
ri.select_fft_bins(readout_selection=np.arange(ri.tone_bins.shape[1]))
time.sleep(1)
tools.optimize_fft_gain(ri)
state = hw.state()
state['lo_index'] = lo_index
#state['attenuation_index'] = attenuation_index
scan.sweep_arrays.append(acquire.run_sweep(ri=ri, tone_banks=1e-6 * (f_lo + f_baseband_all),
num_tone_samples=2 ** tone_sample_exponent,
length_seconds=length_seconds, state=state))
npd.write(ri.get_adc_measurement())
finally:
npd.close()
print("Wrote {}".format(npd.root_path))
print("Elapsed time {:.0f} minutes.".format((time.time() - tic) / 60))
f_lo_spacing=1e-6 *
f_lo_spacing)
for attenuation_index, attenuation in enumerate(attenuations):
ri.set_dac_attenuator(attenuation)
ri.set_tone_baseband_freqs(freqs=1e-6 * np.array([f_baseband[0]]),
nsamp=2**tone_sample_exponent)
#time.sleep(1)
#tools.optimize_fft_gain(ri, fraction_of_maximum=0.5)
ri.set_fft_gain(4)
coarse_state = hw.state()
coarse_state['lo_index'] = lo_index
coarse_state['attenuation_index'] = attenuation_index
coarse_sweep = acquire.run_sweep(
ri=ri,
tone_banks=1e-6 *
(f_lo + f_baseband[::coarse_stride, np.newaxis]),
num_tone_samples=2**tone_sample_exponent,
length_seconds=stream_length_seconds,
state=coarse_state,
verbose=True)[0]
npd.write(coarse_sweep)
coarse_f_r = coarse_sweep.resonator.f_0
coarse_Q = coarse_sweep.resonator.Q
logger.info("Coarse sweep f_r = {:.3f} MHz +/- {:.0f} Hz".format(
1e-6 * coarse_f_r, coarse_sweep.resonator.f_0_error))
logger.info("Coarse sweep Q = {:.0f} +/- {:.0f}".format(
coarse_Q, coarse_sweep.resonator.Q_error))
df_filterbank = calculate.stream_sample_rate(ri_state)
f_baseband_bin_center = df_filterbank * np.round(
f_baseband.mean() / df_filterbank)
f_lo_fine = f_lo_spacing * np.round(
(coarse_f_r - f_baseband_bin_center) / f_lo_spacing)
offset_frequencies_MHz = 1e-6 * f_resolution * offset_integers
sweep_frequencies_MHz = offset_frequencies_MHz[:, np.newaxis] + f0_MHz[np.newaxis, :]
logger.info("Frequency spacing is {:.3f} kHz".format(1e3 * (offset_frequencies_MHz[1] - offset_frequencies_MHz[0])))
logger.info("Sweep span is {:.3f} MHz".format(offset_frequencies_MHz.ptp()))
# Run
ncf = acquire.new_nc_file(suffix='magnetic_shield')
tic = time.time()
try:
for attenuation in attenuations:
ri.set_dac_attenuator(attenuation)
logger.info("Set DAC attenuation to {:.1f} dB".format(attenuation))
state = hw.state()
state['temperature'] = {'package': starcryo_temps.get_temperatures_at(time.time())[0]}
logger.info("Recording {:.1f} s sweep at MHz center frequencies {}".format(sweep_length_seconds, f0_MHz))
sweep_array = acquire.run_sweep(ri=ri, tone_banks=sweep_frequencies_MHz, length_seconds=sweep_length_seconds,
num_tone_samples=num_tone_samples)
fit_f0_MHz = np.array([1e-6 * sweep_array[n].resonator.f_0 for n in range(sweep_array.num_channels)])
logger.info("Fit - initial [kHz]: {}".format(', '.join(['{:.3f}'.format(1e3 * df0) for df0 in fit_f0_MHz - f0_MHz])))
f_stream_MHz = ri.set_tone_freqs(np.array(fit_f0_MHz), nsamp=num_tone_samples)
ri.select_bank(0)
ri.select_fft_bins(np.arange(f_stream_MHz.size))
logger.info("Recording {:.1f} s streams at MHz frequencies {}".format(stream_length_seconds, f_stream_MHz))
stream_array = ri.get_measurement(num_seconds=stream_length_seconds)
sweep_stream_array = basic.SweepStreamArray(sweep_array=sweep_array, stream_array=stream_array,
description='attenuation {:.1f} dB'.format(attenuation))
logger.debug("Writing SweepStreamArray.")
ncf.write(sweep_stream_array)
# Record an ADCSnap with the stream tones playing.
logger.debug("Recording ADCSnap.")
adc_snap = ri.get_adc_measurement()
logger.debug("Writing ADCSnap.")
'orientation': 'up',
'distance_from_base_mm': 25
})
hw = hardware.Hardware(conditioner, magnet)
ri = hardware_tools.r2_with_mk2()
ri.set_dac_atten(40)
ri.set_fft_gain(4)
ri.set_modulation_output('high')
# Run
ncf = acquire.new_nc_file(suffix='sweep')
tic = time.time()
try:
for lo in progress(lo_MHz):
state = hw.state()
state['temperature'] = {
'package': temps.get_temperature_at(time.time())
}
tone_banks = np.array([np.array([f]) for f in lo + offsets_MHz])
ri.set_lo(lomhz=lo, chan_spacing=round_to_MHz)
sweep = acquire.run_sweep(ri,
tone_banks=tone_banks,
num_tone_samples=num_tone_samples,
length_seconds=length_seconds,
state=state)
ncf.write(sweep)
finally:
ncf.close()
print("Wrote {}".format(ncf.root_path))
print("Elapsed time {:.0f} minutes.".format((time.time() - tic) / 60))
sweep_frequencies_MHz = offset_frequencies_MHz[:, np.newaxis] + f0_MHz[np.newaxis, :]
logger.info("Frequency spacing is {:.3f} kHz".format(1e3 * (offset_frequencies_MHz[1] - offset_frequencies_MHz[0])))
logger.info("Sweep span is {:.3f} MHz".format(offset_frequencies_MHz.ptp()))
# Run
ncf = acquire.new_nc_file(suffix='magnetic_shield_compressor_off')
tic = time.time()
try:
for attenuation in attenuations:
ri.set_dac_attenuator(attenuation)
logger.info("Set DAC attenuation to {:.1f} dB".format(attenuation))
state = hw.state()
state['temperature'] = {'package': starcryo_temps.get_temperatures_at(time.time())[0]}
raw_input("Hit enter when temperatures have recovered.")
logger.info("Recording {:.1f} s sweep at MHz center frequencies {}".format(sweep_length_seconds, f0_MHz))
sweep_array = acquire.run_sweep(ri=ri, tone_banks=sweep_frequencies_MHz, length_seconds=sweep_length_seconds,
num_tone_samples=num_tone_samples)
fit_f0_MHz = np.array([1e-6 * sweep_array[n].resonator.f_0 for n in range(sweep_array.num_channels)])
logger.info("Fit - initial [kHz]: {}".format(', '.join(['{:.3f}'.format(df0) for df0 in fit_f0_MHz - f0_MHz])))
f_stream_MHz = ri.set_tone_freqs(np.array(fit_f0_MHz), nsamp=num_tone_samples)
ri.select_bank(0)
ri.select_fft_bins(np.arange(f_stream_MHz.size))
logger.info("Turning compressor off to record stream.")
raw_input("Hit enter to continue.")
logger.info("Recording {:.1f} s streams at MHz frequencies {}".format(stream_length_seconds, f_stream_MHz))
stream_array = ri.get_measurement(num_seconds=stream_length_seconds)
logger.info("Turning compressor on.")
sweep_stream_array = basic.SweepStreamArray(sweep_array=sweep_array, stream_array=stream_array,
description='attenuation {:.1f} dB'.format(attenuation))
logger.debug("Writing SweepStreamArray.")
ncf.write(sweep_stream_array)
# Record an ADCSnap with the stream tones playing.
