def get_N_ROC(self, P_min1=1, u_P_min1=0, P_0=1, u_P_0=0,
F0_RO_pulse=1, u_F0_RO_pulse=0,
F1_RO_pulse=1, u_F1_RO_pulse=0,
ssro_calib_folder=None):
if ssro_calib_folder == None:
ssro_calib_folder = toolbox.latest_data('SSRO')
self.p0 = np.zeros(self.normalized_ssro.shape)
self.u_p0 = np.zeros(self.normalized_ssro.shape)
ro_durations = self.g.attrs['E_RO_durations']
roc = Nspin_correction.NuclearSpinROC()
roc.P_min1 = P_min1
roc.u_P_min1 = u_P_min1
roc.P_0 = P_0
roc.u_P_0 = u_P_0
roc.F0_RO_pulse = F0_RO_pulse
roc.u_F0_RO_pulse = u_F0_RO_pulse
roc.F1_RO_pulse = F1_RO_pulse
roc.u_F1_RO_pulse = u_F1_RO_pulse
for i in range(len(self.normalized_ssro[0])):
roc.F0_ssro, roc.u_F0_ssro, roc.F1_ssro, roc.u_F1_ssro = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_durations[i])
p0, u_p0 = roc.num_evaluation(self.normalized_ssro[:,i],
self.u_normalized_ssro[:,i])
self.p0[:,i] = p0
self.u_p0[:,i] = u_p0
self.result_corrected = True
def get_electron_ROC(self, **kw):
ssro_calib_folder = kw.pop('ssro_calib_folder', None)
if ssro_calib_folder is None:
ssro_calib_folder = toolbox.latest_data('SSROCalibration')
# print ssro_calib_folder
if ssro_calib_folder == '':
ssro_calib_folder = toolbox.latest_data('SSROCalibration')
self.p0 = np.zeros(self.normalized_ssro.shape)
self.u_p0 = np.zeros(self.normalized_ssro.shape)
ro_duration = self.g.attrs['SSRO_duration']
roc = error.SingleQubitROC()
# Decide between ssro calib via MW Initialisation or some other method
# At the time of writing only MWInit and full las0r SSRO exist ~SK 2016
if 'MWInit' in ssro_calib_folder:
el_state = self.adgrp.attrs['electron_transition']
# print 'MWInit, el_state: ' + str(el_state)
roc.F0, roc.u_F0, roc.F1, roc.u_F1 = \
ssro.get_SSRO_MWInit_calibration(ssro_calib_folder,
ro_duration,el_state)
else:
roc.F0, roc.u_F0, roc.F1, roc.u_F1 = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_duration)
p0, u_p0 = roc.num_eval(self.normalized_ssro, self.u_normalized_ssro)
self.p0 = p0
self.u_p0 = u_p0
self.result_corrected = True
def get_N_ROC(self, P_min1=1, u_P_min1=0, P_0=1, u_P_0=0,
F0_RO_pulse=1, u_F0_RO_pulse=0,
F1_RO_pulse=1, u_F1_RO_pulse=0,
ssro_calib_folder=None):
if ssro_calib_folder == None:
ssro_calib_folder = toolbox.latest_data('SSRO')
self.p0 = np.zeros(self.normalized_ssro.shape)
self.u_p0 = np.zeros(self.normalized_ssro.shape)
ro_durations = self.g.attrs['E_RO_durations']
roc = Nspin_correction.NuclearSpinROC()
roc.P_min1 = P_min1
roc.u_P_min1 = u_P_min1
roc.P_0 = P_0
roc.u_P_0 = u_P_0
roc.F0_RO_pulse = F0_RO_pulse
roc.u_F0_RO_pulse = u_F0_RO_pulse
roc.F1_RO_pulse = F1_RO_pulse
roc.u_F1_RO_pulse = u_F1_RO_pulse
for i in range(len(self.normalized_ssro[0])):
roc.F0_ssro, roc.u_F0_ssro, roc.F1_ssro, roc.u_F1_ssro = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_durations[i])
p0, u_p0 = roc.num_evaluation(self.normalized_ssro[:,i],
self.u_normalized_ssro[:,i])
self.p0[:,i] = p0
self.u_p0[:,i] = u_p0
self.result_corrected = True
def get_RO_fidelities(ssro_folder,mw_transition,E_RO_duration):
if 'MWInit' in ssro_folder:
F_0,u_F0,F_1,u_F1 = ssro.get_SSRO_MWInit_calibration(ssro_folder,E_RO_duration,mw_transition)
else:
F_0,u_F0,F_1,u_F1 = ssro.get_SSRO_calibration(ssro_folder,E_RO_duration)
return F_0,F_1 ### excludiung uncertainties for now.
def get_correlation_ROC(self, P_min1=1, u_P_min1=0, P_0=0, u_P_0=0,
F0_RO_pulse=1, u_F0_RO_pulse=0,
F1_RO_pulse=1, u_F1_RO_pulse=0,
ssro_calib_folder=None):
if ssro_calib_folder == None:
ssro_calib_folder = toolbox.latest_data('SSRO')
#The shape below is [sweep_pts,4].
self.p_correlations= np.zeros(self.normalized_correlations.shape)
self.u_p_correlations = np.zeros(self.normalized_correlations.shape)
ro_durations = self.g.attrs['E_RO_durations']
roc = N_and_e_spin_correction.CorrelationsROC()
roc.P_min1 = P_min1
roc.u_P_min1 = u_P_min1
roc.P_0 = P_0
roc.u_P_0 = u_P_0
roc.F0_RO_pulse = F0_RO_pulse
roc.u_F0_RO_pulse = u_F0_RO_pulse
roc.F1_RO_pulse = F1_RO_pulse
roc.u_F1_RO_pulse = u_F1_RO_pulse
#The electron RO correction for the first readout (with ro_durations[0])
roc.F0_e_ssro, roc.u_F0_e_ssro, roc.F1_e_ssro, roc.u_F1_e_ssro = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_durations[0])
#The electron RO correction for the second readout (with ro_durations[1])
roc.F0_N_ssro, roc.u_F0_N_ssro, roc.F1_N_ssro, roc.u_F1_N_ssro = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_durations[1])
#Here the correction for the double readout is calculation.
p_correlations, u_p_correlations = roc.num_evaluation(self.normalized_correlations[:,:],
self.u_normalized_correlations[:,:])
#The output p_correlations above is tuple, we transform it to array
#and Transpose it to retain the right shape.
self.p_correlations = np.array(p_correlations).T
self.u_p_correlations = np.array(u_p_correlations).T
self.result_correlation_corrected = True
def get_correlation_ROC(self, P_min1=1, u_P_min1=0, P_0=0, u_P_0=0,
F0_RO_pulse=1, u_F0_RO_pulse=0,
F1_RO_pulse=1, u_F1_RO_pulse=0,
ssro_calib_folder=None):
if ssro_calib_folder == None:
ssro_calib_folder = toolbox.latest_data('SSRO')
#The shape below is [sweep_pts,4].
self.p_correlations= np.zeros(self.normalized_correlations.shape)
self.u_p_correlations = np.zeros(self.normalized_correlations.shape)
ro_durations = self.g.attrs['E_RO_durations']
roc = N_and_e_spin_correction.CorrelationsROC()
roc.P_min1 = P_min1
roc.u_P_min1 = u_P_min1
roc.P_0 = P_0
roc.u_P_0 = u_P_0
roc.F0_RO_pulse = F0_RO_pulse
roc.u_F0_RO_pulse = u_F0_RO_pulse
roc.F1_RO_pulse = F1_RO_pulse
roc.u_F1_RO_pulse = u_F1_RO_pulse
#The electron RO correction for the first readout (with ro_durations[0])
roc.F0_e_ssro, roc.u_F0_e_ssro, roc.F1_e_ssro, roc.u_F1_e_ssro = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_durations[0])
#The electron RO correction for the second readout (with ro_durations[1])
roc.F0_N_ssro, roc.u_F0_N_ssro, roc.F1_N_ssro, roc.u_F1_N_ssro = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_durations[1])
#Here the correction for the double readout is calculation.
p_correlations, u_p_correlations = roc.num_evaluation(self.normalized_correlations[:,:],
self.u_normalized_correlations[:,:])
#The output p_correlations above is tuple, we transform it to array
#and Transpose it to retain the right shape.
self.p_correlations = np.array(p_correlations).T
self.u_p_correlations = np.array(u_p_correlations).T
self.result_correlation_corrected = True
def get_magnetometry_phase_calibration(self, name='',ssro_calib_folder=''):
self.result_corrected = False
adwingrp = self.adwingrp(name)
self.reps = adwingrp['completed_reps'].value-1
RO_clicks = adwingrp['RO_data'].value
phase = adwingrp['set_phase'].value
times=self.g.attrs['ramsey_time']
phase_values = np.unique(phase)
self.ssro_results = np.zeros(len(phase_values))
for j in phase_values:
self.ssro_results [np.min(np.where(phase==j))] = np.sum(RO_clicks[np.where(phase==j)])
if len(self.ssro_results)==1:
self.sweep_pts = self.g.attrs['sweep_pts']
phase=np.array(list(np.arange(len(self.sweep_pts)))*int((self.reps+1)/float(len(self.sweep_pts))))
phase_values = np.unique(phase)
self.ssro_results = np.zeros(len(phase_values))
for j in phase_values:
self.ssro_results [np.min(np.where(phase==j))] = np.sum(RO_clicks[np.where(phase==j)])
#self.sweep_pts = times
#print 'len phases',len(phases)
#print phases
#print phase_values
self.normalized_ssro = self.ssro_results*len(self.ssro_results)/(float(self.reps))
self.u_normalized_ssro = (self.normalized_ssro*(1.-self.normalized_ssro)/(float(self.reps)))**0.5 #this is quite ugly, maybe replace?
if ssro_calib_folder == '':
ssro_calib_folder = toolbox.latest_data('SSROCalibration')
print ssro_calib_folder
self.p0 = self.normalized_ssro
self.u_p0 = self.u_normalized_ssro
ro_duration = self.g.attrs['SSRO_duration']
roc = error.SingleQubitROC()
roc.F0, roc.u_F0, roc.F1, roc.u_F1 = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_duration)
p0, u_p0 = roc.num_eval(self.normalized_ssro,
self.u_normalized_ssro)
self.p0 = p0
self.u_p0 = u_p0
self.result_corrected = True
return self.p0,self.u_p0
def find_RO_fidelities(self, timestamp, raw_data, folder=''):
ssro_folder = tb.data_from_time(timestamp, folder=folder)
if 'MWInit' in ssro_folder:
F_0, u_F0, F_1, u_F1 = ssro.get_SSRO_MWInit_calibration(
ssro_folder, raw_data.g.attrs['E_RO_durations'][0],
raw_data.g.attrs['electron_transition'])
else:
F_0, u_F0, F_1, u_F1 = ssro.get_SSRO_calibration(
ssro_folder, raw_data.g.attrs['E_RO_durations'][0])
return F_0, F_1
def get_electron_ROC(self, **kw):
ssro_calib_folder = kw.pop('ssro_calib_folder', toolbox.latest_data('SSROCalibration'))
self.p0 = np.zeros(self.normalized_ssro.shape)
self.u_p0 = np.zeros(self.normalized_ssro.shape)
ro_duration = self.g.attrs['SSRO_duration']
roc = error.SingleQubitROC()
roc.F0, roc.u_F0, roc.F1, roc.u_F1 = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_duration)
p0, u_p0 = roc.num_eval(self.normalized_ssro,
self.u_normalized_ssro)
self.p0 = p0
self.u_p0 = u_p0
self.result_corrected = True
def get_electron_ROC(self, ssro_calib_folder=''):
if ssro_calib_folder == '':
ssro_calib_folder = toolbox.latest_data('SSRO')
self.p0 = np.zeros(self.normalized_ssro.shape)
self.u_p0 = np.zeros(self.normalized_ssro.shape)
ro_durations = self.g.attrs['E_RO_durations']
roc = error.SingleQubitROC()
# Decide between ssro calib via MW Initialisation or some other method
# At the time of writing only MWInit and full las0r SSRO exist ~SK 2016
if 'MWInit' in ssro_calib_folder:
el_state = self.adgrp.attrs['electron_transition']
# print 'MWInit, el_state: ' + str(el_state)
for i in range(len(self.normalized_ssro[0])):
roc.F0, roc.u_F0, roc.F1, roc.u_F1 = \
ssro.get_SSRO_MWInit_calibration(ssro_calib_folder,
ro_durations[i],el_state)
p0, u_p0 = roc.num_eval(self.normalized_ssro[:,i],
self.u_normalized_ssro[:,i])
self.p0[:,i] = p0
self.u_p0[:,i] = u_p0
else:
for i in range(len(self.normalized_ssro[0])):
roc.F0, roc.u_F0, roc.F1, roc.u_F1 = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_durations[i])
p0, u_p0 = roc.num_eval(self.normalized_ssro[:,i],
self.u_normalized_ssro[:,i])
self.p0[:,i] = p0
self.u_p0[:,i] = u_p0
self.result_corrected = True
def get_electron_ROC(self, ssro_calib_folder='',**kw):
if ssro_calib_folder == '':
ssro_calib_folder = toolbox.latest_data('SSROCalibration', **kw)
self.p0 = np.zeros(self.normalized_ssro.shape)
self.u_p0 = np.zeros(self.normalized_ssro.shape)
ro_durations = self.g.attrs['E_RO_durations']
roc = error.SingleQubitROC()
# Decide between ssro calib via MW Initialisation or some other method
# At the time of writing only MWInit and full las0r SSRO exist ~SK 2016
if 'MWInit' in ssro_calib_folder:
el_state = self.adgrp.attrs['electron_transition']
# print 'MWInit, el_state: ' + str(el_state)
for i in range(len(self.normalized_ssro[0])):
roc.F0, roc.u_F0, roc.F1, roc.u_F1 = \
ssro.get_SSRO_MWInit_calibration(ssro_calib_folder,
ro_durations[i],el_state)
p0, u_p0 = roc.num_eval(self.normalized_ssro[:,i],
self.u_normalized_ssro[:,i])
self.p0[:,i] = p0
self.u_p0[:,i] = u_p0
else:
for i in range(len(self.normalized_ssro[0])):
roc.F0, roc.u_F0, roc.F1, roc.u_F1 = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_durations[i])
p0, u_p0 = roc.num_eval(self.normalized_ssro[:,i],
self.u_normalized_ssro[:,i])
self.p0[:,i] = p0
self.u_p0[:,i] = u_p0
self.result_corrected = True
def get_electron_ROC(self, ssro_calib_folder=''):
if ssro_calib_folder == '':
ssro_calib_folder = toolbox.latest_data('SSRO')
self.p0 = np.zeros(self.normalized_ssro.shape)
self.u_p0 = np.zeros(self.normalized_ssro.shape)
ro_durations = self.g.attrs['E_RO_durations']
roc = error.SingleQubitROC()
for i in range(len(self.normalized_ssro[0])):
roc.F0, roc.u_F0, roc.F1, roc.u_F1 = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_durations[i])
p0, u_p0 = roc.num_eval(self.normalized_ssro[:,i],
self.u_normalized_ssro[:,i])
self.p0[:,i] = p0
self.u_p0[:,i] = u_p0
self.result_corrected = True
def get_electron_ROC(self, **kw):
ssro_calib_folder = kw.pop('ssro_calib_folder', toolbox.latest_data('SSRO'))
# print ssro_calib_folder
if ssro_calib_folder == '':
ssro_calib_folder = toolbox.latest_data('SSRO')
self.p0 = np.zeros(self.normalized_ssro.shape)
self.u_p0 = np.zeros(self.normalized_ssro.shape)
ro_duration = self.g.attrs['SSRO_duration']
roc = error.SingleQubitROC()
# Decide between ssro calib via MW Initialisation or some other method
# At the time of writing only MWInit and full las0r SSRO exist ~SK 2016
if 'MWInit' in ssro_calib_folder:
el_state = self.adgrp.attrs['electron_transition']
# print 'MWInit, el_state: ' + str(el_state)
roc.F0, roc.u_F0, roc.F1, roc.u_F1 = \
ssro.get_SSRO_MWInit_calibration(ssro_calib_folder,
ro_duration,el_state)
else:
roc.F0, roc.u_F0, roc.F1, roc.u_F1 = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_duration)
p0, u_p0 = roc.num_eval(self.normalized_ssro,
self.u_normalized_ssro)
self.p0 = p0
self.u_p0 = u_p0
self.result_corrected = True
def get_electron_ROC(self, ssro_calib_folder='',post_select_QEC = False, post_select_multiple_rounds = False, post_select_GHZ = False,post_select = True):
'''
Performs Readout Correction, needs to be updated to correct for post selected results and apply error-bars correctly.
'''
if post_select_QEC == True and self.post_select == True:
if ssro_calib_folder == '':
ssro_calib_folder = toolbox.latest_data('SSRO')
self.p0_00 = np.zeros(self.normalized_ssro_00.shape)
self.u_p0_00 = np.zeros(self.normalized_ssro_00.shape)
self.p0_01 = np.zeros(self.normalized_ssro_01.shape)
self.u_p0_01 = np.zeros(self.normalized_ssro_01.shape)
self.p0_10 = np.zeros(self.normalized_ssro_10.shape)
self.u_p0_10 = np.zeros(self.normalized_ssro_10.shape)
self.p0_11 = np.zeros(self.normalized_ssro_11.shape)
self.u_p0_11 = np.zeros(self.normalized_ssro_11.shape)
ro_durations = self.g.attrs['E_RO_durations']
roc = error.SingleQubitROC()
for i in range(len(self.normalized_ssro_00[0])):
roc.F0, roc.u_F0, roc.F1, roc.u_F1 = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_durations[i])
p0_00, u_p0_00 = roc.num_eval(self.normalized_ssro_00[:,i],
self.u_normalized_ssro_00[:,i])
p0_01, u_p0_01 = roc.num_eval(self.normalized_ssro_01[:,i],
self.u_normalized_ssro_01[:,i])
p0_10, u_p0_10 = roc.num_eval(self.normalized_ssro_10[:,i],
self.u_normalized_ssro_10[:,i])
p0_11, u_p0_11 = roc.num_eval(self.normalized_ssro_11[:,i],
self.u_normalized_ssro_11[:,i])
self.p0_00[:,i] = p0_00
self.u_p0_00[:,i] = u_p0_00
self.p0_01[:,i] = p0_01
self.u_p0_01[:,i] = u_p0_01
self.p0_10[:,i] = p0_10
self.u_p0_10[:,i] = u_p0_10
self.p0_11[:,i] = p0_11
self.u_p0_11[:,i] = u_p0_11
elif post_select_multiple_rounds == True and self.post_select == True:
if ssro_calib_folder == '':
ssro_calib_folder = toolbox.latest_data('SSRO')
self.p0_0000 = np.zeros(self.normalized_ssro_0000.shape)
self.u_p0_0000 = np.zeros(self.normalized_ssro_0000.shape)
self.p0_0100 = np.zeros(self.normalized_ssro_0100.shape)
self.u_p0_0100 = np.zeros(self.normalized_ssro_0100.shape)
self.p0_1000 = np.zeros(self.normalized_ssro_1000.shape)
self.u_p0_1000 = np.zeros(self.normalized_ssro_1000.shape)
self.p0_1100 = np.zeros(self.normalized_ssro_1100.shape)
self.u_p0_1100 = np.zeros(self.normalized_ssro_1100.shape)
self.p0_0010 = np.zeros(self.normalized_ssro_0010.shape)
self.u_p0_0010 = np.zeros(self.normalized_ssro_0010.shape)
self.p0_0110 = np.zeros(self.normalized_ssro_0110.shape)
self.u_p0_0110 = np.zeros(self.normalized_ssro_0110.shape)
self.p0_1010 = np.zeros(self.normalized_ssro_1010.shape)
self.u_p0_1010 = np.zeros(self.normalized_ssro_1010.shape)
self.p0_1110 = np.zeros(self.normalized_ssro_1110.shape)
self.u_p0_1110 = np.zeros(self.normalized_ssro_1110.shape)
self.p0_0001 = np.zeros(self.normalized_ssro_0001.shape)
self.u_p0_0001 = np.zeros(self.normalized_ssro_0001.shape)
self.p0_0101 = np.zeros(self.normalized_ssro_0101.shape)
self.u_p0_0101 = np.zeros(self.normalized_ssro_0101.shape)
self.p0_1001 = np.zeros(self.normalized_ssro_1001.shape)
self.u_p0_1001 = np.zeros(self.normalized_ssro_1001.shape)
self.p0_1101 = np.zeros(self.normalized_ssro_1101.shape)
self.u_p0_1101 = np.zeros(self.normalized_ssro_1101.shape)
self.p0_0011 = np.zeros(self.normalized_ssro_0011.shape)
self.u_p0_0011 = np.zeros(self.normalized_ssro_0011.shape)
self.p0_0111 = np.zeros(self.normalized_ssro_0111.shape)
self.u_p0_0111 = np.zeros(self.normalized_ssro_0111.shape)
self.p0_1011 = np.zeros(self.normalized_ssro_1011.shape)
self.u_p0_1011 = np.zeros(self.normalized_ssro_1011.shape)
self.p0_1111 = np.zeros(self.normalized_ssro_1111.shape)
self.u_p0_1111 = np.zeros(self.normalized_ssro_1111.shape)
ro_durations = self.g.attrs['E_RO_durations']
roc = error.SingleQubitROC()
for i in range(len(self.normalized_ssro_0000[0])):
roc.F0, roc.u_F0, roc.F1, roc.u_F1 = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_durations[i])
p0_0000, u_p0_0000 = roc.num_eval(self.normalized_ssro_0000[:,i],
self.u_normalized_ssro_0000[:,i])
p0_0100, u_p0_0100 = roc.num_eval(self.normalized_ssro_0100[:,i],
self.u_normalized_ssro_0100[:,i])
p0_1000, u_p0_1000 = roc.num_eval(self.normalized_ssro_1000[:,i],
self.u_normalized_ssro_1000[:,i])
p0_1100, u_p0_1100 = roc.num_eval(self.normalized_ssro_1100[:,i],
self.u_normalized_ssro_1100[:,i])
p0_0010, u_p0_0010 = roc.num_eval(self.normalized_ssro_0010[:,i],
self.u_normalized_ssro_0010[:,i])
p0_0110, u_p0_0110 = roc.num_eval(self.normalized_ssro_0110[:,i],
self.u_normalized_ssro_0110[:,i])
p0_1010, u_p0_1010 = roc.num_eval(self.normalized_ssro_1010[:,i],
self.u_normalized_ssro_1010[:,i])
p0_1110, u_p0_1110 = roc.num_eval(self.normalized_ssro_1110[:,i],
self.u_normalized_ssro_1110[:,i])
p0_0001, u_p0_0001 = roc.num_eval(self.normalized_ssro_0001[:,i],
self.u_normalized_ssro_0001[:,i])
p0_0101, u_p0_0101 = roc.num_eval(self.normalized_ssro_0101[:,i],
self.u_normalized_ssro_0101[:,i])
p0_1001, u_p0_1001 = roc.num_eval(self.normalized_ssro_1001[:,i],
self.u_normalized_ssro_1001[:,i])
p0_1101, u_p0_1101 = roc.num_eval(self.normalized_ssro_1101[:,i],
self.u_normalized_ssro_1101[:,i])
p0_0011, u_p0_0011 = roc.num_eval(self.normalized_ssro_0011[:,i],
self.u_normalized_ssro_0011[:,i])
p0_0111, u_p0_0111 = roc.num_eval(self.normalized_ssro_0111[:,i],
self.u_normalized_ssro_0111[:,i])
p0_1011, u_p0_1011 = roc.num_eval(self.normalized_ssro_1011[:,i],
self.u_normalized_ssro_1011[:,i])
p0_1111, u_p0_1111 = roc.num_eval(self.normalized_ssro_1111[:,i],
self.u_normalized_ssro_1111[:,i])
self.p0_0000[:,i] = p0_0000
self.u_p0_0000[:,i] = u_p0_0000
self.p0_0100[:,i] = p0_0100
self.u_p0_0100[:,i] = u_p0_0100
self.p0_1000[:,i] = p0_1000
self.u_p0_1000[:,i] = u_p0_1000
self.p0_1100[:,i] = p0_1100
self.u_p0_1100[:,i] = u_p0_1100
self.p0_0010[:,i] = p0_0010
self.u_p0_0010[:,i] = u_p0_0010
self.p0_0110[:,i] = p0_0110
self.u_p0_0110[:,i] = u_p0_0110
self.p0_1010[:,i] = p0_1010
self.u_p0_1010[:,i] = u_p0_1010
self.p0_1110[:,i] = p0_1110
self.u_p0_1110[:,i] = u_p0_1110
self.p0_0001[:,i] = p0_0001
self.u_p0_0001[:,i] = u_p0_0001
self.p0_0101[:,i] = p0_0101
self.u_p0_0101[:,i] = u_p0_0101
self.p0_1001[:,i] = p0_1001
self.u_p0_1001[:,i] = u_p0_1001
self.p0_1101[:,i] = p0_1101
self.u_p0_1101[:,i] = u_p0_1101
self.p0_0011[:,i] = p0_0011
self.u_p0_0011[:,i] = u_p0_0011
self.p0_0111[:,i] = p0_0111
self.u_p0_0111[:,i] = u_p0_0111
self.p0_1011[:,i] = p0_1011
self.u_p0_1011[:,i] = u_p0_1011
self.p0_1111[:,i] = p0_1111
self.u_p0_1111[:,i] = u_p0_1111
elif post_select_GHZ == True and self.post_select==True:
if ssro_calib_folder == '':
ssro_calib_folder = toolbox.latest_data('SSRO')
self.p0_000 = np.zeros(self.normalized_ssro_000.shape)
self.u_p0_000 = np.zeros(self.normalized_ssro_000.shape)
self.p0_001 = np.zeros(self.normalized_ssro_001.shape)
self.u_p0_001 = np.zeros(self.normalized_ssro_001.shape)
self.p0_010 = np.zeros(self.normalized_ssro_010.shape)
self.u_p0_010 = np.zeros(self.normalized_ssro_010.shape)
self.p0_011 = np.zeros(self.normalized_ssro_011.shape)
self.u_p0_011 = np.zeros(self.normalized_ssro_011.shape)
self.p0_100 = np.zeros(self.normalized_ssro_100.shape)
self.u_p0_100 = np.zeros(self.normalized_ssro_100.shape)
self.p0_101 = np.zeros(self.normalized_ssro_101.shape)
self.u_p0_101 = np.zeros(self.normalized_ssro_101.shape)
self.p0_110 = np.zeros(self.normalized_ssro_110.shape)
self.u_p0_110 = np.zeros(self.normalized_ssro_110.shape)
self.p0_111 = np.zeros(self.normalized_ssro_111.shape)
self.u_p0_111 = np.zeros(self.normalized_ssro_111.shape)
ro_durations = self.g.attrs['E_RO_durations']
roc = error.SingleQubitROC()
for i in range(len(self.normalized_ssro_000[0])):
roc.F0, roc.u_F0, roc.F1, roc.u_F1 = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_durations[i])
p0_000, u_p0_000 = roc.num_eval(self.normalized_ssro_000[:,i],
self.u_normalized_ssro_000[:,i])
p0_001, u_p0_001 = roc.num_eval(self.normalized_ssro_001[:,i],
self.u_normalized_ssro_001[:,i])
p0_010, u_p0_010 = roc.num_eval(self.normalized_ssro_010[:,i],
self.u_normalized_ssro_010[:,i])
p0_011, u_p0_011 = roc.num_eval(self.normalized_ssro_011[:,i],
self.u_normalized_ssro_011[:,i])
p0_100, u_p0_100 = roc.num_eval(self.normalized_ssro_100[:,i],
self.u_normalized_ssro_100[:,i])
p0_101, u_p0_101 = roc.num_eval(self.normalized_ssro_101[:,i],
self.u_normalized_ssro_101[:,i])
p0_110, u_p0_110 = roc.num_eval(self.normalized_ssro_110[:,i],
self.u_normalized_ssro_110[:,i])
p0_111, u_p0_111 = roc.num_eval(self.normalized_ssro_111[:,i],
self.u_normalized_ssro_111[:,i])
self.p0_000[:,i] = p0_000
self.u_p0_000[:,i] = u_p0_000
self.p0_001[:,i] = p0_001
self.u_p0_001[:,i] = u_p0_001
self.p0_010[:,i] = p0_010
self.u_p0_010[:,i] = u_p0_010
self.p0_011[:,i] = p0_011
self.u_p0_011[:,i] = u_p0_011
self.p0_100[:,i] = p0_100
self.u_p0_100[:,i] = u_p0_100
self.p0_101[:,i] = p0_101
self.u_p0_101[:,i] = u_p0_101
self.p0_110[:,i] = p0_110
self.u_p0_110[:,i] = u_p0_110
self.p0_111[:,i] = p0_111
self.u_p0_111[:,i] = u_p0_111
self.result_corrected = True
elif self.post_select == True:
if ssro_calib_folder == '':
ssro_calib_folder = toolbox.latest_data('SSRO')
self.p0_0 = np.zeros(self.normalized_ssro_0.shape)
self.u_p0_0 = np.zeros(self.normalized_ssro_0.shape)
self.p0_1 = np.zeros(self.normalized_ssro_1.shape)
self.u_p0_1 = np.zeros(self.normalized_ssro_1.shape)
ro_durations = self.g.attrs['E_RO_durations']
roc = error.SingleQubitROC()
for i in range(len(self.normalized_ssro_0[0])):
roc.F0, roc.u_F0, roc.F1, roc.u_F1 = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_durations[i])
p0_0, u_p0_0 = roc.num_eval(self.normalized_ssro_0[:,i],
self.u_normalized_ssro_0[:,i])
p0_1, u_p0_1 = roc.num_eval(self.normalized_ssro_1[:,i],
self.u_normalized_ssro_1[:,i])
self.p0_0[:,i] = p0_0
self.u_p0_0[:,i] = u_p0_0
self.p0_1[:,i] = p0_1
self.u_p0_1[:,i] = u_p0_1
self.result_corrected = True
self.result_corrected = True
else:
mbi.MBIAnalysis.get_electron_ROC(self,ssro_calib_folder) #NOTE: super cannot be used as this is an "old style class"
def get_magnetometry_phase_calibration(self,
name='',
ssro_calib_folder=''):
self.result_corrected = False
adwingrp = self.adwingrp(name)
self.reps = adwingrp['completed_reps'].value - 1
RO_clicks = adwingrp['RO_data'].value
phase = adwingrp['set_phase'].value
times = self.g.attrs['ramsey_time']
phase_values = np.unique(phase)
self.ssro_results = np.zeros(len(phase_values))
for j in phase_values:
self.ssro_results[np.min(np.where(phase == j))] = np.sum(
RO_clicks[np.where(phase == j)])
if len(self.ssro_results) == 1:
self.sweep_pts = self.g.attrs['sweep_pts']
phase = np.array(
list(np.arange(len(self.sweep_pts))) * int(
(self.reps + 1) / float(len(self.sweep_pts))))
phase_values = np.unique(phase)
self.ssro_results = np.zeros(len(phase_values))
for j in phase_values:
self.ssro_results[np.min(np.where(phase == j))] = np.sum(
RO_clicks[np.where(phase == j)])
#self.sweep_pts = times
#print 'len phases',len(phases)
#print phases
#print phase_values
self.normalized_ssro = self.ssro_results * len(
self.ssro_results) / (float(self.reps))
self.u_normalized_ssro = (
self.normalized_ssro * (1. - self.normalized_ssro) /
(float(self.reps)))**0.5 #this is quite ugly, maybe replace?
if ssro_calib_folder == '':
ssro_calib_folder = toolbox.latest_data('SSROCalibration')
print ssro_calib_folder
self.p0 = self.normalized_ssro
self.u_p0 = self.u_normalized_ssro
ro_duration = self.g.attrs['SSRO_duration']
roc = error.SingleQubitROC()
roc.F0, roc.u_F0, roc.F1, roc.u_F1 = \
ssro.get_SSRO_calibration(ssro_calib_folder,
ro_duration)
p0, u_p0 = roc.num_eval(self.normalized_ssro, self.u_normalized_ssro)
self.p0 = p0
self.u_p0 = u_p0
self.result_corrected = True
return self.p0, self.u_p0
