def NuclearRamseyWithInitialization_cal(name,
carbon_nr=1,
carbon_init_state='up',
el_RO='positive',
detuning=0.5e3,
evo_time=400e-6,
el_state=1,
debug=False,
free_evolution_time=400e-6 +
np.linspace(0., 6.0e-3, 44)):
m = DD.NuclearRamseyWithInitialization(name)
funcs.prepare(m)
'''Set parameters'''
### Sweep parameters
m.params['reps_per_ROsequence'] = 250
m.params['C13_MBI_RO_state'] = 0
### overwritten from msmnt params
####################################
### Option 1; Sweep waiting time ###
####################################
## '''1A - Rotating frame with detuning'''
m.params['add_wait_gate'] = True
m.params['pts'] = len(free_evolution_time)
m.params['free_evolution_time'] = free_evolution_time
# m.params['free_evolution_time'] = 180e-6 + np.linspace(0e-6, 4*1./74e3,m.params['pts'])
m.params['C' + str(carbon_nr) + '_freq_0'] += detuning
m.params['C' + str(carbon_nr) + '_freq_1' +
m.params['electron_transition']] += detuning
m.params['C_RO_phase'] = np.ones(m.params['pts']) * 0
m.params['sweep_name'] = 'free_evolution_time'
m.params['sweep_pts'] = m.params['free_evolution_time']
############################################
### Option 2; Sweep RO phase at set time ###
############################################
# m.params['pts'] = 21
# m.params['add_wait_gate'] = False
# m.params['free_evolution_time'] = np.ones(m.params['pts'] )*evo_time
# m.params['C_RO_phase'] = np.linspace(-20, 400,m.params['pts'])
# m.params['sweep_name'] = 'phase'
# m.params['sweep_pts'] = m.params['C_RO_phase']
'''Derived and fixed parameters'''
m.params['electron_readout_orientation'] = el_RO
m.params['carbon_nr'] = carbon_nr
m.params['init_state'] = carbon_init_state
m.params['electron_after_init'] = str(el_state)
m.params['Nr_C13_init'] = 1
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
funcs.finish(m, upload=True, debug=debug)
def SimpleDecoupling_swp_mw_amp(name,tau=None,N=None, mw_amps=np.arange(0.6,0.8,0.01),reps_per_ROsequence=1000, mbi = True):
m = DD.SimpleDecoupling(name+'_tau_'+str(tau*1e9))
funcs.prepare(m)
#input parameters
m.params['reps_per_ROsequence'] = reps_per_ROsequence
pts = len(mw_amps)
tau_list = tau*np.ones(pts)
N_list = N*np.ones(pts)
#inital and final pulse
m.params['Initial_Pulse'] ='y'
m.params['Final_Pulse'] ='-y'
#Method to construct the sequence
m.params['Decoupling_sequence_scheme'] = 'repeating_T_elt' # repeating_T_elt
m.params['pts'] = pts
m.params['tau_list'] = tau_list
m.params['Number_of_pulses'] = N_list
m.params['sweep_pts'] = mw_amps
m.params['do_general_sweep'] = 1
m.params['general_sweep_name'] = 'Hermite_pi_length'
m.params['general_sweep_pts'] = mw_amps
m.params['sweep_name'] = 'Hermite_pi_length'
m.autoconfig()
m.params['DD_in_eigenstate'] = False
funcs.finish(m, upload =True, debug=False)
def unconditional_rabi(name,
C13_init_method='MBI',
carbon_A=1,
carbon_B=1,
N_list=np.arange(4, 100, 8),
tau_list=None,
electron_readout_orientation='positive',
tomo_basis='X'):
m = DD.Crosstalk(name)
funcs.prepare(m)
'''set experimental parameters'''
m.params['carbon_nr'] = carbon_A ### Carbon spin that is prepared via MBI
m.params[
'Carbon_B'] = carbon_B ### Carbon spin that the Rabi/Gate is performed on
m.params['reps_per_ROsequence'] = 500
###############
# Carbon INIT #
###############
m.params['Nr_C13_init'] = 1
m.params['C13_init_method'] = C13_init_method
m.params['C13_init_state'] = 'up'
m.params['el_after_init'] = '0'
###############
# Rabi params #
###############
m.params['Carbon_B'] = carbon_B
m.params['Rabi_N_Sweep'] = N_list
if tau_list == None:
tau_list = m.params['C' + str(carbon_B) + '_Ren_tau'] * len(N_list)
m.params['Rabi_tau_Sweep'] = tau_list
m.params['pts'] = len(m.params['Rabi_N_Sweep'])
###############
# tomo params #
###############
m.params['Tomography Bases'] = tomo_basis
m.params['electron_readout_orientation'] = electron_readout_orientation
# sweep stuff
if len(set(N_list)) != 1:
print 'SWEEPING N'
m.params['sweep_name'] = 'Number of pulses'
m.params['sweep_pts'] = m.params['Rabi_N_Sweep']
elif len(set(tau_list)) != 1:
print 'SWEEPING tau'
m.params['sweep_name'] = 'Rabi tau'
m.params['sweep_pts'] = m.params['Rabi_tau_Sweep']
#### parity and mbe settings
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
funcs.finish(m, upload=True, debug=False)
def Crosstalk(name,
RO_phase=0,
RO_Z=False,
C13_init_method='swap',
carbon_A=1,
carbon_B=5,
N=np.arange(4, 100, 8),
tau_list=None):
m = DD_2.Crosstalk(name)
funcs.prepare(m)
'''set experimental parameters'''
m.params[
'carbon_nr'] = carbon_A ### Carbon spin that the Ramsey is performed on
m.params[
'Carbon_B'] = carbon_B ### Carbon spin that the Rabi/Gate is performed on
m.params['reps_per_ROsequence'] = 500
m.params['C13_init_state'] = 'up'
m.params['C13_init_method'] = C13_init_method
m.params['sweep_name'] = 'Number of pulses'
m.params['C_RO_phase'] = RO_phase
m.params['C_RO_Z'] = RO_Z
m.params['el_after_init'] = '0'
m.params['Tomography Bases'] = ['Z']
m.params['electron_readout_orientation'] = 'positive'
# ### Sweep parameters
m.params['Rabi_N_Sweep'] = [0] + N
if tau_list == None:
tau_list = m.params['C' + str(carbon_B) + '_Ren_tau' +
m.params['electron_transition']] * len(N)
m.params['Rabi_tau_Sweep'] = m.params['C' + str(
carbon_B) + '_Ren_tau' + m.params['electron_transition']] + tau_list
m.params['pts'] = len(m.params['Rabi_N_Sweep'])
x_tick_labels = []
for i in range(len(tau_list)):
x_tick_labels = x_tick_labels + [
str(tau_list[i] * 1e6) + ', ' + str(N_list[i])
]
# m.params['sweep_pts'] = x_tick_labels
m.params['sweep_pts'] = m.params['Rabi_N_Sweep']
m.params['Nr_C13_init'] = 1
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
funcs.finish(m, upload=True, debug=False)
def NuclearRamseyWithInitialization_unc_phase(name,
carbon_nr = 1,
carbon_init_state = 'up',
el_RO = 'positive',
el_state = 0,
check_phase_or_offset = 'phase',
check_phase = False,
debug = False):
m = DD.NuclearRamseyWithInitializationUncondCGate(name)
funcs.prepare(m)
'''Set parameters'''
if check_phase_or_offset != 'phase' and check_phase_or_offset != 'offset':
print "Wrong parameter passed to check_phase_or_offset"
return
m.params['check_phase_or_offset'] = check_phase_or_offset
m.params['check_phase'] = check_phase
### Sweep parameters
m.params['reps_per_ROsequence'] = phase_reps
m.params['C13_MBI_RO_state'] =0
m.params['pts'] = 25
if carbon_nr == 6 and SETUP == 'lt2':
m.params['pts'] = 21
m.params['add_wait_gate'] = False
# m.params['free_evolution_time'] = np.ones(m.params['pts'] )*360e-6
m.params['C_unc_phase'] = np.linspace(-60, 400,m.params['pts'])
m.params['sweep_name'] = 'phase'
m.params['sweep_pts'] = m.params['C_unc_phase']
'''Derived and fixed parameters'''
m.params['electron_readout_orientation'] = el_RO
m.params['carbon_nr'] = carbon_nr
m.params['init_state'] = carbon_init_state
m.params['electron_after_init'] = str(el_state)
if check_phase_or_offset == 'phase':
m.params['C13_MBI_threshold_list'] = [1]
else: #For offset calibration we use MBI.
m.params['C13_MBI_threshold_list'] = [1]
m.params['Nr_C13_init'] = 1
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
funcs.finish(m, upload =True, debug=debug)
def Single_C_rabi_initialized(name,
carbon_nr=1,
carbon_init_state='up',
el_RO='positive',
debug=False,
el_during_experiment=0,
C13_init_method='swap',
C13_MBI_threshold=[0],
C13_RO_basis=['Y'],
nr_of_pulses_list=np.linspace(0, 5, 6),
gate_phase='X',
reps=200):
m = DD.NuclearRabiWithInitialization(name)
funcs.prepare(m)
'''Set parameters'''
m.params['el_during_experiment'] = el_during_experiment # 1 or 0 or 'sup'
if m.params['el_during_experiment'] == 1:
m.params['el_after_init'] = '1'
else:
m.params['el_after_init'] = '0'
m.params['nr_of_pulses_list'] = nr_of_pulses_list
m.params['pts'] = len(nr_of_pulses_list)
### Derive other parameters
m.params['sweep_name'] = 'Nr of pulses'
m.params['sweep_pts'] = nr_of_pulses_list
m.params['gate_phase'] = 'C13_' + gate_phase + '_phase'
### Sweep parameters
m.params['reps_per_ROsequence'] = reps
m.params['C13_MBI_RO_state'] = 0
m.params['C13_MBI_threshold_list'] = C13_MBI_threshold
m.params['C13_init_method'] = C13_init_method
m.params['electron_readout_orientation'] = el_RO
m.params['carbon_nr'] = carbon_nr
m.params['init_state'] = carbon_init_state
m.params['C_RO_basis'] = C13_RO_basis
m.params['Nr_C13_init'] = 1
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
m.params['use_shutter'] = 0
funcs.finish(m, upload=True, debug=False)
def SweepTransferPhase(name,
transfer_begin='_m1',
transfer_end='_p1',
sweep=linspace(0, 360, 21),
invert_pop_RO=False,
el_state=0,
debug=False,
readout_pop='_m1',
delay=200e-9):
m = DD.Electrontransfercalibration_V2(name)
funcs.prepare(m)
'''Set parameters'''
### Sweep parameters
m.params['reps_per_ROsequence'] = 1000
m.params['C13_MBI_RO_state'] = 0
m.params['do_elec_transfer'] = True
### overwritten from msmnt params
####################################
### Option 1; sweep RO phase ###
####################################
m.params['pts'] = len(sweep)
m.params['phase_sweep'] = sweep
m.params['sweep_name'] = 'RO_phase sweep'
m.params['sweep_pts'] = m.params['phase_sweep']
####################################
# ### Option 2; Sweep delay ###
# ####################################
# ##determine experiment parameters##
# m.params['pts'] = len(sweep)
# m.params['delay_sweep'] = sweep
# m.params['sweep_name'] = 'delay_sweep'
# m.params['sweep_pts'] = m.params['delay_sweep']
m.params['delay'] = 230e-9
m.params['invert_pop_ro'] = invert_pop_RO
m.params['transfer_begin'] = transfer_begin
m.params['transfer_end'] = transfer_end
m.params['readout_pop'] = readout_pop
m.params['electron_after_init'] = str(el_state)
m.params['electron_readout_orientation'] = str(el_state)
m.autoconfig()
funcs.finish(m, upload=True, debug=debug)
def SimpleDecoupling_swp_tau(name,tau_min=9e-6,tau_max=10e-6,tau_step =50e-9, N =16, reps_per_ROsequence=250):
m = DD.SimpleDecoupling(name+'_tau_'+str(tau_min*1e9))
# print 'threshold =' + str(m.params['MBI_threshold'])
# print 'pulse_shape = ' +str(m.params['pulse_shape'])
# NOTE: ADDED from ElectronT1_Hermite on 23-04-2015
m.params.from_dict(qt.exp_params['samples'][SAMPLE])
m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO'])
m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO'])
m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO-integrated'])
m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+espin'])
m.params.from_dict(qt.exp_params['protocols']['cr_mod'])
m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['pulses'])
funcs.prepare(m)
if False: ### if you don't want to do MBI for this script.
m.params['MBI_threshold'] = 0
m.params['Ex_SP_amplitude'] = 0.
m.params['Ex_MBI_amplitude'] = 0.
m.params['SP_E_duration'] = 50
m.params['repump_after_MBI_A_amplitude'] = [12e-9] #20e-9
m.params['repump_after_MBI_duration'] = [200] # 50
'''set experimental parameters'''
m.params['reps_per_ROsequence'] = reps_per_ROsequence
m.params['Initial_Pulse'] ='x'
m.params['Final_Pulse'] ='-x'
m.params['Decoupling_sequence_scheme'] = 'repeating_T_elt'
# m.params['Decoupling_sequence_scheme'] = 'single_block'
Number_of_pulses = N
tau_list = np.arange(tau_min,tau_max,tau_step)
print tau_list
m.params['pts'] = len(tau_list)
m.params['Number_of_pulses'] = Number_of_pulses*np.ones(m.params['pts']).astype(int)
m.params['tau_list'] = tau_list
m.params['sweep_pts'] = tau_list*1e6
m.params['sweep_name'] = 'tau (us)'
m.params['DD_in_eigenstate'] = False
m.autoconfig()
funcs.finish(m, upload = True, debug=False)
def NuclearRamseyWithInitialization_cal(name,
carbon_nr = 5,
carbon_init_state = 'up',
el_RO = 'positive',
detuning = 0.5e3,
el_state = 0,
debug = False,
fid_transition = '_m1'):
m = DD.NuclearRamseyWithInitialization_v2(name)
funcs.prepare(m)
'''Set parameters'''
### Sweep parameters
m.params['reps_per_ROsequence'] = freq_reps
m.params['C13_MBI_RO_state'] = 0
### overwritten from msmnt params
####################################
### Option 1; Sweep waiting time ###
####################################
# 1A - Rotating frame with detuning
m.params['add_wait_gate'] = True
m.params['pts'] = 21
if carbon_nr == 6:
m.params['pts'] = 18
m.params['free_evolution_time'] = 400e-6 + np.linspace(0e-6, 3*1./detuning,m.params['pts'])
# m.params['free_evolution_time'] = 180e-6 + np.linspace(0e-6, 4*1./74e3,m.params['pts'])
m.params['C'+str(carbon_nr)+'_freq_0'] += detuning
m.params['C'+str(carbon_nr)+'_freq_1'+str(fid_transition)] += detuning
m.params['C_RO_phase'] = np.ones(m.params['pts'] )*0
m.params['sweep_name'] = 'free_evolution_time'
m.params['sweep_pts'] = m.params['free_evolution_time']
'''Derived and fixed parameters'''
#
m.params['electron_readout_orientation'] = el_RO
m.params['carbon_nr'] = carbon_nr
m.params['init_state'] = carbon_init_state
m.params['electron_after_init'] = str(el_state)
m.params['Nr_C13_init'] = 1
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
funcs.finish(m, upload =True, debug=debug)
def Transfer_gate_calibration(name,
carbon_nr=1,
carbon_init_state='up',
el_RO='positive',
detuning=0.5e3,
el_state=1,
debug=False,
fid_transition='m1',
sweep=400e-6 + np.linspace(0., 6.0e-3, 44),
dyn_dec_wait=False):
m = DD.Transfer_gate_calibration(name)
funcs.prepare(m)
'''Set parameters'''
### Sweep parameters
m.params['reps_per_ROsequence'] = 500
m.params['C13_MBI_RO_state'] = 0
### overwritten from msmnt params
###########################################
## Option 1; Sweep RO phase at set time ###
###########################################
if fid_transition == '_m1':
m.params['first_transition'] = fid_transition
m.params['second_transition'] = '_p1'
else:
m.params['first_transition'] = fid_transition
m.params['second_transition'] = '_m1'
m.params['pts'] = len(sweep)
m.params['add_wait_gate'] = False
m.params['add_transfer_gate'] = True
m.params['C_RO_phase'] = sweep
m.params['sweep_name'] = 'phase'
m.params['sweep_pts'] = sweep
'''Derived and fixed parameters'''
m.params['electron_readout_orientation'] = el_RO
m.params['carbon_nr'] = carbon_nr
m.params['init_state'] = carbon_init_state
m.params['electron_after_init'] = str(el_state)
m.params['Nr_C13_init'] = 1
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
funcs.finish(m, upload=True, debug=debug)
def NuclearInitializationWithRemoteInitialization(name,
carbon_nr=5,
carbon_init_state='up',
el_RO='positive',
detuning=0.5e3,
el_state=0,
beating_wait_time=1e-6,
free_evolution_time=400e-6 +
np.linspace(0., 6.0e-3, 44),
debug=False):
m = DD.NuclearInitializationWithRemoteInitialization(name)
funcs.prepare(m)
'''Set parameters'''
m.params['C13_MBI_RO_state'] = 0
m.params['C13_MBI_threshold_list'] = [1, 1]
m.params['beating_wait_time'] = beating_wait_time - (
(m.params['C13_MBI_RO_duration'] + m.params['SP_duration_after_C13']) *
1e-6 + 20e-6)
m.params[
'add_wait_gate'] = True #could be removed, does the beating wait gate and ramsey times
m.params['reps_per_ROsequence'] = 250
### Sweep parameters
m.params['Tomography Bases'] = TD.get_tomo_bases(nr_of_qubits=1)
m.params['pts'] = len(m.params['Tomography Bases'])
m.params['sweep_name'] = 'Tomography Bases'
m.params['sweep_pts'] = []
# m.params['free_evolution_time'] = free_evolution_time
# m.params['sweep_name'] = 'free_evolution_time'
# m.params['sweep_pts'] = m.params['free_evolution_time']
# m.params['C'+str(carbon_nr)+'_freq_0'] += detuning
# m.params['C'+str(carbon_nr)+'_freq_1'+m.params['electron_transition']] += detuning
m.params['C_RO_phase'] = np.ones(m.params['pts']) * 0
'''Derived and fixed parameters'''
m.params['electron_readout_orientation'] = el_RO
m.params['carbon_nr'] = carbon_nr
m.params['init_state'] = carbon_init_state
m.params['electron_after_init'] = str(el_state)
m.params['Nr_C13_init'] = 2
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
funcs.finish(m, upload=True, debug=debug)
def Crosstalk_vs2(name, C_measured = 5, C_gate = 1, RO_phase=0, RO_Z=False, C13_init_method = 'MBI',
N_list = np.arange(4,300,24), debug = False,el_RO= 'positive',el_state = 0, nr_of_gates = 1,smart_sweep_pts=False,estimate_phase=0):
m = DD.Nuclear_Crosstalk(name)
funcs.prepare(m)
'''set experimental parameters'''
m.params['carbon_nr'] = C_measured ### Carbon spin that the Ramsey is performed on
m.params['Carbon_B'] = C_gate ### Carbon spin that the Rabi/Gate is performed on
m.params['reps_per_ROsequence'] = crosstalk_reps
m.params['init_state'] = 'up'
# m.params['nr_of_gates'] = nr_of_gates
m.params['pts'] = 16
# if C_measured == 6:
# m.params['pts'] = 16
if smart_sweep_pts:
if np.mod(m.params['pts'],2)!=0:
print 'to use smart data points, the number of points has to be even. Changing # pts: ', m.params['pts'], ' to # pts: ' , m.params['pts']+1
m.params['pts']+=1
print m.params['pts']
#estimate_phase=m.params['C'+str(C_gate)+'_Ren_extra_phase_correction_list'+electron_transition_string][C_measured]
print 'estimated phase for params = ', estimate_phase
phases_a = np.round(np.mod(np.rad2deg(np.arccos(np.linspace(-1,1,(m.params['pts']/2-2)))) - estimate_phase, 360))
phases_b = np.mod(phases_a[1:-1] + 180, 360)
phases_ab = np.sort(np.append(phases_a,phases_b))
phases = np.sort(np.append(phases_ab,(phases_ab[:6]+360)))
m.params['C_RO_phase'] = phases
print m.params['C_RO_phase']
else:
m.params['C_RO_phase'] = np.linspace(-60, 400,m.params['pts'])
m.params['sweep_name'] = 'phase'
m.params['sweep_pts'] = m.params['C_RO_phase']
'''Derived and fixed parameters'''
m.params['electron_readout_orientation'] = el_RO
m.params['Nr_C13_init'] = 1
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
funcs.finish(m, upload =True, debug=debug)
def Carbon_Ramsey(name,
tau=None,
N=None,
carbon=1,
evolution_times=[],
debug=False):
m = DD.NuclearRamsey_v2(name)
funcs.prepare(m)
'''set experimental parameters'''
m.params['reps_per_ROsequence'] = 500 #Repetitions of each data point
m.params['Initial_Pulse'] = 'x'
m.params['Final_Pulse'] = '-x'
m.params['Decoupling_sequence_scheme'] = 'repeating_T_elt'
m.params['addressed_carbon'] = carbon
### Sweep parmater
m.params['free_evolution_times'] = evolution_times
m.params['pts'] = len(m.params['free_evolution_times'])
m.params['sweep_pts'] = m.params['free_evolution_times']
m.params['sweep_name'] = 'Free evolution time'
print 'free evolution times: %s' % m.params['free_evolution_times']
if N == None:
m.params['C_Ren_N' + m.params['electron_transition']] = m.params[
'C' + str(m.params['addressed_carbon']) + '_Ren_N' +
m.params['electron_transition']][0]
else:
m.params['C_Ren_N' + m.params['electron_transition']] = N
if tau == None:
m.params['C_Ren_tau' + m.params['electron_transition']] = m.params[
'C' + str(m.params['addressed_carbon']) + '_Ren_tau' +
m.params['electron_transition']][0]
else:
m.params['C_Ren_tau' + m.params['electron_transition']] = tau
m.autoconfig()
funcs.finish(m, upload=True, debug=False)
print m.params['sweep_pts']
def Crosstalk(name,
RO_phase=0,
RO_Z=False,
C13_init_method='swap',
carbon_A=1,
carbon_B=5,
N=np.arange(4, 100, 8),
tau_list=None):
m = DD.Crosstalk(name)
funcs.prepare(m)
'''set experimental parameters'''
m.params[
'Carbon_A'] = carbon_A ### Carbon spin that the Ramsey is performed on
m.params[
'Carbon_B'] = carbon_B ### Carbon spin that the Rabi/Gate is performed on
m.params['reps_per_ROsequence'] = 150
m.params['C13_init_state'] = 'up'
m.params['C13_init_method'] = C13_init_method
m.params['sweep_name'] = 'Number of pulses'
m.params['C_RO_phase'] = RO_phase
m.params['C_RO_Z'] = RO_Z
# ### Sweep parameters
m.params['Rabi_N_Sweep'] = [0] + N
if tau_list == None:
tau_list = m.params['C' + str(carbon_B) + '_Ren_tau'] * len(N)
m.params['Rabi_tau_Sweep'] = tau_list
m.params['pts'] = len(m.params['Rabi_N_Sweep'])
m.params['sweep_pts'] = m.params['Rabi_N_Sweep']
m.params['Nr_C13_init'] = 1
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
funcs.finish(m, upload=True, debug=False)
def Carbon_Ramsey(name,tau = None,N=None):
# m = DD.NuclearRamsey(name)
# m = DD.NuclearRamsey_v2(name)
m = DD.NuclearRamsey_no_elDD(name)
funcs.prepare(m)
'''set experimental parameters'''
m.params['reps_per_ROsequence'] = 200 #Repetitions of each data point
m.params['Initial_Pulse'] = 'x'
m.params['Final_Pulse'] = '-x'
m.params['Decoupling_sequence_scheme'] = 'repeating_T_elt'
m.params['addressed_carbon'] = 3
carbon_str = str(m.params['addressed_carbon'])
### Sweep paramater
# m.params['free_evolution_times'] = (np.concatenate([np.linspace(1e3,7.5e3,25).astype(int)*1e-9,
# np.linspace(15e3,22e3,25).astype(int)*1e-9]))
m.params['free_evolution_times'] = np.linspace(10e3,20e3,22).astype(int)*1e-9
m.params['pts'] = len(m.params['free_evolution_times'])
m.params['sweep_pts'] = m.params['free_evolution_times']
m.params['sweep_name'] = 'Free evolution time (us)'
print 'free evolution times: %s' %m.params['free_evolution_times']
if N ==None:
m.params['C'+carbon_str+'_Ren_N'+m.params['electron_transition']] = m.params['C'+carbon_str+'_Ren_N'+m.params['electron_transition']]
else:
m.params['C'+carbon_str+'_Ren_N'+m.params['electron_transition']] = N
if tau ==None:
m.params['C'+carbon_str+'_Ren_tau'+m.params['electron_transition']] = m.params['C'+carbon_str+'_Ren_tau'+m.params['electron_transition']]
else:
print tau
m.params['C'+carbon_str+'_Ren_tau'+m.params['electron_transition']] = tau
funcs.finish(m, upload =True, debug=False)
def NuclearRamseyWithInitialization_phase(name,
carbon_nr = 1,
carbon_init_state = 'up',
el_RO = 'positive',
el_state = 0,
debug = False):
m = DD.NuclearRamseyWithInitialization(name)
funcs.prepare(m)
'''Set parameters'''
### Sweep parameters
m.params['reps_per_ROsequence'] = phase_reps
m.params['C13_MBI_RO_state'] =0
m.params['pts'] = 25
if carbon_nr == 6 and SETUP == 'lt2':
m.params['pts'] = 21
m.params['add_wait_gate'] = False
# m.params['free_evolution_time'] = np.ones(m.params['pts'] )*360e-6
m.params['C_RO_phase'] = np.linspace(-60, 400,m.params['pts'])
m.params['sweep_name'] = 'phase'
m.params['sweep_pts'] = m.params['C_RO_phase']
'''Derived and fixed parameters'''
m.params['electron_readout_orientation'] = el_RO
m.params['carbon_nr'] = carbon_nr
m.params['init_state'] = carbon_init_state
m.params['electron_after_init'] = str(el_state)
m.params['Nr_C13_init'] = 1
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
funcs.finish(m, upload =True, debug=debug)
def SimpleDecoupling_swp_N(name,
tau=None,
NoP=np.arange(4, 254, 4),
reps_per_ROsequence=1000,
mbi=True,
readout_pulse='-x'):
m = DD.SimpleDecoupling(name + '_tau_' + str(tau * 1e9))
funcs.prepare(m)
#input parameters
m.params['reps_per_ROsequence'] = reps_per_ROsequence
Number_of_pulses = NoP
pts = len(Number_of_pulses)
if tau == None:
tau = m.params['C3_Ren_tau'][0]
tau_list = tau * np.ones(pts)
print 'tau_list =' + str(tau_list)
#inital and final pulse
m.params['Initial_Pulse'] = 'x'
m.params['Final_Pulse'] = readout_pulse
#Method to construct the sequence
m.params['Decoupling_sequence_scheme'] = 'repeating_T_elt'
m.params['pts'] = pts
m.params['tau_list'] = tau_list
m.params['Number_of_pulses'] = Number_of_pulses
m.params['sweep_pts'] = Number_of_pulses * tau_list * 1.e3
print m.params['sweep_pts']
m.params['sweep_name'] = 'Total evolution time [ms]'
m.autoconfig()
m.params['DD_in_eigenstate'] = False
funcs.finish(m, upload=True, debug=False)
def CarbonRabiWithDirectRF(name,
carbon_nr=5,
carbon_init_state='up',
el_RO='positive',
debug=True,
C13_init_method='swap',
el_after_init='1',
DoRabi=False,
RF_generation_method='AWG'):
m = DD.NuclearRabiWithDirectRF(name)
funcs.prepare(m)
### Parameters
m.params['RF_generation_method'] = RF_generation_method
m.params['reps_per_ROsequence'] = 500
m.params['C13_MBI_threshold_list'] = [1]
if el_after_init == '1':
centerfreq = m.params['C' + str(carbon_nr) + '_freq_1_m1']
if el_after_init == '0':
centerfreq = m.params['C' + str(carbon_nr) + '_freq_0']
if DoRabi:
m.params['RF_pulse_durations'] = np.linspace(100e-6, 100e-6, 1) + 3e-6
m.params['pts'] = len(m.params['RF_pulse_durations'])
m.params['RF_pulse_frqs'] = np.ones(m.params['pts']) * centerfreq
m.params['sweep_name'] = 'RF_pulse_length (us)'
m.params['sweep_pts'] = m.params['RF_pulse_durations'] / 1e-6
elif Sweep_C_RO_phase:
m.params['C_RO_phase'] = [i for i in np.linspace(0, 90, 21)
] #np.linspace(0,180,21)
m.params['pts'] = len(m.params['C_RO_phase'])
m.params['RF_pulse_durations'] = np.ones(m.params['pts']) * 10e-6
m.params['RF_pulse_frqs'] = np.ones(m.params['pts']) * centerfreq
m.params['sweep_name'] = 'RF_pulse_length (us)'
m.params['sweep_pts'] = m.params['C_RO_phase']
else:
m.params['RF_pulse_frqs'] = np.linspace(centerfreq - 100e3,
centerfreq + 100e3, 21)
m.params['pts'] = len(m.params['RF_pulse_frqs'])
m.params['RF_pulse_durations'] = np.ones(m.params['pts']) * 4e-6
m.params['sweep_name'] = 'RF_freq (kHz)'
m.params['sweep_pts'] = m.params['RF_pulse_frqs'] / 1e3
m.params['RF_pulse_phases'] = np.ones(m.params['pts']) * 180.
m.params['RF_pulse_amps'] = np.ones(m.params['pts']) * 0.7
m.params['C13_init_method'] = 'swap' #C13_init_method
m.params['C_RO_phase'] = [
'Z'
] #[0] #['X'] # np.ones(m.params['pts'] )*0 # m.params['pts']*['X']
m.params['electron_readout_orientation'] = el_RO
m.params['carbon_nr'] = carbon_nr
m.params['init_state'] = 'up' #carbon_init_state
m.params['el_after_init'] = el_after_init
m.params['Nr_C13_init'] = 1
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
funcs.finish(m, upload=True, debug=debug)
def MBE(name, carbon = 1,
carbon_init_list = [1],
carbon_init_states = ['up'],
carbon_init_methods = ['swap'],
carbon_init_thresholds = [0],
el_RO = 'positive',
tomo = 'Z',
debug = False):
m = DD.Sweep_Z_init_phase_v2(name)
funcs.prepare(m)
m.params['el_after_init'] = '0'
m.params['C13_MBI_threshold_list'] = carbon_init_thresholds
''' set experimental parameters '''
m.params['reps_per_ROsequence'] = 500
pts = 61
# Sweep parameters, sweep the wait time around 1/hf_parallel
el_trans = qt.exp_params['samples'][SAMPLE]['electron_transition']
A = abs(m.params['C'+str(c) + '_freq_0'] - m.params['C'+str(c) + '_freq_1' + str(el_trans)])
print 'C' + str(c) + 'Coupling Strength: ' + str(A)
m.params['wait_time_list'] = np.linspace(5e-6, 70e-6,pts)
### Carbons to be used
m.params['carbon_list'] = [carbon]
### Carbon Initialization settings
m.params['carbon_init_list'] = carbon_init_list
m.params['init_method_list'] = carbon_init_methods
m.params['init_state_list'] = carbon_init_states
m.params['Nr_C13_init'] = len(carbon_init_list)
##################################
### RO bases (sweep parameter) ###
##################################
m.params['Tomography Bases'] = [[tomo]]*pts
####################
### MBE settings ###
####################
m.params['Nr_MBE'] = 0
m.params['MBE_bases'] = []
m.params['MBE_threshold'] = 1
###################################
### Parity measurement settings ###
###################################
m.params['Nr_parity_msmts'] = 0
m.params['Parity_threshold'] = 1
### Derive other parameters
m.params['pts'] = len(m.params['wait_time_list'])
m.params['sweep_name'] = 'wait_times'
m.params['sweep_pts'] = m.params['wait_time_list']
print m.params['sweep_pts']
### RO params
m.params['electron_readout_orientation'] = el_RO
funcs.finish(m, upload =True, debug=debug)
def MBE(name,
carbon_list=[1],
carbon_init_list=[1],
carbon_init_states=['up'],
carbon_init_methods=['MBI'],
carbon_init_thresholds=[1],
number_of_MBE_steps=1,
mbe_bases=['Y'],
MBE_threshold=1,
number_of_parity_msmnts=0,
parity_msmnts_threshold=1,
e_RO_pulse='none',
el_RO='positive',
debug=False):
m = DD.electron_carbon_density_matrix(name)
funcs.prepare(m)
m.params['C13_MBI_threshold_list'] = carbon_init_thresholds
''' set experimental parameters '''
m.params['reps_per_ROsequence'] = 4000
### Carbons to be used
m.params['carbon_list'] = carbon_list
### Carbon Initialization settings
m.params['carbon_init_list'] = carbon_init_list
m.params['init_method_list'] = carbon_init_methods
m.params['init_state_list'] = carbon_init_states
m.params['Nr_C13_init'] = len(carbon_init_list)
m.params['el_after_init'] = '0'
##################################
### RO bases (sweep parameter) ###
##################################
m.params['Tomography Bases'] = ([['X'], ['Y'], ['Z']])
m.params['electron_RO_pulse'] = e_RO_pulse
####################
### MBE settings ###
####################
m.params['Nr_MBE'] = number_of_MBE_steps
m.params['MBE_bases'] = mbe_bases
m.params['MBE_threshold'] = MBE_threshold
m.params['logical_state'] = 'X'
###################################
### Parity measurement settings ###
###################################
m.params['Nr_parity_msmts'] = 0
m.params['Parity_threshold'] = parity_msmnts_threshold
### Derive other parameters
m.params['pts'] = len(m.params['Tomography Bases'])
m.params['sweep_name'] = 'Tomography Bases'
m.params['sweep_pts'] = []
### RO params
m.params['electron_readout_orientation'] = el_RO
for BP in m.params['Tomography Bases']:
m.params['sweep_pts'].append(BP[0])
print m.params['sweep_pts']
funcs.finish(m, upload=True, debug=debug)
def MBE(name,
carbon_list=[5, 1],
carbon_init_list=[1, 5],
carbon_init_states=2 * ['up'],
carbon_init_methods=2 * ['swap'],
carbon_init_thresholds=2 * [0],
number_of_MBE_steps=0,
mbe_bases=['X', 'X'],
MBE_threshold=1,
number_of_parity_msmnts=0,
parity_msmnts_threshold=1,
el_RO='positive',
debug=False):
m = DD.Two_QB_Probabilistic_MBE(name)
funcs.prepare(m)
m.params['C13_MBI_threshold_list'] = carbon_init_thresholds
''' set experimental parameters '''
m.params['reps_per_ROsequence'] = 1000
### Carbons to be used
m.params['carbon_list'] = carbon_list
### Carbon Initialization settings
m.params['carbon_init_list'] = carbon_init_list
m.params['init_method_list'] = carbon_init_methods
m.params['init_state_list'] = carbon_init_states
m.params['Nr_C13_init'] = len(carbon_init_list)
m.params['el_after_init'] = '0'
##################################
### RO bases (sweep parameter) ###
##################################
#m.params['Tomography Bases'] = 'full'
m.params['Tomography Bases'] = ([['X', 'I'], ['Y', 'I'], ['Z', 'I'],
['I', 'X'], ['I', 'Y'], ['I', 'Z'],
['X', 'X'], ['X', 'Y'], ['X', 'Z'],
['Y', 'X'], ['Y', 'Y'], ['Y', 'Z'],
['Z', 'X'], ['Z', 'Y'], ['Z', 'Z']])
# m.params['Tomography Bases'] = ([
# ['X','I'],['Y','I'],['Z','I'],
# ['I','X'],['I','Y'],['I','Z']])
# m.params['Tomography Bases'] = ([
# ['X','X'],['X','Y'],['X','Z'],
# ['Y','X'],['Y','Y'],['Y','Z'],
# ['Z','X'],['Z','Z']])
# m.params['Tomography Bases'] = ([
# ['X','I'],['Y','I'],['Z','I']])
# m.params['Tomography Bases'] = ([['I','X'],['X','I'],['X','X']])#,['Y','X'],['Y','Y'],['X','X'],['I','Y'],['Y','I']])
# m.params['Tomography Bases'] = ([
# ['X','I','I'],['Y','I','I'],['Z','I','I'],
# ['I','X','I'],['I','Y','I'],['I','Z','I'],
# ['I','I','X'],['I','I','Y'],['I','I','Z']])
# m.params['Tomography Bases'] = TD.get_tomo_bases(nr_of_qubits = 1)
####################
### MBE settings ###
####################
m.params['Nr_MBE'] = number_of_MBE_steps
m.params['MBE_bases'] = mbe_bases
m.params['MBE_threshold'] = MBE_threshold
###################################
### Parity measurement settings ###
###################################
m.params['Nr_parity_msmts'] = number_of_parity_msmnts
m.params['Parity_threshold'] = parity_msmnts_threshold
### Derive other parameters
m.params['pts'] = len(m.params['Tomography Bases'])
m.params['sweep_name'] = 'Tomography Bases'
m.params['sweep_pts'] = []
### RO params
m.params['electron_readout_orientation'] = el_RO
for BP in m.params['Tomography Bases']:
if len(carbon_list) == 2:
m.params['sweep_pts'].append(BP[0] + BP[1])
elif len(carbon_list) == 3:
m.params['sweep_pts'].append(BP[0] + BP[1] + BP[2])
print m.params['sweep_pts']
funcs.finish(m, upload=True, debug=debug)
def MBE(name, carbon = 1,
carbon_init_list = [1],
carbon_init_states = ['up'],
carbon_init_methods = ['swap'],
carbon_init_thresholds = [0],
el_RO = 'positive',
debug = False):
m = DD.Two_QB_Probabilistic_MBE(name)
funcs.prepare(m)
m.params['el_after_init'] = '0'
m.params['C13_MBI_threshold_list'] = carbon_init_thresholds
''' set experimental parameters '''
m.params['reps_per_ROsequence'] = 1000
### Carbons to be used
m.params['carbon_list'] = [carbon]
### Carbon Initialization settings
m.params['carbon_init_list'] = carbon_init_list
m.params['init_method_list'] = carbon_init_methods
m.params['init_state_list'] = carbon_init_states
m.params['Nr_C13_init'] = len(carbon_init_list)
##################################
### RO bases (sweep parameter) ###
##################################
m.params['Tomography Bases'] = TD.get_tomo_bases(nr_of_qubits = 1)
# m.params['Tomography Bases'] = [['X'],['Y'],['Z']]
# m.params['Tomography Bases'] = [['X'],['Y']]
# m.params['Tomography Bases'] = [['X']]
####################
### MBE settings ###
####################
m.params['Nr_MBE'] = 0
m.params['MBE_bases'] = []
m.params['MBE_threshold'] = 1
###################################
### Parity measurement settings ###
###################################
m.params['Nr_parity_msmts'] = 0
m.params['Parity_threshold'] = 1
### Derive other parameters
m.params['pts'] = len(m.params['Tomography Bases'])
m.params['sweep_name'] = 'Tomography Bases'
m.params['sweep_pts'] = []
### RO params
m.params['electron_readout_orientation'] = el_RO
for BP in m.params['Tomography Bases']:
m.params['sweep_pts'].append(BP[0])
funcs.finish(m, upload =True, debug=debug)
def SweepGates(name,**kw):
debug = kw.pop('debug',False)
carbon = kw.pop('carbon',False)
el_RO = kw.pop('el_RO','positive')
tau_list = kw.pop('tau_list',None)
N_list = kw.pop('N_list',None)
m = DD.Sweep_Carbon_Gate(name)
funcs.prepare(m)
m.params['C13_MBI_threshold_list'] = [1]
m.params['el_after_init'] = '0'
''' set experimental parameters '''
m.params['reps_per_ROsequence'] = 1000
### Carbons to be used
m.params['carbon_list'] =[carbon]
########################################
### Carbon Initialization settings #####
########################################
m.params['carbon_init_list'] = [carbon]
m.params['init_method_list'] = ['MBI']
m.params['init_state_list'] = ['up']
m.params['Nr_C13_init'] = 1
##################################
### RO bases,timing and number of pulses (sweep parameters) ###
##################################
m.params['carbon_gate_dd_scheme'] = 'repeating_T_elt'
# print m.params['electron_transition']
if N_list == None or tau_list == None:
# takes from msts.params
com_list,m.params['N_list'],m.params['tau_list'],m.params['Tomography Bases'] = put_sweep_together(m.params['C'+str(carbon)+
'_gate_optimize_N_list'+m.params['electron_transition']],m.params['C'+str(carbon)+'_gate_optimize_tau_list'+m.params['electron_transition']])
else:
com_list,m.params['N_list'],m.params['tau_list'],m.params['Tomography Bases'] = put_sweep_together(N_list,tau_list)
####################
### MBE settings ###
####################
m.params['Nr_MBE'] = 0
m.params['MBE_bases'] = []
m.params['MBE_threshold'] = 1
###################################
### Parity measurement settings ###
###################################
m.params['Nr_parity_msmts'] = 0
m.params['Parity_threshold'] = 1
# print com_list
### Derive other parameters
m.params['pts'] = len(com_list)
#another init param
m.params['init_phase_list'] = [0]*m.params['pts'] #someone hardcoded a swap phase in there. We dont do swap -> put it to whatever
m.params['sweep_name'] = 'Tomo N and tau'
m.params['sweep_pts'] = com_list
### RO params
m.params['electron_readout_orientation'] = el_RO
funcs.finish(m, upload =True, debug=debug)
def NuclearHahnWithInitialization(name,
carbon_nr=5,
carbon_init_state='up',
el_RO='positive',
debug=False,
C13_init_method='MBI',
C13_MBI_RO_state=0,
el_after_init=1,
shutter=False):
m = DD.NuclearHahnEchoWithInitialization(name)
funcs.prepare(m)
'''Set parameters'''
### Sweep parameters
m.params[
'C13_MBI_RO_state'] = C13_MBI_RO_state # Initalize in ms_=-1 to decouple nuclear spins
m.params['C13_MBI_threshold_list'] = [1]
m.params['el_after_init'] = el_after_init
# m.params['C13_MBI_RO_duration'] = 100 #Chaning readout laser duration to ensure m_s=-1
# m.params['SP_duration_after_C13'] = 20
# m.params['A_SP_amplitude_after_C13_MBI'] = 0*15e-9
### overwritten from msmnt params
####################################
### Option 1; Sweep waiting time ###
####################################
### 1B - Lab frame
m.params['add_wait_gate'] = True
m.params['use_shutter'] = int(shutter)
if el_after_init == 0:
m.params['reps_per_ROsequence'] = 1000
m.params['free_evolution_time'] = np.linspace(
2e-3, 60e-3, 15) #np.arange(2e-3, 60e-3, 4e-3)
m.params['pts'] = len(m.params['free_evolution_time'])
m.params['use_shutter'] = 0
if el_after_init == 1:
# m.params['free_evolution_time'] = np.r_[4e-3,25e-3, 50e-3,100e-3, 200e-3, 350e-3, 600e-3, 1.]
m.params['reps_per_ROsequence'] = 500
m.params['free_evolution_time'] = np.linspace(5e-3, 0.15, 15) #[0:2]
m.params['pts'] = len(m.params['free_evolution_time'])
m.params['use_shutter'] = 0
m.params['C_RO_phase'] = m.params['pts'] * ['X']
m.params['sweep_name'] = 'Total_free_evolution_time'
m.params['sweep_pts'] = m.params['free_evolution_time'] * 2
############################################
### Option 2; Sweep RO phase at set time ###
############################################
# m.params['pts'] = 21
# m.params['add_wait_gate'] = False
# m.params['free_evolution_time'] = np.ones(m.params['pts'] )*360e-6
# m.params['C_RO_phase'] = np.linspace(-20, 400,m.params['pts'])
# m.params['sweep_name'] = 'phase'
# m.params['sweep_pts'] = m.params['C_RO_phase']
'''Derived and fixed parameters'''
m.params['C13_init_method'] = C13_init_method
m.params['electron_readout_orientation'] = el_RO
m.params['carbon_nr'] = carbon_nr
m.params['init_state'] = carbon_init_state
m.params['Nr_C13_init'] = 1
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
funcs.finish(m, upload=True, debug=debug)
def generate_sequence(self, upload=True, debug=False):
"""
generate the sequence for the purification experiment.
Tries to be as general as possible in order to suffice for multiple calibration measurements
"""
### initialize empty sequence and elements
combined_list_of_elements = []
combined_seq = pulsar.Sequence('Purification')
### create a list of gates according to the current sweep.
for pt in range(self.params['pts']):
#sweep parameter
if self.params['do_general_sweep'] == 1:
self.params[self.params['general_sweep_name']] = self.params[
'general_sweep_pts'][pt]
gate_seq = []
### LDE elements: WE have two LDE elements with potentially different functions
LDE1 = DD.Gate('LDE1' + str(pt), 'LDE')
LDE1.el_state_after_gate = 'sup'
if self.params['LDE1_attempts'] > 1:
LDE1.reps = self.params['LDE1_attempts'] - 1
LDE1.is_final = False
LDE1_final = DD.Gate('LDE1_final_' + str(pt), 'LDE')
LDE1_final.el_state_after_gate = 'sup'
LDE1_final.reps = 1
LDE1_final.is_final = True
else:
LDE1.is_final = True
if self.params['LDE1_attempts'] != 1:
LDE1.reps = self.params['LDE1_attempts'] - 1
### LDE elements need rephasing or repumping elements
LDE_rephase1 = DD.Gate(
'LDE_rephasing_1' + str(pt),
'single_element',
wait_time=self.params['average_repump_time'])
LDE_rephase1.scheme = 'single_element'
LDE_repump1 = DD.Gate('LDE_repump_1_' + str(pt), 'Trigger')
LDE_repump1.duration = 2e-6
LDE_repump1.elements_duration = LDE_repump1.duration
LDE_repump1.channel = 'AOM_Newfocus'
LDE_repump1.el_state_before_gate = '0'
e_RO = [
DD.Gate('Tomo_Trigger_' + str(pt), 'Trigger', wait_time=10e-6)
]
#######################################################################
### append all necessary gates according to the current measurement ###
#######################################################################
if self.params['do_N_MBI'] > 0:
### Nitrogen MBI
mbi = DD.Gate('MBI_' + str(pt), 'MBI')
gate_seq.append(mbi)
# this could be used for the synchronization of the two setups
# gate_seq.append(DD.Gate('dummy_wait'+str(pt),'passive_elt',wait_time = 3e-6))
if self.params['do_carbon_init'] > 0:
### initialize carbon in +Z or +X
carbon_init_seq = self.initialize_carbon_sequence(
go_to_element='start',
prefix='C_Init',
pt=pt,
addressed_carbon=self.params['carbon'],
initialization_method=self.params['carbon_init_method'])
if gate_seq != []:
carbon_init_seq[0].wait_for_trigger = False
gate_seq.extend(carbon_init_seq)
#### insert a MW pi pulse when repumping
if self.params['MW_before_LDE1'] > 0:
mw_pi = DD.Gate('elec_pi_' + str(pt),
'electron_Gate',
Gate_operation='pi')
if gate_seq == []:
mw_pi.wait_for_trigger = True
gate_seq.append(mw_pi)
if self.params['do_LDE_1'] > 0:
### needs corresponding adwin parameter
if gate_seq == []:
LDE1.wait_for_trigger = True
gate_seq.append(LDE1)
# print 'LDE1 reps',LDE1.reps
### append last adwin synchro element
if not LDE1.is_final:
gate_seq.append(LDE1_final)
if self.params['do_swap_onto_carbon'] > 0:
gate_seq.append(LDE_rephase1)
elif self.params['LDE_1_is_init'] == 0 and self.params[
'opt_pi_pulses'] < 2 and self.params[
'no_repump_after_LDE1'] == 0:
gate_seq.append(LDE_repump1)
# gate_seq.append(DD.Gate('LDE_1_wait'+str(pt),'passive_elt',wait_time = 3e-6))
if self.params['do_swap_onto_carbon'] > 0:
### Elementes for swapping
swap_with_init = self.carbon_swap_gate(
go_to_element='start',
pt=pt,
addressed_carbon=self.params['carbon'],
swap_type='swap_w_init',
RO_after_swap=True)
if self.params['do_carbon_init'] > 0:
### important to realize that the tau_cut of a potential decoupling sequence can alter the
### electron rephasing element. --> Therefore the element has to be rebuilt
self.generate_LDE_rephasing_elt(LDE_rephase1)
gate_seq.extend(swap_with_init)
else:
self.generate_LDE_rephasing_elt(LDE_rephase1)
gate_seq.extend(swap_with_init)
print '*' * 20
print 'Warning ' * 4
print 'Swap without initialization not implemented'
print '*' * 20
if self.params['do_LDE_2'] > 0:
if gate_seq == []:
LDE2.wait_for_trigger = True
gate_seq.append(LDE2)
# need a final element for adwin communication
if self.params['LDE2_attempts'] > 1:
gate_seq.append(LDE2_final)
if (self.params['do_purifying_gate'] > 0
or self.params['do_phase_correction'] > 0
) and self.params['do_repump_after_LDE2'] == 0:
# electron has to stay coherent after LDE attempts
self.generate_LDE_rephasing_elt(LDE_rephase2)
gate_seq.append(LDE_rephase2)
else: # this is used if we sweep the number of repetitions for Qmemory testing.
gate_seq.append(LDE_repump2)
if self.params['do_phase_correction'] > 0 and self.params[
'phase_correct_max_reps'] > 0:
gate_seq.extend(dynamic_phase_correct_list)
if self.params['do_purifying_gate'] > 0:
gate_seq.extend(carbon_purify_seq)
if self.params['do_carbon_readout'] > 0:
if self.params['do_purifying_gate'] > 0:
### prepare branching of the sequence
gate_seq0 = copy.deepcopy(gate_seq)
gate_seq1 = copy.deepcopy(gate_seq)
carbon_tomo_seq0 = self.readout_carbon_sequence(
prefix='Tomo0',
pt=pt,
go_to_element=None,
event_jump_element=None,
RO_trigger_duration=10e-6,
el_state_in=0,
carbon_list=[self.params['carbon']],
RO_basis_list=self.params['Tomography_bases'],
readout_orientation=self.
params['carbon_readout_orientation'])
gate_seq0.extend(carbon_tomo_seq0)
carbon_tomo_seq1 = self.readout_carbon_sequence(
prefix='Tomo1',
pt=pt,
go_to_element=None,
event_jump_element=None,
RO_trigger_duration=10e-6,
el_state_in=1,
carbon_list=[self.params['carbon']],
RO_basis_list=self.params['Tomography_bases'],
readout_orientation=self.
params['carbon_readout_orientation'])
gate_seq1.extend(carbon_tomo_seq1)
# Make jump statements for branching to two different ROs
gate_seq[-1].go_to = carbon_tomo_seq1[0].name
gate_seq[-1].event_jump = carbon_tomo_seq0[0].name
# In the end all roads lead to Rome
Rome = DD.Gate('Rome_' + str(pt),
'passive_elt',
wait_time=3e-6)
gate_seq1.append(Rome)
gate_seq0[-1].go_to = gate_seq1[-1].name
# take care of electron states after the purification msmt. I.e. the electron state is set during the trigger.
gate_seq0[len(gate_seq) -
1].el_state_before_gate = '0' #Element -1
gate_seq1[len(gate_seq) -
1].el_state_before_gate = '1' #Element -1
### generate and merge branches
gate_seq = self.generate_AWG_elements(gate_seq, pt)
gate_seq0 = self.generate_AWG_elements(gate_seq0, pt)
gate_seq1 = self.generate_AWG_elements(gate_seq1, pt)
merged_sequence = []
merged_sequence.extend(gate_seq)
merged_sequence.extend(gate_seq0[len(gate_seq):])
merged_sequence.extend(gate_seq1[len(gate_seq):])
gate_seq = copy.deepcopy(
merged_sequence) # for further processing
else: ### no purifying gate --> we don't need branching!
carbon_tomo_seq = self.readout_carbon_sequence(
prefix='Tomo',
pt=pt,
go_to_element=None,
event_jump_element=None,
RO_trigger_duration=10e-6,
el_state_in=0,
carbon_list=[self.params['carbon']],
RO_basis_list=self.params['Tomography_bases'],
readout_orientation=self.
params['carbon_readout_orientation'])
gate_seq.extend(carbon_tomo_seq)
# e_RO = [DD.Gate('Tomo_Trigger_'+str(pt),'Trigger',
# wait_time = 20e-6)]
# gate_seq.extend(e_RO)
# print 'This is the tomography base', self.params['Tomography_bases']
else: #No carbon spin RO? Do espin RO!
if self.params['do_purifying_gate'] == 0:
gate_seq.extend(e_RO)
###############################################
# prepare and program the actual AWG sequence #
###############################################
#### insert elements here
if not (self.params['do_purifying_gate'] > 0
and self.params['do_carbon_readout'] > 0):
gate_seq = self.generate_AWG_elements(gate_seq, pt)
#### for carbon phase debbuging purposes.
# for g in gate_seq:
# if not 'correct' in g.name:
# print g.name
# self.print_carbon_phases(g,[self.params['carbon']],verbose=True)
### Convert elements to AWG sequence and add to combined list
list_of_elements, seq = self.combine_to_AWG_sequence(gate_seq,
explicit=True)
combined_list_of_elements.extend(list_of_elements)
for seq_el in seq.elements:
combined_seq.append_element(seq_el)
if upload:
print ' uploading sequence'
qt.pulsar.program_awg(combined_seq,
*combined_list_of_elements,
debug=debug)
def MBE(name,
carbon=1,
carbon_init_list=[1],
carbon_init_states=['up'],
carbon_init_methods=['swap'],
carbon_init_thresholds=[0],
el_RO='positive',
tomo='Z',
debug=False):
m = DD.Sweep_Z_init_phase(name)
funcs.prepare(m)
m.params['el_after_init'] = '0'
m.params['C13_MBI_threshold_list'] = carbon_init_thresholds
''' set experimental parameters '''
m.params['reps_per_ROsequence'] = 500
pts = 20
m.params['init_phase_list'] = np.linspace(-90, 90, pts)
### Carbons to be used
m.params['carbon_list'] = [carbon]
### Carbon Initialization settings
m.params['carbon_init_list'] = carbon_init_list
m.params['init_method_list'] = carbon_init_methods
m.params['init_state_list'] = carbon_init_states
m.params['Nr_C13_init'] = len(carbon_init_list)
##################################
### RO bases (sweep parameter) ###
##################################
m.params['Tomography Bases'] = [[tomo]] * pts
####################
### MBE settings ###
####################
m.params['Nr_MBE'] = 0
m.params['MBE_bases'] = []
m.params['MBE_threshold'] = 1
###################################
### Parity measurement settings ###
###################################
m.params['Nr_parity_msmts'] = 0
m.params['Parity_threshold'] = 1
### Derive other parameters
m.params['pts'] = len(m.params['init_phase_list'])
m.params['sweep_name'] = 'Init_phases'
m.params['sweep_pts'] = m.params['init_phase_list']
### RO params
m.params['electron_readout_orientation'] = el_RO
funcs.finish(m, upload=True, debug=debug)
def SWAP(name,
carbon=1,
carbon_init_states=['up'],
carbon_init_methods=['swap'],
carbon_init_thresholds=[0, 1],
elec_init_state=['Z'],
RO_after_swap=True,
el_RO='positive',
debug=False,
swap_type='swap_w_init'):
m = DD.elec_to_carbon_swap(name)
funcs.prepare(m)
''' set experimental parameters '''
m.params['reps_per_ROsequence'] = 800
m.params['C13_MBI_threshold_list'] = carbon_init_thresholds
m.params['el_after_init'] = '0'
######################################
### Carbon Initialization settings ###
######################################
m.params['carbon_init_list'] = [carbon]
m.params['init_method_list'] = carbon_init_methods
m.params['init_state_list'] = carbon_init_states
m.params['Nr_C13_init'] = len(carbon_init_thresholds)
m.params['SWAP_type'] = swap_type
### Carbon to be used
m.params['carbon_list'] = [carbon]
##############################
### Electron intialisation ###
##############################
m.params['elec_init_state'] = elec_init_state
##########################
### ELECTRON repumping ###
##########################
m.params['RO_after_swap'] = RO_after_swap
m.params['Repump_duration'] = 5e-6
####################
### MBE settings ###
####################
m.params['Nr_MBE'] = 0
m.params['MBE_bases'] = []
m.params['MBE_threshold'] = 1
###################################
### Parity measurement settings ###
###################################
m.params['Nr_parity_msmts'] = 0
m.params['Parity_threshold'] = 1
### ###############
### Tomo params ###
###################
m.params['Tomography Bases'] = [['X'], ['Y'], ['Z']]
m.params['pts'] = len(m.params['Tomography Bases'])
m.params['sweep_name'] = 'Tomography Bases'
m.params['sweep_pts'] = []
### RO params
m.params['electron_readout_orientation'] = el_RO
for BP in m.params['Tomography Bases']:
m.params['sweep_pts'].append(BP[0])
funcs.finish(m, upload=True, debug=debug)
def SimpleDecoupling_swp_N(name,
tau=None,
NoP=np.arange(4, 254, 4),
reps_per_ROsequence=1000,
mbi=True):
m = DD.SimpleDecoupling(name + '_tau_' + str(tau * 1e9))
"""
##### MODIFICATION FOR LT1 ######
"""
# m.params.from_dict(qt.exp_params['samples'][SAMPLE])
# m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO'])
# m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO'])
# m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO-integrated'])
# # m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO+MBI'])
# m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+MBI'])
# m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+espin'])
# m.params.from_dict(qt.exp_params['protocols']['cr_mod'])
# m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['pulses'])
# Default values when no MBI
# # Default values when no MBI
# if mbi == False:
# m.params['MBI_threshold'] = 0
# m.params['Ex_SP_amplitude'] = 0
# m.params['Ex_MBI_amplitude'] = 0
# m.params['SP_E_duration'] = 20 #2000
# m.params['repump_after_MBI_A_amplitude'] = [15e-9]
# m.params['repump_after_MBI_duration'] = [300] # 50
# """
# END MODIFICATIONS FOR LT1
# """
funcs.prepare(m)
#input parameters
m.params['reps_per_ROsequence'] = reps_per_ROsequence
Number_of_pulses = NoP
pts = len(Number_of_pulses)
if tau == None:
tau = m.params['C3_Ren_tau'][0]
tau_list = tau * np.ones(pts)
print 'tau_list =' + str(tau_list)
#inital and final pulse
m.params['Initial_Pulse'] = 'x'
m.params['Final_Pulse'] = '-x'
#Method to construct the sequence
m.params['Decoupling_sequence_scheme'] = 'repeating_T_elt'
m.params['pts'] = pts
m.params['tau_list'] = tau_list
m.params['Number_of_pulses'] = Number_of_pulses
m.params['sweep_pts'] = Number_of_pulses
print m.params['sweep_pts']
m.params['sweep_name'] = 'Number of pulses'
m.autoconfig()
# ### MODIFICATION FOR LT1 ###
# m.params['E_RO_durations'] = [m.params['SSRO_duration']]
# m.params['E_RO_amplitudes'] = [m.params['Ex_RO_amplitude']]
# ### END MODIFICATION FOR LT1 ###
funcs.finish(m, upload=True, debug=False)
def generate_sequence(self, upload=True, debug=False):
"""
generate the sequence for the single click experiment.
Tries to be as general as possible in order to suffice for multiple calibration measurements
"""
if self.params['only_meas_phase']:
return # NO AWG NEEDED
### initialize empty sequence and elements
combined_list_of_elements = []
combined_seq = pulsar.Sequence('SingleClickEnt')
if self.params['do_general_sweep'] == 1:
if type(self.params['general_sweep_name']) == list:
x0 = self.params['general_sweep_pts'][0]
x1 = self.params['general_sweep_pts'][1]
self.params['general_sweep_pts1'] = x0
self.params['general_sweep_pts2'] = x1
self.params['general_sweep_pts'] = []
sweep_pts = list(product(x0, x1))
### create a list of gates according to the current sweep.
for pt in range(self.params['pts']):
self.pt = pt
#sweep parameter
if self.params['do_general_sweep'] == 1:
if type(self.params['general_sweep_name']) == list:
self.params[self.params['general_sweep_name']
[0]] = sweep_pts[pt][0]
self.params[self.params['general_sweep_name']
[1]] = sweep_pts[pt][1]
self.params['sweep_pts'] = range(len(sweep_pts))
else:
self.params[
self.params['general_sweep_name']] = self.params[
'general_sweep_pts'][pt]
else:
self.params['general_sweep_name'] = 'no_sweep'
gate_seq = []
LDE = DD.Gate('LDE' + str(pt), 'LDE')
if self.params['LDE_attempts'] > 1:
LDE.reps = self.params['LDE_attempts'] - 1
LDE.is_final = False
LDE_final = DD.Gate('LDE_final_' + str(pt), 'LDE')
LDE_final.reps = 1
LDE_final.is_final = True
else:
LDE.is_final = True
### if statement to decide what LDE does: entangling or just make a specific e state.
if self.params['LDE_is_init'] > 0:
if self.params[
'force_LDE_attempts_before_init'] == 0 or self.params[
'LDE_attempts'] == 1:
LDE.reps = 1
LDE.is_final = True
manipulated_LDE_elt = copy.deepcopy(LDE)
else:
manipulated_LDE_elt = copy.deepcopy(LDE_final)
LDE.reps = self.params['LDE_attempts'] - 1
if self.params['input_el_state'] in ['X', 'mX', 'Y', 'mY']:
manipulated_LDE_elt.first_pulse_is_pi2 = True
#### define some phases:
x_phase = self.params['X_phase']
y_phase = self.params['Y_phase']
first_mw_phase_dict = {
'X': y_phase,
'mX': y_phase + 180,
'Y': x_phase + 180,
'mY': x_phase
}
manipulated_LDE_elt.first_mw_pulse_phase = first_mw_phase_dict[
self.params['input_el_state']]
elif self.params['input_el_state'] in ['Z']:
manipulated_LDE_elt.no_first_pulse = True
elif self.params['input_el_state'] in ['mZ']:
manipulated_LDE_elt.no_mw_pulse = True
### clean up by casting the manipulation back onto the original object:
if self.params[
'force_LDE_attempts_before_init'] == 0 or self.params[
'LDE_attempts'] == 1:
LDE = manipulated_LDE_elt
else:
LDE_final = manipulated_LDE_elt
### if more than 1 reps then we need to take the final element into account
elif self.params['LDE_attempts'] != 1:
############ do the yellow check here!
LDE.reps = self.params['LDE_attempts'] - 1
if self.params['do_yellow_with_AWG'] > 0:
LDE_list = []
LDE_reionize = DD.Gate('LDE_reionize_' + str(pt),
'Trigger')
LDE_reionize.duration = self.params['Yellow_AWG_duration']
LDE_reionize.elements_duration = LDE_reionize.duration
LDE_reionize.channel = 'AOM_Yellow'
# LDE_rounds, remaining_LDE_reps = divmod(LDE.reps,self.joint_params['LDE_attempts_before_yellow'])
LDE_rounds, remaining_LDE_reps = divmod(
LDE.reps, self.params['LDE_attempts_before_yellow'])
for i in range(int(LDE_rounds)):
#### when putting more stuff in the AWG have to make sure that names are unique
## LDE elts
L = copy.deepcopy(LDE)
L.name = L.name + '_' + str(i)
L.reps = int(self.params['LDE_attempts_before_yellow'])
LDE_list.append(L)
### yellow elts
Y = copy.deepcopy(LDE_reionize)
Y.name = Y.name + '_' + str(i)
Y.prefix = Y.prefix + '_' + str(i)
LDE_list.append(Y)
if remaining_LDE_reps != 0:
LDE.reps = remaining_LDE_reps
LDE.name = LDE.name + '_' + str(int(LDE_rounds))
LDE_list.append(LDE)
else:
LDE_list = [LDE]
else:
LDE_list = [LDE]
### LDE elements need rephasing or repumping elements
LDE_repump = DD.Gate('LDE_repump_' + str(pt), 'Trigger')
LDE_repump.duration = 2e-6
LDE_repump.elements_duration = LDE_repump.duration
LDE_repump.channel = 'AOM_Newfocus'
LDE_repump.el_state_before_gate = '0'
LDE_rephasing = DD.Gate('LDE_rephasing_' + str(pt),
'single_element')
LDE_rephasing.scheme = 'single_element'
self.generate_LDE_rephasing_elt(LDE_rephasing)
## decoupling sequence
tomography_pulse = DD.Gate('tomography_pulse_' + str(pt),
'single_element')
tomography_pulse.scheme = 'single_element'
self.generate_tomography_pulse(
tomography_pulse) ### this is still wrong!!!
cond_decoupling = DD.Gate(
'dd_' + str(pt),
'Carbon_Gate',
Carbon_ind=1, # does not matter.
event_jump='dd_end' + str(pt),
tau=self.params['dynamic_decoupling_tau'],
N=self.params['dynamic_decoupling_N'],
no_connection_elt=True)
cond_decoupling.scheme = 'carbon_phase_feedback'
cond_decoupling.reps = int(self.params['max_decoupling_reps'])
cond_decoupling_end = DD.Gate(
'dd_end' + str(pt),
'Carbon_Gate',
Carbon_ind=1, # does not matter.
tau=self.params['dynamic_decoupling_tau'],
N=self.params['dynamic_decoupling_N'],
no_connection_elt=True)
cond_decoupling_end.scheme = 'carbon_phase_feedback_end_elt'
e_RO = [
DD.Gate('Tomo_Trigger_' + str(pt), 'Trigger', wait_time=10e-6)
]
Fail_done = DD.Gate('Fail_done' + str(pt),
'Trigger',
wait_time=10e-6)
if self.params['do_dynamical_decoupling'] + self.params[
'do_dynamical_decoupling_AWG_only'] > 0:
Fail_done.go_to = 'dd_' + str(pt)
else:
Fail_done.go_to = 'wait_for_adwin_' + str(pt)
if self.params['do_dynamical_decoupling'] + self.params[
'do_dynamical_decoupling_AWG_only'] > 0:
Fail_done.go_to = 'dd_' + str(pt)
else:
Fail_done.go_to = 'wait_for_adwin_' + str(pt)
#######################################################################
### append all necessary gates according to the current measurement ###
#######################################################################
waiting_for_adwin = DD.Gate('wait_for_adwin_' + str(pt),
'passive_elt',
wait_time=10e-6)
waiting_for_adwin.wait_for_trigger = True
gate_seq.append(waiting_for_adwin)
if self.params['do_N_MBI'] > 0:
### Nitrogen MBI
mbi = DD.Gate('MBI_' + str(pt), 'MBI')
gate_seq.append(mbi)
#### insert a MW pi pulse when repumping
if self.params['MW_before_LDE'] > 0:
mw_pi = DD.Gate('elec_pi_' + str(pt),
'electron_Gate',
Gate_operation='pi')
if gate_seq == []:
mw_pi.wait_for_trigger = True
gate_seq.append(mw_pi)
if self.params['do_LDE'] > 0:
### needs corresponding adwin parameter
if gate_seq == []:
LDE_list[0].wait_for_trigger = True
gate_seq.extend(LDE_list)
### append last adwin synchro element
if not LDE_list[0].is_final:
gate_seq.append(LDE_final)
if self.params['force_repump_after_LDE'] > 0:
gate_seq.append(LDE_repump)
if self.params['do_dynamical_decoupling'] + self.params[
'do_dynamical_decoupling_AWG_only'] > 0:
LDE_rephasing.go_to = 'dd_' + str(pt)
else:
LDE_rephasing.go_to = 'Tomo_Trigger_' + str(pt)
gate_seq.append(LDE_rephasing)
if self.params['PLU_during_LDE'] > 0:
gate_seq.append(Fail_done)
else:
### there is only a single LDE repetition in the LDE element and we do not repump.
### --> add the rephasing element
gate_seq.append(LDE_rephasing)
if self.params['do_dynamical_decoupling'] + self.params[
'do_dynamical_decoupling_AWG_only'] > 0:
gate_seq.append(cond_decoupling)
gate_seq.append(cond_decoupling_end)
gate_seq.append(tomography_pulse)
gate_seq.extend(e_RO)
###############################################
# prepare and program the actual AWG sequence #
###############################################
#### insert elements here
gate_seq = self.generate_AWG_elements(gate_seq, pt)
### Convert elements to AWG sequence and add to combined list
list_of_elements, seq = self.combine_to_AWG_sequence(gate_seq,
explicit=True)
combined_list_of_elements.extend(list_of_elements)
for seq_el in seq.elements:
combined_seq.append_element(seq_el)
if upload:
print ' uploading sequence'
qt.pulsar.program_awg(combined_seq,
*combined_list_of_elements,
debug=debug,
verbose=False)
else:
print 'upload = false, no sequence uploaded to AWG'
def NuclearRamseyWithInitialization_cal(name,
carbon_list = [1],
carbon_init_state = ['up'],
el_RO = 'positive',
detuning = 0.5e3,
evo_time = 400e-6,
el_state = 1,
electron_after_init = 0,
debug = False,
C13_MBI_nr = 1,
free_evolution_time = 400e-6 + np.linspace(0., 6.0e-3,44)):
m = DD.NuclearRamseyWithInitializationModified(name)
funcs.prepare(m)
### Some conditions must be met
if len(carbon_init_state) != len(carbon_list):
print 'Number of init states and carbons does not match! Aborting'
return
'''Set parameters'''
### Sweep parameters
m.params['reps_per_ROsequence'] = 250
m.params['C13_MBI_RO_state'] = el_state
# Build init list or change this to ['swap']*(len(carbons)-1) + ['MBI']
C13_init_method = []
for i, c in enumerate(carbon_list):
if c == C13_MBI_nr:
C13_init_method.append('MBI')
else:
C13_init_method.append('swap')
m.params['C13_init_method'] = C13_init_method
print 'MBI carbon: ' + str(C13_MBI_nr)
print 'All carbons: ' +str(carbon_list)
print 'm.params[C13_init_method]: ' + str(C13_init_method)
####################################
### Option 1; Sweep waiting time ###
####################################
## '''1A - Rotating frame with detuning'''
m.params['add_wait_gate'] = False
if m.params['add_wait_gate'] == False:
print 'Warning: Add_wait_gate = False'
m.params['pts'] = len(free_evolution_time)
m.params['free_evolution_time'] = free_evolution_time
# m.params['free_evolution_time'] = 180e-6 + np.linspace(0e-6, 4*1./74e3,m.params['pts'])
m.params['C'+str(C13_MBI_nr)+'_freq_0'] += detuning
m.params['C'+str(C13_MBI_nr)+'_freq_1'+m.params['electron_transition']] += detuning
m.params['C_RO_phase'] = np.ones(m.params['pts'] )*0
m.params['sweep_name'] = 'free_evolution_time'
m.params['sweep_pts'] = m.params['free_evolution_time']
############################################
### Option 2; Sweep RO phase at set time ###
############################################
# m.params['pts'] = 21
# m.params['add_wait_gate'] = False
# m.params['free_evolution_time'] = np.ones(m.params['pts'] )*evo_time
# m.params['C_RO_phase'] = np.linspace(-20, 400,m.params['pts'])
# m.params['sweep_name'] = 'phase'
# m.params['sweep_pts'] = m.params['C_RO_phase']
'''Derived and fixed parameters'''
m.params['electron_readout_orientation'] = el_RO
m.params['carbon_list'] = carbon_list
m.params['C13_MBI_nr'] = C13_MBI_nr
m.params['init_state'] = carbon_init_state
m.params['C13_MBI_threshold_list'] = [0]*(len(carbon_list)-1)+[1]
m.params['el_after_init'] = electron_after_init
m.params['Nr_C13_init'] = len(carbon_list)
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
funcs.finish(m, upload =True, debug=debug)
