Exemplo n.º 1
0
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:
Exemplo n.º 8
0
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)
Exemplo n.º 10
0
    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))
Exemplo n.º 12
0
                                               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()
Exemplo n.º 14
0
    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))
Exemplo n.º 15
0
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)