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 compile_xy_values_of_datasets(f_list, ssro_tstamp='112128', **kw):
"""
besides returning all msmt values this function also returns
one data object in case one wants to review msmt params.
"""
if ssro_tstamp == None:
ssro_calib_folder = tb.latest_data('SSROCalib')
else:
ssro_dstmp, ssro_tstmp = tb.verify_timestamp(ssro_tstamp)
ssro_calib_folder = tb.latest_data(ssro_tstmp)
x = []
y = []
y_u = []
for f in f_list:
a = mbi.MBIAnalysis(f)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC(ssro_calib_folder)
x.extend(a.sweep_pts.reshape(-1))
y.extend(a.p0.reshape(-1))
y_u.extend(a.u_p0.reshape(-1))
return x, y, y_u, a
def get_3mmt_data(folder,folder_timestamp,RO_correct=True,ssro_calib_timestamp=None,tomo_bases='XXX',get_title=False,return_orientations=False):
a = CP.ConditionalParityAnalysis(folder)
#a.get_sweep_pts()
a.get_readout_results(name='adwindata', post_select_QEC = True,orientation_correct=True)
orientations = a.orientations
orientation_c = a.orientations[2]
if orientation_c == 'negative':
multiply_by = -1
else:
multiply_by = 1
#print(a.orientations,multiply_by)
if RO_correct == True:
if ssro_calib_timestamp == None:
ssro_calib_folder = toolbox.latest_data('SSRO',older_than=folder_timestamp)
analysis_file=os.path.join(ssro_calib_folder,'analysis.hdf5')
if not os.path.exists(analysis_file):
ssro.ssrocalib(ssro_calib_folder)
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'#GHZ_'+tomo_bases
#print ssro_calib_folder
a.get_electron_ROC(ssro_calib_folder = ssro_calib_folder, post_select_QEC = True)
#take the [0,0] part of the arrays right now; no sweep_pts
p0_00,u_p0_00 = multiply_by*(a.p0_00[0,0]-0.5)*2,(2*a.u_p0_00[0,0])
p0_01,u_p0_01 = multiply_by*(a.p0_01[0,0]-0.5)*2,(2*a.u_p0_01[0,0])
p0_10,u_p0_10 = multiply_by*(a.p0_10[0,0]-0.5)*2,(2*a.u_p0_10[0,0])
p0_11,u_p0_11 = multiply_by*(a.p0_11[0,0]-0.5)*2,(2*a.u_p0_11[0,0])
else:
p0_00,u_p0_00 = multiply_by*(a.normalized_ssro_00[0,0]-0.5)*2,(2*a.u_normalized_ssro_00[0,0])
p0_01,u_p0_01 = multiply_by*(a.normalized_ssro_01[0,0]-0.5)*2,(2*a.u_normalized_ssro_01[0,0])
p0_10,u_p0_10 = multiply_by*(a.normalized_ssro_10[0,0]-0.5)*2,(2*a.u_normalized_ssro_10[0,0])
p0_11,u_p0_11 = multiply_by*(a.normalized_ssro_11[0,0]-0.5)*2,(2*a.u_normalized_ssro_11[0,0])
if get_title:
a_list_name = "".join(aa for aa in a.a_list)
b_list_name = "".join(aa for aa in a.b_list)
c_list_name = "".join(aa for aa in a.c_list)
title = a_list_name+' '+b_list_name+' '+c_list_name
else:
title=''
p = (a.p00[0,0],a.p01[0,0],a.p10[0,0],a.p11[0,0])
y = (p0_00,p0_01,p0_10,p0_11)
y_avg = np.mean(y, axis=0)
#print y_avg
y_err = (u_p0_00,u_p0_01,u_p0_10,u_p0_11)
if return_orientations:
return(p,y,y_err,title,orientations)
return(p,y,y_err,title)
def get_3mmt_data(folder,folder_timestamp,RO_correct=True,ssro_calib_timestamp=None,tomo_bases='XXX',get_title=False,return_orientations=False):
a = CP.ConditionalParityAnalysis(folder)
#a.get_sweep_pts()
a.get_readout_results(name='adwindata', post_select_QEC = True,orientation_correct=True)
orientations = a.orientations
orientation_c = a.orientations[2]
if orientation_c == 'negative':
multiply_by = -1
else:
multiply_by = 1
#print(a.orientations,multiply_by)
if RO_correct == True:
if ssro_calib_timestamp == None:
ssro_calib_folder = toolbox.latest_data('SSRO',older_than=folder_timestamp)
analysis_file=os.path.join(ssro_calib_folder,'analysis.hdf5')
if not os.path.exists(analysis_file):
ssro.ssrocalib(ssro_calib_folder)
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'#GHZ_'+tomo_bases
#print ssro_calib_folder
a.get_electron_ROC(ssro_calib_folder = ssro_calib_folder, post_select_QEC = True)
#take the [0,0] part of the arrays right now; no sweep_pts
p0_00,u_p0_00 = multiply_by*(a.p0_00[0,0]-0.5)*2,(2*a.u_p0_00[0,0])
p0_01,u_p0_01 = multiply_by*(a.p0_01[0,0]-0.5)*2,(2*a.u_p0_01[0,0])
p0_10,u_p0_10 = multiply_by*(a.p0_10[0,0]-0.5)*2,(2*a.u_p0_10[0,0])
p0_11,u_p0_11 = multiply_by*(a.p0_11[0,0]-0.5)*2,(2*a.u_p0_11[0,0])
else:
p0_00,u_p0_00 = multiply_by*(a.normalized_ssro_00[0,0]-0.5)*2,(2*a.u_normalized_ssro_00[0,0])
p0_01,u_p0_01 = multiply_by*(a.normalized_ssro_01[0,0]-0.5)*2,(2*a.u_normalized_ssro_01[0,0])
p0_10,u_p0_10 = multiply_by*(a.normalized_ssro_10[0,0]-0.5)*2,(2*a.u_normalized_ssro_10[0,0])
p0_11,u_p0_11 = multiply_by*(a.normalized_ssro_11[0,0]-0.5)*2,(2*a.u_normalized_ssro_11[0,0])
if get_title:
a_list_name = "".join(aa for aa in a.a_list)
b_list_name = "".join(aa for aa in a.b_list)
c_list_name = "".join(aa for aa in a.c_list)
title = a_list_name+' '+b_list_name+' '+c_list_name
else:
title=''
p = (a.p00[0,0],a.p01[0,0],a.p10[0,0],a.p11[0,0])
y = (p0_00,p0_01,p0_10,p0_11)
y_avg = np.mean(y, axis=0)
#print y_avg
y_err = (u_p0_00,u_p0_01,u_p0_10,u_p0_11)
if return_orientations:
return(p,y,y_err,title,orientations)
return(p,y,y_err,title)
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_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 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 get_PosNeg_data(name,**kw):
ssro_calib_timestamp = kw.pop('ssro_calib_timestamp',None)
older_than = kw.pop('older_than',None)
data_dict = {
'folders' : [],
'sweep_pts': [],
'res' : [],
'res_u' : []
}
for ro in ['positive','negative']:
search_string = ro+name
data_dict['folders'].append(toolbox.latest_data(contains = search_string,older_than = older_than,raise_exc = False))
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
for i,f in enumerate(data_dict['folders']):
a = mbi.MBIAnalysis(f)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC(ssro_calib_folder)
x_labels = a.sweep_pts.reshape(-1)
if i == 0:
data_dict['res'] = ((a.p0.reshape(-1))-0.5)*2
data_dict['res_u'] = 2*a.u_p0.reshape(-1)
else:
y = ((a.p0.reshape(-1))-0.5)*2
y_u = 2*a.u_p0.reshape(-1)
data_dict['res'] = [y0/2-y[ii]/2 for ii,y0 in enumerate(data_dict['res'])]
data_dict['res_u'] = [np.sqrt(y0**2+y_u[ii]**2)/2 for ii,y0 in enumerate(data_dict['res_u'])]
return x_labels,data_dict['res'],data_dict['res_u'],data_dict['folders'][0]
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 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 get_PosNeg_data(name, **kw):
ssro_calib_timestamp = kw.pop('ssro_calib_timestamp', None)
older_than = kw.pop('older_than', None)
data_dict = {'folders': [], 'sweep_pts': [], 'res': [], 'res_u': []}
for ro in ['positive', 'negative']:
search_string = ro + name
data_dict['folders'].append(
toolbox.latest_data(contains=search_string,
older_than=older_than,
raise_exc=False))
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
for i, f in enumerate(data_dict['folders']):
a = mbi.MBIAnalysis(f)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC(ssro_calib_folder)
x_labels = a.sweep_pts.reshape(-1)
if i == 0:
data_dict['res'] = ((a.p0.reshape(-1)) - 0.5) * 2
data_dict['res_u'] = 2 * a.u_p0.reshape(-1)
else:
y = ((a.p0.reshape(-1)) - 0.5) * 2
y_u = 2 * a.u_p0.reshape(-1)
data_dict['res'] = [
y0 / 2 - y[ii] / 2 for ii, y0 in enumerate(data_dict['res'])
]
data_dict['res_u'] = [
np.sqrt(y0**2 + y_u[ii]**2) / 2
for ii, y0 in enumerate(data_dict['res_u'])
]
return x_labels, data_dict['res'], data_dict['res_u'], data_dict[
'folders'][0]
def get_debug_data(folder,folder_timestamp,RO_correct=True,ssro_calib_timestamp=None,tomo_bases="XXX"):
a = CP.ConditionalParityAnalysis(folder)
#a.get_sweep_pts()
a.get_readout_results(name='adwindata', post_select = True, orientation_correct=True)
orientation_b = a.orientations[1]
if orientation_b == 'negative':
multiply_by = -1
else:
multiply_by = 1
#print(a.orientations,multiply_by)
if RO_correct == True:
if ssro_calib_timestamp == None:
ssro_calib_folder = toolbox.latest_data('SSRO',older_than=folder_timestamp)
if not os.path.exists(os.path.join(ssro_calib_folder,'analysis.hdf5')):
ssro.ssrocalib(ssro_calib_folder)
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'#GHZ_'+tomo_bases
print ssro_calib_folder
a.get_electron_ROC(ssro_calib_folder = ssro_calib_folder)
#take the [0,0] part of the arrays right now; no sweep_pts
p0_0,u_p0_0 = multiply_by*(a.p0_0[0,0]-0.5)*2,(2*a.u_p0_0[0,0])
p0_1,u_p0_1 = multiply_by*(a.p0_1[0,0]-0.5)*2,(2*a.u_p0_1[0,0])
else:
p0_0,u_p0_0 = multiply_by*(a.normalized_ssro_0[0,0]-0.5)*2,(2*a.u_normalized_ssro_0[0,0])
p0_1,u_p0_1 = multiply_by*(a.normalized_ssro_1[0,0]-0.5)*2,(2*a.u_normalized_ssro_1[0,0])
p = (a.p0,a.p1)
y = (p0_0,p0_1)
y_avg = np.mean(y, axis=0)
#print y_avg
y_err = (u_p0_0,u_p0_1)
return(p,y,y_err)
def get_debug_data(folder,folder_timestamp,RO_correct=True,ssro_calib_timestamp=None,tomo_bases="XXX"):
a = CP.ConditionalParityAnalysis(folder)
#a.get_sweep_pts()
a.get_readout_results(name='adwindata', post_select = True, orientation_correct=True)
orientation_b = a.orientations[1]
if orientation_b == 'negative':
multiply_by = -1
else:
multiply_by = 1
#print(a.orientations,multiply_by)
if RO_correct == True:
if ssro_calib_timestamp == None:
ssro_calib_folder = toolbox.latest_data('SSRO',older_than=folder_timestamp)
if not os.path.exists(os.path.join(ssro_calib_folder,'analysis.hdf5')):
ssro.ssrocalib(ssro_calib_folder)
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'#GHZ_'+tomo_bases
# print ssro_calib_folder
a.get_electron_ROC(ssro_calib_folder = ssro_calib_folder)
#take the [0,0] part of the arrays right now; no sweep_pts
p0_0,u_p0_0 = multiply_by*(a.p0_0[0,0]-0.5)*2,(2*a.u_p0_0[0,0])
p0_1,u_p0_1 = multiply_by*(a.p0_1[0,0]-0.5)*2,(2*a.u_p0_1[0,0])
else:
p0_0,u_p0_0 = multiply_by*(a.normalized_ssro_0[0,0]-0.5)*2,(2*a.u_normalized_ssro_0[0,0])
p0_1,u_p0_1 = multiply_by*(a.normalized_ssro_1[0,0]-0.5)*2,(2*a.u_normalized_ssro_1[0,0])
p = (a.p0,a.p1)
y = (p0_0,p0_1)
y_avg = np.mean(y, axis=0)
#print y_avg
y_err = (u_p0_0,u_p0_1)
return(p,y,y_err)
def Carbon_phase_sweep(timestamp=None, measurement_name = ['adwindata'], ssro_calib_timestamp =None,
frequency = 1, offset = 0.5, amplitude = 0.5, phase =0,
fixed = [],
plot_fit = False, do_print = False, show_guess = True):
'''
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
List of parameters (order important for 'fixed')
[freq, offset, Amplitude, phase]
'''
if timestamp != None:
folder = toolbox.data_from_time(timestamp)
else:
folder = toolbox.latest_data('CarbonR')
# folder = toolbox.latest_data('CarbonT1')
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'
print ssro_calib_folder
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(ssro_calib_folder)
ax = a.plot_results_vs_sweepparam(ret='ax')
x = a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
ax.plot(x,y)
p0, fitfunc, fitfunc_str = common.fit_cos(frequency, offset, amplitude ,phase )
#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=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],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 Carbon_T1(timestamp=None,
measurement_name='adwindata',
ssro_calib_timestamp=None,
offset=0.5,
x0=0,
amplitude=0.5,
decay_constant=200,
exponent=2,
plot_fit=False,
do_print=False,
fixed=[2],
show_guess=True):
'''
Inputs:
timestamp: in format yyyymmdd_hhmmss or hhmmss or None.
measurement_name: list of measurement names
List of parameters (order important for 'fixed')
offset, amplitude, decay_constant,exponent,frequency ,phase
'''
figsize = (6, 4.7)
if timestamp != None:
folder = toolbox.data_from_time(timestamp)
else:
folder = toolbox.latest_data('ElectronRepump')
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'
print ssro_calib_folder
fit_results = []
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC(ssro_calib_folder)
# print a.result_corrected
# print a.p0[:,0]
# print a.sweep_pts
# print a.labels
# print a.u_p0[:,0]
# print a.readouts
ax = a.plot_results_vs_sweepparam(ret='ax',
ax=None,
figsize=figsize,
ylim=(0.0, 1.0))
x = a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
# ax.plot(x,y)
p0, fitfunc, fitfunc_str = common.fit_general_exponential(
offset, amplitude, x0, decay_constant, exponent)
#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)
## 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)
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 Carbon_T1_analysis(measurement_name = ['adwindata'], ssro_calib_timestamp =None,
offset = 0.5,
amplitude = 0.5,
decay_constant = 0.1,
x0=0,
exponent = 1,
Addressed_carbon=1,
el_RO='positive',
plot_fit = True, do_print = True, show_guess = False):
'''
Function to gather and analyze T1 measurements of a specific carbon.
Addressed_carbon: selects the used timestamps and therefore the analyzed carbon
measurement_name: list of measurement names
Possible inputs for initial guesses: offset, amplitude, decay_constant,exponent
'''
#general plot parameters
ylim=(0.0,1.0)
figsize=(6,4.7)
######################################
# carbon_init= up el_state=0 #
######################################
if Addressed_carbon == 1:
if el_RO=='positive':
timestamp=['20141104_194723','20141104_200359','20141104_215235']
else:
timestamp=['20141104_195541','20141104_205814','20141104_231030']
elif Addressed_carbon == 5:
if el_RO=='positive':
timestamp=['20150316_041301']
# timestamp=['20141105_002824','20141105_004556','20141105_023521']
else:
timestamp=['20150316_054506']
# timestamp=['20141105_003711','20141105_014037','20141105_035322']
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_sil18'
print ssro_calib_folder
##accumulate data and average over positive and negative RO##
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')
timestamp_SSRO, ssro_calib_folder = toolbox.latest_data('AdwinSSRO', older_than = timestamp[kk], return_timestamp = True)
a.get_electron_ROC(ssro_calib_folder)
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
## accumulate data with negative RO
#sort data by free evolution time.
sorting_order=a.sweep_pts.argsort()
a.sweep_pts.sort()
a.p0=a.p0[sorting_order]
a.u_p0=a.u_p0[sorting_order]
## generate plot of the raw data ##
#uncomment this part to plot without error bars, but including obtained fit parameters.
# fig = a.default_fig(figsize=(6,5))
# ax = a.default_ax(fig)
# ax.plot(a.sweep_pts, a.p0, 'bo',label='T1 of Carbon'+str(Addressed_carbon),lw=1.2)
ax=a.plot_results_vs_sweepparam(ret='ax',ax=None,
figsize=figsize,
ylim=(0.0,1.0)
)
## fit to a general exponential##
fit_results = []
x = a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
ax.plot(x,y)
p0, fitfunc, fitfunc_str = common.fit_general_exponential(offset, amplitude, x0, decay_constant,exponent)
#p0, fitfunc, fitfunc_str = common.fit_line(0.5,-0.5/7.)
#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=[0,2])
## 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)
filename= 'C13_T1_analysis_up_positive_C'+str(Addressed_carbon)+'_'+el_RO
print 'plots are saved in ' + folder
#configure the plot
plt.title('Sample_111_No1_C13_T1_up_positive_C'+str(Addressed_carbon)+'el_state_0')
plt.xlabel('Free evolution time (s)')
plt.ylabel('Fidelity')
plt.axis([a.sweep_pts[0],a.sweep_pts[a.pts-1],0.0,1.])
plt.savefig(os.path.join(folder, filename+'.pdf'),
format='pdf')
plt.savefig(os.path.join(folder, filename+'.png'),
format='png')
######################################
# carbon_init= up el_state=1 #
######################################
if Addressed_carbon == 1:
if el_RO=='positive':
timestamp=['20141104_195135','20141104_203107','20141104_223132']
else:
timestamp=['20141104_195949','20141104_212524','20141104_234927']
elif Addressed_carbon == 5:
if el_RO=='positive':
timestamp=['20150316_055528']
# timestamp=['20141105_003250','20141105_011316','20141105_031420']
else:
timestamp=['20150316_042310']
# timestamp=['20141105_004136','20141105_020802','20141105_043221']
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_sil18'
print ssro_calib_folder
##accumulate data and average over positive and negative RO##
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')
timestamp_SSRO, ssro_calib_folder = toolbox.latest_data('AdwinSSRO', older_than = timestamp[kk], return_timestamp = True)
a.get_electron_ROC(ssro_calib_folder)
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))
print
a.pts = cum_pts
a.sweep_pts = cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
## accumulate data with negative RO
#sort data by free evolution time.
sorting_order=a.sweep_pts.argsort()
a.sweep_pts.sort()
a.p0=a.p0[sorting_order]
a.u_p0=a.u_p0[sorting_order]
## generate plot of the raw data ##
#uncomment this part to plot without error bars, but including obtained fit parameters.
# fig = a.default_fig(figsize=(6,5))
# ax = a.default_ax(fig)
# ax.plot(a.sweep_pts, a.p0, 'bo',label='T1 of Carbon'+str(Addressed_carbon),lw=1.2)
ax=a.plot_results_vs_sweepparam(ret='ax',figsize=figsize, ax=None, ylim=ylim)
## fit to a general exponential##
fit_results = []
x = a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
ax.plot(x,y)
p0, fitfunc, fitfunc_str = common.fit_general_exponential(offset, amplitude, x0, decay_constant,exponent)
#p0, fitfunc, fitfunc_str = common.fit_line(0.5,-0.5/7.)
#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=[0,2])
## 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)
filename= 'C13_T1_analysis_up_negative_C'+str(Addressed_carbon)+'_'+el_RO
print 'plots are saved in ' + folder
#configure the plot
plt.title('Sample_111_No1_C13_T1_up_negative_C'+str(Addressed_carbon)+'el_state_1')
plt.xlabel('Free evolution time (s)')
plt.ylabel('Fidelity')
plt.axis([a.sweep_pts[0],a.sweep_pts[a.pts-1],ylim[0],ylim[1]])
plt.savefig(os.path.join(folder, filename+'.pdf'),
format='pdf')
plt.savefig(os.path.join(folder, filename+'.png'),
format='png')
def simple_plot_contrast(timestamps = [None,None], tag = '', measurement_name = ['adwindata'],folder_name ='Tomo',
ssro_calib_timestamp =None, save = True,
do_plot = True, return_data = False,
guess_frq = 1/4000.,
guess_amp = 1.5,
guess_k = 0.,
guess_phi = 0.,
guess_o = 0.3):
### SSRO calibration
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'
if timestamps[0] == None:
folder_a = toolbox.latest_data(contains='positive' + tag)
folder_b = toolbox.latest_data(contains='negative' + tag)
elif len(timestamps)==1:
folder_b = toolbox.data_from_time(timestamps[0])
print folder_b
folder_a = toolbox.latest_data(contains = 'pos', older_than = timestamps[0])
print folder_a
else:
folder_a = toolbox.data_from_time(timestamps[0])
folder_b = toolbox.data_from_time(timestamps[1])
a = mbi.MBIAnalysis(folder_a)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC(ssro_calib_folder)
y_a= ((a.p0.reshape(-1)[:])-0.5)*2
y_err_a = 2*a.u_p0.reshape(-1)[:]
b = mbi.MBIAnalysis(folder_b)
b.get_sweep_pts()
b.get_readout_results(name='adwindata')
b.get_electron_ROC(ssro_calib_folder)
y_b= ((b.p0.reshape(-1)[:])-0.5)*2
y_err_b = 2*b.u_p0.reshape(-1)[:]
x = a.sweep_pts.reshape(-1)[:]
# x = range(len(y_a))
# ax = a.plot_results_vs_sweepparam(ret='ax', name = 'adwindata' )
### Combine data
y = (y_a - y_b)/2.
y_err = 1./2*(y_err_a**2 + y_err_b**2)**0.5
if x[-1] < x[0]:
x = x[::-1]
y = y[::-1]
fig,ax = plt.subplots()
o = fit.Parameter(guess_o, '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 = [A,o,f,phi]
fitfunc_str = ''
ax.errorbar(x,y,yerr = y_err, marker = 'o',ls = '')
def fitfunc(x):
return (o()-A()) + A() * np.exp(-(k()*x)**2) * np.cos(2*np.pi*(f()*x - phi()))
fit_result = fit.fit1d(x,y, None, p0=p0, fitfunc=fitfunc, fixed=[],
do_print=True, ret=True)
ax.set_title(folder_a)
y_fit = fit_result['fitfunc'](np.arange(0,60,1))
for i, y in enumerate(abs(y_fit)):
if y == min(abs(y_fit)):
x_opt = i
ax.text(5,0.9,'pulses for pi/2: ' +str(x_opt))
plot.plot_fit1d(fit_result, np.linspace(0,x[-1],201), ax=ax,
plot_data=False)
ax.set_ylim([-1,1])
plt.savefig(os.path.join(folder_a, 'mbi_erabi_analysis.pdf'),
format='pdf')
plt.savefig(os.path.join(folder_a, 'mbi_erabi_analysis.png'),
format='png')
def Carbon_T1(timestamp=None, measurement_name = 'adwindata', ssro_calib_timestamp =None,
offset = 0.5,
x0 = 0,
amplitude = 0.5,
decay_constant = 200,
exponent = 2,
plot_fit = False, do_print = False, fixed = [2], show_guess = True):
'''
Inputs:
timestamp: in format yyyymmdd_hhmmss or hhmmss or None.
measurement_name: list of measurement names
List of parameters (order important for 'fixed')
offset, amplitude, decay_constant,exponent,frequency ,phase
'''
figsize=(6,4.7)
if timestamp != None:
folder = toolbox.data_from_time(timestamp)
else:
folder = toolbox.latest_data('ElectronRepump')
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'
print ssro_calib_folder
fit_results = []
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC(ssro_calib_folder)
# print a.result_corrected
# print a.p0[:,0]
# print a.sweep_pts
# print a.labels
# print a.u_p0[:,0]
# print a.readouts
ax=a.plot_results_vs_sweepparam(ret='ax',ax=None,
figsize=figsize,
ylim=(0.0,1.0)
)
x = a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
# ax.plot(x,y)
p0, fitfunc, fitfunc_str = common.fit_general_exponential(offset, amplitude,
x0, decay_constant,exponent)
#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)
## 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)
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 OneQubitTomo(timestamp=None, measurement_name = ['adwindata'], ssro_calib_timestamp =None,
frequency = [1,1,1], offset =[ 0.5,0.5,0.5], amplitude =[ 0.5,0.5,0.5], phase =[0.5,0.5,0.5],
fixed = [],
plot_fit = False, do_print = False, show_guess = True):
'''
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
List of parameters (order important for 'fixed')
[freq, offset, Amplitude, phase]
'''
# timestampZ = '20141023_174418'
# folderZ = toolbox.data_from_time(timestampZ)
# timestampX = '20141023_173547'
# folderX = toolbox.data_from_time(timestampX)
# timestampY = '20141023_173918'
# folderY = toolbox.data_from_time(timestampY)
if timestamp != None:
timestampZ = timestamp
folderZ = toolbox.data_from_time(timestamp)
else:
timestampZ, folderZ = toolbox.latest_data('CarbonR',return_timestamp =True)
timestampY, folderY = toolbox.latest_data('CarbonR',older_than = timestampZ, return_timestamp =True)
timestampX, folderX = toolbox.latest_data('CarbonR',older_than = timestampY, return_timestamp =True)
folders = [folderX,folderY, folderZ]
if ssro_calib_timestamp == None:
ssro_calib_folder = toolbox.latest_data('SSRO',older_than = timestampX)
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'
order_of_bases = ['X', 'Y','Z']
x = [None]*len(folders)
y = [None]*len(folders)
fit_result = [None]*len(folders)
for i,folder in enumerate(folders):
fit_results = []
print '*'*60
print order_of_bases[i] + ' Tomography'
print 'folder %s' %folder
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(ssro_calib_folder)
if i ==0:
ax = a.plot_results_vs_sweepparam(ret='ax',labels = order_of_bases[i])
# a.plot_results_vs_sweepparam(ax=ax)
else:
a.plot_results_vs_sweepparam(ax=ax,labels = order_of_bases[i])
x[i] = a.sweep_pts.reshape(-1)[:]
y[i]= a.p0.reshape(-1)[:]
print frequency[i]
p0, fitfunc, fitfunc_str = common.fit_cos(frequency[i], offset[i], amplitude [i],phase[i] )
try:
fit_result[i] = fit.fit1d(x[i],y[i], None, p0=p0, fitfunc=fitfunc, do_print=do_print, ret=True,fixed=fixed)
if plot_fit == True:
plot.plot_fit1d(fit_result[i], np.linspace(x[i][0],x[i][-1],201), ax=ax,
plot_data=False,print_info = False)
fit.write_to_file(fit_result[i],folder,fitname = str(order_of_bases[i])+'-tomography')
except:
pass
if show_guess:
ax.plot(np.linspace(x[i][0],x[i][-1],201), fitfunc(np.linspace(x[i][0],x[i][-1],201)), ':', lw=2)
print 'fitfunction: '+fitfunc_str
if plot_fit ==True:
ax.legend(('X data','X-fit','Y data','Y-fit','Z data','Z-fit'),fontsize='x-small')
elif plot_fit == False:
ax.legend(('X data','Y data','Z data'),fontsize='small')
## plot data and fit as function of total time
fit_results.append(fit_result[i])
plt.savefig(os.path.join(folder, 'analyzed_tomography_result.pdf'),
format='pdf')
plt.savefig(os.path.join(folder, 'analyzed_tomography_result.png'),
format='png')
return fit_results
def CosineSum_MBI_data(folder=None,
timestamp=[],
measurement_name=['adwindata'],
ssro_calib_folder=None,
ssro_calib_timestamp=None,
new_tsmp='20170612_230600',
old_tsmp='20170614_071700',
two_cos=True,
title='Cluster',
x_ticks=np.arange(0, 100, 5),
y_ticks=np.arange(0.2, 0.8, 0.1),
color='b',
c=1,
t=1,
frequency=[1, 1],
offset=0.5,
amplitude=[0.5, 0.5],
phase=[0, 0],
fixed=[],
plot_fit=False,
do_print=False,
show_guess=True,
xlim1=None,
xlim2=None):
'''
Function to analyze simple decoupling measurements. Loads the results and fits them to a simple exponential.
Inputs:
folder: allows to specify specific folder for the data(this overwrites the timestamp input)
ssro_folder: allows to specify specific folder for ssro calib(this overwrites the ssro_timestamp input)
timestamp: in format yyyymmdd_hhmmss or hhmmss or None.
measurement_name: list of measurement names
List of parameters (order important for 'fixed')
[freq, offset, Amplitude, phase]
'''
timestamp = []
plot_fit = True
show_guess = False
exponent = 2
#two_cos=True
fit_results = []
cum_pts = 0
cum_sweep_pts = np.empty(0)
cum_p0 = np.empty(0)
cu = np.empty(0)
cu_u = np.empty(0)
cum_u_p0 = np.empty(0)
cum_tau_list = np.empty(0)
# new_tsmp = '20170611_165140' ## newer than
# old_tsmp = '20170611_235700' ## older than
# new_tsmp = '20170612_005040' ## newer than
# old_tsmp = '20170612_015800' ## older than
# new_tsmp = '20170612_230600' ## newer than
# old_tsmp = '20170614_071700' ## older than
# new_tsmp = '20170616_190600' ## newer than
# old_tsmp = '20170617_053700' ## older than
# new_tsmp = '20170621_183900' ## newer than
# old_tsmp = '20170621_185800' ## older than
# new_tsmp = '20170719_161700' ## newer than
# old_tsmp = '20170719_165500' ## older than
# new_tsmp = '20170720_171400' ## newer than
# old_tsmp = '20170720_181700' ## older than
# new_tsmp = '20170720_182900' ## newer than
# old_tsmp = '20170720_195700' ## older than
search_string = 'Carbon'
while toolbox.latest_data(contains=search_string,
return_timestamp=True,
older_than=old_tsmp,
newer_than=new_tsmp,
raise_exc=False) != False:
old_tsmp, folder = toolbox.latest_data(contains=search_string,
return_timestamp=True,
older_than=old_tsmp,
newer_than=new_tsmp,
raise_exc=False)
timestamp.append(old_tsmp)
timestamp = timestamp[::-1]
if ssro_calib_folder == None:
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_sil18'
print ssro_calib_folder
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(ssro_calib_folder)
cum_pts += a.pts
# temperature = (a.g.attrs['temp']-100)/0.385
# temperature_list.append(temperature)
if kk == 0:
cum_sweep_pts = a.sweep_pts
cum_p0 = a.p0
cum_u_p0 = a.u_p0
#cum_tau_list = a.tau_list
#elif kk in [5,10,15,21,26,31]:
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))
#cum_tau_list = np.concatenate((cum_tau_list, a.tau_list))
a.pts = cum_pts
a.sweep_pts = 1.0e3 * cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
#ax = a.plot_results_vs_sweepparam(ret='ax',fmt='o',color='brown',figsize=(46,12))
e = a.u_p0
x = a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
# fig = plt.figure(1,figsize=(10,2))
# ax2 = fig.add_subplot(111)
# ax2.set_xlabel('Free evolution time (ms)')
# ax2.set_ylabel('State Fidelity')
#f = plt.figure(1,figsize=(60,2))
#f,(ax1,ax2,ax3,ax4) = plt.subplots(1,4,sharey=True, facecolor='w',figsize=(10,3.5))
fig = plt.figure(figsize=(9, 3.3))
gs = gridspec.GridSpec(1, 4, width_ratios=[3, 3, 2, 1])
ax1 = plt.subplot(gs[0])
ax2 = plt.subplot(gs[1])
ax3 = plt.subplot(gs[2])
ax4 = plt.subplot(gs[3])
ax1.errorbar(x.flatten(),
y.flatten(),
yerr=e,
fmt='o',
label='',
color=color,
lw=1,
markersize=3)
ax2.errorbar(x.flatten(),
y.flatten(),
yerr=e,
fmt='o',
label='',
color=color,
lw=1,
markersize=3)
ax3.errorbar(x.flatten(),
y.flatten(),
yerr=e,
fmt='o',
label='',
color=color,
lw=1,
markersize=3)
ax4.errorbar(x.flatten(),
y.flatten(),
yerr=e,
fmt='o',
label='',
color=color,
lw=1,
markersize=3)
fit_result = [None]
#p0, fitfunc, fitfunc_str = common.fit_sum_2cos(offset,amplitude[0],frequency[0],phase[0],amplitude[1],frequency[1],phase[1])
if two_cos == True:
p0, fitfunc, fitfunc_str = common.fit_gaussian_decaying_2cos(
offset, c, t, amplitude[0], frequency[0], phase[0], amplitude[1],
frequency[1], phase[1])
else:
p0, fitfunc, fitfunc_str = common.fit_general_exponential_dec_cos(
offset, amplitude[0], 0, t, exponent, frequency[0], phase[0])
if show_guess:
ax1.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=do_print,
ret=True,
fixed=fixed)
if plot_fit == True:
plot.plot_fit1d(fit_result,
np.linspace(x[0], x[-1], 8001),
ax=ax1,
color=color,
plot_data=False,
print_info=False,
lw=1.5)
plot.plot_fit1d(fit_result,
np.linspace(x[0], x[-1], 8001),
ax=ax2,
color=color,
plot_data=False,
print_info=False,
lw=1.5)
plot.plot_fit1d(fit_result,
np.linspace(x[0], x[-1], 8001),
ax=ax3,
color=color,
plot_data=False,
print_info=False,
lw=1.5)
plot.plot_fit1d(fit_result,
np.linspace(x[0], x[-1], 8001),
ax=ax4,
color=color,
plot_data=False,
print_info=False,
lw=1.5)
fit.write_to_file(fit_result, folder, fitname='Sum of cosine fit')
## plot data and fit as function of total time
#plt.xticks(x_ticks)
# plt.yticks(np.arange(min(y),(max(y)),0.1))
#plt.yticks(y_ticks)
ax1.set_xlim(0, 31)
ax2.set_xlim(xlim1, xlim2)
ax3.set_xlim(609, 631)
ax4.set_xlim(910, 920)
#ax2.set_ylim(0,1)
#ax2.set_xlabel('Free evolution time (ms)')
#ax2.set_ylabel('State Fidelity')
d = .045 # how big to make the diagonal lines in axes coordinates
# arguments to pass plot, just so we don't keep repeating them
ax1.spines['right'].set_visible(False)
ax2.spines['left'].set_visible(False)
ax2.spines['right'].set_visible(False)
ax3.spines['left'].set_visible(False)
ax3.spines['right'].set_visible(False)
ax1.yaxis.tick_left()
ax1.tick_params(labelright='off')
ax2.tick_params(labelleft='off')
ax2.tick_params(labelright='off')
ax3.tick_params(labelleft='off')
ax3.tick_params(labelright='off')
ax4.tick_params(labelleft='off')
ax4.tick_params(labelright='off')
#ax4.tick_params(labelbottom='off')
#ax1.tick_params(labelbottom='off')
#ax2.tick_params(labelbottom='off')
#ax3.tick_params(labelbottom='off')
ax4.spines['left'].set_visible(False)
plt.sca(ax1)
plt.xticks([10, 20, 30])
plt.yticks([0.4, 0.5, 0.6, 0.7])
plt.sca(ax2)
plt.xticks([200, 210, 220, 230])
plt.yticks([])
plt.sca(ax3)
plt.xticks([610, 620, 630])
plt.yticks([])
plt.sca(ax4)
plt.xticks([910, 920])
plt.yticks([])
#plt.step(ax1,ax2,xticks=[10,20,30],yticks=[0.4,0.5,0.6,0.7])
#ax4.yaxis.tick_right()
#ax4.xaxis.tick_bottom()
# kwargs = dict(transform=ax1.transAxes, color='k', clip_on=False)
# ax1.plot((1-d,1+d), (-d,+d), **kwargs)
# ax1.plot((1-d,1+d),(1-d,1+d), **kwargs)
# kwargs.update(transform=ax2.transAxes) # switch to the bottom axes
# ax2.plot((-d,+d), (1-d,1+d), **kwargs)
# ax2.plot((-d,+d), (-d,+d), **kwargs)
# ax2.plot((1-d,1+d), (-d,+d), **kwargs)
# ax2.plot((1-d,1+d),(1-d,1+d), **kwargs)
# kwargs = dict(transform=ax3.transAxes, color='k', clip_on=False)
# ax3.plot((-d,+d), (1-d,1+d), **kwargs)
# ax3.plot((-d,+d), (-d,+d), **kwargs)
# ax3.plot((1-d,1+d), (-d,+d), **kwargs)
# ax3.plot((1-d,1+d),(1-d,1+d), **kwargs)
# kwargs.update(transform=ax4.transAxes) # switch to the bottom axes
# ax4.plot((-d,+d), (1-d,1+d), **kwargs)
# ax4.plot((-d,+d), (-d,+d), **kwargs)
folder = 'C:\Users\TUD277931\Dropbox\TaminiauLab\Projects\Coherence in multi-qubit systems\Paper\Figures'
plt.savefig(os.path.join(folder, title + '.pdf'),
format='pdf',
bbox_inches='tight',
pad_inches=0.2,
transparent=True)
def get_correlations(**kw):
### pull data
ssro_calib_folder = kw.pop('ssro_calib_folder', None)
ssro_calib_timestamp = kw.pop('ssro_calib_timestamp', None)
search_string = kw.pop('search_string', 'el_13C_dm_')
base_folder = kw.pop('base_folder', None)
if ssro_calib_folder == None:
if ssro_calib_timestamp == None:
ssro_calib_folder = tb.latest_data('SSROCalibration')
else:
ssro_dstmp, ssro_tstmp = tb.verify_timestamp(ssro_calib_timestamp)
ssro_calib_folder = tb.latest_data(
contains=ssro_tstmp,
older_than=str(int(ssro_dstmp) + 1) + '_' + ssro_tstmp,
folder=base_folder)
### for basis assignment, see onenote 2016-08-24 or alternatively mathematica file E_13C_Bell_state.nb
tomo_pulses_p = ['none', 'x', 'my'] ### used when looking for folders
tomo_pulses_m = ['X', 'mx', 'y'] ### used when looking for folders
f_list_pos_p, f_list_neg_p, f_list_pos_m, f_list_neg_m = [], [], [], []
exp_values, exp_vals_u = np.array([]), np.array(
[]
) ### this will be a list with all combined expectation values such as XX or YZ
sweep_pts = [
] ### this will be a list of the bases associated expectation values
### carbon 1-qubit correlations
c_x, c_y, c_z = 0., 0., 0.
c_x_u, c_y_u, c_z_u = 0., 0., 0.
### this dictionary is used to translate the electron RO pulse into a measurement basis
tomo_pulse_translation_dict = {
'none': 'Z',
'X': 'Z',
'x': 'Y',
'mx': 'Y',
'y': 'X',
'my': 'X'
}
for p, m in zip(tomo_pulses_p, tomo_pulses_m):
f_list_pos_p.append(
tb.latest_data(search_string + p + '_positive',
folder=base_folder,
return_timestamp=False,
**kw))
f_list_neg_p.append(
tb.latest_data(search_string + p + '_negative',
folder=base_folder,
return_timestamp=False,
**kw))
f_list_pos_m.append(
tb.latest_data(search_string + m + '_positive',
folder=base_folder,
return_timestamp=False,
**kw))
f_list_neg_m.append(
tb.latest_data(search_string + m + '_negative',
folder=base_folder,
return_timestamp=False,
**kw))
#### now also calculate the measured contrast
y_a, y_err_a = get_RO_results(f_list_pos_p[-1], ssro_calib_folder)
y_b, y_err_b = get_RO_results(f_list_neg_p[-1], ssro_calib_folder)
y_c, y_err_c = get_RO_results(f_list_pos_m[-1], ssro_calib_folder)
y_d, y_err_d = get_RO_results(f_list_neg_m[-1], ssro_calib_folder)
y_pos_electron = (y_a - y_b) / 2.
y_pos_electron_u = 1. / 2 * (y_err_a**2 + y_err_b**2)**0.5
y_neg_electron = (y_c - y_d) / 2.
y_neg_electron_u = 1. / 2 * (y_err_c**2 + y_err_d**2)**0.5
#### now do the final combination of results regarding the electron RO basis to get the combined expectation value
y = (y_pos_electron - y_neg_electron) / 2.
y_u = 1. / 2 * (y_pos_electron_u**2 + y_neg_electron_u**2)**0.5
### Combine data
exp_values = np.append(exp_values, y)
exp_vals_u = np.append(exp_vals_u, y_u)
#### we also need to calculate the single qubit expectation values.
#### easy for the electron spin. One simply adds the electron outcomes and divides by 2.
#### for the nuclear spin one has to add up several RO bases and look at the correlations there
#### (because experiments are not grouped by RO basis):
exp_val_sum = (y_pos_electron + y_neg_electron) / 2.
exp_val_sum_u = (y_pos_electron_u**2 + y_neg_electron_u**2) / 4.
### update the running average of the nuclear spin expectation values:
c_x, c_y, c_z = c_x + exp_val_sum[0] / 3., c_y + exp_val_sum[
1] / 3., c_z + exp_val_sum[2] / 3.
c_x_u, c_y_u, c_z_u = c_x_u + exp_val_sum_u[
0] / 9., c_y_u + exp_val_sum_u[1] / 9., c_z_u + exp_val_sum_u[
2] / 9.
### add the electron values
y_electron = np.sum(exp_val_sum) / 3.
y_electron_u = np.sum(exp_val_sum_u / 9.)**0.5
exp_values = np.append(exp_values, y_electron)
exp_vals_u = np.append(exp_vals_u, y_electron_u)
### write up the combined analysis bases:
a = mbi.MBIAnalysis(f_list_pos_p[-1])
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
e_base = np.array([tomo_pulse_translation_dict[p]] * 4)
c_base = a.adgrp.attrs['Tomography Bases'].flatten()
comb_base = np.core.defchararray.add(
e_base, np.append(c_base, 'I')
) ### add identity to 13C bases as this is evaluated on the fly
sweep_pts = np.append(sweep_pts, comb_base)
### the nuclear spin single qubit correlations have been esimated in a running average (transposed correlations)
### and are now added to the results (square root still needs to be taken for the uncertainties)
sweep_pts = np.append(sweep_pts, ['IX', 'IY', 'IZ'])
exp_values = np.append(exp_values, np.array([c_x, c_y, c_z]))
print 'Nuclear spin correlations', c_x, c_y, c_z
print sweep_pts
print np.round(exp_values, 2)
exp_vals_u = np.append(
exp_vals_u, np.array([np.sqrt(c_x_u),
np.sqrt(c_y_u),
np.sqrt(c_z_u)]))
return f_list_pos_p[0], sweep_pts, exp_values, exp_vals_u
def Carbon_Ramsey_Crosstalk(timestamp=None,
measurement_name=['adwindata'],
ssro_calib_timestamp=None,
frequency=1,
offset=0.5,
x0=0,
amplitude=0.5,
decay_constant=200,
phase=0,
exponent=2,
plot_fit=False,
do_print=False,
fixed=[2, 3, 4],
show_guess=True,
return_phase=False,
return_freq=False,
return_results=True,
return_amp=False,
close_plot=False,
title=None):
'''
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
List of parameters (order important for 'fixed')
offset, amplitude, decay_constant,exponent,frequency ,phase
'''
if timestamp != None:
folder_a = toolbox.data_from_time(timestamp)
else:
folder_a, timestamp = toolbox.latest_data('Crosstalk',
return_timestamp=True)
folder_b = toolbox.latest_data('Crosstalk', older_than=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'
print ssro_calib_folder
fit_results = []
for k in range(0, len(measurement_name)):
a = mbi.MBIAnalysis(folder_a)
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_RO_data = 2 * (a.p0.reshape(-1)[:]) - 1
X_RO_data_u = 2 * (a.u_p0.reshape(-1)[:])
a = mbi.MBIAnalysis(folder_b)
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_RO_data = 2 * (a.p0.reshape(-1)[:]) - 1
Y_RO_data_u = 2 * (a.u_p0.reshape(-1)[:])
RO_data = (X_RO_data**2 + Y_RO_data**2)**0.5
RO_data_u = (1. / (X_RO_data**2 + Y_RO_data**2) *
(X_RO_data**2 * X_RO_data_u**2 +
Y_RO_data**2 * Y_RO_data_u**2))**0.5
fig = a.default_fig(figsize=(7.5, 5))
ax2 = a.default_ax(fig)
ax2.axhspan(0, 1, fill=False, ls='dotted')
ax2.set_ylim(-1, 1)
ax2.errorbar(x, RO_data, RO_data_u)
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:
ax2.plot(np.linspace(x[0], x[-1], 201),
fitfunc(np.linspace(x[0], x[-1], 201)),
':',
lw=2)
fit_result = fit.fit1d(x,
RO_data,
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=ax2,
plot_data=False)
fit_results.append(fit_result)
if title == None:
title = 'analyzed_result'
plt.savefig(os.path.join(folder_a, title + '.pdf'), format='pdf')
plt.savefig(os.path.join(folder_a, title + '.png'), format='png')
if close_plot == True:
plt.close()
if return_freq == True:
f0 = fit_result['params_dict']['f']
u_f0 = fit_result['error_dict']['f']
return f0, u_f0
if return_phase == True:
phi0 = fit_result['params_dict']['phi']
u_phi0 = fit_result['error_dict']['phi']
Amp = fit_result['params_dict']['A']
if return_amp == True:
return phi0, u_phi0, Amp
else:
return phi0, u_phi0
if return_results == True:
return fit_results
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 BarPlotTomoContrast(timestamps=[None, None],
tag='',
measurement_name=['adwindata'],
folder_name='Tomo',
ssro_calib_timestamp=None,
save=True,
plot_fit=True,
return_data=False):
'''
Function that makes a bar plot with errorbars of MBI type data that has been measured with a positive
and negative RO.
'''
### SSRO calibration
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_sil18'
if timestamps[0] == None:
folder_a = toolbox.latest_data(contains='positive' + tag)
folder_b = toolbox.latest_data(contains='negative' + tag)
elif len(timestamps) == 1:
folder_b = toolbox.data_from_time(timestamps[0])
folder_a = toolbox.latest_data(contains='positive',
older_than=timestamps[0])
else:
folder_a = toolbox.data_from_time(timestamps[0])
folder_b = toolbox.data_from_time(timestamps[1])
a = mbi.MBIAnalysis(folder_a)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC(ssro_calib_folder)
y_a = ((a.p0.reshape(-1)[:]) - 0.5) * 2
y_err_a = 2 * a.u_p0.reshape(-1)[:]
b = mbi.MBIAnalysis(folder_b)
b.get_sweep_pts()
b.get_readout_results(name='adwindata')
b.get_electron_ROC(ssro_calib_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 plot_fit == True:
fig, ax = plt.subplots()
rects = ax.bar(x, y, yerr=y_err, align='center', ecolor='k')
ax.set_xticks(x)
ax.set_xticklabels(x_labels.tolist())
ax.set_ylim(-1.1, 1.1)
ax.set_title(str(folder_a) + '/' + str(timestamps[0]))
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_a, 'tomo.png'))
fig.savefig(os.path.join(folder_a, 'tomo.pdf'))
except:
print 'Figure has not been saved.'
if return_data == True:
return x_labels, x, y, y_err
def Carbon_T2_analysis_ms1(measurement_name = ['adwindata'], ssro_calib_timestamp =None,
offset = 0.5,
amplitude = 0.5,
decay_constant = 0.2,
x0=0,
exponent = 1,
Addressed_carbon=5,
plot_fit = True, do_print = True, show_guess = False):
if Addressed_carbon == 1:
timestamp_pos=['20141104_195135','20141104_203107','20141104_223132']
timestamp_neg=['20141104_195949','20141104_212524','20141104_234927']
elif Addressed_carbon == 5:
timestamp_pos=['20150309_193904']
timestamp_neg=['20150309_195337']
# timestamp_pos=['20150102_193904']
# timestamp_neg=['20150102_214323']
#timestamp_pos=['20141105_003250','20141105_011316','20141105_031420']
#timestamp_neg=['20141105_004136','20141105_020802','20141105_043221']
elif Addressed_carbon == 2:
timestamp_pos=['20141106_010748','20141106_014724','20141106_040245']
timestamp_neg=['20141106_011609','20141106_024138','20141106_055052']
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_sil18'
print ssro_calib_folder
##accumulate data and average over positive and negative RO##
cum_pts = 0
for kk in range(len(timestamp_pos)):
folder_pos = toolbox.data_from_time(timestamp_pos[kk])
folder_neg = toolbox.data_from_time(timestamp_neg[kk])
a = mbi.MBIAnalysis(folder_pos)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC(ssro_calib_folder)
cum_pts += a.pts
b = mbi.MBIAnalysis(folder_neg)
b.get_sweep_pts()
b.get_readout_results(name='adwindata')
b.get_electron_ROC(ssro_calib_folder)
if kk == 0:
cum_sweep_pts = a.sweep_pts
cum_p0 = (a.p0+(1-b.p0))/2.
cum_u_p0 = np.sqrt(a.u_p0**2+b.u_p0**2)/2
else:
cum_sweep_pts = np.concatenate((cum_sweep_pts, a.sweep_pts))
cum_p0 = np.concatenate((cum_p0, (a.p0+(1-b.p0))/2))
cum_u_p0 = np.concatenate((cum_u_p0, np.sqrt(a.u_p0**2+b.u_p0**2)/2))
print
a.pts = cum_pts
a.sweep_pts = cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
## accumulate data with negative RO
#sort data by free evolution time.
sorting_order=a.sweep_pts.argsort()
a.sweep_pts.sort()
a.p0=a.p0[sorting_order]
a.u_p0=a.u_p0[sorting_order]
## generate plot of the raw data ##
#uncomment this part to plot without error bars, but including obtained fit parameters.
# fig = a.default_fig(figsize=(6,5))
# ax = a.default_ax(fig)
# ax.plot(a.sweep_pts, a.p0, 'bo',label='T1 of Carbon'+str(Addressed_carbon),lw=1.2)
ax=a.plot_results_vs_sweepparam(ret='ax',figsize=figsize, ax=None, ylim=ylim)
## fit to a general exponential##
fit_results = []
x = a.sweep_pts.reshape(-1)[:]*2
y = a.p0.reshape(-1)[:]
y_err = a.u_p0.reshape(-1)[:]
ax.plot(x,y)
p0, fitfunc, fitfunc_str = common.fit_general_exponential(offset, amplitude, x0, decay_constant,exponent)
#p0, fitfunc, fitfunc_str = common.fit_line(0.5,-0.5/7.)
#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=[0,2])
## 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)
filename= 'C13_T2_analysis_up_C'+str(Addressed_carbon)
print 'plots are saved in ' + folder_pos
#configure the plot
plt.title('Sample_111_No1_C13_T2_up_C'+str(Addressed_carbon)+'el_state_1')
plt.xlabel('Free evolution time (s)')
plt.ylabel('Fidelity')
plt.axis([a.sweep_pts[0],a.sweep_pts[a.pts-1],0.4,1])
# plt.savefig(os.path.join(r'D:\measuring\data\Analyzed figures\Carbon Hahn', filename+'.pdf'),
# format='pdf')
# plt.savefig(os.path.join(r'D:\measuring\data\Analyzed figures\Carbon Hahn', filename+'.png'),
# format='png')
return x,y, y_err, fit_result
def Carbon_Ramsey_mult_msmts(timestamp=None, measurement_name = ['adwindata'], ssro_calib_timestamp =None,
frequency = 1,
offset = 0.5,
x0 = 0,
amplitude = 0.5,
decay_constant = 200,
phase =0,
exponent = 2,
plot_fit = False, do_print = False, fixed = [2], show_guess = True,
return_phase = False,
return_freq = False,
return_amp = False,
return_results = True,
close_plot = False,
partstr = 'part',
contains=[],
title = 'Carbon'):
'''
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
List of parameters (order important for 'fixed')
offset, amplitude, decay_constant,exponent,frequency ,phase
'''
if timestamp != None:
folder = toolbox.data_from_time(timestamp)
else:
folder = toolbox.latest_data(title)
if partstr in folder:
numberstart = folder.find(partstr)+len(partstr)
numberofparts = int(folder[numberstart:len(folder)])
basis_str = folder[folder.rfind('\\')+7:numberstart]
else:
numberofparts = 1
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_sil18'
print ssro_calib_folder
fit_results = []
#for kk in range(numberofparts):
for kk,cnts in enumerate(contains):
'''
if partstr in folder:
folder = toolbox.latest_data(basis_str+str(kk+1))
else:
folder = toolbox.latest_data(basis_str)
'''
folder = toolbox.latest_data(cnts)
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')
if kk == 0:
cum_sweep_pts = a.sweep_pts
cum_p0 = a.p0
cum_u_p0 = a.u_p0
cum_pts = a.pts
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))
cum_pts += a.pts
a.pts = cum_pts
a.sweep_pts = cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
sorting_order=a.sweep_pts.argsort()
a.sweep_pts.sort()
a.p0=a.p0[sorting_order]
a.u_p0=a.u_p0[sorting_order]
ax=a.plot_results_vs_sweepparam(ret='ax')
x = a.sweep_pts.reshape(-1)[:]
y = a.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)
## 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')
if close_plot == True:
plt.close()
if return_freq == True:
f0 = fit_result['params_dict']['f']
u_f0 = fit_result['error_dict']['f']
return f0, u_f0
if return_phase == True and return_amp == False:
phi0 = fit_result['params_dict']['phi']
u_phi0 = fit_result['error_dict']['phi']
return phi0, u_phi0
if return_phase == True and return_amp == True:
phi0 = fit_result['params_dict']['phi']
u_phi0 = fit_result['error_dict']['phi']
A = fit_result['params_dict']['A']
u_A = fit_result['error_dict']['A']
return phi0, u_phi0, A, u_A
if return_results == True:
return fit_results
def get_data(folder,folder_timestamp,RO_correct=True,ssro_calib_timestamp=None,tomo_bases='XXX',get_title=False, return_orientations=False, **kw):
evaluate_both = kw.pop('evaluate_both',False)
a = CP.ConditionalParityAnalysis(folder)
#a.get_sweep_pts()
a.get_readout_results(name='adwindata', post_select_GHZ = True)
if a.orientations[3] == 'negative':
multiply_by = -1
else:
multiply_by = 1
print a.orientations
if RO_correct == True:
if ssro_calib_timestamp == None:
ssro_calib_folder = toolbox.latest_data('SSRO',older_than=folder_timestamp)
analysis_file=os.path.join(ssro_calib_folder,'analysis.hdf5')
if not os.path.exists(analysis_file):
ssro.ssrocalib(ssro_calib_folder)
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'#GHZ_'+tomo_bases
#print ssro_calib_folder
a.get_electron_ROC(ssro_calib_folder = ssro_calib_folder, post_select_GHZ = True)
#take the [0,0] part of the arrays; there are no sweep_pts
p0_000,u_p0_000 = multiply_by*(a.p0_000[0,0]-0.5)*2,(2*a.u_p0_000[0,0])
p0_001,u_p0_001 = multiply_by*(a.p0_001[0,0]-0.5)*2,(2*a.u_p0_001[0,0])
p0_010,u_p0_010 = multiply_by*(a.p0_010[0,0]-0.5)*2,(2*a.u_p0_010[0,0])
p0_011,u_p0_011 = multiply_by*(a.p0_011[0,0]-0.5)*2,(2*a.u_p0_011[0,0])
p0_100,u_p0_100 = multiply_by*(a.p0_100[0,0]-0.5)*2,(2*a.u_p0_100[0,0])
p0_101,u_p0_101 = multiply_by*(a.p0_101[0,0]-0.5)*2,(2*a.u_p0_101[0,0])
p0_110,u_p0_110 = multiply_by*(a.p0_110[0,0]-0.5)*2,(2*a.u_p0_110[0,0])
p0_111,u_p0_111 = multiply_by*(a.p0_111[0,0]-0.5)*2,(2*a.u_p0_111[0,0])
print "probablity with ROC", a.p0_000[0,0]
print "exp with ROC",p0_000, u_p0_000
if evaluate_both:
#else:
p0_000,u_p0_000 = multiply_by*(a.normalized_ssro_000[0,0]-0.5)*2,(2*a.u_normalized_ssro_000[0,0])
p0_001,u_p0_001 = multiply_by*(a.normalized_ssro_001[0,0]-0.5)*2,(2*a.u_normalized_ssro_001[0,0])
p0_010,u_p0_010 = multiply_by*(a.normalized_ssro_010[0,0]-0.5)*2,(2*a.u_normalized_ssro_010[0,0])
p0_011,u_p0_011 = multiply_by*(a.normalized_ssro_011[0,0]-0.5)*2,(2*a.u_normalized_ssro_011[0,0])
p0_100,u_p0_100 = multiply_by*(a.normalized_ssro_100[0,0]-0.5)*2,(2*a.u_normalized_ssro_100[0,0])
p0_101,u_p0_101 = multiply_by*(a.normalized_ssro_101[0,0]-0.5)*2,(2*a.u_normalized_ssro_101[0,0])
p0_110,u_p0_110 = multiply_by*(a.normalized_ssro_110[0,0]-0.5)*2,(2*a.u_normalized_ssro_110[0,0])
p0_111,u_p0_111 = multiply_by*(a.normalized_ssro_111[0,0]-0.5)*2,(2*a.u_normalized_ssro_111[0,0])
print "prob without ROC", a.normalized_ssro_000[0,0]
print "exp without ROC",p0_000, u_p0_000
print "WARNING WARNING REMOVE THIS STATEMENT. REMOVE EVALUATE_BOTH OPTION"
if get_title:
a_list_name = "".join(aa for aa in a.a_list)
b_list_name = "".join(aa for aa in a.b_list)
c_list_name = "".join(aa for aa in a.c_list)
d_list_name = "".join(aa for aa in a.d_list)
title = a_list_name+' '+b_list_name+' '+c_list_name+' '+d_list_name
else:
title=''
p = (a.p000[0,0],a.p001[0,0],a.p010[0,0],a.p011[0,0],a.p100[0,0],a.p101[0,0],a.p110[0,0],a.p111[0,0])
y = (p0_000,p0_001,p0_010,p0_011,p0_100,p0_101,p0_110,p0_111)
y_err = (u_p0_000,u_p0_001,u_p0_010,u_p0_011,u_p0_100,u_p0_101,u_p0_110,u_p0_111)
if return_orientations:
return(p,y,y_err,title,a.orientations)
return(p,y,y_err,title)
def CosineSum_MBI_data(folder=None,
timestamp=[],
measurement_name=['adwindata'],
ssro_calib_folder=None,
ssro_calib_timestamp=None,
new_tsmp='20170612_230600',
old_tsmp='20170614_071700',
two_cos=True,
title='Cluster',
x_ticks=np.arange(0, 100, 5),
y_ticks=np.arange(0.2, 0.8, 0.1),
color='b',
c=1,
t=1,
frequency=[1, 1],
offset=0.5,
amplitude=[0.5, 0.5],
phase=[0, 0],
fixed=[],
plot_fit=False,
do_print=False,
show_guess=True,
xlim=None):
'''
Function to analyze simple decoupling measurements. Loads the results and fits them to a simple exponential.
Inputs:
folder: allows to specify specific folder for the data(this overwrites the timestamp input)
ssro_folder: allows to specify specific folder for ssro calib(this overwrites the ssro_timestamp input)
timestamp: in format yyyymmdd_hhmmss or hhmmss or None.
measurement_name: list of measurement names
List of parameters (order important for 'fixed')
[freq, offset, Amplitude, phase]
'''
timestamp = []
plot_fit = True
show_guess = False
exponent = 2
#two_cos=True
fit_results = []
cum_pts = 0
cum_sweep_pts = np.empty(0)
cum_p0 = np.empty(0)
cu = np.empty(0)
cu_u = np.empty(0)
cum_u_p0 = np.empty(0)
cum_tau_list = np.empty(0)
# new_tsmp = '20170611_165140' ## newer than
# old_tsmp = '20170611_235700' ## older than
# new_tsmp = '20170612_005040' ## newer than
# old_tsmp = '20170612_015800' ## older than
# new_tsmp = '20170612_230600' ## newer than
# old_tsmp = '20170614_071700' ## older than
# new_tsmp = '20170616_190600' ## newer than
# old_tsmp = '20170617_053700' ## older than
# new_tsmp = '20170621_183900' ## newer than
# old_tsmp = '20170621_185800' ## older than
# new_tsmp = '20170719_161700' ## newer than
# old_tsmp = '20170719_165500' ## older than
# new_tsmp = '20170720_171400' ## newer than
# old_tsmp = '20170720_181700' ## older than
# new_tsmp = '20170720_182900' ## newer than
# old_tsmp = '20170720_195700' ## older than
search_string = 'Carbon'
while toolbox.latest_data(contains=search_string,
return_timestamp=True,
older_than=old_tsmp,
newer_than=new_tsmp,
raise_exc=False) != False:
old_tsmp, folder = toolbox.latest_data(contains=search_string,
return_timestamp=True,
older_than=old_tsmp,
newer_than=new_tsmp,
raise_exc=False)
timestamp.append(old_tsmp)
timestamp = timestamp[::-1]
if ssro_calib_folder == None:
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_sil18'
print ssro_calib_folder
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(ssro_calib_folder)
cum_pts += a.pts
# temperature = (a.g.attrs['temp']-100)/0.385
# temperature_list.append(temperature)
if kk == 0:
cum_sweep_pts = a.sweep_pts
cum_p0 = a.p0
cum_u_p0 = a.u_p0
#cum_tau_list = a.tau_list
#elif kk in [5,10,15,21,26,31]:
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))
#cum_tau_list = np.concatenate((cum_tau_list, a.tau_list))
a.pts = cum_pts
a.sweep_pts = 1.0e3 * cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
#ax = a.plot_results_vs_sweepparam(ret='ax',fmt='o',color='brown',figsize=(46,12))
e = a.u_p0
x = a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
fig = plt.figure(1, figsize=(4, 1.5))
ax2 = fig.add_subplot(111)
ax2.errorbar(x.flatten(),
y.flatten(),
yerr=e,
fmt='o',
label='',
color=color,
lw=1,
markersize=3)
ax2.set_xlabel('Free evolution time (ms)')
ax2.set_ylabel('State Fidelity')
fit_result = [None]
#p0, fitfunc, fitfunc_str = common.fit_sum_2cos(offset,amplitude[0],frequency[0],phase[0],amplitude[1],frequency[1],phase[1])
if two_cos == True:
p0, fitfunc, fitfunc_str = common.fit_gaussian_decaying_2cos(
offset, c, t, amplitude[0], frequency[0], phase[0], amplitude[1],
frequency[1], phase[1])
else:
p0, fitfunc, fitfunc_str = common.fit_general_exponential_dec_cos(
offset, amplitude[0], 0, t, exponent, frequency[0], phase[0])
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=do_print,
ret=True,
fixed=fixed)
if plot_fit == True:
plot.plot_fit1d(fit_result,
np.linspace(x[0], x[-1], 8001),
ax=ax2,
color=color,
plot_data=False,
print_info=False,
lw=1.5)
fit.write_to_file(fit_result, folder, fitname='Sum of cosine fit')
## plot data and fit as function of total time
plt.xticks(x_ticks)
# plt.yticks(np.arange(min(y),(max(y)),0.1))
plt.yticks(y_ticks)
ax2.set_xlim(0, xlim)
#ax2.set_ylim(0,1)
#ax2.set_xlabel('Free evolution time (ms)')
#ax2.set_ylabel('State Fidelity')
folder = 'C:\Users\TUD277931\Dropbox\TaminiauLab\Projects\Coherence in multi-qubit systems\Paper\Figures\Fig 3'
plt.savefig(os.path.join(folder, title + '.pdf'),
format='pdf',
bbox_inches='tight',
pad_inches=0.2,
transparent=True)
def BarPlotTomo_QEC(timestamp = None, measurement_name = ['adwindata'],folder_name ='Tomo',
plot_post_select = False,
ssro_calib_timestamp = None, save = True,
do_plots = False, title =None ,fontsize = 10, post_select_QEC = False) :
'''
Function that makes a bar plot with errorbars of MBI type data
'''
plt.rc('font', size=fontsize)
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 = CP.ConditionalParityAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata',post_select_QEC = False)
a.get_electron_ROC(ssro_calib_folder)
x_labels = a.sweep_pts.reshape(-1)
''' all data '''
c0,u_c0 = a.convert_fidelity_to_contrast(a.p0,a.u_p0)
x = range(len(c0))
if do_plots ==True:
fig,ax = plt.subplots()
ax.bar(x,c0,yerr=u_c0,align ='center',ecolor = 'k' )
ax.set_xticks(x)
if title == None:
ax.set_title(str(folder)+'/'+str(timestamp))
else:
ax.set_title(title)
print x_labels
ax.set_xticklabels(x_labels.tolist())
ax.set_ylim(-1,1)
ax.hlines([-1,0,1],x[0]-1,x[-1]+1,linestyles='dotted')
try:
fig.savefig(os.path.join(folder,'tomo.png'))
fig.savefig(os.path.join(folder, title+'.pdf'),
format='pdf',bbox_inches='tight')
except:
print 'Figure A has not been saved.'
''' postselected data '''
a = CP.ConditionalParityAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata',post_select_QEC = True)
a.get_electron_ROC(ssro_calib_folder, post_select_QEC = True)
c0_00,u_c0_00 = a.convert_fidelity_to_contrast(a.p0_00,a.u_p0_00)
c0_01,u_c0_01 = a.convert_fidelity_to_contrast(a.p0_01,a.u_p0_01)
c0_10,u_c0_10 = a.convert_fidelity_to_contrast(a.p0_10,a.u_p0_10)
c0_11,u_c0_11 = a.convert_fidelity_to_contrast(a.p0_11,a.u_p0_11)
x = range(len(c0_00))
if do_plots == True and plot_post_select == True:
fig_00,ax_00 = plt.subplots()
rects = ax_00.bar(x,c0_00,yerr=u_c0_00,align ='center',ecolor = 'k' )
# ax_00.bar(x,a.p0_00,yerr = u_c0_00,align = 'center',ecolor = 'k')
ax_00.set_xticks(x)
if title == None:
ax_00.set_title(str(folder)+'/'+str(timestamp)+'0')
else:
ax_00.set_title(str(title)+'0')
ax_00.set_xticklabels(x_labels.tolist())
# ax_00.set_ylim(-1,1)
ax_00.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(c0_00[ii],2)) +'('+ str(int(round(u_c0_00[ii]*100))) +')',
ha='center', va='bottom')
autolabel(rects)
fig_01,ax_01 = plt.subplots()
rects = ax_01.bar(x,c0_01,yerr=u_c0_01,align ='center',ecolor = 'k' )
ax_01.set_xticks(x)
if title == None:
ax_01.set_title(str(folder)+'/'+str(timestamp)+'1')
else:
ax_01.set_title(str(title)+'1')
ax_01.set_xticklabels(x_labels.tolist())
# ax_01.set_ylim(-1,1)
ax_01.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(c0_01[ii],2)) +'('+ str(int(round(u_c0_01[ii]*100))) +')',
ha='center', va='bottom')
autolabel(rects)
fig_10,ax_10 = plt.subplots()
rects = ax_10.bar(x,c0_10,yerr=u_c0_10,align ='center',ecolor = 'k' )
# ax_10.bar(x,a.p0_10,yerr = u_c0_10,align = 'center',ecolor = 'k')
ax_10.set_xticks(x)
if title == None:
ax_10.set_title(str(folder)+'/'+str(timestamp)+'0')
else:
ax_10.set_title(str(title)+'0')
ax_10.set_xticklabels(x_labels.tolist())
# ax_10.set_ylim(-1,1)
ax_10.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(c0_10[ii],2)) +'('+ str(int(round(u_c0_10[ii]*100))) +')',
ha='center', va='bottom')
autolabel(rects)
fig_11,ax_11 = plt.subplots()
rects = ax_11.bar(x,c0_11,yerr=u_c0_11,align ='center',ecolor = 'k' )
ax_11.set_xticks(x)
if title == None:
ax_11.set_title(str(folder)+'/'+str(timestamp)+'1')
else:
ax_11.set_title(str(title)+'1')
ax_11.set_xticklabels(x_labels.tolist())
# ax_11.set_ylim(-1,1)
ax_11.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(c0_11[ii],2)) +'('+ str(int(round(u_c0_11[ii]*100))) +')',
ha='center', va='bottom')
autolabel(rects)
try:
fig_00.savefig(os.path.join(folder, str(title)+'0.pdf'),
format='pdf',bbox_inches='tight')
fig_01.savefig(os.path.join(folder, str(title)+'1.pdf'),
format='pdf',bbox_inches='tight')
fig_10.savefig(os.path.join(folder, str(title)+'0.pdf'),
format='pdf',bbox_inches='tight')
fig_11.savefig(os.path.join(folder, str(title)+'1.pdf'),
format='pdf',bbox_inches='tight')
except:
print 'Figure B has not been saved.'
return x, c0, u_c0, c0_00, u_c0_00, c0_01, u_c0_01, c0_10, u_c0_10, c0_11, u_c0_11, x_labels, folder
def Carbon_Ramsey(timestamp=None, carbon=None, transition=None, measurement_name = ['adwindata'], ssro_calib_timestamp =None,
frequency = 1,
offset = 0.5,
x0 = 0,
amplitude = 0.5,
decay_constant = 200,
phase =0,
exponent = 2,
plot_fit = False, do_print = False, fixed = [2], show_guess = True,
return_phase = False,
return_freq = False,
return_amp = False,
return_results = True,
close_plot = False,
color='b',
title = 'Carbon',
x_ticks=np.arange(0,100,5),
y_ticks=np.arange(0.2,0.8,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
List of parameters (order important for 'fixed')
offset, amplitude, decay_constant,exponent,frequency ,phase
'''
if timestamp != None:
folder = toolbox.data_from_time(timestamp)
elif carbon != None:
folder = toolbox.latest_data(contains='C'+str(carbon)+'_ms'+str(transition))
else:
folder = toolbox.latest_data(title)
print folder
if ssro_calib_timestamp == None:
ssro_calib_folder = toolbox.latest_data('SSROCalibration')
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'
print ssro_calib_folder
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(ssro_calib_folder)
x = 1.0e3*a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
e= a.u_p0
# fig = plt.figure(1,figsize=(4,1.5))
fig = plt.figure(1,figsize=(8,3))
ax2 = fig.add_subplot(111)
ax2.errorbar(x.flatten(),y.flatten(),yerr=e,fmt='o',label='',color=color,markersize=4,lw=1)
ax2.set_xlabel('Free evolution time (ms)')
ax2.set_ylabel('State Fidelity')
print min(y)
print max(y)
#plt.xticks(x_ticks)
# plt.yticks(np.arange(min(y),(max(y)),0.1))
#plt.yticks(y_ticks)
#ax2.set_ylim(min(y)-0.03,max(y)+0.07)
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:
ax2.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=ax2, add_txt = False, color=color, plot_data=False,lw=1.5)
fit_results.append(fit_result)
if title == None:
title = 'analyzed_result'
folder='C:\Users\TUD277931\Dropbox\TaminiauLab\Projects\Coherence in multi-qubit systems\Paper\Figures\Fig 3'
plt.savefig(os.path.join(folder, title + '.pdf'),
format='pdf',bbox_inches='tight',pad_inches=0.2,transparent=True)
if close_plot == True:
plt.close()
# plt.savefig('C:\Users\TUD277931\Dropbox\TaminiauLab\Projects\Coherence in multi-qubit systems\Paper\Figures\Fig 1\T1_sum_log.pdf',
# format='pdf',bbox_inches='tight',pad_inches=0.2,transparent=True)
# for item in fit_result['params_dict']:
# print item
# return fit_result
#print folder
if return_freq == True:
f0 = fit_result['params_dict']['f']
u_f0 = fit_result['error_dict']['f']
return f0, u_f0
if return_phase == True and return_amp == False:
phi0 = fit_result['params_dict']['phi']
u_phi0 = fit_result['error_dict']['phi']
return phi0, u_phi0
if return_phase == True and return_amp == True:
phi0 = fit_result['params_dict']['phi']
u_phi0 = fit_result['error_dict']['phi']
A = fit_result['params_dict']['A']
u_A = fit_result['error_dict']['A']
return phi0, u_phi0, A, u_A
if return_amp == True:
A = fit_result['params_dict']['A']
u_A = fit_result['error_dict']['A']
return A, u_A
if return_results == True:
return fit_results
def Carbon_T2_analysis_ms0(measurement_name=['adwindata'],
ssro_calib_timestamp=None,
offset=0.5,
amplitude=0.5,
decay_constant=0.2,
x0=0,
exponent=1,
Addressed_carbon=5,
plot_fit=True,
do_print=True,
show_guess=False):
'''
Function to gather and analyze T1 measurements of a specific carbon.
Addressed_carbon: selects the used timestamps and therefore the analyzed carbon
measurement_name: list of measurement names
Possible inputs for initial guesses: offset, amplitude, decay_constant,exponent
'''
######################################
# carbon_init= up el_state=0 #
######################################
if Addressed_carbon == 5:
timestamp_pos = ['20150315_215418']
timestamp_neg = ['20150315_225753']
timestamp_pos = ['20150317_103608']
timestamp_neg = ['20150317_105622']
elif Addressed_carbon == 1:
timestamp_pos = ['20150316_000112']
timestamp_neg = ['20150316_010415']
timestamp_pos = ['20150317_015434']
timestamp_neg = ['20150317_021428']
elif Addressed_carbon == 2:
timestamp_pos = ['20150316_020808']
timestamp_neg = ['20150316_031102']
timestamp_pos = ['20150317_061458']
timestamp_neg = ['20150317_063658']
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_sil18'
print ssro_calib_folder
##accumulate data and average over positive and negative RO##
cum_pts = 0
for kk in range(len(timestamp_pos)):
folder_pos = toolbox.data_from_time(timestamp_pos[kk])
folder_neg = toolbox.data_from_time(timestamp_neg[kk])
a = mbi.MBIAnalysis(folder_pos)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
timestamp_SSRO, ssro_calib_folder = toolbox.latest_data(
'AdwinSSRO', older_than=timestamp_pos[kk], return_timestamp=True)
a.get_electron_ROC(ssro_calib_folder)
cum_pts += a.pts
b = mbi.MBIAnalysis(folder_neg)
b.get_sweep_pts()
b.get_readout_results(name='adwindata')
timestamp_SSRO, ssro_calib_folder = toolbox.latest_data(
'AdwinSSRO', older_than=timestamp_neg[kk], return_timestamp=True)
b.get_electron_ROC(ssro_calib_folder)
if kk == 0:
cum_sweep_pts = a.sweep_pts
cum_p0 = (a.p0 + (1 - b.p0)) / 2.
cum_u_p0 = np.sqrt(a.u_p0**2 + b.u_p0**2) / 2
else:
cum_sweep_pts = np.concatenate((cum_sweep_pts, a.sweep_pts))
cum_p0 = np.concatenate((cum_p0, (a.p0 + (1 - b.p0)) / 2))
cum_u_p0 = np.concatenate(
(cum_u_p0, np.sqrt(a.u_p0**2 + b.u_p0**2) / 2))
a.pts = cum_pts
a.sweep_pts = cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
## accumulate data with negative RO
#sort data by free evolution time.
sorting_order = a.sweep_pts.argsort()
a.sweep_pts.sort()
a.p0 = a.p0[sorting_order]
a.u_p0 = a.u_p0[sorting_order]
## generate plot of the raw data ##
#uncomment this part to plot without error bars, but including obtained fit parameters.
# fig = a.default_fig(figsize=(6,5))
# ax = a.default_ax(fig)
# ax.plot(a.sweep_pts, a.p0, 'bo',label='T1 of Carbon'+str(Addressed_carbon),lw=1.2)
ax = a.plot_results_vs_sweepparam(ret='ax',
ax=None,
figsize=figsize,
ylim=(0.4, 1.0))
## fit to a general exponential##
fit_results = []
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(
offset, amplitude, x0, decay_constant, exponent)
#p0, fitfunc, fitfunc_str = common.fit_line(0.5,-0.5/7.)
#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=[0, 2])
## 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)
filename = 'C13_T2_analysis_up_C' + str(Addressed_carbon)
print 'plots are saved in ' + folder_pos
#configure the plot
plt.title('Sample_111_No1_C13_T2_up_C' + str(Addressed_carbon) +
'el_state_0')
plt.xlabel('Free evolution time (s)')
plt.ylabel('Fidelity')
plt.axis([a.sweep_pts[0], a.sweep_pts[a.pts - 1], 0.4, 1.])
# plt.savefig(os.path.join(folder_pos, filename+'.pdf'),
# format='pdf')
# plt.savefig(os.path.join(folder_pos, filename+'.png'),
# format='png')
return x, y, y_err, fit_result
def BarPlotTomoContrast(timestamps = [None,None], tag = '', measurement_name = ['adwindata'],folder_name ='Tomo',
ssro_calib_timestamp =None, save = True,
plot_fit = True, return_data = False) :
'''
Function that makes a bar plot with errorbars of MBI type data that has been measured with a positive
and negative RO.
'''
### SSRO calibration
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_sil18'
if timestamps[0] == None:
folder_a = toolbox.latest_data(contains='positive' + tag)
folder_b = toolbox.latest_data(contains='negative' + tag)
elif len(timestamps)==1:
folder_b = toolbox.data_from_time(timestamps[0])
print folder_b
folder_a = toolbox.latest_data(contains = 'pos', older_than = timestamps[0])
print folder_a
else:
folder_a = toolbox.data_from_time(timestamps[0])
folder_b = toolbox.data_from_time(timestamps[1])
a = mbi.MBIAnalysis(folder_a)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC(ssro_calib_folder)
y_a= ((a.p0.reshape(-1)[:])-0.5)*2
y_err_a = 2*a.u_p0.reshape(-1)[:]
b = mbi.MBIAnalysis(folder_b)
b.get_sweep_pts()
b.get_readout_results(name='adwindata')
b.get_electron_ROC(ssro_calib_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))
### Combine data
y = (y_a - y_b)/2.
y_err = 1./2*(y_err_a**2 + y_err_b**2)**0.5
print tag
print y
print y_err
# print folder_a
# print folder_b
# print y_a
# print y_b
# print y
### Fidelities
# F_ZZ = (1 + y[2] + y[5] + y[14])/4
# F_ZmZ = (1 + y[2] - y[5] - y[14])/4
# F_ent = (1 + y[0] -y[4] -y[8])/4
# F_ent = (1 + y[0] +y[1] +y[2])/4
# print 'Fidelity with ZZ = ' + str(F_ZZ)
# print 'Fidelity with ZmZ = ' + str(F_ZmZ)
# print 'Fidelity with ent = ' + str(F_ent)
# print 'XY = ' +str( (y[0]**2 + y[1]**2)**0.5)
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.set_xticklabels(x_labels.tolist())
ax.set_ylim(-1.1,1.1)
print 'test'
print folder_a
ax.set_title(str(folder_a)+'/'+str(timestamps[0]))
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_a,'tomo.png'))
except:
print 'Figure has not been saved.'
if return_data == True:
return x_labels, x, y, y_err
def CosineSum_MBI_data(folder=None,timestamp=None, measurement_name = ['adwindata'],ssro_calib_folder=None, ssro_calib_timestamp =None,
frequency = [1,1], offset =0.5, amplitude =[ 0.5,0.5], phase =[0,0],
fixed = [],
plot_fit = False, do_print = False, show_guess = True,xlim=None):
'''
Function to analyze simple decoupling measurements. Loads the results and fits them to a simple exponential.
Inputs:
folder: allows to specify specific folder for the data(this overwrites the timestamp input)
ssro_folder: allows to specify specific folder for ssro calib(this overwrites the ssro_timestamp input)
timestamp: in format yyyymmdd_hhmmss or hhmmss or None.
measurement_name: list of measurement names
List of parameters (order important for 'fixed')
[freq, offset, Amplitude, phase]
'''
if folder== None:
if timestamp == None:
timestamp, folder = toolbox.latest_data('CarbonR',return_timestamp =True)
else:
folder = toolbox.data_from_time(timestamp)
if ssro_calib_folder==None:
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'
print ssro_calib_folder
fit_result = [None]
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)[:]
p0, fitfunc, fitfunc_str = common.fit_sum_2cos(offset,amplitude[0],frequency[0],phase[0],amplitude[1],frequency[1],phase[1])
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=do_print, ret=True,fixed=fixed)
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.write_to_file(fit_result,folder,fitname = 'Sum of cosine fit')
## plot data and fit as function of total time
plt.savefig(os.path.join(folder, 'CosineSumFit.pdf'),
format='pdf')
plt.savefig(os.path.join(folder, 'CosineSumFit.png'),
format='png')
return fitfunc,ax,a,fit_result
def fit_ramsey(title=None, timestamp = None, ssro_calib_timestamp = None, ax = None,do_fit = False, Rmbi_guess=0.9, theta_guess= 1.5705, phi_guess=1.5705, show_guess = False):
"""
fit Rmbi**2Cos(theta)**2 + Rmbi**2Sin(theta)**2(cos(x+phi)+sin(x+phi)
"""
if timestamp != None:
folder = toolbox.data_from_time(timestamp)
else:
folder = toolbox.latest_data(title)
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_sil18'
print ssro_calib_folder
fig, ax = plt.subplots(1,1, figsize=(4.5,4))
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC()
x = a.sweep_pts.reshape(-1)[:]
y= ((a.p0.reshape(-1))-0.5)*2
x = np.linspace(0,720,len(y))
y_err = a.u_p0.reshape(-1)[:]
Rmbi = fit.Parameter(Rmbi_guess, 'Rmbi')
theta = fit.Parameter(theta_guess, 'theta')
phi = fit.Parameter(phi_guess, 'phi')
p0 = [Rmbi,theta, phi]
fitfunc_str = 'Rmbi^2 * Cos(theta)^2 + Rmbi^2 * Sin(theta)^2 * (Cos(x+phi)+Sin(x+phi)'
ax.errorbar(x,y,yerr=y_err)
def fitfunc(x) :
# return (Rmbi()*np.cos(theta()+np.pi*x/180.)+0*phi())
return (Rmbi()**2)*(np.cos(theta()*np.pi/180.)**2 + np.sin(theta()*np.pi/180.)**2 * (np.cos(x*np.pi/180.+np.pi*phi()/180.)+np.sin(x*np.pi/180.+np.pi*phi()/180.)))
if show_guess:
ax.plot(np.linspace(0,x[-1],201), fitfunc(np.linspace(0,x[-1],201)), ':', lw=2)
if do_fit == True:
fit_result = fit.fit1d(x,y, None, p0=p0, fitfunc=fitfunc,
fitfunc_str=fitfunc_str, do_print=True, ret=True,fixed = [])
plot.plot_fit1d(fit_result, np.linspace(x[0],x[-1],201), ax=ax,
plot_data=False, print_info=False)
ax.set_title(folder)
ax.set_ylabel('Contrast')
ax.set_xlabel('Phase')
ax.set_ylim([-1.1,1.1])
# print 'fitted minimal fidelity {0:.3f} +- {1:.3f}'.format((1-fit['params'][0]),fit['error'][0])
# print 'Fitted minimum at {0:.3f} +- {1:.3f}'.format((fit['params'][2]),fit['error'][2])
def fit_ramsey(title=None,
timestamp=None,
ssro_calib_timestamp=None,
ax=None,
do_fit=False,
Rmbi_guess=0.9,
theta_guess=1.5705,
phi_guess=1.5705,
show_guess=False):
"""
fit Rmbi**2Cos(theta)**2 + Rmbi**2Sin(theta)**2(cos(x+phi)+sin(x+phi)
"""
if timestamp != None:
folder = toolbox.data_from_time(timestamp)
else:
folder = toolbox.latest_data(title)
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_sil18'
print ssro_calib_folder
fig, ax = plt.subplots(1, 1, figsize=(4.5, 4))
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC()
x = a.sweep_pts.reshape(-1)[:]
y = ((a.p0.reshape(-1)) - 0.5) * 2
x = np.linspace(0, 720, len(y))
y_err = a.u_p0.reshape(-1)[:]
Rmbi = fit.Parameter(Rmbi_guess, 'Rmbi')
theta = fit.Parameter(theta_guess, 'theta')
phi = fit.Parameter(phi_guess, 'phi')
p0 = [Rmbi, theta, phi]
fitfunc_str = 'Rmbi^2 * Cos(theta)^2 + Rmbi^2 * Sin(theta)^2 * (Cos(x+phi)+Sin(x+phi)'
ax.errorbar(x, y, yerr=y_err)
def fitfunc(x):
# return (Rmbi()*np.cos(theta()+np.pi*x/180.)+0*phi())
return (Rmbi()**
2) * (np.cos(theta() * np.pi / 180.)**2 +
np.sin(theta() * np.pi / 180.)**2 *
(np.cos(x * np.pi / 180. + np.pi * phi() / 180.) +
np.sin(x * np.pi / 180. + np.pi * phi() / 180.)))
if show_guess:
ax.plot(np.linspace(0, x[-1], 201),
fitfunc(np.linspace(0, x[-1], 201)),
':',
lw=2)
if do_fit == True:
fit_result = fit.fit1d(x,
y,
None,
p0=p0,
fitfunc=fitfunc,
fitfunc_str=fitfunc_str,
do_print=True,
ret=True,
fixed=[])
plot.plot_fit1d(fit_result,
np.linspace(x[0], x[-1], 201),
ax=ax,
plot_data=False,
print_info=False)
ax.set_title(folder)
ax.set_ylabel('Contrast')
ax.set_xlabel('Phase')
ax.set_ylim([-1.1, 1.1])
from analysis.lib.tools import toolbox
from analysis.lib.fitting import fit, esr
from analysis.lib.tools import plot
from analysis.lib.math import error
### settings
timestamp = '20150613_093117'#'20150609_231010' ### one can use this timestamp as starting point.
ssro_calib_timestamp = '20150610_174113'
analysis_length = 38
average_data = True
analysis_type = 'double_lorentz' #### possibilities 'peseudo-voigt' 'gauss' 'lorentz' 'double_gauss', 'double_lorentz'
show_guess = False
ssro_dstmp, ssro_tstmp = toolbox.verify_timestamp(ssro_calib_timestamp)
ssro_calib_folder = toolbox.datadir + '/'+ssro_dstmp+'/'+ssro_tstmp+'_AdwinSSRO_SSROCalibration_111_1_sil18'
folder_list = []
if timestamp == None:
timestamp = '20800101_101010' ## some future date... only younger data is considered.
for i in range(analysis_length):
timestamp, folder = toolbox.latest_data(contains='DESR',
return_timestamp =True,
older_than=timestamp,
raise_exc=False)
folder_list.append(folder)
# print folder_list
def Sweep_repetitions(older_than = None,
folder_name ='Memory_NoOf_Repetitions_',
carbon = '2',
ssro_calib_timestamp =None,
plot_result= True) :
folder_dict = {
'X' : [],
'Y' : [],
'resX' : [],
'resX_u' : [],
'resY' : [],
'resY_u': [],
'sweep_pts': [],
'res' : [],
'res_u' : []
}
### search data
for ro in ['positive','negative']:
for t in ['X','Y']:
search_string = folder_name+ro+'_Tomo_'+t+'_'+'C'+carbon
folder_dict[t].append(toolbox.latest_data(contains = search_string,older_than = older_than,raise_exc = False))
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
x_labels,npX,npY,npX_u,npY_u = get_dephasing_data(folder_dict,ssro_calib_folder)
folder_dict['res'] = np.sqrt(npY**2+npX**2)
folder_dict['res_u'] = np.sqrt((npX*npX_u)**2+(npY*npY_u)**2)/np.sqrt((npX**2+npY**2))
if folder_name == 'Memory_Sweep_repump_time_':
plot_label = 'average repump time'
elif folder_name == 'Memory_NoOf_Repetitions_':
plot_label = 'Number of repetitions'
elif folder_name == 'Memory_Sweep_repump_duration':
plot_label = 'repump duration'
elif folder_name == 'Memory_sweep_timing_':
x_labels = np.array(x_labels)*1e6
plot_label = 'Waiting time (us)'
else:
plot_label = folder_name
if plot_result:
fig = plt.figure()
ax = plt.subplot()
plt.errorbar(x_labels,folder_dict['res'],folder_dict['res_u'],marker='o',label='C'+carbon)
plt.xlabel(plot_label)
plt.ylabel('Bloch vector length')
plt.title('Dephasing for C'+carbon)
plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
plt.savefig(os.path.join(folder_dict[t][0],'CarbonDephasing.pdf'),format='pdf')
plt.savefig(os.path.join(folder_dict[t][0],'CarbonDephasing.png'),format='png')
plt.show()
plt.close('all')
else:
return np.array(x_labels), np.array(folder_dict['res']),np.array(folder_dict['res_u']),folder_dict[t][0]
def simple_plot_contrast(timestamps = [None,None], tag = '', measurement_name = ['adwindata'],folder_name ='Tomo',
ssro_calib_timestamp =None, save = True,
do_plot = True, return_data = False) :
'''
Function that makes a bar plot with errorbars of MBI type data that has been measured with a positive
and negative RO.
'''
### SSRO calibration
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'
if timestamps[0] == None:
folder_a = toolbox.latest_data(contains='positive' + tag)
folder_b = toolbox.latest_data(contains='negative' + tag)
elif len(timestamps)==1:
folder_b = toolbox.data_from_time(timestamps[0])
print folder_b
folder_a = toolbox.latest_data(contains = 'pos', older_than = timestamps[0])
print folder_a
else:
folder_a = toolbox.data_from_time(timestamps[0])
folder_b = toolbox.data_from_time(timestamps[1])
a = mbi.MBIAnalysis(folder_a)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC(ssro_calib_folder)
y_a= ((a.p0.reshape(-1)[:])-0.5)*2
y_err_a = 2*a.u_p0.reshape(-1)[:]
b = mbi.MBIAnalysis(folder_b)
b.get_sweep_pts()
b.get_readout_results(name='adwindata')
b.get_electron_ROC(ssro_calib_folder)
y_b= ((b.p0.reshape(-1)[:])-0.5)*2
y_err_b = 2*b.u_p0.reshape(-1)[:]
x = a.sweep_pts.reshape(-1)[:]
# x = range(len(y_a))
### Combine data
y = (y_a - y_b)/2.
y_err = 1./2*(y_err_a**2 + y_err_b**2)**0.5
if do_plot == True:
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)
print folder_a
ax.set_title(str(folder_a)+'/'+str(timestamps[0]))
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_a,'simple_plot_contrast.png'))
except:
print 'Figure has not been saved.'
if return_data == True:
return x, y, y_err
def Osci_period(carbon = '1',older_than = None,ssro_calib_timestamp = None,**kw):
fit_results = kw.pop('fit_results',True)
folder_name = kw.pop('folder_name','Memory_NoOf_Repetitions_')
### fit parameters
freq = kw.pop('freq',1/170.)
offset = kw.pop('offfset',0.)
decay = kw.pop('decay',200)
fixed = kw.pop('fixed',[1])
print folder_name
folder_dict = {
'X' : [],
'Y' : [],
'resX' : [],
'resX_u' : [],
'resY' : [],
'resY_u': [],
'sweep_pts': [],
'res' : [],
'res_u' : []
}
### search data
for ro in ['positive','negative']:
for t in ['X','Y']:
search_string = folder_name+ro+'_Tomo_'+t+'_'+'C'+carbon
folder_dict[t].append(toolbox.latest_data(contains = search_string,older_than = older_than,raise_exc = False))
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
### extract data
x_labels,npX,npY,npX_u,npY_u = get_dephasing_data(folder_dict,ssro_calib_folder)
fig = plt.figure()
ax = plt.subplot()
for y,y_u,jj in zip([npX,npY],[npX_u,npY_u],range(2)):
if fit_results:
A0 = max(y)
phi0 = 0
p0,fitfunc,fitfunc_str = common.fit_decaying_cos(freq,offset,A0,phi0,decay)
# fixed = [1]
fit_result = fit.fit1d(x_labels,y,None,p0 = p0, fitfunc = fitfunc, do_print = True, ret = True, fixed = fixed)
plot.plot_fit1d(fit_result, np.linspace(x_labels[0],x_labels[-1],1001), ax=ax,color = color_list[jj], plot_data=False,add_txt = False, lw = 2)
plt.errorbar(x_labels,y,y_u,marker='o',color = color_list[jj],label='C'+carbon+['X','Y'][jj])
## define folder for data saving
folder = folder_dict[t][0]
plt.xlabel('Repump repetitions')
plt.ylabel('Contrast')
plt.title(get_tstamp_from_folder(folder) + ' Dephasing for C'+carbon)
plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
plt.savefig(os.path.join(folder,'CarbonDephasing_osci.pdf'),format='pdf')
plt.savefig(os.path.join(folder,'CarbonDephasing_osci.png'),format='png')
plt.show()
plt.close('all')
print 'Results are saved in ', folder[18:18+15]
def Carbon_T1_analysis(measurement_name=['adwindata'],
ssro_calib_timestamp=None,
offset=0.5,
amplitude=0.5,
decay_constant=0.04,
x0=0,
exponent=1,
Addressed_carbon=1,
plot_fit=True,
do_print=False,
show_guess=False,
el_state='both'):
'''
Function to gather and analyze T1 measurements of a specific carbon.
Addressed_carbon: selects the used timestamps and therefore the analyzed carbon
measurement_name: list of measurement names
Possible inputs for initial guesses: offset, amplitude, decay_constant,exponent
'''
#general plot parameters
ylim = (0.5, 1.0)
figsize = (6, 4.7)
######################################
# carbon_init= up el_state=0 #
######################################
if el_state == '0' or el_state == 'both':
if Addressed_carbon == 1:
timestamp_pos = [
'20141104_194723', '20141104_200359', '20141104_215235'
]
timestamp_neg = [
'20141104_195541', '20141104_205814', '20141104_231030'
]
elif Addressed_carbon == 5:
timestamp_pos = ['20150316_041301']
timestamp_neg = ['20150316_054506']
# timestamp_pos=['20141105_192118','20141105_193818','20141105_212709']
# timestamp_neg=['20141105_192948','20141105_203243','20141105_231521']
#timestamp_pos=['20141105_002824','20141105_004556','20141105_023521']
#timestamp_neg=['20141105_003711','20141105_014037','20141105_035322']
elif Addressed_carbon == 2:
timestamp_pos = [
'20141106_010336', '20141106_012019', '20141106_030844'
]
timestamp_neg = [
'20141106_011155', '20141106_021431', '20141106_045651'
]
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_sil18'
print ssro_calib_folder
##accumulate data and average over positive and negative RO##
cum_pts = 0
for kk in range(len(timestamp_pos)):
folder_pos = toolbox.data_from_time(timestamp_pos[kk])
folder_neg = toolbox.data_from_time(timestamp_neg[kk])
a = mbi.MBIAnalysis(folder_pos)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC(ssro_calib_folder)
cum_pts += a.pts
b = mbi.MBIAnalysis(folder_neg)
b.get_sweep_pts()
b.get_readout_results(name='adwindata')
b.get_electron_ROC(ssro_calib_folder)
if kk == 0:
cum_sweep_pts = a.sweep_pts
cum_p0 = (a.p0 + (1 - b.p0)) / 2.
cum_u_p0 = np.sqrt(a.u_p0**2 + b.u_p0**2) / 2
else:
cum_sweep_pts = np.concatenate((cum_sweep_pts, a.sweep_pts))
cum_p0 = np.concatenate((cum_p0, (a.p0 + (1 - b.p0)) / 2))
cum_u_p0 = np.concatenate(
(cum_u_p0, np.sqrt(a.u_p0**2 + b.u_p0**2) / 2))
a.pts = cum_pts
a.sweep_pts = cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
## accumulate data with negative RO
#sort data by free evolution time.
sorting_order = a.sweep_pts.argsort()
a.sweep_pts.sort()
a.p0 = a.p0[sorting_order]
a.u_p0 = a.u_p0[sorting_order]
## generate plot of the raw data ##
#uncomment this part to plot without error bars, but including obtained fit parameters.
# fig = a.default_fig(figsize=(6,5))
# ax = a.default_ax(fig)
# ax.plot(a.sweep_pts, a.p0, 'bo',label='T1 of Carbon'+str(Addressed_carbon),lw=1.2)
ax = a.plot_results_vs_sweepparam(ret='ax',
ax=None,
figsize=figsize,
ylim=(0.4, 1.0))
## fit to a general exponential##
fit_results = []
x = a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
ax.plot(x, y)
plt.show()
p0, fitfunc, fitfunc_str = common.fit_general_exponential(
offset, amplitude, x0, decay_constant, exponent)
#p0, fitfunc, fitfunc_str = common.fit_line(0.5,-0.5/7.)
#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=[0, 2])
## 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)
filename = 'C13_T1_analysis_up_C' + str(Addressed_carbon)
print 'plots are saved in ' + folder_pos
#configure the plot
plt.title('Sample_111_No1_C13_T1_up_C' + str(Addressed_carbon) +
'el_state_0')
plt.xlabel('Free evolution time (s)')
plt.ylabel('Fidelity')
plt.axis([a.sweep_pts[0], a.sweep_pts[a.pts - 1], 0.4, 1.])
plt.savefig(os.path.join(folder_pos, filename + '.pdf'), format='pdf')
plt.savefig(os.path.join(folder_pos, filename + '.png'), format='png')
######################################
# carbon_init= up el_state=1 #
######################################
if el_state == '1' or el_state == 'both':
if Addressed_carbon == 1:
timestamp_pos = [
'20141104_195135', '20141104_203107', '20141104_223132'
]
timestamp_neg = [
'20141104_195949', '20141104_212524', '20141104_234927'
]
elif Addressed_carbon == 5:
timestamp_neg = ['20150316_055528']
timestamp_pos = ['20150316_042310']
# timestamp_neg=['20150312_001153']
# timestamp_pos=['20150311_231635']
# timestamp_neg=['20141105_193405','20141105_205957','20141106_000928']
#timestamp_pos=['20141105_003250','20141105_011316','20141105_031420']
#timestamp_neg=['20141105_004136','20141105_020802','20141105_043221']
elif Addressed_carbon == 2:
timestamp_pos = [
'20141106_010748', '20141106_014724', '20141106_040245'
]
timestamp_neg = [
'20141106_011609', '20141106_024138', '20141106_055052'
]
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_sil18'
print ssro_calib_folder
##accumulate data and average over positive and negative RO##
cum_pts = 0
for kk in range(len(timestamp_pos)):
folder_pos = toolbox.data_from_time(timestamp_pos[kk])
folder_neg = toolbox.data_from_time(timestamp_neg[kk])
a = mbi.MBIAnalysis(folder_pos)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
timestamp_SSRO, ssro_calib_folder = toolbox.latest_data(
'AdwinSSRO',
older_than=timestamp_pos[kk],
return_timestamp=True)
a.get_electron_ROC(ssro_calib_folder)
cum_pts += a.pts
b = mbi.MBIAnalysis(folder_neg)
b.get_sweep_pts()
b.get_readout_results(name='adwindata')
timestamp_SSRO, ssro_calib_folder = toolbox.latest_data(
'AdwinSSRO',
older_than=timestamp_neg[kk],
return_timestamp=True)
b.get_electron_ROC(ssro_calib_folder)
print a.p0.transpose()
print b.p0.transpose()
if kk == 0:
cum_sweep_pts = a.sweep_pts
cum_p0 = (a.p0 + (1 - b.p0)) / 2.
cum_u_p0 = np.sqrt(a.u_p0**2 + b.u_p0**2) / 2
else:
cum_sweep_pts = np.concatenate((cum_sweep_pts, a.sweep_pts))
cum_p0 = np.concatenate((cum_p0, (a.p0 + (1 - b.p0)) / 2))
cum_u_p0 = np.concatenate(
(cum_u_p0, np.sqrt(a.u_p0**2 + b.u_p0**2) / 2))
a.pts = cum_pts
a.sweep_pts = cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
print a.p0
## accumulate data with negative RO
#sort data by free evolution time.
sorting_order = a.sweep_pts.argsort()
a.sweep_pts.sort()
a.p0 = a.p0[sorting_order]
a.u_p0 = a.u_p0[sorting_order]
## generate plot of the raw data ##
#uncomment this part to plot without error bars, but including obtained fit parameters.
# fig = a.default_fig(figsize=(6,5))
# ax = a.default_ax(fig)
# ax.plot(a.sweep_pts, a.p0, 'bo',label='T1 of Carbon'+str(Addressed_carbon),lw=1.2)
ax = a.plot_results_vs_sweepparam(ret='ax',
figsize=figsize,
ax=None,
ylim=ylim)
## fit to a general exponential##
fit_results = []
x = a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
ax.plot(x, y)
# plt.show()
p0, fitfunc, fitfunc_str = common.fit_general_exponential(
offset, amplitude, x0, decay_constant, exponent)
#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=[0, 2])
## 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)
filename = 'C13_T1_analysis_up_C' + str(Addressed_carbon)
print 'plots are saved in ' + folder_pos
#configure the plot
plt.title('Sample_111_No1_C13_T1_up_C' + str(Addressed_carbon) +
'el_state_1')
plt.xlabel('Free evolution time (s)')
plt.ylabel('Fidelity')
plt.axis([a.sweep_pts[0], a.sweep_pts[a.pts - 1], ylim[0], ylim[1]])
plt.savefig(os.path.join(folder_pos, filename + '.pdf'), format='pdf')
plt.savefig(os.path.join(folder_pos, filename + '.png'), format='png')
def Sweep_repetitions(older_than=None,
folder_name='Memory_NoOf_Repetitions_',
carbon='2',
ssro_calib_timestamp=None,
plot_result=True):
folder_dict = {
'X': [],
'Y': [],
'resX': [],
'resX_u': [],
'resY': [],
'resY_u': [],
'sweep_pts': [],
'res': [],
'res_u': []
}
### search data
for ro in ['positive', 'negative']:
for t in ['X', 'Y']:
search_string = folder_name + ro + '_Tomo_' + t + '_' + 'C' + carbon
folder_dict[t].append(
toolbox.latest_data(contains=search_string,
older_than=older_than,
raise_exc=False))
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
x_labels, npX, npY, npX_u, npY_u = get_dephasing_data(
folder_dict, ssro_calib_folder)
folder_dict['res'] = np.sqrt(npY**2 + npX**2)
folder_dict['res_u'] = np.sqrt((npX * npX_u)**2 +
(npY * npY_u)**2) / np.sqrt(
(npX**2 + npY**2))
if folder_name == 'Memory_Sweep_repump_time_':
plot_label = 'average repump time'
elif folder_name == 'Memory_NoOf_Repetitions_':
plot_label = 'Number of repetitions'
elif folder_name == 'Memory_Sweep_repump_duration':
plot_label = 'repump duration'
elif folder_name == 'Memory_sweep_timing_':
x_labels = np.array(x_labels) * 1e6
plot_label = 'Waiting time (us)'
else:
plot_label = folder_name
if plot_result:
fig = plt.figure()
ax = plt.subplot()
plt.errorbar(x_labels,
folder_dict['res'],
folder_dict['res_u'],
marker='o',
label='C' + carbon)
plt.xlabel(plot_label)
plt.ylabel('Bloch vector length')
plt.title('Dephasing for C' + carbon)
plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
plt.savefig(os.path.join(folder_dict[t][0], 'CarbonDephasing.pdf'),
format='pdf')
plt.savefig(os.path.join(folder_dict[t][0], 'CarbonDephasing.png'),
format='png')
plt.show()
plt.close('all')
else:
return np.array(x_labels), np.array(folder_dict['res']), np.array(
folder_dict['res_u']), folder_dict[t][0]
def simple_plot_contrast(timestamps=[None, None],
tag='',
measurement_name=['adwindata'],
folder_name='Tomo',
ssro_calib_timestamp=None,
save=True,
do_plot=True,
return_data=False):
'''
Function that makes a bar plot with errorbars of MBI type data that has been measured with a positive
and negative RO.
'''
### SSRO calibration
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'
if timestamps[0] == None:
folder_a = toolbox.latest_data(contains='positive' + tag)
folder_b = toolbox.latest_data(contains='negative' + tag)
elif len(timestamps) == 1:
folder_b = toolbox.data_from_time(timestamps[0])
print folder_b
folder_a = toolbox.latest_data(contains='pos',
older_than=timestamps[0])
print folder_a
else:
folder_a = toolbox.data_from_time(timestamps[0])
folder_b = toolbox.data_from_time(timestamps[1])
a = mbi.MBIAnalysis(folder_a)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC(ssro_calib_folder)
y_a = ((a.p0.reshape(-1)[:]) - 0.5) * 2
y_err_a = 2 * a.u_p0.reshape(-1)[:]
b = mbi.MBIAnalysis(folder_b)
b.get_sweep_pts()
b.get_readout_results(name='adwindata')
b.get_electron_ROC(ssro_calib_folder)
y_b = ((b.p0.reshape(-1)[:]) - 0.5) * 2
y_err_b = 2 * b.u_p0.reshape(-1)[:]
x = a.sweep_pts.reshape(-1)[:]
# x = range(len(y_a))
### Combine data
y = (y_a - y_b) / 2.
y_err = 1. / 2 * (y_err_a**2 + y_err_b**2)**0.5
if do_plot == True:
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)
print folder_a
ax.set_title(str(folder_a) + '/' + str(timestamps[0]))
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_a, 'simple_plot_contrast.png'))
except:
print 'Figure has not been saved.'
if return_data == True:
return x, y, y_err
def Carbon_Ramsey_mult_msmts(timestamp=None,
measurement_name=['adwindata'],
ssro_calib_timestamp=None,
frequency=1,
offset=0.5,
x0=0,
amplitude=0.5,
decay_constant=200,
phase=0,
exponent=2,
plot_fit=False,
do_print=False,
fixed=[2],
show_guess=True,
return_phase=False,
return_freq=False,
return_amp=False,
return_results=True,
close_plot=False,
partstr='part',
contains=[],
title='Carbon'):
'''
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
List of parameters (order important for 'fixed')
offset, amplitude, decay_constant,exponent,frequency ,phase
'''
if timestamp != None:
folder = toolbox.data_from_time(timestamp)
else:
folder = toolbox.latest_data(title)
if partstr in folder:
numberstart = folder.find(partstr) + len(partstr)
numberofparts = int(folder[numberstart:len(folder)])
basis_str = folder[folder.rfind('\\') + 7:numberstart]
else:
numberofparts = 1
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_sil18'
print ssro_calib_folder
fit_results = []
#for kk in range(numberofparts):
for kk, cnts in enumerate(contains):
'''
if partstr in folder:
folder = toolbox.latest_data(basis_str+str(kk+1))
else:
folder = toolbox.latest_data(basis_str)
'''
folder = toolbox.latest_data(cnts)
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')
if kk == 0:
cum_sweep_pts = a.sweep_pts
cum_p0 = a.p0
cum_u_p0 = a.u_p0
cum_pts = a.pts
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))
cum_pts += a.pts
a.pts = cum_pts
a.sweep_pts = cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
sorting_order = a.sweep_pts.argsort()
a.sweep_pts.sort()
a.p0 = a.p0[sorting_order]
a.u_p0 = a.u_p0[sorting_order]
ax = a.plot_results_vs_sweepparam(ret='ax')
x = a.sweep_pts.reshape(-1)[:]
y = a.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)
## 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')
if close_plot == True:
plt.close()
if return_freq == True:
f0 = fit_result['params_dict']['f']
u_f0 = fit_result['error_dict']['f']
return f0, u_f0
if return_phase == True and return_amp == False:
phi0 = fit_result['params_dict']['phi']
u_phi0 = fit_result['error_dict']['phi']
return phi0, u_phi0
if return_phase == True and return_amp == True:
phi0 = fit_result['params_dict']['phi']
u_phi0 = fit_result['error_dict']['phi']
A = fit_result['params_dict']['A']
u_A = fit_result['error_dict']['A']
return phi0, u_phi0, A, u_A
if return_results == True:
return fit_results
def Carbon_Ramsey(timestamp=None, measurement_name = ['adwindata'], ssro_calib_timestamp =None,
frequency = 1,
offset = 0.5,
x0 = 0,
amplitude = 0.5,
decay_constant = 200,
phase =0,
exponent = 2,
plot_fit = False, do_print = False, fixed = [2], show_guess = True,
return_phase = False,
return_freq = False,
return_amp = False,
return_results = True,
close_plot = False,
title = 'Carbon'):
'''
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
List of parameters (order important for 'fixed')
offset, amplitude, decay_constant,exponent,frequency ,phase
'''
if timestamp != None:
folder = toolbox.data_from_time(timestamp)
else:
folder = toolbox.latest_data(title)
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_sil18'
print ssro_calib_folder
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(ssro_calib_folder)
ax = a.plot_results_vs_sweepparam(ret='ax')
x = a.sweep_pts.reshape(-1)[:]
y = a.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')
if close_plot == True:
plt.close()
# for item in fit_result['params_dict']:
# print item
if return_freq == True:
f0 = fit_result['params_dict']['f']
u_f0 = fit_result['error_dict']['f']
return f0, u_f0
if return_phase == True and return_amp == False:
phi0 = fit_result['params_dict']['phi']
u_phi0 = fit_result['error_dict']['phi']
return phi0, u_phi0
if return_phase == True and return_amp == True:
phi0 = fit_result['params_dict']['phi']
u_phi0 = fit_result['error_dict']['phi']
A = fit_result['params_dict']['A']
u_A = fit_result['error_dict']['A']
return phi0, u_phi0, A, u_A
if return_amp == True:
A = fit_result['params_dict']['A']
u_A = fit_result['error_dict']['A']
return A, u_A
if return_results == True:
return fit_results
def QEC_analysis(timestamp=None, measurement_name = ['adwindata'], ssro_calib_timestamp =None,
frequency = 1,
offset = 0.5,
x0 = 0,
amplitude = 0.5,
decay_constant = 200,
phase =0,
exponent = 2,
plot_fit = False, do_print = False, fixed = [2], show_guess = True,
return_phase = False,
return_freq = False,
return_results = True,
close_plot = False,
title = None):
'''
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
List of parameters (order important for 'fixed')
offset, amplitude, decay_constant,exponent,frequency ,phase
'''
if timestamp != None:
folder = toolbox.data_from_time(timestamp)
else:
folder = toolbox.latest_data('Tomography')
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'
print ssro_calib_folder
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(ssro_calib_folder)
ax = a.plot_results_vs_sweepparam(ret='ax')
x = a.sweep_pts.reshape(-1)[:]
y = a.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')
if close_plot == True:
plt.close()
if return_freq == True:
f0 = fit_result['params_dict']['f']
u_f0 = fit_result['error_dict']['f']
return f0, u_f0
if return_phase == True:
phi0 = fit_result['params_dict']['phi']
u_phi0 = fit_result['error_dict']['phi']
return phi0, u_phi0
if return_results == True:
return fit_results
def Carbon_Ramsey_Crosstalk(timestamp=None, measurement_name = ['adwindata'], ssro_calib_timestamp =None,
frequency = 1,
offset = 0.5,
x0 = 0,
amplitude = 0.5,
decay_constant = 200,
phase =0,
exponent = 2,
plot_fit = False, do_print = False, fixed = [2,3,4], show_guess = True,
return_phase = False,
return_freq = False,
return_results = True,
return_amp = False,
close_plot = False,
title = None):
'''
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
List of parameters (order important for 'fixed')
offset, amplitude, decay_constant,exponent,frequency ,phase
'''
if timestamp != None:
folder_a = toolbox.data_from_time(timestamp)
else:
folder_a, timestamp = toolbox.latest_data('Crosstalk', return_timestamp = True)
folder_b = toolbox.latest_data('Crosstalk',older_than = 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'
print ssro_calib_folder
fit_results = []
for k in range(0,len(measurement_name)):
a = mbi.MBIAnalysis(folder_a)
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_RO_data = 2*(a.p0.reshape(-1)[:])-1
X_RO_data_u = 2*(a.u_p0.reshape(-1)[:])
a = mbi.MBIAnalysis(folder_b)
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_RO_data = 2*(a.p0.reshape(-1)[:])-1
Y_RO_data_u = 2*(a.u_p0.reshape(-1)[:])
RO_data = (X_RO_data**2 + Y_RO_data**2)**0.5
RO_data_u = (1./(X_RO_data**2 + Y_RO_data**2)*(X_RO_data**2 * X_RO_data_u**2 + Y_RO_data**2 *Y_RO_data_u**2))**0.5
fig = a.default_fig(figsize=(7.5,5))
ax2 = a.default_ax(fig)
ax2.axhspan(0,1,fill=False,ls='dotted')
ax2.set_ylim(-1,1)
ax2.errorbar(x,RO_data,RO_data_u)
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:
ax2.plot(np.linspace(x[0],x[-1],201), fitfunc(np.linspace(x[0],x[-1],201)), ':', lw=2)
fit_result = fit.fit1d(x,RO_data, 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=ax2, plot_data=False)
fit_results.append(fit_result)
if title == None:
title = 'analyzed_result'
plt.savefig(os.path.join(folder_a, title + '.pdf'),
format='pdf')
plt.savefig(os.path.join(folder_a, title + '.png'),
format='png')
if close_plot == True:
plt.close()
if return_freq == True:
f0 = fit_result['params_dict']['f']
u_f0 = fit_result['error_dict']['f']
return f0, u_f0
if return_phase == True:
phi0 = fit_result['params_dict']['phi']
u_phi0 = fit_result['error_dict']['phi']
Amp = fit_result['params_dict']['A']
if return_amp == True:
return phi0, u_phi0, Amp
else:
return phi0, u_phi0
if return_results == True:
return fit_results
def Carbon_T2_analysis_ms0(measurement_name = ['adwindata'], ssro_calib_timestamp =None,
offset = 0.5,
amplitude = 0.5,
decay_constant = 0.2,
x0=0,
exponent = 1,
Addressed_carbon=5,
plot_fit = True, do_print = True, show_guess = False):
'''
Function to gather and analyze T1 measurements of a specific carbon.
Addressed_carbon: selects the used timestamps and therefore the analyzed carbon
measurement_name: list of measurement names
Possible inputs for initial guesses: offset, amplitude, decay_constant,exponent
'''
######################################
# carbon_init= up el_state=0 #
######################################
if Addressed_carbon == 5:
timestamp_pos=['20150315_215418']
timestamp_neg=['20150315_225753']
timestamp_pos=['20150317_103608']
timestamp_neg=['20150317_105622']
elif Addressed_carbon == 1:
timestamp_pos=['20150316_000112']
timestamp_neg=['20150316_010415']
timestamp_pos=['20150317_015434']
timestamp_neg=['20150317_021428']
elif Addressed_carbon == 2:
timestamp_pos=['20150316_020808']
timestamp_neg=['20150316_031102']
timestamp_pos=['20150317_061458']
timestamp_neg=['20150317_063658']
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_sil18'
print ssro_calib_folder
##accumulate data and average over positive and negative RO##
cum_pts = 0
for kk in range(len(timestamp_pos)):
folder_pos = toolbox.data_from_time(timestamp_pos[kk])
folder_neg = toolbox.data_from_time(timestamp_neg[kk])
a = mbi.MBIAnalysis(folder_pos)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
timestamp_SSRO, ssro_calib_folder = toolbox.latest_data('AdwinSSRO', older_than = timestamp_pos[kk], return_timestamp = True)
a.get_electron_ROC(ssro_calib_folder)
cum_pts += a.pts
b = mbi.MBIAnalysis(folder_neg)
b.get_sweep_pts()
b.get_readout_results(name='adwindata')
timestamp_SSRO, ssro_calib_folder = toolbox.latest_data('AdwinSSRO', older_than = timestamp_neg[kk], return_timestamp = True)
b.get_electron_ROC(ssro_calib_folder)
if kk == 0:
cum_sweep_pts = a.sweep_pts
cum_p0 = (a.p0+(1-b.p0))/2.
cum_u_p0 = np.sqrt(a.u_p0**2+b.u_p0**2)/2
else:
cum_sweep_pts = np.concatenate((cum_sweep_pts, a.sweep_pts))
cum_p0 = np.concatenate((cum_p0, (a.p0+(1-b.p0))/2))
cum_u_p0 = np.concatenate((cum_u_p0, np.sqrt(a.u_p0**2+b.u_p0**2)/2))
a.pts = cum_pts
a.sweep_pts = cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
## accumulate data with negative RO
#sort data by free evolution time.
sorting_order=a.sweep_pts.argsort()
a.sweep_pts.sort()
a.p0=a.p0[sorting_order]
a.u_p0=a.u_p0[sorting_order]
## generate plot of the raw data ##
#uncomment this part to plot without error bars, but including obtained fit parameters.
# fig = a.default_fig(figsize=(6,5))
# ax = a.default_ax(fig)
# ax.plot(a.sweep_pts, a.p0, 'bo',label='T1 of Carbon'+str(Addressed_carbon),lw=1.2)
ax=a.plot_results_vs_sweepparam(ret='ax',ax=None,
figsize=figsize,
ylim=(0.4,1.0)
)
## fit to a general exponential##
fit_results = []
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(offset, amplitude, x0, decay_constant,exponent)
#p0, fitfunc, fitfunc_str = common.fit_line(0.5,-0.5/7.)
#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=[0,2])
## 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)
filename= 'C13_T2_analysis_up_C'+str(Addressed_carbon)
print 'plots are saved in ' + folder_pos
#configure the plot
plt.title('Sample_111_No1_C13_T2_up_C'+str(Addressed_carbon)+'el_state_0')
plt.xlabel('Free evolution time (s)')
plt.ylabel('Fidelity')
plt.axis([a.sweep_pts[0],a.sweep_pts[a.pts-1],0.4,1.])
# plt.savefig(os.path.join(folder_pos, filename+'.pdf'),
# format='pdf')
# plt.savefig(os.path.join(folder_pos, filename+'.png'),
# format='png')
return x,y, y_err, fit_result
def simple_plot_contrast(timestamps=[None, None],
tag='',
measurement_name=['adwindata'],
folder_name='Tomo',
ssro_calib_timestamp=None,
save=True,
do_plot=True,
return_data=False,
guess_frq=1 / 4000.,
guess_amp=1.5,
guess_k=0.,
guess_phi=0.,
guess_o=0.3):
### SSRO calibration
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'
if timestamps[0] == None:
folder_a = toolbox.latest_data(contains='positive' + tag)
folder_b = toolbox.latest_data(contains='negative' + tag)
elif len(timestamps) == 1:
folder_b = toolbox.data_from_time(timestamps[0])
print folder_b
folder_a = toolbox.latest_data(contains='pos',
older_than=timestamps[0])
print folder_a
else:
folder_a = toolbox.data_from_time(timestamps[0])
folder_b = toolbox.data_from_time(timestamps[1])
a = mbi.MBIAnalysis(folder_a)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC(ssro_calib_folder)
y_a = ((a.p0.reshape(-1)[:]) - 0.5) * 2
y_err_a = 2 * a.u_p0.reshape(-1)[:]
b = mbi.MBIAnalysis(folder_b)
b.get_sweep_pts()
b.get_readout_results(name='adwindata')
b.get_electron_ROC(ssro_calib_folder)
y_b = ((b.p0.reshape(-1)[:]) - 0.5) * 2
y_err_b = 2 * b.u_p0.reshape(-1)[:]
x = a.sweep_pts.reshape(-1)[:]
# x = range(len(y_a))
# ax = a.plot_results_vs_sweepparam(ret='ax', name = 'adwindata' )
### Combine data
y = (y_a - y_b) / 2.
y_err = 1. / 2 * (y_err_a**2 + y_err_b**2)**0.5
if x[-1] < x[0]:
x = x[::-1]
y = y[::-1]
fig, ax = plt.subplots()
o = fit.Parameter(guess_o, '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 = [A, o, f, phi]
fitfunc_str = ''
ax.errorbar(x, y, yerr=y_err, marker='o', ls='')
def fitfunc(x):
return (o() -
A()) + A() * np.exp(-(k() * x)**2) * np.cos(2 * np.pi *
(f() * x - phi()))
fit_result = fit.fit1d(x,
y,
None,
p0=p0,
fitfunc=fitfunc,
fixed=[],
do_print=True,
ret=True)
ax.set_title(folder_a)
y_fit = fit_result['fitfunc'](np.arange(0, 60, 1))
for i, y in enumerate(abs(y_fit)):
if y == min(abs(y_fit)):
x_opt = i
ax.text(5, 0.9, 'pulses for pi/2: ' + str(x_opt))
plot.plot_fit1d(fit_result,
np.linspace(0, x[-1], 201),
ax=ax,
plot_data=False)
ax.set_ylim([-1, 1])
plt.savefig(os.path.join(folder_a, 'mbi_erabi_analysis.pdf'), format='pdf')
plt.savefig(os.path.join(folder_a, 'mbi_erabi_analysis.png'), format='png')
def get_data(folder,folder_timestamp,RO_correct=True,ssro_calib_timestamp=None,tomo_bases='XXX',get_title=False, return_orientations=False, **kw):
evaluate_both = kw.pop('evaluate_both',False)
a = CP.ConditionalParityAnalysis(folder)
#a.get_sweep_pts()
a.get_readout_results(name='adwindata', post_select_GHZ = True)
if a.orientations[3] == 'negative':
multiply_by = -1
else:
multiply_by = 1
print a.orientations
if RO_correct == True:
if ssro_calib_timestamp == None:
ssro_calib_folder = toolbox.latest_data('SSRO',older_than=folder_timestamp)
analysis_file=os.path.join(ssro_calib_folder,'analysis.hdf5')
if not os.path.exists(analysis_file):
ssro.ssrocalib(ssro_calib_folder)
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'#GHZ_'+tomo_bases
#print ssro_calib_folder
a.get_electron_ROC(ssro_calib_folder = ssro_calib_folder, post_select_GHZ = True)
#take the [0,0] part of the arrays; there are no sweep_pts
p0_000,u_p0_000 = multiply_by*(a.p0_000[0,0]-0.5)*2,(2*a.u_p0_000[0,0])
p0_001,u_p0_001 = multiply_by*(a.p0_001[0,0]-0.5)*2,(2*a.u_p0_001[0,0])
p0_010,u_p0_010 = multiply_by*(a.p0_010[0,0]-0.5)*2,(2*a.u_p0_010[0,0])
p0_011,u_p0_011 = multiply_by*(a.p0_011[0,0]-0.5)*2,(2*a.u_p0_011[0,0])
p0_100,u_p0_100 = multiply_by*(a.p0_100[0,0]-0.5)*2,(2*a.u_p0_100[0,0])
p0_101,u_p0_101 = multiply_by*(a.p0_101[0,0]-0.5)*2,(2*a.u_p0_101[0,0])
p0_110,u_p0_110 = multiply_by*(a.p0_110[0,0]-0.5)*2,(2*a.u_p0_110[0,0])
p0_111,u_p0_111 = multiply_by*(a.p0_111[0,0]-0.5)*2,(2*a.u_p0_111[0,0])
print "probablity with ROC", a.p0_000[0,0]
print "exp with ROC",p0_000, u_p0_000
if evaluate_both:
#else:
p0_000,u_p0_000 = multiply_by*(a.normalized_ssro_000[0,0]-0.5)*2,(2*a.u_normalized_ssro_000[0,0])
p0_001,u_p0_001 = multiply_by*(a.normalized_ssro_001[0,0]-0.5)*2,(2*a.u_normalized_ssro_001[0,0])
p0_010,u_p0_010 = multiply_by*(a.normalized_ssro_010[0,0]-0.5)*2,(2*a.u_normalized_ssro_010[0,0])
p0_011,u_p0_011 = multiply_by*(a.normalized_ssro_011[0,0]-0.5)*2,(2*a.u_normalized_ssro_011[0,0])
p0_100,u_p0_100 = multiply_by*(a.normalized_ssro_100[0,0]-0.5)*2,(2*a.u_normalized_ssro_100[0,0])
p0_101,u_p0_101 = multiply_by*(a.normalized_ssro_101[0,0]-0.5)*2,(2*a.u_normalized_ssro_101[0,0])
p0_110,u_p0_110 = multiply_by*(a.normalized_ssro_110[0,0]-0.5)*2,(2*a.u_normalized_ssro_110[0,0])
p0_111,u_p0_111 = multiply_by*(a.normalized_ssro_111[0,0]-0.5)*2,(2*a.u_normalized_ssro_111[0,0])
print "prob without ROC", a.normalized_ssro_000[0,0]
print "exp without ROC",p0_000, u_p0_000
print "WARNING WARNING REMOVE THIS STATEMENT. REMOVE EVALUATE_BOTH OPTION"
if get_title:
a_list_name = "".join(aa for aa in a.a_list)
b_list_name = "".join(aa for aa in a.b_list)
c_list_name = "".join(aa for aa in a.c_list)
d_list_name = "".join(aa for aa in a.d_list)
title = a_list_name+' '+b_list_name+' '+c_list_name+' '+d_list_name
else:
title=''
p = (a.p000[0,0],a.p001[0,0],a.p010[0,0],a.p011[0,0],a.p100[0,0],a.p101[0,0],a.p110[0,0],a.p111[0,0])
y = (p0_000,p0_001,p0_010,p0_011,p0_100,p0_101,p0_110,p0_111)
y_err = (u_p0_000,u_p0_001,u_p0_010,u_p0_011,u_p0_100,u_p0_101,u_p0_110,u_p0_111)
if return_orientations:
return(p,y,y_err,title,a.orientations)
return(p,y,y_err,title)
def Osci_period(carbon='1', older_than=None, ssro_calib_timestamp=None, **kw):
fit_results = kw.pop('fit_results', True)
folder_name = kw.pop('folder_name', 'Memory_NoOf_Repetitions_')
### fit parameters
freq = kw.pop('freq', 1 / 170.)
offset = kw.pop('offfset', 0.)
decay = kw.pop('decay', 200)
fixed = kw.pop('fixed', [1])
print folder_name
folder_dict = {
'X': [],
'Y': [],
'resX': [],
'resX_u': [],
'resY': [],
'resY_u': [],
'sweep_pts': [],
'res': [],
'res_u': []
}
### search data
for ro in ['positive', 'negative']:
for t in ['X', 'Y']:
search_string = folder_name + ro + '_Tomo_' + t + '_' + 'C' + carbon
folder_dict[t].append(
toolbox.latest_data(contains=search_string,
older_than=older_than,
raise_exc=False))
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
### extract data
x_labels, npX, npY, npX_u, npY_u = get_dephasing_data(
folder_dict, ssro_calib_folder)
fig = plt.figure()
ax = plt.subplot()
for y, y_u, jj in zip([npX, npY], [npX_u, npY_u], range(2)):
if fit_results:
A0 = max(y)
phi0 = 0
p0, fitfunc, fitfunc_str = common.fit_decaying_cos(
freq, offset, A0, phi0, decay)
# fixed = [1]
fit_result = fit.fit1d(x_labels,
y,
None,
p0=p0,
fitfunc=fitfunc,
do_print=True,
ret=True,
fixed=fixed)
plot.plot_fit1d(fit_result,
np.linspace(x_labels[0], x_labels[-1], 1001),
ax=ax,
color=color_list[jj],
plot_data=False,
add_txt=False,
lw=2)
plt.errorbar(x_labels,
y,
y_u,
marker='o',
color=color_list[jj],
label='C' + carbon + ['X', 'Y'][jj])
## define folder for data saving
folder = folder_dict[t][0]
plt.xlabel('Repump repetitions')
plt.ylabel('Contrast')
plt.title(get_tstamp_from_folder(folder) + ' Dephasing for C' + carbon)
plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
plt.savefig(os.path.join(folder, 'CarbonDephasing_osci.pdf'), format='pdf')
plt.savefig(os.path.join(folder, 'CarbonDephasing_osci.png'), format='png')
plt.show()
plt.close('all')
print 'Results are saved in ', folder[18:18 + 15]
def Carbon_T2_analysis_ms1(measurement_name=['adwindata'],
ssro_calib_timestamp=None,
offset=0.5,
amplitude=0.5,
decay_constant=0.2,
x0=0,
exponent=1,
Addressed_carbon=5,
plot_fit=True,
do_print=True,
show_guess=False):
if Addressed_carbon == 1:
timestamp_pos = [
'20141104_195135', '20141104_203107', '20141104_223132'
]
timestamp_neg = [
'20141104_195949', '20141104_212524', '20141104_234927'
]
elif Addressed_carbon == 5:
timestamp_pos = ['20150309_193904']
timestamp_neg = ['20150309_195337']
# timestamp_pos=['20150102_193904']
# timestamp_neg=['20150102_214323']
#timestamp_pos=['20141105_003250','20141105_011316','20141105_031420']
#timestamp_neg=['20141105_004136','20141105_020802','20141105_043221']
elif Addressed_carbon == 2:
timestamp_pos = [
'20141106_010748', '20141106_014724', '20141106_040245'
]
timestamp_neg = [
'20141106_011609', '20141106_024138', '20141106_055052'
]
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_sil18'
print ssro_calib_folder
##accumulate data and average over positive and negative RO##
cum_pts = 0
for kk in range(len(timestamp_pos)):
folder_pos = toolbox.data_from_time(timestamp_pos[kk])
folder_neg = toolbox.data_from_time(timestamp_neg[kk])
a = mbi.MBIAnalysis(folder_pos)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC(ssro_calib_folder)
cum_pts += a.pts
b = mbi.MBIAnalysis(folder_neg)
b.get_sweep_pts()
b.get_readout_results(name='adwindata')
b.get_electron_ROC(ssro_calib_folder)
if kk == 0:
cum_sweep_pts = a.sweep_pts
cum_p0 = (a.p0 + (1 - b.p0)) / 2.
cum_u_p0 = np.sqrt(a.u_p0**2 + b.u_p0**2) / 2
else:
cum_sweep_pts = np.concatenate((cum_sweep_pts, a.sweep_pts))
cum_p0 = np.concatenate((cum_p0, (a.p0 + (1 - b.p0)) / 2))
cum_u_p0 = np.concatenate(
(cum_u_p0, np.sqrt(a.u_p0**2 + b.u_p0**2) / 2))
print
a.pts = cum_pts
a.sweep_pts = cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
## accumulate data with negative RO
#sort data by free evolution time.
sorting_order = a.sweep_pts.argsort()
a.sweep_pts.sort()
a.p0 = a.p0[sorting_order]
a.u_p0 = a.u_p0[sorting_order]
## generate plot of the raw data ##
#uncomment this part to plot without error bars, but including obtained fit parameters.
# fig = a.default_fig(figsize=(6,5))
# ax = a.default_ax(fig)
# ax.plot(a.sweep_pts, a.p0, 'bo',label='T1 of Carbon'+str(Addressed_carbon),lw=1.2)
ax = a.plot_results_vs_sweepparam(ret='ax',
figsize=figsize,
ax=None,
ylim=ylim)
## fit to a general exponential##
fit_results = []
x = a.sweep_pts.reshape(-1)[:] * 2
y = a.p0.reshape(-1)[:]
y_err = a.u_p0.reshape(-1)[:]
ax.plot(x, y)
p0, fitfunc, fitfunc_str = common.fit_general_exponential(
offset, amplitude, x0, decay_constant, exponent)
#p0, fitfunc, fitfunc_str = common.fit_line(0.5,-0.5/7.)
#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=[0, 2])
## 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)
filename = 'C13_T2_analysis_up_C' + str(Addressed_carbon)
print 'plots are saved in ' + folder_pos
#configure the plot
plt.title('Sample_111_No1_C13_T2_up_C' + str(Addressed_carbon) +
'el_state_1')
plt.xlabel('Free evolution time (s)')
plt.ylabel('Fidelity')
plt.axis([a.sweep_pts[0], a.sweep_pts[a.pts - 1], 0.4, 1])
# plt.savefig(os.path.join(r'D:\measuring\data\Analyzed figures\Carbon Hahn', filename+'.pdf'),
# format='pdf')
# plt.savefig(os.path.join(r'D:\measuring\data\Analyzed figures\Carbon Hahn', filename+'.png'),
# format='png')
return x, y, y_err, fit_result
timestamp_pos=['20150316_020808']
timestamp_neg=['20150316_031102']
timestamp_pos=['20150317_061458']
timestamp_neg=['20150317_063658']
=======
timestamp_pos=['20150102_185838']
timestamp_neg=['20150102_191030']
else:
print "Carbon not measured"
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_sil18'
print ssro_calib_folder
##accumulate data and average over positive and negative RO##
cum_pts = 0
for kk in range(len(timestamp_pos)):
folder_pos = toolbox.data_from_time(timestamp_pos[kk])
folder_neg = toolbox.data_from_time(timestamp_neg[kk])
print folder_pos
print folder_neg
a = mbi.MBIAnalysis(folder_pos)
a.get_sweep_pts()
def BarPlotTomo_QEC(timestamp=None,
measurement_name=['adwindata'],
folder_name='Tomo',
plot_post_select=False,
ssro_calib_timestamp=None,
save=True,
do_plots=False,
title=None,
fontsize=10,
post_select_QEC=False):
'''
Function that makes a bar plot with errorbars of MBI type data
'''
plt.rc('font', size=fontsize)
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 = CP.ConditionalParityAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata', post_select_QEC=False)
a.get_electron_ROC(ssro_calib_folder)
x_labels = a.sweep_pts.reshape(-1)
''' all data '''
c0, u_c0 = a.convert_fidelity_to_contrast(a.p0, a.u_p0)
x = range(len(c0))
if do_plots == True:
fig, ax = plt.subplots()
ax.bar(x, c0, yerr=u_c0, align='center', ecolor='k')
ax.set_xticks(x)
if title == None:
ax.set_title(str(folder) + '/' + str(timestamp))
else:
ax.set_title(title)
print x_labels
ax.set_xticklabels(x_labels.tolist())
ax.set_ylim(-1, 1)
ax.hlines([-1, 0, 1], x[0] - 1, x[-1] + 1, linestyles='dotted')
try:
fig.savefig(os.path.join(folder, 'tomo.png'))
fig.savefig(os.path.join(folder, title + '.pdf'),
format='pdf',
bbox_inches='tight')
except:
print 'Figure A has not been saved.'
''' postselected data '''
a = CP.ConditionalParityAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata', post_select_QEC=True)
a.get_electron_ROC(ssro_calib_folder, post_select_QEC=True)
c0_00, u_c0_00 = a.convert_fidelity_to_contrast(a.p0_00, a.u_p0_00)
c0_01, u_c0_01 = a.convert_fidelity_to_contrast(a.p0_01, a.u_p0_01)
c0_10, u_c0_10 = a.convert_fidelity_to_contrast(a.p0_10, a.u_p0_10)
c0_11, u_c0_11 = a.convert_fidelity_to_contrast(a.p0_11, a.u_p0_11)
x = range(len(c0_00))
if do_plots == True and plot_post_select == True:
fig_00, ax_00 = plt.subplots()
rects = ax_00.bar(x, c0_00, yerr=u_c0_00, align='center', ecolor='k')
# ax_00.bar(x,a.p0_00,yerr = u_c0_00,align = 'center',ecolor = 'k')
ax_00.set_xticks(x)
if title == None:
ax_00.set_title(str(folder) + '/' + str(timestamp) + '0')
else:
ax_00.set_title(str(title) + '0')
ax_00.set_xticklabels(x_labels.tolist())
# ax_00.set_ylim(-1,1)
ax_00.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(c0_00[ii], 2)) + '(' +
str(int(round(u_c0_00[ii] * 100))) + ')',
ha='center',
va='bottom')
autolabel(rects)
fig_01, ax_01 = plt.subplots()
rects = ax_01.bar(x, c0_01, yerr=u_c0_01, align='center', ecolor='k')
ax_01.set_xticks(x)
if title == None:
ax_01.set_title(str(folder) + '/' + str(timestamp) + '1')
else:
ax_01.set_title(str(title) + '1')
ax_01.set_xticklabels(x_labels.tolist())
# ax_01.set_ylim(-1,1)
ax_01.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(c0_01[ii], 2)) + '(' +
str(int(round(u_c0_01[ii] * 100))) + ')',
ha='center',
va='bottom')
autolabel(rects)
fig_10, ax_10 = plt.subplots()
rects = ax_10.bar(x, c0_10, yerr=u_c0_10, align='center', ecolor='k')
# ax_10.bar(x,a.p0_10,yerr = u_c0_10,align = 'center',ecolor = 'k')
ax_10.set_xticks(x)
if title == None:
ax_10.set_title(str(folder) + '/' + str(timestamp) + '0')
else:
ax_10.set_title(str(title) + '0')
ax_10.set_xticklabels(x_labels.tolist())
# ax_10.set_ylim(-1,1)
ax_10.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(c0_10[ii], 2)) + '(' +
str(int(round(u_c0_10[ii] * 100))) + ')',
ha='center',
va='bottom')
autolabel(rects)
fig_11, ax_11 = plt.subplots()
rects = ax_11.bar(x, c0_11, yerr=u_c0_11, align='center', ecolor='k')
ax_11.set_xticks(x)
if title == None:
ax_11.set_title(str(folder) + '/' + str(timestamp) + '1')
else:
ax_11.set_title(str(title) + '1')
ax_11.set_xticklabels(x_labels.tolist())
# ax_11.set_ylim(-1,1)
ax_11.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(c0_11[ii], 2)) + '(' +
str(int(round(u_c0_11[ii] * 100))) + ')',
ha='center',
va='bottom')
autolabel(rects)
try:
fig_00.savefig(os.path.join(folder,
str(title) + '0.pdf'),
format='pdf',
bbox_inches='tight')
fig_01.savefig(os.path.join(folder,
str(title) + '1.pdf'),
format='pdf',
bbox_inches='tight')
fig_10.savefig(os.path.join(folder,
str(title) + '0.pdf'),
format='pdf',
bbox_inches='tight')
fig_11.savefig(os.path.join(folder,
str(title) + '1.pdf'),
format='pdf',
bbox_inches='tight')
except:
print 'Figure B has not been saved.'
return x, c0, u_c0, c0_00, u_c0_00, c0_01, u_c0_01, c0_10, u_c0_10, c0_11, u_c0_11, x_labels, folder
