def generate_sequence(do_program=True):
seq = Sequence('spin_control')
# vars for the channel names
chan_mw_pm = 'MW_pulsemod'
chan_mwI = 'MW_Imod'
chan_mwQ = 'MW_Qmod'
#awgcfg.configure_sequence(seq, mw = {chan_mw_pm: {'AWG_channel': 'ch1m1'}})
awgcfg.configure_sequence(seq,'mw')
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_'+str(i+1), chan_mw_pm, 'spin_control_'+str(i+1),
start = 0, duration = 1500, amplitude = 0)
seq.add_pulse('PM_microwave_'+str(length[i]), chan_mw_pm,
'spin_control_'+str(i+1), start = 0, duration = length[i],
start_reference='wait_'+str(i+1),
link_start_to = 'end')
seq.add_pulse('I_microwave_'+str(length[i]), chan_mwI,
'spin_control_'+str(i+1), start = 0, duration = length[i],
start_reference='wait_'+str(i+1),
link_start_to = 'end')
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(do_program=True):
seq = Sequence('conditionalrepumptest')
# 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 = 'AOM_Newfocus' # ok
chan_adwinsync = 'ADwin_sync' # ok
chan_eom = 'EOM_Matisse'
chan_eom_aom = 'EOM_AOM_Matisse'
awgcfg.configure_sequence(seq,
'basics',
'hydraharp',
ssro={chan_alaser: {
'high': par_cr_A_amplitude
}})
seq.add_element('preselect',
goto_target='preselect',
event_jump_target='wait_for_ADwin')
seq.add_pulse('cr1',
chan_exlaser,
'preselect',
duration=par_cr_duration,
amplitude=par_cr_Ex_amplitude)
seq.add_pulse('cr1_2',
chan_alaser,
'preselect',
start=0,
duration=0,
amplitude=par_cr_A_amplitude,
start_reference='cr1',
link_start_to='start',
duration_reference='cr1',
link_duration_to='duration')
seq.add_pulse('ADwin_ionization_probe',
chan_adwinsync,
'preselect',
start=0,
duration=-20000,
start_reference='cr1',
link_start_to='start',
duration_reference='cr1',
link_duration_to='duration')
seq.add_element('wait_for_ADwin',
trigger_wait=True,
goto_target='optical_rabi')
seq.add_pulse('probe1',
chan_exlaser,
'wait_for_ADwin',
start=0,
duration=1000,
amplitude=par_cr_Ex_amplitude)
seq.add_pulse('probe2',
chan_alaser,
'wait_for_ADwin',
start=-125,
duration=1000,
amplitude=par_cr_A_amplitude)
seq.set_instrument(ins_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 True
def generate_sequence(self, fstart, fstop, fsteps, do_program=True):
seq = Sequence(self.name)
# vars for the channel names
chan_mwpulsemod = 'MW_pulsemod'
chan_mwI = 'MW_Imod'
chan_mwQ = 'MW_Qmod'
chan_green = 'AOM_Green'
chan_hhsync = 'HH_sync'
basicscfg = {'AOM_Green': {'high': 0.6}}
awgcfg.configure_sequence(seq, 'hydraharp', 'mw', basics=basicscfg)
# sweep the modulation freq
for i, f_mod in enumerate(np.linspace(fstart, fstop, fsteps)):
###################################################################
# the actual rabi sequence and readout
ename = 'desrseq%d' % i
kw = {} if i < fsteps - 1 else {'goto_target': 'desrseq0'}
seq.add_element(ename, **kw)
seq.add_pulse('wait_for_singlets',
chan_hhsync,
ename,
duration=1500,
amplitude=0)
seq.add_IQmod_pulse(name='mwburst',
channel=(chan_mwI, chan_mwQ),
element=ename,
start=0,
duration=self.pipulse,
start_reference='wait_for_singlets',
link_start_to='end',
frequency=f_mod,
amplitude=self.amplitude_mod)
seq.clone_channel(chan_mwpulsemod,
chan_mwI,
ename,
start=-self.MW_pulse_mod_risetime,
duration=2 * self.MW_pulse_mod_risetime,
link_start_to='start',
link_duration_to='duration',
amplitude=2.0)
seq.add_pulse('readout',
chan_green,
ename,
start=500,
duration=2000,
start_reference='mwburst-I',
link_start_to='end')
seq.add_pulse('start_counting',
chan_hhsync,
ename,
start=-100,
duration=50,
start_reference='readout',
link_start_to='start')
###################################################################
seq.set_instrument(self.ins_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 True
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'
awgcfg.configure_sequence(
seq,
'hydraharp',
optical_rabi={
chan_eom_aom: {
'high': par_eom_aom_amplitude
},
chan_alaser_lt1: {
'high': par_sp_voltage_lt1
}
},
ssro={chan_alaser_lt2: {
'high': par_sp_voltage_lt2
}})
seq.add_element(
'optical_rabi',
goto_target='idle') #'optical_rabi',event_jump_target='idle')
seq.add_pulse('spinpumping_LT1',
chan_alaser_lt1,
'optical_rabi',
start=0,
duration=par_sp_duration)
seq.add_pulse('spinpumping_LT2',
chan_alaser_lt2,
'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_LT1',
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):
#FIXME position for the initialization pulse
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')
if use_pulse_gating_module:
seq.add_pulse('gate'+str(i), chan_pulse_gating_module, 'optical_rabi',
amplitude = 2.,
start = par_eom_start + par_eom_off_duration/2 + \
par_eom_pulse_offset + par_gate_start_offset,
duration = par_gate_duration,
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_exlaser,
'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()
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')
#if photon_pulse_nr[i]>0.5:
# if (i+1)%4==0:
# ch0_events[i-3]=1
# ch0_events[i-2]=1
# events+=1
# else:
# ch1_events[i]=1
ch0_events[0] = 0
ch0_events[1] = 1
#ch0_events[12]=0
#ch0_events[13]=1
seq = Sequence('PLU_test')
seq.add_channel('sync', 'ch2m2', cable_delay=0, high=2, low=0)
seq.add_channel('ch0', 'ch1', cable_delay=0, high=2, low=0)
seq.add_channel('ch1', 'ch1m2', cable_delay=0, high=2, low=0)
seq.add_channel('ma3', 'ch2m1', cable_delay=40, high=2, low=0)
seq.add_channel('hhsync', 'ch3m1', cable_delay=000, high=2, low=0)
pulse_duration = 70
photon_duration = 20
elt = 'plu_test'
wait = 'wait'
elt2 = 'plu_test2'
seq.add_element(elt, repetitions=1, goto_target=elt)
#sync_intervals[3] = 3333
#sync_intervals[50] = 2343200
#ch0_delays[49] = 2300500
#ch1_delays[49] = 2300500
#ch0_delays[50] = 2300000
#ch1_delays[50] = 2300000
#sync_intervals[5] = 1423
#sync_intervals[6] = 345
#sync_intervals[7] = 6456
#sync_intervals[8] = 453
#sync_intervals[9] = 3463
seq = Sequence('HH400_test')
seq.add_channel('sync', 'ch2m2', cable_delay=20, high=2, low=0)
seq.add_channel('ch0', 'ch1m1', cable_delay=0, high=2, low=0)
seq.add_channel('ch1', 'ch1m2', cable_delay=0, high=2, low=0)
seq.add_channel('ma3', 'ch2m1', cable_delay=0, high=2, low=0)
pulse_duration = 25
# Configure hydraharp
par_binsize_T3 = 8 # resolution of recorded data in HH 1ps*2**binsize_T3
elt = 'hh_test'
seq.add_element(elt, repetitions=5, goto_target='idle')
seq.add_element('idle', repetitions=wait, goto_target='late_ph')
seq.add_element('late_ph')
seq.add_element(elt + '2', repetitions=5)
def generate_sequence(fstart = 5E6, fstop = f_stop-(f_start+5E6), steps = nr_of_datapoints, do_program = True):
seq = Sequence('dark_esr')
print (fstart+f_start)/1E9
print (fstop+fstart+f_start)/1E9
awgcfg.configure_sequence(seq,'mw')
# vars for the channel names
chan_mwpulsemod = 'MW_pulsemod'
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
amplitude_mod = 1.
power = 20.
mode = 'SSB'
amplitude_i = 0.
amplitude_q = 0.
amplitude_ssbmod = 0.8
f_ssbmod = 0.
MW_pulse_mod_risetime = 20
# 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_IQmod_pulse(name = 'mwburst', channel = (chan_mwI,chan_mwQ),
element = ename, start = 0, duration = pipulse,
frequency = f_mod,
amplitude = amplitude_mod)
seq.clone_channel(chan_mwpulsemod, chan_mwI, ename,
start=-MW_pulse_mod_risetime, duration=2*MW_pulse_mod_risetime,
link_start_to = 'start', 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):
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()
from measurement.AWG_HW_sequencer_v2 import Sequence
seq = Sequence('preselect')
seq.add_channel('Ex', 'ch1m1', cable_delay=0, high=1)
seq.add_channel('A2', 'ch1m2', cable_delay=604, high=1)
seq.add_channel('ADwin_sync', 'ch3m2', high=2.0, cable_delay=0)
#seq.add_channel('MW_Imod', 'ch1', high=0.9, low=-0.9, cable_delay = 199)
#seq.add_channel('MW_Qmod', 'ch4', high=0.9, low=-0.9, cable_delay = 0)
MW_pulse_mod_risetime = 0
seq.add_element('preselect', event_jump_target='wait_for_ADwin')
seq.add_pulse('cr1', 'Ex', 'preselect', duration=1000, amplitude=1)
seq.add_pulse('cr1_2',
'A2',
'preselect',
start=0,
duration=0,
amplitude=1,
start_reference='cr1',
link_start_to='start',
duration_reference='cr1',
link_duration_to='duration')
seq.add_pulse('ADwin_ionization_probe',
'ADwin_sync',
'preselect',
start=0,
duration=20000,
def generate_sequence(self, PLstart, PLstop, PLsteps, do_program=True):
seq = Sequence(self.name)
# vars for the channel names
chan_mwpulsemod = 'MW_pulsemod'
chan_mwI = 'MW_Imod'
chan_mwQ = 'MW_Qmod'
chan_green = 'AOM_Green'
chan_hhsync = 'HH_sync'
basicscfg = {'AOM_Green': {'high': 0.8}}
awgcfg.configure_sequence(seq, 'hydraharp', 'mw', basics=basicscfg)
# sweep the pulse length
for i, pulselength in enumerate(np.linspace(PLstart, PLstop, PLsteps)):
###################################################################
# the actual rabi sequence and readout
print pulselength
ename = 'rabiseq%d' % i
kw = {} if i < PLsteps - 1 else {'goto_target': 'rabiseq0'}
seq.add_element(ename, **kw)
seq.add_pulse('wait_for_singlets',
chan_hhsync,
ename,
duration=1500,
amplitude=0)
if self.mode == 'SSB':
seq.add_IQmod_pulse(name='mwburst',
channel=(chan_mwI, chan_mwQ),
element=ename,
start=0,
duration=pulselength,
start_reference='wait_for_singlets',
link_start_to='end',
frequency=self.f_ssbmod,
amplitude=1)
elif self.mode == 'I+Q':
seq.add_pulse('mwburst',
chan_mwI,
ename,
start=0,
duration=pulselength,
start_reference='wait_for_singlets',
link_start_to='end',
amplitude=self.amplitude_i)
seq.add_pulse('mwburst',
chan_mwQ,
ename,
start=0,
duration=pulselength,
start_reference='wait_for_singlets',
link_start_to='end',
amplitude=self.amplitude_q)
else:
print 'Invalid mode for the sequence! Abort.'
return False
seq.clone_channel(chan_mwpulsemod,
chan_mwI,
ename,
start=-self.MW_pulse_mod_risetime,
duration=2 * self.MW_pulse_mod_risetime,
link_start_to='start',
link_duration_to='duration',
amplitude=2.0)
ref = 'mwburst' if self.mode == 'I+Q' else 'mwburst-I'
#seq.add_pulse('readout', 'AOM_green', ename, start = 500,
# duration = 1000, start_reference=ref,
# link_start_to = 'end')
seq.add_pulse('readout',
chan_green,
ename,
start=500 + PLstop,
duration=10000,
start_reference='wait_for_singlets',
link_start_to='end')
seq.add_pulse('start_counting',
chan_hhsync,
ename,
start=-100,
duration=50,
start_reference='readout',
link_start_to='start')
###################################################################
seq.set_instrument(self.ins_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 True
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 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(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'
awgcfg.configure_sequence(
seq,
'hydraharp',
'ssro',
optical_rabi={chan_eom_aom: {
'high': par_eom_aom_amplitude
}})
#int(par_adwin_aom_duration*1e4)
seq.add_element(
'optical_rabi',
goto_target='idle') #'optical_rabi',event_jump_target='idle')
seq.add_pulse('spinpumping_LT1',
chan_alaser_lt1,
'optical_rabi',
start=0,
duration=par_sp_duration,
amplitude=par_sp_voltage_lt1)
seq.add_pulse('spinpumping_LT2',
chan_alaser_lt2,
'optical_rabi',
start=0,
duration=par_sp_duration,
amplitude=par_sp_voltage_lt2)
#Define a start point for the sequence, set amplitude to 0. actual sync pulse comes later
seq.add_pulse('start',
chan_hhsync,
'optical_rabi',
start=0,
start_reference='spinpumping_LT1',
link_start_to='end',
duration=50,
amplitude=0.0)
last = 'start'
for i in arange(par_rabi_reps):
#FIXME position for the initialization pulse
seq.add_pulse('start' + str(i),
chan_hhsync,
'optical_rabi',
start=par_rabi_cycle_duration,
duration=50,
start_reference=last,
link_start_to='start')
last = 'start' + str(i)
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')
seq.add_element('idle',
goto_target='idle',
event_jump_target='optical_rabi')
seq.add_pulse('empty',
chan_exlaser,
'idle',
start=0,
duration=1000,
amplitude=0)
#seq.add_pulse('probe2', chan_alaser, 'wait_for_ADwin', start=-125, duration = 1000,
# amplitude = par_cr_A_amplitude)
#seq.add_pulse('probemw', chan_mw, 'wait_for_ADwin', start=-525, duration = 1000,
# amplitude = 1.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, fstart, fstop, fsteps, do_program=True):
seq = Sequence(self.name)
# MWs
seq.add_channel('MW_pulsemod', 'ch2m2', high=2.0, cable_delay=199)
seq.add_channel('MW_Imod', 'ch1', high=0.9, low=-0.9, cable_delay=199)
seq.add_channel('MW_Qmod', 'ch4', high=0.9, low=-0.9, cable_delay=199)
# Light
seq.add_channel('AOM_green', 'ch2m1', cable_delay=604, high=0.5)
# PH data aquisition
seq.add_channel('PH_start', 'ch4m2', cable_delay=0)
seq.add_channel('PH_MA1', 'ch3m1', cable_delay=0, high=2.0)
#######################################################################
# creates two start pulses to compensate
# for PH bug (misses first 2 start pulses)
#ename = 'sync'
#seq.add_element(ename)
#seq.add_pulse('PH_sync1', 'PH_start', ename, duration = 50)
#seq.add_pulse('PH_sync2', 'PH_start', ename, start = 500, duration = 50,
# start_reference = 'PH_sync1', link_start_to = 'end')
#seq.add_pulse('PH_sync_wait', 'PH_start', ename, start = 500,
# duration = 50, start_reference = 'PH_sync2',
# link_start_to = 'end', amplitude = 0)
#######################################################################
# sweep the pulse length
for i, f_mod in enumerate(np.linspace(fstart, fstop, fsteps)):
###################################################################
# the actual rabi sequence and readout
ename = 'esrseq%d' % i
kw = {} if i < fsteps - 1 else {'goto_target': 'esrseq0'}
seq.add_element(ename, **kw)
seq.add_pulse('wait_for_singlets',
'PH_start',
ename,
duration=1000,
amplitude=0)
seq.add_IQmod_pulse(name='mwburst',
channel=('MW_Imod', 'MW_Qmod'),
element=ename,
start=0,
duration=self.pipulse,
start_reference='wait_for_singlets',
link_start_to='end',
frequency=f_mod,
amplitude=self.amplitude_mod)
seq.clone_channel('MW_pulsemod',
'MW_Imod',
ename,
start=-MW_pulse_mod_risetime,
duration=2 * MW_pulse_mod_risetime,
link_start_to='start',
link_duration_to='duration',
amplitude=2.0)
seq.add_pulse('readout',
'AOM_green',
ename,
start=500,
duration=1000,
start_reference='mwburst-I',
link_start_to='end')
seq.add_pulse('start_counting',
'PH_start',
ename,
start=-100,
duration=50,
start_reference='readout',
link_start_to='start')
###################################################################
seq.set_instrument(self.ins_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_time(do_program=True):
'''
This sequence consists of a fixed number of CORPSE pulses
and sweeps the time between the individual pulses in the CORPSE pulse sequence
sweep_param = numpy array with time between each pulse in the CORPSE pulses sequence
pulse_dict={
"Pi":{"duration": ..., "amplitude":... ,},
"istate_pulse": {"duration":... , "amplitude":..., First pulse to create init state
"Do_Pulse": Boolean},
"time_between_pulses": ..., waiting time between the CORPSE-pulses
"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
def generate_sequence(self, do_program=True):
seq = Sequence(self.name)
# vars for the channel names
chan_mwpulsemod = 'MW_pulsemod'
chan_mwI = 'MW_Imod'
chan_mwQ = 'MW_Qmod'
chan_green = 'AOM_Green'
chan_phstart = 'PH_start'
chan_phsync = 'PH_sync'
chan_exlaser = 'AOM_Matisse'
chan_alaser = 'AOM_Newfocus'
chan_adwinsync = 'ADwin_sync'
awgcfg.configure_sequence(seq, 'basics', 'picoharp', 'mw',
ssro={ chan_alaser: {'high': self.par_cr_A_amplitude } } )
commonseq.phsync_element(seq)
seq.add_element('initialize')
seq.add_pulse('green_initialize', chan_green, 'initialize', start = 0, duration = 10000)
seq.add_element('preselect', event_jump_target = 'wait_for_ADwin')
seq.add_pulse('cr1', chan_exlaser, 'preselect', duration = self.par_cr_duration,
amplitude = self.par_cr_Ex_amplitude)
seq.add_pulse('cr1_2', chan_alaser, 'preselect', start = 0, duration = 0,
amplitude = self.par_cr_A_amplitude, start_reference = 'cr1', link_start_to = 'start',
duration_reference = 'cr1', link_duration_to = 'duration')
seq.add_pulse('ADwin_ionization_probe', chan_adwinsync, 'preselect', start = 0,
duration = -20000, start_reference = 'cr1', link_start_to = 'start',
duration_reference = 'cr1', link_duration_to = 'duration')
seq.add_element('readout', goto_target = 'readout', event_jump_target = 'wait_for_ADwin')
seq.add_pulse('wait_a', chan_exlaser, 'readout', start = 0, duration = 500,
amplitude = 0)
seq.add_pulse('sp', chan_exlaser, 'readout', start = 0, duration = self.par_sp_duration,
amplitude = self.par_sp_Ex_amplitude, start_reference = 'wait_a', link_start_to = 'end')
seq.add_pulse('sp_2', chan_alaser, 'readout', start = 0, duration = 0,
amplitude = self.par_sp_A_amplitude, start_reference = 'sp', link_start_to = 'start',
duration_reference = 'sp', link_duration_to = 'duration')
seq.add_pulse('ro', chan_exlaser, 'readout', start = 6000, duration = self.par_ro_duration,
amplitude = self.par_ro_Ex_amplitude, start_reference = 'sp', link_start_to = 'end')
seq.add_pulse('ro_2', chan_alaser, 'readout', start = 0, duration = 0,
amplitude = self.par_ro_A_amplitude, start_reference = 'ro', link_start_to = 'start',
duration_reference = 'ro', link_duration_to = 'duration')
seq.add_pulse('cr2', chan_exlaser, 'readout', start = 1000, duration = self.par_cr_duration,
amplitude = self.par_cr_Ex_amplitude, start_reference = 'ro', link_start_to = 'end')
seq.add_pulse('cr2_2', chan_alaser, 'readout', start = 0, duration = 0,
amplitude = self.par_cr_A_amplitude, start_reference = 'cr2', link_start_to = 'start',
duration_reference = 'cr2', link_duration_to = 'duration')
seq.add_pulse('start_sp', chan_phstart, 'readout', start = -100, duration = 50,
start_reference = 'sp', link_start_to = 'start')
seq.add_pulse('start_sp_filter', chan_phstart, 'readout',
start=-100-self.par_sp_filter_duration, duration = 50,
start_reference='sp', link_start_to='end')
if self.par_ro_spinfilter:
seq.add_pulse('start_ro_sp_filter', chan_phstart, 'readout',
start=-100-self.par_ro_spinfilter_duration, duration = 50,
start_reference='ro', link_start_to='end')
seq.add_pulse('start_ro', chan_phstart, 'readout', start = -100, duration = 50,
start_reference = 'ro', link_start_to = 'start')
seq.add_pulse('start_cr2', chan_phstart, 'readout', start = -100, duration = 50,
start_reference = 'cr2', link_start_to = 'start')
seq.add_pulse('ADwin_ionization_probe', chan_adwinsync, 'readout', start = 0,
duration = -20000, start_reference = 'cr2', link_start_to = 'start',
duration_reference = 'cr2', link_duration_to = 'duration')
seq.add_element('wait_for_ADwin', trigger_wait = True, goto_target = 'readout')
seq.add_pulse('probe1', chan_exlaser, 'wait_for_ADwin', start=0, duration = 1000,
amplitude = self.par_cr_Ex_amplitude)
seq.add_pulse('probe2', chan_alaser, 'wait_for_ADwin', start=-125, duration = 1000,
amplitude = self.par_cr_A_amplitude)
seq.set_instrument(self.ins_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 True
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(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_sequence(do_program=True):
seq = Sequence(name)
# 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 = 'AOM_Newfocus' # ok
chan_adwinsync = 'ADwin_sync' # ok
chan_eom = 'EOM_Matisse'
chan_eom_aom = 'EOM_AOM_Matisse'
awgcfg.configure_sequence(seq, 'basics', 'hydraharp',
optical_rabi = {chan_eom_aom: {'high': par_eom_aom_amplitude}},
ssro={ chan_alaser: {'high': par_cr_A_amplitude } } )
seq.add_element('preselect', event_jump_target = 'wait_for_ADwin')
seq.add_pulse('cr1', chan_exlaser, 'preselect', duration = par_cr_duration,
amplitude = par_cr_Ex_amplitude)
seq.add_pulse('cr1_2', chan_alaser, 'preselect', start = 0, duration = 0,
amplitude = par_cr_A_amplitude, start_reference = 'cr1', link_start_to = 'start',
duration_reference = 'cr1', link_duration_to = 'duration')
seq.add_pulse('ADwin_ionization_probe', chan_adwinsync, 'preselect', start = 0,
duration = -20000, start_reference = 'cr1', link_start_to = 'start',
duration_reference = 'cr1', link_duration_to = 'duration')
seq.add_element('optical_rabi', goto_target = 'preselect', repetitions = par_rabi_elt_reps)
seq.add_pulse('start', chan_hhsync, 'optical_rabi', start = 0, duration = 50, amplitude = 0.0)
last = 'start'
for i in arange(par_rabi_reps):
seq.add_pulse('start'+str(i), chan_hhsync, 'optical_rabi', start = par_rabi_cycle_duration, duration = 50,
start_reference = last, link_start_to = 'start')
last = 'start'+str(i)
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_aom_start + int(par_aom_duration/2) + par_eom_pulse_start, duration = par_eom_pulse_duration,
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_off_duration + par_aom_start + par_eom_pulse_start +
int(par_aom_duration/2), duration = par_eom_pulse_duration,
start_reference = last, link_start_to = 'start')
seq.add_element('wait_for_ADwin', trigger_wait = True, goto_target = 'optical_rabi')
seq.add_pulse('probe1', chan_exlaser, 'wait_for_ADwin', start=0, duration = 1000,
amplitude = par_cr_Ex_amplitude)
seq.add_pulse('probe2', chan_alaser, 'wait_for_ADwin', start=-125, duration = 1000,
amplitude = par_cr_A_amplitude)
seq.set_instrument(ins_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 True
name = 'optical_rabi'
par_aom_duration = 200
par_aom_start = 800
par_eom_off_duration = 100
par_eom_pulse_duration = 30
par_eom_pulse_offset = -30
par_eom_off_amplitude = -.2
par_eom_pulse_amplitude = -.1
par_eom_aom_amplitude = 0.1
par_eom_initial_idle_duration = 0
seq = Sequence(name)
# vars for the channel names
chan_HHsync = 'HH_sync'
chan_eom_aom = 'AOM_EOM_Matisse'
chan_eom = 'EOM_Matisse'
seq.add_channel('EOM_Matisse',
'ch4',
cable_delay=0,
low=par_eom_off_amplitude,
high=par_eom_pulse_amplitude)
seq.add_channel('AOM_EOM_Matisse', 'ch4m1', cable_delay=0, low=0., high=1.)
seq.add_channel('HH_sync', 'ch2m2', cable_delay=0, low=0., high=2.)
seq.add_element(name, repetitions=1, goto_target=name)
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_apd_gate_1 = 'APD_Gate_1'
chan_apd_gate_2 = 'APD_Gate_2'
awgcfg.configure_sequence(
seq,
'hydraharp',
'ssro',
optical_rabi={chan_eom_aom: {
'high': par_eom_aom_amplitude
}})
#int(par_adwin_aom_duration*1e4)
seq.add_element(
'optical_rabi',
goto_target='idle') #'optical_rabi',event_jump_target='idle')
seq.add_pulse('spinpumping_LT1',
chan_alaser_lt1,
'optical_rabi',
start=0,
duration=par_sp_duration,
amplitude=par_sp_voltage_lt1)
seq.add_pulse('spinpumping_LT2',
chan_alaser_lt2,
'optical_rabi',
start=0,
duration=par_sp_duration,
amplitude=par_sp_voltage_lt2)
#Define a start point for the sequence, set amplitude to 0. actual sync pulse comes later
seq.add_pulse('start',
chan_hhsync,
'optical_rabi',
start=-1000,
start_reference='spinpumping_LT1',
link_start_to='end',
duration=50,
amplitude=0.)
# seq.add_pulse('start', chan_hhsync, 'optical_rabi', start = -1000,
# duration = 50, amplitude = 2.0)
last = 'start'
seq.add_pulse('AOM',
chan_eom_aom,
'optical_rabi',
start=par_aom_start,
duration=par_aom_duration,
amplitude=par_eom_aom_amplitude,
start_reference=last,
link_start_to='start')
if use_apd_gate:
seq.add_pulse('gate_apd1',
chan_apd_gate_1,
'optical_rabi',
amplitude=-2.,
start=par_aom_start + par_gate_start_offset,
duration=par_gate_duration,
start_reference=last,
link_start_to='start')
seq.add_pulse('gate_apd2',
chan_apd_gate_2,
'optical_rabi',
amplitude=-2.,
start=par_aom_start + par_gate_start_offset + 300,
duration=par_gate_duration,
start_reference=last,
link_start_to='start')
seq.add_element('idle',
goto_target='idle',
event_jump_target='optical_rabi')
seq.add_pulse('empty',
chan_exlaser,
'idle',
start=0,
duration=1000,
amplitude=0)
#seq.add_pulse('probe2', chan_alaser, 'wait_for_ADwin', start=-125, duration = 1000,
# amplitude = par_cr_A_amplitude)
#seq.add_pulse('probemw', chan_mw, 'wait_for_ADwin', start=-525, duration = 1000,
# amplitude = 1.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('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()
