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