def save_DD_data():
from analysis.lib.m2.ssro import mbi; reload(mbi)
base_folder_lt3 = analysis_params.data_settings['base_folder_lt3']
lt3_folder = os.path.join(base_folder_lt3,'DDCalib')
lt3_ssro_folder = os.path.join(base_folder_lt3,'SSROs')
base_folder_lt4 = analysis_params.data_settings['base_folder_lt4']
lt4_folder = os.path.join(base_folder_lt4,'DDCalib')
lt4_ssro_folder = os.path.join(base_folder_lt4,'SSROs')
file_b = tb.latest_data(contains = 'sweep_decoupling',folder= lt3_folder)
file_a = tb.latest_data(contains = 'sweep_decoupling',folder =lt4_folder)
ssro_b = tb.latest_data(contains = 'SSROCalib', folder = lt3_ssro_folder)
ssro_a = tb.latest_data(contains = 'SSROCalib', folder = lt4_ssro_folder)
print file_b
a = mbi.MBIAnalysis(file_b)
a.get_sweep_pts()
a.get_readout_results(name='adwindata',CR_after_check = True)
a.get_electron_ROC(ssro_b)
a.save('ssro_results')
a = mbi.MBIAnalysis(file_a)
a.get_sweep_pts()
a.get_readout_results(name='adwindata',CR_after_check = True)
a.get_electron_ROC(ssro_a)
a.save('ssro_results')
def load_mult_dat(timestamp, number_of_msmts, ssro_calib_folder=''):
cum_pts = 0
for kk in range(number_of_msmts):
folder = toolbox.data_from_time(timestamp)
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='measurement' + str(kk))
a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder)
cum_pts += a.pts
if kk == 0:
cum_sweep_pts = np.linspace(2.0, 2.5, 51)#a.sweep_pts
cum_p0 = a.p0
cum_u_p0 = a.u_p0
else:
cum_sweep_pts = np.concatenate((cum_sweep_pts, np.linspace(2.0+kk*(50)*10e-3, 2.5+kk*(50)*10e-3, 51)))
cum_p0 = np.concatenate((cum_p0, a.p0))
cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0))
a.pts = cum_pts
a.sweep_pts = cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
return a, folder
def load_mult_dat(timestamps, number_of_msmts, ssro_calib_folders=['']):
cum_pts = 0
for tt in range(len(timestamps)):
for kk in range(number_of_msmts[tt]):
folder = toolbox.data_from_time(timestamps[tt])
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='measurement' + str(kk))
a.get_electron_ROC(ssro_calib_folder=ssro_calib_folders[tt])
cum_pts += a.pts
if kk == 0 and tt==0:
cum_sweep_pts = np.linspace(2.0, 2.2, 51)#a.sweep_pts
cum_p0 = a.p0
cum_u_p0 = a.u_p0
elif tt==0:
cum_sweep_pts = np.concatenate((cum_sweep_pts, np.linspace(2.0+kk*(50)*4e-3, 2.2+kk*(50)*4e-3, 51)))
cum_p0 = np.concatenate((cum_p0, a.p0))
cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0))
elif tt==1:
cum_sweep_pts = np.concatenate((cum_sweep_pts, np.linspace(2.0+(kk+150)*(50)*4e-3, 2.2+(kk+150)*(50)*4e-3, 51)))
cum_p0 = np.concatenate((cum_p0, a.p0))
cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0))
a.pts = cum_pts
a.sweep_pts = cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
return a, folder
def fit_correlation_parabolic(folder, ax, *args, **kw):
which_correlation = kw.pop('which_correlation', 2)
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_correlations(name='adwindata')
a.plot_results_vs_sweepparam(ax=ax, mode='correlations')
x = a.sweep_pts.reshape(-1)[:]
y = a.normalized_correlations[:, which_correlation]
x0 = fit.Parameter(args[0], 'x0')
of = fit.Parameter(args[1], 'of')
a = fit.Parameter(args[2], 'a')
fitfunc_str = '(1-of) + a (x-x0)**2'
def fitfunc_parabolic(x):
return (1. - of()) + a() * (x - x0())**2
fit_result = fit.fit1d(x,
y,
None,
p0=[of, a, x0],
fitfunc=fitfunc_parabolic,
fitfunc_str=fitfunc_str,
do_print=True,
ret=True)
plot.plot_fit1d(fit_result,
np.linspace(x[0], x[-1], 201),
ax=ax,
plot_data=False,
print_info=False)
return fit_result
def phase_offset_after_LDE(contains='', **kw):
'''
gets data from a folder whose name contains the contains variable.
Does or does not fit the data with a gaussian function
'''
### folder choice
if contains == '':
contains = 'phase_offset_after_LDE'
# older_than = kw.get('older_than',None) automatically handled by kws
### acquire data
f = toolbox.latest_data(contains, **kw)
a = mbi.MBIAnalysis(f)
print 'this is the timestamp ', get_tstamp_from_folder(f)
ro_array = ['positive', 'negative']
x, y, y_u = get_pos_neg_data(a, adwindata_str='', ro_array=ro_array, **kw)
y = np.round(y, decimals=2)
y_u = np.round(y_u, decimals=2)
# print el,x,y,y_u ### for debugging
data = [0, 0, 0]
### put output string together
for jj, res, res_u in zip(range(3), y, y_u):
data[jj] = cp.deepcopy(str(res) + " +/- " + str(res_u))
row_format = "{:>18}" * (len(x))
headline_format = "{:>18}" * len(x)
print headline_format.format(*x)
print "-------------------------------------------------------------------------"
print row_format.format(*data)
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 load_mult_dat(tau, number_of_msmts, N_steps=4,ssro_calib_folder=''):
cum_pts = 0
for kk in range(number_of_msmts):
folder = toolbox.latest_data(contains=str(tau), older_than='140424')
# print folder
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='measurement'+ str(kk))
a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder)
cum_pts += a.pts
pts = 11
N_start = (kk+0) * (pts-1)*N_steps
N_end = (kk+1+0) * (pts-1)*N_steps
N_list = np.linspace(N_start, N_end, pts)
if kk == 0:
cum_sweep_pts = np.linspace(N_start, N_end, 11)#a.sweep_pts
cum_p0 = a.p0
cum_u_p0 = a.u_p0
else:
cum_sweep_pts = np.concatenate((cum_sweep_pts, np.linspace(N_start,N_end,11)))
cum_p0 = np.concatenate((cum_p0, a.p0))
cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0))
a.pts = cum_pts
a.sweep_pts = cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
return a, folder
def epulse_fidelity(folder, ax, *args):
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC()
a.plot_results_vs_sweepparam(ax=ax, name='adwindata')
x = a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
of = fit.Parameter(args[0], 'of')
fitfunc_str = '(1-of)'
def fitfunc_fid(x):
return (1. - of())
fit_result = fit.fit1d(x,
y,
None,
p0=[of],
fitfunc=fitfunc_fid,
fitfunc_str=fitfunc_str,
do_print=True,
ret=True)
plot.plot_fit1d(fit_result,
np.linspace(x[0], x[-1], 201),
ax=ax,
plot_data=False,
print_info=False)
return fit_result
def load_mult_dat(timestamp):
cum_pts = 0
for kk in range(len(timestamp)):
folder = toolbox.data_from_time(timestamp[kk])
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC()
cum_pts += a.pts
if kk == 0:
cum_sweep_pts = a.sweep_pts
cum_p0 = a.p0
cum_u_p0 = a.u_p0
else:
cum_sweep_pts = np.concatenate((cum_sweep_pts, a.sweep_pts))
cum_p0 = np.concatenate((cum_p0, a.p0))
cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0))
a.pts = cum_pts
a.sweep_pts = cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
return a
def fit_linear(folder, ax, value, *args):
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC()
a.plot_results_vs_sweepparam(ax=ax, name='adwindata')
x = a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
a = fit.Parameter(args[0], 'a')
b = fit.Parameter(args[0], 'b')
fitfunc_str = 'a x + b'
def fitfunc(x):
return a() * x + b()
fit_result = fit.fit1d(x,
y,
None,
p0=[a, b],
fitfunc=fitfunc,
fitfunc_str=fitfunc_str,
do_print=True,
ret=True)
plot.plot_fit1d(fit_result,
np.linspace(x[0], x[-1], 201),
ax=ax,
plot_data=False,
print_info=False)
return fit_result
def fit_population_vs_detuning(folder, ax, *args):
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC(
) # a.get_N_ROC(0.97,0.03,0.96,0.01,0.93,0.01)#(0.99, 0.02, 0.94, 0.005)
ax = a.plot_results_vs_sweepparam(ret='ax', name='adwindata')
x = a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
guess_a = 1
guess_A = -0.8
guess_F = 0.005
guess_x0 = args[0]
fit_result = fit.fit1d(x,
y,
rabi.fit_population_vs_detuning,
guess_a,
guess_A,
guess_F,
guess_x0,
fixed=[],
do_print=True,
ret=True)
plot.plot_fit1d(fit_result,
np.linspace(a.sweep_pts[0], a.sweep_pts[-1], 201),
ax=ax,
plot_data=False)
return fit_result
def load_mult_dat(timestamp,
number_of_msmts,
x_axis_start = 2.0,
x_axis_step = 1.0,
x_axis_pts_per_msmnt= 101,
ssro_calib_folder =''):
'''
function to load and combine multiple msmts.
'''
cum_pts = 0
for kk in range(number_of_msmts):
folder = toolbox.data_from_time(timestamp)
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='measurement' + str(kk))
a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder)
cum_pts += a.pts
if kk == 0:
cum_sweep_pts = np.linspace(x_axis_start, x_axis_start+x_axis_step, x_axis_pts_per_msmnt)#a.sweep_pts
cum_p0 = a.p0
cum_u_p0 = a.u_p0
else:
cum_sweep_pts = np.concatenate((cum_sweep_pts, np.linspace(x_axis_start+kk*x_axis_step, x_axis_start+(kk+1)*x_axis_step, x_axis_pts_per_msmnt)))
cum_p0 = np.concatenate((cum_p0, a.p0))
cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0))
a.pts = cum_pts
a.sweep_pts = cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
return a, folder
def get_CR_histos(
contains='',
timestamp=None,
):
if timestamp != None:
folder = toolbox.data_from_time(timestamp)
else:
folder = toolbox.latest_data(contains)
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC()
before, after = a.get_CR_before_after()
fig = plt.figure()
ax = plt.subplot()
ax.hist(before,
abs(max(before) - min(before) + 1),
normed=True,
label='before')
ax.hist(after,
abs(max(after) - min(after) + 1),
normed=True,
label='after')
ax.set_title(a.default_plot_title)
ax.set_xlabel('counts during CR check')
ax.set_ylabel('probability')
plt.legend()
plt.show()
plt.close('all')
def fast_pi2():
folder = toolbox.latest_data('cal_fast_pi_over_2')
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC()
#a.plot_results_vs_sweepparam(ax=ax, name='adwindata')
x = a.sweep_pts
y = a.p0.reshape(-1)
u_y = a.u_p0.reshape(-1)
n = a.sweep_name
x2 = x[::2]
y2 = y[1::2] - y[::2]
u_y2 = np.sqrt(u_y[1::2]**2 + u_y[::2]**2)
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4), sharex=True)
ax1.errorbar(x2, y2, yerr=u_y2, fmt='o')
ax1.set_xlabel(n)
ax1.set_title('Difference btw. Pi/2-Pi and Pi/2' + '\n' + a.timestamp)
ax1.set_ylabel('Difference')
m = fit.Parameter((y[-1] - y[0]) / (x[-1] - x[0]), 'm')
x0 = fit.Parameter(x2.mean(), 'x0')
p0 = [m, x0]
def ff(x):
return m() * (x - x0())
fitfunc_str = 'm * (x - x0)'
fit_result = fit.fit1d(x2,
y2,
None,
p0=p0,
fitfunc=ff,
fitfunc_str=fitfunc_str,
do_print=True,
ret=True)
ax2.errorbar(x2, y[0::2], yerr=u_y[0::2], fmt='o', label='Pi/2')
ax2.errorbar(x2, y[1::2], yerr=u_y[1::2], fmt='o', label='Pi/2 - Pi')
ax2.legend(frameon=True, framealpha=0.5)
ax2.set_ylabel('P(0)')
ax2.set_xlabel(n)
if fit_result != False:
ax2.axvline(x0(), c='k', lw=2)
ax2.axhline(0.5, c='k', lw=2)
ax2.set_title('X marks the spot')
plot.plot_fit1d(fit_result,
np.linspace(x2[0], x2[-1], 201),
ax=ax1,
plot_data=False,
print_info=True)
return x0(), 0
def get_and_plot_data_nuc_RO(timestamp_list_pos, timestamp_list_neg, ssro_calib_folder):
for ii, timestamp in enumerate(timestamp_list_pos):
folder = toolbox.data_from_time(timestamp)
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC(ssro_calib_folder)
a.x = a.sweep_pts.reshape(-1)[:]
a.sweep_pts = range(len(a.p0))
folder = toolbox.data_from_time(timestamp_list_neg[ii])
b = mbi.MBIAnalysis(folder)
b.get_sweep_pts()
b.get_readout_results(name='adwindata')
b.get_electron_ROC(ssro_calib_folder)
### Combine positive/negative data
a.p0 = ( (2*a.p0-1) - (2*b.p0-1))/2.
a.u_p0 = (a.u_p0**2 + a.u_p0**2)**0.5
# if ii==0:
# ax = a.plot_results_vs_sweepparam(ret='ax', markersize = 4, save=False, fmt = 'o')
# ax.set_ylim(-1.05,1.05)
# ax.set_xlim(a.sweep_pts[0]-0.1,a.sweep_pts[-1]+0.1)
# ax.axhspan(0,1,fill=False,ls='dotted')
# ax.axhspan(-1,0,fill=False,ls='dotted')
# else:
# a.plot_results_vs_sweepparam(ax= ax, markersize = 4, save=False, fmt = 'o')
# ax.set_ylim(-1.05,1.05)
if ii==0:
p0_sum = a.p0
u_p0_sum = a.u_p0**2
else:
p0_sum = p0_sum + a.p0
u_p0_sum = u_p0_sum + a.u_p0**2
a.p0 = p0_sum/len(timestamp_list_pos)
a.u_p0 = (u_p0_sum**0.5) / len(timestamp_list_pos)
a.p0 = a.p0.reshape(-1)[:]
a.u_p0 = a.u_p0.reshape(-1)[:]
return a, folder
def get_RO_results(folder, ssro_calib_folder):
a = mbi.MBIAnalysis(folder)
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)[:]
return y_a, y_err_a
def get_data(name_contains,
input_timestamp=None,
input_id=None,
ssro_calib_folder=''):
'''
Retrieves msmt data for a SINGLE loop in SimpleDecoupling, i.e. 'tot' = 1.
Inputs:
- String containing an element of the file name
- (Optional): timestamp. Default is latest data
Returns:
- 'x': array with sweeped parameter values
- 'y': array with msmt outcomes (corrected for SSRO fidelity)
- 'yerr': array with msmt errors
- 'folder': path of data file
- (optional)'timestamp': timestamp corresponding to data. Returned by default unless a timestamp is specified
- (optional) 'ssro_calib_folder': path of the corresponding ssro calibration file. If '', latest calibration is used
'''
if input_timestamp != None:
folder = toolbox.data_from_time(input_timestamp)
else:
timestamp, folder = toolbox.latest_data(name_contains,
return_timestamp=True)
a = mbi.MBIAnalysis(folder)
#print 'DATA FOLDER & SSRO FOLDER:'
#print folder
#ax = a.plot_results_vs_sweepparam(ret='ax', )
# Retrieve data & reshape
if input_id != None:
name = 'measurement' + str(input_id)
adwingrp = a.adwingrp(name=name)
a.adgrp = adwingrp
sweep = a.adgrp.attrs['sweep_pts']
x = sweep.reshape(-1)[:]
a.get_readout_results(name=name)
a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder)
y = a.p0.reshape(-1)[:]
yerr = a.u_p0.reshape(-1)[:]
else:
a.get_sweep_pts()
a.get_readout_results(name='measurement0')
a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder)
x = a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
yerr = a.u_p0.reshape(-1)[:]
if input_timestamp != None:
return x, y, yerr, folder
else:
return x, y, yerr, folder, timestamp
def analyse_pulse_calibration(angle='_pi_1', timestamp=None, guess_x0=None):
### parameters
if guess_x0 == None:
if angle == '_pi_1':
guess_x0 = 0.38
elif angle == '_pi_o':
guess_x0 = 0.24
elif angle == '_pi_p1':
guess_x0 = 0.67
angle = '_pi_1'
else:
guess_x0 = 0.5
msmt_type = 'sequence'
guess_of = 0.973
guess_a = 0.
### script
if timestamp != None:
folder = toolbox.data_from_time(timestamp)
else:
folder = toolbox.latest_data(angle)
if msmt_type == 'sequence':
a = sequence.SequenceAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results('ssro')
a.get_electron_ROC()
ax = a.plot_result_vs_sweepparam(ret='ax')
x = a.sweep_pts
y = a.p0
elif msmt_type == 'mbi':
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC()
ax = a.plot_results_vs_sweepparam(name='adwindata', ret='ax')
ax.set_ylim(-0.1, 1)
x = a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
else:
raise Exception('Unknown msmt type')
res = funcs.calibrate_pulse_amplitude(x, y, ax, guess_x0, guess_of,
guess_a)
plt.savefig(os.path.join(folder, 'pulse_calibration.pdf'), format='pdf')
plt.savefig(os.path.join(folder, 'pulse_calibration.png'), format='png')
def calibrate_epulse_rabi(folder, ax, *args, **kws):
fit_x0 = kws.pop('fit_x0', True)
fit_k = kws.pop('fit_k', True)
double_ro = kws.pop('double_ro', 'False')
guess_x0 = kws.pop('guess_x0', 0)
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC()
a.plot_results_vs_sweepparam(ax=ax, name='adwindata')
x = a.sweep_pts.reshape(-1)[:]
if double_ro == 'electron':
y = a.p0[:, 0]
elif double_ro == 'nitrogen':
y = a.p0[:, 1]
else:
y = a.p0.reshape(-1)[:]
f = fit.Parameter(args[0], 'f')
A = fit.Parameter(args[1], 'A')
x0 = fit.Parameter(guess_x0, 'x0')
k = fit.Parameter(0, 'k')
p0 = [f, A]
if fit_x0:
p0.append(x0)
if fit_k:
p0.append(k)
fitfunc_str = '(1 - A) + A * exp(-kx) * cos(2pi f (x - x0))'
def fitfunc(x):
return (1.-A()) + A() * np.exp(-k()*x) * \
np.cos(2*np.pi*f()*(x - x0()))
fit_result = fit.fit1d(x,
y,
None,
p0=p0,
fitfunc=fitfunc,
fitfunc_str=fitfunc_str,
do_print=True,
ret=True)
plot.plot_fit1d(fit_result,
np.linspace(x[0], x[-1], 201),
ax=ax,
plot_data=False,
print_info=False)
return fit_result
def get_data(name_contains):
folder = toolbox.latest_data(name_contains)
print folder
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='measurement0')
a.get_electron_ROC()
#ax = a.plot_results_vs_sweepparam(ret='ax', )
t_shift = 0
# t_start=0
# t_0=10
x = a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
return x, y, folder
def fingerprint_loop(older_than=None,
newer_than=None,
contains='',
number=0,
filename='loop'):
fig = figure(number, figsize=(10, 5))
ax = fig.add_subplot(111)
histdata_1521 = []
histdata_1531 = []
# ssro_calib_folders = ['d:\\measuring\\data\\20140504\\070533_AdwinSSRO_SSROCalibration_Hans_sil1']
## Data location ##
while toolbox.latest_data(contains=contains,
older_than=older_than,
newer_than=newer_than,
raise_exc=False) != False:
timestamp, folder = toolbox.latest_data(contains=contains,
older_than=older_than,
newer_than=newer_than,
return_timestamp=True)
ssro_calib_folder = toolbox.latest_data(
contains='AdwinSSRO_SSROCalibration', older_than='20140502193810')
## Data location ##
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC(ssro_calib_folder)
# ############
# ## Plotting ###
# # ############
# print folder
x = a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
y_error = a.u_p0.reshape(-1)[:]
# ax.errorbar(x,y,y_error)
older_than = str(int(timestamp) - 1)
idx_1521 = np.argmin(abs(x - 15.21))
idx_1531 = np.argmin(abs(x - 15.31))
if y[idx_1521] < 0.8:
histdata_1521.append(y[idx_1521])
histdata_1531.append(y[idx_1531])
ax.errorbar(x, y, y_error)
print y_error
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 el_to_c_swap(contains='', input_el=['Z'], do_fit=False, **kw):
'''
gets data from a folder whose name contains the contains variable.
Does or does not fit the data with a gaussian function
'''
### folder choice
if contains == '':
contains = 'Swap_el_to_C'
# older_than = kw.get('older_than',None) automatically handled by kws
### acquire data
f = toolbox.latest_data(contains, **kw)
a = mbi.MBIAnalysis(f)
print 'this is the timestamp ', get_tstamp_from_folder(f)
# data = np.empty([3,len(input_el)],dtype=str)
data = []
for i in range(len(input_el)):
data.append([0, 0, 0])
for ii, el in enumerate(input_el):
# data.append([0,0,0])
data_strings = []
ro_str = 'el_state_' + el + '_'
ro_array = ['positive', 'negative']
x, y, y_u = get_pos_neg_data(a,
adwindata_str=ro_str,
ro_array=ro_array,
**kw)
y = np.round(y, decimals=2)
y_u = np.round(y_u, decimals=2)
# print el,x,y,y_u ### for debugging
### put output string together
for jj, res, res_u in zip(range(3), y, y_u):
data[ii][jj] = cp.deepcopy(str(res) + " +/- " + str(res_u))
row_format = "{:>18}" * (len(x) + 1)
headline_format = "{:>12}" + "{:>18}" * len(x)
print headline_format.format("", *x)
for el, row in zip(input_el, data):
print "--------------------------------------------------------------------------------------------------"
print row_format.format(el + ' |', *row)
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 fingerprint(timestamp=None,
measurement_name=['adwindata'],
show_guess=True):
''' Function to analyze simple fingerprint measurements.
Inputs:
timestamp: in format yyyymmdd_hhmmss or hhmmss or None.
measurement_name: list of measurement names
'''
if timestamp != None:
folder = toolbox.data_from_time(timestamp)
else:
folder = toolbox.latest_data('DecouplingSequence')
fit_results = []
for k in range(0, len(measurement_name)):
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(measurement_name[k])
a.get_electron_ROC()
ax = a.plot_results_vs_sweepparam(ret='ax')
x = a.sweep_pts.reshape(-1)[:]
y = a.p0.reshape(-1)[:]
# p0, fitfunc, fitfunc_str = common.fit_decaying_cos(frequency,offset, amplitude, phase, decay_constant)
#plot the initial guess
# if show_guess:
# ax.plot(np.linspace(0,x[-1],201), fitfunc(np.linspace(0,x[-1],201)), ':', lw=2)
# fit_result = fit.fit1d(x,y, None, p0=p0, fitfunc=fitfunc, do_print=True, ret=True,fixed=[3])
# ## plot data and fit as function of total time
# if plot_fit == True:
# plot.plot_fit1d(fit_result, np.linspace(0,x[-1],201), ax=ax, plot_data=False)
# fit_results.append(fit_result)
plt.savefig(os.path.join(folder, 'analyzed_result.pdf'), format='pdf')
plt.savefig(os.path.join(folder, 'analyzed_result.png'), format='png')
return
def 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 calibrate_epulse_amplitude(folder, ax, *args, **kw):
double_ro = kw.pop('double_ro', 'False')
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='adwindata')
a.get_electron_ROC()
a.plot_results_vs_sweepparam(ax=ax, name='adwindata')
x = a.sweep_pts.reshape(-1)[:]
if double_ro == 'electron':
y = a.p0[:, 0]
elif double_ro == 'nitrogen':
y = a.p0[:, 1]
else:
y = a.p0.reshape(-1)[:]
x0 = fit.Parameter(args[0], 'x0')
of = fit.Parameter(args[1], 'of')
a = fit.Parameter(args[2], 'a')
fitfunc_str = '(1-of) + a (x-x0)**2'
def fitfunc_parabolic(x):
return (1. - of()) + a() * (x - x0())**2
fit_result = fit.fit1d(x,
y,
None,
p0=[of, a, x0],
fitfunc=fitfunc_parabolic,
fitfunc_str=fitfunc_str,
do_print=True,
ret=True)
plot.plot_fit1d(fit_result,
np.linspace(x[0], x[-1], 201),
ax=ax,
plot_data=False,
print_info=False)
return fit_result
def load_mult_dat_tag(tag,
older_than,
number_of_msmts,
ssro_calib_folder='',
start=3.0,
pts=51,
step_size=10e-3):
cum_pts = 0
for kk in range(number_of_msmts):
folder = toolbox.latest_data(contains=tag,
older_than=older_than,
folder='d:\measuring\data')
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results(name='measurement' + str(kk))
a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder)
cum_pts += a.pts
# print a.reps
if kk == 0:
cum_sweep_pts = np.linspace(start, start + (pts - 1) * step_size,
pts)
cum_p0 = a.p0
cum_u_p0 = a.u_p0
else:
cum_sweep_pts = np.concatenate(
(cum_sweep_pts,
np.linspace(
start + kk * (pts - 1) * step_size, start +
(pts - 1) * step_size + kk * (pts - 1) * step_size, pts)))
cum_p0 = np.concatenate((cum_p0, a.p0))
cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0))
a.pts = cum_pts
a.sweep_pts = cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
return a, folder
def load_mult_dat(timestamp, ssro_calib_folder='', data_folder=None):
'''
function to load and combine multiple msmts.
'''
cum_pts = 0
kk = 0
while True:
folder = toolbox.data_from_time(timestamp, folder=data_folder)
a = mbi.MBIAnalysis(folder)
a.get_sweep_pts()
try:
a.get_readout_results(name='measurement' + str(kk))
except:
print 'found no more data, stopping the loop after {} datasets'.format(
kk)
break
a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder)
cum_pts += a.pts
if kk == 0:
cum_p0 = a.p0
cum_u_p0 = a.u_p0
else:
cum_p0 = np.concatenate((cum_p0, a.p0))
cum_u_p0 = np.concatenate((cum_u_p0, a.u_p0))
kk += 1
print 'Number of datasets is', kk
step = a.sweep_pts[-1] - a.sweep_pts[0]
pts_per_msmt = len(a.sweep_pts)
x_axis_start = a.sweep_pts[-1] - step * (kk)
cum_sweep_pts = np.linspace(x_axis_start, a.sweep_pts[-1], cum_pts)
a.pts = cum_pts
a.sweep_pts = cum_sweep_pts
a.p0 = cum_p0
a.u_p0 = cum_u_p0
return a, folder
def tomo_analysis(contains="tomo", name="", **kw):
# older_than = kw.get('older_than',None) automatically handled by kws
### acquire data
f = toolbox.latest_data(contains, **kw)
a = mbi.MBIAnalysis(f)
ro_array = ['positive', 'negative']
x, y, y_u = get_pos_neg_data(a,
adwindata_str=name,
ro_array=ro_array,
**kw)
x = ["".join(bases) for bases in x]
xlabel = a.g.attrs['sweep_name']
ylabel = "Expectation value"
fig, ax = create_plot(f,
xlabel=xlabel,
ylabel=ylabel,
title='Delay feedback + tomography')
fake_x = np.arange(len(x))
rects = ax.bar(fake_x, y, yerr=y_u, align='center', ecolor='k')
ax.set_xticks(fake_x)
ax.set_xticklabels(x)
ax.set_ylim(-1.0, 1.0)
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_u[ii] * 100))) + ')',
ha='center',
va='bottom')
autolabel(rects)
save_and_close_plot(f)
