def plot_pulse_cal_dac_offsets_vs_days(s, decimation=21):
    data_directory = ["", "Brooks", "pulseCal", "dac_step_offsets"]
    cxn = s._cxn
    d = dvw(data_directory, cxn)

    datasets = [29]
    datasets_ref = np.linspace(20, 39, 20)
    # datasets_ref = [20]
    datasets = np.linspace(40, 279, 240)
    markers = ["r-", "b-", "g-", "m-", "c-", "k-", "y-"]

    diff_chans = ["Diff+", "Diff-"]

    for data_ref in datasets_ref:
        data_ref = np.int(data_ref)
        for diff_chan in diff_chans:
            count = 0
            fig = plt.figure()
            for ds in datasets:
                ds = np.int(ds)
                print "ds: {}; %20: {}".format(ds, ds % 20)
                if (ds % 20) + 20 == data_ref:
                    data = d[ds]
                    print "current dataset: {}".format(ds)
                    data_times = data.get_column("Time")["us"]

                    data_voltage = data.get_column(diff_chan)["V"]

                    data_voltage, amp, offset = normalize_pulse(data_voltage, percent=1.0 / 15)

                    data_voltage = smoothing(data_voltage, decimation)
                    data_times = smoothing(data_times, decimation)

                    ref_data = d[np.int(data_ref)]
                    ref_voltage = ref_data.get_column(diff_chan)["V"]
                    ref_voltage, amp, offset = normalize_pulse(ref_voltage, percent=1.0 / 15)
                    ref_voltage = smoothing(ref_voltage, decimation)

                    plt.plot(
                        data_times,
                        data_voltage - ref_voltage,
                        markers[count % 7],
                        label="{}, step#: {}".format(diff_chan, count),
                    )
                    gc.collect()
                    count += 1
                    plt.title(
                        "Data-Reference vs Time.  ACQ:RESP: {}, low: {}; high: {}".format(
                            data.parameters["scope_response_filter"],
                            data.parameters["low_dac_amp"],
                            data.parameters["high_dac_amp"],
                        )
                    )
            plt.xlabel("Time (us)")
            plt.ylabel("% of step")
            plt.axis([-100, 700, -0.05, 0.05])
            plt.tight_layout()
            plt.legend(loc=4, numpoints=1)
            fig.savefig("{}; low_amp = {}.png".format(diff_chan, data.parameters["low_dac_amp"]), bbox_inches="tight")
            plt.close("all")
def plot_pulse_cals_vs_channels(s):
    data_directory = ["", "Brooks", "pulseCal", "AgilentDSA90804A"]
    cxn = s._cxn
    d = dvw(data_directory, cxn)

    datasets = [1, 2, 3, 4]

    plt.figure()
    plt.title("Calibration Pulse Different sample rates:  Ch1")
    markers = ["r-", "b-", "g-", "m-"]
    count = 0
    for ds in datasets:
        data = d[ds]
        data_times = data.get_column("Time")["ns"]
        data_voltage = data.get_column("Voltage")["V"]
        plt.plot(
            data_times / 1.0e3,
            data_voltage * 1.0e3 / 5,
            markers[count],
            label="ch{}".format(data.parameters["channel"]),
        )
        count += 1
    plt.xlabel("Time (us)")
    plt.ylabel("Voltage (% of step)")
    plt.legend(loc=4, numpoints=1)
def plot_pulse_cals_vs_y_pos(s):
    data_directory = ["", "Brooks", "pulseCal", "AgilentDSA90804A"]
    cxn = s._cxn
    d = dvw(data_directory, cxn)

    datasets = [104, 105, 106, 107, 108, 109, 110, 111, 112]
    plt.figure()
    plt.title("Calibration Pulse Different y_offset:  Ch1")
    markers = ["r-", "b-", "g-", "m-", "c-", "k-", "y-", "r--", "b--"]
    count = 0
    for ds in datasets:
        data = d[ds]
        data_times = data.get_column("Time")["ns"]
        data_voltage = data.get_column("Voltage")["V"]
        plt.plot(
            data_times[::2] / 1.0e3,
            data_voltage[::2] * 1.0e3,
            markers[count],
            label="{} V".format(data.parameters["y_position_v"]),
        )
        gc.collect()
        count += 1
    plt.xlabel("Time (us)")
    plt.ylabel("Voltage (mV)")
    plt.legend(loc=4, numpoints=1)
def plot_pulse_cal_steps(s):
    data_directory = ["", "Brooks", "pulseCal", "AgilentDSA90804A", "DAC_source"]
    cxn = s._cxn
    d = dvw(data_directory, cxn)

    datasets = np.linspace(4, 299, 296)
    # datasets = np.linspace(4, 20, 17)

    plt.figure()
    plt.title("Calibration Pulse Repetitions, Fs: 1e9Hz, 50mV/div:  Ch1")
    markers = ["r-", "b-", "g-", "m-", "c-", "k-", "y-", "r--"]
    count = 0
    for ds in datasets:
        if ds % 10 == 4:
            ds = np.int(ds)
            data = d[ds]
            print "current dataset: {}".format(ds)
            if data.parameters["dac_low_amp"] == -0.5:
                print "found match, dataset: {}".format(ds)
                data_times = data.get_column("Time")["ns"]
                data_voltage = data.get_column("Voltage")["V"]
                data_voltage -= np.mean(data_voltage)
                plt.plot(
                    data_times[::2] / 1.0e3, data_voltage[::2] * 1.0e3, markers[count % 7], label="{}".format(count)
                )
        gc.collect()
        count += 1
    plt.xlabel("Time (us)")
    plt.ylabel("Voltage (mV)")
    plt.legend(loc=4, numpoints=1)
def plot_pulse_cals_vs_x_axis(s):
    data_directory = ["", "Brooks", "pulseCal", "AgilentDSA90804A"]
    cxn = s._cxn
    d = dvw(data_directory, cxn)

    datasets = [24, 25, 26, 27, 28, 29, 30]

    plt.figure()
    plt.title("Calibration Pulse Different x-scales, 1e9Hz, 50mV/div:  Ch1")
    markers = ["r-", "b-", "g-", "m-", "c-", "k-", "y-", "r--"]
    count = 0
    for ds in datasets:
        data = d[ds]
        data_times = data.get_column("Time")["ns"]
        data_voltage = data.get_column("Voltage")["V"]
        plt.plot(
            data_times[::2] / 1.0e3,
            data_voltage[::2] * 1.0e3,
            markers[count],
            label="{} s/div".format(data.parameters["horizontal_scale"]),
        )
        gc.collect()
        count += 1
    plt.xlabel("Time (us)")
    plt.ylabel("Voltage (mV)")
    plt.legend(loc=4, numpoints=1)
def plot_pulse_cals_vs_sample_rate2(s):
    data_directory = ["", "Brooks", "pulseCal", "AgilentDSA90804A"]
    cxn = s._cxn
    d = dvw(data_directory, cxn)

    datasets = [11, 12, 13, 14, 15]

    plt.figure()
    plt.title("Calibration Pulse Different sample rates:  Ch1")
    markers = ["r-", "b-", "g-", "m-", "c-", "k-"]
    count = 0
    for ds in datasets:
        data = d[ds]
        data_times = data.get_column("Time")["ns"]
        data_voltage = data.get_column("Voltage")["V"]
        plt.plot(
            data_times[::2] / 1.0e3,
            data_voltage[::2] * 1.0e3,
            markers[count],
            label="Fs: {} Hz".format(data.parameters["sample_rate"]),
        )
        gc.collect()
        count += 1
    plt.xlabel("Time (us)")
    plt.ylabel("Voltage (mV)")
    plt.legend(loc=4, numpoints=1)
def plot_pulse_cals_vs_scales(s):
    data_directory = ["", "Brooks", "pulseCal", "AgilentDSA90804A"]
    cxn = s._cxn
    d = dvw(data_directory, cxn)

    datasets = [16, 17, 18, 19, 20, 21, 22, 23]

    plt.figure()
    plt.title("Calibration Pulse Different scaled, 1e9Hz:  Ch1")
    markers = ["r-", "b-", "g-", "m-", "c-", "k-", "y-", "r--"]
    count = 0
    for ds in datasets:
        data = d[ds]
        data_times = data.get_column("Time")["ns"]
        data_voltage = data.get_column("Voltage")["V"]
        plt.plot(
            data_times[::2] / 1.0e3,
            data_voltage[::2] * 1.0e3,
            markers[count],
            label="{} V/div".format(data.parameters["y_scale_v_per_div"]),
        )
        gc.collect()
        count += 1
    plt.xlabel("Time (us)")
    plt.ylabel("Voltage (mV)")
    plt.legend(loc=4, numpoints=1)
def plotPhaseCalPowers(s, IQ = True, chooseCal = False):
    dataDir = ['', 'Brooks', 'parAmp', 'impaNGC_CuBox_CuAuPCB', 'longZParamp', '160604'] #longZParamp in NGC Cu Box, CuAuPCB

    cxn = s._cxn

    d = dvw(dataDir,cxn)
    dataSets = d.keys()

    cm = plt.cm.get_cmap('RdYlBu')

    for dataSet in dataSets:
        if dataSet[-3::] == 'dBm':  #then scan is at 18dBm
            data = d[dataSet]
            color = np.float(string.split(data.parameters.get('loPower'))[0])
            print color
            
            phase = IQtoPhase(data['Q']/data['I'])
            
            if IQ:
                sc = plt.scatter(data['I'], data['Q'], c = np.zeros(len(phase)) + color, vmin = 0, vmax = 20, cmap = cm, edgecolors = 'none' )
            else:
                sc = plt.scatter(data['FluxV [V]'], phase, c = np.zeros(len(phase)) + color, vmin = 0, vmax = 20, cmap = cm, edgecolors = 'none' )
            
    
    plt.colorbar(sc, label = 'CW Tone Power (dBm)')
    if IQ:
        plt.title('IQ Plane vs CW Tone Power (dBm) @ 4.8 GHz',fontsize=20)
        plt.ylabel('Q (V)')
        plt.xlabel('I (V)')
    else:
        plt.title('Phase (rad) vs Flux Voltage (V) @ 4.8 GHz',fontsize=20)
        plt.ylabel('Phase (rad)')
        plt.xlabel('Flux Voltage (V)')
    plt.show()
def plotPhaseCalFreqs(sample, IQ = True, freq = None, chooseCal = False, dataDir = None):
    cxn = sample._cxn

    if dataDir == None:
        d = dvw(sample,cxn)
    else:
        d = dvw(dataDir,cxn)
    dataSets = d.keys()

    dataSets = dataSets[38::-1]

    cm = plt.cm.get_cmap('RdYlBu')

    freqtemp = freq
    if freq == None:
        freqtemp = 1.

    for dataSet in dataSets:
        if dataSet[-3::] == 'GHz' and (np.int(np.float(dataSet[-7:-4])*10.0) == np.int(10.0*freqtemp) or freq == None):  #then scan is at 18dBm
            data = d[dataSet]
            print dataSet
            color = np.float(data.parameters.get('loFreq')['Hz'])/1000000000.0
            pwr = np.float(data.parameters.get('loPower')['dBm'])
            print color

            phase = IQtoPhase(data['Q']/data['I'])

            # DCIQcofit(sample, dataSet = dataSet, plot = True,dataDir = None, useReg = False)
            if IQ:
                sc = plt.scatter(data['I'], data['Q'], c = np.zeros(len(phase)) + color, vmin = 4, vmax = 6.5, cmap = cm, edgecolors = 'none' )
            else:
                sc = plt.scatter(data['FluxV [V]'], phase, c = np.zeros(len(phase)) + color, vmin = 4, vmax = 6.5, cmap = cm, edgecolors = 'none' )

    plt.colorbar(sc, label = 'CW Tone Frequency (GHz)')
    if IQ:
        plt.title('IQ Plane: %s GHz @ %s dBm'%(color, pwr),fontsize=20)
        plt.ylabel('Q (V)')
        plt.xlabel('I (V)')
    else:
        plt.title('Phase (rad) vs Flux Voltage (V):  18dBm Drive',fontsize=20)
        plt.xlabel('Flux Voltage (V)')
        plt.ylabel('Phase (rad)')
    plt.show()
Exemplo n.º 10
0
def plot_pulse_cal_dac_offsets(s, decimation=21):
    data_directory = ["", "Brooks", "pulseCal", "dac_step_offsets"]
    cxn = s._cxn
    d = dvw(data_directory, cxn)

    datasets = [29]
    datasets.append(np.linspace(20, 28, 9))
    datasets.append(np.linspace(30, 39, 10))
    datasets = np.hstack(datasets)
    datasets = [21, 41]
    markers = ["r-", "b-", "g-", "m-", "c-", "k-", "y-"]

    diff_chans = ["Diff+", "Diff-"]

    for diff_chan in diff_chans:
        count = 0
        plt.figure()
        for ds in datasets:
            ds = np.int(ds)
            data = d[ds]
            print "current dataset: {}".format(ds)
            data_times = data.get_column("Time")["us"]

            data_voltage = data.get_column(diff_chan)["V"]

            data_voltage, amp, offset = normalize_pulse(data_voltage, percent=1.0 / 15)

            data_voltage = smoothing(data_voltage, decimation)
            data_times = smoothing(data_times, decimation)

            if count == 0:
                ref_voltage = data_voltage

            plt.plot(
                data_times,
                data_voltage - ref_voltage,
                markers[count % 7],
                label="{}, step#: {}".format(diff_chan, count),
            )
            gc.collect()
            count += 1
        plt.title(
            "0.1Dac_amp Step, diff_offset, Fs: 1e9Hz, 50mV/div:  Ch1, {} resp".format(
                data.parameters["scope_response_filter"]
            )
        )
        plt.xlabel("Time (us)")
        plt.ylabel("% of step")
        plt.axis([-100, 700, -0.15, 0.15])
        plt.tight_layout()
        plt.legend(loc=4, numpoints=1)
Exemplo n.º 11
0
def plot_pulse_cal_attens(s, decimation=55):
    data_directory = ["", "Brooks", "pulseCal", "fixed_sensitivity_atten_rfpg"]
    cxn = s._cxn
    d = dvw(data_directory, cxn)

    datasets = [2, 12, 10, 8, 6, 4]  # guassian
    datasets = [1, 11, 9, 7, 5, 3]  # flat

    plt.figure()

    markers = ["r-", "b-", "g-", "m-", "c-", "k-", "y-"]
    count = 0

    for ds in datasets:
        ds = int(ds)
        data = d[ds]
        print "current dataset: {}".format(ds)
        data_times = data.get_column("Time")["us"]
        data_voltage = data.get_column("Voltage")["V"]

        data_voltage, amp, offset = normalize_pulse(data_voltage, percent=1.0 / 15)

        data_voltage = smoothing(data_voltage, decimation)
        data_times = smoothing(data_times, decimation)

        if count == 0:
            ref_voltage = data_voltage

        plt.plot(
            data_times,
            data_voltage - ref_voltage,
            markers[count % 7],
            label="{} db".format(data.parameters["attenuation"]),
        )
        gc.collect()
        count += 1
    plt.title(
        "Calibration Pulse w/ different atten, Fs: 1e9Hz, 50mV/div:  Ch1, {} resp".format(
            data.parameters["scope_response_filter"]
        )
    )
    plt.xlabel("Time (us)")
    plt.ylabel("% of step")
    plt.axis([-100, 700, -0.15, 0.15])
    plt.tight_layout()
    plt.legend(loc=4, numpoints=1)
Exemplo n.º 12
0
def plot_pulse_cal_repetitions(s):
    data_directory = ["", "Brooks", "pulseCal", "AgilentDSA90804A"]
    cxn = s._cxn
    d = dvw(data_directory, cxn)

    datasets = np.linspace(36, 97, 62)

    plt.figure()
    plt.title("Calibration Pulse Repetitions, Fs: 1e9Hz, 50mV/div:  Ch1")
    markers = ["r-", "b-", "g-", "m-", "c-", "k-", "y-", "r--"]
    count = 0
    for ds in datasets:
        ds = np.int(ds)
        data = d[ds]
        data_times = data.get_column("Time")["ns"]
        data_voltage = data.get_column("Voltage")["V"]
        plt.plot(data_times[::2] / 1.0e3, data_voltage[::2] * 1.0e3, markers[count % 7], label="{}".format(count))
        gc.collect()
        count += 1
    plt.xlabel("Time (us)")
    plt.ylabel("Voltage (mV)")
    plt.legend(loc=4, numpoints=1)
Exemplo n.º 13
0
def checkStep(sample, stepDataSet, stepDataDir = None):
    cxn = sample._cxn
    
    # get calibration datasets
    if stepDataDir == None:
        d = dvw(sample, cxn)
    else:
        d = dvw(dataDir, cxn)
        
    stepData = d[stepDataSet]

    calDataSet = stepData.parameters['IQcalibrationDataSet']
    calDataDir = stepData.parameters['IQcalibrationDir']
    calD = dvw(calDataDir, cxn)

    calData = calD[calDataSet]
    fluxVcal = calData['FluxV']
    Ical = calData['I']
    Qcal = calData['Q']
    
    # convert flux voltage from dmmV to DAC amp
    fluxDACampCal = dmmVtoDACamp(fluxVcal * V, calData, useReg = False)
    # convert DAC amp flux voltage to flux
    fluxCal = dacAmpToFlux(fluxDACampCal, calData, useReg = False)
    
    # compute Cal phase
    phaseCal = IQtoPhase(Ical, Qcal)
    
    times = stepData['Time']
    fluxV = stepData['FluxV']
    fluxVDAC = scopeVtoDACamp(fluxV * V, stepData, useReg = False)
    flux = dacAmpToFlux(fluxVDAC, stepData, useReg = False)
    
    I = stepData['I']
    Q = stepData['Q']
    phase = IQtoPhase(I, Q)
    
    startI = stepData.parameters['startI']
    endI = stepData.parameters['endI']
    startQ = stepData.parameters['startQ']
    endQ = stepData.parameters['endQ']
    startDACamp = stepData.parameters['startDACamp']
    endDACamp = stepData.parameters['endDACamp']

    plt.figure()
    plt.title('I step vs expected')
    plt.plot(times, I, 'rs', label = 'response I')
    plt.plot([times[0],times[-1]], [startI, startI], 'b-', linewidth = 5, label = 'Expected Start I')
    plt.plot([times[0],times[-1]], [endI, endI], 'g-', linewidth = 5, label = 'Expected end I')
    plt.legend(numpoints = 1, loc = 3)
    plt.show()
    
    plt.figure()
    plt.title('Q step vs expected')
    plt.plot(times, Q, 'rs', label = 'response Q')
    plt.plot([times[0],times[-1]], [startQ, startQ], 'b-', linewidth = 5, label = 'Expected Start Q')
    plt.plot([times[0],times[-1]], [endQ, endQ], 'g-', linewidth = 5, label = 'Expected end Q')
    plt.legend(numpoints = 1, loc = 3)
    plt.show()
    
    plt.figure()
    plt.title('fluxV step vs expected')
    plt.plot(times, fluxVDAC, 'rs', label = 'response fluxV')
    plt.plot([times[0],times[-1]], [startDACamp, startDACamp], 'b-', linewidth = 5, label = 'Expected Start fluxV')
    plt.plot([times[0],times[-1]], [endDACamp,endDACamp], 'g-', linewidth = 5, label = 'Expected end fluxV')
    plt.legend(numpoints = 1, loc = 3)
    plt.show()
    
    
Exemplo n.º 14
0
def plot_settle_datasets(sample, set_qubits=None, set_amps=None, first=False,
                         directories=None, dir_sets=None,
                         plot=False, frequencies=False, title='', autoscale=True,
                         labels=None, plot_axes=[1, 5e5, 90.0, 100.4],
                         use_legend=True, leg_loc=4):
    if directories is None:
        directories = [sample._dir]

    colors = ['r', 'b', 'g', 'c', 'm', 'y', 'k']


    if dir_sets is not None:
        for dir_set in dir_sets:
            d = dvw(dir_set[0], sample._cxn)
            data = d[dir_set[1]]
            if 'Z Settle Time Long Rise' not in data.name:
                raise Exception('Error, this is not Z-settle dataset. Requested'
                                'data set is: {}'.format(data.name))

            qubit = data.parameters['measure'][0]
            q = data.parameters[qubit]

            # Get spec peaks
            fit_gauss_max = lambda x, y: fitting.getMaxGauss(x, y,
                                                             fitToMax=True)
            times, freqs_MHz = fitting.minima_cuts(data, 0, method=fit_gauss_max,
                                               plot=False)
            # offset datavault times by 50ns + spectroscopyLen/2
            spectroscopylen = data.parameters[qubit]['spectroscopyLen']['ns']
            times += 50 + spectroscopylen/2.

            # get zfunc and inverse zfunc
            Z = zfuncs.TransmonFrequency(q['zFuncAna'])

            def fit_settle(ts, a0, t0, a1, t1, a2, t2, b):
                outp = []
                for t in ts:
                    outp.append((a0 * np.exp(-t/t0)) + (a1 * np.exp(-t/t1)) + (a2 * np.exp(-t/t2)) + b)
                return np.array(outp)

            # seed estimates [A0, T0, A1, T1, A2, T2, B]
            # A0 ~ 5 MHz
            # A1 ~ 5 MHz
            # A2 ~ 1 MHz
            # T0 ~ 10 nsec
            # T1 ~ 1000 nsec
            # T2 ~ 50000 nsec
            # B ~ a frequency.

            # fit qubit frequency vs time
            popt1, pcov1 = curve_fit(fit_settle, times, freqs_MHz,
                                     p0=[5., 10., 5., 100., 1000., 50000.,
                                         freqs_MHz[-1]], maxfev=5200)

            # calculate step amplitude in frequency
            a0, t0, a1, t1, a2, t2, f_inf = popt1


            ordering = t0 < t1 and t1 < t2
            # if not ordering:
            #     raise Exception('Error! Time constants out of order! t0: {} ns;'
            #                     ' t1: {} ns; t2: {} ns'.format(t0, t1, t2))

            z_amp_inf = Z.freq_to_amp((f_inf / 1000.) * GHz)

            # plot_times
            plot_times = np.linspace(np.min(times), np.max(times), 1000)
            # compute frequencies for fit plot
            plot_frequencies = fit_settle(plot_times, a0, t0, a1, t1, a2, t2, f_inf)
            # scale fit frequencies to
            plot_z_amplitudes = Z.freq_to_amp((plot_frequencies / 1000.) * GHz)
            # scale z_amps to fraction
            plot_percent = plot_z_amplitudes * 100. / z_amp_inf

            # Amplitude of step from DAC
            z_amplitude = float(data.parameters['stack']['frame0']['arg']['z_amplitude'])

            if np.abs(z_amplitude-z_amp_inf) > 0.03:
                raise Exception('Error!  Requested amplitude ({}) and measured '
                                'amplitude ({}) do not match!'
                                ''.format(z_amplitude, z_amp_inf))

            # Amplitude of step according to zfunc
            zfunc_amplitudes = Z.freq_to_amp(freqs_MHz / 1000. * GHz)
            # normalized z_func_amplitudes
            zfunc_percent = 100. * zfunc_amplitudes / z_amp_inf

            # convert settle amplitudes to fraction of step
            f_step_amp = ((Z.amp_to_freq(0.0)['GHz']) * 1000.) - f_inf
            a0 /= f_step_amp
            a1 /= f_step_amp
            a2 /= f_step_amp

            f_step_amp = np.int(f_step_amp*10.)/10.
            # data plot
            if frequencies:
                plt.semilogx(times, freqs_MHz, lw=0, marker='s',
                             label='{}: z_amp: {}; f_amp: {} MHz'.format(
                                 qubit,
                                 z_amplitude, f_step_amp))
                plt.ylabel('Qubit Frequency (MHz)', fontsize=18)

                if not autoscale:
                    plt.axis(plot_axes)
                if len(dir_sets) == 1:
                    plt.semilogx(plot_times, plot_frequencies, lw=2, marker='s',
                                 markeredgecolor='none')

            else:
                plt.semilogx(times, zfunc_percent, lw=0, marker='s',
                             label='{}; {} MHz'.format(
                                 z_amplitude, f_step_amp))
                plt.ylabel('Z Amp (% of step)', fontsize=18)
                if not autoscale:
                    plt.axis(plot_axes)
            #  fit
            # plt.semilogx(x_vals/1e3,y_vals*100, color = colors[counter], lw = 2, marker = None, label = 'z_step_amp: %s ;Tshort %s us; Ashort: %s; Tlong %s us; Along: %s'%(str(z_amplitude),str(shortTime), str(shortAmp), str(longTime), str(longAmp)))
                if len(dir_sets) == 1:
                    plt.semilogx(plot_times, plot_percent, lw=2, marker='s', markeredgecolor='none')

        if plot:
            plt.title(title,
                      fontsize=18)

            plt.xlabel('Time (ns)', fontsize=18)
            plt.tick_params(labelsize=15)
            if use_legend:
                if labels is not None:
                    plt.legend(labels, numpoints=1, loc=leg_loc)
                else:
                    plt.legend(numpoints=1, loc=leg_loc)
            plt.tight_layout()
            plt.show()

        if False:
            plt.figure()
            plt.title(
                'Settle Amplitude vs Step Amplitude: a0*exp(-t/t0) + a1*exp(-t/t1) + a2*exp(-t/t2)',
                fontsize=11)
            plt.ylabel('Settle amplitude (% of step)')
            plt.xlabel('Step amplitude (DAC units)')
            plt.plot(zamps, a0s, 'rs', label='a0s')
            plt.plot(zamps, a1s, 'bs', label='a1s')
            plt.plot(zamps, a2s, 'gs', label='a2s')
            plt.legend(numpoints=1, loc=2)
            plt.axis(plot_axes)
            plt.tight_layout()
            plt.show()

            plt.figure()
            plt.title(
                'Settle Amplitude vs Step Amplitude: a0*exp(-t/t0) + a1*exp(-t/t1) + a2*exp(-t/t2)',
                fontsize=11)
            plt.ylabel('Settle amplitude (% of step)')
            plt.xlabel('Step amplitude (DAC units)')
            plt.semilogy(zamps, np.abs(a0s), 'rs', label='a0s')
            plt.semilogy(zamps, np.abs(a1s), 'bs', label='a1s')
            plt.semilogy(zamps, np.abs(a2s), 'gs', label='a2s')
            plt.legend(numpoints=1, loc=3)
            # plt.axis([-1.0,1.0, 0, 10])
            plt.tight_layout()
            plt.show()

            plt.figure()
            plt.title(
                'Settle Times vs Step Amplitude: a0*exp(-t/t0) + a1*exp(-t/t1) + a2*exp(-t/t2)',
                fontsize=11)
            plt.ylabel('Settle Time nsec')
            plt.xlabel('Step amplitude (DAC units)')
            plt.semilogy(zamps, t0s, 'rs', label='t0s')
            plt.semilogy(zamps, t1s, 'bs', label='t1s')
            plt.semilogy(zamps, t2s, 'gs', label='t2s')
            plt.legend(numpoints=1, loc=2)
            # plt.axis([-1.0,1.0, 0, 10])
            plt.tight_layout()
            plt.show()

    return times, zfunc_percent
Exemplo n.º 15
0
def cal_IQ(sample, DACamps=np.linspace(-1.0,1.0,num=101)/4.0, loFreq=6.4 * GHz,
            loPower=18.0 * dBm, averages=5, name='DC_calibration',
            update=True, calScope=True, useScope=False):
    if calScope and not useScope:
        calibrateToDAC(sample, numPoints = 7, plot = False)
    
    with labrad.connect() as cxn1:
        independents = [('FluxV','V')]
        dependents = [('I','','V'),('Q','','V')]
        
        # create a DV reference for storing the summary data
        dv1 = cxn1.data_vault
        dv1.cd(sample._dir, True)
        dv1.new(name, independents, dependents)

        cxn = sample._cxn
        adr = cxn.adr_server
        ADR = adr.list_devices()

        sample['ADR'] = '%s'%ADR
        sample['averages'] = averages
        adr.select_device()
        temperatures = adr.temperatures()
        sample['50K_Temp'] = temperatures[0]
        sample['4K_Temp'] = temperatures[1]
        sample['4K_Mag_Temp'] = temperatures[2]
        ruox = adr.ruox_status()
        sample['Ruox_Temp'] = ruox[0]
        sample['Ruox_Resistance'] = ruox[1]
        sample['Magnet_Current'] = adr.magnet_status()[0]
        sample['Magnet_Voltage'] = adr.magnet_status()[1]
                
        p1 = dv1.packet()
        start = time.time()
        sample['Start_time'] = start*1e9*ns
        d = dvw(sample, cxn)
        
        sample['IQcalibrationDir'] = sample._dir
        sample['IQcalibrationDataSet'] = d[-1].name
        sample['scanType'] = 'DC_calibration'
        if useScope:
            sample['DC_inst'] = 'Infiniium Scope'
        else:
            sample['DC_inst'] = 'Three Agilent DMMs'
        
        #set FPGA voltage
        DAC_DC(sample, amp = DACamps[0])
                
        # Set up Hittite
        config_Hittite(sample, loFreq = loFreq, loPower = loPower, outputState = 'ON')
        
        if not useScope:
            # Configure DMMS
            dmm = cxn.agilent_34401a_dmm
            dmms = dmm.list_devices()
        
        for val in DACamps:
            I = []
            Q = []
            fluxV = []
            print 'Current DC voltage:  ', val
            
            # Set DAC Value
            DAC_DC(sample, amp = val)
            time.sleep(1)
            
            if useScope:
                data = InfiniiumScan(sample, averages = averages, config = True, record = False, name = 'Scopetrace', sampleRate = 40e9, horizScale = 1e-06, trig_level = 0.0, amp = val)
                fluxV = np.array(data.T[1]).mean()
                I = np.array(data.T[2]).mean()
                Q = np.array(data.T[3]).mean()
            #Take DMM points and average
            else:
                avgCount = 0
                while avgCount < averages:
                    dmm.select_device(dmms[0][1])
                    I.append(dmm.voltage()['V'])
                    dmm.select_device(dmms[1][1])
                    Q.append(dmm.voltage()['V'])
                    dmm.select_device(dmms[2][1])
                    fluxV.append(dmm.voltage()['V'])
                    avgCount += 1

                I = np.array(I).mean()
                Q = np.array(Q).mean()
                fluxV = np.array(fluxV).mean()

            print 'fluxV: ',fluxV
            print 'I: ',I
            print 'Q: ',Q

            currentTime = time.time()-start
                      
            dataPoint=[]
            dataPoint.append(fluxV)
            dataPoint.append(I)
            dataPoint.append(Q)
            dataPoint = np.array(dataPoint).T
            dv1.add(dataPoint)
            
        DCIQcofit(sample, dataSet = None, plot = False, dataDir = None, useReg = True)
        
        for key in sample.keys():
            p1.add_parameter(key, sample.__getitem__(key))
        p1.send()
    
    
    DAC_DC(sample, amp = 0.0)
    config_Hittite(sample, loFreq = loFreq, loPower = loPower,  outputState = 'OFF')
Exemplo n.º 16
0
def IQtoFluxStep(s, dataDir = ['', 'Brooks', 'parAmp', 'impaNGC_CuBox_CuAuPCB', '151218', 'step'], box = ''):

    if box == 'UCSB':
        dataDir = ['', 'Brooks', 'parAmp', 'impaUCSBAlBox', '151118', 'calibration'] #UCSB IMPA Box
        dataSet = 783
        dataSet = 889
        dataSet = 513

    if box == 'NGC Cu':
        dataDir = ['', 'Brooks', 'parAmp', 'impaNGC_CuBox_CuAuPCB', '151218', 'step']
        dataSet = 783
    if box == 'NGC Cu2':
        dataDir = ['', 'Brooks', 'parAmp', 'impaNGC_CuBox_CuAuPCB', '160109', 'step']
        dataSet = 853

    # Get Calibration
    fluxVScale, fluxVOffset, aI, aQ, thetaI, thetaQ, Z0, Ic = DCIQcofit(s, plot = False, bound = 0.1, dataDir = dataDir, box = box)
    # poptQ, pcovQ, poptI, pcovI, popt1 = fitIQ(s, dataSet = 34, plot = False)

    phi0 = 2.067833758 * (10**-15)  #Wb
    omega = 2 * np.pi * 4.2 * 10**9 # rad/sec
    cap = 4.0 * 10**-12 # Farads


    cxn = s._cxn

    d = dvw(dataDir,cxn)
    dataSets = d.keys()
    # dataSets = dataSets[538:850]
    # dataSets = dataSets[538:850]
    # dataSets = dataSets[1220:1221]

    if box == 'UCSB':
        dataSets = dataSets[889:1254]
        # dataSets = dataSets[::-1]
        # dataSets = dataSets[14::]
        dataSets = dataSets[::20]

    if box == 'NGC Cu':
        # dataSets = dataSets[20:341]
        dataSets = dataSets[365::]
        dataSets = dataSets[::-1]
        dataSets = dataSets[17::]
        dataSets = dataSets[::20]

    if box == 'NGC Cu2':
        # dataSets = dataSets[dataSet+1:133]
        # dataSets = dataSets[::4]
        dataSets = [dataSets[4]]
        # dataSets = dataSets[0:1]
        # del dataSets[3]


    cm = plt.cm.get_cmap('RdYlBu')

    for dataSet in dataSets:
        #
        # Import Data Set:  Time, fluxV, I and Q
        #
        data = d[dataSet]
        color = np.float(string.split(data.parameters.get('stepAmp'))[0])
        print 'color:  ',color
        if color > 0.28:
            decimation = 1
            times = data.T[0]
            fluxV = data.T[1]
            flux = (fluxV * fluxVScale + fluxVOffset - np.pi/2)/np.pi
            I = data.T[2]
            Q = data.T[3]


            #
            # Shift I and Q data back in time to align step edge
            #
            shift = 38.9e-9 # sec
            shiftPts = np.int(shift/(((times.max()-times.min())/len(times))*10e-10))
            print 'shiftPts:  ',shiftPts
            times = np.array(times[:-shiftPts])
            flux = np.array(flux[:-shiftPts])
            fluxV = np.array(fluxV[:-shiftPts])
            I = np.array(I[shiftPts:])
            Q = np.array(Q[shiftPts:])



            #
            # Rotate I and Q by fit params (arbitrary theta rotation) back to 0.
            #
            Iscaled = aI * (I * np.cos(-thetaI) - Q * np.sin(-thetaI))
            Qscaled = aQ * (I * np.sin(-thetaQ) + Q * np.cos(-thetaQ))

            # if box == 'NGC Cu' or box == 'NGC Cu2':
            if box == 'NGC Cu':
                thetaI = 1.5
                thetaQ = 1.5
                Iscaled = 1 * (I * np.cos(-thetaI) - Q * np.sin(-thetaI))
                Qscaled = 1 * (I * np.sin(-thetaQ) + Q * np.cos(-thetaQ))
            # Iscaled = I
            # Qscaled = Q

            #
            # Compute and unwrap the phase
            # reverse the phase for unwrapping since the ending phase should always be the same.
            #
            # I = I[::-1]
            # Q = Q[::-1]
            phases = np.arctan(Qscaled/Iscaled)
            phases = (np.unwrap(phases[::-1]*2, discont = np.pi)/2)/np.pi
            phases = phases[::-1]

            #
            # Compute Lj from phase and fit params
            #

            Lj = 1/(omega *((np.tan(phases)/(2*Z0)) + (omega * cap)))


            #
            # Compute phi/phi0 from Lj and fit params
            #

            fluxComputed = np.arccos((phi0/(Lj * 2 * np.pi * Ic)))/np.pi


            #
            # Decimate to plot
            #
            times = times [::decimation]
            flux = flux[::decimation]
            fluxV = fluxV[::decimation]
            I = I[::decimation]
            Q = Q[::decimation]
            phases = phases[::decimation]
            fluxComputed = fluxComputed[::decimation]
            #
            #  Convert phase to

            A1 = np.array(flux[100]).mean()
            B1 = np.array(flux[-100:]).mean()

            A2 = np.array(fluxComputed[100]).mean()
            B2 = np.array(fluxComputed[-100]).mean()

            fluxComputed = (fluxComputed - A2)/(B1-A1)
            flux= (flux - A1)/(B1-A1)


            # phase = np.arctan(Q/I)
            cm = plt.cm.get_cmap('RdYlBu')
            # sc = plt.scatter(times, phases, c = np.zeros(len(times)) + color, vmin = 0, vmax = 3.5, cmap = cm, edgecolors='none')
            if max(np.abs(phases)) < 60 and (np.max(phases) - np.min(phases) > 0.75):
                # sc = plt.scatter(times, fluxComputed, c = np.zeros(len(times)) + color, vmin = 0.3, vmax = 3.5, cmap = cm, edgecolors='none', alpha = 0.5, label = '%s V'%color)
                # sc = plt.scatter(times, flux, c = np.zeros(len(times)) + color, vmin = 0.3, vmax = 3.5, cmap = cm, edgecolors='none', alpha = 0.5, label = '%s V'%color)
                plt.plot(times, fluxComputed, 'rs--', label = 'response', markeredgecolor='none')
                plt.plot(times, flux, 'bo--', label = 'input', markeredgecolor='none')
                # plt.plot(times, fluxComputed/flux, 'cs--', label = 'input', markeredgecolor='none')

            # plt.plot(times, phases, alpha = 0.5, c = color, cmap = cm)

            # Lj = 2 * Z0 / (np.tan(phases%np.pi) - 2 * omega * cap * Z0)
            # computedFlux = (1/np.pi) * np.arccos(phi0 / (2 * np.pi * Ic * Lj))
            # sc = plt.scatter(times, computedFlux, c = np.zeros(len(times)) + color, vmin = 0, vmax = 3.5, cmap = cm, edgecolors='none')


            # plt.colorbar(sc, label = 'Step Voltage (Volts)')
            # plt.title('Output Phase/Input Voltage vs. Time (nsec)',fontsize=20)
            # plt.ylabel('Arb (not even linear)')
            plt.title('Flux (Phi0) vs. Time (nsec)',fontsize=20)
            plt.ylabel('Flux (Phi0)')
            plt.xlabel('Time (nsec)')
            plt.legend(numpoints =1,loc = 1)
            # plt.axis([-10, 100, -0.2,0.2 ])
            plt.show()
Exemplo n.º 17
0
def DCIQcofit(sample, dataSet = None, plot = False, bound = 0.15, dataDir = None, useReg = False):

    cxn = sample._cxn
    dvw.cache.clear()
    if dataDir == None:
        d = dvw(sample['IQcalibrationDir'], cxn)
    else:
        d = dvw(dataDir,cxn)

    if dataSet == None:
        dataSet = sample['IQcalibrationDataSet']

    #
    # Import Data Set:  fluxV, I and Q
    #
    data = d[dataSet]
    I = data['I']
    Q  = data['Q']
    fluxV = data['FluxV']

    # convert flux voltage from DMM volts to DAC amp using the scaling from the datavault
    if useReg:
        paramSource = sample
    else:
        paramSource = data

    #convert flux voltage from DMM volts to DAC amp
    fluxV = dmmVtoDACamp(fluxV * V, paramSource, useReg = useReg)



    phase = IQtoPhase(I, Q)


    # create interp with linear spacing in flux.
    phaseToVolts = sc.interpolate.interp1d(phase, fluxV)
    voltsToPhase = sc.interpolate.interp1d(fluxV, phase)

    linFluxV = np.linspace(np.min(fluxV), np.max(fluxV), 501)
    linPhase = voltsToPhase(linFluxV)


    #
    #  Function to fit the fluxV per Phi0 period
    #
    def periodFit(fluxV, Amplitude, Offset, Phase, Period):
        return Amplitude * np.abs(np.cos(fluxV * Period  + Phase)) + Offset

    # p0s = [Amplitude, Offset, Phase, Period]

    p0s = [1.3,-1.0,0.1 * np.pi ,2*np.pi/0.7]
    poptA, pcovA = curve_fit(periodFit, linFluxV, linPhase, p0 = p0s, maxfev = 5200)

    p0s = [1.3,-1.0,0.5 * np.pi ,2*np.pi/0.7]
    poptB, pcovB = curve_fit(periodFit, linFluxV, linPhase, p0 = p0s, maxfev = 5200)

    perrA = np.linalg.norm(np.sqrt(pcovA[2][2]**2 + pcovA[3][3]**2))
    perrB = np.linalg.norm(np.sqrt(pcovB[2][2]**2 + pcovB[3][3]**2))

    if perrA < perrB:
        popt = poptA
        pcov = pcovA

    else:
        popt = poptB
        pcov = pcovB


    dacAmpToFluxGain = popt[3]/np.pi
    dacAmpToFluxOffset = popt[2]/np.pi

    sample['dacAmpToFluxGain'] = dacAmpToFluxGain
    sample['dacAmpToFluxOffset'] = dacAmpToFluxOffset

    print 'Volts per cycle: ', (2.0/dacAmpToFluxGain)
    print 'Volts shift:  ', dacAmpToFluxOffset

    #
    # plot fit on data.
    #
    xvals = np.linspace(np.min(fluxV), np.max(fluxV), 601)
    yvals = periodFit(xvals, popt[0], popt[1], popt[2], popt[3])

    if plot:
        plt.figure()
        plt.plot(xvals, yvals, 'b--', label = 'fit')
        plt.plot(linFluxV, linPhase, 'rs', label = 'data')
        plt.title('Make sure fit period and phase match data',fontsize=20)
        plt.ylabel('phase (arb)')
        plt.xlabel('Flux Voltage (Volts)')
        plt.legend(numpoints =1,loc = 1)
        plt.show()

    flux = dacAmpToFlux(linFluxV, paramSource, useReg = useReg)

    sample['minFlux'] = np.min(flux)
    sample['maxFlux'] = np.max(flux)

    if plot:
        plt.figure()
        plt.plot(flux, linPhase, 'rs', label = 'Phase')
        plt.title('Make sure Phase centered at 0 flux and zero at phi0/2',fontsize=20)
        plt.ylabel('Phase (rad)')
        plt.xlabel('Flux (phi0)')
        plt.show()
Exemplo n.º 18
0
def step_response(sample, startFlux = 0.0, endFlux = 0.39, averages = 50, plot = False, sampleRate = 5e8, horizScale = 203e-06):
    cxn = sample._cxn
    
    dvw.cache.clear()
    print 'DIR:  ', sample['IQcalibrationDir']
    print 'DataSet:  ', sample['IQcalibrationDataSet']
    d = dvw(sample['IQcalibrationDir'], cxn)
    dataSet = sample['IQcalibrationDataSet']
    calData = d[dataSet]
    
    Ical = calData['I']
    Qcal = calData['Q']

    # get FluxV in DMM volts and scale to DACamp
    fluxV = calData['FluxV']
    fluxV = dmmVtoDACamp(fluxV*V, calData, useReg = False)
    
    # compute phase and unwrap
    phase = IQtoPhase(Ical, Qcal)
    
    # generate interpolation functions from calibration
    phaseToVolts = sc.interpolate.interp1d(phase, fluxV)
    voltsToPhase = sc.interpolate.interp1d(fluxV, phase)
    dacAmpToI = sc.interpolate.interp1d(fluxV, Ical)
    dacAmpToQ = sc.interpolate.interp1d(fluxV, Qcal)
    

    
    #  Config Hittite to match settings from calibration
    config_Hittite(sample,
                   loFreq = calData.parameters['loFreq'], 
                   loPower = calData.parameters['loPower'],
                   outputState = 'ON')
    
    
    sample['startFlux'] = startFlux
    sample['endFlux'] = endFlux
    #  Compute start and end DAC amps to generate the step
    startDACamp = fluxToDACamp(startFlux, calData, useReg = False)
    endDACamp = fluxToDACamp(endFlux, calData, useReg = False)
    sample['startDACamp'] = startDACamp
    sample['endDACamp'] = endDACamp
    
    #  Compute start and end DMM voltages
    startDMMvoltage = dacAmpToDMMV(startDACamp, calData, useReg = False)
    endDMMvoltage = dacAmpToDMMV(endDACamp, calData, useReg = False)
    sample['startDMMvoltage'] = startDMMvoltage
    sample['endDMMvoltage'] = endDMMvoltage
    
    #  Compute start and end DMM voltages
    startScopeVoltage = dacAmpToScopeV(startDACamp, calData, useReg = False)
    endScopeVoltage = dacAmpToScopeV(endDACamp, calData, useReg = False)
    sample['startScopeVoltage'] = startScopeVoltage
    sample['endScopeVoltage'] = endScopeVoltage
    
    #  Compute start and end I values
    startI = np.float(dacAmpToI(startDACamp))
    endI = np.float(dacAmpToI(endDACamp))
    print 'startI: ', type(startI), startI
    sample['startI'] = startI
    sample['endI'] = endI
    
    #  Compute start and end Q values
    startQ = np.float(dacAmpToQ(startDACamp))
    endQ = np.float(dacAmpToQ(endDACamp))
    sample['startQ'] = startQ
    sample['endQ'] = endQ
    
    
    print ''
    print ''
    print 'start I voltage: %s , end I voltage:  %s'%(startI, endI)
    print 'start Q voltage: %s , end Q voltage:  %s'%(startQ, endQ)
    print 'start Flux: %s , end Flux:  %s'%(startFlux, endFlux)
    print 'start DAC voltage: %s , end DAC voltage:  %s'%(startDACamp, endDACamp)
    print 'start DMM voltage: %s , end DMM voltage:  %s'%(startDMMvoltage, endDMMvoltage)
    print 'start scope voltage: %s , end scope voltage:  %s'%(startScopeVoltage, endScopeVoltage)
    print ''
    print ''
    
    sample['scanType'] = 'step_response'
    DAC_square(sample, lowAmp = startDACamp, highAmp = endDACamp)
    
    xs = []
    ys = []
    zs = []
    for (x,y,z) in zip(fluxV, Ical, Qcal):
        if np.min([startDACamp, endDACamp]) < x and x < np.max([startDACamp, endDACamp]):
           xs.append(x)
           ys.append(y)
           zs.append(z)
    
    minI = np.min(ys)
    maxI = np.max(ys)
    print 'minI: %s ; maxI: %s'%(minI, maxI)
    
    minQ = np.min(zs)
    maxQ = np.max(zs)
    print 'minQ: %s ; maxQ: %s'%(minQ, maxQ)
    
    overRange = (3.0/8.0) #150% of range/ 8 divisions
    
    # compute scales and y positions for scope channels
    # scales = [np.abs(startScopeVoltage['V'] - endScopeVoltage['V'])*overRange, np.abs(minI-maxI)*overRange, np.abs(minQ-maxQ)*overRange, 0.5]
    # positions = [np.mean([startScopeVoltage['V'],endScopeVoltage['V']]), np.mean([minI,maxI]), np.mean([minQ,maxQ]), 0.0]
    trig_level = np.mean([startScopeVoltage['V'],endScopeVoltage['V']])+ 0.0 * np.abs(endScopeVoltage['V'] - startScopeVoltage['V'])
    print 'Trigger at: ', trig_level
    
    fluxVsub = np.array(xs)
    phaseSub = voltsToPhase(xs)
    Isub = dacAmpToI(xs)
    Qsub = dacAmpToQ(xs)

    if plot:
        # plt.figure()
        # plt.title('Calibration IQ points vs DMM Flux Voltage')
        # plt.plot(dacAmpToFlux(fluxV, calData, useReg = False), phase, 'rs-', label = 'phase')
        # plt.plot(dacAmpToFlux(fluxVsub, calData, useReg = False), phaseSub, 'bs', label = 'step phase')
        # plt.xlabel('Flux (phi0)')
        # plt.ylabel('DMM Volts')
        # plt.legend(numpoints = 1, loc = 4)
        # plt.show()
    
        # plt.figure()
        # plt.title('Calibration Phase vs DAC amp')
        # plt.plot(fluxV, phase, 'rs-', label = 'phase')
        # plt.plot(fluxVsub, phaseSub, 'bs', label = 'step phase')
        # plt.xlabel('DAC amp')
        # plt.ylabel('rad')
        # plt.legend(numpoints = 1, loc = 4)
        # plt.show()
    
        plt.figure()
        plt.title('Calibration IQ points vs DAC amp')
        plt.plot(fluxV, Ical, 'r-', label = 'I')
        plt.plot(fluxVsub, Isub, 'rs', label = 'Istep')
        plt.plot(fluxV, Qcal, 'b-', label = 'Q')
        plt.plot(fluxVsub, Qsub, 'bs', label = 'Qstep')
        plt.plot(startDACamp, startI, 'rx', markersize = 10, linewidth = 10, label = 'start I')
        plt.plot(startDACamp, startQ, 'bx', markersize = 10, linewidth = 10, label = 'start Q')
        plt.plot(endDACamp, endI, 'rs', markersize = 10, linewidth = 10, label = 'end I')
        plt.plot(endDACamp, endQ, 'bs', markersize = 10, linewidth = 10, label = 'end Q')
        plt.xlabel('DAC amp')
        plt.ylabel('Scope Volts')
        plt.legend(numpoints = 1, loc = 4)
        plt.show()

    # plt.figure()
    # plt.title('Calibration IQ points vs DMM Flux Voltage')
    # plt.plot(fluxV, calData['I'], 'rs-', label = 'I')
    # plt.plot(fluxV, calData['Q'], 'bs-', label = 'Q')
    
    # plt.xlabel('Flux Voltage (DMM volts)')
    # plt.ylabel('DMM Volts')
    # plt.legend(numpoints = 1, loc = 4)
    # plt.show()

    
    stepResp = InfiniiumScan(sample, averages = averages, sampleRate = sampleRate, 
                  horizScale = horizScale, config = True, record = True, 
                  name = 'step_response', 
                  trig_level = trig_level)
    if plot:
        checkStep(sample, -1)
    # times = stepResp.T[0]
    # inputVoltage = stepResp.T[1] * V
    # respI = stepResp.T[2]
    # respQ = stepResp.T[3]

    # plt.figure()
    # plt.title('I step vs expected')
    # plt.plot(times, respI, 'rs', label = 'response I')
    # plt.plot([times[0],times-1], [startScopeV, startScopeV], 'b-', linewidth = 5, label = 'Expected Start I')
    # plt.plot([times[0],times-1], [endScopeV, endScopeV], 'g-', linewidth = 5, label = 'Expected end I')
    # plt.legend(numpoints = 1, loc = 3)
    # plt.show()
    

    
    # # inputVoltage = scopeVtoDACamp(inputVoltage, calData, useReg = False)
    # # inputPhase = voltsToPhase(inputVoltage)
    # # # inputFlux = dacAmpToFlux(inputVoltage, calData, useReg = False)
    
    # responsePhase = np.arctan(respQ/respI)
    # responsePhase = ((np.unwrap(responsePhase[::-1]*2, discont = np.pi)/2)/np.pi)[::-1]
    
    # # responseFluxV = phaseToVolts(responsePhase)
    # # responseFlux = dacAmpToFlux(responsePhase)
    
    # # plt.plot(times, inputPhase, 'r-', label = 'input Flux')
    # plt.plot(times, responsePhase, 'b-', label = 'response Flux')
    # plt.xlabel('times')
    # plt.ylabel('flux (Phi0)')
    # plt.legend(loc = 4, numpoints = 1)
    # plt.show()
    del sample['startFlux']
    del sample['endFlux']
    del sample['startDACamp'] 
    del sample['endDACamp']
    del sample['startDMMvoltage']
    del sample['endDMMvoltage']
    del sample['startScopeVoltage'] 
    del sample['endScopeVoltage']
    
    return stepResp
Exemplo n.º 19
0
def summary(s, set_qubit=None, directory=None, plot=False, Brass=False,
            falling=False, set_amps=None, frequencies=False):
    dataDirsTFunc = []
    longZdataSets = []

    # Directory to look for settle times:
    if directory is None:
        dataDirsTFunc.append(['', 'Brooks', 'qubitData', 'NGQ', '141020'])
    else:
        dataDirsTFunc.append(directory)

    cxn = s._cxn
    plt1 = plt.figure()
    counter = 0
    colors = ['r', 'b', 'g', 'c', 'm', 'y', 'k', 'r', 'b', 'g', 'c', 'm', 'y',
              'k', 'r', 'b', 'g', 'c', 'm', 'y', 'k', 'r', 'b', 'g', 'c', 'm',
              'y', 'k', 'r', 'b', 'g', 'c', 'm', 'y', 'k', 'r', 'b', 'g', 'c',
              'm', 'y', 'k', 'r', 'b', 'g', 'c', 'm', 'y', 'k', 'r', 'b', 'g',
              'c', 'm', 'y', 'k', 'r', 'b', 'g', 'c', 'm', 'y', 'k', 'r', 'b',
              'g', 'c', 'm', 'y', 'k', 'r', 'b', 'g', 'c', 'm', 'y', 'k', 'r',
              'b', 'g', 'c', 'm', 'y', 'k', 'r', 'b', 'g', 'c', 'm', 'y', 'k',
              'r', 'b', 'g', 'c', 'm', 'y', 'k', 'r', 'b', 'g', 'c', 'm', 'y',
              'k', 'r', 'b', 'g', 'c', 'm', 'y', 'k']
    ordering = []
    t0s = []
    t1s = []
    t2s = []
    a0s = []
    a1s = []
    a2s = []
    zamps = []
    for dataDirTFunc in dataDirsTFunc:
        d = dvw(dataDirTFunc, cxn)

        # Pull out all data sets of this type in the directory
        settleDataSets = (d[int(x[:5])] for x in d.keys() if
                          'Z Settle Time Long Rise' in x)

        if falling:
            settleDataSets = (d[int(x[:5])] for x in d.keys() if
                              'Spectroscopy Z settle falling' in x)

        for data in settleDataSets:

            biasvals = []
            freqvals = []
            freqvals2 = []
            timevals = []

            print 'dir: {}'.format(dataDirTFunc)
            print 'DATA SET:', data.name
            # get data set from data vault
            qubit = data.parameters['measure'][0]
            q = data.parameters[qubit]

            # Get spec peaks
            fit_gauss_max = lambda x, y: fitting.getMaxGauss(x, y,
                                                             fitToMax=True)
            spectroscopylen = data.parameters[qubit]['spectroscopyLen']['ns']
            times, freqs = fitting.minima_cuts(data, 0, method=fit_gauss_max, plot=False)
            times += 50 + spectroscopylen/2.

            z_amplitude = float(
                data.parameters['stack']['frame0']['arg']['z_amplitude'])

            conditions = True
            if set_qubit is not None:
                if qubit != set_qubit:
                    conditions = False
            if set_amps is not None:
                if float(
                    data.parameters['stack']['frame0']['arg']['z_amplitude']) not in set_amps:
                    conditions = False
                    print 'set_amp: {}; data_amp: {}'.format(set_amps, float(
                    data.parameters['stack']['frame0']['arg']['z_amplitude']))

            if len(times) > 50 and conditions:
                zamps.append(z_amplitude)
                # get zfunc and inverse zfunc
                Z = zfuncs.TransmonFrequency(q['zFuncAna'])

                def fitSettle(ts, a0, t0, a1, t1, a2, t2, b):
                    outp = []
                    for t in ts:
                        # outp.append((a0 * np.exp(-t/t0)) + (a1 * np.exp(-t/t1)) + (a2 * np.exp(-t/t2)) + b)
                        # two Tau fit.
                        outp.append(
                            (a1 * np.exp(-t / t1)) + (a2 * np.exp(-t / t2)) + b)
                    return np.array(outp)

                # seed estimates [A0, T0, A1, T1, A2, T2, B]
                # A0 ~ 5 MHz
                # A1 ~ 5 MHz
                # A2 ~ 1 MHz
                # T0 ~ 10 nsec
                # T1 ~ 1000 nsec
                # T2 ~ 50000 nsec
                # B ~ a frequency.

                popt1, pcov1 = curve_fit(fitSettle, times, freqs,
                                         p0=[5, 10, 5, 1000, 1, 50000,
                                             freqs[-1]], maxfev=5200)

                f_step_amp = ((Z.amp_to_freq(0.0)['GHz']) * 1000) - popt1[6]
                a0s.append(popt1[0] / f_step_amp)
                a1s.append(popt1[2] / f_step_amp)
                a2s.append(popt1[4] / f_step_amp)
                t0s.append(popt1[1])
                t1s.append(popt1[3])
                t2s.append(popt1[5])

                print 'a0: ', a0s[-1]
                print 't0: ', t0s[-1]
                print 'a1: ', a1s[-1]
                print 't1: ', t1s[-1]
                print 'a2: ', a2s[-1]
                print 't2: ', t2s[-1]
                print 'b: ', popt1[6]
                ordering.append((popt1[1] < popt1[3] and popt1[3] < popt1[5]))
                print 'correct ordeR???', ordering[-1]
                infSettleZ = Z.freq_to_amp((popt1[6] / 1000) * GHz)

                xs = np.array(times)
                ys = np.array(freqs)
                x_vals = np.linspace(np.min(times), np.max(times), 10000)
                y_vals = fitSettle(x_vals, popt1[0], popt1[1], popt1[2],
                                   popt1[3], popt1[4], popt1[5], popt1[6])
                y_vals = Z.freq_to_amp((np.array(y_vals) / 1000) * GHz)
                y_vals = y_vals / infSettleZ
                decay_time = np.floor(popt1[2] / 100) / 10

                shortAmp = ((popt1[0] / f_step_amp) * 100)
                shortTime = np.floor(popt1[2] / 100) / 10
                print 'Decay short amp:  %s percent' % shortAmp
                print 'Decay short time:  ', shortTime, 'us'

                longAmp = ((popt1[5] / f_step_amp) * 100)
                longTime = np.floor(popt1[6] / 100) / 10
                print 'Decay long amp:  %s percent' % longAmp
                print 'Decay long time:  ', longTime, 'us'

                print qubit
                # Amplitude of step from DAC
                z_amplitude = float(
                    data.parameters['stack']['frame0']['arg']['z_amplitude'])
                print ' z_amplitude', z_amplitude

                # Amplitude of step according to zfunc
                zfunc_amplitudes = (Z.freq_to_amp((np.array(freqs) / (1000)) * GHz))
                zfunc_amplitudes = zfunc_amplitudes / infSettleZ

                counter = int(z_amplitude * 10)

                #  data
                # plt.semilogx(times/1000,zfunc_amplitudes*100, color = colors[counter], lw = 0, marker = 's',markeredgecolor='none', label = labels[counter])
                # plt.semilogx(times/1000,zfunc_amplitudes*100, color = colors[counter], lw = 0, marker = 's',markeredgecolor='none', label = 'z_step_amp: %0.1f ;Tshort %.5f us; Ashort: %0.2d; Tlong %02d us; Along: %0.2d'%(z_amplitude,float(shortTime), np.float(shortAmp), longTime, np.float(longAmp)))
                f_step_amp = np.int(f_step_amp*10.)/10.
                if frequencies:
                    plt.semilogx(times / 1000., freqs,
                                 color=colors[counter], lw=0, marker='s',
                                 label='<{}> {}: z_amplitude: {}; f_step_amp: {} MHz'.format(
                                     np.int(data.name.split()[0]), qubit,
                                     z_amplitude, f_step_amp))
                    plt.ylabel('Qubit Frequency (MHz)', fontsize=18)
                else:
                    plt.semilogx(times / 1000., zfunc_amplitudes * 100,
                                 color=colors[counter], lw=0, marker='s',
                                 label='<{}> {}: z_amplitude: {}; f_step_amp: '
                                       '{} MHz'.format(
                                     np.int(data.name.split()[0]), qubit,
                                     z_amplitude, f_step_amp))
                    plt.ylabel('Z Amp (% of step)', fontsize=18)
                    # plt.axis([0.03, 24000, 90, 102])
                print type(z_amplitude), type(shortTime)
                #  fit
                # plt.semilogx(x_vals/1e3,y_vals*100, color = colors[counter], lw = 2, marker = None, label = 'z_step_amp: %s ;Tshort %s us; Ashort: %s; Tlong %s us; Along: %s'%(str(z_amplitude),str(shortTime), str(shortAmp), str(longTime), str(longAmp)))
                plt.semilogx(x_vals / 1000, y_vals * 100, color=colors[counter],
                             lw=2, marker='s', markeredgecolor='none')
                counter += 1
                # plt.title(dataDirTFunc, fontsize=18)
                # plt.xlabel('Time (us)', fontsize=18)
                # plt.tick_params(labelsize=15)
                # plt.legend(numpoints=1, loc=4)
                # plt.tight_layout
                # plt.show()

    if plot:
        plt.title(dataDirTFunc, fontsize=18)
        plt.xlabel('Time (us)', fontsize=18)
        plt.tick_params(labelsize=15)
        plt.legend(numpoints=1, loc=4)
        plt.tight_layout()
        plt.show()

    if False:
        plt.figure()
        plt.title(
            'Settle Amplitude vs Step Amplitude: a0*exp(-t/t0) + a1*exp(-t/t1) + a2*exp(-t/t2)',
            fontsize=11)
        plt.ylabel('Settle amplitude (% of step)')
        plt.xlabel('Step amplitude (DAC units)')
        plt.plot(zamps, a0s, 'rs', label='a0s')
        plt.plot(zamps, a1s, 'bs', label='a1s')
        plt.plot(zamps, a2s, 'gs', label='a2s')
        plt.legend(numpoints=1, loc=2)
        plt.axis([-1.0, 1.0, -0.5, 0.5])
        plt.tight_layout()
        plt.show()

        plt.figure()
        plt.title(
            'Settle Amplitude vs Step Amplitude: a0*exp(-t/t0) + a1*exp(-t/t1) + a2*exp(-t/t2)',
            fontsize=11)
        plt.ylabel('Settle amplitude (% of step)')
        plt.xlabel('Step amplitude (DAC units)')
        plt.semilogy(zamps, np.abs(a0s), 'rs', label='a0s')
        plt.semilogy(zamps, np.abs(a1s), 'bs', label='a1s')
        plt.semilogy(zamps, np.abs(a2s), 'gs', label='a2s')
        plt.legend(numpoints=1, loc=3)
        # plt.axis([-1.0,1.0, 0, 10])
        plt.tight_layout()
        plt.show()

        plt.figure()
        plt.title(
            'Settle Times vs Step Amplitude: a0*exp(-t/t0) + a1*exp(-t/t1) + a2*exp(-t/t2)',
            fontsize=11)
        plt.ylabel('Settle Time nsec')
        plt.xlabel('Step amplitude (DAC units)')
        plt.semilogy(zamps, t0s, 'rs', label='t0s')
        plt.semilogy(zamps, t1s, 'bs', label='t1s')
        plt.semilogy(zamps, t2s, 'gs', label='t2s')
        plt.legend(numpoints=1, loc=2)
        # plt.axis([-1.0,1.0, 0, 10])
        plt.tight_layout()
        plt.show()

    return zamps, a0s, a1s, a2s, t0s, t1s, t2s

    # dataDirsTFunc.append(['', 'Brooks', 'qubitData', 'AlBoxViasPCB', '160415'])
    # dataDirsTFunc.append(['', 'Brooks', 'qubitData', 'AlBoxViasPCB', '160415'])
    # dataDirsTFunc.append(['', 'Brooks', 'qubitData', 'AlBoxViasPCB', '160415'])
    # dataDirsTFunc.append(['', 'Brooks', 'qubitData', 'AlBoxViasPCB', '160415'])
    # dataDirsTFunc.append(['', 'Brooks', 'qubitData', 'AlBoxViasPCB', '160415'])
    # dataDirsTFunc.append(['', 'Brooks', 'qubitData', 'AlBoxViasPCB', '160415'])
    # longZdataSets.append(63)
    # longZdataSets.append(64)
    # longZdataSets.append(65)
    # longZdataSets.append(66)
    # longZdataSets.append(67)
    # longZdataSets.append(68)
    # longZdataSets.append(69)



    # # title_plot = 'Al Box, Copper vias Q2'
    # dataDirsTFunc.append(['', 'Brooks', 'qubitData', 'AlBoxAlCuPCB', '160305'])
    # dataDirsTFunc.append(['', 'Brooks', 'qubitData', 'AlBoxAlCuPCB', '160305'])
    # dataDirsTFunc.append(['', 'Brooks', 'qubitData', 'AlBoxAlCuPCB', '160305'])
    # dataDirsTFunc.append(['', 'Brooks', 'qubitData', 'AlBoxAlCuPCB', '160305'])
    # longZdataSets.append(77)
    # longZdataSets.append(78)
    # longZdataSets.append(79)
    # longZdataSets.append(80)

    # # machined Al box, Q3
    # dataDirsTFunc.append(['', 'Brooks', 'qubitData', 'AndrewsChip', 'D1', '160304'])
    # dataDirsTFunc.append(['', 'Brooks', 'qubitData', 'AndrewsChip', 'D1', '160304'])
    # dataDirsTFunc.append(['', 'Brooks', 'qubitData', 'AndrewsChip', 'D1', '160304'])
    # longZdataSets.append(17)
    # longZdataSets.append(13)
    # longZdataSets.append(13)

    #  Brass box Cu Vias, Al PCB
    # dataDirsTFunc.append(['', 'Brooks', 'qubitData', 'BrassBoxCuViasAlPCB', '160418'])
    # # Amp = 0.4
    # longZdataSets.append(90)
Exemplo n.º 20
0
def go(sample, stepDataSet, stepDataDir = None, calDataSet = None, plot = False):
    cxn = sample._cxn
    
    # get calibration datasets
    if stepDataDir == None:
        d = dvw(sample, cxn)
    else:
        d = dvw(dataDir, cxn)
        
    calDataSet = sample['IQcalibrationDataSet']
    calDataDir = sample['IQcalibrationDir']
    calD = dvw(calDataDir, cxn)

    calData = calD[calDataSet]
    fluxVcal = calData['FluxV']
    Ical = calData['I']
    Qcal = calData['Q']
    
    # convert flux voltage from dmmV to DAC amp
    fluxDACampCal = dmmVtoDACamp(fluxVcal * V, calData, useReg = False)
    # convert DAC amp flux voltage to flux
    fluxCal = dacAmpToFlux(fluxDACampCal, calData, useReg = False)
    
    # compute Cal phase
    phaseCal = IQtoPhase(Ical, Qcal)
    
    stepData = d[stepDataSet]
    fluxV = stepData['FluxV']
    fluxVDAC = scopeVtoDACamp(fluxV * V, stepData, useReg = False)
    
    times = stepData['Time']
    flux = dacAmpToFlux(fluxVDAC, stepData, useReg = False)
    I = stepData['I']
    Q = stepData['Q']

    # shift I back to Q
    shift = 1.1 # sec
    shiftPts = np.int(shift/(((times.max()-times.min())/len(times))))
    print 'shiftPts:  ',shiftPts
    if shiftPts > 0:
        times = np.array(times[:-shiftPts])
        flux = np.array(flux[:-shiftPts])
        Q = np.array(Q[:-shiftPts])
        I = np.array(I[shiftPts:])
    
    if plot:
        # plot I&Q to time check shift
        
        plt.figure()
        plt.title('CHECK TIME SHIFT Response Signals I and Q')
        plt.plot(times, I, 'r-',label = 'I')
        plt.plot(times, Q, 'b-',label = 'Q')
        plt.ylabel('Voltage (V)')
        plt.xlabel('Time (ns)')
        plt.legend(numpoints =1,loc = 3)
        plt.tight_layout()
        plt.show()  

    phase = IQtoPhase(I, Q)
    
    phaseSub = []
    fluxSub = []
    for p,f in zip(phaseCal, fluxCal):
        if f < np.max(flux) and f > np.min(flux):
            phaseSub.append(p)
            fluxSub.append(f)
            
    phaseToFlux = sc.interpolate.interp1d(phaseSub, fluxSub)
    
    fluxToPhase = sc.interpolate.interp1d(fluxCal, phaseCal)
    
    interpFluxes = np.linspace(np.min(fluxSub), np.max(fluxSub), 1000)
    interpPhases = fluxToPhase(interpFluxes)
    
    # plot volts to phase interp func
    if plot:
        plt.figure()
        plt.title('Phase response (rad) vs. Flux Voltage (Volts)')
        plt.plot(fluxCal, phaseCal, 'rs',label = 'data')
        plt.plot(interpFluxes, interpPhases, 'b-', label = 'interp')
        plt.plot(flux[0], phase[0], 'rx', markersize = 20, label = 'start Flux')
        plt.plot(flux[-1], phase[-1], 'bx', markersize = 20, label = 'end Flux')
        plt.ylabel('phase (rad)')
        plt.xlabel('Flux (phi0)')
        plt.legend(numpoints =1,loc = 3)
        plt.tight_layout()
        plt.show()

    interpPhases = np.linspace(np.min(phaseSub), np.max(phaseSub), 1000)
    interpFluxes = phaseToFlux(interpPhases)

    # plot phase to volts interp func
    if plot:
        plt.figure()
        plt.title('Flux (phi0) vs. Phase response (rad)')
        plt.plot(phaseCal, fluxCal, 'rs',label = 'data')
        plt.plot(interpPhases, interpFluxes, 'b-', label = 'interp')
        plt.xlabel('phase (rad)')
        plt.ylabel('Flux (phi0)')
        plt.legend(numpoints =1,loc = 3)
        plt.tight_layout()
        plt.show()
        

        plt.figure()
        plt.title('Response Phase (rad) vs Time (ns)')
        plt.plot(times, phase, 'r-', linewidth = 10, label = 'phase')
        plt.xlabel('Time (ns)')
        plt.ylabel('phase (rad)')
        plt.legend(numpoints = 1, loc = 3)
        plt.tight_layout()
        plt.show()
        

    
    
    # shift Response phase back to stimulus flux
    shift = 37.3 # sec
    shiftPts = np.int(shift/(((times.max()-times.min())/len(times))))
    print 'shiftPts:  ',shiftPts
    times = np.array(times[:-shiftPts])
    flux = np.array(flux[:-shiftPts])
    phase = np.array(phase[shiftPts:])
    
    
        
    # plot input step & response phase to time check shift
    if plot:
        plt.figure()
        plt.title('CHECK TIME SHIFT')
        plt.plot(times, flux, 'r-',label = 'stimulus')
        plt.plot(times, phase, 'b-',label = 'response')
        plt.ylabel('NOT SAME Y SCALES')
        plt.xlabel('Time (ns)')
        plt.legend(numpoints =1,loc = 3)
        plt.tight_layout()
        plt.show()    
    
    def savitzky_golay(y, window_size, order, deriv=0, rate=1):
        
        try:
            window_size = np.abs(np.int(window_size))
            order = np.abs(np.int(order))
        except ValueError, msg:
            raise ValueError("window_size and order have to be of type int")
        if window_size % 2 != 1 or window_size < 1:
            raise TypeError("window_size size must be a positive odd number")
        if window_size < order + 2:
            raise TypeError("window_size is too small for the polynomials order")
        order_range = range(order+1)
        half_window = (window_size -1) // 2
        # precompute coefficients
        b = np.mat([[k**i for i in order_range] for k in range(-half_window, half_window+1)])
        m = np.linalg.pinv(b).A[deriv] * rate**deriv * factorial(deriv)
        # pad the signal at the extremes with
        # values taken from the signal itself
        firstvals = y[0] - np.abs( y[1:half_window+1][::-1] - y[0] )
        lastvals = y[-1] + np.abs(y[-half_window-1:-1][::-1] - y[-1])
        y = np.concatenate((firstvals, y, lastvals))
        return np.convolve( m[::-1], y, mode='valid')