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