def generate_sequence(do_program=True):
seq = Sequence('spin_control')
awgcfg.configure_sequence(seq,'mw')
# vars for the channel names
chan_mw_pm = 'MW_pulsemod' #is connected to ch1m1
if lt1:
chan_mwI = 'MW_Imod_lt1'
chan_mwQ = 'MW_Qmod_lt1'
else:
chan_mwI = 'MW_Imod' #ch1
chan_mwQ = 'MW_Qmod' #ch3
if lt1:
MW_pulse_mod_risetime = 2
else:
MW_pulse_mod_risetime = 6
seq.add_element(name = 'spin_control', trigger_wait = True, goto_target = 'spin_control')
seq.add_pulse('wait', channel = chan_mw_pm, element = 'spin_control',
start = 0, duration = 100, amplitude = 0)
seq.add_pulse('mwburst', channel = chan_mwI, element = 'spin_control',
start = 0, duration = par['RO_duration']*1000,
amplitude = amplitude_ssbmod, start_reference = 'wait',
link_start_to = 'end', shape = 'rectangular')
seq.add_pulse('pulse_mod', channel = chan_mw_pm, element = 'spin_control',
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'mwburst', link_start_to = 'start',
duration_reference = 'mwburst', link_duration_to = 'duration',
amplitude = 2.0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
def generate_sequence(self, do_program=True):
awg.set_event_jump_timing('SYNC')
self.seq = Sequence('lde')
seq = self.seq
# channels
chan_hhsync = 'HH_sync' # historically PH_start
chan_hh_ma1 = 'HH_MA1' # historically PH_sync
chan_plusync = 'PLU_gate'
chan_alaser = 'AOM_Newfocus'
chan_eom = 'EOM_Matisse'
chan_eom_aom = 'EOM_AOM_Matisse'
chan_mw_pm = 'MW_pulsemod'
chan_mwI_lt2 = 'MW_Imod'
chan_mwQ_lt2 = 'MW_Qmod'
chan_mwI_lt1 = 'MW_Imod_lt1'
chan_mwQ_lt1 = 'MW_Qmod_lt1'
# check if MWpi and optical pi don't overlap:
if self.wait_after_opt_pi >= self.opt_pi_separation - \
self.eom_pulse_duration - self.pi_lt2_duration:
print '!!! =================== !!!'
print 'WARNING: pi pulse and 2nd optical pi pulse might overlap!'
print 'Decrease variable wait_after_opt_pi'
print '!!! =================== !!!'
# TODO study the current AWG configuration, then adapt this
awgcfg.configure_sequence(
self.seq,
'hydraharp',
'mw',
LDE={
chan_eom_aom: {
'high': self.eom_aom_amplitude
},
chan_alaser: {
'high': self.A_SP_amplitude,
}
},
)
seq.add_element('lde',
goto_target='idle',
repetitions=self.max_LDE_attempts,
event_jump_target='idle',
trigger_wait=True)
# 1: spin pumping
seq.add_pulse(
'initialdelay',
chan_alaser,
'lde',
start=0,
duration=10,
amplitude=0,
)
seq.add_pulse('spinpumping',
chan_alaser,
'lde',
start=0,
duration=self.SP_duration,
start_reference='initialdelay',
link_start_to='end',
amplitude=1)
# 2: Pi/2 pulses on both spins
seq.add_pulse('pi/2-1 lt2',
chan_mwI_lt2,
'lde',
duration=self.pi2_lt2_duration,
amplitude=self.pi2_lt2_amplitude,
start_reference='spinpumping',
start=self.wait_after_SP,
link_start_to='end')
seq.add_pulse('pi/2-1 lt1',
chan_mwI_lt1,
'lde',
duration=self.pi2_lt1_duration,
amplitude=self.pi2_lt1_amplitude,
start_reference='pi/2-1 lt2',
start=(self.pi2_lt2_duration - self.pi2_lt1_duration) /
2,
link_start_to='start')
seq.add_pulse('pi/2-1 pm', chan_mw_pm, 'lde',
amplitude = self.MW_pulsemod_amplitude,
duration = max(self.pi2_lt2_duration+\
2*self.MW_pulsemod_risetime_lt2,
self.pi2_lt1_duration+\
2*self.MW_pulsemod_risetime_lt1),
start = min(-self.MW_pulsemod_risetime_lt2,
(self.pi2_lt2_duration-self.pi2_lt1_duration)/2 - \
self.MW_pulsemod_risetime_lt1),
start_reference = 'pi/2-1 lt2',
link_start_to = 'start' )
# 3a: optical pi-pulse no 1
i = 1
last = 'pi/2-1 pm'
seq.add_pulse('start' + str(i),
chan_hhsync,
'lde',
start=self.wait_after_pi2,
duration=50,
amplitude=2.0,
start_reference=last,
link_start_to='end')
last = 'start' + str(i)
seq.add_pulse('mrkr' + str(i),
chan_hh_ma1,
'lde',
start=-20,
duration=50,
amplitude=2.0,
start_reference=last,
link_start_to='start')
seq.add_pulse('start' + str(i) + 'delay',
chan_hhsync,
'lde',
start=0,
duration=50,
amplitude=0,
start_reference=last,
link_start_to='end')
last = 'start' + str(i) + 'delay'
seq.add_pulse('AOM' + str(i),
chan_eom_aom,
'lde',
start=self.aom_start,
duration=self.aom_duration,
start_reference=last,
link_start_to='start')
seq.add_pulse('EOM_off' + str(i),
chan_eom,
'lde',
amplitude=self.eom_off_amplitude,
start=self.eom_start,
duration=self.eom_off_duration,
start_reference=last,
link_start_to='start')
seq.add_pulse('EOM_pulse'+str(i), chan_eom, 'lde',
amplitude = self.eom_pulse_amplitude - self.eom_off_amplitude,
start = self.eom_start + self.eom_off_duration/2 + \
self.eom_pulse_offset, duration = self.eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1'+str(i), chan_eom, 'lde',
amplitude = self.eom_overshoot1,
start = self.eom_start + self.eom_off_duration/2 + \
self.eom_pulse_offset + self.eom_pulse_duration,
duration = self.eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2'+str(i), chan_eom, 'lde',
amplitude = self.eom_overshoot2,
start = self.eom_start + self.eom_off_duration/2 + \
self.eom_pulse_offset + self.eom_pulse_duration + \
self.eom_overshoot_duration1,
duration = self.eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_off_comp' + str(i),
chan_eom,
'lde',
amplitude=-self.eom_off_amplitude,
start=self.eom_start + self.eom_off_duration,
duration=self.eom_off_duration,
start_reference=last,
link_start_to='start')
seq.add_pulse('EOM_pulse_comp'+str(i), chan_eom, 'lde',
amplitude = -self.eom_pulse_amplitude + self.eom_off_amplitude,
start = self.eom_start+self.eom_off_duration + \
int(self.eom_off_duration/2) + self.eom_pulse_offset,
duration = self.eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1_comp'+str(i), chan_eom, 'lde',
amplitude = -self.eom_overshoot1,
start = self.eom_start+self.eom_off_duration + \
int(self.eom_off_duration/2) + self.eom_pulse_offset + \
self.eom_pulse_duration,
duration = self.eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2_comp'+str(i), chan_eom, 'lde',
amplitude = -self.eom_overshoot2,
start = self.eom_start+self.eom_off_duration + \
int(self.eom_off_duration/2) + self.eom_pulse_offset + \
self.eom_pulse_duration + self.eom_overshoot_duration1,
duration = self.eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
last = 'EOM_pulse' + str(i)
# 3b: add pre-sync pulses for the HH
for j in range(self.presync_pulses):
if not debug_mode:
pre_sync_amp = 2.0
else:
pre_sync_amp = 0.0
seq.add_pulse('presync' + str(j),
chan_hhsync,
'lde',
start=-(j + 1) * self.opt_pi_separation,
duration=50,
amplitude=pre_sync_amp,
start_reference='start' + str(i),
link_start_to='start')
# 3c: add PLU gate
seq.add_pulse('plu-gate' + str(i),
chan_plusync,
'lde',
start=0,
duration=self.plu_gate_duration,
amplitude=2.0,
start_reference='EOM_pulse' + str(i),
link_start_to='end')
# 4: spin pi pulses
seq.add_pulse('pi lt2',
chan_mwI_lt2,
'lde',
duration=self.pi_lt2_duration,
amplitude=self.pi_lt2_amplitude,
start_reference=last,
start=self.wait_after_opt_pi,
link_start_to='end')
seq.add_pulse('pi lt1',
chan_mwI_lt1,
'lde',
duration=self.pi_lt1_duration,
amplitude=self.pi_lt1_amplitude,
start_reference='pi lt2',
start=(self.pi_lt2_duration - self.pi_lt1_duration) / 2,
link_start_to='start')
seq.add_pulse('pi pm', chan_mw_pm, 'lde',
amplitude = self.MW_pulsemod_amplitude,
duration = max(self.pi_lt2_duration+\
2*self.MW_pulsemod_risetime_lt2,
self.pi_lt1_duration+\
2*self.MW_pulsemod_risetime_lt1),
start = min(-self.MW_pulsemod_risetime_lt2,
(self.pi_lt2_duration-self.pi_lt1_duration)/2 - \
self.MW_pulsemod_risetime_lt1),
start_reference = 'pi lt2',
link_start_to = 'start')
# 5a: optical pi-pulse no2
i = 2
seq.add_pulse('start' + str(i),
chan_hhsync,
'lde',
start=self.opt_pi_separation,
duration=50,
amplitude=2.0,
start_reference='start' + str(i - 1),
link_start_to='start')
last = 'start' + str(i)
seq.add_pulse('start' + str(i) + 'delay',
chan_hhsync,
'lde',
start=0,
duration=50,
amplitude=0,
start_reference=last,
link_start_to='end')
last = 'start' + str(i) + 'delay'
seq.add_pulse('AOM' + str(i),
chan_eom_aom,
'lde',
start=self.aom_start,
duration=self.aom_duration,
start_reference=last,
link_start_to='start')
seq.add_pulse('EOM_off' + str(i),
chan_eom,
'lde',
amplitude=self.eom_off_amplitude,
start=self.eom_start,
duration=self.eom_off_duration,
start_reference=last,
link_start_to='start')
seq.add_pulse('EOM_pulse'+str(i), chan_eom, 'lde',
amplitude = self.eom_pulse_amplitude - self.eom_off_amplitude,
start = self.eom_start + self.eom_off_duration/2 + \
self.eom_pulse_offset, duration = self.eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1'+str(i), chan_eom, 'lde',
amplitude = self.eom_overshoot1,
start = self.eom_start + self.eom_off_duration/2 + \
self.eom_pulse_offset + self.eom_pulse_duration,
duration = self.eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2'+str(i), chan_eom, 'lde',
amplitude = self.eom_overshoot2,
start = self.eom_start + self.eom_off_duration/2 + \
self.eom_pulse_offset + self.eom_pulse_duration + \
self.eom_overshoot_duration1,
duration = self.eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_off_comp' + str(i),
chan_eom,
'lde',
amplitude=-self.eom_off_amplitude,
start=self.eom_start + self.eom_off_duration,
duration=self.eom_off_duration,
start_reference=last,
link_start_to='start')
seq.add_pulse('EOM_pulse_comp'+str(i), chan_eom, 'lde',
amplitude = -self.eom_pulse_amplitude + self.eom_off_amplitude,
start = self.eom_start+self.eom_off_duration + \
int(self.eom_off_duration/2) + self.eom_pulse_offset,
duration = self.eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1_comp'+str(i), chan_eom, 'lde',
amplitude = -self.eom_overshoot1,
start = self.eom_start+self.eom_off_duration + \
int(self.eom_off_duration/2) + self.eom_pulse_offset + \
self.eom_pulse_duration,
duration = self.eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2_comp'+str(i), chan_eom, 'lde',
amplitude = -self.eom_overshoot2,
start = self.eom_start+self.eom_off_duration + \
int(self.eom_off_duration/2) + self.eom_pulse_offset + \
self.eom_pulse_duration + self.eom_overshoot_duration1,
duration = self.eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
last = 'EOM_pulse' + str(i)
# 5b: add post-sync pulses for the HH
for j in range(self.postsync_pulses):
if not debug_mode:
post_sync_amp = 2.0
else:
post_sync_amp = 0.0
seq.add_pulse('postsync' + str(j),
chan_hhsync,
'lde',
start=(j + 1) * self.opt_pi_separation,
duration=50,
amplitude=post_sync_amp,
start_reference='start' + str(i),
link_start_to='start')
# 5c: add PLU gate
seq.add_pulse('plu-gate' + str(i),
chan_plusync,
'lde',
start=self.plu_2_start_offset,
duration=self.plu_gate_duration,
amplitude=2.0,
start_reference='EOM_pulse' + str(i),
link_start_to='end')
# 5d: two additional PLU gates
seq.add_pulse('plu-gate3',
chan_plusync,
'lde',
start=self.plu_3_delay,
duration=self.plu_gate_duration,
amplitude=2.0,
start_reference='plu-gate2',
link_start_to='end')
seq.add_pulse('plu-gate4',
chan_plusync,
'lde',
start=self.plu_4_delay,
duration=self.plu_gate_duration,
amplitude=2.0,
start_reference='plu-gate2',
link_start_to='end')
# 6: basis rotation
if m.basis_rot:
Iamplt1 = self.basis_rot_I_amplitude_lt1
Qamplt1 = self.basis_rot_Q_amplitude_lt1
Iamplt2 = self.basis_rot_I_amplitude_lt2
Qamplt2 = self.basis_rot_Q_amplitude_lt2
PMamp = self.MW_pulsemod_amplitude
else:
Iamplt1 = Qamplt1 = Iamplt2 = Qamplt2 = PMamp = 0
seq.add_pulse('basis rot lt2 I',
chan_mwI_lt2,
'lde',
duration=self.basis_rot_duration_lt2,
amplitude=Iamplt2,
start_reference=last,
start=self.wait_after_opt_pi2,
link_start_to='end')
seq.add_pulse('basis rot lt2 Q',
chan_mwQ_lt2,
'lde',
duration=self.basis_rot_duration_lt2,
amplitude=Qamplt2,
start_reference=last,
start=self.wait_after_opt_pi2,
link_start_to='end')
seq.add_pulse('basis rot lt1 I', chan_mwI_lt1, 'lde',
duration = self.basis_rot_duration_lt1,
amplitude = Iamplt1,
start_reference = 'basis rot lt2 I',
start = (self.basis_rot_duration_lt2-\
self.basis_rot_duration_lt1)/2,
link_start_to = 'start' )
seq.add_pulse('basis rot lt1 Q', chan_mwQ_lt1, 'lde',
duration = self.basis_rot_duration_lt1,
amplitude = Qamplt1,
start_reference = 'basis rot lt2 I',
start = (self.basis_rot_duration_lt2-\
self.basis_rot_duration_lt1)/2,
link_start_to = 'start' )
seq.add_pulse('basis rot pm', chan_mw_pm, 'lde',
amplitude = PMamp,
duration = max(self.basis_rot_duration_lt2+\
2*self.MW_pulsemod_risetime_lt2,
self.basis_rot_duration_lt1+\
2*self.MW_pulsemod_risetime_lt1),
start = min(-self.MW_pulsemod_risetime_lt2,
(self.basis_rot_duration_lt2-\
self.basis_rot_duration_lt1)/2 - \
self.MW_pulsemod_risetime_lt1),
start_reference = 'basis rot lt2 I',
link_start_to = 'start')
# 7: final delay
seq.add_pulse('final delay',
chan_hhsync,
'lde',
amplitude=0,
duration=self.finaldelay,
start=0,
start_reference='plu-gate4',
link_start_to='end')
# idle element
seq.add_element('idle', goto_target='lde')
seq.add_pulse('empty',
chan_alaser,
'idle',
start=0,
duration=1000,
amplitude=0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
return seq
def XY8_cycles(sweep_param,pulse_dict,lt1 = False,do_program=True):
'''
This sequence consists of a number of decoupling-pulses per element
sweep_param = numpy array with number of Pi-pulses per element
pulse_dict={
"Pi":{"duration": ...,
"amplitude": ...},
"istate_pulse": {"duration":... ,
"amplitude":...}, First pulse to create init state
"duty_cycle_time": ..., waiting time at the end of each element
}
'''
seq = Sequence('XY8')
awgcfg.configure_sequence(seq,'mw')
# vars for the channel names
chan_mw_pm = 'MW_pulsemod' #is connected to ch1m1
superposition_pulse=False
if lt1:
chan_mwI = 'MW_Imod_lt1'
chan_mwQ = 'MW_Qmod_lt1'
else:
chan_mwI = 'MW_Imod'
chan_mwQ = 'MW_Qmod'
#FIXME: take this from a dictionary
if lt1:
MW_pulse_mod_risetime = 10
else:
MW_pulse_mod_risetime = 10
nr_of_datapoints = len(sweep_param)
nr_of_XY8_cycles = pulse_dict["nr_of_XY8_cycles"]
pulse_nr = 8*nr_of_XY8_cycles
pi = pulse_dict["Pi"]
tau_sweep = sweep_param
duty_cycle_time = pulse_dict["duty_cycle_time"]
istate_pulse = pulse_dict["init_state_pulse"]
for i in np.arange(nr_of_datapoints):
#create element for each datapoint and link last element to first
if i == nr_of_datapoints-1:
seq.add_element(name = 'spin_control_'+str(i+1),
trigger_wait = True, goto_target = 'spin_control_1')
else:
seq.add_element(name = 'spin_control_'+str(i+1),
trigger_wait = True)
tau=tau_sweep[i]
seq.add_pulse('first_wait', channel = chan_mw_pm,
element = 'spin_control_'+str(i+1),start = 0,
duration = 50, amplitude = 0)
seq.add_pulse('init_state_pulse' , channel = chan_mwI, element = 'spin_control_'+str(i+1),
start_reference = 'first_wait', link_start_to = 'end', start = 0,
duration = istate_pulse["duration"], amplitude = istate_pulse["amplitude"], shape = 'rectangular')
seq.add_pulse('init_state_pulse_mod', channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'init_state_pulse', link_start_to = 'start',
duration_reference = 'init_state_pulse', link_duration_to = 'duration',
amplitude = 2.0)
last = 'init_state_pulse'
for j in np.arange(pulse_nr):
if np.mod(j,8)+1 in [1,3,6,8]:
chan = chan_mwI
else:
chan = chan_mwQ
seq.add_pulse('wait_before' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start_reference = last, link_start_to='end',start = 0,
duration = tau, amplitude = 0)
seq.add_pulse('pi' + str(j), channel = chan, element = 'spin_control_'+str(i+1),
start = 0, start_reference = 'wait_before'+str(j), link_start_to = 'end',
duration = pi["duration"], amplitude = pi["amplitude"], shape = 'rectangular')
seq.add_pulse('pulse_mod' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'pi' + str(j), link_start_to = 'start',
duration_reference = 'pi'+str(j), link_duration_to = 'duration',
amplitude = 2.0)
seq.add_pulse('wait_after' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start_reference = 'pi'+str(j), link_start_to='end',start = 0,
duration = tau, amplitude = 0)
last = 'wait_after'+str(j)
seq.add_pulse('readout_pulse' , channel = chan_mwI, element = 'spin_control_'+str(i+1),
start_reference = last, link_start_to = 'end', start = 0,
duration = istate_pulse["duration"], amplitude = -istate_pulse["amplitude"], shape = 'rectangular')
seq.add_pulse('init_state_pulse_mod', channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'readout_pulse', link_start_to = 'start',
duration_reference = 'init_state_pulse', link_duration_to = 'duration',
amplitude = 2.0)
seq.add_pulse('final_wait', channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start_reference = 'readout_pulse',link_start_to ='end',
duration = duty_cycle_time, amplitude = 0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
max_seq_time = seq.send_sequence()
name= '%d XY8_cycles' % nr_of_XY8_cycles
return {"seqname":name, "max_seq_time":max_seq_time}
def generate_sequence(fstart=f_start - f_mw,
fstop=f_stop - f_mw,
steps=nr_of_datapoints,
do_program=True):
seq = Sequence('dark_esr')
print 'start frequency = ', (fstart + f_mw) / 1E9
print 'stop frequency = ', (fstop + f_mw) / 1E9
awgcfg.configure_sequence(seq, 'mw')
# vars for the channel names
chan_mw_pm = 'MW_pulsemod' #is connected to ch1m1
if lt1:
chan_mwI = 'MW_Imod_lt1'
chan_mwQ = 'MW_Qmod_lt1'
else:
chan_mwI = 'MW_Imod'
chan_mwQ = 'MW_Qmod'
# in this version we keep the center frequency and sweep the
# modulation frequency
# f_central = (fstart+fstop)/2.0
pipulse = pi_pulse_length
mode = 'SSB'
amplitude_i = 0.
amplitude_q = 0.
if lt1:
MW_pulse_mod_risetime = 2
else:
MW_pulse_mod_risetime = 6
# sweep the modulation freq
for i, f_mod in enumerate(linspace(fstart, fstop, steps)):
###################################################################
# the actual rabi sequence and readout
ename = 'desrseq%d' % i
kw = {} if i < steps - 1 else {'goto_target': 'desrseq0'}
seq.add_element(ename, trigger_wait=True, **kw)
seq.add_pulse('wait',
channel=chan_mw_pm,
element=ename,
start=0,
duration=100,
amplitude=0)
seq.add_pulse(name='mwburst',
channel=chan_mwI,
element=ename,
start=0,
duration=pipulse,
frequency=f_mod,
shape='sine',
amplitude=amplitude_ssbmod,
link_start_to='end',
start_reference='wait')
seq.add_pulse('pulse_mod',
channel=chan_mw_pm,
element=ename,
start=-MW_pulse_mod_risetime,
duration=2 * MW_pulse_mod_risetime,
start_reference='mwburst',
link_start_to='start',
duration_reference='mwburst',
link_duration_to='duration',
amplitude=2.0)
###################################################################
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
def generate_sequence(self, do_program=True):
awg.set_event_jump_timing("SYNC")
self.seq = Sequence("lde")
seq = self.seq
# channels
chan_hhsync = "HH_sync" # historically PH_start
chan_hh_ma1 = "HH_MA1" # historically PH_sync
chan_plusync = "PLU_gate"
chan_alaser = "AOM_Newfocus"
chan_eom = "EOM_Matisse"
chan_eom_aom = "EOM_AOM_Matisse"
chan_mw_pm = "MW_pulsemod"
chan_mwI_lt2 = "MW_Imod"
chan_mwQ_lt2 = "MW_Qmod"
chan_mwI_lt1 = "MW_Imod_lt1"
chan_mwQ_lt1 = "MW_Qmod_lt1"
# check if MWpi and optical pi don't overlap:
if self.wait_after_opt_pi >= self.opt_pi_separation - self.eom_pulse_duration - self.pi_lt2_duration:
print "!!! =================== !!!"
print "WARNING: pi pulse and 2nd optical pi pulse might overlap!"
print "Decrease variable wait_after_opt_pi"
print "!!! =================== !!!"
# TODO study the current AWG configuration, then adapt this
awgcfg.configure_sequence(
self.seq,
"hydraharp",
"mw",
LDE={chan_eom_aom: {"high": self.eom_aom_amplitude}, chan_alaser: {"high": self.A_SP_amplitude}},
)
seq.add_element(
"lde", goto_target="idle", repetitions=self.max_LDE_attempts, event_jump_target="idle", trigger_wait=True
)
# 1: spin pumping
seq.add_pulse("initialdelay", chan_alaser, "lde", start=0, duration=10, amplitude=0)
seq.add_pulse(
"spinpumping",
chan_alaser,
"lde",
start=0,
duration=self.SP_duration,
start_reference="initialdelay",
link_start_to="end",
amplitude=1,
)
# 2: Pi/2 pulses on both spins
seq.add_pulse(
"pi/2-1 lt2",
chan_mwI_lt2,
"lde",
duration=self.pi2_lt2_duration,
amplitude=self.pi2_lt2_amplitude,
start_reference="spinpumping",
start=self.wait_after_SP,
link_start_to="end",
)
seq.add_pulse(
"pi/2-1 lt1",
chan_mwI_lt1,
"lde",
duration=self.pi2_lt1_duration,
amplitude=self.pi2_lt1_amplitude,
start_reference="pi/2-1 lt2",
start=(self.pi2_lt2_duration - self.pi2_lt1_duration) / 2,
link_start_to="start",
)
seq.add_pulse(
"pi/2-1 pm",
chan_mw_pm,
"lde",
amplitude=self.MW_pulsemod_amplitude,
duration=max(
self.pi2_lt2_duration + 2 * self.MW_pulsemod_risetime_lt2,
self.pi2_lt1_duration + 2 * self.MW_pulsemod_risetime_lt1,
),
start=min(
-self.MW_pulsemod_risetime_lt2,
(self.pi2_lt2_duration - self.pi2_lt1_duration) / 2 - self.MW_pulsemod_risetime_lt1,
),
start_reference="pi/2-1 lt2",
link_start_to="start",
)
# 3a: optical pi-pulse no 1
i = 1
last = "pi/2-1 pm"
seq.add_pulse(
"start" + str(i),
chan_hhsync,
"lde",
start=self.wait_after_pi2,
duration=50,
amplitude=2.0,
start_reference=last,
link_start_to="end",
)
last = "start" + str(i)
seq.add_pulse(
"mrkr" + str(i),
chan_hh_ma1,
"lde",
start=-20,
duration=50,
amplitude=2.0,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"start" + str(i) + "delay",
chan_hhsync,
"lde",
start=0,
duration=50,
amplitude=0,
start_reference=last,
link_start_to="end",
)
last = "start" + str(i) + "delay"
seq.add_pulse(
"AOM" + str(i),
chan_eom_aom,
"lde",
start=self.aom_start,
duration=self.aom_duration,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_off" + str(i),
chan_eom,
"lde",
amplitude=self.eom_off_amplitude,
start=self.eom_start,
duration=self.eom_off_duration,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_pulse" + str(i),
chan_eom,
"lde",
amplitude=self.eom_pulse_amplitude - self.eom_off_amplitude,
start=self.eom_start + self.eom_off_duration / 2 + self.eom_pulse_offset,
duration=self.eom_pulse_duration,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_overshoot1" + str(i),
chan_eom,
"lde",
amplitude=self.eom_overshoot1,
start=self.eom_start + self.eom_off_duration / 2 + self.eom_pulse_offset + self.eom_pulse_duration,
duration=self.eom_overshoot_duration1,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_overshoot2" + str(i),
chan_eom,
"lde",
amplitude=self.eom_overshoot2,
start=self.eom_start
+ self.eom_off_duration / 2
+ self.eom_pulse_offset
+ self.eom_pulse_duration
+ self.eom_overshoot_duration1,
duration=self.eom_overshoot_duration2,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_off_comp" + str(i),
chan_eom,
"lde",
amplitude=-self.eom_off_amplitude,
start=self.eom_start + self.eom_off_duration,
duration=self.eom_off_duration,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_pulse_comp" + str(i),
chan_eom,
"lde",
amplitude=-self.eom_pulse_amplitude + self.eom_off_amplitude,
start=self.eom_start + self.eom_off_duration + int(self.eom_off_duration / 2) + self.eom_pulse_offset,
duration=self.eom_pulse_duration,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_overshoot1_comp" + str(i),
chan_eom,
"lde",
amplitude=-self.eom_overshoot1,
start=self.eom_start
+ self.eom_off_duration
+ int(self.eom_off_duration / 2)
+ self.eom_pulse_offset
+ self.eom_pulse_duration,
duration=self.eom_overshoot_duration1,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_overshoot2_comp" + str(i),
chan_eom,
"lde",
amplitude=-self.eom_overshoot2,
start=self.eom_start
+ self.eom_off_duration
+ int(self.eom_off_duration / 2)
+ self.eom_pulse_offset
+ self.eom_pulse_duration
+ self.eom_overshoot_duration1,
duration=self.eom_overshoot_duration2,
start_reference=last,
link_start_to="start",
)
last = "EOM_pulse" + str(i)
# 3b: add pre-sync pulses for the HH
for j in range(self.presync_pulses):
if not debug_mode:
pre_sync_amp = 2.0
else:
pre_sync_amp = 0.0
seq.add_pulse(
"presync" + str(j),
chan_hhsync,
"lde",
start=-(j + 1) * self.opt_pi_separation,
duration=50,
amplitude=pre_sync_amp,
start_reference="start" + str(i),
link_start_to="start",
)
# 3c: add PLU gate
seq.add_pulse(
"plu-gate" + str(i),
chan_plusync,
"lde",
start=0,
duration=self.plu_gate_duration,
amplitude=2.0,
start_reference="EOM_pulse" + str(i),
link_start_to="end",
)
# 4: spin pi pulses
seq.add_pulse(
"pi lt2",
chan_mwI_lt2,
"lde",
duration=self.pi_lt2_duration,
amplitude=self.pi_lt2_amplitude,
start_reference=last,
start=self.wait_after_opt_pi,
link_start_to="end",
)
seq.add_pulse(
"pi lt1",
chan_mwI_lt1,
"lde",
duration=self.pi_lt1_duration,
amplitude=self.pi_lt1_amplitude,
start_reference="pi lt2",
start=(self.pi_lt2_duration - self.pi_lt1_duration) / 2,
link_start_to="start",
)
seq.add_pulse(
"pi pm",
chan_mw_pm,
"lde",
amplitude=self.MW_pulsemod_amplitude,
duration=max(
self.pi_lt2_duration + 2 * self.MW_pulsemod_risetime_lt2,
self.pi_lt1_duration + 2 * self.MW_pulsemod_risetime_lt1,
),
start=min(
-self.MW_pulsemod_risetime_lt2,
(self.pi_lt2_duration - self.pi_lt1_duration) / 2 - self.MW_pulsemod_risetime_lt1,
),
start_reference="pi lt2",
link_start_to="start",
)
# 5a: optical pi-pulse no2
i = 2
seq.add_pulse(
"start" + str(i),
chan_hhsync,
"lde",
start=self.opt_pi_separation,
duration=50,
amplitude=2.0,
start_reference="start" + str(i - 1),
link_start_to="start",
)
last = "start" + str(i)
seq.add_pulse(
"start" + str(i) + "delay",
chan_hhsync,
"lde",
start=0,
duration=50,
amplitude=0,
start_reference=last,
link_start_to="end",
)
last = "start" + str(i) + "delay"
seq.add_pulse(
"AOM" + str(i),
chan_eom_aom,
"lde",
start=self.aom_start,
duration=self.aom_duration,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_off" + str(i),
chan_eom,
"lde",
amplitude=self.eom_off_amplitude,
start=self.eom_start,
duration=self.eom_off_duration,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_pulse" + str(i),
chan_eom,
"lde",
amplitude=self.eom_pulse_amplitude - self.eom_off_amplitude,
start=self.eom_start + self.eom_off_duration / 2 + self.eom_pulse_offset,
duration=self.eom_pulse_duration,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_overshoot1" + str(i),
chan_eom,
"lde",
amplitude=self.eom_overshoot1,
start=self.eom_start + self.eom_off_duration / 2 + self.eom_pulse_offset + self.eom_pulse_duration,
duration=self.eom_overshoot_duration1,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_overshoot2" + str(i),
chan_eom,
"lde",
amplitude=self.eom_overshoot2,
start=self.eom_start
+ self.eom_off_duration / 2
+ self.eom_pulse_offset
+ self.eom_pulse_duration
+ self.eom_overshoot_duration1,
duration=self.eom_overshoot_duration2,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_off_comp" + str(i),
chan_eom,
"lde",
amplitude=-self.eom_off_amplitude,
start=self.eom_start + self.eom_off_duration,
duration=self.eom_off_duration,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_pulse_comp" + str(i),
chan_eom,
"lde",
amplitude=-self.eom_pulse_amplitude + self.eom_off_amplitude,
start=self.eom_start + self.eom_off_duration + int(self.eom_off_duration / 2) + self.eom_pulse_offset,
duration=self.eom_pulse_duration,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_overshoot1_comp" + str(i),
chan_eom,
"lde",
amplitude=-self.eom_overshoot1,
start=self.eom_start
+ self.eom_off_duration
+ int(self.eom_off_duration / 2)
+ self.eom_pulse_offset
+ self.eom_pulse_duration,
duration=self.eom_overshoot_duration1,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_overshoot2_comp" + str(i),
chan_eom,
"lde",
amplitude=-self.eom_overshoot2,
start=self.eom_start
+ self.eom_off_duration
+ int(self.eom_off_duration / 2)
+ self.eom_pulse_offset
+ self.eom_pulse_duration
+ self.eom_overshoot_duration1,
duration=self.eom_overshoot_duration2,
start_reference=last,
link_start_to="start",
)
last = "EOM_pulse" + str(i)
# 5b: add post-sync pulses for the HH
for j in range(self.postsync_pulses):
if not debug_mode:
post_sync_amp = 2.0
else:
post_sync_amp = 0.0
seq.add_pulse(
"postsync" + str(j),
chan_hhsync,
"lde",
start=(j + 1) * self.opt_pi_separation,
duration=50,
amplitude=post_sync_amp,
start_reference="start" + str(i),
link_start_to="start",
)
# 5c: add PLU gate
seq.add_pulse(
"plu-gate" + str(i),
chan_plusync,
"lde",
start=self.plu_2_start_offset,
duration=self.plu_gate_duration,
amplitude=2.0,
start_reference="EOM_pulse" + str(i),
link_start_to="end",
)
# 5d: two additional PLU gates
seq.add_pulse(
"plu-gate3",
chan_plusync,
"lde",
start=self.plu_3_delay,
duration=self.plu_gate_duration,
amplitude=2.0,
start_reference="plu-gate2",
link_start_to="end",
)
seq.add_pulse(
"plu-gate4",
chan_plusync,
"lde",
start=self.plu_4_delay,
duration=self.plu_gate_duration,
amplitude=2.0,
start_reference="plu-gate2",
link_start_to="end",
)
# 6: basis rotation
if m.basis_rot:
Iamplt1 = self.basis_rot_I_amplitude_lt1
Qamplt1 = self.basis_rot_Q_amplitude_lt1
Iamplt2 = self.basis_rot_I_amplitude_lt2
Qamplt2 = self.basis_rot_Q_amplitude_lt2
PMamp = self.MW_pulsemod_amplitude
else:
Iamplt1 = Qamplt1 = Iamplt2 = Qamplt2 = PMamp = 0
seq.add_pulse(
"basis rot lt2 I",
chan_mwI_lt2,
"lde",
duration=self.basis_rot_duration_lt2,
amplitude=Iamplt2,
start_reference=last,
start=self.wait_after_opt_pi2,
link_start_to="end",
)
seq.add_pulse(
"basis rot lt2 Q",
chan_mwQ_lt2,
"lde",
duration=self.basis_rot_duration_lt2,
amplitude=Qamplt2,
start_reference=last,
start=self.wait_after_opt_pi2,
link_start_to="end",
)
seq.add_pulse(
"basis rot lt1 I",
chan_mwI_lt1,
"lde",
duration=self.basis_rot_duration_lt1,
amplitude=Iamplt1,
start_reference="basis rot lt2 I",
start=(self.basis_rot_duration_lt2 - self.basis_rot_duration_lt1) / 2,
link_start_to="start",
)
seq.add_pulse(
"basis rot lt1 Q",
chan_mwQ_lt1,
"lde",
duration=self.basis_rot_duration_lt1,
amplitude=Qamplt1,
start_reference="basis rot lt2 I",
start=(self.basis_rot_duration_lt2 - self.basis_rot_duration_lt1) / 2,
link_start_to="start",
)
seq.add_pulse(
"basis rot pm",
chan_mw_pm,
"lde",
amplitude=PMamp,
duration=max(
self.basis_rot_duration_lt2 + 2 * self.MW_pulsemod_risetime_lt2,
self.basis_rot_duration_lt1 + 2 * self.MW_pulsemod_risetime_lt1,
),
start=min(
-self.MW_pulsemod_risetime_lt2,
(self.basis_rot_duration_lt2 - self.basis_rot_duration_lt1) / 2 - self.MW_pulsemod_risetime_lt1,
),
start_reference="basis rot lt2 I",
link_start_to="start",
)
# 7: final delay
seq.add_pulse(
"final delay",
chan_hhsync,
"lde",
amplitude=0,
duration=self.finaldelay,
start=0,
start_reference="plu-gate4",
link_start_to="end",
)
# idle element
seq.add_element("idle", goto_target="lde")
seq.add_pulse("empty", chan_alaser, "idle", start=0, duration=1000, amplitude=0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
return seq
def generate_sequence_SE(do_program=True):
#######################################
###### SPIN ECHO SEQUENCE #############
#######################################
seq = Sequence("spin_control")
awgcfg.configure_sequence(seq, "mw")
# vars for the channel names
chan_mw_pm = "MW_pulsemod" # is connected to ch1m1
par["sequence_wait_time"] = int(ceil(((max_wait_time + pi_2_pulse_length) * 2 + pi_2_pulse_length + 100) / 1e3) + 1)
if lt1:
chan_mwI = "MW_Imod_lt1"
chan_mwQ = "MW_Qmod_lt1"
else:
chan_mwI = "MW_Imod"
chan_mwQ = "MW_Qmod"
if lt1:
MW_pulse_mod_risetime = 2
else:
MW_pulse_mod_risetime = 6
for i in np.arange(nr_of_datapoints):
if i == nr_of_datapoints - 1:
seq.add_element(name="spin_control_" + str(i + 1), trigger_wait=True, goto_target="spin_control_1")
else:
seq.add_element(name="spin_control_" + str(i + 1), trigger_wait=True)
seq.add_pulse(
"wait", channel=chan_mw_pm, element="spin_control_" + str(i + 1), start=0, duration=50, amplitude=0
)
seq.add_pulse(
"first_pi_over_2",
channel=chan_mwI,
element="spin_control_" + str(i + 1),
start=0,
duration=pi_2_pulse_length,
amplitude=0.68,
start_reference="wait",
link_start_to="end",
shape="rectangular",
)
seq.add_pulse(
"pulse_mod",
channel=chan_mw_pm,
element="spin_control_" + str(i + 1),
start=-MW_pulse_mod_risetime,
duration=2 * MW_pulse_mod_risetime,
start_reference="first_pi_over_2",
link_start_to="start",
duration_reference="first_pi_over_2",
link_duration_to="duration",
amplitude=2.0,
)
seq.add_pulse(
"tau",
channel=chan_mw_pm,
element="spin_control_" + str(i + 1),
start_reference="first_pi_over_2",
link_start_to="end",
duration=tau[i],
amplitude=0,
)
seq.add_pulse(
"pi",
channel=chan_mwI,
element="spin_control_" + str(i + 1),
start=0,
duration=pi_pulse_length,
amplitude=amplitude_ssbmod,
start_reference="tau",
link_start_to="end",
shape="rectangular",
)
seq.add_pulse(
"pulse_mod_2",
channel=chan_mw_pm,
element="spin_control_" + str(i + 1),
start=-MW_pulse_mod_risetime,
duration=2 * MW_pulse_mod_risetime,
start_reference="pi",
link_start_to="start",
duration_reference="pi",
link_duration_to="duration",
amplitude=2.0,
)
seq.add_pulse(
"tau_2",
channel=chan_mw_pm,
element="spin_control_" + str(i + 1),
start_reference="pi",
link_start_to="end",
duration=tau[i],
amplitude=0,
)
seq.add_pulse(
"second_pi_over_2",
channel=chan_mwI,
element="spin_control_" + str(i + 1),
start=0,
duration=pi_2_pulse_length,
amplitude=0.68,
start_reference="tau_2",
link_start_to="end",
shape="rectangular",
)
seq.add_pulse(
"pulse_mod2",
channel=chan_mw_pm,
element="spin_control_" + str(i + 1),
start=-MW_pulse_mod_risetime,
duration=2 * MW_pulse_mod_risetime,
start_reference="second_pi_over_2",
link_start_to="start",
duration_reference="second_pi_over_2",
link_duration_to="duration",
amplitude=2.0,
)
seq.add_pulse(
"final_wait",
channel=chan_mw_pm,
element="spin_control_" + str(i + 1),
start_reference="second_pi_over_2",
link_start_to="end",
duration=50,
amplitude=0,
)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
def generate_sequence(self, do_program=True):
awg.set_event_jump_timing('SYNC')
self.seq = Sequence('lde')
seq = self.seq
# channels
chan_hhsync = 'HH_sync' # historically PH_start
chan_hh_ma1 = 'HH_MA1' # historically PH_sync
chan_plusync = 'PLU_gate'
chan_alaser = 'AOM_Newfocus'
chan_eom = 'EOM_Matisse'
chan_eom_aom = 'EOM_AOM_Matisse'
chan_mw_pm = 'MW_pulsemod'
chan_mwI_lt2 = 'MW_Imod'
chan_mwQ_lt2 = 'MW_Qmod'
chan_mwI_lt1 = 'MW_Imod_lt1'
chan_mwQ_lt1 = 'MW_Qmod_lt1'
# check if MWpi and optical pi don't overlap:
if self.wait_after_opt_pi >= self.opt_pi_separation - \
self.eom_pulse_duration - self.pi_lt2_duration:
print '!!! =================== !!!'
print 'WARNING: pi pulse and 2nd optical pi pulse might overlap!'
print 'Decrease variable wait_after_opt_pi'
print '!!! =================== !!!'
# TODO study the current AWG configuration, then adapt this
awgcfg.configure_sequence(self.seq, 'hydraharp', 'mw',
LDE = {
chan_eom_aom: { 'high' : self.eom_aom_amplitude },
chan_alaser: { 'high' : self.A_SP_amplitude, }
},
)
seq.add_element('lde', goto_target='idle',
repetitions=self.max_LDE_attempts, event_jump_target='idle',
trigger_wait=True)
# 1: spin pumping
seq.add_pulse('initialdelay', chan_alaser, 'lde',
start = 0, duration = 10, amplitude=0, )
seq.add_pulse('spinpumping', chan_alaser, 'lde',
start = 0, duration = self.SP_duration,
start_reference='initialdelay',
link_start_to='end', amplitude=1)
# 2: Pi/2 pulses on both spins
seq.add_pulse('pi/2-1 lt2', chan_mwI_lt2, 'lde',
duration = self.pi2_lt2_duration,
amplitude = self.pi2_lt2_amplitude,
start_reference = 'spinpumping',
start = self.wait_after_SP,
link_start_to = 'end' )
seq.add_pulse('pi/2-1 lt1', chan_mwI_lt1, 'lde',
duration = self.pi2_lt1_duration,
amplitude = self.pi2_lt1_amplitude,
start_reference = 'pi/2-1 lt2',
start = (self.pi2_lt2_duration-self.pi2_lt1_duration)/2,
link_start_to = 'start' )
seq.add_pulse('pi/2-1 pm', chan_mw_pm, 'lde',
amplitude = self.MW_pulsemod_amplitude,
duration = max(self.pi2_lt2_duration+\
2*self.MW_pulsemod_risetime_lt2,
self.pi2_lt1_duration+\
2*self.MW_pulsemod_risetime_lt1),
start = min(-self.MW_pulsemod_risetime_lt2,
(self.pi2_lt2_duration-self.pi2_lt1_duration)/2 - \
self.MW_pulsemod_risetime_lt1),
start_reference = 'pi/2-1 lt2',
link_start_to = 'start' )
# 3a: optical pi-pulse no 1
i = 1
last = 'pi/2-1 pm'
seq.add_pulse('start'+str(i), chan_hhsync, 'lde',
start = self.wait_after_pi2, duration = 50,
amplitude = 2.0, start_reference = last,
link_start_to = 'end')
last = 'start'+str(i)
seq.add_pulse('mrkr'+str(i), chan_hh_ma1, 'lde',
start=-20, duration=50,
amplitude=2.0, start_reference=last,
link_start_to='start')
seq.add_pulse('start'+str(i)+'delay', chan_hhsync, 'lde',
start = 0, duration = 50, amplitude = 0,
start_reference = last, link_start_to = 'end')
last = 'start'+str(i)+'delay'
seq.add_pulse('AOM'+str(i), chan_eom_aom, 'lde',
start = self.aom_start, duration = self.aom_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_off'+str(i), chan_eom, 'lde',
amplitude = self.eom_off_amplitude,
start = self.eom_start, duration = self.eom_off_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_pulse'+str(i), chan_eom, 'lde',
amplitude = self.eom_pulse_amplitude - self.eom_off_amplitude,
start = self.eom_start + self.eom_off_duration/2 + \
self.eom_pulse_offset, duration = self.eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1'+str(i), chan_eom, 'lde',
amplitude = self.eom_overshoot1,
start = self.eom_start + self.eom_off_duration/2 + \
self.eom_pulse_offset + self.eom_pulse_duration,
duration = self.eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2'+str(i), chan_eom, 'lde',
amplitude = self.eom_overshoot2,
start = self.eom_start + self.eom_off_duration/2 + \
self.eom_pulse_offset + self.eom_pulse_duration + \
self.eom_overshoot_duration1,
duration = self.eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_off_comp'+str(i), chan_eom, 'lde',
amplitude = -self.eom_off_amplitude,
start = self.eom_start+self.eom_off_duration,
duration = self.eom_off_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_pulse_comp'+str(i), chan_eom, 'lde',
amplitude = -self.eom_pulse_amplitude + self.eom_off_amplitude,
start = self.eom_start+self.eom_off_duration + \
int(self.eom_off_duration/2) + self.eom_pulse_offset,
duration = self.eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1_comp'+str(i), chan_eom, 'lde',
amplitude = -self.eom_overshoot1,
start = self.eom_start+self.eom_off_duration + \
int(self.eom_off_duration/2) + self.eom_pulse_offset + \
self.eom_pulse_duration,
duration = self.eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2_comp'+str(i), chan_eom, 'lde',
amplitude = -self.eom_overshoot2,
start = self.eom_start+self.eom_off_duration + \
int(self.eom_off_duration/2) + self.eom_pulse_offset + \
self.eom_pulse_duration + self.eom_overshoot_duration1,
duration = self.eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
last = 'EOM_pulse'+str(i)
# 3b: add pre-sync pulses for the HH
for j in range(self.presync_pulses):
if not debug_mode:
pre_sync_amp = 2.0
else:
pre_sync_amp = 0.0
seq.add_pulse('presync'+str(j), chan_hhsync, 'lde',
start = -(j+1)*self.opt_pi_separation, duration = 50,
amplitude = pre_sync_amp, start_reference = 'start'+str(i),
link_start_to = 'start')
# 3c: add PLU gate
seq.add_pulse('plu-gate'+str(i), chan_plusync, 'lde',
start = 0,
duration = self.plu_gate_duration,
amplitude = 2.0,
start_reference = 'EOM_pulse'+str(i),
link_start_to = 'end' )
# 4: spin pi pulses
seq.add_pulse('pi lt2', chan_mwI_lt2, 'lde',
duration = self.pi_lt2_duration,
amplitude = self.pi_lt2_amplitude,
start_reference = last,
start = self.wait_after_opt_pi,
link_start_to = 'end' )
seq.add_pulse('pi lt1', chan_mwI_lt1, 'lde',
duration = self.pi_lt1_duration,
amplitude = self.pi_lt1_amplitude,
start_reference = 'pi lt2',
start = (self.pi_lt2_duration-self.pi_lt1_duration)/2,
link_start_to = 'start' )
seq.add_pulse('pi pm', chan_mw_pm, 'lde',
amplitude = self.MW_pulsemod_amplitude,
duration = max(self.pi_lt2_duration+\
2*self.MW_pulsemod_risetime_lt2,
self.pi_lt1_duration+\
2*self.MW_pulsemod_risetime_lt1),
start = min(-self.MW_pulsemod_risetime_lt2,
(self.pi_lt2_duration-self.pi_lt1_duration)/2 - \
self.MW_pulsemod_risetime_lt1),
start_reference = 'pi lt2',
link_start_to = 'start')
# 5a: optical pi-pulse no2
i = 2
seq.add_pulse('start'+str(i), chan_hhsync, 'lde',
start = self.opt_pi_separation, duration = 50,
amplitude = 2.0, start_reference = 'start'+str(i-1),
link_start_to = 'start')
last = 'start'+str(i)
seq.add_pulse('start'+str(i)+'delay', chan_hhsync, 'lde',
start = 0, duration = 50, amplitude = 0,
start_reference = last, link_start_to = 'end')
last = 'start'+str(i)+'delay'
seq.add_pulse('AOM'+str(i), chan_eom_aom, 'lde',
start = self.aom_start, duration = self.aom_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_off'+str(i), chan_eom, 'lde',
amplitude = self.eom_off_amplitude,
start = self.eom_start, duration = self.eom_off_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_pulse'+str(i), chan_eom, 'lde',
amplitude = self.eom_pulse_amplitude - self.eom_off_amplitude,
start = self.eom_start + self.eom_off_duration/2 + \
self.eom_pulse_offset, duration = self.eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1'+str(i), chan_eom, 'lde',
amplitude = self.eom_overshoot1,
start = self.eom_start + self.eom_off_duration/2 + \
self.eom_pulse_offset + self.eom_pulse_duration,
duration = self.eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2'+str(i), chan_eom, 'lde',
amplitude = self.eom_overshoot2,
start = self.eom_start + self.eom_off_duration/2 + \
self.eom_pulse_offset + self.eom_pulse_duration + \
self.eom_overshoot_duration1,
duration = self.eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_off_comp'+str(i), chan_eom, 'lde',
amplitude = -self.eom_off_amplitude,
start = self.eom_start+self.eom_off_duration,
duration = self.eom_off_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_pulse_comp'+str(i), chan_eom, 'lde',
amplitude = -self.eom_pulse_amplitude + self.eom_off_amplitude,
start = self.eom_start+self.eom_off_duration + \
int(self.eom_off_duration/2) + self.eom_pulse_offset,
duration = self.eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1_comp'+str(i), chan_eom, 'lde',
amplitude = -self.eom_overshoot1,
start = self.eom_start+self.eom_off_duration + \
int(self.eom_off_duration/2) + self.eom_pulse_offset + \
self.eom_pulse_duration,
duration = self.eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2_comp'+str(i), chan_eom, 'lde',
amplitude = -self.eom_overshoot2,
start = self.eom_start+self.eom_off_duration + \
int(self.eom_off_duration/2) + self.eom_pulse_offset + \
self.eom_pulse_duration + self.eom_overshoot_duration1,
duration = self.eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
last = 'EOM_pulse'+str(i)
# 5b: add post-sync pulses for the HH
for j in range(self.postsync_pulses):
if not debug_mode:
post_sync_amp = 2.0
else:
post_sync_amp = 0.0
seq.add_pulse('postsync'+str(j), chan_hhsync, 'lde',
start = (j+1)*self.opt_pi_separation, duration = 50,
amplitude = post_sync_amp, start_reference = 'start'+str(i),
link_start_to = 'start')
# 5c: add PLU gate
seq.add_pulse('plu-gate'+str(i), chan_plusync, 'lde',
start = self.plu_2_start_offset,
duration = self.plu_gate_duration,
amplitude = 2.0,
start_reference = 'EOM_pulse'+str(i),
link_start_to = 'end' )
# 5d: two additional PLU gates
seq.add_pulse('plu-gate3', chan_plusync, 'lde',
start = self.plu_3_delay,
duration = self.plu_gate_duration,
amplitude = 2.0,
start_reference = 'plu-gate2',
link_start_to = 'end')
seq.add_pulse('plu-gate4', chan_plusync, 'lde',
start = self.plu_4_delay,
duration = self.plu_gate_duration,
amplitude = 2.0,
start_reference = 'plu-gate2',
link_start_to = 'end')
# 6: basis rotation
if m.basis_rot:
Iamplt1 = self.basis_rot_I_amplitude_lt1
Qamplt1 = self.basis_rot_Q_amplitude_lt1
Iamplt2 = self.basis_rot_I_amplitude_lt2
Qamplt2 = self.basis_rot_Q_amplitude_lt2
PMamp = self.MW_pulsemod_amplitude
else:
Iamplt1=Qamplt1=Iamplt2=Qamplt2=PMamp=0
seq.add_pulse('basis rot lt2 I', chan_mwI_lt2, 'lde',
duration = self.basis_rot_duration_lt2,
amplitude = Iamplt2,
start_reference = last,
start = self.wait_after_opt_pi2,
link_start_to = 'end' )
seq.add_pulse('basis rot lt2 Q', chan_mwQ_lt2, 'lde',
duration = self.basis_rot_duration_lt2,
amplitude = Qamplt2,
start_reference = last,
start = self.wait_after_opt_pi2,
link_start_to = 'end' )
seq.add_pulse('basis rot lt1 I', chan_mwI_lt1, 'lde',
duration = self.basis_rot_duration_lt1,
amplitude = Iamplt1,
start_reference = 'basis rot lt2 I',
start = (self.basis_rot_duration_lt2-\
self.basis_rot_duration_lt1)/2,
link_start_to = 'start' )
seq.add_pulse('basis rot lt1 Q', chan_mwQ_lt1, 'lde',
duration = self.basis_rot_duration_lt1,
amplitude = Qamplt1,
start_reference = 'basis rot lt2 I',
start = (self.basis_rot_duration_lt2-\
self.basis_rot_duration_lt1)/2,
link_start_to = 'start' )
seq.add_pulse('basis rot pm', chan_mw_pm, 'lde',
amplitude = PMamp,
duration = max(self.basis_rot_duration_lt2+\
2*self.MW_pulsemod_risetime_lt2,
self.basis_rot_duration_lt1+\
2*self.MW_pulsemod_risetime_lt1),
start = min(-self.MW_pulsemod_risetime_lt2,
(self.basis_rot_duration_lt2-\
self.basis_rot_duration_lt1)/2 - \
self.MW_pulsemod_risetime_lt1),
start_reference = 'basis rot lt2 I',
link_start_to = 'start')
# 7: final delay
seq.add_pulse('final delay', chan_hhsync, 'lde',
amplitude = 0,
duration = self.finaldelay,
start = 0,
start_reference = 'plu-gate4',
link_start_to = 'end' )
# idle element
seq.add_element('idle', goto_target='lde')
seq.add_pulse('empty', chan_alaser, 'idle', start=0, duration = 1000,
amplitude = 0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
return seq
from measurement.config import awgchannels_lt2 as awgcfg
from measurement.AWG_HW_sequencer_v2 import Sequence
seq = Sequence('argh')
os.chdir('D:/measuring/qtlab/')
reload(awgcfg)
os.chdir('D:/measuring/user/scripts/lt2_scripts/')
awgcfg.configure_sequence(seq,'mw')
#seq.add_channel('PH_start', 'ch4m2', cable_delay=0)
#seq.add_channel('Green', 'ch2m1', cable_delay=604, high=0.5)
#seq.add_channel('MW_pulsemod', 'ch2m2', high=2.0, cable_delay = 0)
#seq.add_channel('MW_Imod', 'ch1', high=0.9, low=-0.9)
#seq.add_channel('MW_Qmod', 'ch4', high=0.9, low=-0.9, cable_delay = 0)
seq.add_channel('trigger','ch4m2', high=1.0)
#seq.add_channel('pm','ch1m1', high=2.0, cable_delay=27)
chan_mw_pm = 'MW_pulsemod'
chan_mwI = 'MW_Imod_lt1'
chan_mwQ = 'MW_Qmod_lt1'
MW_pulse_mod_risetime = 10#6 = correct for LT2, 2 = correct for LT1
MW_Imod_duration = 8
elt = 'test'
seq.add_element(elt, goto_target = elt)
#seq.add_pulse('PH', 'PH_start', elt, start=0, duration=50)
#seq.add_pulse('Green', 'Green', elt, start=0, amplitude = 1, duration=5000,start_reference = 'PH',link_start_to='end')
def generate_sequence(do_program=True):
seq = Sequence('tpqi_remote')
# vars for the channel names
chan_hhsync = 'HH_sync' # historically PH_start
chan_hh_ma1 = 'HH_MA1' # historically PH_sync
chan_exlaser = 'AOM_Matisse' # ok
chan_alaser_lt2 = 'AOM_Newfocus' # ok
chan_alaser_lt1 = 'AOM_Newfocus_lt1'
chan_adwinsync = 'ADwin_sync' # ok
chan_eom = 'EOM_Matisse'
chan_eom_aom = 'EOM_AOM_Matisse'
chan_plu = 'PLU_gate'
#chan_pulse_gating_module = 'Pulse_gating_module'
awgcfg.configure_sequence(seq, 'hydraharp', 'mw',
LDE = {
chan_eom_aom: { 'high' : par_eom_aom_amplitude },
},
)
#int(par_adwin_aom_duration*1e4)
seq.add_element('optical_rabi', repetitions=par_el_repetitions, goto_target = 'idle')#'optical_rabi',event_jump_target='idle')
seq.add_pulse('sync_start', chan_hhsync, 'optical_rabi',
start = 0, duration = 50,
amplitude = 2.0)
seq.add_pulse('delay', chan_hhsync, 'optical_rabi',
start = 0, duration = 50, amplitude = 0,
start_reference = 'sync_start', link_start_to = 'end')
last = 'delay'
#XXXXXXXX
seq.add_pulse('AOM', chan_eom_aom, 'optical_rabi',
start = par_aom_start, duration = par_aom_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_off', chan_eom, 'optical_rabi',
amplitude = par_eom_off_amplitude,
start = par_eom_start, duration = par_eom_off_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_pulse', chan_eom, 'optical_rabi',
amplitude = par_eom_pulse_amplitude - par_eom_off_amplitude,
start = par_eom_start + par_eom_off_duration/2 + \
par_eom_pulse_offset, duration = par_eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1', chan_eom, 'optical_rabi',
amplitude = par_eom_overshoot1,
start = par_eom_start + par_eom_off_duration/2 + \
par_eom_pulse_offset + par_eom_pulse_duration,
duration = par_eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2', chan_eom, 'optical_rabi',
amplitude = par_eom_overshoot2,
start = par_eom_start + par_eom_off_duration/2 + \
par_eom_pulse_offset + par_eom_pulse_duration + \
par_eom_overshoot_duration1,
duration = par_eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_off_comp', chan_eom, 'optical_rabi',
amplitude = -par_eom_off_amplitude,
start = par_eom_start+par_eom_off_duration,
duration = par_eom_off_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_pulse_comp', chan_eom, 'optical_rabi',
amplitude = -par_eom_pulse_amplitude + par_eom_off_amplitude,
start = par_eom_start+par_eom_off_duration + \
int(par_eom_off_duration/2) + par_eom_pulse_offset,
duration = par_eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1_comp', chan_eom, 'optical_rabi',
amplitude = -par_eom_overshoot1,
start = par_eom_start+par_eom_off_duration + \
int(par_eom_off_duration/2) + par_eom_pulse_offset + \
par_eom_pulse_duration,
duration = par_eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2_comp', chan_eom, 'optical_rabi',
amplitude = -par_eom_overshoot2,
start = par_eom_start+par_eom_off_duration + \
int(par_eom_off_duration/2) + par_eom_pulse_offset + \
par_eom_pulse_duration + par_eom_overshoot_duration1,
duration = par_eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
#XXXXXXXXXXXX
seq.add_pulse('Gate_PLU_2', chan_plu, 'optical_rabi',
start = 0, duration = par_plu_gate_duration,
start_reference = 'EOM_pulse', link_start_to = 'end')
seq.add_pulse('Gate_PLU_1', chan_plu, 'optical_rabi',
start = -100, duration = 50,
start_reference = 'Gate_PLU_2', link_start_to = 'start')
seq.add_pulse('Gate_PLU_3', chan_plu, 'optical_rabi',
start = 300, duration = 150,
start_reference = 'Gate_PLU_2', link_start_to = 'end')
seq.add_pulse('Gate_PLU_4', chan_plu, 'optical_rabi',
start = 50, duration = 50,
start_reference = 'Gate_PLU_3', link_start_to = 'end')
seq.add_pulse('empty', chan_hh_ma1, 'optical_rabi', start=0,
start_reference = 'sync_start', link_start_to = 'start',
duration = par_sync_period , amplitude = 0)
seq.add_element('idle', goto_target='idle',
event_jump_target = 'optical_rabi')
seq.add_pulse('empty', chan_hh_ma1, 'idle', start=0, duration = 1000,
amplitude = 0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
def generate_sequence_SE(do_program=True):
seq = Sequence('spin_control')
awgcfg.configure_sequence(seq, 'mw')
# vars for the channel names
chan_mw_pm = 'MW_pulsemod' #is connected to ch1m1
if lt1:
chan_mwI = 'MW_Imod_lt1'
chan_mwQ = 'MW_Qmod_lt1'
else:
chan_mwI = 'MW_Imod'
chan_mwQ = 'MW_Qmod'
if lt1:
MW_pulse_mod_risetime = 2
else:
MW_pulse_mod_risetime = 6
for i in np.arange(nr_of_datapoints):
if i == nr_of_datapoints - 1:
seq.add_element(name='spin_control_' + str(i + 1),
trigger_wait=True,
goto_target='spin_control_1')
else:
seq.add_element(name='spin_control_' + str(i + 1),
trigger_wait=True)
seq.add_pulse('wait',
channel=chan_mw_pm,
element='spin_control_' + str(i + 1),
start=0,
duration=50,
amplitude=0)
seq.add_pulse('first_pi_over_2',
channel=chan_mwI,
element='spin_control_' + str(i + 1),
start=0,
duration=pi_2_pulse_length,
amplitude=amplitude_ssbmod,
start_reference='wait',
link_start_to='end',
shape='rectangular')
seq.add_pulse('pulse_mod',
channel=chan_mw_pm,
element='spin_control_' + str(i + 1),
start=-MW_pulse_mod_risetime,
duration=2 * MW_pulse_mod_risetime,
start_reference='first_pi_over_2',
link_start_to='start',
duration_reference='first_pi_over_2',
link_duration_to='duration',
amplitude=2.0)
seq.add_pulse('tau',
channel=chan_mw_pm,
element='spin_control_' + str(i + 1),
start_reference='first_pi_over_2',
link_start_to='end',
duration=tau[i],
amplitude=0)
seq.add_pulse('pi',
channel=chan_mwI,
element='spin_control_' + str(i + 1),
start=0,
duration=pi_pulse_length,
amplitude=amplitude_ssbmod,
start_reference='tau',
link_start_to='end',
shape='rectangular')
seq.add_pulse('pulse_mod_2',
channel=chan_mw_pm,
element='spin_control_' + str(i + 1),
start=-MW_pulse_mod_risetime,
duration=2 * MW_pulse_mod_risetime,
start_reference='pi',
link_start_to='start',
duration_reference='pi',
link_duration_to='duration',
amplitude=2.0)
seq.add_pulse('tau_2',
channel=chan_mw_pm,
element='spin_control_' + str(i + 1),
start_reference='pi',
link_start_to='end',
duration=tau[i],
amplitude=0)
seq.add_pulse('second_pi_over_2',
channel=chan_mwI,
element='spin_control_' + str(i + 1),
start=0,
duration=pi_2_pulse_length,
amplitude=amplitude_ssbmod,
start_reference='tau_2',
link_start_to='end',
shape='rectangular')
seq.add_pulse('pulse_mod2',
channel=chan_mw_pm,
element='spin_control_' + str(i + 1),
start=-MW_pulse_mod_risetime,
duration=2 * MW_pulse_mod_risetime,
start_reference='second_pi_over_2',
link_start_to='start',
duration_reference='second_pi_over_2',
link_duration_to='duration',
amplitude=2.0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
def generate_sequence_SE(do_program=True):
seq = Sequence('spin_control')
awgcfg.configure_sequence(seq,'mw')
# vars for the channel names
chan_mw_pm = 'MW_pulsemod' #is connected to ch1m1
if lt1:
chan_mwI = 'MW_Imod_lt1'
chan_mwQ = 'MW_Qmod_lt1'
else:
chan_mwI = 'MW_Imod'
chan_mwQ = 'MW_Qmod'
if lt1:
MW_pulse_mod_risetime = 2
else:
MW_pulse_mod_risetime = 6
for i in np.arange(nr_of_datapoints):
seq.add_element(name='MBI_pulse'+str(i),trigger_wait=True, event_jump_target='spin_control_'+str(i+1),goto_target='MBI_pulse'+str(i))
if i == nr_of_datapoints-1:
seq.add_element(name = 'spin_control_'+str(i+1),
trigger_wait = True, goto_target = 'spin_control_1')
else:
seq.add_element(name = 'spin_control_'+str(i+1),
trigger_wait = True)
seq.add_pulse('wait', channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start = 0, duration = 50, amplitude = 0)
seq.add_pulse('first_pi_over_2', channel = chan_mwI, element = 'spin_control_'+str(i+1),
start = 0, duration = pi_2_pulse_length, amplitude = amplitude_ssbmod, start_reference = 'wait',
link_start_to = 'end', shape = 'rectangular')
seq.add_pulse('pulse_mod', channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'first_pi_over_2', link_start_to = 'start',
duration_reference = 'first_pi_over_2', link_duration_to = 'duration',
amplitude = 2.0)
seq.add_pulse('tau', channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start_reference = 'first_pi_over_2',link_start_to ='end', duration = tau[i], amplitude = 0)
seq.add_pulse('pi', channel = chan_mwI, element = 'spin_control_'+str(i+1),
start = 0, duration = pi_pulse_length, amplitude = amplitude_ssbmod, start_reference = 'tau',
link_start_to = 'end', shape = 'rectangular')
seq.add_pulse('pulse_mod_2', channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'pi', link_start_to = 'start',
duration_reference = 'pi', link_duration_to = 'duration',
amplitude = 2.0)
seq.add_pulse('tau_2', channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start_reference = 'pi',link_start_to ='end', duration = tau[i], amplitude = 0)
seq.add_pulse('second_pi_over_2', channel = chan_mwI, element = 'spin_control_'+str(i+1),
start = 0, duration = pi_2_pulse_length, amplitude = amplitude_ssbmod, start_reference = 'tau_2',
link_start_to = 'end', shape = 'rectangular')
seq.add_pulse('pulse_mod2', channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'second_pi_over_2', link_start_to = 'start',
duration_reference = 'second_pi_over_2', link_duration_to = 'duration',
amplitude = 2.0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
def generate_sequence_readout_pulse(do_program=True):
seq = Sequence('spin_control')
awgcfg.configure_sequence(seq,'mw_weak_meas')
# vars for the channel names
chan_mw_pm = 'MW_pulsemod' #is connected to ch1m1
if lt1:
chan_mwI = 'MW_Imod_lt1'
chan_mwQ = 'MW_Qmod_lt1'
else:
chan_mwI = 'MW_Imod'
chan_mwQ = 'MW_Qmod'
chan_RF = 'RF'
if lt1:
MW_pulse_mod_risetime = 2
else:
MW_pulse_mod_risetime = 6
for i in np.arange(nr_of_datapoints):
seq.add_element(name='MBI_pulse'+str(i),trigger_wait=True, event_jump_target='spin_control_'+str(i+1),goto_target='MBI_pulse'+str(i))
seq.add_pulse('wait', channel = chan_mwI, element ='MBI_pulse'+str(i),
start = 0, duration = 100, amplitude = 0)
seq.add_pulse('pi_pulse', channel = chan_mwI, element = 'MBI_pulse'+str(i),
start = 0, duration = pi_pulse_length, amplitude = shelving*amplitude_ssbmod, start_reference = 'wait',
link_start_to = 'end', shape = 'rectangular')
seq.add_pulse('pulse_mod', channel = chan_mw_pm, element = 'MBI_pulse'+str(i),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'pi_pulse', link_start_to = 'start',
duration_reference = 'pi_pulse', link_duration_to = 'duration',
amplitude = shelving*2.0)
seq.add_pulse('wait2', channel = chan_mwI, element ='MBI_pulse'+str(i),
start = 0, start_reference ='pi_pulse',link_start_to='end',duration = 100, amplitude = 0)
seq.add_pulse('MBI_pulse', channel = chan_mwI, element = 'MBI_pulse'+str(i),
start = 0, duration = MBI_pulse_length, amplitude = MBI_amp, start_reference = 'wait2',
link_start_to = 'end', shape = 'sine',frequency=MBI_f+hf)
seq.add_pulse('pulse_mod2', channel = chan_mw_pm, element = 'MBI_pulse'+str(i),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'MBI_pulse', link_start_to = 'start',
duration_reference = 'MBI_pulse', link_duration_to = 'duration',
amplitude = 2.0)
seq.add_pulse('wait_for_ADwin', channel = chan_mwI, element = 'MBI_pulse'+str(i),
start = 0, duration = 1000*(par['MBI_RO_duration']+par['wait_for_MBI_pulse'])-MBI_pulse_length+1000., amplitude = 0, start_reference = 'MBI_pulse',
link_start_to = 'end', shape = 'rectangular')
if i == nr_of_datapoints-1:
seq.add_element(name = 'spin_control_'+str(i+1),
trigger_wait = True, goto_target = 'MBI_pulse0')
else:
seq.add_element(name = 'spin_control_'+str(i+1),
trigger_wait = True)
seq.add_pulse('wait', channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start = 0, duration = 100+first_wait_time, amplitude = 0)
seq.add_pulse('shelving_pulse', channel = chan_mwI, element = 'spin_control_'+str(i+1),
start = 2000, duration =shelving_duration, amplitude = shelving_amp, start_reference = 'wait',
link_start_to = 'end', shape = 'sine',frequency=MBI_f+hf,envelope='erf')
seq.add_pulse('pulse_mod', channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'shelving_pulse', link_start_to = 'start',
duration_reference = 'shelving_pulse', link_duration_to = 'duration',
amplitude = 2.0)
seq.add_pulse('wait2', channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start = 0, duration = 100, amplitude = 0,start_reference='shelving_pulse',link_start_to='end')
seq.add_pulse('readout_pulse', channel = chan_mwI, element = 'spin_control_'+str(i+1),
start = 2000, duration =RO_duration[i], amplitude = pi2pi_amp, start_reference = 'wait2',
link_start_to = 'end', shape = 'sine',frequency=MBI_f+hf,envelope='erf')
seq.add_pulse('pulse_mod2', channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'readout_pulse', link_start_to = 'start',
duration_reference = 'readout_pulse', link_duration_to = 'duration',
amplitude = 2.0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
def XY8_cycles_multiple_elements(sweep_param,pulse_dict,lt1 = False,do_program=True):
'''
This sequence consists of a number of decoupling-pulses per sweepparam
every pulse is in a single element, tau is repeated to decrease number of points
sweep_param = numpy array with number of Pi-pulses per element
pulse_dict={
"Pi":{"duration": ...,
"amplitude": ...},
"istate_pulse": {"duration":... ,
"amplitude":...}, First pulse to create init state
"duty_cycle_time": ..., waiting time at the end of each element
"tau_el_length":...
}
'''
seq = Sequence('XY8')
awgcfg.configure_sequence(seq,'mw')
# vars for the channel names
chan_mw_pm = 'MW_pulsemod' #is connected to ch1m1
if lt1:
chan_mwI = 'MW_Imod_lt1'
chan_mwQ = 'MW_Qmod_lt1'
else:
chan_mwI = 'MW_Imod'
chan_mwQ = 'MW_Qmod'
#FIXME: take this from a dictionary
if lt1:
MW_pulse_mod_risetime = 10
else:
MW_pulse_mod_risetime = 10
nr_of_datapoints = len(sweep_param)
nr_of_XY8_cycles = pulse_dict["nr_of_XY8_cycles"]
pulse_nr = 8*nr_of_XY8_cycles
pi = pulse_dict["Pi"]
tau_sweep = sweep_param
duty_cycle_time = pulse_dict["duty_cycle_time"]
istate_pulse = pulse_dict["init_state_pulse"]
tau_len=pulse_dict["tau_el_length"] # ns
for i in np.arange(nr_of_datapoints):
#create element for each datapoint and link last element to first
el_name = 'Pi_over2_'+str(i+1)
seq.add_element(name = el_name,
trigger_wait = True)
seq.add_pulse(name='first_wait', channel = chan_mw_pm,
element = el_name,start = 0,
duration = 960, amplitude = 0)
seq.add_pulse(name='Pi/2_pulse' , channel = chan_mwI, element = el_name,
start_reference = 'first_wait', link_start_to = 'end', start = 0,
duration = istate_pulse["duration"], amplitude = istate_pulse["amplitude"], shape = 'rectangular')
seq.add_pulse(name='Pi/2_pulse_mod', channel = chan_mw_pm, element = el_name,
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'Pi/2_pulse', link_start_to = 'start',
duration_reference = 'Pi/2_pulse', link_duration_to = 'duration',
amplitude = 2.0)
pulse_idx = 0
tau_idx=0
for j in np.arange(pulse_nr):
if np.mod(j,8)+1 in [1,3,6,8]:
chan = chan_mwI
pulse_el_name = 'X'+str(pulse_idx)+'_'+str(i+1)
else:
chan = chan_mwQ
pulse_el_name = 'Y'+str(pulse_idx)+'_'+str(i+1)
## tau1
cur_el_name='tau'+str(tau_idx)+'_'+str(i+1)
seq.add_element(name=cur_el_name,trigger_wait = False,repetitions=tau_sweep[i])
seq.add_pulse(name='tau'+str(tau_idx),channel=chan_mw_pm,element=cur_el_name,
start=0,duration=tau_len-int(1000./tau_sweep[i]/2.))
tau_idx+=1
## pi pulse
seq.add_element(name=pulse_el_name,trigger_wait = False,repetitions=1)
seq.add_pulse(name='extra_wait'+str(j), channel = chan_mw_pm,
element = pulse_el_name,start = 0,
duration = 500.-int(pi["duration"]/2), amplitude = 0)
seq.add_pulse('pi' + str(j), channel = chan, element = pulse_el_name,
start = 0, duration = pi["duration"], amplitude = pi["amplitude"], shape = 'rectangular',
start_reference='extra_wait'+str(j),link_start_to='end')
seq.add_pulse('pulse_mod' + str(j), channel = chan_mw_pm, element = pulse_el_name,
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'pi' + str(j), link_start_to = 'start',
duration_reference = 'pi'+str(j), link_duration_to = 'duration',
amplitude = 2.0)
seq.add_pulse(name='extra_wait_2'+str(j), channel = chan_mw_pm,
element = pulse_el_name,start = 0,
duration = 500.-int(pi["duration"]/2), amplitude = 0,start_reference='pi'+str(j),link_start_to='end')
pulse_idx+=1
## tau2
cur_el_name='tau'+str(tau_idx)+'_'+str(i+1)
seq.add_element(name=cur_el_name,trigger_wait = False,repetitions=tau_sweep[i])
seq.add_pulse(name='tau'+str(tau_idx),channel=chan_mw_pm,element=cur_el_name,
start=0,duration=tau_len-int(1000./tau_sweep[i]/2.))
tau_idx+=1
##Final readout pulse
cur_el_name = 'readout'+str(i+1)
if i == nr_of_datapoints-1:
print 'going to nr 1'
target= 'Pi_over2_'+str(1)
else:
target='none'
seq.add_element(name = cur_el_name ,trigger_wait = False,goto_target=target)
seq.add_pulse('readout_pulse' , channel = chan_mwI, element = cur_el_name,
start = 0, duration = istate_pulse["duration"], amplitude = istate_pulse["amplitude"], shape = 'rectangular')
seq.add_pulse('Pi/2_pulse_mod', channel = chan_mw_pm, element = cur_el_name,
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'readout_pulse', link_start_to = 'start',
duration_reference = 'readout_pulse', link_duration_to = 'duration',
amplitude = 2.0)
seq.add_pulse('final_wait', channel = chan_mw_pm, element = cur_el_name,
start_reference = 'readout_pulse',link_start_to ='end',
duration = duty_cycle_time, amplitude = 0)
print 'start to set AWG specs'
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
a = seq.send_sequence()
print 'done sending AWG sequence'
tau_max = tau_len*(tau_sweep.max())
max_seq_time = pulse_nr*(pi["duration"]+2*tau_max)+duty_cycle_time+50+2*istate_pulse["duration"]
print 'max seq time %d' % max_seq_time
name= '%d XY8_cycles' % nr_of_XY8_cycles
return {"seqname":name, "max_seq_time":max_seq_time}
def generate_sequence(do_program=True):
seq = Sequence('tpqi_remote')
# vars for the channel names
chan_hhsync = 'HH_sync' # historically PH_start
chan_hh_ma1 = 'HH_MA1' # historically PH_sync
chan_alasers = 'AOM_Newfocus' # ok
chan_eom = 'EOM_Matisse'
chan_eom_aom = 'EOM_AOM_Matisse'
awgcfg.configure_sequence(seq, 'hydraharp',
LDE = {chan_eom_aom: {'high': par_eom_aom_amplitude},
chan_alasers: {'high': par_sp_voltage}})
seq.add_element('optical_rabi', goto_target = 'idle')#'optical_rabi',event_jump_target='idle')
seq.add_pulse('spinpumping',chan_alasers, 'optical_rabi',
start = 0, duration = par_sp_duration)
#Define a start point for the sequence, set amplitude to 0. actual sync pulse comes later
if debug_mode:
seq.add_pulse('hh_debug_sync', chan_hhsync, 'optical_rabi', start = 0,
duration = 50, amplitude = 0.0)
seq.add_pulse('start', chan_hhsync, 'optical_rabi', start = 0,
start_reference='spinpumping', link_start_to='end',
duration = 50, amplitude = 0.0)
last_start = 'start'
seq.add_pulse('start_marker', chan_hh_ma1, 'optical_rabi',
start = par_rabi_cycle_duration/2,
start_reference='start', link_start_to='end',
duration = 50)
for i in arange(par_rabi_reps):
seq.add_pulse('start'+str(i), chan_hhsync, 'optical_rabi',
start = par_rabi_cycle_duration, duration = 50,
amplitude = 2.0, start_reference = last_start,
link_start_to = 'start')
last_start = 'start'+str(i)
seq.add_pulse('start'+str(i)+'delay', chan_hhsync, 'optical_rabi',
start = 0, duration = 50, amplitude = 0,
start_reference = last_start, link_start_to = 'end')
last = 'start'+str(i)+'delay'
seq.add_pulse('AOM'+str(i), chan_eom_aom, 'optical_rabi',
start = par_aom_start, duration = par_aom_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_off'+str(i), chan_eom, 'optical_rabi',
amplitude = par_eom_off_amplitude,
start = par_eom_start, duration = par_eom_off_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_pulse'+str(i), chan_eom, 'optical_rabi',
amplitude = par_eom_pulse_amplitude - par_eom_off_amplitude,
start = par_eom_start + par_eom_off_duration/2 + \
par_eom_pulse_offset, duration = par_eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1'+str(i), chan_eom, 'optical_rabi',
amplitude = par_eom_overshoot1,
start = par_eom_start + par_eom_off_duration/2 + \
par_eom_pulse_offset + par_eom_pulse_duration,
duration = par_eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2'+str(i), chan_eom, 'optical_rabi',
amplitude = par_eom_overshoot2,
start = par_eom_start + par_eom_off_duration/2 + \
par_eom_pulse_offset + par_eom_pulse_duration + \
par_eom_overshoot_duration1,
duration = par_eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_off_comp'+str(i), chan_eom, 'optical_rabi',
amplitude = -par_eom_off_amplitude,
start = par_eom_start+par_eom_off_duration,
duration = par_eom_off_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_pulse_comp'+str(i), chan_eom, 'optical_rabi',
amplitude = -par_eom_pulse_amplitude + par_eom_off_amplitude,
start = par_eom_start+par_eom_off_duration + \
int(par_eom_off_duration/2) + par_eom_pulse_offset,
duration = par_eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1_comp'+str(i), chan_eom, 'optical_rabi',
amplitude = -par_eom_overshoot1,
start = par_eom_start+par_eom_off_duration + \
int(par_eom_off_duration/2) + par_eom_pulse_offset + \
par_eom_pulse_duration,
duration = par_eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2_comp'+str(i), chan_eom, 'optical_rabi',
amplitude = -par_eom_overshoot2,
start = par_eom_start+par_eom_off_duration + \
int(par_eom_off_duration/2) + par_eom_pulse_offset + \
par_eom_pulse_duration + par_eom_overshoot_duration1,
duration = par_eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
first_sync = 'start0'
last_sync = 'start'+str(par_rabi_reps-1)
if not debug_mode:
last = first_sync
for i in arange(par_pre_rabi_syncs):
seq.add_pulse('pre_start'+str(i), chan_hhsync, 'optical_rabi',
start = -par_rabi_cycle_duration, duration = 50,
start_reference = last, link_start_to = 'start')
last = 'pre_start'+str(i)
last = last_sync
for i in arange(par_post_rabi_syncs):
seq.add_pulse('post_start'+str(i), chan_hhsync, 'optical_rabi',
start = par_rabi_cycle_duration, duration = 50,
start_reference = last, link_start_to = 'start')
last = 'post_start'+str(i)
seq.add_element('idle', goto_target='idle',
event_jump_target = 'optical_rabi')
seq.add_pulse('empty', chan_alasers, 'idle', start=0, duration = 1000,
amplitude = 0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
def DSC_pulses_amp(sweep_param,pulse_dict,lt1 = False,do_program=True,do_program=True):
'''
This sequence consists of a fixed number of CORPSE pulses
and sweeps their amplitude
sweep_param = numpy array with amplitude of CORPSE-pulses
pulse_dict={
"Pi":{"duration": ...},
"istate_pulse": {"duration":... , "amplitude":..., First pulse to create init state
"Do_Pulse": Boolean},
"time_between_pulses": ..., waiting time between the CORPSE-pulses
"time_between_CORPSE":..., waiting time between each individual pulse inside the CORPSE pulse sequence
"duty_cycle_time": ..., waiting time at the end of each element
"nr_of_pulses": ...,
}
'''
seq = Sequence('spin_control')
awgcfg.configure_sequence(seq,'mw')
# vars for the channel names
chan_mw_pm = 'MW_pulsemod' #is connected to ch1m1
if lt1:
chan_mwI = 'MW_Imod_lt1'
chan_mwQ = 'MW_Qmod_lt1'
else:
chan_mwI = 'MW_Imod'
chan_mwQ = 'MW_Qmod'
if lt1:
MW_pulse_mod_risetime = 10
else:
MW_pulse_mod_risetime = 10
nr_of_datapoints = len(sweep_param)
amplitude = sweep_param
pi = pulse_dict["Pi"]
istate_pulse = pulse_dict["init_state_pulse"]
time_between_pulses = pulse_dict["time_between_pulses"]
time_between_CORPSE = pulse_dict["time_between_CORPSE"]
duty_cycle_time = pulse_dict["duty_cycle_time"]
nr_of_pulses = pulse_dict["nr_of_pulses"]
pulse_420_length = int(2.*pi["duration"]*(420./360.))
pulse_300_length = int(2.*pi["duration"]*(300./360.))
pulse_60_length = int(2.*pi["duration"]*(60./360.))
for i in np.arange(nr_of_datapoints):
if i == nr_of_datapoints-1:
seq.add_element(name = 'spin_control_'+str(i+1),
trigger_wait = True, goto_target = 'spin_control_1')
else:
seq.add_element(name = 'spin_control_'+str(i+1),
trigger_wait = True)
for j in np.arange(nr_of_pulses):
if j == 0:
if init_state_pulse["Do_Pulse"]:
seq.add_pulse('first_wait', channel = chan_mw_pm,
element = 'spin_control_'+str(i+1),start = 0,
duration = 50, amplitude = 0)
seq.add_pulse('init_state_pulse' + str(j), channel = chan_mwI, element = 'spin_control_'+str(i+1),
start_reference = 'first_wait', link_start_to = 'end', start = 0,
duration = istate_pulse["duration"], amplitude = istate_pulse["amplitude"], shape = 'rectangular')
seq.add_pulse('init_state_pulse_mod' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'init_state_pulse' + str(j), link_start_to = 'start',
duration_reference = 'init_state_pulse'+str(j), link_duration_to = 'duration',
amplitude = 2.0)
seq.add_pulse('wait' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start_reference = 'init_state_pulse' + str(j), link_start_to='end',start = 0,
duration = time_between_pulses, amplitude = 0)
else:
seq.add_pulse('wait' + str(j), channel = chan_mw_pm,
element = 'spin_control_'+str(i+1), start = 0,
duration = 50, amplitude = 0)
else:
seq.add_pulse('wait' + str(j), channel = chan_mw_pm,
element = 'spin_control_'+str(i+1), start = 0,
duration = time_between_pulses, amplitude = 0)
seq.add_pulse('pulse_420' + str(j), channel = chan_mwI, element = 'spin_control_'+str(i+1),
start = 0, start_reference = 'wait'+str(j),link_start_to = 'end',
duration = pulse_420_length, amplitude = amplitude[i], shape = 'rectangular')
seq.add_pulse('pulse_mod_420' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'pulse_420' + str(j), link_start_to = 'start',
duration_reference = 'pulse_420'+str(j), link_duration_to = 'duration',
amplitude = 2.0)
seq.add_pulse('wait_1' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start = 0,start_reference = 'pulse_mod_420'+str(j),link_start_to ='end',
duration = time_between_CORPSE, amplitude = 0)
seq.add_pulse('pulse_300' + str(j), channel = chan_mwI, element = 'spin_control_'+str(i+1),
start = 0, start_reference = 'wait_1'+str(j), link_start_to = 'end',
duration = pulse_300_length, amplitude = -amplitude[i],shape = 'rectangular')
seq.add_pulse('pulse_mod_300' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'pulse_300' + str(j), link_start_to = 'start',
duration_reference = 'pulse_300'+str(j), link_duration_to = 'duration',
amplitude = 2.0)
seq.add_pulse('wait_2' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start = 0,start_reference = 'pulse_mod_300'+str(j),link_start_to ='end',
duration = time_between_CORPSE, amplitude = 0)
seq.add_pulse('pulse_60' + str(j), channel = chan_mwI, element = 'spin_control_'+str(i+1),
start = 0, start_reference = 'wait_2'+str(j), link_start_to = 'end',
duration = pulse_60_length, amplitude = amplitude[i],shape = 'rectangular')
seq.add_pulse('pulse_mod_60' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'pulse_60' + str(j), link_start_to = 'start',
duration_reference = 'pulse_60'+str(j), link_duration_to = 'duration',
amplitude = 2.0)
last = 'Pulse_60'+str(j)
seq.add_pulse('final_wait', channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start_reference = last,link_start_to ='end', duration = duty_cycle_time, amplitude = 0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
def generate_sequence(fstart = f_start-f_mw, fstop = f_stop-f_mw, steps = nr_of_datapoints, do_program = True):
seq = Sequence('dark_esr')
print 'start frequency = ',(fstart+f_mw)/1E9
print 'stop frequency = ',(fstop+f_mw)/1E9
awgcfg.configure_sequence(seq,'mw')
# vars for the channel names
chan_mw_pm = 'MW_pulsemod' #is connected to ch1m1
if lt1:
chan_mwI = 'MW_Imod_lt1'
chan_mwQ = 'MW_Qmod_lt1'
else:
chan_mwI = 'MW_Imod'
chan_mwQ = 'MW_Qmod'
# in this version we keep the center frequency and sweep the
# modulation frequency
# f_central = (fstart+fstop)/2.0
pipulse = pi_pulse_length
mode = 'SSB'
amplitude_i = 0.
amplitude_q = 0.
if lt1:
MW_pulse_mod_risetime = 2
else:
MW_pulse_mod_risetime = 6
# sweep the modulation freq
for i, f_mod in enumerate(linspace(fstart, fstop, steps)):
###################################################################
# the actual rabi sequence and readout
ename = 'desrseq%d' % i
kw = {} if i < steps-1 else {'goto_target': 'desrseq0'}
seq.add_element(ename, trigger_wait = True, **kw)
seq.add_pulse('wait', channel = chan_mw_pm, element = ename,
start = 0, duration = 100, amplitude = 0)
seq.add_pulse(name = 'mwburst', channel = chan_mwI,
element = ename, start = 0, duration = pipulse,
frequency = f_mod, shape = 'sine',
amplitude = amplitude_ssbmod, link_start_to = 'end',
start_reference = 'wait')
seq.add_pulse('pulse_mod', channel = chan_mw_pm, element = ename,
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'mwburst', link_start_to = 'start',
duration_reference = 'mwburst', link_duration_to = 'duration',
amplitude = 2.0)
###################################################################
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
def Multiple_Pi_pulses(sweep_param,pulse_dict,lt1 = False,do_program=True):
'''
This sequence consists of a number of Pi-pulses per element
sweep_param = numpy array with number of Pi-pulses per element
pulse_dict={
"Pi":{"duration": ...,"amplitude": ...},
"istate_pulse": {"duration":... , "amplitude":...}, First pulse to create init state
"time_between_pulses": ...,
"duty_cycle_time": ..., waiting time at the end of each element
}
'''
seq = Sequence('spin_control')
awgcfg.configure_sequence(seq,'mw')
# vars for the channel names
chan_mw_pm = 'MW_pulsemod' #is connected to ch1m1
superposition_pulse=False
if lt1:
chan_mwI = 'MW_Imod_lt1'
chan_mwQ = 'MW_Qmod_lt1'
else:
chan_mwI = 'MW_Imod'
chan_mwQ = 'MW_Qmod'
#FIXME: take this from a dictionary
if lt1:
MW_pulse_mod_risetime = 10
else:
MW_pulse_mod_risetime = 10
nr_of_datapoints = len(sweep_param)
pulse_nr = sweep_param
pi = pulse_dict["Pi"]
time_between_pulses = pulse_dict["time_between_pulses"]
duty_cycle_time = pulse_dict["duty_cycle_time"]
istate_pulse = pulse_dict["init_state_pulse"]
for i in np.arange(nr_of_datapoints):
#create element for each datapoint and link last element to first
if i == nr_of_datapoints-1:
seq.add_element(name = 'spin_control_'+str(i+1),
trigger_wait = True, goto_target = 'spin_control_1')
else:
seq.add_element(name = 'spin_control_'+str(i+1),
trigger_wait = True)
for j in np.arange(pulse_nr[i]):
if j == 0:
if init_state_pulse["Do_Pulse"]:
seq.add_pulse('first_wait', channel = chan_mw_pm,
element = 'spin_control_'+str(i+1),start = 0,
duration = 50, amplitude = 0)
seq.add_pulse('init_state_pulse' + str(j), channel = chan_mwI, element = 'spin_control_'+str(i+1),
start_reference = 'first_wait', link_start_to = 'end', start = 0,
duration = istate_pulse["duration"], amplitude = istate_pulse["amplitude"], shape = 'rectangular')
seq.add_pulse('init_state_pulse_mod' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'init_state_pulse' + str(j), link_start_to = 'start',
duration_reference = 'init_state_pulse'+str(j), link_duration_to = 'duration',
amplitude = 2.0)
seq.add_pulse('wait' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start_reference = 'init_state_pulse' + str(j), link_start_to='end',start = 0,
duration = time_between_pulses, amplitude = 0)
else:
seq.add_pulse('wait' + str(j), channel = chan_mw_pm,
element = 'spin_control_'+str(i+1), start = 0,
duration = 50, amplitude = 0)
else:
seq.add_pulse('wait' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start = 0,start_reference = last,link_start_to ='end',
duration = time_between_pulses, amplitude = 0)
seq.add_pulse('pi' + str(j), channel = chan_mwI, element = 'spin_control_'+str(i+1),
start = 0, start_reference = 'wait'+str(j), link_start_to = 'end',
duration = pi["duration"], amplitude = pi["amplitude"], shape = 'rectangular')
seq.add_pulse('pulse_mod' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'pi' + str(j), link_start_to = 'start',
duration_reference = 'pi'+str(j), link_duration_to = 'duration',
amplitude = 2.0)
last = 'pi'+str(j)
seq.add_pulse('final_wait', channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start_reference = last,link_start_to ='end',
duration = duty_cycle_time, amplitude = 0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
def generate_sequence(do_program=True):
seq = Sequence("spin_control")
awgcfg.configure_sequence(seq, "mw")
# vars for the channel names
chan_mw_pm = "MW_pulsemod" # is connected to ch1m1
if lt1:
chan_mwI = "MW_Imod_lt1"
chan_mwQ = "MW_Qmod_lt1"
else:
chan_mwI = "MW_Imod" # ch1
chan_mwQ = "MW_Qmod" # ch3
if lt1:
MW_pulse_mod_risetime = 10
else:
MW_pulse_mod_risetime = 10
for i in np.arange(nr_of_datapoints):
if i == nr_of_datapoints - 1:
seq.add_element(name="spin_control_" + str(i + 1), trigger_wait=True, goto_target="spin_control_1")
else:
seq.add_element(name="spin_control_" + str(i + 1), trigger_wait=True)
seq.add_pulse(
"wait", channel=chan_mw_pm, element="spin_control_" + str(i + 1), start=0, duration=100, amplitude=0
)
if length[i] != 0:
seq.add_pulse(
"mwburst",
channel=chan_mwI,
element="spin_control_" + str(i + 1),
start=0,
duration=length[i],
amplitude=amplitude_ssbmod,
start_reference="wait",
link_start_to="end",
shape="rectangular",
)
seq.add_pulse(
"pulse_mod",
channel=chan_mw_pm,
element="spin_control_" + str(i + 1),
start=-MW_pulse_mod_risetime,
duration=2 * MW_pulse_mod_risetime,
start_reference="mwburst",
link_start_to="start",
duration_reference="mwburst",
link_duration_to="duration",
amplitude=2.0,
)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
from measurement.config import awgchannels_lt2 as awgcfg
from measurement.AWG_HW_sequencer_v2 import Sequence
seq = Sequence('argh')
os.chdir('D:/measuring/qtlab/')
reload(awgcfg)
os.chdir('D:/measuring/user/scripts/lt2_scripts/')
SMB100_lt1.set_frequency(2.8295E9)
SMB100.set_power(15)
SMB100_lt1.set_pulm('on')
SMB100_lt1.set_iq('on')
awgcfg.configure_sequence(seq,'mw','LDE','hydraharp')
#seq.add_channel('PH_start', 'ch4m2', cable_delay=0)
#seq.add_channel('Green', 'ch2m1', cable_delay=604, high=0.5)
#seq.add_channel('MW_pulsemod', 'ch2m2', high=2.0, cable_delay = 0)
#seq.add_channel('MW_Imod', 'ch1', high=0.9, low=-0.9)
#seq.add_channel('MW_Qmod', 'ch4', high=0.9, low=-0.9, cable_delay = 0)
#seq.add_channel('pm','ch1m1', high=2.0, cable_delay=27)
MW_pulse_mod_risetime = 10#6 = correct for LT2, 2 = correct for LT1
MW_Imod_duration = 1000
elt = 'test'
seq.add_element(elt, goto_target = elt)
#seq.add_pulse('PH', 'PH_start', elt, start=0, duration=50)
#seq.add_pulse('Green', 'Green', elt, start=0, amplitude = 1, duration=5000,start_reference = 'PH',link_start_to='end')
def generate_sequence(do_program=True):
seq = Sequence('tpqi_remote')
# vars for the channel names
chan_hhsync = 'HH_sync' # historically PH_start
chan_hh_ma1 = 'HH_MA1' # historically PH_sync
chan_alasers = 'AOM_Newfocus' # ok
chan_eom = 'EOM_Matisse'
chan_eom_aom = 'EOM_AOM_Matisse'
awgcfg.configure_sequence(seq,
'hydraharp',
LDE={
chan_eom_aom: {
'high': par_eom_aom_amplitude
},
chan_alasers: {
'high': par_sp_voltage
}
})
seq.add_element(
'optical_rabi',
goto_target='idle') #'optical_rabi',event_jump_target='idle')
seq.add_pulse('spinpumping',
chan_alasers,
'optical_rabi',
start=0,
duration=par_sp_duration)
#Define a start point for the sequence, set amplitude to 0. actual sync pulse comes later
if debug_mode:
seq.add_pulse('hh_debug_sync',
chan_hhsync,
'optical_rabi',
start=0,
duration=50,
amplitude=0.0)
seq.add_pulse('start',
chan_hhsync,
'optical_rabi',
start=0,
start_reference='spinpumping',
link_start_to='end',
duration=50,
amplitude=0.0)
last_start = 'start'
seq.add_pulse('start_marker',
chan_hh_ma1,
'optical_rabi',
start=par_rabi_cycle_duration / 2,
start_reference='start',
link_start_to='end',
duration=50)
for i in arange(par_rabi_reps):
seq.add_pulse('start' + str(i),
chan_hhsync,
'optical_rabi',
start=par_rabi_cycle_duration,
duration=50,
amplitude=2.0,
start_reference=last_start,
link_start_to='start')
last_start = 'start' + str(i)
seq.add_pulse('start' + str(i) + 'delay',
chan_hhsync,
'optical_rabi',
start=0,
duration=50,
amplitude=0,
start_reference=last_start,
link_start_to='end')
last = 'start' + str(i) + 'delay'
seq.add_pulse('AOM' + str(i),
chan_eom_aom,
'optical_rabi',
start=par_aom_start,
duration=par_aom_duration,
start_reference=last,
link_start_to='start')
seq.add_pulse('EOM_off' + str(i),
chan_eom,
'optical_rabi',
amplitude=par_eom_off_amplitude,
start=par_eom_start,
duration=par_eom_off_duration,
start_reference=last,
link_start_to='start')
seq.add_pulse('EOM_pulse'+str(i), chan_eom, 'optical_rabi',
amplitude = par_eom_pulse_amplitude - par_eom_off_amplitude,
start = par_eom_start + par_eom_off_duration/2 + \
par_eom_pulse_offset, duration = par_eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1'+str(i), chan_eom, 'optical_rabi',
amplitude = par_eom_overshoot1,
start = par_eom_start + par_eom_off_duration/2 + \
par_eom_pulse_offset + par_eom_pulse_duration,
duration = par_eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2'+str(i), chan_eom, 'optical_rabi',
amplitude = par_eom_overshoot2,
start = par_eom_start + par_eom_off_duration/2 + \
par_eom_pulse_offset + par_eom_pulse_duration + \
par_eom_overshoot_duration1,
duration = par_eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_off_comp' + str(i),
chan_eom,
'optical_rabi',
amplitude=-par_eom_off_amplitude,
start=par_eom_start + par_eom_off_duration,
duration=par_eom_off_duration,
start_reference=last,
link_start_to='start')
seq.add_pulse('EOM_pulse_comp'+str(i), chan_eom, 'optical_rabi',
amplitude = -par_eom_pulse_amplitude + par_eom_off_amplitude,
start = par_eom_start+par_eom_off_duration + \
int(par_eom_off_duration/2) + par_eom_pulse_offset,
duration = par_eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1_comp'+str(i), chan_eom, 'optical_rabi',
amplitude = -par_eom_overshoot1,
start = par_eom_start+par_eom_off_duration + \
int(par_eom_off_duration/2) + par_eom_pulse_offset + \
par_eom_pulse_duration,
duration = par_eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2_comp'+str(i), chan_eom, 'optical_rabi',
amplitude = -par_eom_overshoot2,
start = par_eom_start+par_eom_off_duration + \
int(par_eom_off_duration/2) + par_eom_pulse_offset + \
par_eom_pulse_duration + par_eom_overshoot_duration1,
duration = par_eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
first_sync = 'start0'
last_sync = 'start' + str(par_rabi_reps - 1)
if not debug_mode:
last = first_sync
for i in arange(par_pre_rabi_syncs):
seq.add_pulse('pre_start' + str(i),
chan_hhsync,
'optical_rabi',
start=-par_rabi_cycle_duration,
duration=50,
start_reference=last,
link_start_to='start')
last = 'pre_start' + str(i)
last = last_sync
for i in arange(par_post_rabi_syncs):
seq.add_pulse('post_start' + str(i),
chan_hhsync,
'optical_rabi',
start=par_rabi_cycle_duration,
duration=50,
start_reference=last,
link_start_to='start')
last = 'post_start' + str(i)
seq.add_element('idle',
goto_target='idle',
event_jump_target='optical_rabi')
seq.add_pulse('empty',
chan_alasers,
'idle',
start=0,
duration=1000,
amplitude=0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
def generate_sequence(self, do_program=True):
self.seq = Sequence('lde')
seq = self.seq
# channels
chan_hhsync = 'HH_sync' # historically PH_start
chan_hh_ma1 = 'HH_MA1' # historically PH_sync
chan_plusync = 'PLU_gate'
chan_alaser = 'AOM_Newfocus'
chan_eom = 'EOM_Matisse'
chan_eom_aom = 'EOM_AOM_Matisse'
chan_mw_pm = 'MW_pulsemod'
chan_mwI_lt2 = 'MW_Imod'
chan_mwQ_lt2 = 'MW_Qmod'
chan_mwI_lt1 = 'MW_Imod_lt1'
chan_mwQ_lt1 = 'MW_Qmod_lt1'
# TODO study the current AWG configuration, then adapt this
awgcfg.configure_sequence(self.seq, 'hydraharp', 'mw',
LDE = {
chan_eom_aom: { 'high' : self.eom_aom_amplitude },
chan_alaser: { 'high' : self.A_SP_amplitude, }
},
)
seq.add_element('lde', goto_target='lde', trigger_wait=False)
# 1: spin pumping
seq.add_pulse('initialdelay', chan_alaser, 'lde',
start = 0, duration = 10, amplitude=0, )
seq.add_pulse('spinpumping', chan_alaser, 'lde',
start = 0, duration = self.SP_duration,
start_reference='initialdelay',
link_start_to='end', amplitude=1)
# 2: Pi/2 pulses on both spins
seq.add_pulse('pi/2-1 lt2', chan_mwI_lt2, 'lde',
duration = self.pi2_lt2_duration,
amplitude = self.pi2_lt2_amplitude,
start_reference = 'spinpumping',
start = self.wait_after_SP,
link_start_to = 'end' )
seq.add_pulse('pi/2-1 lt1', chan_mwI_lt1, 'lde',
duration = self.pi2_lt1_duration,
amplitude = self.pi2_lt1_amplitude,
start_reference = 'pi/2-1 lt2',
start = (self.pi2_lt2_duration-self.pi2_lt1_duration)/2,
link_start_to = 'start' )
seq.add_pulse('pi/2-1 pm', chan_mw_pm, 'lde',
amplitude = self.MW_pulsemod_amplitude,
duration = max(self.pi2_lt2_duration+\
2*self.MW_pulsemod_risetime_lt2,
self.pi2_lt1_duration+\
2*self.MW_pulsemod_risetime_lt1),
start = min(-self.MW_pulsemod_risetime_lt2,
(self.pi2_lt2_duration-self.pi2_lt1_duration)/2 - \
self.MW_pulsemod_risetime_lt1),
start_reference = 'pi/2-1 lt2',
link_start_to = 'start' )
# 3a: optical pi-pulse no 1
i = 1
last = 'pi/2-1 pm'
seq.add_pulse('start'+str(i), chan_hhsync, 'lde',
start = self.wait_after_pi2, duration = 50,
amplitude = 2.0, start_reference = last,
link_start_to = 'end')
last = 'start'+str(i)
seq.add_pulse('mrkr'+str(i), chan_hh_ma1, 'lde',
start=-20, duration=50,
amplitude=0.0, start_reference=last,
link_start_to='start')
seq.add_pulse('start'+str(i)+'delay', chan_hhsync, 'lde',
start = 0, duration = 50, amplitude = 0,
start_reference = last, link_start_to = 'end')
last = 'start'+str(i)+'delay'
seq.add_pulse('AOM'+str(i), chan_eom_aom, 'lde',
start = m.aom_start, duration = m.aom_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_off'+str(i), chan_eom, 'lde',
amplitude = m.eom_off_amplitude,
start = m.eom_start, duration = m.eom_off_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_pulse'+str(i), chan_eom, 'lde',
amplitude = m.eom_pulse_amplitude - m.eom_off_amplitude,
start = m.eom_start + m.eom_off_duration/2 + \
m.eom_pulse_offset, duration = m.eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1'+str(i), chan_eom, 'lde',
amplitude = m.eom_overshoot1,
start = m.eom_start + m.eom_off_duration/2 + \
m.eom_pulse_offset + m.eom_pulse_duration,
duration = m.eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2'+str(i), chan_eom, 'lde',
amplitude = m.eom_overshoot2,
start = m.eom_start + m.eom_off_duration/2 + \
m.eom_pulse_offset + m.eom_pulse_duration + \
m.eom_overshoot_duration1,
duration = m.eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_off_comp'+str(i), chan_eom, 'lde',
amplitude = -m.eom_off_amplitude,
start = m.eom_start+m.eom_off_duration,
duration = m.eom_off_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_pulse_comp'+str(i), chan_eom, 'lde',
amplitude = -m.eom_pulse_amplitude + m.eom_off_amplitude,
start = m.eom_start+m.eom_off_duration + \
int(m.eom_off_duration/2) + m.eom_pulse_offset,
duration = m.eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1_comp'+str(i), chan_eom, 'lde',
amplitude = -m.eom_overshoot1,
start = m.eom_start+m.eom_off_duration + \
int(m.eom_off_duration/2) + m.eom_pulse_offset + \
m.eom_pulse_duration,
duration = m.eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2_comp'+str(i), chan_eom, 'lde',
amplitude = -m.eom_overshoot2,
start = m.eom_start+m.eom_off_duration + \
int(m.eom_off_duration/2) + m.eom_pulse_offset + \
m.eom_pulse_duration + m.eom_overshoot_duration1,
duration = m.eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
last = 'EOM_overshoot2_comp'+str(i)
last = 'EOM_pulse'+str(i)
# 3b: add pre-sync pulses for the HH
for j in range(self.presync_pulses):
seq.add_pulse('presync'+str(j), chan_hhsync, 'lde',
start = -(j+1)*self.opt_pi_separation, duration = 50,
amplitude = 2.0, start_reference = 'start'+str(i),
link_start_to = 'start')
# 3c: add PLU gate
seq.add_pulse('plu-gate'+str(i), chan_plusync, 'lde',
start = 0,
duration = self.plu_gate_duration,
amplitude = 0.0,
start_reference = 'EOM_pulse'+str(i),
link_start_to = 'end' )
# 4: spin pi pulses
seq.add_pulse('pi lt2', chan_mwI_lt2, 'lde',
duration = self.pi_lt2_duration,
amplitude = self.pi_lt2_amplitude,
start_reference = last,
start = self.wait_after_opt_pi,
link_start_to = 'start' )
seq.add_pulse('pi lt1', chan_mwI_lt1, 'lde',
duration = self.pi_lt1_duration,
amplitude = self.pi_lt1_amplitude,
start_reference = 'pi lt2',
start = (self.pi_lt2_duration-self.pi_lt1_duration)/2,
link_start_to = 'start' )
seq.add_pulse('pi pm', chan_mw_pm, 'lde',
amplitude = self.MW_pulsemod_amplitude,
duration = max(self.pi_lt2_duration+\
2*self.MW_pulsemod_risetime_lt2,
self.pi_lt1_duration+\
2*self.MW_pulsemod_risetime_lt1),
start = min(-self.MW_pulsemod_risetime_lt2,
(self.pi_lt2_duration-self.pi_lt1_duration)/2 - \
self.MW_pulsemod_risetime_lt1),
start_reference = 'pi lt2',
link_start_to = 'start')
# 5a: optical pi-pulse no2
i = 2
seq.add_pulse('start'+str(i), chan_hhsync, 'lde',
start = self.opt_pi_separation, duration = 50,
amplitude = 2.0, start_reference = 'start'+str(i-1),
link_start_to = 'start')
last = 'start'+str(i)
seq.add_pulse('start'+str(i)+'delay', chan_hhsync, 'lde',
start = 0, duration = 50, amplitude = 0,
start_reference = last, link_start_to = 'end')
last = 'start'+str(i)+'delay'
seq.add_pulse('AOM'+str(i), chan_eom_aom, 'lde',
start = m.aom_start, duration = m.aom_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_off'+str(i), chan_eom, 'lde',
amplitude = m.eom_off_amplitude,
start = m.eom_start, duration = m.eom_off_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_pulse'+str(i), chan_eom, 'lde',
amplitude = m.eom_pulse_amplitude - m.eom_off_amplitude,
start = m.eom_start + m.eom_off_duration/2 + \
m.eom_pulse_offset, duration = m.eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1'+str(i), chan_eom, 'lde',
amplitude = m.eom_overshoot1,
start = m.eom_start + m.eom_off_duration/2 + \
m.eom_pulse_offset + m.eom_pulse_duration,
duration = m.eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2'+str(i), chan_eom, 'lde',
amplitude = m.eom_overshoot2,
start = m.eom_start + m.eom_off_duration/2 + \
m.eom_pulse_offset + m.eom_pulse_duration + \
m.eom_overshoot_duration1,
duration = m.eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_off_comp'+str(i), chan_eom, 'lde',
amplitude = -m.eom_off_amplitude,
start = m.eom_start+m.eom_off_duration,
duration = m.eom_off_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_pulse_comp'+str(i), chan_eom, 'lde',
amplitude = -m.eom_pulse_amplitude + m.eom_off_amplitude,
start = m.eom_start+m.eom_off_duration + \
int(m.eom_off_duration/2) + m.eom_pulse_offset,
duration = m.eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1_comp'+str(i), chan_eom, 'lde',
amplitude = -m.eom_overshoot1,
start = m.eom_start+m.eom_off_duration + \
int(m.eom_off_duration/2) + m.eom_pulse_offset + \
m.eom_pulse_duration,
duration = m.eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2_comp'+str(i), chan_eom, 'lde',
amplitude = -m.eom_overshoot2,
start = m.eom_start+m.eom_off_duration + \
int(m.eom_off_duration/2) + m.eom_pulse_offset + \
m.eom_pulse_duration + m.eom_overshoot_duration1,
duration = m.eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
last = 'EOM_overshoot2_comp'+str(i)
# 5b: add post-sync pulses for the HH
for j in range(self.postsync_pulses):
seq.add_pulse('postsync'+str(j), chan_hhsync, 'lde',
start = (j+1)*self.opt_pi_separation, duration = 50,
amplitude = 2.0, start_reference = 'start'+str(i),
link_start_to = 'start')
# 5c: add PLU gate
seq.add_pulse('plu-gate'+str(i), chan_plusync, 'lde',
start = 0,
duration = self.plu_gate_duration,
amplitude = 0.0,
start_reference = 'EOM_pulse'+str(i),
link_start_to = 'end' )
# 5d: two additional PLU gates
seq.add_pulse('plu-gate3', chan_plusync, 'lde',
start = self.plu_3_delay,
duration = self.plu_gate_duration,
amplitude = 0.0,
start_reference = 'plu-gate2',
link_start_to = 'end')
seq.add_pulse('plu-gate4', chan_plusync, 'lde',
start = self.plu_4_delay,
duration = self.plu_gate_duration,
amplitude = 0.0,
start_reference = 'plu-gate2',
link_start_to = 'end')
# idle element
seq.add_element('idle', goto_target='lde')
seq.add_pulse('empty', chan_alaser, 'idle', start=0, duration = 1000,
amplitude = 0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(True)
seq.force_HW_sequencing(True)
seq.send_sequence()
return seq
def generate_DSC_sequence_time(do_program=True):
seq = Sequence('spin_control')
awgcfg.configure_sequence(seq,'mw')
# vars for the channel names
chan_mw_pm = 'MW_pulsemod' #is connected to ch1m1
if lt1:
chan_mwI = 'MW_Imod_lt1'
chan_mwQ = 'MW_Qmod_lt1'
else:
chan_mwI = 'MW_Imod'
chan_mwQ = 'MW_Qmod'
if lt1:
MW_pulse_mod_risetime = 10
else:
MW_pulse_mod_risetime = 10
for i in np.arange(nr_of_datapoints):
if i == nr_of_datapoints-1:
seq.add_element(name = 'spin_control_'+str(i+1),
trigger_wait = True, goto_target = 'spin_control_1')
else:
seq.add_element(name = 'spin_control_'+str(i+1),
trigger_wait = True)
for j in np.arange(nr_of_pulses):
if j == 0:
seq.add_pulse('wait' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1), start = 0, duration = 50, amplitude = 0)
else:
seq.add_pulse('wait' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start = 0,start_reference = last,link_start_to ='end', duration = time_between_pulses, amplitude = 0)
seq.add_pulse('pulse_420' + str(j), channel = chan_mwI, element = 'spin_control_'+str(i+1),
start = 0, duration = pulse_420_length, amplitude = amplitude_ssbmod, start_reference = 'wait'+str(j),
link_start_to = 'end', shape = 'rectangular')
seq.add_pulse('pulse_mod_420' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'pulse_420' + str(j), link_start_to = 'start',
duration_reference = 'pulse_420'+str(j), link_duration_to = 'duration',
amplitude = 2.0)
seq.add_pulse('wait_1' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start = 0,start_reference = 'pulse_mod_420'+str(j),link_start_to ='end', duration = time[i], amplitude = 0)
seq.add_pulse('pulse_300' + str(j), channel = chan_mwI, element = 'spin_control_'+str(i+1),
start = 0, duration = pulse_300_length, amplitude = -amplitude_ssbmod, start_reference = 'wait_1'+str(j),
link_start_to = 'end', shape = 'rectangular')
seq.add_pulse('pulse_mod_300' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'pulse_300' + str(j), link_start_to = 'start',
duration_reference = 'pulse_300'+str(j), link_duration_to = 'duration',
amplitude = 2.0)
seq.add_pulse('wait_2' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start = 0,start_reference = 'pulse_mod_300'+str(j),link_start_to ='end', duration = time[i], amplitude = 0)
seq.add_pulse('pulse_60' + str(j), channel = chan_mwI, element = 'spin_control_'+str(i+1),
start = 0, duration = pulse_60_length, amplitude = amplitude_ssbmod, start_reference = 'wait_2'+str(j),
link_start_to = 'end', shape = 'rectangular')
seq.add_pulse('pulse_mod_60' + str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
start_reference = 'pulse_60' + str(j), link_start_to = 'start',
duration_reference = 'pulse_60'+str(j), link_duration_to = 'duration',
amplitude = 2.0)
seq.add_pulse('wait_3'+str(j), channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start_reference = 'pulse_mod_60'+str(j),link_start_to ='end', duration = time_between_pulses, amplitude = 0)
last = 'wait_3'+str(j)
seq.add_pulse('final_wait', channel = chan_mw_pm, element = 'spin_control_'+str(i+1),
start_reference = last,link_start_to ='end', duration = duty_cycle_time, amplitude = 0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
def generate_DSC_sequence_time(do_program=True):
seq = Sequence('spin_control')
awgcfg.configure_sequence(seq, 'mw')
# vars for the channel names
chan_mw_pm = 'MW_pulsemod' #is connected to ch1m1
if lt1:
chan_mwI = 'MW_Imod_lt1'
chan_mwQ = 'MW_Qmod_lt1'
else:
chan_mwI = 'MW_Imod'
chan_mwQ = 'MW_Qmod'
if lt1:
MW_pulse_mod_risetime = 10
else:
MW_pulse_mod_risetime = 10
for i in np.arange(nr_of_datapoints):
if i == nr_of_datapoints - 1:
seq.add_element(name='spin_control_' + str(i + 1),
trigger_wait=True,
goto_target='spin_control_1')
else:
seq.add_element(name='spin_control_' + str(i + 1),
trigger_wait=True)
for j in np.arange(nr_of_pulses):
if j == 0:
seq.add_pulse('wait' + str(j),
channel=chan_mw_pm,
element='spin_control_' + str(i + 1),
start=0,
duration=50,
amplitude=0)
else:
seq.add_pulse('wait' + str(j),
channel=chan_mw_pm,
element='spin_control_' + str(i + 1),
start=0,
start_reference=last,
link_start_to='end',
duration=time_between_pulses,
amplitude=0)
seq.add_pulse('pulse_420' + str(j),
channel=chan_mwI,
element='spin_control_' + str(i + 1),
start=0,
duration=pulse_420_length,
amplitude=amplitude_ssbmod,
start_reference='wait' + str(j),
link_start_to='end',
shape='rectangular')
seq.add_pulse('pulse_mod_420' + str(j),
channel=chan_mw_pm,
element='spin_control_' + str(i + 1),
start=-MW_pulse_mod_risetime,
duration=2 * MW_pulse_mod_risetime,
start_reference='pulse_420' + str(j),
link_start_to='start',
duration_reference='pulse_420' + str(j),
link_duration_to='duration',
amplitude=2.0)
seq.add_pulse('wait_1' + str(j),
channel=chan_mw_pm,
element='spin_control_' + str(i + 1),
start=0,
start_reference='pulse_mod_420' + str(j),
link_start_to='end',
duration=time[i],
amplitude=0)
seq.add_pulse('pulse_300' + str(j),
channel=chan_mwI,
element='spin_control_' + str(i + 1),
start=0,
duration=pulse_300_length,
amplitude=-amplitude_ssbmod,
start_reference='wait_1' + str(j),
link_start_to='end',
shape='rectangular')
seq.add_pulse('pulse_mod_300' + str(j),
channel=chan_mw_pm,
element='spin_control_' + str(i + 1),
start=-MW_pulse_mod_risetime,
duration=2 * MW_pulse_mod_risetime,
start_reference='pulse_300' + str(j),
link_start_to='start',
duration_reference='pulse_300' + str(j),
link_duration_to='duration',
amplitude=2.0)
seq.add_pulse('wait_2' + str(j),
channel=chan_mw_pm,
element='spin_control_' + str(i + 1),
start=0,
start_reference='pulse_mod_300' + str(j),
link_start_to='end',
duration=time[i],
amplitude=0)
seq.add_pulse('pulse_60' + str(j),
channel=chan_mwI,
element='spin_control_' + str(i + 1),
start=0,
duration=pulse_60_length,
amplitude=amplitude_ssbmod,
start_reference='wait_2' + str(j),
link_start_to='end',
shape='rectangular')
seq.add_pulse('pulse_mod_60' + str(j),
channel=chan_mw_pm,
element='spin_control_' + str(i + 1),
start=-MW_pulse_mod_risetime,
duration=2 * MW_pulse_mod_risetime,
start_reference='pulse_60' + str(j),
link_start_to='start',
duration_reference='pulse_60' + str(j),
link_duration_to='duration',
amplitude=2.0)
seq.add_pulse('wait_3' + str(j),
channel=chan_mw_pm,
element='spin_control_' + str(i + 1),
start_reference='pulse_mod_60' + str(j),
link_start_to='end',
duration=time_between_pulses,
amplitude=0)
last = 'wait_3' + str(j)
seq.add_pulse('final_wait',
channel=chan_mw_pm,
element='spin_control_' + str(i + 1),
start_reference=last,
link_start_to='end',
duration=duty_cycle_time,
amplitude=0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
from measurement.config import awgchannels_lt2 as awgcfg
from measurement.AWG_HW_sequencer_v2 import Sequence
seq = Sequence('argh')
os.chdir('D:/measuring/qtlab/')
reload(awgcfg)
os.chdir('D:/measuring/user/scripts/lt2_scripts/')
awgcfg.configure_sequence(seq, 'mw')
#seq.add_channel('PH_start', 'ch4m2', cable_delay=0)
#seq.add_channel('Green', 'ch2m1', cable_delay=604, high=0.5)
#seq.add_channel('MW_pulsemod', 'ch2m2', high=2.0, cable_delay = 0)
#seq.add_channel('MW_Imod', 'ch1', high=0.9, low=-0.9)
#seq.add_channel('MW_Qmod', 'ch4', high=0.9, low=-0.9, cable_delay = 0)
seq.add_channel('trigger', 'ch4m2', high=1.0)
#seq.add_channel('pm','ch1m1', high=2.0, cable_delay=27)
chan_mw_pm = 'MW_pulsemod'
chan_mwI = 'MW_Imod_lt1'
chan_mwQ = 'MW_Qmod_lt1'
MW_pulse_mod_risetime = 10 #6 = correct for LT2, 2 = correct for LT1
MW_Imod_duration = 8
elt = 'test'
seq.add_element(elt, goto_target=elt)
#seq.add_pulse('PH', 'PH_start', elt, start=0, duration=50)
#seq.add_pulse('Green', 'Green', elt, start=0, amplitude = 1, duration=5000,start_reference = 'PH',link_start_to='end')
def generate_sequence(do_program=True):
seq = Sequence("tpqi_remote")
# vars for the channel names
chan_hhsync = "HH_sync" # historically PH_start
chan_hh_ma1 = "HH_MA1" # historically PH_sync
chan_alasers = "AOM_Newfocus" # ok
chan_eom = "EOM_Matisse"
chan_eom_aom = "EOM_AOM_Matisse"
awgcfg.configure_sequence(
seq, "hydraharp", LDE={chan_eom_aom: {"high": par_eom_aom_amplitude}, chan_alasers: {"high": par_sp_voltage}}
)
seq.add_element(
"optical_rabi", goto_target="idle", repetitions=par_elt_reps
) #'optical_rabi',event_jump_target='idle')
seq.add_pulse("spinpumping", chan_alasers, "optical_rabi", start=0, duration=par_sp_duration)
# Define a start point for the sequence, set amplitude to 0. actual sync pulse comes later
if debug_mode:
seq.add_pulse(
"hh_debug_sync",
chan_hhsync,
"optical_rabi",
start=0,
start_reference="spinpumping",
link_start_to="start",
duration=50,
amplitude=0.0,
)
seq.add_pulse(
"start",
chan_hhsync,
"optical_rabi",
start=0,
start_reference="spinpumping",
link_start_to="end",
duration=50,
amplitude=0.0,
)
last_start = "start"
seq.add_pulse(
"start_marker",
chan_hh_ma1,
"optical_rabi",
start=par_rabi_cycle_duration / 2,
start_reference="start",
link_start_to="end",
duration=50,
)
for i in arange(par_rabi_reps):
seq.add_pulse(
"start" + str(i),
chan_hhsync,
"optical_rabi",
start=par_rabi_cycle_duration,
duration=50,
amplitude=2.0,
start_reference=last_start,
link_start_to="start",
)
last_start = "start" + str(i)
seq.add_pulse(
"start" + str(i) + "delay",
chan_hhsync,
"optical_rabi",
start=0,
duration=50,
amplitude=0,
start_reference=last_start,
link_start_to="end",
)
last = "start" + str(i) + "delay"
seq.add_pulse(
"AOM" + str(i),
chan_eom_aom,
"optical_rabi",
start=par_aom_start,
duration=par_aom_duration,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_off" + str(i),
chan_eom,
"optical_rabi",
amplitude=par_eom_off_amplitude,
start=par_eom_start,
duration=par_eom_off_duration,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_pulse" + str(i),
chan_eom,
"optical_rabi",
amplitude=par_eom_pulse_amplitude - par_eom_off_amplitude,
start=par_eom_start + par_eom_off_duration / 2 + par_eom_pulse_offset,
duration=par_eom_pulse_duration,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_overshoot1" + str(i),
chan_eom,
"optical_rabi",
amplitude=par_eom_overshoot1,
start=par_eom_start + par_eom_off_duration / 2 + par_eom_pulse_offset + par_eom_pulse_duration,
duration=par_eom_overshoot_duration1,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_overshoot2" + str(i),
chan_eom,
"optical_rabi",
amplitude=par_eom_overshoot2,
start=par_eom_start
+ par_eom_off_duration / 2
+ par_eom_pulse_offset
+ par_eom_pulse_duration
+ par_eom_overshoot_duration1,
duration=par_eom_overshoot_duration2,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_off_comp" + str(i),
chan_eom,
"optical_rabi",
amplitude=-par_eom_off_amplitude,
start=par_eom_start + par_eom_off_duration,
duration=par_eom_off_duration,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_pulse_comp" + str(i),
chan_eom,
"optical_rabi",
amplitude=-par_eom_pulse_amplitude + par_eom_off_amplitude,
start=par_eom_start + par_eom_off_duration + int(par_eom_off_duration / 2) + par_eom_pulse_offset,
duration=par_eom_pulse_duration,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_overshoot1_comp" + str(i),
chan_eom,
"optical_rabi",
amplitude=-par_eom_overshoot1,
start=par_eom_start
+ par_eom_off_duration
+ int(par_eom_off_duration / 2)
+ par_eom_pulse_offset
+ par_eom_pulse_duration,
duration=par_eom_overshoot_duration1,
start_reference=last,
link_start_to="start",
)
seq.add_pulse(
"EOM_overshoot2_comp" + str(i),
chan_eom,
"optical_rabi",
amplitude=-par_eom_overshoot2,
start=par_eom_start
+ par_eom_off_duration
+ int(par_eom_off_duration / 2)
+ par_eom_pulse_offset
+ par_eom_pulse_duration
+ par_eom_overshoot_duration1,
duration=par_eom_overshoot_duration2,
start_reference=last,
link_start_to="start",
)
first_sync = "start0"
last_sync = "start" + str(par_rabi_reps - 1)
if not debug_mode:
last = first_sync
for i in arange(par_pre_rabi_syncs):
seq.add_pulse(
"pre_start" + str(i),
chan_hhsync,
"optical_rabi",
start=-par_rabi_cycle_duration,
duration=50,
start_reference=last,
link_start_to="start",
)
last = "pre_start" + str(i)
last = last_sync
for i in arange(par_post_rabi_syncs):
seq.add_pulse(
"post_start" + str(i),
chan_hhsync,
"optical_rabi",
start=par_rabi_cycle_duration,
duration=50,
start_reference=last,
link_start_to="start",
)
last = "post_start" + str(i)
seq.add_element("idle", goto_target="idle", event_jump_target="optical_rabi")
seq.add_pulse("empty", chan_alasers, "idle", start=0, duration=1000, amplitude=0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
return seq
from measurement.config import awgchannels_lt2 as awgcfg
from measurement.AWG_HW_sequencer_v2 import Sequence
seq = Sequence('argh')
os.chdir('D:/measuring/qtlab/')
reload(awgcfg)
os.chdir('D:/measuring/user/scripts/lt2_scripts/')
SMB100_lt1.set_frequency(2.8295E9)
SMB100.set_power(15)
SMB100_lt1.set_pulm('on')
SMB100_lt1.set_iq('on')
awgcfg.configure_sequence(seq, 'mw', 'LDE', 'hydraharp')
#seq.add_channel('PH_start', 'ch4m2', cable_delay=0)
#seq.add_channel('Green', 'ch2m1', cable_delay=604, high=0.5)
#seq.add_channel('MW_pulsemod', 'ch2m2', high=2.0, cable_delay = 0)
#seq.add_channel('MW_Imod', 'ch1', high=0.9, low=-0.9)
#seq.add_channel('MW_Qmod', 'ch4', high=0.9, low=-0.9, cable_delay = 0)
#seq.add_channel('pm','ch1m1', high=2.0, cable_delay=27)
MW_pulse_mod_risetime = 10 #6 = correct for LT2, 2 = correct for LT1
MW_Imod_duration = 1000
elt = 'test'
seq.add_element(elt, goto_target=elt)
#seq.add_pulse('PH', 'PH_start', elt, start=0, duration=50)
#seq.add_pulse('Green', 'Green', elt, start=0, amplitude = 1, duration=5000,start_reference = 'PH',link_start_to='end')
def generate_sequence(do_program=True):
seq = Sequence('tpqi_remote')
# vars for the channel names
chan_hhsync = 'HH_sync' # historically PH_start
chan_hh_ma1 = 'HH_MA1' # historically PH_sync
chan_exlaser = 'AOM_Matisse' # ok
chan_alaser_lt2 = 'AOM_Newfocus' # ok
chan_alaser_lt1 = 'AOM_Newfocus_lt1'
chan_adwinsync = 'ADwin_sync' # ok
chan_eom = 'EOM_Matisse'
chan_eom_aom = 'EOM_AOM_Matisse'
chan_plu = 'PLU_gate'
#chan_pulse_gating_module = 'Pulse_gating_module'
awgcfg.configure_sequence(
seq,
'hydraharp',
'mw',
LDE={
chan_eom_aom: {
'high': par_eom_aom_amplitude
},
},
)
#int(par_adwin_aom_duration*1e4)
seq.add_element(
'optical_rabi', repetitions=par_el_repetitions,
goto_target='idle') #'optical_rabi',event_jump_target='idle')
seq.add_pulse('sync_start',
chan_hhsync,
'optical_rabi',
start=0,
duration=50,
amplitude=2.0)
seq.add_pulse('delay',
chan_hhsync,
'optical_rabi',
start=0,
duration=50,
amplitude=0,
start_reference='sync_start',
link_start_to='end')
last = 'delay'
#XXXXXXXX
seq.add_pulse('AOM',
chan_eom_aom,
'optical_rabi',
start=par_aom_start,
duration=par_aom_duration,
start_reference=last,
link_start_to='start')
seq.add_pulse('EOM_off',
chan_eom,
'optical_rabi',
amplitude=par_eom_off_amplitude,
start=par_eom_start,
duration=par_eom_off_duration,
start_reference=last,
link_start_to='start')
seq.add_pulse('EOM_pulse', chan_eom, 'optical_rabi',
amplitude = par_eom_pulse_amplitude - par_eom_off_amplitude,
start = par_eom_start + par_eom_off_duration/2 + \
par_eom_pulse_offset, duration = par_eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1', chan_eom, 'optical_rabi',
amplitude = par_eom_overshoot1,
start = par_eom_start + par_eom_off_duration/2 + \
par_eom_pulse_offset + par_eom_pulse_duration,
duration = par_eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2', chan_eom, 'optical_rabi',
amplitude = par_eom_overshoot2,
start = par_eom_start + par_eom_off_duration/2 + \
par_eom_pulse_offset + par_eom_pulse_duration + \
par_eom_overshoot_duration1,
duration = par_eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_off_comp',
chan_eom,
'optical_rabi',
amplitude=-par_eom_off_amplitude,
start=par_eom_start + par_eom_off_duration,
duration=par_eom_off_duration,
start_reference=last,
link_start_to='start')
seq.add_pulse('EOM_pulse_comp', chan_eom, 'optical_rabi',
amplitude = -par_eom_pulse_amplitude + par_eom_off_amplitude,
start = par_eom_start+par_eom_off_duration + \
int(par_eom_off_duration/2) + par_eom_pulse_offset,
duration = par_eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot1_comp', chan_eom, 'optical_rabi',
amplitude = -par_eom_overshoot1,
start = par_eom_start+par_eom_off_duration + \
int(par_eom_off_duration/2) + par_eom_pulse_offset + \
par_eom_pulse_duration,
duration = par_eom_overshoot_duration1,
start_reference = last, link_start_to = 'start')
seq.add_pulse('EOM_overshoot2_comp', chan_eom, 'optical_rabi',
amplitude = -par_eom_overshoot2,
start = par_eom_start+par_eom_off_duration + \
int(par_eom_off_duration/2) + par_eom_pulse_offset + \
par_eom_pulse_duration + par_eom_overshoot_duration1,
duration = par_eom_overshoot_duration2,
start_reference = last, link_start_to = 'start')
#XXXXXXXXXXXX
seq.add_pulse('Gate_PLU_2',
chan_plu,
'optical_rabi',
start=0,
duration=par_plu_gate_duration,
start_reference='EOM_pulse',
link_start_to='end')
seq.add_pulse('Gate_PLU_1',
chan_plu,
'optical_rabi',
start=-100,
duration=50,
start_reference='Gate_PLU_2',
link_start_to='start')
seq.add_pulse('Gate_PLU_3',
chan_plu,
'optical_rabi',
start=300,
duration=150,
start_reference='Gate_PLU_2',
link_start_to='end')
seq.add_pulse('Gate_PLU_4',
chan_plu,
'optical_rabi',
start=50,
duration=50,
start_reference='Gate_PLU_3',
link_start_to='end')
seq.add_pulse('empty',
chan_hh_ma1,
'optical_rabi',
start=0,
start_reference='sync_start',
link_start_to='start',
duration=par_sync_period,
amplitude=0)
seq.add_element('idle',
goto_target='idle',
event_jump_target='optical_rabi')
seq.add_pulse('empty',
chan_hh_ma1,
'idle',
start=0,
duration=1000,
amplitude=0)
seq.set_instrument(awg)
seq.set_clock(1e9)
seq.set_send_waveforms(do_program)
seq.set_send_sequence(do_program)
seq.set_program_channels(True)
seq.set_start_sequence(False)
seq.force_HW_sequencing(True)
seq.send_sequence()
