def test_io_list():
num_streams = 3
streams = core.MeasurementList(
[utilities.CornerCases() for n in range(num_streams)])
io = memory.Dictionary()
sweep = basic.SingleSweep(core.IOList())
io.write(sweep)
sweep.streams.extend(streams)
assert io.read(io.node_names()[0]) == basic.SingleSweep(streams)
current_f0s[problems + 1]) / 2.0
if np.any(np.diff(current_f0s) < 0.015):
print "repeated problematic resonator collision:", current_f0s
print "deltas:", np.diff(current_f0s)
problems = np.flatnonzero(np.diff(current_f0s) < 0.015) + 1
current_f0s[problems] = (current_f0s[problems - 1] +
current_f0s[problems + 1]) / 2.0
ri.set_tone_freqs(current_f0s, nsamp)
ri.select_fft_bins(range(initial_f0s.shape[0]))
hittite.on()
ri.set_modulation_output(7)
for n in range(100):
ncf = new_nc_file(suffix='cw_sweep_hwp_step_%03d' % n)
sweepstream = mmw_source_sweep.MMWSweepList(swpa,
core.IOList(),
state=setup.state())
ncf.write(sweepstream)
hwp_motor.increment()
for hittite_power in [0]:
hittite.set_power(hittite_power)
for freq in mmw_freqs:
hittite.set_freq(freq / 12.)
try:
meas = ri.get_measurement(num_seconds=0.2)
meas.state = setup.state(fast=True)
print n, hittite_power, freq, meas.state.lockin.rms_voltage
try:
sweepstream.stream_list.append(meas)
offset_frequency = np.linspace(10, 200, 16)
num_tone_samples = 2**15
dac_attenuation = 62 # The maximum
lo_frequency = 3000
# Hardware
conditioner = analog.HeterodyneMarkII()
hw = hardware.Hardware(conditioner)
ri = hardware_tools.r1_with_mk2()
ri.initialize(use_config=False)
ri.set_dac_attenuator(dac_attenuation)
ri.set_lo(lomhz=lo_frequency)
ri.set_tone_freqs(freqs=lo_frequency + offset_frequency,
nsamp=num_tone_samples)
ri.select_fft_bins(np.arange(offset_frequency.size))
assert np.all(ri.lo_valon.get_phase_locks())
# Acquire
sweep = basic.SweepArray(core.IOList(), description="T_c measurement")
name = 'sweep'
npd = acquire.new_npy_directory(suffix='Tc')
npd.write(sweep, name)
try:
while True:
sweep.stream_arrays.append(
ri.get_measurement(num_seconds=length_seconds, state=hw.state()))
sleep(wait)
finally:
npd.close()
print("Wrote {}".format(npd.root_path))
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
for hwp_index in range(num_hwp_angles):
logger.info("Recording {:.1f} s stream with source modulating at HWP angle {:d} of {:d}".format(
stream_length_seconds, hwp_index, num_hwp_angles))
sweep_stream_list.stream_list.append(ri.get_measurement(num_seconds=stream_length_seconds, state=hw.state()))
logger.info("Incrementing HWP by {:d} steps".format(num_hwp_increments_per_angle))
for _ in range(num_hwp_increments_per_angle):
hwp.increment()
time.sleep(wait_between_increments)
time.sleep(wait_between_angles)
"With {:.2f} fractional overlap, LO frequencies are separated by {:.1f} MHz"
.format(overlap_fraction, 1e-6 * df_lo))
num_sweeps = int(np.ceil((f_stop - f_start) / df_lo))
logger.info("The {:d} sweeps span {:.1f} MHz to {:.1f} MHz".format(
num_sweeps, 1e-6 * f_start, 1e-6 * (f_start + df_lo * num_sweeps)))
f_baseband_all = (f_baseband_minimum +
df_baseband * np.arange(num_waveforms * num_tones).reshape(
(num_waveforms, num_tones), order='F'))
#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)
print("Using {} simultaneous tones spanning {:.1f} MHz.".format(num_tones, 1e-6 * f_block))
f_center_MHz = 1e-6 * np.arange(f_start, f_stop, f_block)
print("Block center frequencies in MHz: {}".format(', '.join(['{:.1f}'.format(f) for f in f_center_MHz])))
f_lo_offset_MHz = 1e-6 * (np.arange(-f_tone / 2, f_tone / 2, f_lo_resolution) - f_minimum)
# This order covers the entire band then comes back to fill in the gaps.
f_lo_MHz = (f_center_MHz[np.newaxis, :] + f_lo_offset_MHz[:, np.newaxis]).flatten()
n_minimum = np.ceil(f_minimum / f_roach_resolution)
step = np.floor(f_tone / f_roach_resolution)
n_baseband = n_minimum + step * np.arange(num_tones)
f_baseband_MHz = 1e-6 * n_baseband * f_roach_resolution
# State
state = {'cryostat': 'hpd',
'canceling_magnet': {'orientation': 'up',
'distance_from_base_mm': 25}}
# Acquire
ri.set_tone_baseband_freqs(freqs=f_baseband_MHz, nsamp=num_tone_samples)
ri.select_fft_bins(np.arange(f_baseband_MHz.size))
sweep = basic.SweepArray(core.IOList(), state=state, description=acquire.script_code())
ncf = new_nc_file(suffix='lo_scan')
ncf.write(sweep)
try:
for f_lo in make_iterable(f_lo_MHz):
ri.set_lo(lomhz=f_lo, chan_spacing=1e-6 * f_lo_resolution)
sweep.stream_arrays.append(ri.get_measurement(num_seconds=stream_seconds, state=state))
finally:
ncf.close()
print("Wrote {}".format(ncf.root_path))
print("Elapsed time {:.0f} minutes.".format((time.time() - tic) / 60))
fft_gains = [6, 7, 8, 9]
tone_sample_exponent = 15
length_seconds = 0.1
wait = 10
# Hardware
conditioner = analog.Baseband()
shield = hardware.Thing(name='magnetic_shield_bucket', state={})
hw = hardware.Hardware(conditioner, shield)
ri = r2baseband.Roach2Baseband(roachip=ROACH2_IP, adc_valon=ROACH2_VALON)
ri.set_modulation_output('high')
ri.set_tone_freqs(freqs=frequency, nsamp=2**tone_sample_exponent)
# Run
sweeps = [
basic.SweepArray(core.IOList(),
description="T_c {:.1f} dB".format(attenuation))
for attenuation in attenuations
]
ncf = acquire.new_nc_file(suffix='Tc')
for sweep in sweeps:
ncf.write(sweep)
try:
while True:
for sweep, attenuation, fft_gain in zip(sweeps, attenuations,
fft_gains):
ri.set_fft_gain(fft_gain)
ri.set_dac_attenuator(attenuation)
sweep.stream_arrays.append(
ri.get_measurement(num_seconds=length_seconds,
state=hw.state()))
nsamp = 2**18 #going above 2**18 with 128 simultaneous tones doesn't quite work yet
offsets = np.arange(-16,16)*512./nsamp
mmw_freqs = np.linspace(140e9, 165e9, 500)
ri.set_dac_atten(20)
setup.hittite.off()
ri.set_modulation_output('high')
tic = time.time()
ncf = new_nc_file(suffix='mmw_source_sweep')
swpa = acquire.run_sweep(ri, tone_banks=initial_f0s[None,:] + offsets[:,None], num_tone_samples=nsamp,
length_seconds=0, verbose=True,
)
sweepstream = mmw_source_sweep.MMWSweepList(swpa, core.IOList(), state=setup.state())
ncf.write(sweepstream)
current_f0s = []
for sidx in range(initial_f0s.shape[0]):
swp = swpa.sweep(sidx)
res = swp.resonator
print res.f_0, res.Q, res.current_result.redchi, (initial_f0s[sidx]*1e6-res.f_0)
if np.abs(res.f_0 - initial_f0s[sidx]*1e6) > 200e3:
current_f0s.append(initial_f0s[sidx]*1e6)
print "using original frequency for ",initial_f0s[sidx]
else:
current_f0s.append(res.f_0)
print "fits complete", (time.time()-tic)/60.
current_f0s = np.array(current_f0s)/1e6
current_f0s.sort()
if np.any(np.diff(current_f0s)<0.015):