def RO_correction_of_correlators(correlators_per_sweep_pt,electron_transitions,E_RO_durations,ssro_a,ssro_b,**kw):
verbose = kw.pop('verbose',False)
do_ROC = kw.pop('do_ROC',True)
### to store the estimated statistical uncertainty
norm_correlators_u = np.zeros(np.shape(correlators_per_sweep_pt))
norm_correlators = np.zeros(np.shape(correlators_per_sweep_pt))
if do_ROC:
### get ssro_ROC for LT3 --> corresponds to setup B
F0_LT3,F1_LT3 = get_RO_fidelities(ssro_b,electron_transitions[1],E_RO_durations[1])
### get ssro_ROC for LT4 --> corresponds to setup A
F0_LT4,F1_LT4 = get_RO_fidelities(ssro_a,electron_transitions[0],E_RO_durations[0])
for j, corrs in zip([0,1],correlators_per_sweep_pt):
for i, corr in enumerate(corrs):
#### note that the function below assumes an error of 1% on the SSRO fidelities!
norm_correlator,norm_correlator_u = sscorr.ssro_correct_twoqubit_state_photon_numbers(np.array(corr),F0_LT4,F0_LT3,F1_LT4,F1_LT3,
verbose = verbose,return_error_bars = True)
norm_correlators[j,i] = np.squeeze(norm_correlator)
norm_correlators_u[j,i] = norm_correlator_u
else:
for j, corrs in zip([0,1],correlators_per_sweep_pt):
for i, corr in enumerate(corrs):
norm_correlators[j,i] = np.array(corr,dtype = np.float64)/np.sum(np.array(corr))
norm_correlators_u[j,i] = np.array(np.sqrt(corr),dtype = np.float64)/np.sum(np.array(corr))
return norm_correlators,norm_correlators_u
def ro_c_F_odd(corr, F0a, F0b, F1a, F1b, dF0a, dF0b, dF1a, dF1b, ro_correct=True):
if ro_correct:
roc=sscorr.ssro_correct_twoqubit_state_photon_numbers(corr, F0a, F0b, F1a, F1b,
dF0a=dF0a, dF0b=dF0b, dF1a=dF1a, dF1b=dF1b, verbose=False)
return (roc[1][0]+roc[2][0])
else:
N=float(corr.sum())
return (corr[1]/N+corr[2]/N)
def readout_correction(self, F0_1=0.917, uF0_1=0.003, F1_1=0.993,
uF1_1=0.001, F0_2=0.809, uF0_2=0.007, F1_2=0.985, uF1_2=0.011):
# print ''
# print 'psi1:', self.psi1[::-1]
p1, up1 = sscorr.ssro_correct_twoqubit_state_photon_numbers(
self.psi1[::-1], F0_1, F0_2, F1_1, F1_2, dF0a=uF0_1, dF1a=uF1_1,
dF0b=uF0_2, dF1b=uF1_2, return_error_bars=True, verbose=False)
self.psi1_corrected = p1[::-1].reshape(-1)
self.u_psi1_corrected = up1[::-1]
# print 'psi2:', self.psi2[::-1]
p2,up2 = sscorr.ssro_correct_twoqubit_state_photon_numbers(
self.psi2[::-1], F0_1, F0_2, F1_1, F1_2, dF0a=uF0_1, dF1a=uF1_1,
dF0b=uF0_2, dF1b=uF1_2, return_error_bars=True, verbose=False)
self.psi2_corrected = p2[::-1].reshape(-1)
self.u_psi2_corrected = up2[::-1]
def readout_correction(self,
F0_1=0.917,
uF0_1=0.003,
F1_1=0.993,
uF1_1=0.001,
F0_2=0.809,
uF0_2=0.007,
F1_2=0.985,
uF1_2=0.011):
# print ''
# print 'psi1:', self.psi1[::-1]
p1, up1 = sscorr.ssro_correct_twoqubit_state_photon_numbers(
self.psi1[::-1],
F0_1,
F0_2,
F1_1,
F1_2,
dF0a=uF0_1,
dF1a=uF1_1,
dF0b=uF0_2,
dF1b=uF1_2,
return_error_bars=True,
verbose=False)
self.psi1_corrected = p1[::-1].reshape(-1)
self.u_psi1_corrected = up1[::-1]
# print 'psi2:', self.psi2[::-1]
p2, up2 = sscorr.ssro_correct_twoqubit_state_photon_numbers(
self.psi2[::-1],
F0_1,
F0_2,
F1_1,
F1_2,
dF0a=uF0_1,
dF1a=uF1_1,
dF0b=uF0_2,
dF1b=uF1_2,
return_error_bars=True,
verbose=False)
self.psi2_corrected = p2[::-1].reshape(-1)
self.u_psi2_corrected = up2[::-1]
def plot(self,save_path=r'D:\analysis\output'):
ZZ_corr_err=sscorr.get_correlation_errors(self.ZZ_corr)
XX_corr_err=sscorr.get_correlation_errors(self.XX_corr)
XmX_corr_err=sscorr.get_correlation_errors(self.XmX_corr)
fig=plt.figure()
plt.subplot(231)
sscorr.plot_uncorrected(self.ZZ_corr, ZZ_corr_err)
plt.subplot(232)
sscorr.plot_uncorrected(self.XX_corr, XX_corr_err)
plt.subplot(233)
sscorr.plot_uncorrected(self.XmX_corr, XmX_corr_err)
ZZ_c_corr, ZZ_c_corr_err=sscorr.ssro_correct_twoqubit_state_photon_numbers(self.ZZ_corr,
self.F0a, self.F0b, self.F1a, self.F1b,
dF0a=self.dF0a, dF0b=self.dF0b, dF1a=self.dF1a, dF1b=self.dF1b,
verbose=False, return_error_bars=True)
XX_c_corr, XX_c_corr_err=sscorr.ssro_correct_twoqubit_state_photon_numbers(self.XX_corr,
self.F0a, self.F0b, self.F1a, self.F1b,
dF0a=self.dF0a, dF0b=self.dF0b, dF1a=self.dF1a, dF1b=self.dF1b,
verbose=False, return_error_bars=True)
XmX_c_corr, XmX_c_corr_err=sscorr.ssro_correct_twoqubit_state_photon_numbers(self.XmX_corr,
self.F0a, self.F0b, self.F1a, self.F1b,
dF0a=self.dF0a, dF0b=self.dF0b, dF1a=self.dF1a, dF1b=self.dF1b,
verbose=False, return_error_bars=True)
plt.subplot(234)
sscorr.plot_corrected(ZZ_c_corr, ZZ_c_corr_err)
plt.subplot(235)
sscorr.plot_corrected(XX_c_corr, XX_c_corr_err)
plt.subplot(236)
sscorr.plot_corrected(XmX_c_corr, XmX_c_corr_err)
plt.suptitle('Correlations for state '+self.state+' with w_start ' + str(self.w_start) +\
', w_length ' +str(self.w_length)+ ', w_dt ' + str(self.w_dt) + \
'\n and Fidelity F='+str(self.F)+'+/-'+str(self.dF))
fig.set_size_inches(12,12)
fig.savefig(os.path.join(save_path,'fidelity'+'_'+self.state+'.pdf'))
return fig
def ro_c_F_S(corr, F0a, F0b, F1a, F1b, dF0a, dF0b, dF1a, dF1b, ro_correct=True):
if ro_correct:
roc=sscorr.ssro_correct_twoqubit_state_photon_numbers(corr, F0a, F0b, F1a, F1b,
dF0a=dF0a, dF0b=dF0b, dF1a=dF1a, dF1b=dF1b, verbose=False)
val=roc[0][0]*roc[3][0]
if val > 0:
return np.sqrt(val)
else:
return 0.0
else:
N=float(corr.sum())
val=(corr[0]/N*corr[3]/N)
if val > 0:
return np.sqrt(val)
else:
return 0.0
def _get_corrected_correlations(self, correlations, mod, *rofidelities):
_c, _u_c = sscorr.ssro_correct_twoqubit_state_photon_numbers(
correlations[::-1], *rofidelities, verbose=False)
"""
perform readout correction on a histogram, with given SSRO fidelities
and uncertainties. depending on mode, enforces positive probabilities,
keeping the sum at 1 at the expense of others (depends on mode).
"""
c = _c[::-1].reshape(-1)
u_c = _u_c[::-1].reshape(-1)
def mod_none(c, u_c):
return c, u_c
def mod_nonegatives_compensate_proportionally(c, u_c):
neg = c < 0.
total = c[neg].sum()
c[np.logical_not(neg)] /= (1. + float(total))
c[neg] = 0.
return c, u_c
# NOTE not universal; would not be too hard to rewrite, but since not
# necessary, i'm too lazy now; -wolfgang
def mod_nonegatives_compensate_opposite_parity(c, u_c):
if c[3] < 0:
c[1] -= abs(c[3] / 2.)
c[2] -= abs(c[3] / 2.)
c[3] = 0
return c, u_c
modifiers = {
None: mod_none,
'lowerbound': mod_nonegatives_compensate_opposite_parity,
'bestguess': mod_none,
}
return modifiers[mod](c, u_c)
def _get_corrected_correlations(self, correlations, mod, *rofidelities):
_c,_u_c = sscorr.ssro_correct_twoqubit_state_photon_numbers(
correlations[::-1], *rofidelities, verbose=False)
"""
perform readout correction on a histogram, with given SSRO fidelities
and uncertainties. depending on mode, enforces positive probabilities,
keeping the sum at 1 at the expense of others (depends on mode).
"""
c = _c[::-1].reshape(-1)
u_c = _u_c[::-1].reshape(-1)
def mod_none(c,u_c):
return c, u_c
def mod_nonegatives_compensate_proportionally(c,u_c):
neg = c < 0.
total = c[neg].sum()
c[np.logical_not(neg)] /= (1.+float(total))
c[neg] = 0.
return c, u_c
# NOTE not universal; would not be too hard to rewrite, but since not
# necessary, i'm too lazy now; -wolfgang
def mod_nonegatives_compensate_opposite_parity(c,u_c):
if c[3] < 0:
c[1] -= abs(c[3]/2.)
c[2] -= abs(c[3]/2.)
c[3] = 0
return c, u_c
modifiers = {
None : mod_none,
'lowerbound' : mod_nonegatives_compensate_opposite_parity,
'bestguess' : mod_none,
}
return modifiers[mod](c,u_c)
u_c_xmx=u_MLE_psi2xmx
if estimate[-3:]=='yes':
uub_c_zz=uub_MLE_psi2zz
uub_c_xx=uub_MLE_psi2xx
uub_c_xmx=uub_MLE_psi2xmx
ulb_c_zz=ulb_MLE_psi2zz
ulb_c_xx=ulb_MLE_psi2xx
ulb_c_xmx=ulb_MLE_psi2xmx
u_zz=sscorr.get_correlation_errors(zz)
u_xx=sscorr.get_correlation_errors(xx)
u_xmx=sscorr.get_correlation_errors(xmx)
if estimate=='ro_correct':
c_zz, u_c_zz=sscorr.ssro_correct_twoqubit_state_photon_numbers(zz[::-1],
F0a, F0b, F1a, F1b,
dF0a=dF0a, dF0b=dF0b, dF1a=dF1a, dF1b=dF1b,
verbose=False, return_error_bars=True)
c_xx,u_c_xx=sscorr.ssro_correct_twoqubit_state_photon_numbers(xx[::-1],
F0a, F0b, F1a, F1b,
dF0a=dF0a, dF0b=dF0b, dF1a=dF1a, dF1b=dF1b,
verbose=False, return_error_bars=True)
c_xmx, u_c_xmx=sscorr.ssro_correct_twoqubit_state_photon_numbers(xmx[::-1],
F0a, F0b, F1a, F1b,
dF0a=dF0a, dF0b=dF0b, dF1a=dF1a, dF1b=dF1b,
verbose=False, return_error_bars=True)
c_zz=c_zz[::-1].reshape(-1)
c_xx=c_xx[::-1].reshape(-1)
c_xmx=c_xmx[::-1].reshape(-1)
u_c_zz=u_c_zz[::-1]
u_c_xx=u_c_xx[::-1]
u_c_xmx=u_c_xmx[::-1]
def correlate_RO_results(self,
apply_ROC=False,
verbose=True,
return_value=False):
self.RO_data_LT3_plus = []
self.RO_data_LT3_minus = []
self.RO_data_LT4_plus = []
self.RO_data_LT4_minus = []
loop_array = zip(self.lt3_dict['tstamp'],self.lt4_dict['tstamp'],self.HH_sync_psi_plus,self.HH_sync_psi_minus, \
self.lt3_dict['counted_awg_reps'],self.lt4_dict['counted_awg_reps'],self.lt3_dict['ssro_results'],
self.lt4_dict['ssro_results'],self.lt3_dict['raw_data'],self.lt4_dict['raw_data'])
for t_lt3, t_lt4, HH_s_psi_p, HH_s_psi_m, adwin_syncs_lt3, adwin_syncs_lt4, adwin_ro_lt3, adwin_ro_lt4, a_lt3, a_lt4 in loop_array:
fltr_plus_lt3 = self.filter_adwin_data_from_pq_syncs(
HH_s_psi_p, adwin_syncs_lt3)
fltr_minus_lt3 = self.filter_adwin_data_from_pq_syncs(
HH_s_psi_m, adwin_syncs_lt3)
fltr_plus_lt4 = self.filter_adwin_data_from_pq_syncs(
HH_s_psi_p, adwin_syncs_lt4)
fltr_minus_lt4 = self.filter_adwin_data_from_pq_syncs(
HH_s_psi_m, adwin_syncs_lt4)
# print t_lt3,t_lt4,adwin_syncs_lt3,fltr_plus_lt3,HH_s_psi_p
# print t_lt3,adwin_ro_lt3,adwin_ro_lt4
self.RO_data_LT3_plus.append(adwin_ro_lt3[fltr_plus_lt3])
self.RO_data_LT4_plus.append(adwin_ro_lt4[fltr_plus_lt4])
self.RO_data_LT3_minus.append(adwin_ro_lt3[fltr_minus_lt3])
self.RO_data_LT4_minus.append(adwin_ro_lt4[fltr_minus_lt4])
# print fltr_plus_lt3
# print fltr_plus_lt4
all_m_lt3, all_m_lt4, all_p_lt3, all_p_lt4 = np.array([]), np.array(
[]), np.array([]), np.array([])
for m_lt3, m_lt4, p_lt3, p_lt4 in zip(self.RO_data_LT3_minus,
self.RO_data_LT4_minus,
self.RO_data_LT3_plus,
self.RO_data_LT4_plus):
# if verbose:
# if len(m_lt3) != 0:
# print 'p_correlated for psi_minus', float(np.sum(np.equal(m_lt3,m_lt4)))/len(m_lt3)
# if len(p_lt4) != 0:
# print 'p_correlated for psi_plus', float(np.sum(np.equal(p_lt3,p_lt4)))/len(p_lt4)
all_m_lt3 = np.append(all_m_lt3, m_lt3)
all_m_lt4 = np.append(all_m_lt4, m_lt4)
all_p_lt3 = np.append(all_p_lt3, p_lt3)
all_p_lt4 = np.append(all_p_lt4, p_lt4)
#### print correlation matrix for RO results
###
### get overall events psi minus:
m_correlations = [0, 0, 0, 0]
### ROC correction should happen before this step to account for different RO durations (which we should never have in the first place.)
m_correlations[0] = np.sum(
np.equal(all_m_lt3[all_m_lt3 == 1], all_m_lt4[all_m_lt3 == 1]))
m_correlations[1] = np.sum(
np.not_equal(all_m_lt3[all_m_lt3 == 1], all_m_lt4[all_m_lt3 == 1]))
m_correlations[2] = np.sum(
np.not_equal(all_m_lt3[all_m_lt3 == 0], all_m_lt4[all_m_lt3 == 0]))
m_correlations[3] = np.sum(
np.equal(all_m_lt3[all_m_lt3 == 0], all_m_lt4[all_m_lt3 == 0]))
# print m_correlations
# print headline_format.format("", *x)
p_correlations = [0, 0, 0, 0]
p_correlations[0] = np.sum(
np.equal(all_p_lt3[all_p_lt3 == 1], all_p_lt4[all_p_lt3 == 1]))
p_correlations[1] = np.sum(
np.not_equal(all_p_lt3[all_p_lt3 == 1], all_p_lt4[all_p_lt3 == 1]))
p_correlations[2] = np.sum(
np.not_equal(all_p_lt3[all_p_lt3 == 0], all_p_lt4[all_p_lt3 == 0]))
p_correlations[3] = np.sum(
np.equal(all_p_lt3[all_p_lt3 == 0], all_p_lt4[all_p_lt3 == 0]))
if verbose:
print 'The occurence of each event after filtering'
print
x = [
'ms0 & ms0',
'ms0 & ms1',
'ms1 & ms0',
'ms1 & ms1',
]
row_format = "{:>12}" * (len(x) + 1)
headline_format = "{:>15}" + "{:>12}" * len(x)
print headline_format.format("", *x)
for state, row in zip(['psi_minus'], [m_correlations]):
print "-" * (12 * 4 + 15)
print row_format.format(state + ' |', *row)
print
for state, row in zip(['psi_plus'], [p_correlations]):
print "-" * (12 * 4 + 15)
print row_format.format(state + ' |', *row)
if apply_ROC:
# def ssro_correct_twoqubit_state_photon_numbers(correlations, F0a, F0b, F1a, F1b,
# return_error_bars=False, dF0a=0.01, dF0b=0.01, dF1a=0.01, dF1b=0.01,
# verbose = True):
### get ssro_ROC for LT3 --> corresponds to setup B
F0_LT3, F1_LT3 = self.find_RO_fidelities(self.ROC_lt3_tstamp,
a_lt3,
folder=self.lt3_folder)
### get ssro_ROC for LT4 --> corresponds to setup A
F0_LT4, F1_LT4 = self.find_RO_fidelities(self.ROC_lt4_tstamp,
a_lt4,
folder=self.lt4_folder)
### apply ROC to the results
# m_correlations = m_correlations.tolist()
corrected_psi_minus = sscorr.ssro_correct_twoqubit_state_photon_numbers(
np.array(m_correlations[::-1]), F0_LT4, F0_LT3, F1_LT4, F1_LT3)
corrected_psi_plus = sscorr.ssro_correct_twoqubit_state_photon_numbers(
np.array(p_correlations[::-1]), F0_LT4, F0_LT3, F1_LT4, F1_LT3)
if return_value:
return m_correlations, p_correlations
def Ent_fid_vs_dt_max(Total_entanglement_events, pts, Start_dt, Last_dt, F1a, F1b, F0a, F0b):
# Defines range for dt
x=np.linspace(Start_dt,Last_dt,pts)
# Initializes Psiplus and Psiminus fidelity and errors
Psiplus_Fid = np.zeros(pts)
Psiminus_Fid = np.zeros(pts)
err_Psiplus_Fid = np.zeros(pts)
err_Psiminus_Fid = np.zeros(pts)
# Initializes Corrected Psiplus and Psiminus fidelities and errors
Psiplus_Fid_corr = np.zeros(pts)
Psiminus_Fid_corr = np.zeros(pts)
err_Psiplus_Fid_corr = np.zeros(pts)
err_Psiminus_Fid_corr = np.zeros(pts)
# Initializes numbers of Psiplus and Psiminus events
psiplus_events= np.zeros(pts)
psiminus_events = np.zeros(pts)
for i,a in enumerate(x):
# Filter on photons with dt = a
Total_entanglement_events_dt_filter = DT_filter_max(Total_entanglement_events, a)
# Filters on photons with sync times within the tail
psiplus_filt_bars, psiplus_filt_bars_norm, psiminus_filt_bars, psiminus_filt_bars_norm = \
get_events_in_correct_range(Total_entanglement_events_dt_filter, VERBOSE = False)
# Determines total number of Psiplus and Psiminus events
psiplus_events[i] = sum(psiplus_filt_bars)
psiminus_events[i] = sum(psiminus_filt_bars)
# Sets Readout Fidelities and calculates errors
Psiplus_Fid[i] = (psiplus_filt_bars_norm[1]+psiplus_filt_bars_norm[2])
Psiminus_Fid[i] = (psiminus_filt_bars_norm[0]+psiminus_filt_bars_norm[3])
err_Psiplus_Fid[i] = Psiplus_Fid[i]/np.sqrt(psiplus_events[i])
err_Psiminus_Fid[i] = Psiminus_Fid[i]/np.sqrt(psiminus_events[i])
# Caclculates Corrected Readout Fidelities
psiplus_filt_bars_norm_temp = psiplus_filt_bars_norm[::-1]
psiminus_filt_bars_norm_temp = psiminus_filt_bars_norm[::-1]
psiplus_filt_bars_norm_corr_temp = sscorr.ssro_correct_twoqubit_state_photon_numbers(psiplus_filt_bars_norm_temp, F0a, F0b, F1a, F1b,
return_error_bars=False, dF0a=0.01, dF0b=0.01, dF1a=0.01, dF1b=0.01,
verbose = False)
psiminus_filt_bars_norm_corr_temp = sscorr.ssro_correct_twoqubit_state_photon_numbers(psiminus_filt_bars_norm_temp, F0a, F0b, F1a, F1b,
return_error_bars=False, dF0a=0.01, dF0b=0.01, dF1a=0.01, dF1b=0.01,
verbose = False)
psiplus_filt_bars_norm_corr = psiplus_filt_bars_norm_corr_temp[::-1]
psiminus_filt_bars_norm_corr = psiminus_filt_bars_norm_corr_temp[::-1]
# Sets corrected Readout Fidelities and errors
Psiplus_Fid_corr[i] = (psiplus_filt_bars_norm_corr[1]+psiplus_filt_bars_norm_corr[2])
Psiminus_Fid_corr[i] = (psiminus_filt_bars_norm_corr[0]+psiminus_filt_bars_norm_corr[3])
err_Psiplus_Fid_corr[i] = Psiplus_Fid_corr[i]/np.sqrt(psiplus_events[i])
err_Psiminus_Fid_corr[i] = Psiminus_Fid_corr[i]/np.sqrt(psiminus_events[i])
return x, Psiplus_Fid, Psiminus_Fid, err_Psiplus_Fid, err_Psiminus_Fid, Psiplus_Fid_corr, Psiminus_Fid_corr, err_Psiplus_Fid_corr, err_Psiminus_Fid_corr, psiplus_events, psiminus_events
def Ent_fid_vs_dt_interval(pts, Interval_length, dt_start, Total_entanglement_events, F1a, F1b, F0a, F0b, Verbose = True):
# Set x-axis
x= np.zeros(pts)
for i in np.arange(pts):
x[i] = 0.5 + 3*i
# Initializes Psiplus and Psiminus fidelity and errors
Psiplus_Fid = np.zeros(pts)
Psiminus_Fid = np.zeros(pts)
err_Psiplus_Fid = np.zeros(pts)
err_Psiminus_Fid = np.zeros(pts)
# Initializes Corrected Psiplus and Psiminus fidelities and errors
Psiplus_Fid_corr = np.zeros(pts)
Psiminus_Fid_corr = np.zeros(pts)
err_Psiplus_Fid_corr = np.zeros(pts)
err_Psiminus_Fid_corr = np.zeros(pts)
# Initializes numbers of Psiplus and Psiminus events
psiplus_events= np.zeros(pts)
psiminus_events = np.zeros(pts)
for i in np.arange(pts):
Start_dt = dt_start + i * Interval_length
Stop_dt = Start_dt + Interval_length
# Filter on photons with dt = a
Total_entanglement_events_dt_filter = Filter.DT_filter_interval(Total_entanglement_events, Start_dt, Stop_dt)
# Filters on photons with sync times within the tail
psiplus_filt_bars, psiplus_filt_bars_norm, psiminus_filt_bars, psiminus_filt_bars_norm = \
get_events_in_correct_range(Total_entanglement_events_dt_filter, VERBOSE = False)
# Determines total number of Psiplus and Psiminus events
psiplus_events[i] = sum(psiplus_filt_bars)
psiminus_events[i] = sum(psiminus_filt_bars)
if Verbose:
print "Interval: ", i+1
print "Window is set correctly"
if psiplus_events[i] == 0:
print " Window is set too small no psiplus events found"
Psiplus_Fid[i] = 0
if psiminus_events[i] == 0:
print " Window is set too small no psiminus events found"
Psiminus_Fid[i] = 0
# Sets Readout Fidelities and calculates errors
Psiplus_Fid[i] = (psiplus_filt_bars_norm[1]+psiplus_filt_bars_norm[2])
Psiminus_Fid[i] = (psiminus_filt_bars_norm[0]+psiminus_filt_bars_norm[3])
err_Psiplus_Fid[i] = Psiplus_Fid[i]/np.sqrt(psiplus_events[i])
err_Psiminus_Fid[i] = Psiminus_Fid[i]/np.sqrt(psiminus_events[i])
# Caclculates Corrected Readout Fidelities
psiplus_filt_bars_norm_temp = psiplus_filt_bars_norm[::-1]
psiminus_filt_bars_norm_temp = psiminus_filt_bars_norm[::-1]
psiplus_filt_bars_norm_corr_temp = sscorr.ssro_correct_twoqubit_state_photon_numbers(psiplus_filt_bars_norm_temp, F0a, F0b, F1a, F1b,
return_error_bars=False, dF0a=0.01, dF0b=0.01, dF1a=0.01, dF1b=0.01,
verbose = False)
psiminus_filt_bars_norm_corr_temp = sscorr.ssro_correct_twoqubit_state_photon_numbers(psiminus_filt_bars_norm_temp, F0a, F0b, F1a, F1b,
return_error_bars=False, dF0a=0.01, dF0b=0.01, dF1a=0.01, dF1b=0.01,
verbose = False)
psiplus_filt_bars_norm_corr = psiplus_filt_bars_norm_corr_temp[::-1]
psiminus_filt_bars_norm_corr = psiminus_filt_bars_norm_corr_temp[::-1]
# Sets corrected Readout Fidelities and errors
Psiplus_Fid_corr[i] = (psiplus_filt_bars_norm_corr[1]+psiplus_filt_bars_norm_corr[2])
Psiminus_Fid_corr[i] = (psiminus_filt_bars_norm_corr[0]+psiminus_filt_bars_norm_corr[3])
err_Psiplus_Fid_corr[i] = Psiplus_Fid_corr[i]/np.sqrt(psiplus_events[i])
err_Psiminus_Fid_corr[i] = Psiminus_Fid_corr[i]/np.sqrt(psiminus_events[i])
return x, Psiplus_Fid, Psiminus_Fid, err_Psiplus_Fid, err_Psiminus_Fid, Psiplus_Fid_corr, Psiminus_Fid_corr, err_Psiplus_Fid_corr, err_Psiminus_Fid_corr, psiplus_events, psiminus_events
