def analyse_pi_pulse(**kw): ''' Perform a parabolic fit of the data to extract the optimal voltage for the pi pulse. ''' timestamp = kw.pop('timestamp', None) do_print = kw.pop('do_print', False) x0_guess = kw.pop('x0_guess', 0.6) a_guess = kw.pop('a_guess', 12) of_guess = kw.pop('of_guess', 0.9) if timestamp != None: folder = toolbox.data_from_time(timestamp) if folder==None: folder = toolbox.latest_data(timestamp) else: folder = toolbox.latest_data('Pi') fig, ax = plt.subplots(1,1, figsize=(4.5,4)) fit_result=calibration_tools.fit_parabolic(folder, x0_guess=x0_guess,a_guess=a_guess,of_guess=of_guess, ax=ax, do_print = do_print)#, info_xy=(x0_guess,0.5)) calibration_tools.plot_result(folder, ax=ax, ret=True) #ax.set_ylim(0.,0.4) plt.savefig(os.path.join(folder, 'pi_pulse_calibration_analysis_fit.png')) return fit_result
def analyse_pi_pulse(**kw): ''' Perform a parabolic fit of the data to extract the optimal voltage for the pi pulse. ''' timestamp = kw.pop('timestamp', None) do_print = kw.pop('do_print', False) x0_guess = kw.pop('x0_guess', 0.6) a_guess = kw.pop('a_guess', 12) of_guess = kw.pop('of_guess', 0.9) if timestamp != None: folder = toolbox.data_from_time(timestamp) if folder == None: folder = toolbox.latest_data(timestamp) else: folder = toolbox.latest_data('Pi') fig, ax = plt.subplots(1, 1, figsize=(4.5, 4)) fit_result = calibration_tools.fit_parabolic( folder, x0_guess=x0_guess, a_guess=a_guess, of_guess=of_guess, ax=ax, do_print=do_print) #, info_xy=(x0_guess,0.5)) calibration_tools.plot_result(folder, ax=ax, ret=True) #ax.set_ylim(0.,0.4) plt.savefig(os.path.join(folder, 'pi_pulse_calibration_analysis_fit.png')) return fit_result
def load_mult_dat(timestamps, number_of_msmts, ssro_calib_folders=['']): cum_pts = 0 for tt in range(len(timestamps)): for kk in range(number_of_msmts[tt]): folder = toolbox.data_from_time(timestamps[tt]) a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='measurement' + str(kk)) a.get_electron_ROC(ssro_calib_folder=ssro_calib_folders[tt]) cum_pts += a.pts if kk == 0 and tt==0: cum_sweep_pts = np.linspace(2.0, 2.2, 51)#a.sweep_pts cum_p0 = a.p0 cum_u_p0 = a.u_p0 elif tt==0: cum_sweep_pts = np.concatenate((cum_sweep_pts, np.linspace(2.0+kk*(50)*4e-3, 2.2+kk*(50)*4e-3, 51))) cum_p0 = np.concatenate((cum_p0, a.p0)) cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0)) elif tt==1: cum_sweep_pts = np.concatenate((cum_sweep_pts, np.linspace(2.0+(kk+150)*(50)*4e-3, 2.2+(kk+150)*(50)*4e-3, 51))) cum_p0 = np.concatenate((cum_p0, a.p0)) cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0)) a.pts = cum_pts a.sweep_pts = cum_sweep_pts a.p0 = cum_p0 a.u_p0 = cum_u_p0 return a, folder
def analyze_data(timestamp, output=False): #, guess_frq = 1 / 20e9, guess_amp = 0.5): if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data('ElectronT1') print folder a = sequence.SequenceAnalysis(folder) a.get_sweep_pts() a.get_readout_results('ssro') a.get_electron_ROC() # print a.p0 ax = a.plot_result_vs_sweepparam(ret='ax') # plt.ylim([0,0.052]) x = a.sweep_pts y = a.p0 if output: return x, y, ax else: return ax
def Zeno_get_2Q_values(timestamp=None, folder=None,folder_name='Zeno', measurement_name = ['adwindata'], ssro_calib_timestamp ='20150128_080328'): """ Returns the relevant 2qubit values for a given timestamp. """ if timestamp == None and folder==None: timestamp, folder = toolbox.latest_data(folder_name,return_timestamp =True) elif timestamp ==None and folder!=None: pass else: folder = toolbox.data_from_time(timestamp) if folder != None and timestamp == None: d,t = toolbox.get_date_time_string_from_folder(folder) timestamp = toolbox.timestamp_from_datetime(t) ### SSRO calibration if ssro_calib_timestamp == None: ssro_calib_folder = toolbox.latest_data('SSRO',older_than=timestamp) else: ssro_dstmp, ssro_tstmp = toolbox.verify_timestamp(ssro_calib_timestamp) ssro_calib_folder = toolbox.datadir + '/'+ssro_dstmp+'/'+ssro_tstmp+'_AdwinSSRO_SSROCalibration_111_1_sil18' a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='adwindata') a.get_electron_ROC(ssro_calib_folder) x_labels = a.sweep_pts.reshape(-1) y= ((a.p0.reshape(-1))-0.5)*2 y_err = 2*a.u_p0.reshape(-1) return x_labels,y,y_err
def analyze_data(timestamp, output=False): #, guess_frq = 1 / 20e9, guess_amp = 0.5): # 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('Pi_Calibration') print folder 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') # plt.ylim([0,0.052]) x = a.sweep_pts y = a.p0 if output: return folder, x, y
def analyze_data(timestamp, output = False): #, guess_frq = 1 / 20e9, guess_amp = 0.5): # 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('Pi_Calibration') print folder 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') # plt.ylim([0,0.052]) x = a.sweep_pts y = a.p0 if output: return folder, x, y
def load_mult_dat(timestamp, number_of_msmts, ssro_calib_folder=''): cum_pts = 0 for kk in range(number_of_msmts): folder = toolbox.data_from_time(timestamp) a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='measurement' + str(kk)) a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder) cum_pts += a.pts if kk == 0: cum_sweep_pts = np.linspace(2.0, 2.5, 51)#a.sweep_pts cum_p0 = a.p0 cum_u_p0 = a.u_p0 else: cum_sweep_pts = np.concatenate((cum_sweep_pts, np.linspace(2.0+kk*(50)*10e-3, 2.5+kk*(50)*10e-3, 51))) cum_p0 = np.concatenate((cum_p0, a.p0)) cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0)) a.pts = cum_pts a.sweep_pts = cum_sweep_pts a.p0 = cum_p0 a.u_p0 = cum_u_p0 return a, folder
def load_mult_dat(timestamp): cum_pts = 0 for kk in range(len(timestamp)): folder = toolbox.data_from_time(timestamp[kk]) a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='adwindata') a.get_electron_ROC() cum_pts += a.pts if kk == 0: cum_sweep_pts = a.sweep_pts cum_p0 = a.p0 cum_u_p0 = a.u_p0 else: cum_sweep_pts = np.concatenate((cum_sweep_pts, a.sweep_pts)) cum_p0 = np.concatenate((cum_p0, a.p0)) cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0)) a.pts = cum_pts a.sweep_pts = cum_sweep_pts a.p0 = cum_p0 a.u_p0 = cum_u_p0 return a
def load_mult_dat(timestamp, number_of_msmts,older_than = '', ssro_calib_folder='',start = 2.0, pts = 51, step_size = 10e-3): cum_pts = 0 for kk in range(number_of_msmts): folder = toolbox.data_from_time(timestamp,folder = 'd:\measuring\data') a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='measurement' + str(kk)) a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder) cum_pts += a.pts if kk == 0: cum_sweep_pts = np.linspace(start, start+(pts-1)*step_size,pts) cum_p0 = a.p0 cum_u_p0 = a.u_p0 else: cum_sweep_pts = np.concatenate((cum_sweep_pts, np.linspace(start+kk*(pts-1)*step_size, start+(pts-1)*step_size+kk*(pts-1)*step_size, pts))) cum_p0 = np.concatenate((cum_p0, a.p0)) cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0)) a.pts = cum_pts a.sweep_pts = cum_sweep_pts a.p0 = cum_p0 a.u_p0 = cum_u_p0 return a, folder
def load_mult_dat(timestamp, number_of_msmts, ssro_calib_folder=''): cum_pts = 0 for kk in range(number_of_msmts): folder = toolbox.data_from_time(timestamp,folder = 'd:\measuring\data') a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='measurement' + str(kk)) a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder) cum_pts += a.pts if kk == 0: cum_sweep_pts = np.linspace(2.0, 2.5, 51) cum_p0 = a.p0 cum_u_p0 = a.u_p0 else: cum_sweep_pts = np.concatenate((cum_sweep_pts, np.linspace(2.0+kk*(50)*10e-3, 2.5+kk*(50)*10e-3, 51))) cum_p0 = np.concatenate((cum_p0, a.p0)) cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0)) a.pts = cum_pts a.sweep_pts = cum_sweep_pts a.p0 = cum_p0 a.u_p0 = cum_u_p0 return a, folder
def load_mult_dat(timestamp, number_of_msmts, x_axis_start = 2.0, x_axis_step = 1.0, x_axis_pts_per_msmnt= 101, ssro_calib_folder =''): ''' function to load and combine multiple msmts. ''' cum_pts = 0 for kk in range(number_of_msmts): folder = toolbox.data_from_time(timestamp) a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='measurement' + str(kk)) a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder) cum_pts += a.pts if kk == 0: cum_sweep_pts = np.linspace(x_axis_start, x_axis_start+x_axis_step, x_axis_pts_per_msmnt)#a.sweep_pts cum_p0 = a.p0 cum_u_p0 = a.u_p0 else: cum_sweep_pts = np.concatenate((cum_sweep_pts, np.linspace(x_axis_start+kk*x_axis_step, x_axis_start+(kk+1)*x_axis_step, x_axis_pts_per_msmnt))) cum_p0 = np.concatenate((cum_p0, a.p0)) cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0)) a.pts = cum_pts a.sweep_pts = cum_sweep_pts a.p0 = cum_p0 a.u_p0 = cum_u_p0 return a, folder
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
def analyze_data(timestamp, output = False): #, guess_frq = 1 / 20e9, guess_amp = 0.5): if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data('ElectronT1') print folder a = sequence.SequenceAnalysis(folder) a.get_sweep_pts() a.get_readout_results('ssro') a.get_electron_ROC() # print a.p0 ax = a.plot_result_vs_sweepparam(ret='ax') # plt.ylim([0,0.052]) x = a.sweep_pts y = a.p0 if output: return x, y, ax else: return ax
def get_CR_histos( contains='', timestamp=None, ): if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data(contains) a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='adwindata') a.get_electron_ROC() before, after = a.get_CR_before_after() fig = plt.figure() ax = plt.subplot() ax.hist(before, abs(max(before) - min(before) + 1), normed=True, label='before') ax.hist(after, abs(max(after) - min(after) + 1), normed=True, label='after') ax.set_title(a.default_plot_title) ax.set_xlabel('counts during CR check') ax.set_ylabel('probability') plt.legend() plt.show() plt.close('all')
def get_and_plot_data_nuc_RO(timestamp_list_pos, timestamp_list_neg, ssro_calib_folder): for ii, timestamp in enumerate(timestamp_list_pos): folder = toolbox.data_from_time(timestamp) a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='adwindata') a.get_electron_ROC(ssro_calib_folder) a.x = a.sweep_pts.reshape(-1)[:] a.sweep_pts = range(len(a.p0)) folder = toolbox.data_from_time(timestamp_list_neg[ii]) b = mbi.MBIAnalysis(folder) b.get_sweep_pts() b.get_readout_results(name='adwindata') b.get_electron_ROC(ssro_calib_folder) ### Combine positive/negative data a.p0 = ( (2*a.p0-1) - (2*b.p0-1))/2. a.u_p0 = (a.u_p0**2 + a.u_p0**2)**0.5 # if ii==0: # ax = a.plot_results_vs_sweepparam(ret='ax', markersize = 4, save=False, fmt = 'o') # ax.set_ylim(-1.05,1.05) # ax.set_xlim(a.sweep_pts[0]-0.1,a.sweep_pts[-1]+0.1) # ax.axhspan(0,1,fill=False,ls='dotted') # ax.axhspan(-1,0,fill=False,ls='dotted') # else: # a.plot_results_vs_sweepparam(ax= ax, markersize = 4, save=False, fmt = 'o') # ax.set_ylim(-1.05,1.05) if ii==0: p0_sum = a.p0 u_p0_sum = a.u_p0**2 else: p0_sum = p0_sum + a.p0 u_p0_sum = u_p0_sum + a.u_p0**2 a.p0 = p0_sum/len(timestamp_list_pos) a.u_p0 = (u_p0_sum**0.5) / len(timestamp_list_pos) a.p0 = a.p0.reshape(-1)[:] a.u_p0 = a.u_p0.reshape(-1)[:] return a, folder
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')
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
def bloch_vector_length(name='', multiplicity='01', timestamp=None, guess_x0=None): ### parameters if guess_x0 == None: guess_x0 = 0.5 guess_of = 0.973 guess_a = 0. ### script x_dict = {} y_dict = {} y_err_dict = {} for RO in ['X', '-X', 'Y', '-Y', 'Z', '-Z']: if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data(name + RO + multiplicity) print folder 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_dict[RO] = {} y_dict[RO] = {} y_err_dict[RO] = {} x_dict[RO] = a.sweep_pts y_dict[RO] = ((a.p0.reshape(-1)[:]) - 0.5) * 2 y_err_dict[RO] = 2 * a.u_p0.reshape(-1)[:] y_f = (((y_dict['X'] - y_dict['-X']) / 2.)**2 + ((y_dict['Y'] - y_dict['-Y']) / 2.)**2 + ((y_dict['Z'] - y_dict['-Z']) / 2.)**2)**(1 / 2.) print y_f fig, ax = plt.subplots() ax.plot(x_dict['X'], y_f, 'o', color='k') ax.set_ylim(-0.1, 1.1) # ax.set_xlim(x_dict['X'][0]-0.01,x_dict['X'][:]+0.01) ax.set_title(folder) # ax.hlines([-1,0],x_dict['X'][0]-1,x_dict['X'][-1]+1,linestyles='dotted') ax.set_xlabel('Amplitude') ax.set_ylabel('Bloch vector length') res = funcs.calibrate_pulse_amplitude(x_dict['X'], y_f, ax, guess_x0, guess_of, guess_a) plt.savefig(os.path.join(folder, 'bloch_length.pdf'), format='pdf') plt.savefig(os.path.join(folder, 'bloch_length.png'), format='png')
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
def BarPlotTomo(timestamp = None, measurement_name = ['adwindata'],folder_name ='Tomo', ssro_calib_timestamp =None, save = True, plot_fit = True) : ''' Function that makes a bar plot with errorbars of MBI type data ''' if timestamp == None: timestamp, folder = toolbox.latest_data(folder_name,return_timestamp =True) else: folder = toolbox.data_from_time(timestamp) if ssro_calib_timestamp == None: ssro_calib_folder = toolbox.latest_data('SSRO') else: ssro_dstmp, ssro_tstmp = toolbox.verify_timestamp(ssro_calib_timestamp) ssro_calib_folder = toolbox.datadir + '/'+ssro_dstmp+'/'+ssro_tstmp+'_AdwinSSRO_SSROCalibration_Hans_sil1' a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='adwindata') a.get_electron_ROC(ssro_calib_folder) x_labels = a.sweep_pts.reshape(-1) y= ((a.p0.reshape(-1))-0.5)*2 x = range(len(y)) y_err = 2*a.u_p0.reshape(-1) if plot_fit ==True: fig,ax = plt.subplots() rects = ax.bar(x,y,yerr=y_err,align ='center',ecolor = 'k' ) ax.set_xticks(x) # ax.title = timestamp # print x_labels ax.set_xticklabels(x_labels.tolist()) ax.set_ylim(-1.1,1.1) ax.set_title(str(folder)+'/'+str(timestamp)) # ax.grid() ax.hlines([-1,0,1],x[0]-1,x[-1]+1,linestyles='dotted') # print values on bar plot def autolabel(rects): for ii,rect in enumerate(rects): height = rect.get_height() plt.text(rect.get_x()+rect.get_width()/2., 1.02*height, str(round(y[ii],2)) +'('+ str(int(round(y_err[ii]*100))) +')', ha='center', va='bottom') autolabel(rects) if save and ax != None: try: fig.savefig( os.path.join(folder,'tomo.png')) except: print 'Figure has not been saved.'
def get_data(name_contains, input_timestamp=None, input_id=None, ssro_calib_folder=''): ''' Retrieves msmt data for a SINGLE loop in SimpleDecoupling, i.e. 'tot' = 1. Inputs: - String containing an element of the file name - (Optional): timestamp. Default is latest data Returns: - 'x': array with sweeped parameter values - 'y': array with msmt outcomes (corrected for SSRO fidelity) - 'yerr': array with msmt errors - 'folder': path of data file - (optional)'timestamp': timestamp corresponding to data. Returned by default unless a timestamp is specified - (optional) 'ssro_calib_folder': path of the corresponding ssro calibration file. If '', latest calibration is used ''' if input_timestamp != None: folder = toolbox.data_from_time(input_timestamp) else: timestamp, folder = toolbox.latest_data(name_contains, return_timestamp=True) a = mbi.MBIAnalysis(folder) #print 'DATA FOLDER & SSRO FOLDER:' #print folder #ax = a.plot_results_vs_sweepparam(ret='ax', ) # Retrieve data & reshape if input_id != None: name = 'measurement' + str(input_id) adwingrp = a.adwingrp(name=name) a.adgrp = adwingrp sweep = a.adgrp.attrs['sweep_pts'] x = sweep.reshape(-1)[:] a.get_readout_results(name=name) a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder) y = a.p0.reshape(-1)[:] yerr = a.u_p0.reshape(-1)[:] else: a.get_sweep_pts() a.get_readout_results(name='measurement0') a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder) x = a.sweep_pts.reshape(-1)[:] y = a.p0.reshape(-1)[:] yerr = a.u_p0.reshape(-1)[:] if input_timestamp != None: return x, y, yerr, folder else: return x, y, yerr, folder, timestamp
def get_pos_neg_data(a, adwindata_str='', ro_array=['positive', 'negative'], **kw): ''' Input: a : a data object of the class MBIAnalysis averages positive and negative data returns the sweep points, measured contrast and uncertainty ''' ### get SSRO ssro_calib_folder = kw.pop('ssro_calib_folder', None) if ssro_calib_folder is None: use_preceding_ssro_calib = kw.pop('use_preceding_ssro_calib', False) if use_preceding_ssro_calib: kw['older_than'] = a.timestamp.replace('/', '') ssro_calib_folder = toolbox.latest_data('SSROCalib', **kw) else: ssro_calib_timestamp = kw.pop('ssro_calib_timestamp', None) if ssro_calib_timestamp == None: ssro_calib_folder = toolbox.latest_data( 'SSROCalib', **kw) # , older_than = older_than) else: ssro_dstmp, ssro_tstmp = toolbox.verify_timestamp( ssro_calib_timestamp) ssro_calib_folder = toolbox.data_from_time( ssro_calib_timestamp) # if adwindata_str == '': # return ##acquire pos_neg data for i, ro in enumerate(ro_array): a.get_sweep_pts() a.get_readout_results(name=adwindata_str + ro, CR_after_check=CR_after_check, **kw) a.get_electron_ROC(ssro_calib_folder, **kw) x_labels = a.sweep_pts if i == 0: res = ((a.p0.reshape(-1)) - 0.5) * 2 res_u = 2 * a.u_p0.reshape(-1) else: y = ((a.p0.reshape(-1)) - 0.5) * 2 # Contrast y_u = 2 * a.u_p0.reshape(-1) # contrast res = [y0 / 2 - y[ii] / 2 for ii, y0 in enumerate(res)] res_u = [ np.sqrt(y0**2 + y_u[ii]**2) / 2 for ii, y0 in enumerate(res_u) ] return np.array(x_labels), np.array(res), np.array(res_u)
def analyse_pulse_calibration(angle='_pi_1'): ### parameters timestamp = None if angle == '_pi_1': guess_x0 = 0.38 elif angle == '_pi_o': guess_x0 = 0.24 elif angle == '_pi_p1': guess_x0 = 0.67 angle='_pi_1' else: guess_x0=0.5 msmt_type = 'mbi' guess_of = 0.973 guess_a = 0. ### script if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data(angle) if msmt_type == 'sequence': 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 elif msmt_type == 'mbi': a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='adwindata') a.get_electron_ROC() ax = a.plot_results_vs_sweepparam(name='adwindata', ret='ax') ax.set_ylim(-0.1,1) x = a.sweep_pts.reshape(-1)[:] y = a.p0.reshape(-1)[:] else: raise Exception('Unknown msmt type') res = funcs.calibrate_pulse_amplitude(x, y, ax, guess_x0, guess_of, guess_a) plt.savefig(os.path.join(folder, 'pulse_calibration.pdf'), format='pdf') plt.savefig(os.path.join(folder, 'pulse_calibration.png'), format='png')
def plot_singlerun_GHZ_data(timestamp=None, plot=True, save = True,contains=None): if timestamp == None: timestamp, folder = toolbox.latest_data(return_timestamp =True,contains=contains) else: folder = toolbox.data_from_time(timestamp) p,y,y_err,title = get_data(folder,timestamp,RO_correct=True) x_labels = ('1,1,1', '1,1,-1' , '1,-1,1', '1,-1,-1','-1,1,1', '-1,1,-1' , '-1,-1,1', '-1,-1,-1') x = range(len(y)) do_plot(folder,timestamp,'GHZ_results',p,y,y_err,x_labels,x)
def plot_singlerun_GHZ_data(timestamp=None, plot=True, save = True): if timestamp == None: timestamp, folder = toolbox.latest_data(folder_name,return_timestamp =True) else: folder = toolbox.data_from_time(timestamp) p,y,y_err = get_data(folder,timestamp,RO_correct=True) x_labels = ('1,1,1', '1,1,-1' , '1,-1,1', '1,-1,-1','-1,1,1', '-1,1,-1' , '-1,-1,1', '-1,-1,-1') x = range(len(y)) do_plot(folder,timestamp,'GHZ_results',p,y,y_err,x_labels,x)
def analyze_dark_esr_single(guess_offset=1, guess_width=0.2e-3, guess_amplitude=0.3, timestamp=None, add_folder=None, ret='f0', ssro_calib_folder='', **kw): if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data('DarkESR') if add_folder != None: folder = add_folder a = sequence.SequenceAnalysis(folder) a.get_sweep_pts() a.get_readout_results('ssro') a.get_electron_ROC() x = a.sweep_pts # convert to MHz y = a.p0.reshape(-1)[:] 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 # 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=[]) if ret == 'f0': f0 = fit_result['params_dict']['x0'] u_f0 = fit_result['error_dict']['x0'] return f0, u_f0
def get_data(name_contains, input_timestamp = None, input_id = None, ssro_calib_folder = ''): ''' Retrieves msmt data for a SINGLE loop in SimpleDecoupling, i.e. 'tot' = 1. Inputs: - String containing an element of the file name - (Optional): timestamp. Default is latest data Returns: - 'x': array with sweeped parameter values - 'y': array with msmt outcomes (corrected for SSRO fidelity) - 'yerr': array with msmt errors - 'folder': path of data file - (optional)'timestamp': timestamp corresponding to data. Returned by default unless a timestamp is specified - (optional) 'ssro_calib_folder': path of the corresponding ssro calibration file. If '', latest calibration is used ''' if input_timestamp != None: folder = toolbox.data_from_time(input_timestamp) else: timestamp, folder = toolbox.latest_data(name_contains, return_timestamp = True) a = mbi.MBIAnalysis(folder) #print 'DATA FOLDER & SSRO FOLDER:' #print folder #ax = a.plot_results_vs_sweepparam(ret='ax', ) # Retrieve data & reshape if input_id != None: name = 'measurement'+ str(input_id) adwingrp = a.adwingrp(name = name) a.adgrp = adwingrp sweep = a.adgrp.attrs['sweep_pts'] x = sweep.reshape(-1)[:] a.get_readout_results(name = name) a.get_electron_ROC(ssro_calib_folder = ssro_calib_folder) y = a.p0.reshape(-1)[:] yerr = a.u_p0.reshape(-1)[:] else: a.get_sweep_pts() a.get_readout_results(name='measurement0') a.get_electron_ROC(ssro_calib_folder = ssro_calib_folder) x = a.sweep_pts.reshape(-1)[:] y = a.p0.reshape(-1)[:] yerr = a.u_p0.reshape(-1)[:] if input_timestamp != None: return x, y, yerr, folder else: return x, y, yerr, folder, timestamp
def find_RO_fidelities(self, timestamp, raw_data, folder=''): ssro_folder = tb.data_from_time(timestamp, folder=folder) if 'MWInit' in ssro_folder: F_0, u_F0, F_1, u_F1 = ssro.get_SSRO_MWInit_calibration( ssro_folder, raw_data.g.attrs['E_RO_durations'][0], raw_data.g.attrs['electron_transition']) else: F_0, u_F0, F_1, u_F1 = ssro.get_SSRO_calibration( ssro_folder, raw_data.g.attrs['E_RO_durations'][0]) return F_0, F_1
def analyse_pulse_calibration(angle='_pi_1', timestamp=None, guess_x0=None): ### parameters if guess_x0 == None: if angle == '_pi_1': guess_x0 = 0.38 elif angle == '_pi_o': guess_x0 = 0.24 elif angle == '_pi_p1': guess_x0 = 0.67 angle = '_pi_1' else: guess_x0 = 0.5 msmt_type = 'sequence' guess_of = 0.973 guess_a = 0. ### script if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data(angle) if msmt_type == 'sequence': 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 elif msmt_type == 'mbi': a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='adwindata') a.get_electron_ROC() ax = a.plot_results_vs_sweepparam(name='adwindata', ret='ax') ax.set_ylim(-0.1, 1) x = a.sweep_pts.reshape(-1)[:] y = a.p0.reshape(-1)[:] else: raise Exception('Unknown msmt type') res = funcs.calibrate_pulse_amplitude(x, y, ax, guess_x0, guess_of, guess_a) plt.savefig(os.path.join(folder, 'pulse_calibration.pdf'), format='pdf') plt.savefig(os.path.join(folder, 'pulse_calibration.png'), format='png')
def electron_T2_anal(timestamp=None, measurement_name=['ms0'], Amplitude=1 / 2., T2=10e3, offset=1. / 2, k=4, do_print=False, ylim=(0., 1.)): ''' Function to analyze simple decoupling measurements. Loads the results and fits them to a simple exponential. Inputs: timestamp: in format yyyymmdd_hhmmss or hhmmss or None. measurement_name: list of measurement names Based on electron_T1_anal, modified by Adriaan Rol ''' if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data('Decoupling') print folder fit_results = [] for k in range(0, len(measurement_name)): a = sequence.SequenceAnalysis(folder) a.get_sweep_pts() a.get_readout_results(measurement_name[k]) a.get_electron_ROC() ax = a.plot_result_vs_sweepparam(ret='ax') ax.set_ylim(ylim) x = a.sweep_pts p0, fitfunc, fitfunc_str = SE.fit_echo(T2, Amplitude, offset, k) y = a.p0 fit_result = fit.fit1d(x, y, None, p0=p0, fitfunc=fitfunc, do_print=do_print, ret=True, fixed=[3]) #fit_result = False if fit_result != False: plot.plot_fit1d(fit_result, np.linspace(0, x[-1], 201), ax=ax, plot_data=False) fit_results.append(fit_result) plot.ylim = ([0, 0.2]) return fit_results
def fit_Ramsey_6_cos_hf_fixed(timestamp, ssro_calib_folder, g_tau, g_A, g_a, g_det, g_hf_N, g_hf_C, fixed=[], folder=None): if folder is None: if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data('ElectronRamsey') a = sequence.SequenceAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='ssro') if ssro_calib_folder != None: a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder) else: a.get_electron_ROC() # Plot data ax = a.plot_result_vs_sweepparam(ret='ax', name='ssro') p0, fitfunc_0, fitfunc_str_0 = ramsey.fit_ramsey_hyperfinelines_fixed_6cos( g_tau, g_A, g_a, g_det, g_hf_N, g_hf_C) fit_result = fit.fit1d(a.sweep_pts, a.p0.reshape(-1), ramsey.fit_ramsey_hyperfinelines_fixed_6cos, g_tau, g_A, g_a, g_det, g_hf_N, g_hf_C, fixed=fixed, do_print=True, ret=True) 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.png'), format='png')
def fit_Ramsey_gausscos_withoffset(timestamp = None, ssro_calib_folder = None, guess_avg = 0.5, guess_A = 1./3., guess_t = 10000, guess_a = 2, guess_f = 1./35, guess_phi = 0, guess_b = 1, fixed = [], fit_result = True): """ Fits cosine with offset modulated by Gaussian decay to electron Ramsey signal. fit func = 'avg + A *exp(-(x/t)**2) * (a * cos(2pi * (f*x + phi/360) ) + b)' """ ### script if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data('ElectronRamsey') a = sequence.SequenceAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='ssro') if ssro_calib_folder != None: a.get_electron_ROC(ssro_calib_folder = ssro_calib_folder) else: a.get_electron_ROC() # Plot data ax = a.plot_result_vs_sweepparam(ret='ax', name='ssro') # ax.set_xlim(0,1000) p0, fitfunc_0, fitfunc_str_0 = ramsey.fit_gaussian_decaying_cos_withoffset(guess_avg, guess_A, guess_t, guess_a, guess_f, guess_phi, guess_b) # Plot initial guess # fit_xvals_0=np.linspace(0,a.sweep_pts[-1],1000) # ax.plot(fit_xvals_0,fitfunc_0(fit_xvals_0), 'r--', lw=1) #fit_xvals=np.linspace(res['x'][0],res['x'][-1],fit_num_points) fit_result = fit.fit1d(a.sweep_pts, a.p0.reshape(-1), ramsey.fit_gaussian_decaying_cos_withoffset, guess_avg, guess_A, guess_t, guess_a, guess_f, guess_phi, guess_b, fixed=fixed, do_print=True, ret=True) if fit_result != False : plot.plot_fit1d(fit_result, np.linspace(0,a.sweep_pts[-1],2001), ax=ax, plot_data=False) plt.savefig(os.path.join(folder, 'electronramsey_analysis.pdf'), format='pdf')
def electron_T1_anal(timestamp=None, measurement_name=['ms0'], Amplitude=0.1, T1=1000, offset=1, do_print=False): ''' Function to analyze T1 measurements. Loads the results and fits them to a simple exponential. Inputs: timestamp: in format yyyymmdd_hhmmss or hhmmss or None. measurement_name: list of measurement names ''' if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data('ElectronT1') fit_results = [] for k in range(0, len(measurement_name)): a = sequence.SequenceAnalysis(folder) a.get_sweep_pts() a.get_readout_results('ssro') #a.get_readout_results(measurement_name[k]) #commented out since newer measurements are no longer grouped which renders the whole for-loop obsolete. NK 20141110 a.get_electron_ROC() ax = a.plot_result_vs_sweepparam(ret='ax') x = a.sweep_pts p0, fitfunc, fitfunc_str = common.fit_exp_decay_with_offset( offset, Amplitude, T1) y = a.p0 #print y fit_result = fit.fit1d(x, y, 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) fit_results.append(fit_result) plt.savefig(os.path.join(folder, 'analyzed_result.pdf'), format='pdf') plt.savefig(os.path.join(folder, 'analyzed_result.png'), format='png') return fit_results
def analyze_dark_esr_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) if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data('DarkESR') a = sequence.SequenceAnalysis(folder) a.get_sweep_pts() a.get_readout_results('ssro') a.get_electron_ROC() x = a.sweep_pts # convert to MHz y = a.p0.reshape(-1)[:] a.plot_result_vs_sweepparam(ret=ret, name='ssro', ax=ax) ax.set_ylim(0.6,1.05) 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=[]) 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') 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
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
def analyze_dark_esr_single( guess_offset = 1, guess_width = 0.2e-3, guess_amplitude = 0.3, timestamp = None, add_folder = None, ret='f0', ssro_calib_folder='', **kw): if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data('DarkESR') if add_folder !=None: folder = add_folder a = sequence.SequenceAnalysis(folder) a.get_sweep_pts() a.get_readout_results('ssro') a.get_electron_ROC() x = a.sweep_pts # convert to MHz y = a.p0.reshape(-1)[:] 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 # 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=[]) if ret == 'f0': f0 = fit_result['params_dict']['x0'] u_f0 = fit_result['error_dict']['x0'] return f0, u_f0
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')
def simple_plot(timestamp=None, measurement_name=['adwindata'], folder_name='CarbonPiCal', ssro_calib_timestamp=None, save=True, plot_fit=True): ''' Function that makes a bar plot with errorbars of MBI type data ''' if timestamp == None: timestamp, folder = toolbox.latest_data(folder_name, return_timestamp=True) else: folder = toolbox.data_from_time(timestamp) if ssro_calib_timestamp == None: ssro_calib_folder = toolbox.latest_data('SSRO') else: ssro_dstmp, ssro_tstmp = toolbox.verify_timestamp(ssro_calib_timestamp) ssro_calib_folder = toolbox.datadir + '\\' + ssro_dstmp + '\\' + ssro_tstmp + '_AdwinSSRO_SSROCalibration_111_1_sil8' print ssro_calib_folder a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='adwindata') a.get_electron_ROC(ssro_calib_folder) x_labels = a.sweep_pts.reshape(-1) y = ((a.p0.reshape(-1)) - 0.5) * 2 x = range(len(y)) y_err = 2 * a.u_p0.reshape(-1) fig, ax = plt.subplots() rects = ax.errorbar(x, y, yerr=y_err) ax.set_xticks(x) ax.set_xticklabels(x_labels.tolist(), rotation=90) ax.set_ylim(-1.1, 1.1) ax.set_title(str(folder) + '/' + str(timestamp)) ax.hlines([-1, 0, 1], x[0] - 1, x[-1] + 1, linestyles='dotted') if save and ax != None: try: fig.savefig(os.path.join(folder, 'simple_plot.png')) except: print 'Figure has not been saved.'
def fingerprint(timestamp=None, measurement_name = ['adwindata'], show_guess = True ): ''' Function to analyze simple fingerprint measurements. Inputs: timestamp: in format yyyymmdd_hhmmss or hhmmss or None. measurement_name: list of measurement names ''' if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data('DecouplingSequence') fit_results = [] for k in range(0,len(measurement_name)): a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(measurement_name[k]) a.get_electron_ROC() ax = a.plot_results_vs_sweepparam(ret='ax') x = a.sweep_pts.reshape(-1)[:] y = a.p0.reshape(-1)[:] # p0, fitfunc, fitfunc_str = common.fit_decaying_cos(frequency,offset, amplitude, phase, decay_constant) #plot the initial guess # 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=True, ret=True,fixed=[3]) # ## plot data and fit as function of total time # if plot_fit == True: # plot.plot_fit1d(fit_result, np.linspace(0,x[-1],201), ax=ax, plot_data=False) # fit_results.append(fit_result) plt.savefig(os.path.join(folder, 'analyzed_result.pdf'), format='pdf') plt.savefig(os.path.join(folder, 'analyzed_result.png'), format='png') return
def simple_plot(timestamp = None, measurement_name = ['adwindata'],folder_name ='CarbonPiCal', ssro_calib_timestamp =None, save = True, plot_fit = True) : ''' Function that makes a bar plot with errorbars of MBI type data ''' if timestamp == None: timestamp, folder = toolbox.latest_data(folder_name,return_timestamp =True) else: folder = toolbox.data_from_time(timestamp) if ssro_calib_timestamp == None: ssro_calib_folder = toolbox.latest_data('SSRO') else: ssro_dstmp, ssro_tstmp = toolbox.verify_timestamp(ssro_calib_timestamp) ssro_calib_folder = toolbox.datadir + '\\'+ssro_dstmp+'\\'+ssro_tstmp+'_AdwinSSRO_SSROCalibration_111_1_sil8' print ssro_calib_folder a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='adwindata') a.get_electron_ROC(ssro_calib_folder) x_labels = a.sweep_pts.reshape(-1) y= ((a.p0.reshape(-1))-0.5)*2 x = range(len(y)) y_err = 2*a.u_p0.reshape(-1) fig,ax = plt.subplots() rects = ax.errorbar(x,y,yerr=y_err) ax.set_xticks(x) ax.set_xticklabels(x_labels.tolist()) ax.set_ylim(-1.1,1.1) ax.set_title(str(folder)+'/'+str(timestamp)) ax.hlines([-1,0,1],x[0]-1,x[-1]+1,linestyles='dotted') if save and ax != None: try: fig.savefig( os.path.join(folder,'simple_plot.png')) except: print 'Figure has not been saved.'
def Zeno_get_2Q_values(timestamp=None, folder=None, folder_name='Zeno', measurement_name=['adwindata'], ssro_calib_timestamp=None): """ Returns the relevant RO values for a given timestamp. """ if timestamp == None and folder == None: timestamp, folder = toolbox.latest_data(folder_name, return_timestamp=True) elif timestamp == None and folder != None: pass else: folder = toolbox.data_from_time(timestamp) if folder != None and timestamp == None: d, t = toolbox.get_date_time_string_from_folder(folder) timestamp = toolbox.timestamp_from_datetime(t) ### SSRO calibration if ssro_calib_timestamp == None: ssro_calib_folder = toolbox.latest_data('SSRO', older_than=timestamp) else: ssro_dstmp, ssro_tstmp = toolbox.verify_timestamp(ssro_calib_timestamp) ssro_calib_folder = toolbox.datadir + '/' + ssro_dstmp + '/' + ssro_tstmp + '_AdwinSSRO_SSROCalibration_111_1_sil18' if 'Evotime' in folder: c1ms0 = float( folder[114:]) ##assign the frequency from the folder name else: c1ms0 = float(folder[-8:]) a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='adwindata') a.get_electron_ROC(ssro_calib_folder) x_labels = a.sweep_pts.reshape(-1) y = ((a.p0.reshape(-1)) - 0.5) * 2 y_err = 2 * a.u_p0.reshape(-1) return x_labels, c1ms0, y, y_err
def fingerprint(timestamp=None, measurement_name=['adwindata'], show_guess=True): ''' Function to analyze simple fingerprint measurements. Inputs: timestamp: in format yyyymmdd_hhmmss or hhmmss or None. measurement_name: list of measurement names ''' if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data('DecouplingSequence') fit_results = [] for k in range(0, len(measurement_name)): a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(measurement_name[k]) a.get_electron_ROC() ax = a.plot_results_vs_sweepparam(ret='ax') x = a.sweep_pts.reshape(-1)[:] y = a.p0.reshape(-1)[:] # p0, fitfunc, fitfunc_str = common.fit_decaying_cos(frequency,offset, amplitude, phase, decay_constant) #plot the initial guess # 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=True, ret=True,fixed=[3]) # ## plot data and fit as function of total time # if plot_fit == True: # plot.plot_fit1d(fit_result, np.linspace(0,x[-1],201), ax=ax, plot_data=False) # fit_results.append(fit_result) plt.savefig(os.path.join(folder, 'analyzed_result.pdf'), format='pdf') plt.savefig(os.path.join(folder, 'analyzed_result.png'), format='png') return
def load_mult_dat(timestamp, ssro_calib_folder =''): ''' function to load and combine multiple msmts. ''' cum_pts = 0 kk = 0 while True: folder = toolbox.data_from_time(timestamp) a = mbi.MBIAnalysis(folder) a.get_sweep_pts() try: a.get_readout_results(name='measurement' + str(kk)) except: print 'found no more data, stopping the loop after {} datasets'.format(kk) break a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder) cum_pts += a.pts if kk == 0: cum_p0 = a.p0 cum_u_p0 = a.u_p0 else: cum_p0 = np.concatenate((cum_p0, a.p0)) cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0)) kk+=1 print 'Number of datasets is',kk step = a.sweep_pts[-1]-a.sweep_pts[0] pts_per_msmt = len(a.sweep_pts) x_axis_start = a.sweep_pts[-1]-step*(kk) cum_sweep_pts = np.linspace(x_axis_start,a.sweep_pts[-1],cum_pts) a.pts = cum_pts a.sweep_pts = cum_sweep_pts a.p0 = cum_p0 a.u_p0 = cum_u_p0 return a, folder
def load_mult_dat(timestamp, ssro_calib_folder='', data_folder=None): ''' function to load and combine multiple msmts. ''' cum_pts = 0 kk = 0 while True: folder = toolbox.data_from_time(timestamp, folder=data_folder) a = mbi.MBIAnalysis(folder) a.get_sweep_pts() try: a.get_readout_results(name='measurement' + str(kk)) except: print 'found no more data, stopping the loop after {} datasets'.format( kk) break a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder) cum_pts += a.pts if kk == 0: cum_p0 = a.p0 cum_u_p0 = a.u_p0 else: cum_p0 = np.concatenate((cum_p0, a.p0)) cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0)) kk += 1 print 'Number of datasets is', kk step = a.sweep_pts[-1] - a.sweep_pts[0] pts_per_msmt = len(a.sweep_pts) x_axis_start = a.sweep_pts[-1] - step * (kk) cum_sweep_pts = np.linspace(x_axis_start, a.sweep_pts[-1], cum_pts) a.pts = cum_pts a.sweep_pts = cum_sweep_pts a.p0 = cum_p0 a.u_p0 = cum_u_p0 return a, folder
def electron_T2_anal(timestamp=None, measurement_name = ['ms0'],Amplitude = 1/2., T2 = 10e3, offset = 1./2, k=4, do_print = False, ylim=(0.,1.)): ''' Function to analyze simple decoupling measurements. Loads the results and fits them to a simple exponential. Inputs: timestamp: in format yyyymmdd_hhmmss or hhmmss or None. measurement_name: list of measurement names Based on electron_T1_anal, modified by Adriaan Rol ''' if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data('Decoupling') print folder fit_results = [] for k in range(0,len(measurement_name)): a = sequence.SequenceAnalysis(folder) a.get_sweep_pts() a.get_readout_results(measurement_name[k]) a.get_electron_ROC() ax = a.plot_result_vs_sweepparam(ret='ax') ax.set_ylim(ylim) x = a.sweep_pts p0, fitfunc, fitfunc_str = SE.fit_echo(T2, Amplitude, offset, k) y = a.p0 fit_result = fit.fit1d(x,y, None, p0=p0, fitfunc=fitfunc, do_print=do_print, ret=True, fixed=[3]) #fit_result = False if fit_result != False : plot.plot_fit1d(fit_result, np.linspace(0,x[-1],201), ax=ax, plot_data=False) fit_results.append(fit_result) plot.ylim=([0,0.2]) return fit_results
def load_mult_dat(timestamp, number_of_msmts, older_than='', ssro_calib_folder='', start=2.0, pts=51, step_size=10e-3): cum_pts = 0 for kk in range(number_of_msmts): folder = toolbox.data_from_time(timestamp, folder='d:\measuring\data') a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='measurement' + str(kk)) a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder) cum_pts += a.pts if kk == 0: cum_sweep_pts = np.linspace(start, start + (pts - 1) * step_size, pts) cum_p0 = a.p0 cum_u_p0 = a.u_p0 else: cum_sweep_pts = np.concatenate( (cum_sweep_pts, np.linspace( start + kk * (pts - 1) * step_size, start + (pts - 1) * step_size + kk * (pts - 1) * step_size, pts))) cum_p0 = np.concatenate((cum_p0, a.p0)) cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0)) a.pts = cum_pts a.sweep_pts = cum_sweep_pts a.p0 = cum_p0 a.u_p0 = cum_u_p0 return a, folder
def electron_T1_anal(timestamp=None, measurement_name = ['ms0'],Amplitude = 0.1, T1 = 1000, offset =1,do_print = False): ''' Function to analyze T1 measurements. Loads the results and fits them to a simple exponential. Inputs: timestamp: in format yyyymmdd_hhmmss or hhmmss or None. measurement_name: list of measurement names ''' if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data('T1') fit_results = [] for k in range(0,len(measurement_name)): a = sequence.SequenceAnalysis(folder) a.get_sweep_pts() a.get_readout_results('ssro') #a.get_readout_results(measurement_name[k]) #commented out since newer measurements are no longer grouped which renders the whole for-loop obsolete. NK 20141110 a.get_electron_ROC() ax = a.plot_result_vs_sweepparam(ret='ax') x = a.sweep_pts p0, fitfunc, fitfunc_str = common.fit_exp_decay_with_offset(offset, Amplitude, T1) y = a.p0 print y fit_result = fit.fit1d(x,y, 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) fit_results.append(fit_result) plt.savefig(os.path.join(folder, 'analyzed_result.pdf'), format='pdf') plt.savefig(os.path.join(folder, 'analyzed_result.png'), format='png') return fit_results
def get_and_plot_data(timestamp_list, ssro_calib_folder): for ii, timestamp in enumerate(timestamp_list): folder = toolbox.data_from_time(timestamp) a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='adwindata') # print ssro_calib_folder a.get_electron_ROC() if ii==0: ax = a.plot_results_vs_sweepparam(ret='ax', markersize = 4, save=False, fmt = 'o-') ax.set_ylim(-0.05,1.05) ax.set_xlim(a.sweep_pts[0],a.sweep_pts[-1]) ax.axhspan(0,1,fill=False,ls='dotted') ax.axhspan(0,0.5,fill=False,ls='dotted') else: a.plot_results_vs_sweepparam(ax= ax, markersize = 4, save=False, fmt = 'o-') if ii==0: p0_sum = a.p0 u_p0_sum = a.u_p0**2 else: p0_sum = p0_sum + a.p0 u_p0_sum = u_p0_sum + a.u_p0**2 a.p0 = p0_sum/len(timestamp_list) a.u_p0 = (u_p0_sum**0.5) / len(timestamp_list) a.x = a.sweep_pts.reshape(-1)[:] a.p0 = a.p0.reshape(-1)[:] a.u_p0 = a.u_p0.reshape(-1)[:] return a, folder
def get_coincidences_from_folder(folder,lt4_timestamps,timing_offsets,offsets_ch1, index = 1,save = True,pulse_offset=0): sync_num_name = 'PQ_sync_number-' + str(index) # print 'this is the save!', save co = np.ones([1,4]) for i,t_lt4 in enumerate(lt4_timestamps): f = tb.data_from_time(t_lt4,folder = folder) f = tb.get_msmt_fp(f) pqf = pq_tools.pqf_from_fp(f, rights = 'r+') if sync_num_name in pqf.keys(): if i == 0: co = get_coincidences(pqf,pulse_offset=pulse_offset) co[:,(1,2)]= co[:,(1,2)] + timing_offsets[i] co[:,2]= co[:,2] + offsets_ch1[i] else: co_temp = get_coincidences(pqf,pulse_offset=pulse_offset,save = save) co_temp[:,(1,2)]= co_temp[:,(1,2)] + timing_offsets[i] co_temp[:,2]= co_temp[:,2] + offsets_ch1[i] co = np.vstack((co, co_temp)) return co
def analyze_dark_esr_double(timestamp = None,center_guess = False, ax=None, ret=None,min_dip_depth = 0.85 ,do_ROC = True, **kw): if ax == None: fig, ax = plt.subplots(1,1) if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data('DarkESR') a = sequence.SequenceAnalysis(folder) a.get_sweep_pts() a.get_readout_results('ssro') # a.get_electron_ROC() x = a.sweep_pts # convert to MHz # y = a.get_readout_results('ssro') if do_ROC == True: a.get_electron_ROC() y = a.p0.reshape(-1)[:] else: y = a.get_readout_results('ssro') # y = a.p0.reshape(-1)[:] a.plot_result_vs_sweepparam(ret=ret, name='ssro', ax=ax) ax.set_ylim(0.6,1.05) # try fitting guess_offset = 1.0 guess_A_min = 0.3 guess_A_plus = 0.3 guess_x0 = 1.74666 guess_sigma = 0.100e-3 guess_Csplit = 0.210e-3/2 if center_guess == True: guess_x0 = float(raw_input('Center guess?')) else: guess_x0 = x[y.argmin()] guess_x0 = x[len(x)/2.] print 'guess_ctr = '+str(guess_x0) ### fitfunction A_min = fit.Parameter(guess_A_min, 'A_min') A_plus = fit.Parameter(guess_A_plus, 'A_plus') o = fit.Parameter(guess_offset, 'o') x0 = fit.Parameter(guess_x0, 'x0') sigma = fit.Parameter(guess_sigma, 'sigma') Csplit = fit.Parameter(guess_Csplit, 'Csplit') def fitfunc(x): return o() - A_min()*np.exp(-((x-(x0()-Csplit()))/sigma())**2) \ - A_plus()*np.exp(-((x-(x0()+Csplit()))/sigma())**2) \ fit_result = fit.fit1d(x, y, None, p0 = [A_min, A_plus, o, x0, sigma, Csplit], fitfunc = fitfunc, 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') 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
def append_data(timestamps_1=[None, None], timestamps_2=[], timestamps_3=[], ssro_folder=None, det=False, ms=None): y_total = ([]) y_err_total = ([]) x_total = ([]) x_labels_total = ([]) p0 = ([]) p1 = ([]) time_list = [timestamps_1] if timestamps_2 != []: time_list = [timestamps_1, timestamps_2] if timestamps_3 != []: time_list = [timestamps_1, timestamps_2, timestamps_3] for timestamps in time_list: folder_a = toolbox.data_from_time(timestamps[0]) folder_b = toolbox.data_from_time(timestamps[1]) if det == False: a = mbi.MBIAnalysis(folder_a) else: a = CP.ConditionalParityAnalysis(folder_a) a.get_sweep_pts() a.get_readout_results(name='adwindata') a.get_electron_ROC(ssro_folder) y_a = ((a.p0.reshape(-1)[:]) - 0.5) * 2 y_err_a = 2 * a.u_p0.reshape(-1)[:] if det == False: b = mbi.MBIAnalysis(folder_b) else: b = CP.ConditionalParityAnalysis(folder_b) b.get_sweep_pts() b.get_readout_results(name='adwindata') b.get_electron_ROC(ssro_folder) y_b = ((b.p0.reshape(-1)[:]) - 0.5) * 2 y_err_b = 2 * b.u_p0.reshape(-1)[:] x_labels = a.sweep_pts.reshape(-1)[:] # x = range(len(y_a)) y = (y_a - y_b) / 2. y_err = 1. / 2 * (y_err_a**2 + y_err_b**2)**0.5 if ms == 0: a = CP.ConditionalParityAnalysis(folder_a) a.get_sweep_pts() a.get_readout_results(name='adwindata', post_select=True) a.get_electron_ROC(ssro_folder) c0_0_p, u_c0_0_p = a.convert_fidelity_to_contrast(a.p0_0, a.u_p0_0) c0_1_p, u_c0_1_p = a.convert_fidelity_to_contrast(a.p0_1, a.u_p0_1) b = CP.ConditionalParityAnalysis(folder_b) b.get_sweep_pts() b.get_readout_results(name='adwindata', post_select=True) b.get_electron_ROC(ssro_folder) c0_0_n, u_c0_0_n = b.convert_fidelity_to_contrast(b.p0_0, b.u_p0_0) c0_1_n, u_c0_1_n = b.convert_fidelity_to_contrast(b.p0_1, b.u_p0_1) ## ms=0 data y = (c0_0_p - c0_0_n) / 2. y_err = 1. / 2 * (u_c0_0_p**2 + u_c0_0_n**2)**0.5 if ms == 1: a = CP.ConditionalParityAnalysis(folder_a) a.get_sweep_pts() a.get_readout_results(name='adwindata', post_select=True) a.get_electron_ROC(ssro_folder) c0_0_p, u_c0_0_p = a.convert_fidelity_to_contrast(a.p0_0, a.u_p0_0) c0_1_p, u_c0_1_p = a.convert_fidelity_to_contrast(a.p0_1, a.u_p0_1) b = CP.ConditionalParityAnalysis(folder_b) b.get_sweep_pts() b.get_readout_results(name='adwindata', post_select=True) b.get_electron_ROC(ssro_folder) c0_0_n, u_c0_0_n = b.convert_fidelity_to_contrast(b.p0_0, b.u_p0_0) c0_1_n, u_c0_1_n = b.convert_fidelity_to_contrast(b.p0_1, b.u_p0_1) ## ms=1 data y = (c0_1_p - c0_1_n) / 2. y_err = 1. / 2 * (u_c0_1_p**2 + u_c0_1_n**2)**0.5 y_total = np.append(y_total, y) if det == True and ms != None: print 'PROBABILITIES' print 1 / 2. * (a.p0 + b.p0) print 1 / 2. * (a.p1 + b.p1) p0 = np.append(p0, 1 / 2. * (a.p0 + b.p0)) p1 = np.append(p1, 1 / 2. * (a.p1 + b.p1)) y_err_total = np.append(y_err_total, y_err) # x_total = np.append(x_total,x) x_labels_total = np.append(x_labels_total, x_labels) if det == True and ms != None: print 'PROBABILITIES' print p0 print p1 print np.average(p0) print np.average(p1) # print 1/2.*(a.p0+b.p0) # if ms ==1: # sign = [1,1,1,-1,1,-1,-1,1,-1,-1,1,-1,-1,1,-1] # print len(sign) # print len(y_total) # y_total = [y_total[i]*sign[i] for i in range(len(y_total))] x_total = range(len(y_total)) return x_total, x_labels_total, y_total, y_err_total
def Carbon_Ramsey(timestamp=None, measurement_name=['adwindata'], ssro_folder=None, frequency=1, offset=0.5, x0=0, amplitude=0.5, decay_constant=0.015, phase=0, exponent=2, plot_fit=False, do_print=False, fixed=[2], show_guess=True, return_phase=False, return_freq=False, return_A=False, return_results=True, close_plot=False, title='Carbon'): ''' ''' folder = toolbox.data_from_time(timestamp) ssro_calib_folder = ssro_folder fit_results = [] a = mbi.MBIAnalysis(folder) a.get_sweep_pts() a.get_readout_results(name='adwindata') a.get_electron_ROC(ssro_calib_folder) ax = a.plot_results_vs_sweepparam(ret='ax') x = a.sweep_pts.reshape(-1)[:] y = a.p0.reshape(-1)[:] y_err = a.u_p0.reshape(-1)[:] ax.plot(x, y) p0, fitfunc, fitfunc_str = common.fit_general_exponential_dec_cos( offset, amplitude, x0, decay_constant, exponent, frequency, phase) #plot the initial guess 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=fixed) print 'fitfunction: ' + fitfunc_str ## plot data and fit as function of total time if plot_fit == True: plot.plot_fit1d(fit_result, np.linspace(x[0], x[-1], 1001), ax=ax, plot_data=False) fit_results.append(fit_result) if title == None: title = 'analyzed_result' plt.savefig(os.path.join(folder, title + '.pdf'), format='pdf') plt.savefig(os.path.join(folder, title + '.png'), format='png') return x, y, y_err, fit_result
import logging from matplotlib import pyplot as plt from analysis.lib import fitting from analysis.lib.m2.ssro import mbi reload(mbi) from analysis.lib.fitting import fit from analysis.lib.tools import toolbox from analysis.lib.m2 import m2 from analysis.lib.m2.ssro import ssro from analysis.lib.tools import plot timestamp = None#'20130823183658'# None#'20130802141105'#'20130731181935' # '20130802141105' if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data() 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', name= 'adwindata') #a = sequence.SequenceAnalysis(folder) #a.get_sweep_pts() #a.get_readout_results(name='ssro') #a.get_electron_ROC() #a.get_N_ROC(1.00, 0.02, 0.94, 0.01, 0.96, 0.01) #ax = a.plot_result_vs_sweepparam(ret='ax', name='ssro')
def Carbon_Ramsey(timestamp=None, measurement_name = ['adwindata'], frequency = [1], amplitude = [0.5], decay_constant = [200],phase =[0], offset = 0.5, fitfunc_type = 'single', plot_fit = False, do_print = False, show_guess = True, fitexp = None): ''' Inputs: timestamp: in format yyyymmdd_hhmmss or hhmmss or None. measurement_name: list of measurement names ''' if timestamp != None: folder = toolbox.data_from_time(timestamp) else: folder = toolbox.latest_data('CarbonRamsey') 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() a.sweep_pts = a.sweep_pts*1e6 ax = a.plot_results_vs_sweepparam(ret='ax') ax.set_ylim(-0.05,1.05) ax.set_xlim(-0.05,40) x = a.sweep_pts.reshape(-1)[:] y = a.p0.reshape(-1)[:] print fitexp print print if len(frequency) == 1: if fitexp == 'Gaussian': p0, fitfunc, fitfunc_str = common.fit_gaussian_decaying_cos(frequency[0], offset, amplitude[0], phase[0], decay_constant[0]) print 'ok' else: p0, fitfunc, fitfunc_str = common.fit_decaying_cos(frequency[0], offset, amplitude[0], phase[0], decay_constant[0]) #plot the initial guess print 'no' 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=True, ret=True,fixed=[4]) elif len(frequency) == 2: print 'yes' p0, fitfunc, fitfunc_str = common.fit_double_decaying_cos(frequency[0], amplitude[0], phase[0], decay_constant[0], frequency[1], amplitude[1], phase[1], decay_constant[1], offset) 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=True, ret=True,fixed=[2,3,6,7]) ### Also plot the individual curves # p0_0, fitfunc_0, fitfunc_str_0 = common.fit_double_decaying_cos(fit_result['params'][0], 0, phase[0], fit_result['params'][2], fit_result['params'][3], fit_result['params'][4], phase[1], fit_result['params'][5]) # ax.plot(np.linspace(0,x[-1],201), fitfunc_0(np.linspace(0,x[-1],201)), 'b-', lw=1) # p0_1, fitfunc_1, fitfunc_str_1 = common.fit_double_decaying_cos(fit_result['params'][0], fit_result['params'][1], phase[0], fit_result['params'][2], fit_result['params'][3],0, phase[1], fit_result['params'][5]) # ax.plot(np.linspace(0,x[-1],201), fitfunc_1(np.linspace(0,x[-1],201)), 'm-', lw=1) ## plot fit if plot_fit == True: plot.plot_fit1d(fit_result, np.linspace(0,x[-1],201), ax=ax, plot_data=False) fit_results.append(fit_result) ax.set_xlabel('Free evolution time (us)') print folder plt.savefig(os.path.join(folder, 'analyzed_result2.pdf'), format='pdf') plt.savefig(os.path.join(folder, 'analyzed_result2.png'), format='png') # 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 ### PLEASE DO NOT DO THESE KIND OF THINGS BELOW!!!! ### THIS IS A MODULE WITH FUNCTIONS THAT ARE GENERALLY USED ### DO NO ADD DATA HERE< BUT IMPORT THIS FUNCTION IF YOU NEED IT ######################### RAMSEY T2* ############################################## # Carbon_Ramsey(timestamp='20140519135216', measurement_name = ['adwindata'], # frequency = [575], amplitude = [0.5], decay_constant = [0.009],phase =[0], # fitfunc_type = 'single', plot_fit = True, do_print = False, show_guess = False,fitexp='Gaussian') # Carbon_Ramsey(timestamp='20140519183105', measurement_name = ['adwindata'], # frequency = [575], amplitude = [0.5], decay_constant = [0.007],phase =[0], # fitfunc_type = 'single', plot_fit = True, do_print = False, show_guess = False,fitexp='Gaussian') # Carbon_Ramsey(timestamp='20140520134826', measurement_name = ['adwindata'], # frequency = [205], amplitude = [0.5], decay_constant = [0.007],phase =[0], # fitfunc_type = 'single', plot_fit = True, do_print = False, show_guess = False,fitexp='Gaussian') ######################## RAMSEY 2 freq ############################################## # Carbon_Ramsey(timestamp='20140521164658', measurement_name = ['adwindata'], # frequency = [338e-3,14e-3], amplitude = [1,1], decay_constant = [0.009e6,0.009e6],phase =[0,0], # fitfunc_type = 'single', plot_fit = True, do_print = False, show_guess = False) # Carbon_Ramsey(timestamp='20140521165249', measurement_name = ['adwindata'], # frequency = [305e-3,16e-3], amplitude = [1,1], decay_constant = [0.009e6,0.009e6],phase =[0,0], # fitfunc_type = 'single', plot_fit = True, do_print = False, show_guess = False) # Carbon_Ramsey(timestamp='20140521170735', measurement_name = ['adwindata'], # frequency = [350e-3,27e-3], amplitude = [1,1], decay_constant = [0.009e6,0.009e6],phase =[0,0], # fitfunc_type = 'single', plot_fit = True, do_print = False, show_guess = False) # Carbon_Ramsey(timestamp='20140521162939', measurement_name = ['adwindata'], # frequency = [344e-3,19e-3], amplitude = [1,1], decay_constant = [0.009e6,0.009e6],phase =[0,0], # fitfunc_type = 'single', plot_fit = True, do_print = False, show_guess = False) # ######################### RAMSEY simple ############################################## # Carbon_Ramsey(timestamp='20140507114220', measurement_name = ['adwindata'], # frequency = [350e-3], amplitude = [-0.5], decay_constant = [900e6],phase =[0], # fitfunc_type = 'single', plot_fit = True, do_print = False, show_guess = False,fitexp='Gaussian') # Carbon_Ramsey(timestamp='20140507124543', measurement_name = ['adwindata'], # frequency = [350e-3], amplitude = [-0.5], decay_constant = [900e6],phase =[0], # fitfunc_type = 'single', plot_fit = True, do_print = False, show_guess = False,fitexp='Gaussian') # Carbon_Ramsey(timestamp='20140507151219', measurement_name = ['adwindata'], # frequency = [350e-3], amplitude = [-0.5], decay_constant = [900e6],phase =[0], # fitfunc_type = 'single', plot_fit = True, do_print = False, show_guess = False,fitexp='Gaussian') # Carbon_Ramsey(timestamp='20140429141113', measurement_name = ['adwindata'], # frequency = [350e-3], amplitude = [-0.5], decay_constant = [900e6],phase =[0], # fitfunc_type = 'single', plot_fit = True, do_print = False, show_guess = False,fitexp='Gaussian')