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