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 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))