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 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 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
])
try:
ri.set_tone_baseband_freqs(f_baseband_MHz_sweep_actual, nsamp=2 ** tone_sample_exponent)
for resonator_index, f_lo_MHz_center in enumerate(f_lo_MHz_centers):
for attenuation_index, attenuation in enumerate(attenuations):
ri.set_dac_attenuator(attenuation)
for offset_index, f_lo_MHz_offset in enumerate(f_lo_MHz_offsets):
f_lo_MHz = df_lo_MHz * np.round((f_lo_MHz_center + f_lo_MHz_offset) / df_lo_MHz)
ri.set_lo(lomhz=f_lo_MHz, chan_spacing=df_lo_MHz)
logger.info("Set LO to {:.3f} MHz".format(f_lo_MHz))
assert np.all(ri.adc_valon.get_phase_locks())
assert np.all(ri.lo_valon.get_phase_locks())
state = hw.state()
state['resonator_index'] = resonator_index
state['lo_valon'] = {'frequency_a': 1e6 * ri.lo_valon.get_frequency_a(),
'frequency_b': 1e6 * ri.lo_valon.get_frequency_b()}
sweep = acquire.run_loaded_sweep(ri, length_seconds=length_seconds_sweep,
tone_bank_indices=np.arange(num_tones_sweep), state=state)[0]
f0_MHz_fit = 1e-6 * sweep.resonator.f_0
logger.info("Fit resonance frequency is {:.3f} MHz".format(f0_MHz_fit))
is_not_first_loop = (resonator_index > 0) or (attenuation_index > 0) or (offset_index > 0)
f_stream_MHz = ri.add_tone_freqs(np.array([f0_MHz_fit]), overwrite_last=is_not_first_loop)
ri.select_bank(num_tones_sweep)
ri.select_fft_bins(np.arange(f_stream_MHz.size))
time.sleep(wait)
logger.info("Recording {:.1f} s stream at {:.3f} MHz".format(length_seconds_stream, f_stream_MHz[0]))
stream = ri.get_measurement(num_seconds=length_seconds_stream, state=state)[0]
sss = basic.SingleSweepStream(sweep=sweep, stream=stream, state=state)
npd.write(sss)
npd.write(ri.get_adc_measurement())
finally:
npd.close()
print("Wrote {}".format(npd.root_path))
ri.set_tone_baseband_freqs(freqs=1e-6 * f_baseband[:, np.newaxis],
nsamp=2**tone_sample_exponent)
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 * df_lo)
for attenuation_index, (attenuation, fft_gain) in enumerate(
zip(attenuations, fft_gains)):
ri.set_dac_attenuator(attenuation)
ri.set_fft_gain(fft_gain)
state = hw.state()
state['lo_index'] = lo_index
coarse_sweep = acquire.run_loaded_sweep(
ri,
length_seconds=sweep_length_seconds,
tone_bank_indices=np.arange(0, num_sweep_tones,
coarse_stride))[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 = df_lo * np.round(
(coarse_f_r - f_baseband_bin_center) / df_lo)
ri.set_lo(lomhz=1e-6 * f_lo_fine, chan_spacing=1e-6 * df_lo)
f_lo_center = df_lo * np.round((f_center - f_baseband.mean()) / df_lo)
# Run
npd = acquire.new_npy_directory(suffix=suffix)
tic = time.time()
try:
ri.set_tone_baseband_freqs(freqs=1e-6 * f_baseband[:, np.newaxis], nsamp=2 ** tone_sample_exponent)
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 * df_lo)
for attenuation_index, (attenuation, fft_gain) in enumerate(zip(attenuations, fft_gains)):
ri.set_dac_attenuator(attenuation)
ri.set_fft_gain(fft_gain)
state = hw.state()
state['lo_index'] = lo_index
coarse_sweep = acquire.run_loaded_sweep(ri, length_seconds=sweep_length_seconds,
tone_bank_indices=np.arange(0, num_sweep_tones, coarse_stride))[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 = df_lo * np.round((coarse_f_r - f_baseband_bin_center) / df_lo)
ri.set_lo(lomhz=1e-6 * f_lo_fine, chan_spacing=1e-6 * df_lo)
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]
fine_sweep_off = acquire.run_loaded_sweep(ri, length_seconds=sweep_length_seconds,
tone_bank_indices=fine_indices)[0]
ri.select_bank(np.argmin(np.abs(f_baseband_bin_center - f_baseband)))
mmw_freqs = np.linspace(140e9, 165e9, 500)
ri.set_dac_atten(10)
state = dict(mmw_atten_turns=(7,7), hittite_power_dBm=0.0,)
for (lo,f0s) in [(low_group_lo,low_group),
(high_group_lo, high_group)]:
tic = time.time()
ncf = new_nc_file(suffix='lo_%.1f' % lo)
ri.set_lo(lo)
measured_frequencies = acquire.load_heterodyne_sweep_tones(ri, np.add.outer(offsets, f0s), num_tone_samples=nsamp)
print "waveforms loaded", (time.time()-tic)/60.
hittite.off()
swpa = acquire.run_loaded_sweep(ri, length_seconds=0, state=state)
print "resonance sweep done", (time.time()-tic)/60.
ncf.write(swpa)
print "sweep written", (time.time()-tic)/60.
current_f0s = []
fits = []
for sidx in range(32):
swp = swpa.sweep(sidx)
res = lmfit_resonator.LinearResonatorWithCable(swp.frequency, swp.s21_point, swp.s21_point_error)
res.fit()
fits.append(res)
print res.f_0, res.Q, res.current_result.redchi, (f0s[sidx]*1e6-res.f_0)
current_f0s.append(res.f_0)
print "fits complete", (time.time()-tic)/60.
current_f0s = np.array(current_f0s)/1e6
current_f0s.sort()
tic = time.time()
try:
ri.set_tone_baseband_freqs(offset_array_MHz, nsamp=num_tone_samples)
for lo_index, lo in enumerate(lo_MHz):
ri.set_lo(lomhz=lo, chan_spacing=lo_round_to_MHz)
logger.info("Set LO to {:.3f} MHz".format(lo))
for attenuation in attenuations:
ri.set_dac_attenuator(attenuation)
logger.info("Set DAC attenuation to {:.1f} dB".format(attenuation))
state = hw.state()
state['lo_index'] = lo_index
state['temperature'] = {
'package': temps.get_temperature_at(time.time())
}
sweep_array = acquire.run_loaded_sweep(
ri,
length_seconds=sweep_length_seconds,
tone_bank_indices=np.arange(num_sweep_tones))
on_sweep = sweep_array[0]
off_sweep = sweep_array[1]
f0_MHz = 1e-6 * on_sweep.resonator.f_0
logger.info("Fit resonance frequency is {:.3f} MHz".format(f0_MHz))
# Overwrite the last waveform after the first loop.
is_first_loop = (lo == lo_MHz[0]) & (attenuation
== attenuations[0])
f_stream_MHz = ri.add_tone_freqs(np.array(
[f0_MHz, f0_MHz + f_stream_offset_MHz]),
overwrite_last=~is_first_loop)
# NB: it may be true that select_bank() has to be called before select_fft_bins()
ri.select_bank(num_sweep_tones)
ri.select_fft_bins(np.arange(f_stream_MHz.size))
logger.info(
for offset_index, f_lo_MHz_offset in enumerate(f_lo_MHz_offsets):
f_lo_MHz = df_lo_MHz * np.round(
(f_lo_MHz_center + f_lo_MHz_offset) / df_lo_MHz)
ri.set_lo(lomhz=f_lo_MHz, chan_spacing=df_lo_MHz)
logger.info("Set LO to {:.3f} MHz".format(f_lo_MHz))
assert np.all(ri.adc_valon.get_phase_locks())
assert np.all(ri.lo_valon.get_phase_locks())
state = hw.state()
state['resonator_index'] = resonator_index
state['lo_valon'] = {
'frequency_a': 1e6 * ri.lo_valon.get_frequency_a(),
'frequency_b': 1e6 * ri.lo_valon.get_frequency_b()
}
sweep = acquire.run_loaded_sweep(
ri,
length_seconds=length_seconds_sweep,
tone_bank_indices=np.arange(num_tones_sweep),
state=state)[0]
f0_MHz_fit = 1e-6 * sweep.resonator.f_0
logger.info(
"Fit resonance frequency is {:.3f} MHz".format(f0_MHz_fit))
is_not_first_loop = (resonator_index > 0) or (
attenuation_index > 0) or (offset_index > 0)
f_stream_MHz = ri.add_tone_freqs(
np.array([f0_MHz_fit]), overwrite_last=is_not_first_loop)
ri.select_bank(num_tones_sweep)
ri.select_fft_bins(np.arange(f_stream_MHz.size))
time.sleep(wait)
logger.info("Recording {:.1f} s stream at {:.3f} MHz".format(
length_seconds_stream, f_stream_MHz[0]))
stream = ri.get_measurement(num_seconds=length_seconds_stream,
logger.info("Using {:d} tones spanning {:.1f} MHz".format(num_sweep_tones, 1e-6 * df_sweep))
df_sweep_start = (1 - overlap_fraction) * df_sweep
num_sweeps = np.int(np.ceil((f_stop - f_start) / df_sweep_start))
logger.info("Dividing {:.0f} MHz span into {:d} sweeps with {:.2f} overlap fraction".format(
1e-6 * (f_stop - f_start), num_sweeps, overlap_fraction))
df_filterbank = ri_state.adc_sample_rate / ri_state.num_filterbank_channels
df_tone_minimum = df_filterbank * filterbank_bin_separation
logger.info("Separating tones by {:d} filterbank bins requires minimum separation of {:.3f} MHz".format(
filterbank_bin_separation, 1e-6 * df_tone_minimum))
num_tones_per_step = np.min([num_tones_maximum, np.int(df_sweep / df_tone_minimum)])
num_steps = np.int(num_sweep_tones / num_tones_per_step)
logger.info("Dividing each sweep into {:d} steps of {:d} tones each".format(num_steps, num_tones_per_step))
f_baseband_all = f_baseband_minimum + df_baseband * (num_steps * np.arange(num_tones_per_step)[np.newaxis, :] +
np.arange(num_steps)[:, np.newaxis])
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_sweep_start * np.arange(num_sweeps)
# Run
npd = acquire.new_npy_directory(suffix=suffix)
tic = time.time()
try:
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 * df_lo)
npd.write(acquire.run_loaded_sweep(ri=ri, length_seconds=length_seconds, state=hw.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))
ri.set_dac_atten(2)
for (lo,f0s) in [(low_group_lo,low_group),
(high_group_lo, high_group)]:
ri.set_lo(lo)
tic = time.time()
measured_frequencies = acquire.load_heterodyne_sweep_tones(ri, np.add.outer(offsets, f0s), num_tone_samples=nsamp)
print "waveforms loaded", (time.time()-tic)/60.
for hittite_power in np.arange(-3.4,1.1,0.5):
hittite.set_power(hittite_power)
ncf = new_nc_file(suffix='cw_noise')
setup.hittite.on()
ri.set_modulation_output('low')
swpa = acquire.run_loaded_sweep(ri, length_seconds=0, state=setup.state(), description='source on 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(32):
swp = swpa.sweep(sidx)
res = lmfit_resonator.LinearResonatorWithCable(swp.frequency, swp.s21_point, swp.s21_point_error)
print res.f_0, res.Q, res.current_result.redchi, (f0s[sidx]*1e6-res.f_0)
if sidx not in [15,17] and np.abs(res.f_0 - f0s[sidx]*1e6) > 200e3:
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.
current_f0s = np.array(current_f0s)/1e6
sourcemeter.set_current_source()
sourcemeter.set_current_amplitude(0.0)
sourcemeter.enable_output()
ri.set_modulation_output("low")
# ri.set_dac_atten(36)
first = True
# while True: #for dac_atten in [40,36,32,28,24,20]:
for led_current in np.array([0.0, 0.1, 1, 2, 4, 8]) * 1e-3:
sourcemeter.set_current_amplitude(led_current)
dac_atten = 28
ri.set_dac_atten(dac_atten)
ncf = new_nc_file(suffix="dark_%d_dB_dac_%.1f_mA_led" % (dac_atten, led_current * 1e3))
ri.set_modulation_output("high")
swpa = acquire.run_loaded_sweep(ri, length_seconds=0, state=setup.state(), description="light sweep")
logger.info("resonance sweep done %.1f min", (time.time() - tic) / 60.0)
ri.set_modulation_output("low")
ncf.write(swpa)
# print "sweep written", (time.time()-tic)/60.
if first:
current_f0s = []
for sidx in range(8):
swp = swpa.sweep(sidx)
res = lmfit_resonator.LinearResonatorWithCable(swp.frequency, swp.s21_point, swp.s21_point_error)
print res.f_0, res.Q, res.current_result.redchi, (f0s[sidx] * 1e6 - res.f_0)
if False: # sidx not in [15,17] and np.abs(res.f_0 - f0s[sidx]*1e6) > 200e3:
current_f0s.append(f0s[sidx] * 1e6)
print "using original frequency for ", f0s[sidx]
else:
current_f0s.append(res.f_0)
offset_bins = np.arange(-(nstep + 1), (nstep + 1)) * step
offsets = offset_bins * 512.0 / nsamp
mmw_freqs = np.linspace(140e9, 165e9, 500)
ri.set_dac_atten(10)
for (lo, f0s) in [(low_group_lo, low_group), (high_group_lo, high_group)]:
tic = time.time()
ncf = new_nc_file(suffix='lo_%.1f' % lo)
ri.set_lo(lo)
measured_frequencies = acquire.load_heterodyne_sweep_tones(
ri, np.add.outer(offsets, f0s), num_tone_samples=nsamp)
print "waveforms loaded", (time.time() - tic) / 60.
setup.hittite.off()
swpa = acquire.run_loaded_sweep(ri, length_seconds=0, state=setup.state())
print "resonance sweep done", (time.time() - tic) / 60.
sweepstream = mmw_source_sweep.MMWSweepList(swpa,
core.IOList(),
state=setup.state())
ncf.write(sweepstream)
print "sweep written", (time.time() - tic) / 60.
current_f0s = []
for sidx in range(32):
swp = swpa.sweep(sidx)
res = lmfit_resonator.LinearResonatorWithCable(swp.frequency,
swp.s21_point,
swp.s21_point_error)
print res.f_0, res.Q, res.current_result.redchi, (f0s[sidx] * 1e6 -
res.f_0)
current_f0s.append(res.f_0)
# Hardware
conditioner = analog.HeterodyneMarkII()
magnet = hardware.Thing(name='magnet_array', state={'orientation': 'up',
'distance_from_base_mm': 276})
hw = hardware.Hardware(conditioner, magnet)
ri = hardware_tools.r1h11_with_mk2(initialize=True, use_config=False)
ri.set_dac_attenuator(dac_attenuation)
ri.set_fft_gain(fft_gain)
# Calculate LO and baseband frequencies
f_resolution = ri.state.adc_sample_rate / 2**tone_sample_exponent
minimum_integer = int(f_minimum / f_resolution)
offset_integers = minimum_integer + sweep_interval * np.arange(num_sweep_tones)
offset_frequencies_MHz = 1e-6 * f_resolution * offset_integers
f_lo_MHz = df_lo_MHz * np.round((f0_MHz - offset_frequencies_MHz.mean()) / df_lo_MHz)
logger.info("Frequency spacing is {:.1f} kHz".format(1e-3 * sweep_interval * f_resolution))
logger.info("Sweep span is {:.1f} MHz".format(offset_frequencies_MHz.ptp()))
ri.set_lo(lomhz=f_lo_MHz, chan_spacing=df_lo_MHz)
logger.info("Set LO to {:.3f} MHz".format(f_lo_MHz))
ri.set_tone_baseband_freqs(offset_frequencies_MHz[:, np.newaxis], nsamp=2 ** tone_sample_exponent)
sweep_array = acquire.run_loaded_sweep(ri, length_seconds=sweep_length_seconds,
tone_bank_indices=np.arange(num_sweep_tones))
fit_f0_MHz = 1e-6 * sweep_array[0].resonator.f_0
logger.info("Fit resonance frequency in MHz is {}".format(fit_f0_MHz))
f_stream_MHz = ri.add_tone_freqs(freqs=np.array([fit_f0_MHz]))
ri.select_bank(num_sweep_tones)
ri.select_fft_bins(np.array([0]))
sourcemeter.set_current_source()
sourcemeter.set_current_amplitude(0.0)
sourcemeter.enable_output()
ri.set_modulation_output('low')
#ri.set_dac_atten(36)
first = True
#while True: #for dac_atten in [40,36,32,28,24,20]:
for led_current in np.array([0.0,0.1,1,2,4,8])*1e-3:
sourcemeter.set_current_amplitude(led_current)
dac_atten = 28
ri.set_dac_atten(dac_atten)
ncf = new_nc_file(suffix='dark_%d_dB_dac_%.1f_mA_led' % (dac_atten,led_current*1e3))
ri.set_modulation_output('high')
swpa = acquire.run_loaded_sweep(ri,length_seconds=0,state=setup.state(),description='light sweep')
logger.info("resonance sweep done %.1f min", (time.time()-tic)/60.)
ri.set_modulation_output('low')
ncf.write(swpa)
#print "sweep written", (time.time()-tic)/60.
if first:
current_f0s = []
for sidx in range(8):
swp = swpa.sweep(sidx)
res = lmfit_resonator.LinearResonatorWithCable(swp.frequency, swp.s21_point, swp.s21_point_error)
print res.f_0, res.Q, res.current_result.redchi, (f0s[sidx]*1e6-res.f_0)
if False: #sidx not in [15,17] and np.abs(res.f_0 - f0s[sidx]*1e6) > 200e3:
current_f0s.append(f0s[sidx]*1e6)
print "using original frequency for ",f0s[sidx]
else:
current_f0s.append(res.f_0)
[num_tones_maximum, np.int(df_sweep / df_tone_minimum)])
num_steps = np.int(num_sweep_tones / num_tones_per_step)
logger.info("Dividing each sweep into {:d} steps of {:d} tones each".format(
num_steps, num_tones_per_step))
f_baseband_all = f_baseband_minimum + df_baseband * (
num_steps * np.arange(num_tones_per_step)[np.newaxis, :] +
np.arange(num_steps)[:, np.newaxis])
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_sweep_start * np.arange(
num_sweeps)
# Run
npd = acquire.new_npy_directory(suffix=suffix)
tic = time.time()
try:
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 * df_lo)
npd.write(
acquire.run_loaded_sweep(ri=ri,
length_seconds=length_seconds,
state=hw.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_baseband_all = f_baseband_minimum + df_baseband * (num_steps * np.arange(num_tones_per_step)[np.newaxis, :] +
np.arange(num_steps)[:, np.newaxis])
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_sweep_start * 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)
# FFT gain optimization is broken...
#ri.set_fft_gain(fft_gain_maximum)
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 * df_lo)
ri.select_bank(0)
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_loaded_sweep(ri=ri, 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))
