def sweep_and_stream(df, roach, n_channels, approximate_stream_length, banks, overwrite_last, transient_wait=10): df.log_hw_state(roach) fine_sweep = sweeps.do_prepared_sweep(roach, nchan_per_step=n_channels, reads_per_step=2, banks=banks) df.add_sweep(fine_sweep) df.sync() fit_f0s = np.array([r.f_0 for r in acquire.fit_sweep_data(fine_sweep)]) timestream_frequencies = roach.add_tone_freqs( fit_f0s, overwrite_last=overwrite_last) roach.select_fft_bins(np.arange(n_channels)) roach.select_bank(roach.fft_bins.shape[0] - 1) roach._sync() time.sleep( transient_wait ) # The above commands create a transient that takes about 5 seconds to decay. df.log_hw_state(roach) start_time = time.time() stream, addresses = roach.get_data_seconds(approximate_stream_length, pow2=True) df.add_timestream_data(stream, roach, start_time) df.sync() return fit_f0s
def sweep_and_stream(df, roach, n_channels, approximate_stream_length, banks, overwrite_last, transient_wait=10): df.log_hw_state(roach) fine_sweep = sweeps.do_prepared_sweep(roach, nchan_per_step=n_channels, reads_per_step=2, banks=banks) df.add_sweep(fine_sweep) df.sync() fit_f0s = np.array([r.f_0 for r in acquire.fit_sweep_data(fine_sweep)]) timestream_frequencies = roach.add_tone_freqs(fit_f0s, overwrite_last=overwrite_last) roach.select_fft_bins(np.arange(n_channels)) roach.select_bank(roach.fft_bins.shape[0]-1) roach._sync() time.sleep(transient_wait) # The above commands create a transient that takes about 5 seconds to decay. df.log_hw_state(roach) start_time = time.time() stream, addresses = roach.get_data_seconds(approximate_stream_length, pow2=True) df.add_timestream_data(stream, roach, start_time) df.sync() return fit_f0s
def sweep_and_stream(df, roach, lockin, n_channels, approximate_stream_length, banks, overwrite_last, mmw_source_frequency, mmw_source_modulation_freq, transient_wait=10): df.log_hw_state(roach) fine_sweep = sweeps.do_prepared_sweep(roach, nchan_per_step=n_channels, reads_per_step=2, banks=banks) df.add_sweep(fine_sweep) df.sync() fit_f0s = np.array([r.f_0 for r in acquire.fit_sweep_data(fine_sweep)]) timestream_frequencies = roach.add_tone_freqs( fit_f0s, overwrite_last=overwrite_last) roach.select_fft_bins(np.arange(n_channels)) roach.select_bank(roach.fft_bins.shape[0] - 1) roach._sync() time.sleep( transient_wait ) # The above commands create a transient that takes about 5 seconds to decay. df.log_hw_state(roach) start_time = time.time() stream, addresses = roach.get_data_seconds(approximate_stream_length, pow2=True) x, y, r, theta = lockin.get_data( ) # I don't think this will actually work, but maybe it doesn't matter. df.add_timestream_data( stream, roach, start_time, mmw_source_freq=mmw_source_frequency, mmw_source_modulation_freq=mmw_source_modulation_freq, zbd_voltage=x) df.sync() return fit_f0s
def sweep_and_stream(df, roach, lockin, n_channels, approximate_stream_length, banks, overwrite_last, mmw_source_frequency, mmw_source_modulation_freq, transient_wait=10): df.log_hw_state(roach) fine_sweep = sweeps.do_prepared_sweep(roach, nchan_per_step=n_channels, reads_per_step=2, banks=banks) df.add_sweep(fine_sweep) df.sync() fit_f0s = np.array([r.f_0 for r in acquire.fit_sweep_data(fine_sweep)]) timestream_frequencies = roach.add_tone_freqs(fit_f0s, overwrite_last=overwrite_last) roach.select_fft_bins(np.arange(n_channels)) roach.select_bank(roach.fft_bins.shape[0]-1) roach._sync() time.sleep(transient_wait) # The above commands create a transient that takes about 5 seconds to decay. df.log_hw_state(roach) start_time = time.time() stream, addresses = roach.get_data_seconds(approximate_stream_length, pow2=True) x, y, r, theta = lockin.get_data() # I don't think this will actually work, but maybe it doesn't matter. df.add_timestream_data(stream, roach, start_time, mmw_source_freq=mmw_source_frequency, mmw_source_modulation_freq=mmw_source_modulation_freq, zbd_voltage=x) df.sync() return fit_f0s
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 = [45]#np.linspace(35,46,4)#[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: print "using original guess" meas_cfs.append(thiscf) else: print "using fmin"
except ValueError: print("Recording data.") break start_time = time.time() df = data_file.DataFile(suffix=suffix) df.nc.mmw_atten_turns = mmw_atten_turns # Take a coarse sweep with the source off at the lowest attenuation to get the approximate resonance frequencies. source_off() maximum_attenuation = max(attenuations) print("Setting DAC attenuator to {:.1f} dB for coarse sweep.".format(maximum_attenuation)) roach.set_dac_attenuator(maximum_attenuation) coarse_measured_frequencies = sweeps.prepare_sweep(roach, f0s, coarse_offset_frequencies, coarse_n_samples) df.log_hw_state(roach) coarse_sweep = sweeps.do_prepared_sweep(roach, nchan_per_step=f0s.size, reads_per_step=2) df.add_sweep(coarse_sweep) coarse_resonators = acquire.fit_sweep_data(coarse_sweep) coarse_fit_f0s = np.array([r.f_0 for r in coarse_resonators]) print("coarse - initial [Hz]: " + ', '.join(['{:.0f}'.format(1e6 * diff) for diff in coarse_fit_f0s - f0s])) # Record one stream at the lowest attenuation. mmw_source_modulation_freq = source_modulate() print("Set source modulation frequency to {:.1f} Hz.".format(mmw_source_modulation_freq)) modulated_measured_frequencies = roach.set_tone_freqs(coarse_fit_f0s, nsamp=fine_n_samples) roach.select_fft_bins(np.arange(f0s.size)) roach._sync() time.sleep(1) df.log_hw_state(roach) modulated_start_time = time.time() modulated_stream, addresses = roach.get_data_seconds(4)
for atten in attenlist: nsamp = 2**18 step = 1 nstep = 80 offset_bins = np.arange(-(nstep+1),(nstep+1))*step offsets = offset_bins*512.0/nsamp offsets = np.concatenate(([offsets.min()-20e-3,],offsets,[offsets.max()+20e-3])) source_off() print "setting attenuator to",atten ri.set_dac_attenuator(atten) measured_freqs = sweeps.prepare_sweep(ri,f0binned,offsets,nsamp=nsamp) print "loaded waveforms in", (time.time()-start),"seconds" sweep_data = sweeps.do_prepared_sweep(ri, nchan_per_step=atonce, reads_per_step=1) orig_sweep_data = sweep_data meas_cfs = [] idxs = [] delays = [] for m in range(len(f0s)): fr,s21,errors = sweep_data.select_by_freq(f0s[m]) thiscf = f0s[m] res = fit_best_resonator(fr[1:-1],s21[1:-1],errors=errors[1:-1]) #Resonator(fr,s21,errors=errors) delay = res.delay delays.append(delay) s21 = s21*np.exp(2j*np.pi*res.delay*fr) res = fit_best_resonator(fr,s21,errors=errors) fmin = fr[np.abs(s21).argmin()] print "s21 fmin", fmin, "original guess",thiscf,"this fit", res.f_0, "delay",delay,"resid delay",res.delay if use_fmin:
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: print "using original guess" meas_cfs.append(thiscf) else:
print len(f0s) mmw_freqs = np.linspace(140e9, 165e9, 500) use_fmin = False attenlist = [41] start = time.time() for atten in attenlist: hittite.off() print "setting attenuator to", atten ri.set_dac_attenuator(atten) measured_freqs = sweeps.prepare_sweep(ri, f0binned, offsets, nsamp=nsamp) print "loaded waveforms in", (time.time() - start), "seconds" sweep_data = sweeps.do_prepared_sweep(ri, nchan_per_step=atonce, reads_per_step=4) orig_sweep_data = sweep_data meas_cfs = [] idxs = [] delays = [] for m in range(len(f0s)): fr, s21, errors = sweep_data.select_by_freq(f0s[m]) thiscf = f0s[m] res = fit_best_resonator( fr[1:-1], s21[1:-1], errors=errors[1:-1]) #Resonator(fr,s21,errors=errors) delay = res.delay delays.append(delay) s21 = s21 * np.exp(2j * np.pi * res.delay * fr) res = fit_best_resonator(fr, s21, errors=errors)
print "*" * 40 print "Enter mmw attenuator values as a tuple i.e.: 6.5,6.5 or type exit to stop collecting data" mmw_atten_str = raw_input("mmw attenuator values: ") if mmw_atten_str == 'exit': source_off() break else: mmw_atten_turns = eval(mmw_atten_str) mmw_source_modulation_freq = source_on() print "setting attenuator to", attenlist[0] ri.set_dac_attenuator(attenlist[0]) f0binned = coarse_frequency_resolution * np.round(f0s / coarse_frequency_resolution) measured_freqs = sweeps.prepare_sweep(ri, f0binned, coarse_offset_freqs, nsamp=coarse_n_samples) print "loaded waveforms in", (time.time() - start), "seconds" sweep_data = sweeps.do_prepared_sweep(ri, nchan_per_step=f0s.size, reads_per_step=2) orig_sweep_data = sweep_data meas_cfs = [] idxs = [] delays = [] for m in range(len(f0s)): fr, s21, errors = sweep_data.select_by_freq(f0s[m]) thiscf = f0s[m] * source_on_freq_scale res = fit_best_resonator(fr[1:-1], s21[1:-1], errors=errors[1:-1]) # Resonator(fr,s21,errors=errors) delay = res.delay delays.append(delay) s21 = s21 * np.exp(2j * np.pi * res.delay * fr) res = fit_best_resonator(fr, s21, errors=errors) fmin = fr[np.abs(s21).argmin()] print "s21 fmin", fmin, "original guess", thiscf, "this fit", res.f_0, "delay", delay, "resid delay", res.delay if use_fmin:
start_time = time.time() df = data_file.DataFile(suffix=suffix) df.nc.mmw_atten_turns = mmw_atten_turns # Take a coarse sweep with the source off at the lowest attenuation to get the approximate resonance frequencies. source_off() maximum_attenuation = max(attenuations) print("Setting DAC attenuator to {:.1f} dB for coarse sweep.".format( maximum_attenuation)) roach.set_dac_attenuator(maximum_attenuation) coarse_measured_frequencies = sweeps.prepare_sweep( roach, f0s, coarse_offset_frequencies, coarse_n_samples) df.log_hw_state(roach) coarse_sweep = sweeps.do_prepared_sweep(roach, nchan_per_step=f0s.size, reads_per_step=2) df.add_sweep(coarse_sweep) coarse_resonators = acquire.fit_sweep_data(coarse_sweep) coarse_fit_f0s = np.array([r.f_0 for r in coarse_resonators]) print( "coarse - initial [Hz]: " + ', '.join( ['{:.0f}'.format(1e6 * diff) for diff in coarse_fit_f0s - f0s])) # Record one stream at the lowest attenuation. mmw_source_modulation_freq = source_modulate() print("Set source modulation frequency to {:.1f} Hz.".format( mmw_source_modulation_freq)) modulated_measured_frequencies = roach.set_tone_freqs(coarse_fit_f0s, nsamp=fine_n_samples) roach.select_fft_bins(np.arange(f0s.size))
pow2=True) df.add_timestream_data(stream, roach, start_time) df.sync() return fit_f0s # Take a coarse sweep with the source off at the lowest attenuation to get the approximate resonance frequencies. maximum_attenuation = max(attenuations) print("Setting DAC attenuator to {:.1f} dB for coarse sweep.".format( maximum_attenuation)) roach.set_dac_attenuator(maximum_attenuation) coarse_measured_frequencies = sweeps.prepare_sweep(roach, f0s, coarse_offset_frequencies, coarse_n_samples) coarse_sweep = sweeps.do_prepared_sweep(roach, nchan_per_step=n_channels, reads_per_step=2) coarse_resonators = acquire.fit_sweep_data(coarse_sweep) coarse_f0s = np.array([r.f_0 for r in coarse_resonators]) print("coarse - initial [Hz]: " + ', '.join(['{:.0f}'.format(1e6 * diff) for diff in coarse_f0s - f0s])) #for probe_channel, dummy_frequency, probe_detuning in zip(probe_channels, dummy_frequencies, probe_detunings): print("Probing channel {}. Setting sweep frequencies.".format(probe_channel)) probe_frequency = coarse_f0s[probe_channel] frequencies = coarse_f0s.copy() frequencies[probe_channel] = dummy_frequency order = frequencies.argsort() fine_frequencies = sweeps.prepare_sweep(roach, frequencies[order], fine_offset_frequencies, fine_n_samples)
coarse_sweep_on = acquire.sweep(roach, f_initial, coarse_exponent) f_fine_on = np.array([r.f_0 for r in acquire.fit_sweep_data(coarse_sweep_on)]) for loop_index,atten in enumerate([40,38,36,34,32]): roach.set_dac_attenuator(atten) df = data_file.DataFile(suffix=suffix) df.log_hw_state(roach) if True:#loop_index == 0 : fine_sweep_on = acquire.sweep(roach, f_fine_on, fine_exponent, transient_wait=0) else: fine_sweep_on = sweeps.do_prepared_sweep(roach,nchan_per_step=len(f_initial)) 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_initial])) df.add_sweep(fine_sweep_on) df.log_hw_state(roach) for k in range(num_streams): on_start_time = time.time() if k == 0: stream_on, address = acquire.timestream(roach, f_fine_on, stream_time, transient_wait=0) else: sweep = sweeps.do_prepared_sweep(roach,nchan_per_step=16) df.add_sweep(sweep) roach.select_bank(roach.tone_bins.shape[0] - 1) roach.select_fft_bins(range(roach.fft_bins.shape[1])) roach._sync()
roach._sync() time.sleep(transient_wait) # The above commands create a transient that takes about 5 seconds to decay. df.log_hw_state(roach) start_time = time.time() stream, addresses = roach.get_data_seconds(approximate_stream_length, pow2=True) df.add_timestream_data(stream, roach, start_time) df.sync() return fit_f0s # Take a coarse sweep with the source off at the lowest attenuation to get the approximate resonance frequencies. maximum_attenuation = max(attenuations) print("Setting DAC attenuator to {:.1f} dB for coarse sweep.".format(maximum_attenuation)) roach.set_dac_attenuator(maximum_attenuation) coarse_measured_frequencies = sweeps.prepare_sweep(roach, f0s, coarse_offset_frequencies, coarse_n_samples) coarse_sweep = sweeps.do_prepared_sweep(roach, nchan_per_step=n_channels, reads_per_step=2) coarse_resonators = acquire.fit_sweep_data(coarse_sweep) coarse_f0s = np.array([r.f_0 for r in coarse_resonators]) print("coarse - initial [Hz]: " + ', '.join(['{:.0f}'.format(1e6 * diff) for diff in coarse_f0s - f0s])) #for probe_channel, dummy_frequency, probe_detuning in zip(probe_channels, dummy_frequencies, probe_detunings): print("Probing channel {}. Setting sweep frequencies.".format(probe_channel)) probe_frequency = coarse_f0s[probe_channel] frequencies = coarse_f0s.copy() frequencies[probe_channel] = dummy_frequency order = frequencies.argsort() fine_frequencies = sweeps.prepare_sweep(roach, frequencies[order], fine_offset_frequencies, fine_n_samples) #for k, hittite_power in enumerate(hittite_powers): # for attenuation in attenuations: for k, attenuation in enumerate(attenuations): print("\nSetting DAC attenuator to {:.1f} dB.".format(attenuation))
f_fine_on = np.array([r.f_0 for r in acquire.fit_sweep_data(coarse_sweep_on)]) for loop_index, atten in enumerate([40, 38, 36, 34, 32]): roach.set_dac_attenuator(atten) df = data_file.DataFile(suffix=suffix) df.log_hw_state(roach) if True: #loop_index == 0 : fine_sweep_on = acquire.sweep(roach, f_fine_on, fine_exponent, transient_wait=0) else: fine_sweep_on = sweeps.do_prepared_sweep(roach, nchan_per_step=len(f_initial)) 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_initial ])) df.add_sweep(fine_sweep_on) df.log_hw_state(roach) for k in range(num_streams): on_start_time = time.time() if k == 0: stream_on, address = acquire.timestream(roach, f_fine_on, stream_time, transient_wait=0)