def generate_sequence(do_program=True):
seq = Sequence('spin_control')
chan_mw_pm = 'MW_pulsemod'
awgcfg.configure_sequence(seq, mw = {chan_mw_pm: {'AWG_channel': 'ch1m1'}})
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('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.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)
# 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('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(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('sync_pulse')
seq.add_pulse('start', chan_hhsync, name, start = 0, duration = 50, amplitude = 4.0)
seq.add_pulse('pulse', chan_eom_aom, name, )
#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, duration = 50, amplitude = 0.0)
last = 'start'
for i in arange(pulse_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.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(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):
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 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(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
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()
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(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(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(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.0,
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()
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'
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()
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(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, '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, amplitude = par_adwin_aom_amp, start_reference = 'cr1', link_start_to = 'start',
duration_reference = 'cr1', link_duration_to = 'duration')
#int(par_adwin_aom_duration*1e4)
seq.add_element('optical_rabi', goto_target = 'preselect', repetitions = par_rabi_elt_reps)
#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, 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('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.add_pulse('probemw', chan_mw, 'wait_for_ADwin', start=-525, duration = 1000,
# amplitude = 1.0)
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(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(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(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
