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 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 NuclearRamseyWithInitialization_phase(name,
carbon_nr=1,
carbon_init_state='up',
el_RO='positive',
el_state=0,
debug=False,
nr_of_pts=24):
m = DD.NuclearRamseyWithInitialization_v2(name)
funcs.prepare(m)
'''Set parameters'''
### Sweep parameters
m.params['reps_per_ROsequence'] = 500
m.params['C13_MBI_RO_state'] = el_state
m.params['pts'] = nr_of_pts
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 spin_echo(name):
m = DD.SimpleDecoupling(name)
funcs.prepare(m)
#############
# Parameters for spin-echo
#############
pts = 21
tau_start = 100e-6 #!!! Measurement class has minimal tau of 4us
tau_final = 200e-6
m.params['reps_per_ROsequence'] = 2500 #Repetitions of each data point
########
# parameters specific for spin -echo
###########
Number_of_pulses = 1
m.params['Initial_Pulse'] = 'x'
m.params['Final_Pulse'] = 'x'
m.params['Decoupling_sequence_scheme'] = 'repeating_T_elt'
#####
#Calculate/set remaining paramters
tau_list = np.linspace(
tau_start / 2.0, tau_final / 2.0, pts
) #The way tau is defined is different in hahn spin-echo and decoupling experiments
m.params['pts'] = pts
m.params['Number_of_pulses'] = Number_of_pulses * np.ones(pts).astype(int)
m.params['tau_list'] = tau_list
m.params['sweep_pts'] = 2 * Number_of_pulses * tau_list * 1e6
m.params['sweep_name'] = '2*N*tau (us)'
m.autoconfig()
funcs.finish(m, upload=True, debug=True)
def Long_Carbon_Ramsey(name, tau=None, Addressed_Carbon=7):
m = DD.LongNuclearRamsey(name)
funcs.prepare(m)
'''set experimental parameters'''
m.params['reps_per_ROsequence'] = 500 #Repetitions of each data point
m.params['Ren_Decoupling_scheme'] = 'repeating_T_elt'
m.params['DD_wait_scheme'] = 'auto' #XY8'
### Sweep parameters
m.params['N_list'] = range(
4, 320, 24) # np.ones(len(m.params['Phases_of_Ren_B']))*4 #
m.params['Phases_of_Ren_B'] = np.ones(len(m.params['N_list'])) * 0
# m.params['N_list'] = np.ones(21)*4#
# m.params['Phases_of_Ren_B'] = np.linspace(0,360*2,21)
m.params['C' + str(Addressed_Carbon) + '_freq'] = (
m.params['C' + str(Addressed_Carbon) + '_freq'] + 0.1e3
) # Overwrites the msmst params. Usefull to calibrate and find the correct freq
tau_larmor = m.get_tau_larmor()
m.params['tau_list'] = np.ones(len(m.params['N_list'])) * tau_larmor * 16
m.params['Addressed_Carbon'] = Addressed_Carbon
m.params['pts'] = len(m.params['Phases_of_Ren_B'])
m.params['sweep_pts'] = np.ones(
len(m.params['N_list']
)) #NB! This value is overwritten in the measurement class
# when the sweep name is 'Free Evolution Time (s)'
m.params['sweep_name'] = 'Free Evolution time (s)'
m.autoconfig()
funcs.finish(m, upload=True, debug=False)
def SimpleDecoupling_swp_tau(name,
tau_min=9e-6,
tau_max=10e-6,
tau_step=50e-9,
N=16):
m = DD.SimpleDecoupling(name)
funcs.prepare(m)
'''set experimental parameters'''
m.params['reps_per_ROsequence'] = 500 #Repetitions of each data point
m.params['Initial_Pulse'] = 'x'
if N % 4 == 0:
m.params['Final_Pulse'] = '-x'
else:
m.params['Final_Pulse'] = 'x'
m.params['Decoupling_sequence_scheme'] = 'repeating_T_elt'
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.autoconfig()
funcs.finish(m, upload=True, debug=False)
def Geometricgate(name, C13_init_method='swap',carbon_nr = 5,C13_init_state='up'):
m = DD.GeometricGate(name)
funcs.prepare(m)
'''set experimental parameters'''
m.params['Carbon_nr'] = carbon_nr
m.params['reps_per_ROsequence'] = 200
m.params['C13_init_state'] = C13_init_state
m.params['sweep_name'] = 'Number of pulses'
m.params['e_ro_orientation'] = 'positive'
m.params['C13_init_method'] = C13_init_method
m.params['calibrate_pulses']= True
m.params['no_unconditional_rotation'] = False
f0=m.params['C'+str(carbon_nr)+'_freq_0']
f1=m.params['C'+str(carbon_nr)+'_freq_1']
HalfWaittime=(1/np.abs(f1-f0))/4.
# ### Sweep parameters
# m.params['waiting_times']=np.linspace(HalfWaittime-10e-6,HalfWaittime+10e-6,11)
m.params['Number_of_pulses_uncond'] = np.arange(4,60,4)
m.params['waiting_times'] = [HalfWaittime]*len(m.params['Number_of_pulses_uncond'])
m.params['pts'] = len(m.params['Number_of_pulses_uncond'])
m.params['sweep_pts'] =m.params['Number_of_pulses_uncond']
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(name,
state='up',
tau=None,
RO_phase=0,
RO_Z=False,
N=None,
method='swap'):
m = DD.NuclearRamseyWithInitialization(name)
funcs.prepare(m)
'''set experimental parameters'''
### Initialize:
m.params['Addressed_Carbon'] = 3
m.params['C_init_method'] = 'MBI' #'MBI'->X, 'swap'-> 0
m.params['C13_MBI_threshold'] = 1
m.params['C13_init_state'] = state # 'up' or 'down'
m.params['electron_init_state'] = '0' # '0' or '1'
### Sweep parameters
detuning_ms0 = None
detuning_ms1 = None
m.params['reps_per_ROsequence'] = 500
m.params['pts'] = 25
## sweeping the readout phase
m.params['C_RO_phase'] = RO_phase + np.linspace(0, 720, m.params['pts'])
m.params['C_RO_Z'] = RO_Z
m.params['wait_times'] = (
np.ones(m.params['pts']) * 100e-6 + 30e-6
) #Note: wait time must be atleast carbon init time +5us
m.params['sweep_pts'] = m.params[
'C_RO_phase'] - RO_phase #This needs to substracted for the data analysis.
m.params['sweep_name'] = 'C_RO_phase'
# ### sweeping the waittime
# m.params['wait_times'] = np.linspace(130e-6, 130e-6 + 4e-3,m.params['pts']) #Note: wait time must be atleast carbon init time +5us
# m.params['C_RO_phase'] = np.ones(m.params['pts'])*RO_phase
# m.params['C_RO_Z'] = RO_Z
# m.params['sweep_pts'] = m.params['wait_times']
# m.params['sweep_name'] = 'evolution time'
##
if detuning_ms0 != None:
m.params['C3_freq_0'] = m.params['C3_freq_0'] - detuning_ms0
if detuning_ms1 != None:
m.params['C3_freq_1' + m.params['electron_transition']] = m.params[
'C3_freq_1' + m.params['electron_transition']] - detuning_ms1
#### Overwrite certain params for quick tests ###
m.params['C13_MBI_RO_duration'] = 20
m.params['E_C13_MBI_amplitude'] = 3e-9
if N != None:
m.params['C1_Ren_N'] = [N, 10]
m.params['SP_duration_after_C13'] = 50
m.params['A_SP_amplitude_after_C13_MBI'] = 15e-9
m.params['E_SP_amplitude_after_C13_MBI'] = 0e-9
funcs.finish(m, upload=True, debug=False)
def nspinflips(name):
m = NSpinflips(name)
funcs.prepare(m)
SP_power = 200e-9
m.params['AWG_SP_amplitude'] = qt.instruments[
'NewfocusAOM'].power_to_voltage(SP_power, controller='sec')
m.params['AWG_SP_duration'] = 5e-6
pts = 11
step_size = 150
m.params['pts'] = pts
m.params['AWG_sequence_repetitions'] = np.arange(pts) * step_size
m.params['reps_per_ROsequence'] = 1500
# for testing
m.params['pi2pi_mIm1_mod_frq'] = 250e6
m.params['pi2pi_mIm1_amp'] = 0.0 #0.05
m.params['pi2pi_mIm1_duration'] = 1e-6
# for the autoanalysis
m.params['sweep_name'] = 'SP cycles'
m.params['sweep_pts'] = m.params['AWG_sequence_repetitions']
funcs.finish(m, upload=True, debug=False)
def Echo_gate(name, C13_init_method='swap', carbon_nr=5, C13_init_state='up'):
m = DD.EchoGate(name)
funcs.prepare(m)
'''set experimental parameters'''
m.params['Carbon_nr'] = carbon_nr
m.params['reps_per_ROsequence'] = 100
m.params['C13_init_state'] = C13_init_state
m.params['C13_init_method'] = C13_init_method
m.params['sweep_name'] = 'waiting time (us)'
m.params['e_ro_orientation'] = 'positive'
m.params[
'E_superposition'] = True ### This boolean inserts an initial and final pi/2 pulse on the electronic state.
# ### Sweep parameters
m.params['waiting_times'] = np.arange(10e-6, 400e-6, 10e-6)
m.params['do_carbon_pi'] = True
m.params['No_of_pulses'] = np.arange(8, 101, 8)
#m.params['waiting_times'] = np.arange(10e-6,400e-6,10e-6)
m.params['pts'] = len(m.params['waiting_times'])
m.params['sweep_pts'] = [x * 2 * 10**6 for x in m.params['waiting_times']
] ## rescale to microseconds
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, carbon = 7, evolution_times = []):
m = DD.NuclearRamsey(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 SimpleDecoupling_swp_N(name,
tau=None,
Number_of_pulses=np.arange(80, 100, 2),
Final_Pulse='x',
Initial_Pulse='x',
reps_per_ROsequence=1000):
m = DD.SimpleDecoupling(name)
funcs.prepare(m)
#input parameters
m.params['reps_per_ROsequence'] = reps_per_ROsequence
pts = len(Number_of_pulses)
if tau == None:
tau = m.params['C3_Ren_tau' + m.params['electron_transition']][0]
tau_list = tau * np.ones(pts)
print 'tau_list =' + str(tau_list)
#inital and final pulse
m.params['Initial_Pulse'] = Initial_Pulse
m.params['Final_Pulse'] = Final_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
print m.params['sweep_pts']
m.params['sweep_name'] = 'Number of pulses'
m.autoconfig()
funcs.finish(m, upload=True, debug=False)
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), phase_array = np.linspace(-60, 400,19), debug = False,el_RO= 'positive',el_state = 0, nr_of_gates = 1):
m = DD.Nuclear_Crosstalk_vs2(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'] = 300
m.params['init_state'] = 'up'
m.params['nr_of_gates'] = nr_of_gates
m.params['pts'] = len(phase_array)
m.params['C_RO_phase'] = phase_array
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 SweepGates(name,**kw):
debug = kw.pop('debug',False)
carbon = kw.pop('carbon',False)
el_RO = kw.pop('el_RO','positive')
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'] = 1500
### 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) ###
##################################
#print m.params['electron_transition']
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['C'+str(carbon)+'_dec_trans']],m.params['C'+str(carbon)+'_gate_optimize_tau_list'+m.params['C'+str(carbon)+'_dec_trans']])
####################
### MBE settings ###
####################
m.params['electron_transition_used']=m.params['C'+str(carbon)+'_dec_trans']
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)
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 NuclearT1_repumping(name,
tau=None,
carbon_state='up',
electron_RO='positive',
carbon=1,
el_RO_result=0,
el_after_init=0,
pts=2,
short_time=1.0e-3,
long_time=20.0e-3):
m = DD.NuclearT1_repumping(name)
funcs.prepare(m)
'''set experimental parameters'''
### Sweep parameters
m.params['reps_per_ROsequence'] = 500 #Repetitions of each data point
m.params['pts'] = 2
m.params['Addressed_Carbon'] = carbon
m.params['C13_init_state'] = carbon_state
m.params['electron_readout_orientation'] = electron_RO
m.params['C13_MBI_RO_state'] = el_RO_result
m.params[
'el_after_init'] = el_after_init #if ==1 then a micrwave pi pulse prings the electorn into ms=-1
m.params['sweep_name'] = 'wait_times'
m.params['wait_times'] = np.linspace(
short_time, long_time, m.params['pts']
) #Note: wait time must be at least carbon init time +5us
m.params['sweep_pts'] = m.params['wait_times']
m.params['Nr_C13_init'] = 1
### MBE settings
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
############################
# repumping parameters #
############################
m.params['repetitive_SP_A_duration'] = 80 #in us
m.params['repump_repetitions'] = [5, 5]
m.params['repetitive_SP_A_power'] = 30e-9
#############################
#!NB: These should go into msmt params
#############################
##########
# Overwrite certain params to test their influence on the sequence.
m.params['C13_MBI_threshold_list'] = [0]
m.params['C13_MBI_threshold'] = 0
m.params['C13_MBI_RO_duration'] = 100
m.params['SP_duration_after_C13'] = 250
# m.autoconfig() (autoconfig is firs line in funcs.finish )
funcs.finish(m, upload=True, debug=True)
def electronramsey_WithNuclearInit(name,
Addressed_Carbon=1,
C_13_init_state='up',
el_RO_result=0,
electron_RO='positive',
no_carbon_init = False):
m = DD.ElectronRamseyWithNuclearInit(name)
funcs.prepare(m)
pts = 32
m.params['pts'] = pts
m.params['reps_per_ROsequence'] = 1000
m.params['wait_times'] = np.linspace(0,300000e-9,pts)
# MW pulses
m.params['detuning'] = 0 #0.5e6
m.params['pi2_phases1'] = np.ones(pts) * 0
m.params['pi2_phases2'] = np.ones(pts) * 360 * m.params['wait_times'] * m.params['detuning']
m.params['pi2_lengths'] = np.ones(pts) * 16e-9
# for the autoanalysis
m.params['sweep_name'] = 'evolution time (ns)'
m.params['sweep_pts'] = m.params['wait_times']/1e-9
#define everything carbon related
m.params['Addressed_Carbon'] = Addressed_Carbon
m.params['C13_init_state'] = C_13_init_state
m.params['electron_readout_orientation'] = electron_RO
m.params['C13_MBI_RO_state'] = el_RO_result
m.params['no_carbon_init']=no_carbon_init # if True, this flag circumvents any carbon initialization. (does not work yet)
#This part of the script does not yet work with the current adwin script. Causes adwin to crash....
if no_carbon_init:
m.params['Nr_C13_init'] = 0
m.params['C13_MBI_threshold_list'] = []
else:
m.params['Nr_C13_init'] = 1
m.params['C13_MBI_threshold_list'] = [0]
### MBE settings
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
##########
# Overwrite certain params to test their influence on the sequence.
funcs.finish(m, upload=True, debug=False)
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_v3(name)
funcs.prepare(m)
m.params['C13_MBI_threshold_list'] = carbon_init_thresholds
''' set experimental parameters '''
m.params['reps_per_ROsequence'] = 500
### 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)
####################
### 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 SimpleDecoupling_swp_tau(name,tau_min=9e-6,tau_max=10e-6,tau_step =50e-9, N =16):
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-204
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'])
m.params['temp'] = temperature_sensor.get_readlastval()
funcs.prepare(m)
if True: ### 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'] = 20 #2000
m.params['repump_after_MBI_A_amplitude'] = [25e-9]
m.params['repump_after_MBI_duration'] = [300] # 50
'''set experimental parameters'''
m.params['reps_per_ROsequence'] = 250 #250 #Repetitions of each data point
m.params['Initial_Pulse'] ='x'
if N%4 == 0:
m.params['Final_Pulse'] ='-x'
else:
m.params['Final_Pulse'] ='x'
m.params['Decoupling_sequence_scheme'] = 'repeating_T_elt'
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)'
# print m.params['fast_pi_duration']
# print m.params['fast_pi_amp']
# m.params['fast_pi2_duration'] = pi_dur
# m.params['fast_pi2_amp'] = pi_amp
m.autoconfig()
funcs.finish(m, upload =True, debug=False)
def Single_C_gate_characterization(name,
carbon_nr=1,
carbon_init_state='up',
el_RO='positive',
debug=False,
el_during_experiment=1,
C13_init_method='MBI',
C13_MBI_threshold=[1],
C13_RO_basis=['Y'],
nr_of_gates_list=np.linspace(0, 5, 6),
gate_phase='Y',
constant_time=False,
reps=200):
m = DD.Nuclear_gate_characterization(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_gates_list'] = nr_of_gates_list
m.params['pts'] = len(nr_of_gates_list)
### Derive other parameters
m.params['sweep_name'] = 'Nr of gates'
m.params['sweep_pts'] = nr_of_gates_list
m.params['constant_time'] = constant_time
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 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 NoBranching_and_invert_test(name,
carbon_list=[1],
A_list=['X'],
tomo_list=['X'],
debug=False,
parity_orientations=['positive', 'positive'],
use_composite_pi=True):
m = DD.test_undo_RO_phase_and_invert(name)
funcs.prepare(m)
m.params['reps_per_ROsequence'] = 5000
m.params['pts'] = 1
m.params['RO_trigger_duration'] = 150e-6
m.params['use_composite_pi'] = use_composite_pi
##### Carbon initializations params
m.params['Nr_C13_init'] = 1
m.params['carbon_init_list'] = [1] #[]
m.params['init_state_list'] = ['down'] #['up','up']#['up']
m.params['init_method_list'] = ['MBI'] #['swap','swap']# ['swap']
m.params['C13_MBI_threshold_list'] = [1] #[0,0]#[0]
m.params['Nr_MBE'] = 0
#m.params['MBE_bases'] = []
#m.params['MBE_threshold'] = 1
m.params['Nr_parity_msmts'] = 1
m.params['add_wait_gate'] = False
m.params['wait_in_msm1'] = False
###### RO mmtA params
m.params['Parity_A_do_init_pi2'] = True
m.params['Parity_A_carbon_list'] = carbon_list
m.params['Parity_A_RO_list'] = A_list
m.params['Parity_A_RO_orientation'] = parity_orientations[0]
# if we do invert, we don't have to do anything conditional
m.params['undo_parityA_conditional_pi'] = False
m.params['undo_parityA_conditional_pi2'] = False
m.params['Invert_A_do_final_pi2'] = False
m.params['Tomo_do_init_pi2'] = False
for s in tomo_list:
if 'Z' in s:
print 'tomography contains Z; doing pi/2 between invertRO and RO'
m.params['Invert_A_do_final_pi2'] = True
m.params['Tomo_do_init_pi2'] = True
m.params['Tomo_carbon_list'] = carbon_list
m.params['Tomo_RO_orientation'] = parity_orientations[1]
m.params['Tomo_RO_list'] = tomo_list
funcs.finish(m, upload=True, debug=debug)
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_cal(name,
carbon_nr=5,
carbon_init_state='up',
el_RO='positive',
detuning=0.5e3,
el_state=1,
debug=debug):
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'] = el_state
### overwritten from msmnt params
####################################
### Option 1; Sweep waiting time ###
####################################
# 1A - Rotating frame with detuning
m.params['add_wait_gate'] = True
m.params['pts'] = 21
m.params['free_evolution_time'] = 400e-6 + np.linspace(
0e-6, 3 * 1. / detuning, m.params['pts'])
if m.params['multiple_source']:
m.params['electron_transition'] = m.params['C' + str(carbon_nr) +
'_dec_trans']
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
print 'frequencies'
print m.params['C' + str(carbon_nr) + '_freq_0']
print m.params['C' + str(carbon_nr) + '_freq_1' +
m.params['electron_transition']]
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 SweepTransferPhase(name,
transfer_begin='_m1',
transfer_end='_p1',
sweep=linspace(0, 360, 21),
invert_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'] = 1500
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']
m.params['shorten_factor'] = 0.1
####################################
# ### 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'] = delay
m.params['invert_ro'] = invert_RO
m.params['transfer_begin'] = transfer_begin
m.params['transfer_end'] = transfer_end
m.params['readout_pop'] = readout_pop
m.params['invert_pop_ro'] = True #added extra to make it run
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 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'] = 2500 #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'] = 1
### Sweep parmater
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, 1000e3,
30).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'
print 'free evolution times: %s' % m.params['free_evolution_times']
if N == None:
m.params['C_Ren_N'] = m.params['C' +
str(m.params['addressed_carbon']) +
'_Ren_N'][0]
else:
m.params['C_Ren_N'] = N
if tau == None:
m.params['C_Ren_tau'] = m.params['C' +
str(m.params['addressed_carbon']) +
'_Ren_tau'][0]
else:
m.params['C_Ren_tau'] = tau
#############################
#!NB: These should go into msmt params
#############################
m.params['min_dec_tau'] = 20e-9 + m.params['fast_pi_duration'] / 2.0
m.params[
'max_dec_tau'] = 0.35e-6 #0.35e-6 #Based on measurement for fingerprint at low tau
m.params['dec_pulse_multiple'] = 4 #lowest multiple of 4 pulses
m.autoconfig()
funcs.finish(m, upload=True, debug=False)
print m.params['sweep_pts']
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 NoBranching_no_invert_test(name,
carbon_list=[1, 2],
A_list=['X', 'X'],
tomo_list=['X', 'X'],
debug=False,
parity_orientations=['positive', 'positive']):
m = DD.test_undo_RO_phase(name)
funcs.prepare(m)
m.params['reps_per_ROsequence'] = 1200
m.params['pts'] = 1
m.params['RO_trigger_duration'] = 150e-6
##### Carbon initializations params
m.params['Nr_C13_init'] = 2
m.params['carbon_init_list'] = [1, 2]
m.params['init_state_list'] = 2 * ['up']
m.params['init_method_list'] = 2 * ['swap']
m.params['C13_MBI_threshold_list'] = [0, 0]
m.params['Nr_MBE'] = 0
#m.params['MBE_bases'] = []
#m.params['MBE_threshold'] = 1
m.params['Nr_parity_msmts'] = 1
m.params['add_wait_gate'] = False
m.params['wait_in_msm1'] = False
###### RO mmtA params
m.params['Parity_A_carbon_list'] = carbon_list
m.params['Parity_A_RO_list'] = A_list
m.params['Parity_A_RO_orientation'] = parity_orientations[0]
# if we do X or Y tomography after, we have to do a conditional pi2, and no init pi2 for RO
m.params['undo_parityA_conditional_pi2'] = True
m.params['undo_parityA_conditional_pi'] = False
# We merges the init pi2 of the tomography
m.params['Tomo_do_init_pi2'] = False
# if we do Z tomography after, we have to do a conditional pi, and a init pi2 for RO
for s in tomo_list:
if 'Z' in s:
print 'tomography contains Z; doing conditional pi and pi/2 between invertRO and RO'
m.params['undo_parityA_conditional_pi2'] = False
m.params['undo_parityA_conditional_pi'] = True
m.params['Tomo_do_init_pi2'] = True
m.params['Tomo_carbon_list'] = carbon_list
m.params['Tomo_RO_orientation'] = parity_orientations[1]
m.params['Tomo_RO_list'] = tomo_list
funcs.finish(m, upload=True, debug=debug)
def run(name, mw_switch = False):
if mw_switch:
m = pulsar_mbi_espin.ElectronRabi_Switch(name)
else:
m = pulsar_mbi_espin.ElectronRabi(name)
funcs.prepare(m)
print 'threshold =' + str(m.params['MBI_threshold'])
# m.params.from_dict(qt.exp_params['protocols']['Hans_sil1']['Magnetometry'])
pts_coarse = 31
fine_pts = 51
fine_range = 0.4e6
n_split = m.params['N_HF_frq']
mw_mod = m.params['MW_modulation_frequency']
outer_minus = np.linspace(mw_mod-1e6,mw_mod-fine_range,pts_coarse)
outer_plus = np.linspace(mw_mod+fine_range,mw_mod+1e6,pts_coarse) + 2*n_split
aplus_list = np.linspace(mw_mod-fine_range,mw_mod+fine_range,fine_pts) +2*n_split
a0_list = np.linspace(mw_mod-fine_range,mw_mod+fine_range,fine_pts) + n_split
amin_list = np.linspace(mw_mod-fine_range,mw_mod+fine_range,fine_pts)
amin_to_a0 = np.linspace(mw_mod+fine_range,mw_mod-fine_range+n_split,pts_coarse)
a0_to_aplus = np.linspace(mw_mod+fine_range+n_split,mw_mod-fine_range+2*n_split,pts_coarse)
# m.params['MW_pulse_mod_frqs'] = np.linspace(m.params['MW_modulation_frequency']
# -1.5e6, m.params['MW_modulation_frequency']+5.5e6, pts)
m.params['MW_pulse_mod_frqs'] = np.r_[outer_minus,amin_list,amin_to_a0,a0_list,a0_to_aplus,aplus_list,outer_plus]
print m.params['MW_pulse_mod_frqs']
pts = len(m.params['MW_pulse_mod_frqs'])
m.params['reps_per_ROsequence'] = 250
m.params['MW_pulse_multiplicities'] = np.ones(pts).astype(int)
m.params['MW_pulse_delays'] = np.ones(pts) * 2500e-9
# MW pulses
m.params['MW_pulse_durations'] = np.ones(pts) * 8e-6 #m.params['AWG_MBI_MW_pulse_duration']*4 #3e-6 #3000e-9
m.params['MW_pulse_amps'] = np.ones(pts) * 0.006 #m.params['AWG_MBI_MW_pulse_amp']/4 #0.01525 #for msm1, ??? for msp1,
m.params['pts'] = pts
# for the autoanalysis
m.params['sweep_name'] = 'MW pulse frequency (MHz)'
m.params['sweep_pts'] = (m.params['MW_pulse_mod_frqs'] + m.params['mw_frq'])/1.e6
print m.params['MBI_threshold']
funcs.finish(m, debug=False)
def NuclearT1(name,
carbon_state='up',
el_RO='positive',
carbon_nr=5,
el_RO_result=0,
el_after_init=0,
pts=5,
short_time=1.0e-4,
long_time=20.0e-3):
m = DD.NuclearT1_OLD(name)
funcs.prepare(m)
'''set experimental parameters'''
m.params['wait_times'] = np.r_[10e-4, 50e-4, 50e-3, 100e-3, 200e-3, 500e-3,
1., 2.]
### Sweep parameters
m.params['reps_per_ROsequence'] = 400 #Repetitions of each data point
m.params['pts'] = len(m.params['wait_times'])
m.params['carbon_nr'] = carbon_nr
m.params['C13_init_state'] = carbon_state
m.params['electron_readout_orientation'] = el_RO
m.params['C13_MBI_RO_state'] = el_RO_result
m.params[
'el_after_init'] = el_after_init #if ==1 then a micrwave pi pulse prings the electorn into ms=-1
m.params['C_RO_phase'] = m.params['pts'] * ['Z']
m.params['sweep_name'] = 'wait_times'
# m.params['wait_times'] = np.linspace(short_time,long_time,m.params['pts']) #Note: wait time must be at least carbon init time +5us
m.params['sweep_pts'] = m.params['wait_times']
m.params['Nr_C13_init'] = 1 #len(carbon_list)
### MBE settings
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
#############################
#!NB: These should go into msmt params
#############################
##########
# Overwrite certain params to test their influence on the sequence.
# m.params['C13_MBI_threshold_list'] = [0]
# m.params['C13_MBI_RO_duration'] = 100
# m.params['SP_duration_after_C13'] = 250
# m.autoconfig() (autoconfig is firs line in funcs.finish )
funcs.finish(m, upload=True, debug=False)
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 run(name):
m = pulsar_mbi_espin.ElectronRabi(name)
funcs.prepare(m)
pts = 36
m.params['pts'] = pts
m.params['reps_per_ROsequence'] = 200
m.params['MW_pulse_multiplicities'] = np.ones(pts).astype(int)
m.params['MW_pulse_delays'] = np.ones(pts) * 2000e-9
# MW pulses
m.params['MW_pulse_durations'] = np.ones(pts) * 2e-6
m.params['MW_pulse_amps'] = np.ones(pts) * 0.03
m.params['MW_pulse_mod_frqs'] = linspace(m.params['MW_modulation_frequency']-4.5e6, m.params['MW_modulation_frequency']+4.5e6, pts)
print m.params['MW_pulse_mod_frqs']
# for the autoanalysis
m.params['sweep_name'] = 'MW pulse frequency (MHz)'
m.params['sweep_pts'] = (m.params['MW_pulse_mod_frqs'] + m.params['mw_frq'])/1.e6
funcs.finish(m, upload=0, debug=False)
print m.params['AWG_MBI_MW_pulse_mod_frq']
def run(name):
m = pulsar_mbi_espin.ElectronRabi(name)
funcs.prepare(m)
print 'MBI threshold =' + str(m.params['MBI_threshold'])
print 'Ex_MBI_amplitude =' + str(m.params['Ex_MBI_amplitude'])
print 'SSRO_duration =' + str(m.params['SSRO_duration'])
pts = 31
m.params['pts'] = pts
m.params['reps_per_ROsequence'] = 300
m.params['MW_pulse_multiplicities'] = np.ones(pts).astype(int)
m.params['MW_pulse_delays'] = np.ones(pts) * 2000e-9
# MW pulses
m.params['MW_pulse_durations'] = np.linspace(0,400e-9,pts) + 10e-9 #why this +10 here?
m.params['MW_pulse_amps'] = np.ones(pts) * 1
m.params['MW_pulse_mod_frqs'] = np.ones(pts) * m.params['AWG_MBI_MW_pulse_mod_frq']
print m.params['MW_pulse_mod_frqs']
# for the autoanalysis
m.params['sweep_name'] = 'MW pulse duration (ns)'
m.params['sweep_pts'] = m.params['MW_pulse_durations'] * 1e9
funcs.finish(m, debug=False)
def finish(m, upload=True, debug=False, **kw):
funcs.finish(m, upload, debug, **kw)