Ejemplo n.º 1
0
def do_plot_sp(tlength,binlength,clr,t0,y_raw,ax,inset=False):
    x_raw=np.arange(len(y_raw))/1000. #us
    x=x_raw[0:tlength]
    y=y_raw[0:tlength]
    x_rb=rb.average(x,order=binlength)
    y_rb=rb.average(y,order=binlength)
    fit_d_exp_tail = fit.fit1d(x_raw,y_raw, 
                    common.fit_double_exp_decay_with_offset, 
                    0, 1, 1, 1, 0.1, 
                    do_plot = False, ret = True)
    ydfit=fit_d_exp_tail['fitdata']
    if not inset:
        fit_exp_tail = fit.fit1d(x_raw,y_raw, 
                        common.fit_exp_decay_with_offset, 
                        0, 1, 1, 
                        do_plot = False, ret = True)
        yfit=fit_exp_tail['fitdata']

    ax.plot(x_rb,y_rb,'o',mec =clr['bright'], color="none")
    if not inset:
        ax.plot(x_raw,yfit,color =clr['medium'])
    ax.plot(x_raw,ydfit,color =clr['dark'])
    plt.xlabel('time ($\mathrm{\mu}$s)')
    if not inset:
        plt.xlim(-0.2,tlength/1000.)
        plt.ylabel('clicks (kHz)')
    else:
        plt.xlim(-0.9,tlength/1000.)
        plt.ylabel('clicks (MHz)')
    return fit_d_exp_tail
Ejemplo n.º 2
0
    def g2_hist(self, range=(-520,520), bins=2*52):
        # NOTE bins should be an even number!
        
        self.peaks = {}
        self.amplitudes = []
        self.normpeaks = {}

        for i,d in enumerate(self.deltas):
            hy,hx = np.histogram(self.coincidences[i]+self.offset, 
                    bins=bins, range=range)
            self.peaks[d] = (hy,hx)
            self.fitdt = hx[1]-hx[0]

            if d != 0:
                A = fit.Parameter(max(hy))

                def fitfunc(x):
                    return A()*np.exp(-abs(x)/self.tau)

                fit.fit1d(hx[:-1]+(hx[1]-hx[0])/2., hy, None, fitfunc=fitfunc, p0=[A], do_print=True, 
                        fixed=[])

                self.amplitudes.append(A())
                    
        # normalize peaks
        self.meanamp = np.mean(self.amplitudes)
        for d in self.peaks:
            self.normpeaks[d] = (self.peaks[d][0]/self.meanamp, self.peaks[d][1])
                       
        return True   
Ejemplo n.º 3
0
    def g2_hist(self, range=(-520, 520), bins=2 * 52):
        # NOTE bins should be an even number!

        self.peaks = {}
        self.amplitudes = []
        self.normpeaks = {}

        for i, d in enumerate(self.deltas):
            hy, hx = np.histogram(self.coincidences[i] + self.offset, bins=bins, range=range)
            self.peaks[d] = (hy, hx)
            self.fitdt = hx[1] - hx[0]

            if d != 0:
                A = fit.Parameter(max(hy))

                def fitfunc(x):
                    return A() * np.exp(-abs(x) / self.tau)

                fit.fit1d(hx[:-1] + (hx[1] - hx[0]) / 2.0, hy, None, fitfunc=fitfunc, p0=[A], do_print=True, fixed=[])

                self.amplitudes.append(A())

        # normalize peaks
        self.meanamp = np.mean(self.amplitudes)
        for d in self.peaks:
            self.normpeaks[d] = (self.peaks[d][0] / self.meanamp, self.peaks[d][1])

        return True
Ejemplo n.º 4
0
    def plot_relaxation_vs_sweep(self, ms, st, save=True, **kw):
        ret = kw.get('ret', None)
        ax = kw.get('ax', None)
        ax2 = kw.get('ax2', None)
        if ax == None:
            fig = self.default_fig(figsize=(6,4))
            ax = self.default_ax(fig)
            fig2 = self.default_fig(figsize=(10,6))
            #fig2.title('Relaxation fit vs' + self.sweep_name)
        else:
            save = False
        name= '_ms'+ str(ms) + '_' + str(st)
        sweep=self.sweep_pts[::2]
        taus=np.zeros(len(sweep))
        for i,sw in enumerate(sweep):
            #print i
            start,length=getattr(self,'_get_'+st+'_window')(ms,i)
            y,x=self._get_relaxation(ms, i, start, length)
            x=x[:-1]
            res = fit.fit1d(x,y, common.fit_exp_decay_shifted_with_offset, 0, y[0], 1000, x[0], 
            ret=True, do_print=False, fixed=[3])
    
            if res != False:
                ax2=plt.subplot(3,np.ceil(float(len(sweep)+1)/3),i+1)
                plot.plot_fit1d(res, x, ax=ax2, plot_data=True, print_info=False)
                ax2.text(ax2.get_xlim()[-1]*0.8,ax2.get_ylim()[-1]*0.8, '{:.2f}'.format(sw),horizontalalignment='right')
                if (res['params_dict']['A'] > 10*res['params_dict']['a']):
                    taus[i]=res['params_dict']['tau']/1e3
                else:
                    print 'Sweep point {} ignored'.format(i)
            else:
                print 'Could not fit sweep point {}'.format(i)
        skip_points = kw.get('skip_points', 0)
        xx=sweep[taus>1.][skip_points:]
        yy=taus[taus>1.][skip_points:]
        
        #y(x) = A * exp(-(x-x0)/tau) + a
        #g_a : offset
        #g_A : initial Amplitude
        #g_tau : decay constant
        #g_x0 : x offset
        res2 = fit.fit1d(xx,yy, common.fit_exp_decay_with_offset, 10, yy[0], xx[len(xx)/2]/2.,  
                ret=True, do_print=True, fixed=[])
        ax.plot(xx,yy, 'o')
        #ax.plot(sweep,10+yy[0]*np.exp(-(sweep- xx[0])/(xx[len(xx)/2]/2.)))
        
        if res2 != False:
            plot.plot_fit1d(res2, xx, ax=ax, plot_data=False, print_info=True)
        #ax.colorbar()
        ax.set_xlabel(self.sweep_name)
        ax.set_ylabel('ms={} {}-relaxation time [us]'.format(ms,st))
        return res

        if save:
            self.save_fig_incremental_filename(fig,name+'_relaxation_vs_sweep')
        
        if ret == 'ax':
            return ax
        if ret == 'fig':
            return fig
Ejemplo n.º 5
0
def fitNflips (N, cM, fixAmpl = False, fixOff=False, show_plots = True):

    cM_m1 = squeeze(asarray(cM[0, :]))
    cM_0 = squeeze(asarray(cM[1, :]))
    cM_p1 = squeeze(asarray(cM[2, :]))

    A_guess = 1.
    off_guess= 0.
    p_guess=0.05
    
    fixP = []
    if fixAmpl == True:
        fixP.append(0)
    if fixOff == True:
        fixP.append(1)

    fit_m1 = fit.fit1d (asarray(N), cM_m1, common.fit_nuclearSpinFlips_1, A_guess, off_guess, p_guess, fixed = fixP,  do_plot = show_plots, ret = True)
    fit_0 = fit.fit1d (asarray(N), cM_0, common.fit_nuclearSpinFlips_2, A_guess, off_guess, p_guess,  fixed = fixP, do_plot = show_plots, ret=True)
    fit_p1 = fit.fit1d (asarray(N), cM_p1, common.fit_nuclearSpinFlips_3, A_guess, off_guess, p_guess,  fixed = fixP, do_plot = show_plots, ret=True)
    results = [fit_m1, fit_0, fit_p1]
    print fit_m1[0]['fitdata']
    plt.figure()
    plt.plot (N, fit_m1[0]['fitdata'], 'b', label = 'mI=-1')
    plt.plot (N, fit_0[0]['fitdata'], 'r', label = 'mI=0')
    plt.plot (N, fit_p1[0]['fitdata'], 'k', label = 'mI=+1')
    plt.plot (N, cM_m1, '>b')
    plt.plot (N, cM_0, 'ro')
    plt.plot (N, cM_p1, 'kD')
    plt.rcParams.update({'font.size': 18})
    plt.xlabel ('number of read-out steps', fontsize = 16)
    plt.ylabel ('readout corrected nuclear spin fidelity', fontsize = 16)   
    plt.legend (loc =1, prop={'size':12})
    plt.show()

    return results
Ejemplo n.º 6
0
def fitNflips(N, cM, fixAmpl=False, fixOff=False, show_plots=True):

    cM_m1 = squeeze(asarray(cM[0, :]))
    cM_0 = squeeze(asarray(cM[1, :]))
    cM_p1 = squeeze(asarray(cM[2, :]))

    A_guess = 1.
    off_guess = 0.
    p_guess = 0.05

    fixP = []
    if fixAmpl == True:
        fixP.append(0)
    if fixOff == True:
        fixP.append(1)

    fit_m1 = fit.fit1d(asarray(N),
                       cM_m1,
                       common.fit_nuclearSpinFlips_1,
                       A_guess,
                       off_guess,
                       p_guess,
                       fixed=fixP,
                       do_plot=show_plots,
                       ret=True)
    fit_0 = fit.fit1d(asarray(N),
                      cM_0,
                      common.fit_nuclearSpinFlips_2,
                      A_guess,
                      off_guess,
                      p_guess,
                      fixed=fixP,
                      do_plot=show_plots,
                      ret=True)
    fit_p1 = fit.fit1d(asarray(N),
                       cM_p1,
                       common.fit_nuclearSpinFlips_3,
                       A_guess,
                       off_guess,
                       p_guess,
                       fixed=fixP,
                       do_plot=show_plots,
                       ret=True)
    results = [fit_m1, fit_0, fit_p1]
    print fit_m1[0]['fitdata']
    plt.figure()
    plt.plot(N, fit_m1[0]['fitdata'], 'b', label='mI=-1')
    plt.plot(N, fit_0[0]['fitdata'], 'r', label='mI=0')
    plt.plot(N, fit_p1[0]['fitdata'], 'k', label='mI=+1')
    plt.plot(N, cM_m1, '>b')
    plt.plot(N, cM_0, 'ro')
    plt.plot(N, cM_p1, 'kD')
    plt.rcParams.update({'font.size': 18})
    plt.xlabel('number of read-out steps', fontsize=16)
    plt.ylabel('readout corrected nuclear spin fidelity', fontsize=16)
    plt.legend(loc=1, prop={'size': 12})
    plt.show()

    return results
Ejemplo n.º 7
0
def fit_two_lorentzian_peaks(V,y,offset,amplitude,x0,gamma,amplitude2,gamma2,splitting,fixed):
    """
    Function that fits two lorentzian peaks to noisy data. 
    Input:
    V - the x array of data 
    y - the y array of data 
    offset - guess for the fit offset
    amplitude - guess for the amplitude of the highest peak
    x0 - guess for the location of the highest peak
    gamma - guess for the FWHM of the highest peak
    amplitude2 - guess for the amplitude of the lowest peak
    gamma2 - guess for the FWHM of the lowest peak
    splitting - guess for the splitting between the two peaks
    fixed - array of the parameters to be fixed in fit function. (keep order; e.g.to fix spliting: fixed = [5])
    """
    #First try fitting with the left peak the largest
    dx2_1 = splitting
    p0_1, fitfunc_1, fitfunc_str_1 = common.fit_2lorentz_splitting(offset, amplitude, x0, gamma, amplitude2, dx2_1, gamma2)
    fit_result_1 = fit.fit1d(V,y, None, p0=p0_1, fitfunc=fitfunc_1, do_print=False, ret=True,fixed=fixed)
    #Then try fitting with the right peak the largest
    dx2_2 = - splitting
    p0_2, fitfunc_2, fitfunc_str_2 = common.fit_2lorentz_splitting(offset, amplitude, x0, gamma, amplitude2, dx2_2, gamma2)
    fit_result_2 = fit.fit1d(V,y, None, p0=p0_2, fitfunc=fitfunc_2, do_print=False, ret=True,fixed=fixed)

    discard_1 = False
    discard_2 = False
    if fit_result_1['params_dict']['A2']*fit_result_1['params_dict']['gamma2'] < 0:
        # print 'discard first fit' 
        discard_1 = True
    if fit_result_2['params_dict']['A2']*fit_result_2['params_dict']['gamma2'] < 0:
        # print 'discard second fit' 
        discard_2 = True

    if discard_1 and discard_2:
        print 'discarding both Lorentzian fits since they do not give a positive transmission' 
        fit_failed = True
    else:
        fit_failed = False

    if (fit_result_1['chisq'] < fit_result_2['chisq']) or discard_2:
        fit_result = fit_result_1
        left_peak_high = True

    else:
        fit_result = fit_result_2
        left_peak_high = False

    return fit_result, left_peak_high, fit_failed
Ejemplo n.º 8
0
def epulse_fidelity(folder, ax, *args):

    a = sequence.SequenceAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results(name='ssro')
    a.get_electron_ROC()
    a.plot_result_vs_sweepparam(ax=ax, name='ssro')

    x = a.sweep_pts.reshape(-1)[:]
    y = a.p0.reshape(-1)[:]

    of = fit.Parameter(args[0], 'of')
    of2 = fit.Parameter(0, 'of2')
    of3 = fit.Parameter(0, 'of3')
    fitfunc_str = '(1-of)'

    def fitfunc_fid(x):
        return (1. - of())

    fit_result = fit.fit1d(x,
                           y,
                           None,
                           p0=[of],
                           fixed=[],
                           fitfunc=fitfunc_fid,
                           fitfunc_str=fitfunc_str,
                           do_print=True,
                           ret=True)
    #plot.plot_fit1d(fit_result, np.linspace(x[0],x[-1],201), ax=ax,
    #    plot_data=False, print_info=False)

    return fit_result
Ejemplo n.º 9
0
def fit_linear(folder, ax, value, *args):
    a = sequence.SequenceAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results(name='ssro')
    a.get_electron_ROC()
    a.plot_result_vs_sweepparam(ax=ax, name='ssro')

    x = a.sweep_pts.reshape(-1)[:]
    y = a.p0.reshape(-1)[:]
    ax.set_title(a.timestamp)

    a = fit.Parameter(args[0], 'a')
    b = fit.Parameter(args[0], 'b')
    fitfunc_str = 'a x + b'

    def fitfunc(x):
        return a() * x + b()

    fit_result = fit.fit1d(x,
                           y,
                           None,
                           p0=[a, b],
                           fitfunc=fitfunc,
                           fitfunc_str=fitfunc_str,
                           do_print=True,
                           ret=True)
    plot.plot_fit1d(fit_result,
                    np.linspace(x[0], x[-1], 201),
                    ax=ax,
                    plot_data=False,
                    print_info=False)

    return fit_result
Ejemplo n.º 10
0
def calibrate_epulse_amplitude(folder, ax, *args):
    a = sequence.SequenceAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results(name='ssro')
    a.get_electron_ROC()
    a.plot_result_vs_sweepparam(ax=ax, name='ssro')

    x = a.sweep_pts.reshape(-1)[:]
    y = a.p0.reshape(-1)[:]
    ax.set_title(a.timestamp)

    x0 = fit.Parameter(args[0], 'x0')
    of = fit.Parameter(args[1], 'of')
    a = fit.Parameter(args[2], 'a')
    fitfunc_str = '(1-of) + a (x-x0)**2'

    def fitfunc_parabolic(x):
        return (1. - of()) + a() * (x - x0())**2

    fit_result = fit.fit1d(x,
                           y,
                           None,
                           p0=[of, a, x0],
                           fitfunc=fitfunc_parabolic,
                           fitfunc_str=fitfunc_str,
                           do_print=True,
                           ret=True)
    plot.plot_fit1d(fit_result,
                    np.linspace(x[0], x[-1], 201),
                    ax=ax,
                    plot_data=False,
                    print_info=True)

    return fit_result
Ejemplo n.º 11
0
def fit_population_vs_detuning(folder, ax, *args):
    a = mbi.MBIAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results(name='adwindata')
    a.get_electron_ROC(
    )  # a.get_N_ROC(0.97,0.03,0.96,0.01,0.93,0.01)#(0.99, 0.02, 0.94, 0.005)
    ax = a.plot_results_vs_sweepparam(ret='ax', name='adwindata')

    x = a.sweep_pts.reshape(-1)[:]
    y = a.p0.reshape(-1)[:]

    guess_a = 1
    guess_A = -0.8
    guess_F = 0.005
    guess_x0 = args[0]

    fit_result = fit.fit1d(x,
                           y,
                           rabi.fit_population_vs_detuning,
                           guess_a,
                           guess_A,
                           guess_F,
                           guess_x0,
                           fixed=[],
                           do_print=True,
                           ret=True)
    plot.plot_fit1d(fit_result,
                    np.linspace(a.sweep_pts[0], a.sweep_pts[-1], 201),
                    ax=ax,
                    plot_data=False)

    return fit_result
Ejemplo n.º 12
0
def fit_correlation_parabolic(folder, ax, *args, **kw):
    which_correlation = kw.pop('which_correlation', 2)

    a = mbi.MBIAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results(name='adwindata')
    a.get_correlations(name='adwindata')
    a.plot_results_vs_sweepparam(ax=ax, mode='correlations')

    x = a.sweep_pts.reshape(-1)[:]
    y = a.normalized_correlations[:, which_correlation]

    x0 = fit.Parameter(args[0], 'x0')
    of = fit.Parameter(args[1], 'of')
    a = fit.Parameter(args[2], 'a')
    fitfunc_str = '(1-of) + a (x-x0)**2'

    def fitfunc_parabolic(x):
        return (1. - of()) + a() * (x - x0())**2

    fit_result = fit.fit1d(x,
                           y,
                           None,
                           p0=[of, a, x0],
                           fitfunc=fitfunc_parabolic,
                           fitfunc_str=fitfunc_str,
                           do_print=True,
                           ret=True)
    plot.plot_fit1d(fit_result,
                    np.linspace(x[0], x[-1], 201),
                    ax=ax,
                    plot_data=False,
                    print_info=False)

    return fit_result
Ejemplo n.º 13
0
    def _fit(self, X, Y):
        #Fit parabole: o + A * (x-c)**2  ['g_o', 'g_A', 'g_c']
        guess_o = np.min(Y)
        guess_A = ((np.max(Y) - np.min(Y)) /
                   (X[np.argmax(Y)] - X[np.argmin(Y)])**2)
        guess_c = X[np.argmin(Y)]
        print 'fit guess ', guess_A, guess_c, guess_o
        fitres = fit.fit1d(X,
                           Y,
                           common.fit_parabole,
                           guess_o,
                           guess_A,
                           guess_c,
                           len(X),
                           do_print=False,
                           ret=True)

        if fitres['success'] != False:
            p1 = fitres['params_dict']
            print p1
            fd = fitres['fitfunc'](X)
            p = plt.plot(name=self._plot_name)
            p.add(X, fd, '-b')
        else:
            print '\tCould not fit curve!'
            return None, None
        return p1['A'], p1['c']
Ejemplo n.º 14
0
def fit_exp(x=[], y=[], plot_fits=False):

    guess_b = 10.
    guess_c = 0.
    b = fit.Parameter(guess_b, 'b')

    def fitfunc(x):
        return np.exp(-np.abs((x) / b()))

    xx = np.linspace(0, x[-1], 1000)
    fit_result = fit.fit1d(x,
                           y,
                           None,
                           p0=[b],
                           fitfunc=fitfunc,
                           do_print=False,
                           ret=True)

    b_fit = fit_result['params_dict']['b']
    err_b = fit_result['error_dict']['b']

    if plot_fits:
        plt.figure()
        plt.plot(x * 1000, y, '.b')
        plt.plot(xx * 1000, np.exp(-np.abs((xx) / b_fit)), 'r')
        plt.xlabel('time [msec]')
        plt.show()

    return b_fit, err_b
Ejemplo n.º 15
0
def fit_linear(folder=None, ax=None, a_guess=1., b_guess=0.):
    """
    fit a x + b from Sequence in folder
    """
    a, ax, x, y = plot_result(folder, ax)

    a = fit.Parameter(a_guess, 'a')
    b = fit.Parameter(b_guess, 'b')
    fitfunc_str = 'a x + b'

    def fitfunc(x):
        return a() * x + b()

    fit_result = fit.fit1d(x,
                           y,
                           None,
                           p0=[a, b],
                           fitfunc=fitfunc,
                           fitfunc_str=fitfunc_str,
                           do_print=True,
                           ret=True)
    plot.plot_fit1d(fit_result,
                    np.linspace(x[0], x[-1], 201),
                    ax=ax,
                    plot_data=False,
                    print_info=False)

    return fit_result
Ejemplo n.º 16
0
    def fit_calibration(self, V, freq, fixed):
        guess_b = -21.3
        guess_c = -0.13
        guess_d = 0.48
        guess_a = freq[0] +3*guess_b-9*guess_c+27*guess_d

        a = fit.Parameter(guess_a, 'a')
        b = fit.Parameter(guess_b, 'b')
        c = fit.Parameter(guess_c, 'c')
        d = fit.Parameter(guess_d, 'd')

        p0 = [a, b, c, d]
        fitfunc_str = ''

        def fitfunc(x):
            return a()+b()*x+c()*x**2+d()*x**3


        fit_result = fit.fit1d(V,freq, None, p0=p0, fitfunc=fitfunc, fixed=fixed,
                do_print=False, ret=True)
        if (len(fixed)==2):
            a_fit = fit_result['params_dict']['a']
            c_fit = fit_result['params_dict']['c']
            return a_fit, c_fit
        else:
            a_fit = fit_result['params_dict']['a']
            b_fit = fit_result['params_dict']['b']
            c_fit = fit_result['params_dict']['c']
            d_fit = fit_result['params_dict']['d']
            return a_fit, b_fit, c_fit, d_fit
Ejemplo n.º 17
0
def fit_parabola(x, y, 
	guess_x0, 
	guess_amp,
	guess_of,
	fixed,
	show_fit = True,
	save = True):
	
	x0 = fit.Parameter(guess_x0, 'x0')
	A = fit.Parameter(guess_amp, 'A')
	o = fit.Parameter(guess_of, 'o')
	p0 = [x0, A, o]
	fitfunc_str = ''

	fitfunc_str = 'o + A*(x - x0)^2'

	def fitfunc(x):
	    return o() + A() * (x - x0) ** 2.

	fit_result = fit.fit1d(x,y, None, p0=p0, fitfunc=fitfunc, fixed=fixed,
	        do_print=True, ret=True)

	if show_fit:
		plot.plot_fit1d(fit_result, np.linspace(0,x[-1],201),
	       plot_data=True)
	# print "pi pulse = {:.5f} ".format(1/f()/2.) + a.sweep_name

	# ax.set_title(a.timestamp+'\n'+a.measurementstring)
	if save:
		plt.savefig(os.path.join(folder, 'Calibrate_Pi_analysis_parabolafit.png'))
Ejemplo n.º 18
0
def fit_gauss(x, y, **kw):
    a = kw.pop('a', 0.1)
    A = kw.pop('A', 0.7)
    x0 = kw.pop('x0', 0)
    T = kw.pop('T', 1000)
    n = kw.pop('n', 2)
    fixed = kw.pop('fixed', [0, 2, 4])
    show_guess = kw.pop('show_guess', False)
    do_print = kw.pop('do_print', False)
    p0, fitfunc, fitfunc_str = common.fit_general_exponential(a, A, x0, T, n)
    if show_guess:
        ax.plot(np.linspace(0, x[-1], 201),
                fitfunc(np.linspace(0, x[-1], 201)),
                ':',
                lw=2)
    fit_result = fit.fit1d(x,
                           y,
                           None,
                           p0=p0,
                           fitfunc=fitfunc,
                           do_print=do_print,
                           ret=True,
                           fixed=fixed)

    return fit_result
Ejemplo n.º 19
0
 def plot_last_histogram(self):
     y, x = self._hist, self._hist_bins[
         1:] * self._hist_binsize_ns  #np.histogram(self._dts_ns, bins = np.linspace(self.get_roi_min(), self.get_roi_max(),pts))#np.min(dts[dts>0]),np.max(dts),pts))
     plotname = self.get_name() + '_histogram'
     qt.plot(x, y, name=plotname, clear=True)
     f = common.fit_exp_decay_shifted_with_offset
     #A * exp(-(x-x0)/tau) + a
     #['g_a', 'g_A', 'g_tau', 'g_x0']
     args = [1, np.max(y) * 0.1, 12, x[np.argmax(y) + 2.]]
     first_fit_bin = int(
         np.round(self._plot_extra_range / self._hist_binsize_ns))
     xf, yf = x[first_fit_bin:], y[first_fit_bin:]
     fitres = fit.fit1d(xf,
                        yf,
                        f,
                        *args,
                        fixed=[0],
                        do_print=False,
                        ret=True,
                        maxfev=100)
     plot_pts = 200
     x_p = np.linspace(min(xf), max(xf), plot_pts)
     if fitres['success']:
         y_p = fitres['fitfunc'](x_p)
         print 'fit success'
     else:
         y_p = f(*args)[1](x_p)
         print 'fit failed'
     print fitres['params_dict']
     qt.plot(x_p, y_p, 'b', name=plotname, clear=False)
     self.y = y
     self.x = x
Ejemplo n.º 20
0
def analysis():
    dp=os.path.join(meas_folder, date)
    amp=[]
    phase=[]
 
    j=0
    color=['Crimson','RoyalBlue']
    ramsey_data={}
    for i in datafolders:    
        tau_guess = 3000
        offset_guess=0.5   
        freq=1e-3
        amp=0.5
        result=sc.analyse_plot_results_vs_sweepparam(i,yname='P(mI=0)',Nuclcor=False,dataname='Spin_RO',d=date)
        resultcor=sc.analyse_plot_results_vs_sweepparam(i,yname='P(mI=0)',Nuclcor=True,dataname='Spin_RO',d=date)
	fit_result = fit.fit1d(result['x'], result['y'], ramsey.fit_ramsey_gaussian_decay, 
                    tau_guess, offset_guess, (freq,amp,90),
                    do_print = True , ret = True)
        fit_x=np.linspace(result['x'].min(),result['x'].max(),201)
	ramsey_data['fit_x']=fit_x
	if label[j]=='mI=-1':
	    ramsey_data['datamin1']=result['y']
	    ramsey_data['xmin1']=result['x']
	    ramsey_data['udatamin1']=result['uy']
	    ramsey_data['fitmin1']=fit_result['fitfunc'](fit_x)
	    ramsey_data['datamin1_cor']=resultcor['y']
        else:    
	    ramsey_data['datazero']=result['y']
	    ramsey_data['xzero']=result['x']
	    ramsey_data['udatazero']=result['uy']	
	    ramsey_data['fitzero']=fit_result['fitfunc'](fit_x)
	    ramsey_data['datazero1_cor']=resultcor['y']
	np.savez(os.path.join(basepath,name),**ramsey_data)
        j+=1 
Ejemplo n.º 21
0
def fit_correlation_oscillation(folder, ax, *args, **kw):
    which_correlation = kw.pop("which_correlation", 2)

    a = mbi.MBIAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results(name="adwindata")
    a.get_correlations(name="adwindata")
    a.plot_results_vs_sweepparam(ax=ax, mode="correlations")

    x = a.sweep_pts.reshape(-1)[:]
    y = a.normalized_correlations[:, which_correlation]

    x0 = fit.Parameter(args[0], "x0")
    f = fit.Parameter(args[1], "f")
    A = fit.Parameter(args[2], "A")
    o = fit.Parameter(0.25, "o")
    fitfunc_str = "(1 - A) + A * cos(2pi f (x - x0))"

    def fitfunc(x):
        return o() + A() * np.cos(2 * np.pi * f() * (x - x0()))

    fit_result = fit.fit1d(
        x, y, None, p0=[f, A, x0, o], fitfunc=fitfunc, fitfunc_str=fitfunc_str, do_print=True, ret=True
    )
    plot.plot_fit1d(fit_result, np.linspace(x[0], x[-1], 201), ax=ax, plot_data=False, print_info=False)

    return fit_result
Ejemplo n.º 22
0
def fit_calibration(V, freq):
    guess_b = (freq[-1] - freq[0]) / (V[-1] - V[0])
    guess_a = freq[0]
    print 'Initial guess: ', guess_a, guess_b

    a = fit.Parameter(guess_a, 'a')
    b = fit.Parameter(guess_b, 'b')

    p0 = [a, b]
    fitfunc_str = ''

    def fitfunc(x):
        return a() + b() * x

    fit_result = fit.fit1d(V,
                           freq,
                           None,
                           p0=p0,
                           fitfunc=fitfunc,
                           fixed=[],
                           do_print=False,
                           ret=True)
    a_fit = fit_result['params_dict']['a']
    b_fit = fit_result['params_dict']['b']
    print 'a= ', a_fit
    print 'b=', b_fit
    return a_fit, b_fit
Ejemplo n.º 23
0
def plot_desr(do_save=False):
    folder=r'M:\tnw\ns\qt\Diamond\Projects\Magnetometry with adaptive measurements\Data\raw_data\20141014\130500_PulsarDarkESR_FM_Gretel_sil10'

    ssro_calib_folder = toolbox.latest_data(contains='AdwinSSRO_SSROCalibration')
    print ssro_calib_folder
    
    a = sequence.SequenceAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results('ssro')
    a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder)

    x = a.sweep_pts # convert to MHz
    y = a.p0.reshape(-1)[:]
    # ax.plot(x,y)
    fig2 = plt.figure(figsize=(2,1.25))
    fig2.clf()
    ax2 = fig2.add_subplot(111) 
    #a.plot_result_vs_sweepparam(ret=True, name='ssro',ax=ax2)
    ax2.set_xlim([-3,3])
    ax2.set_ylim(0.5,1)
    ax2.yaxis.set_ticks([0.5,0.75,1])
    #ax2.xaxis.set_ticks([0.5,0.75,1])
    guess_x0= 2.845334
    guess_offset = 1
    guess_Nsplit = 2.18e-3
    guess_sigma = 0.0001

    guess_A_min1 = 0.4
    guess_A_plus1 = 0.25
    guess_A_0 = 0.3
 

    A_min1 = fit.Parameter(guess_A_min1, 'A_min1')
    A_plus1 = fit.Parameter(guess_A_plus1, 'A_plus1')
    A_0 = fit.Parameter(guess_A_0, 'A_0')
    o = fit.Parameter(guess_offset, 'o')
    x0 = fit.Parameter(guess_x0, 'x0')
    sigma = fit.Parameter(guess_sigma, 'sigma')
    Nsplit = fit.Parameter(guess_Nsplit, 'Nsplit')
    def fitfunc(x):

        return o() - np.abs(A_min1())*np.exp(-((x-(x0()-Nsplit()))/sigma())**2) \
                - np.abs(A_plus1())*np.exp(-((x-(x0()+Nsplit()))/sigma())**2) \
                - np.abs(A_0())*np.exp(-((x-x0())/sigma())**2) \
    

    print x
    fit_result = fit.fit1d(x, y, None, p0 = [A_min1, A_plus1, A_0, sigma, o, x0, Nsplit],
        fitfunc = fitfunc, do_print=True, ret=True, fixed=[])  
    print fitfunc(x)
    x_fit=np.linspace(a.sweep_pts[0],a.sweep_pts[-1],2001)
    y_fit=fit_result['fitfunc'](x_fit)
    
    
    ax2.plot(1e3*(x_fit-2.845334),y_fit,color='Grey',linewidth=2)
    ax2.errorbar(1e3*(a.sweep_pts-2.845334),a.p0,yerr=a.u_p0,color=colors[3],fmt='o')
    ax2.set_ylabel('P($m_s =0$)')
    ax2.set_xlabel('Pulse detuning (MHz)')
    if do_save:
        fig2.savefig(r'M:\tnw\ns\qt\Diamond\Projects\Magnetometry with adaptive measurements\Data\analyzed data\desr.pdf', bbox_inches='tight')
Ejemplo n.º 24
0
    def poly_fit_frq(self, **kw):
        plot_fit = kw.pop('plot_fit', True)

        g_x0 = self.x_data[0]
        g_a0 = self.frq_data[0]
        g_a1 = (self.frq_data[-1] - self.frq_data[0]) / (self.x_data[-1] -
                                                         self.x_data[0])
        g_a2 = -0.2
        g_a3 = 2
        fixed = []

        p0, fitfunc, fitfunc_str = common.fit_poly_shifted(
            g_x0, g_a0, g_a1, g_a2, g_a3)
        fit_result = fit.fit1d(self.x_data,
                               self.frq_data,
                               None,
                               p0=p0,
                               fitfunc=fitfunc,
                               do_print=False,
                               ret=True,
                               fixed=fixed)
        if plot_fit:
            plot.plot_fit1d(fit_result,
                            np.linspace(self.x_data[-1], self.x_data[0],
                                        10 * len(self.x_data)),
                            label='Fit',
                            show_guess=False,
                            plot_data=True,
                            color='red',
                            data_linestyle='-',
                            print_info=True)

        self.frq_data = fit_result['fitfunc'](self.x_data)
        return self.frq_data
Ejemplo n.º 25
0
def fit_correlation_parabolic(folder, ax, *args, **kw):
    which_correlation = kw.pop("which_correlation", 2)

    a = mbi.MBIAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results(name="adwindata")
    a.get_correlations(name="adwindata")
    a.plot_results_vs_sweepparam(ax=ax, mode="correlations")

    x = a.sweep_pts.reshape(-1)[:]
    y = a.normalized_correlations[:, which_correlation]

    x0 = fit.Parameter(args[0], "x0")
    of = fit.Parameter(args[1], "of")
    a = fit.Parameter(args[2], "a")
    fitfunc_str = "(1-of) + a (x-x0)**2"

    def fitfunc_parabolic(x):
        return (1.0 - of()) + a() * (x - x0()) ** 2

    fit_result = fit.fit1d(
        x, y, None, p0=[of, a, x0], fitfunc=fitfunc_parabolic, fitfunc_str=fitfunc_str, do_print=True, ret=True
    )
    plot.plot_fit1d(fit_result, np.linspace(x[0], x[-1], 201), ax=ax, plot_data=False, print_info=False)

    return fit_result
Ejemplo n.º 26
0
def analyze_dark_esr(folder, ax=None, **kw):
    if ax == None:
        fig, ax = plt.subplots(1,1)
    ssro_calib_folder = toolbox.latest_data(contains='AdwinSSRO_SSROCalibration')

    a = sequence.SequenceAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results('ssro')
    a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder)

    x = a.sweep_pts # convert to MHz
    y = a.p0.reshape(-1)[:]
    a.plot_result_vs_sweepparam(ret=None, name='ssro', ax=ax)

    guess_ctr = x[np.floor(len(x)/2.)]


    fit_result = fit.fit1d(x, y, esr.fit_ESR_gauss, guess_offset,
            guess_amplitude, guess_width, guess_ctr,
            # (2, guess_splitN),
             #(2, guess_splitC),
            # (2, guess_splitB),
            #(3, guess_splitN),
            do_print=True, ret=True, fixed=[])
    
    plot.plot_fit1d(fit_result, np.linspace(min(x), max(x), 1000), ax=ax, plot_data=False, **kw)
       
    ax.set_xlabel('MW frq (GHz)')
    ax.set_ylabel(r'fidelity wrt. $|0\rangle$')
    ax.set_title(a.timestamp+'\n'+a.measurementstring)
    plt.savefig(os.path.join(folder, 'darkesr_analysis.png'),
            format='png')
    return fit_result
Ejemplo n.º 27
0
def optimize_z(z_range=0.4, nr_pts=5, green_power=100e-6):
    z_current = mos.get_z()
    zs = np.linspace(z_current - z_range / 2., z_current + z_range / 2.,
                     nr_pts)
    SN = np.zeros(nr_pts)

    green_aom.set_power(green_power)
    for i, z in enumerate(zs):
        print i, z
        mos.set_z(z)
        SN[i] = get_signal_to_noise()
        if (msvcrt.kbhit() and msvcrt.getch() == 'q'):
            break

    d = qt.Data(name='z_optimization_sn')
    d.add_coordinate('z (um)')
    d.add_value('SN')
    d.create_file()
    filename = d.get_filepath()[:-4]
    d.add_data_point(zs, SN)
    d.close_file()
    print filename
    fitargs = (np.min(SN), np.max(SN), zs[np.argmax(SN)], 0.1)

    gaussian_fit_SN = fit.fit1d(zs,
                                SN,
                                common.fit_gauss_pos,
                                *fitargs,
                                do_print=False,
                                ret=True)

    p0 = gaussian_fit_SN['params_dict']

    #qt.plot(zs,SN,name='sn_measurement_z',clear=True)

    zp = np.linspace(min(zs), max(zs), 100)

    # p_c = qt.plot(zp,gaussian_fit_SN['fitfunc'](zp), name='SN_vs_z')
    # p_c.save_png(filename+'.png')

    # p_c = qt.Plot2D(d, 'bO-', coorddim=0, name='z_optimization_sn', valdim=1, clear=True)
    # p_c.save_png(filename+'.png')

    print p0
    if gaussian_fit_SN['success']:

        print 'z0', p0['x0']

        if (p0['x0'] < min(zs)) or (p0['x0'] > max(zs)):
            'optimum out of scan range. setting to max point: ', zs[np.argmax(
                SN)]
            mos.set_z(zs[np.argmax(SN)])
        else:
            'optimize succeeded. new z:', p0['x0']
            mos.set_z(p0['x0'])

        #return gaussian_fit_SN
    else:
        'fit failed, setting back to intial positon', z_current
        mos.set_z(z_current)
Ejemplo n.º 28
0
def analyze_dark_esr_single(x,
                            y,
                            guess_ctr,
                            guess_offset=1,
                            guess_width=0.2e-3,
                            guess_amplitude=0.3,
                            ret='f0',
                            **kw):

    guess_ctr = x[y.argmin()]
    print 'guess_ctr = ' + str(guess_ctr)
    ## I added this to be more robust for SSRO calibration.Please monitor if this is better - Machiel may-2014
    guess_offset = np.average(y)
    dip_threshold = guess_offset - 1.5 * np.std(y)
    print guess_offset
    print dip_threshold
    print min(y)
    if min(y) > dip_threshold:
        print 'Could not find dip'
        return

    fit_result = fit.fit1d(x,
                           y,
                           esr.fit_ESR_gauss,
                           guess_offset,
                           guess_amplitude,
                           guess_width,
                           guess_ctr,
                           do_print=True,
                           ret=True,
                           fixed=[])

    f0 = fit_result['params_dict']['x0']
    u_f0 = fit_result['error_dict']['x0']
    return f0, u_f0
Ejemplo n.º 29
0
def get_signal_to_noise():

    opt_ins = qt.instruments['opt1d_counts']

    x, y = opt_ins.run(dimension='x',
                       scan_length=1.2,
                       nr_of_points=51,
                       pixel_time=100,
                       return_data=True,
                       gaussian_fit=True)

    fitargs = (np.min(y), np.max(y), x[np.argmax(y)], 0.1)
    #print fitargs, len(p)
    gaussian_fit = fit.fit1d(x,
                             y,
                             common.fit_gauss_pos,
                             *fitargs,
                             do_print=False,
                             ret=True)

    print gaussian_fit['success']

    p0 = gaussian_fit['params_dict']
    plot(x, y, name='sn_measurement', clear=True)
    xp = linspace(min(x), max(x), 100)
    plot(xp, gaussian_fit['fitfunc'](xp), name='sn_measurement')

    print 'signal/noise : {:.0f}/{:.0f}  = {:.2f}'.format(
        p0['A'], p0['a'], p0['A'] / p0['a'])
    return gaussian_fit
def analyze_dark_esr_single(x,y,guess_ctr, 
guess_offset = 1,
guess_width = 0.2e-3,
guess_amplitude = 0.3,
ret='f0',
**kw):

    guess_ctr = x[y.argmin()]
    print 'guess_ctr = '+str(guess_ctr)
    ## I added this to be more robust for SSRO calibration.Please monitor if this is better - Machiel may-2014
    guess_offset=np.average(y)
    dip_threshold=guess_offset-1.5*np.std(y)
    print guess_offset
    print dip_threshold
    print min(y)
    if min(y) > dip_threshold:
        print 'Could not find dip'
        return

    fit_result = fit.fit1d(x, y, esr.fit_ESR_gauss, guess_offset,
            guess_amplitude, guess_width, guess_ctr,
            do_print=True, ret=True, fixed=[])


    f0 = fit_result['params_dict']['x0']
    u_f0 = fit_result['error_dict']['x0']
    return f0, u_f0
Ejemplo n.º 31
0
def calibrate_epulse_rabi(folder, ax, *args, **kws):
    fit_phi = kws.pop('fit_phi', True)
    fit_k = kws.pop('fit_k', True)

    a = sequence.SequenceAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results(name='ssro')
    a.get_electron_ROC()
    a.plot_result_vs_sweepparam(ax=ax, name='ssro')
    
    x = a.sweep_pts.reshape(-1)[:]
    y = a.p0.reshape(-1)[:]
    ax.set_title(a.timestamp)

    f = fit.Parameter(args[0], 'f')
    A = fit.Parameter(args[1], 'A')
    x0 = fit.Parameter(0, 'x0')
    k = fit.Parameter(0, 'k')
    p0 = [f, A]
    if fit_phi:
        p0.append(x0)
    if fit_k:
        p0.append(k)
    fitfunc_str = '(1 - A) + A * exp(-kx) * cos(2pi f (x - x0))'

    def fitfunc(x) : 
        return (1.-A()) + A() * np.exp(-k()*x) * \
            np.cos(2*np.pi*(f()*(x - x0())))

    fit_result = fit.fit1d(x,y, None, p0=p0, fitfunc=fitfunc,
        fitfunc_str=fitfunc_str, do_print=True, ret=True)
    plot.plot_fit1d(fit_result, np.linspace(x[0],x[-1],201), ax=ax,
        plot_data=False, print_info=False)
        
    return fit_result
Ejemplo n.º 32
0
def epulse_fidelity(folder, ax, *args):

    a = sequence.SequenceAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results(name='ssro')
    a.get_electron_ROC()
    a.plot_result_vs_sweepparam(ax=ax, name='ssro')
    
    x = a.sweep_pts.reshape(-1)[:]
    y = a.p0.reshape(-1)[:]
    
    of = fit.Parameter(args[0], 'of')
    of2 = fit.Parameter(0, 'of2')
    of3 = fit.Parameter(0, 'of3')
    fitfunc_str = '(1-of)'
    
    def fitfunc_fid(x) :
        return (1.-of())

    fit_result = fit.fit1d(x,y, None, p0=[of], fixed = [], fitfunc=fitfunc_fid,
        fitfunc_str=fitfunc_str, do_print=True, ret=True)
    #plot.plot_fit1d(fit_result, np.linspace(x[0],x[-1],201), ax=ax,
    #    plot_data=False, print_info=False)
       
    return fit_result
Ejemplo n.º 33
0
def fit_gaussian(folder, ax, *args):
    a = sequence.SequenceAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results(name='ssro')
    a.get_electron_ROC()
    a.plot_result_vs_sweepparam(ax=ax, name='ssro')

    x = a.sweep_pts.reshape(-1)[:]
    y = a.p0.reshape(-1)[:]
    ax.set_title(a.timestamp)  

    x0 = fit.Parameter(args[0], 'x0')
    a = fit.Parameter(0.5, 'a')
    o = fit.Parameter(0.5, 'o')
    c = fit.Parameter(15, 'c')
    f = fit.Parameter(1./500, 'f')
    fitfunc_str = 'o + a * exp( - ( (x-x0)/c )^2) '

    def fitfunc(x):
        return o() + a() * np.exp( -((x-x0())/ c())**2)

    fit_result = fit.fit1d(x,y, None, p0=[o,x0,a,c], fixed = [], fitfunc=fitfunc,
            fitfunc_str=fitfunc_str, do_print=True, ret=True)
    plot.plot_fit1d(fit_result, np.linspace(x[0],x[-1],201), ax=ax,
            plot_data=False)

    return fit_result
Ejemplo n.º 34
0
def calibrate_epulse_amplitude(folder, ax, *args):
    a = sequence.SequenceAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results(name='ssro')
    a.get_electron_ROC()
    a.plot_result_vs_sweepparam(ax=ax, name='ssro')
    
    x = a.sweep_pts.reshape(-1)[:]
    y = a.p0.reshape(-1)[:]
    ax.set_title(a.timestamp)
    
    x0 = fit.Parameter(args[0], 'x0')
    of = fit.Parameter(args[1], 'of')
    a = fit.Parameter(args[2], 'a')
    fitfunc_str = '(1-of) + a (x-x0)**2'
    
    def fitfunc_parabolic(x):
        return (1.-of()) + a() * (x-x0())**2
    
    fit_result = fit.fit1d(x,y, None, p0=[of, a, x0], fitfunc=fitfunc_parabolic,
        fitfunc_str=fitfunc_str, do_print=True, ret=True)
    plot.plot_fit1d(fit_result, np.linspace(x[0],x[-1],201), ax=ax,
        plot_data=False, print_info=True)


    return fit_result
Ejemplo n.º 35
0
def fit_sweep_pump_power(x, y, L=0.042):
    guess_b = 1
    guess_a = max(y)

    a = fit.Parameter(guess_a, 'a')
    b = fit.Parameter(guess_b, 'b')

    p0 = [a, b]
    fitfunc_str = ''

    def fitfunc(x):
        return a() * np.sin(L * (b() * x)**0.5)**2

    fit_result = fit.fit1d(x,
                           y,
                           None,
                           p0=p0,
                           fitfunc=fitfunc,
                           fixed=[],
                           do_print=True,
                           ret=True)
    a_fit = fit_result['params_dict']['a']
    b_fit = fit_result['params_dict']['b']
    print 'a= ', a_fit
    print 'b=', b_fit
    return a_fit, b_fit
Ejemplo n.º 36
0
def fit_rabi(folder=None, ax = None, f_guess=0.9, A_guess=1,fit_phi = False,fit_k = False):
    """
    fit (1 - A) + A * exp(-kx) * cos(2pi f (x - x0)) from Sequence in folder
    """
    a, ax, x, y = plot_result(folder,ax)

    f = fit.Parameter(f_guess, 'f')
    A = fit.Parameter(A_guess, 'A')
    x0 = fit.Parameter(0, 'x0')
    k = fit.Parameter(0, 'k')
    p0 = [f, A]
    if fit_phi:
        p0.append(x0)
    if fit_k:
        p0.append(k)
    fitfunc_str = '(1 - A) + A * exp(-kx) * cos(2pi f (x - x0))'

    def fitfunc(x) : 
        return (1.-A()) + A() * np.exp(-k()*x) * \
            np.cos(2*np.pi*(f()*(x - x0())))

    fit_result = fit.fit1d(x,y, None, p0=p0, fitfunc=fitfunc,
        fitfunc_str=fitfunc_str, do_print=True, ret=True)
    plot.plot_fit1d(fit_result, np.linspace(x[0],x[-1],201), ax=ax,
        plot_data=False, print_info=False)
        
    return fit_result
def analyze_dark_esr(x,y,guess_ctr, guess_splitN,
guess_offset = 1,
guess_width = 0.2e-3,
guess_amplitude = 0.3,
ret='f0',
**kw):

    j=0
    min_dip_depth = 0.9
    print 'j = '+str(j)

    print y[21]
    k = len(y)
    while y[j]>min_dip_depth and j < len(y)-2:  #y[j]>0.93*y[j+1]: # such that we account for noise
        k = j
        j += 1
    #j = len(y)-2
    if k > len(y)-3:
        print 'Could not find dip'
        return
    else:
        guess_ctr = x[k]+ guess_splitN #convert to GHz and go to middle dip
        print 'guess_ctr= '+str(guess_ctr)
        print 'k'+str(k)
    ## I added this to be more robust for SSRO calibration.Please monitor if this is better - Machiel may-2014

    fit_result = fit.fit1d(x, y, esr.fit_ESR_gauss, guess_offset,
            guess_amplitude, guess_width, guess_ctr,
            (3, guess_splitN),
            do_print=True, ret=True, fixed=[4])

    if ret == 'f0':
        f0 = fit_result['params_dict']['x0']
        u_f0 = fit_result['error_dict']['x0']
        return f0, u_f0
Ejemplo n.º 38
0
def fit_sin_and_calc_phi(x,y,ax = False):

    g_a = 0.0
    g_A = np.amax(y)
    g_phi = x[np.argmax(y)] 
    ### frequency guess is hardcoded as this is mainly intended for specific entangling oscillations.
    g_f = 1/360.
    p0s, fitfunc,fitfunc_str = common.fit_cos(g_f,g_a,g_A,g_phi)

    fit_result = fit.fit1d(x,y, None, p0=p0s, fitfunc=fitfunc,
         ret=True,fixed=[0,1])

    if ax:
        plot.plot_fit1d(fit_result, np.linspace(x[0],x[-1],201), ax=ax, 
            plot_data=False,print_info = False)
        A = fit_result['params_dict']['A']
        phi = fit_result['params_dict']['phi']
        if A < 0:
            phi = phi + 180
            A = -A
        phi = np.mod(-phi,360)
        phi_u = fit_result['error_dict']['phi']
        print 'A,phi,phi_u ', A, phi, phi_u
    

    return phi, phi_u  # Phi and Phi_u
Ejemplo n.º 39
0
def calibrate_Npulse_rabi(folder, ax, *args):
    a = mbi.MBIAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results(name="adwindata")
    a.get_electron_ROC()
    a.plot_results_vs_sweepparam(ax=ax, name="adwindata")

    x = a.sweep_pts.reshape(-1)[:]
    y = a.p0[:, 0]

    f = fit.Parameter(args[0], "f")
    A = fit.Parameter(args[1], "A")
    o = fit.Parameter(0.5, "o")
    x0 = fit.Parameter(0, "x0")
    p0 = [f, A, x0, o]

    fitfunc_str = "o + A * cos(2pi f x - 2pi phi)"

    def fitfunc(x):
        return o() + A() * np.cos(2 * np.pi * (f() * (x - x0())))

    fit_result = fit.fit1d(x, y, None, p0=p0, fitfunc=fitfunc, fitfunc_str=fitfunc_str, do_print=True, ret=True)
    plot.plot_fit1d(fit_result, np.linspace(x[0], x[-1], 201), ax=ax, plot_data=False, print_info=False)

    return fit_result
Ejemplo n.º 40
0
def determine_drift(times, peak_positions, data_folder):
    times_dec = []

    ftr = [3600,60,1]
    for time in times:
        time_dec = sum([a*b for a,b in zip(ftr, [ int(time[0:2]),int(time[2:4]),int(time[4:6]) ]) ])
        times_dec = np.append(times_dec, time_dec)

    times_dec = times_dec - times_dec[0]

    g_a = 2.13
    g_b = 0.0007
    fixed=[]
    p0, fitfunc, fitfunc_str = common.fit_line(g_a, g_b)
    fit_result = fit.fit1d(times_dec,peak_positions, None, p0=p0, fitfunc=fitfunc, do_print=False, ret=True,fixed=fixed)

    b = fit_result['params_dict']['b']
    u_b = fit_result['error_dict']['b']

    fig,ax = plt.subplots(figsize=(6,4.7))

    ax = plot.plot_fit1d(fit_result, np.linspace(times_dec[0],times_dec[-1],10*len(times_dec)), ax=ax,color='r',show_guess=True, plot_data=True, label = 'fit', add_txt=False, ret='ax')
    ax.set_xlabel('time (s)')
    ax.set_ylabel('peak position (V)')
    ax.set_title(data_folder + ' \n Drift is {} $\pm$ {} mV/s '.format(round(b*1.e3,3), round(u_b*1.e3,3)))

    fig.savefig(data_folder +'/'+ "drift "  + ".png")

    plt.show()
    plt.close()
Ejemplo n.º 41
0
    def analyse_data(self, filename):
        data = np.loadtxt(filename)
        counts = data[:, 1]
        freq = data[:, 0] * 1e-9
        guess_offset = counts[0]
        guess_amplitude = np.max(counts) - np.min(counts)
        guess_width = 0.005
        guess_ctr = 2.88
        success = False
        fit_result = fit.fit1d(freq,
                               counts,
                               esr.fit_ESR_gauss,
                               guess_offset,
                               guess_amplitude,
                               guess_width,
                               guess_ctr,
                               do_print=False,
                               ret=True)
        if fit_result['success'] == 1 and abs(fit_result['params_dict']['x0'] -
                                              guess_ctr) < 0.1:
            success = True
        plot.plot_fit1d(fit_result,
                        np.linspace(np.min(freq), np.max(freq), 1000),
                        plot_data=True,
                        add_txt=True,
                        plot_title=None)
        plt.savefig(filename + '_fit' + '.png')
        plt.close()

        return success
Ejemplo n.º 42
0
def calibrate_epulse_amplitude(folder, ax, *args, **kw):
    double_ro = kw.pop("double_ro", "False")

    a = mbi.MBIAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results(name="adwindata")
    a.get_electron_ROC()
    a.plot_results_vs_sweepparam(ax=ax, name="adwindata")

    x = a.sweep_pts.reshape(-1)[:]
    if double_ro == "electron":
        y = a.p0[:, 0]
    elif double_ro == "nitrogen":
        y = a.p0[:, 1]
    else:
        y = a.p0.reshape(-1)[:]

    x0 = fit.Parameter(args[0], "x0")
    of = fit.Parameter(args[1], "of")
    a = fit.Parameter(args[2], "a")
    fitfunc_str = "(1-of) + a (x-x0)**2"

    def fitfunc_parabolic(x):
        return (1.0 - of()) + a() * (x - x0()) ** 2

    fit_result = fit.fit1d(
        x, y, None, p0=[of, a, x0], fitfunc=fitfunc_parabolic, fitfunc_str=fitfunc_str, do_print=True, ret=True
    )
    plot.plot_fit1d(fit_result, np.linspace(x[0], x[-1], 201), ax=ax, plot_data=False, print_info=False)

    return fit_result
Ejemplo n.º 43
0
def fit_exp(x,
            y,
            guess_a,
            guess_A,
            guess_tau,
            fixed=[],
            show_fit=True,
            save=True,
            timestamp='',
            **kw):
    '''
	Fit single exponential to T1 data
	'''

    p0, fitfunc, fitfunc_str = common.fit_exp_decay_with_offset(
        guess_a, guess_A, guess_tau)

    fit_result = fit.fit1d(x,
                           y,
                           None,
                           p0=p0,
                           fitfunc=fitfunc,
                           fixed=fixed,
                           do_print=True,
                           ret=True)

    # Plot fit and format if requested
    keys = sorted(kw.keys())

    if show_fit:
        if len(keys) == 0:
            plot.plot_fit1d(fit_result,
                            np.linspace(0, x[-1], 201),
                            plot_data=True)
        elif len(keys) != 0 and 'ax' in keys:
            ax = kw['ax']
            plot.plot_fit1d(fit_result,
                            np.linspace(0, x[-1], 201),
                            plot_data=False,
                            ax=ax)
        elif len(keys) != 0 and 'ax' not in keys:
            print 'length of keyword arguments =', len(keys)
            raise Exception(
                "Your keywords for plot formatting didn't contain a pyplot axis with keyword 'ax'. Please provide it."
            )

    if 'xlabel' in keys:
        ax.set_xlabel(kw['xlabel'])
    if 'ylabel' in keys:
        ax.set_ylabel(kw['ylabel'])

    if timestamp != '':
        if timestamp == None:
            folder = toolbox.latest_data('ElectronT1')
        else:
            folder = toolbox.data_from_time(timestamp)

    if save:
        plt.savefig(os.path.join(folder, 'Calibrate_Pi_analysis_fit.png'))
    return fit_result
Ejemplo n.º 44
0
def fast_pi2():
    folder = toolbox.latest_data('cal_fast_pi_over_2')

    a = mbi.MBIAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results(name='adwindata')
    a.get_electron_ROC()
    #a.plot_results_vs_sweepparam(ax=ax, name='adwindata')

    x = a.sweep_pts
    y = a.p0.reshape(-1)
    u_y = a.u_p0.reshape(-1)
    n = a.sweep_name

    x2 = x[::2]
    y2 = y[1::2] - y[::2]
    u_y2 = np.sqrt(u_y[1::2]**2 + u_y[::2]**2)

    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4), sharex=True)
    ax1.errorbar(x2, y2, yerr=u_y2, fmt='o')
    ax1.set_xlabel(n)
    ax1.set_title('Difference btw. Pi/2-Pi and Pi/2' + '\n' + a.timestamp)
    ax1.set_ylabel('Difference')

    m = fit.Parameter((y[-1] - y[0]) / (x[-1] - x[0]), 'm')
    x0 = fit.Parameter(x2.mean(), 'x0')
    p0 = [m, x0]

    def ff(x):
        return m() * (x - x0())

    fitfunc_str = 'm * (x - x0)'

    fit_result = fit.fit1d(x2,
                           y2,
                           None,
                           p0=p0,
                           fitfunc=ff,
                           fitfunc_str=fitfunc_str,
                           do_print=True,
                           ret=True)

    ax2.errorbar(x2, y[0::2], yerr=u_y[0::2], fmt='o', label='Pi/2')
    ax2.errorbar(x2, y[1::2], yerr=u_y[1::2], fmt='o', label='Pi/2 - Pi')
    ax2.legend(frameon=True, framealpha=0.5)
    ax2.set_ylabel('P(0)')
    ax2.set_xlabel(n)
    if fit_result != False:
        ax2.axvline(x0(), c='k', lw=2)
        ax2.axhline(0.5, c='k', lw=2)
        ax2.set_title('X marks the spot')

        plot.plot_fit1d(fit_result,
                        np.linspace(x2[0], x2[-1], 201),
                        ax=ax1,
                        plot_data=False,
                        print_info=True)

    return x0(), 0
Ejemplo n.º 45
0
    def calibrate(self, steps): # calibration values in uW
        rng = np.arange(0,steps)
        x = np.zeros(steps,dtype = float)
        y = np.zeros(steps,dtype = float)
        
        self.set_power(0)
        self._ins_pm.set_wavelength(self._wavelength)
        time.sleep(2)
        bg = self._ins_pm.get_power()

        print 'background power: %.4f uW' % (bg*1e6)

        time.sleep(.2)

        V_max = self.get_V_max()
        V_min = self.get_V_min()
        
        if V_max + V_min < 0: rng=np.flipud(rng)
        
        for a in rng:
            x[a] = a*(V_max-V_min)/float(steps-1)+V_min
            self.apply_voltage(x[a])
            time.sleep(0.5)
            y[a] = self._ins_pm.get_power() - bg
            
            print 'measured power at %.2f V: %.4f uW' % \
                    (x[a], y[a]*1e6)
        
        #x= x*(V_max-V_min)/float(steps-1)+V_min 
        a, xc, k = np.copysign(np.max(y), V_max + V_min), np.copysign(.1, V_max + V_min), np.copysign(5., V_max + V_min)
        fitres = fit.fit1d(x,y, common.fit_AOM_powerdependence, 
                a, xc, k, do_print=True, ret=True)
     
        fd = np.zeros(len(x))        
        if type(fitres) != type(False):
            p1 = fitres['params_dict']
            self.set_cal_a(p1['a'])
            self.set_cal_xc(p1['xc'])
            self.set_cal_k(p1['k'])
            fd = fitres['fitfunc'](x)
        else:
            print 'could not fit calibration curve!'
        
        dat = qt.Data(name= 'aom_calibration_'+self._name+'_'+\
                self._cur_controller)
        dat.add_coordinate('Voltage [V]')
        dat.add_value('Power [W]')
        dat.add_value('fit')
        dat.create_file()
        plt = qt.Plot2D(dat, 'rO', name='aom calibration', coorddim=0, valdim=1, 
                clear=True)
        plt.add_data(dat, coorddim=0, valdim=2)
        dat.add_data_point(x,y,fd)
        dat.close_file()
        plt.save_png(dat.get_filepath()+'png')

        self.save_cfg()
        print (self._name+' calibration finished')
Ejemplo n.º 46
0
def analyze_nmr_single(timestamp = None,center_guess = False, ax=None, ret=None,min_dip_depth = 0.85 , **kw):

    if ax == None:
        fig, ax = plt.subplots(1,1)
        
    x = np.zeros((0))
    y = np.zeros((0))
    ysig = np.zeros((0))
    # rdts = np.zeros((0))


    for i in range(20):
        timestamp, folder = toolbox.latest_data(contains = 'NuclearRFRabi_111_1_sil18Rabi_C5_el1_positive_'+str(i)+'run',return_timestamp = True)
        a = mbi.MBIAnalysis(folder)

        a.get_sweep_pts()
        a.get_readout_results(name='adwindata')
        a.get_electron_ROC()    
        x = np.append(x,a.sweep_pts[:]) 
        y = np.append(y,a.p0[:])
        ysig = np.append(ysig,a.u_p0[:])
    print dir(a)

    for i in range(len(x)-1):
        print x[i], x[i+1]-x[i]



    if center_guess == True:
        guess_ctr = float(raw_input('Center guess?'))
    else:
        guess_ctr = x[y.argmin()]
        print 'guess_ctr = '+str(guess_ctr)
    
    # # try fitting
    fit_result = fit.fit1d(x, y, esr.fit_ESR_gauss, guess_offset,
            guess_amplitude, guess_width, guess_ctr,
            do_print=False, ret=True, fixed=[])
    # fit_result = fit.fit1d(x, y, common.fit_2gauss, guess_offset,
    #         guess_amplitude, guess_ctr-30e-3,guess_width, guess_amplitude, guess_ctr+30e-3,guess_width,
    #         do_print=False, ret=True, fixed=[])
    fit_result['yerr'] = ysig
    plot.plot_fit1d(fit_result, np.linspace(min(x), max(x), 1000), ax=ax, plot_data=True, **kw)

    ax.set_xlabel('RF frq (kHz)')
    ax.set_ylabel(r'fidelity wrt. $|0\rangle$')
    ax.set_title(a.timestamp+'\n'+a.measurementstring)

    plt.savefig(os.path.join(folder, 'nmr_analysis.png'),
            format='png')
    if ret == 'f0':
        f0 = fit_result['params_dict']['x0']
        u_f0 = fit_result['error_dict']['x0']

        ax.text(f0, 0.8, '$f_0$ = ({:.3f} +/- {:.3f})'.format(
            (f0-2.8)*1e3, u_f0*1e3), ha='center')

        return (f0-2.8)*1e3, u_f0*1e3
Ejemplo n.º 47
0
    def calibrate(self, steps): # calibration values in uW
        rng = np.arange(0,steps)
        x = np.zeros(steps,dtype = float)
        y = np.zeros(steps,dtype = float)
        
        self.set_power(0)
        self._ins_pm.set_wavelength(self._wavelength)
        time.sleep(2)
        bg = self._ins_pm.get_power()

        print 'background power: %.4f uW' % (bg*1e6)

        time.sleep(.2)

        V_max = self.get_V_max()
        V_min = self.get_V_min()
        
        if V_max + V_min < 0: rng=np.flipud(rng)
        
        for a in rng:
            x[a] = a*(V_max-V_min)/float(steps-1)+V_min
            self.apply_voltage(x[a])
            time.sleep(0.5)
            y[a] = self._ins_pm.get_power() - bg
            
            print 'measured power at %.2f V: %.4f uW' % \
                    (x[a], y[a]*1e6)
        
        #x= x*(V_max-V_min)/float(steps-1)+V_min 
        a, xc, k = np.copysign(np.max(y), V_max + V_min), np.copysign(.1, V_max + V_min), np.copysign(5., V_max + V_min)
        fitres = fit.fit1d(x,y, common.fit_AOM_powerdependence, 
                a, xc, k, do_print=True, ret=True)
     
        fd = np.zeros(len(x))        
        if type(fitres) != type(False):
            p1 = fitres['params_dict']
            self.set_cal_a(p1['a'])
            self.set_cal_xc(p1['xc'])
            self.set_cal_k(p1['k'])
            fd = fitres['fitfunc'](x)
        else:
            print 'could not fit calibration curve!'
        
        dat = qt.Data(name= 'aom_calibration_'+self._name+'_'+\
                self._cur_controller)
        dat.add_coordinate('Voltage [V]')
        dat.add_value('Power [W]')
        dat.add_value('fit')
        dat.create_file()
        plt = qt.Plot2D(dat, 'rO', name='aom calibration', coorddim=0, valdim=1, 
                clear=True)
        plt.add_data(dat, coorddim=0, valdim=2)
        dat.add_data_point(x,y,fd)
        dat.close_file()
        plt.save_png(dat.get_filepath()+'png')

        self.save_cfg()
        print (self._name+' calibration finished')
def Carbon_control_sweep_N_zoom(timestamp=None, measurement_name = ['adwindata'], 
            A = [0.5, 0.5],
            fitfunc_type = 'single', plot_fit = False, do_print = False, show_guess = True,
            yaxis = [-0.05,1.05]):
    ''' Function to analyze data for optimization of the number of pulses for a controlled C13 gate. 
    '''
    
    if timestamp != None:
        folder = toolbox.data_from_time(timestamp)
    else:
        folder = toolbox.latest_data('Decoupling')

    fit_results = []
    for k in range(0,len(measurement_name)):
        a = mbi.MBIAnalysis(folder)
        a.get_sweep_pts()
        a.get_readout_results(name='adwindata')
        a.get_electron_ROC()
        ax = a.plot_results_vs_sweepparam(ret='ax')
        ax.set_ylim(yaxis)
        ax.axhspan(0,0.5,fill=False,ls='dotted')

        x = a.sweep_pts.reshape(-1)[:]
        y = a.p0.reshape(-1)[:]
        y_u = a.u_p0.reshape(-1)[:]

        ax.set_xlim(x[0]-1,x[-1]+1)

        p0, fitfunc, fitfunc_str = common.fit_poly(A)
        
        if show_guess:
            ax.plot(np.linspace(x[0],x[-1],201), fitfunc(np.linspace(x[0],x[-1],201)), ':', lw=2)
        
        fit_result = fit.fit1d(x,y, None, p0=p0, fitfunc=fitfunc, do_print=True, ret=True,fixed=[3])
        if plot_fit == True:
            plot.plot_fit1d(fit_result, np.linspace(x[0],x[-1],201), ax=ax, plot_data=False,print_info = True)

        fit_results.append(fit_result)
        print folder
        plt.savefig(os.path.join(folder, 'analyzed_result.pdf'),
        format='pdf')
        plt.savefig(os.path.join(folder, 'analyzed_result.png'),
        format='png')

        diff = np.abs(y - 0.5)
        print diff
        print 'Optimum number of pulses N = ' + str(x[np.argmin(diff)])
        print 'with y-0.5 = ' + str(y[np.argmin(diff)]-0.5) + ' +/- ' + str(y_u[np.argmin(diff)])

        # freq = fit_results[0]['params_dict']['f1']
        # period = 1/freq 
        # print 'Period is %s pulses ' %(period)
        # # N_pi = round(period*.5/2)*2.0 
        # N_pi2 = round(period/2*.25)*2.0
        # # print 'Pi pulse: %s pulses' %N_pi
        # print 'Pi2 pulse: %s pulses' %N_pi2
    return fit_results
Ejemplo n.º 49
0
def analyse_Ramsey(folder='',
                   T2=3e3,
                   Ampl=-1. / 3,
                   detuning=3e-3,
                   hf_N=2.17e-3,
                   *arg):

    timestamp = kw.pop(timestamp, None)

    guess_tau = T2
    guess_a = 0.5
    guess_A = Ampl

    guess_hf_N = hf_N
    guess_det = detuning
    guess_hf_C = hf_C

    if timestamp != None:
        folder = toolbox.data_from_time(timestamp)
    elif folder != '':
        folder = toolbox.latest_data('Ramsey')

    a = sequence.SequenceAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results(name='ssro')
    a.get_electron_ROC()
    x = a.sweep_pts
    y = a.p0

    ax = a.plot_result_vs_sweepparam(ret='ax', name='ssro')

    params_0, fitfunc_0, fitfunc_str_0 = ramsey.fit_ramsey_14N_fixed_13C_opt(
        guess_tau, guess_A, guess_a, guess_det, guess_hf_N)
    x_0 = np.linspace(0, a.sweep_pts[-1], 1000)
    ax.plot(x_0, fitfunc_0(x_0), 'r--', lw=1)
    #fit_xvals=np.linspace(res['x'][0],res['x'][-1],fit_num_points)

    fit_result = fit.fit1d(x,
                           y,
                           ramsey.fit_ramsey_14N_fixed_13C_opt,
                           guess_tau,
                           guess_A,
                           guess_a,
                           guess_det,
                           guess_hf_N,
                           fixed=[],
                           do_print=True,
                           ret=True)
    #fit_result = False
    if fit_result != False:
        plot.plot_fit1d(fit_result,
                        np.linspace(0, a.sweep_pts[-1], 201),
                        ax=ax,
                        plot_data=False)

    plt.savefig(os.path.join(folder, 'electronramsey_analysis.pdf'),
                format='pdf')
Ejemplo n.º 50
0
def plot_single_rabi_curve(folder, ax, color, label, tot, utot, tot_mean):
    a = sequence.MagnetometrySequenceAnalysis(folder)
    RO, uRO = a.get_magnetometry_phase_calibration(
        name='adwindata',
        ssro_calib_folder=
        r'M:\tnw\ns\qt\Diamond\Projects\Magnetometry with adaptive measurements\Data\raw_data\20141127\162130_AdwinSSRO_SSROCalibration_Gretel_sil10'
    )

    guess_f1 = 20e-3  #in GHz
    guess_A1 = 0.5
    guess_phi1 = np.pi
    guess_tau = 96
    guess_a = 0.5

    a.sweep_pts = a.sweep_pts
    print a.sweep_pts
    #ax.set_ylim([0.0,1.05])
    amp = (max(a.p0) - min(a.p0)) / 2.
    offset = (max(a.p0) + min(a.p0)) / 2.
    freq = 1 / 8000.
    decay = 10000.
    fit_result = fit.fit1d(a.sweep_pts,
                           a.p0,
                           rabi.fit_rabi_damped_exp,
                           freq,
                           amp,
                           offset,
                           decay,
                           fixed=[],
                           do_print=False,
                           ret=True)
    A = fit_result['params_dict']['A'] * 2
    F = fit_result['params_dict']['f']
    eF = fit_result['error_dict']['f']
    #print fit_result
    print min(a.p0), A
    print 'frq', F * 1e6, '+-', eF, 'kHz'
    x_fit = np.linspace(a.sweep_pts[0], a.sweep_pts[-1], 501)
    y_fit = fit_result['fitfunc'](x_fit)
    ax.plot(x_fit * 1e-3, y_fit, '-', color='Grey', linewidth=2)
    ax.errorbar(a.sweep_pts * 1e-3,
                a.p0,
                yerr=a.u_p0,
                color=color,
                fmt='o',
                label=label)

    if len(tot) == 0:
        tot = (a.p0 - mean(a.p0))
        utot = a.u_p0
        tot_mean = mean(a.p0)
    else:
        tot = tot + (a.p0 - mean(a.p0))
        utot = utot + a.u_p0
        tot_mean = tot_mean + mean(a.p0)
    print max(a.u_p0)
    return tot, a.sweep_pts, utot, tot_mean, A
Ejemplo n.º 51
0
def plot_single_ramsey_curve(folder,ax,color,label,fit_carbon):

    a=np.loadtxt(folder)
    
    guess_A = 0.5
    guess_phi1 = 0*np.pi/2.
    guess_phi2 = 0*np.pi/2.
    guess_phi3 = 0*np.pi/2.
    guess_hf=2.18
    guess_tau = 3
    guess_a = 0.5
    guess_det = 5
    guess_C1 = .2
    sweep_pts=a[:,0]*1e-3
    p0=a[:,2]
    u_p0=a[:,3]
    #ax.set_ylim([0.0,1.05])
    if fit_carbon ==False:
        fit_result = fit.fit1d(sweep_pts, p0, ramsey.fit_ramsey_hyperfinelines_fixed,
            guess_tau, guess_A,guess_a, guess_det,guess_hf,guess_phi1,guess_phi2,guess_phi3,
            #(guess_f3, guess_A3, guess_phi3),
            fixed=[],
            do_print=True, ret=True)
    else:
        guess_A=0.5/6.
        p=np.pi
        guess_phi3=p
        guess_phi2=p
        guess_phi1=p
        fit_result = fit.fit1d(sweep_pts, p0, ramsey.fit_ramsey_14N_fixed_13C_opt,
                guess_tau, guess_A,guess_a, guess_det,guess_hf,guess_phi1,guess_phi2,guess_phi3,guess_C1,
                #(guess_f3, guess_A3, guess_phi3),
                fixed=[],
                do_print=True, ret=True)

    #ax.errorbar(sweep_pts,p0,yerr=u_p0,mec=color,fmt='o',label=label,markeredgewidth=1,mfc='None')
    ax.plot(sweep_pts,p0,'.',mec=color,label=label,markeredgewidth=1,mfc='None')
    x_fit=np.linspace(sweep_pts[0],sweep_pts[-1],501)
    y_fit=fit_result['fitfunc'](x_fit)
    ax.plot(x_fit,y_fit,'-',color='Grey',linewidth=0.75)
    ax.set_xlim([0,4])
    ax.set_ylim([0,1])
    ax.set_yticks([0,0.5,1])
    ax.legend()
Ejemplo n.º 52
0
    def fit_double_exponential(self, name='', save=True, log_plot=True, offset=0, **kw):  
        ret = kw.get('ret', None)
        ax = kw.get('ax', None)
        indices = kw.pop('indices',range(self.sweep_length))

        if ax == None:
            fig = self.default_fig(figsize=(6,4))
            ax = self.default_ax(fig)
        else:
            save = False
        xx=self.tail_hist_b[:-1]
        
        for i in indices:
            
            yy=self.tail_hist_h[i]+offset*i
            if log_plot:
                ax.semilogy(xx,yy,'-')
            else:
                ax.plot(xx,yy)


            guess_xo = 50.
            guess_tau = 50.
            guess_tau2 = 300.
            guess_o = 50.
            guess_A = 500.
            guess_AA = 500.
            AA=fit.Parameter(guess_A, 'A')
            A=fit.Parameter(guess_AA, 'AA')
            o=fit.Parameter(guess_o, 'o')
            xo = fit.Parameter(guess_xo, 'xo')
            tau = fit.Parameter(guess_tau, 'tau')
            tau2 = fit.Parameter(guess_tau2, 'tau2')
            p0 = [A, AA, o, xo, tau, tau2]
            #print p0

            def fitfunc(x):
                #return o() + A() *np.exp(-(x-xo())/tau())
                return o() + A() * np.exp(-((x-xo())/tau())) + AA()*np.exp(-((x-xo())/tau2()))
            fit_result = fit.fit1d(xx, yy, None, p0=p0, fitfunc=fitfunc, fixed=[], do_print=True, ret=True)
            x_fit=np.linspace(xx[0],xx[-1],500)
            y_fit=fit_result['fitfunc'](x_fit)
            ax.plot(x_fit,y_fit,color='k')



        ax.set_xlabel('Time after sync [ns]')
        ax.set_ylabel('Counts')

        if save:
            self.save_fig_incremental_filename(fig,'plot_tail_hist_all')
        
        if ret == 'ax':
            return ax
        if ret == 'fig':
            return fig
Ejemplo n.º 53
0
def calibrate_pi2_noMBI(folder):
    a = sequence.SequenceAnalysis(folder)
    a.get_sweep_pts()
    a.get_readout_results('ssro')
    a.get_electron_ROC()
    x = a.sweep_pts
    y = a.p0
    u_y = a.u_p0
    n = a.sweep_name
    a.finish()

    x2 = x[::2]
    print x2
    y2 = y[1::2] - y[::2]
    u_y2 = np.sqrt(u_y[1::2]**2 + u_y[::2]**2)

    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4), sharex=True)
    ax1.errorbar(x2, y2, yerr=u_y2, fmt='o')
    ax1.set_xlabel(n)
    ax1.set_title('Difference btw. Pi/2-Pi and Pi/2')
    ax1.set_ylabel('Difference')

    m = fit.Parameter((y[-1] - y[0]) / (x[-1] - x[0]), 'm')
    x0 = fit.Parameter(y2.mean(), 'x0')
    p0 = [m, x0]

    def ff(x):
        return m() * (x - x0())

    fitfunc_str = 'm * (x - x0)'

    fit_result = fit.fit1d(x2,
                           y2,
                           None,
                           p0=p0,
                           fitfunc=ff,
                           fitfunc_str=fitfunc_str,
                           do_print=True,
                           ret=True)

    ax2.errorbar(x2, y[0::2], yerr=u_y[0::2], fmt='o', label='Pi/2')
    ax2.errorbar(x2, y[1::2], yerr=u_y[1::2], fmt='o', label='Pi/2 - Pi')
    ax2.legend(frameon=True, framealpha=0.5)
    ax2.set_ylabel('P(0)')
    ax2.set_xlabel(n)
    ax2.axvline(x0(), c='k', lw=2)
    ax2.axhline(0.5, c='k', lw=2)
    ax2.set_title('X marks the spot')

    plot.plot_fit1d(fit_result,
                    np.linspace(x2[0], x2[-1], 201),
                    ax=ax1,
                    plot_data=False,
                    print_info=True)

    fig.savefig(os.path.join(folder, 'pi2_calibration.png'))
Ejemplo n.º 54
0
def fit_exp(d,yname,xname='RO_times'):
    offset_guess=d[yname].max()
    amp_guess=offset_guess
    decay_guess=10
    feedback_fit_result = fit.fit1d(d[xname], d[yname], common.fit_exp_decay_with_offset, 
		    offset_guess, amp_guess,decay_guess,
		    do_print = False , ret = True)
    x=np.linspace(d[xname].min(),d[xname].max(),501)
    y=feedback_fit_result['fitfunc'](x)
    return x,y
Ejemplo n.º 55
0
def meas_BW(min_pos, max_pos, steps, name = 'beamwaist'):


#generate list of steps
    x_list = numpy.linspace(min_pos, max_pos, steps)

    ins_xps = qt.instruments['xps']
    ins_fm = qt.instruments['fm']


    # create data object
    qt.mstart()

    qt.msleep(0.2)


    d = qt.Data(name='BeamWaist')
    d.add_coordinate('displacement (mm)')
    d.add_value('power')
    d.create_file()
    filename=d.get_filepath()[:-4]

    plot2d = qt.Plot2D(d, name=name)
    stop_scan = False
    result = numpy.zeros(steps)
    for i,cur_x in enumerate(x_list):

        if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): stop_scan=True
        ins_xps.set_abs_positionZ(float(-1*cur_x))

        qt.msleep(0.05)
        result[i] = ins_fm.get_power()
        d.add_data_point(cur_x, result[i])

        if stop_scan: break


    ins_xps.set_abs_positionZ(-1*min_pos)
    i_max = result.tolist().index(max(result))
    i_min = result.tolist().index(min(result))

    print 'result imax is: %s' % result[i_max]
    knife_fit = fit.fit1d(x_list, result,fit_knife_simple, result[i_max],
                    0, 2, result[i_min], do_print=False,ret=True)
    if type(knife_fit) != dict:
                print 'fit failed!'
    else:
        print 'best fit params are: A: %.03f x0: %.03f w: %.03f b: %.03f' % (
        knife_fit['params'][0], knife_fit['params'][1], knife_fit['params'][2],
        knife_fit['params'][3])
    plot2d.set_plottitle('Beam Waist: %.03f +- %.03f' % (knife_fit['params'][2], knife_fit['error'][2]))
    d.close_file()
    plot2d.save_png(filename+'.png')

    qt.mend()
def analyse_Rabi(guess_frq = 2., guess_amp = 0.2, guess_of = 0.1, **kw) :

    timestamp    = kw.pop('timestamp', None)
    guess_phi    = kw.pop('guess_phi', 0.)
    guess_k      = kw.pop('guess_k', 0.)
    mbi_analysis = kw.pop('mbi_analysis', False)
    do_print     = kw.pop('do_print', False)

    o = fit.Parameter(guess_of, 'o')
    f = fit.Parameter(guess_frq, 'f')
    A = fit.Parameter(guess_amp, 'A')
    phi = fit.Parameter(guess_phi, 'phi')
    k = fit.Parameter(guess_k, 'k')
    p0 = [f, A, phi, o, k]
    fitfunc_str = ''


    if timestamp != None:
        folder = toolbox.data_from_time(timestamp)
    else :
        folder = toolbox.latest_data('ElectronRabi')

    if mbi_analysis:
        a = mbi.MBIAnalysis(folder)
        a.get_sweep_pts()
        a.get_readout_results('adwindata')
        a.get_electron_ROC()
        ax = a.plot_results_vs_sweepparam(ret='ax', name = 'adwindata')

    else:
        a = sequence.SequenceAnalysis(folder)
        a.get_sweep_pts()
        a.get_readout_results('ssro')
        a.get_electron_ROC()
        ax = a.plot_result_vs_sweepparam(ret='ax')

    x = a.sweep_pts
    y = a.p0

    fitfunc_str = 'o - A + A*e^(-kx)*cos(2pi (fx-phi))'

    def fitfunc(x):
    	return (o()-A()) + A() * np.exp(-k()*x) * np.cos(2*np.pi*(f()*x - phi()))

    fit_result = fit.fit1d(x,y, None, p0=p0, fitfunc=fitfunc, fixed=[2],
            do_print=do_print, ret=True)
    plot.plot_fit1d(fit_result, np.linspace(0,x[-1],201), ax=ax,
            plot_data=False)

    print "\npi pulse at {:.3f} for .\n".format(1/f()/2.) + a.sweep_name

    # ax.set_title(a.timestamp+'\n'+a.measurementstring)
    plt.savefig(os.path.join(folder, 'electronrabi_analysis_fit.png'))

    return fit_result
Ejemplo n.º 57
0
def electron_T1_analysis(older_than='20161110_180000',
                         newer_than='20161110_141200',
                         mode='init0',
                         Amplitude=2,
                         offset=1,
                         T1=1e9,
                         do_print=True):

    Folder_list = toolbox.latest_data(
        contains='ElectronT1_111_1_sil18m0to0switch_on',
        older_than=older_than,
        newer_than=newer_than,
        return_all=True)
    x_tot = []
    y_tot = []
    y_var_tot = []

    for i in range(len(Folder_list)):
        print Folder_list[len(Folder_list) - i - 1]
        Folder = Folder_list[len(Folder_list) - i - 1]
        x, y, y_var = get_T1_data(Folder)
        #print y
        x_tot.extend(list(x))
        y_tot.extend(list(y))
        y_var_tot.extend(list(y_var))

    print x_tot
    print y_tot
    print y_var_tot

    p0, fitfunc, fitfunc_str = common.fit_exp_decay_with_offset(
        offset, Amplitude, T1)
    # fit_result = fit.fit1d(x_tot,y_tot, None, p0=p0, fitfunc=fitfunc, do_print=do_print, ret=True)
    # #plt.plot(x_tot,y_tot)
    # plot.plot_fit1d(fit_result, np.linspace(0,x_tot[-1],201), ax= None, plot_data=False)

    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.errorbar(x_tot, y_tot, fmt='o', yerr=y_var_tot)
    ax.set_ylim([0.0, 1.1])

    fit_result = fit.fit1d(x_tot,
                           y_tot,
                           None,
                           p0=p0,
                           fitfunc=fitfunc,
                           do_print=do_print,
                           ret=True)
    plot.plot_fit1d(fit_result,
                    np.linspace(0, x[-1], 201),
                    ax=ax,
                    plot_data=False)

    plt.savefig(os.path.join(Folder, 'analyzed_result.pdf'), format='pdf')
    plt.savefig(os.path.join(Folder, 'analyzed_result.png'), format='png')
def fitDiodeData(x,y):
    o = fit.Parameter(0,'offset')
    a = fit.Parameter(-0.2, 'amplitude')
    tau = fit.Parameter(7, 'tau')
    fitfunc_str = 'y(x) = o + a*exp(x/tau)'

    def fitfunc(x):
        return o() + a() * numpy.exp((x) / (tau()))

    fit_result = fit.fit1d(x,y, None, p0=[o,tau,a], fixed=[], fitfunc=fitfunc,
            fitfunc_str=fitfunc_str, do_print=True, ret=True)
    return fit_result
Ejemplo n.º 59
0
def optimize_matrix_amplitude(name, Z_matrix, do_fit=True):
    amplitude = 2.0  #V
    steps = 21  #XXXXXXXXXXXX 13
    amps = np.linspace(-amplitude, amplitude, steps)

    Z_voltages = dm.voltages_from_matrix(Z_matrix)
    cur_voltages = dm.get_cur_voltages()

    logging.debug('DM: Starting optimisation scan')
    y_NV = np.zeros(steps)
    for i, amp in enumerate(amps):
        new_voltages = cur_voltages + amp * Z_voltages
        dm.set_cur_voltages(new_voltages)
        if i == 0:
            time.sleep(2. * int_time / 1000.)
        y_NV[i] = measure_counts()
        #qt.msleep(0.2)
    logging.debug('DM: Starting fit')
    opt_amp = None

    if do_fit:
        f = common.fit_gauss
        #a + A * exp(-(x-x0)**2/(2*sigma**2))
        #['g_a', 'g_A', 'g_x0', 'g_sigma']
        args = [100, max(y_NV), 0, 1]
        fitres = fit.fit1d(amps,
                           y_NV,
                           f,
                           *args,
                           fixed=[],
                           do_print=False,
                           ret=True)
        if fitres['success']:
            if fitres['params_dict']['A'] > 0.:
                opt_amp = fitres['params_dict']['x0']
                max_cnts = fitres['params_dict']['A'] + fitres['params_dict'][
                    'a']
                fp = plot_scan(name, amps, y_NV, fitres['fitfunc'])
    if opt_amp == None:
        print 'fit failed, going to max point'
        opt_amp = amps[np.argmax(y_NV)]
        max_cnts = np.max(y_NV)
        fp = plot_scan(name, amps, y_NV)

    logging.debug('DM: Fitting scan finished')
    new_voltages = cur_voltages + opt_amp * Z_voltages
    dm.set_cur_voltages(new_voltages)

    dm.plot_mirror_surf(True, fp[:-3])
    dm.save_mirror_surf(fp[:-4] + '_msurf')

    counters.set_is_running(True)
    return max_cnts, opt_amp
Ejemplo n.º 60
0
def fit_parabolic(folder=None,
                  ax=None,
                  x0_guess=0.,
                  of_guess=0.5,
                  a_guess=1.,
                  **kw):
    """
    fit (1-of) + a (x-x0)**2 from Sequence in folder
    """
    do_print = kw.pop('do_print', False)
    fixed = kw.pop('fixed', [])
    a0, ax, x, y = plot_result(folder, ax, **kw)
    x0 = fit.Parameter(x0_guess, 'x0')
    of = fit.Parameter(of_guess, 'of')
    a = fit.Parameter(a_guess, 'a')

    x_min = kw.pop("x_min", None)
    x_max = kw.pop("x_max", None)

    fit_x = x
    fit_y = y

    if x_min is not None:
        mask = fit_x > x_min
        fit_x = fit_x[mask]
        fit_y = fit_y[mask]

    if x_max is not None:
        mask = fit_x < x_max
        fit_x = fit_x[mask]
        fit_y = fit_y[mask]

    fitfunc_str = '(1-of) + a (x-x0)**2'

    def fitfunc_parabolic(x):
        return (1. - of()) + a() * (x - x0())**2

    fit_result = fit.fit1d(fit_x,
                           fit_y,
                           None,
                           p0=[of, a, x0],
                           fitfunc=fitfunc_parabolic,
                           fitfunc_str=fitfunc_str,
                           do_print=do_print,
                           ret=True)
    fit_result['u_y'] = a0.u_p0
    plot.plot_fit1d(fit_result,
                    np.linspace(np.min(fit_x), np.max(fit_x), 201),
                    ax=ax,
                    plot_data=False,
                    **kw)

    return fit_result