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