def generate_sequence(self, upload=True, **kw):
T = pulse.SquarePulse(channel='MW_pulsemod', length=10e-9, amplitude=0)
X = pulselib.MW_IQmod_pulse(
'MW pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=self.params['MW_pulse_mod_risetime'])
fast_pi = pulse.cp(X,
amplitude=self.params['fast_pi_amp'],
length=self.params['fast_pi_duration'],
frequency=self.params['fast_pi_mod_frq'])
fast_pi2 = pulse.cp(X,
amplitude=self.params['fast_pi2_amp'],
length=self.params['fast_pi2_duration'],
frequency=self.params['fast_pi2_mod_frq'])
mbi_elt = self._MBI_element()
sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar)
adwin_sync = pulse.SquarePulse(channel='adwin_sync',
length=10e-6,
amplitude=2)
sync_elt.append(adwin_sync)
elts = []
seq = pulsar.Sequence('Zeroth revival sequence')
for i in range(self.params['pts']):
e = element.Element('pi2_pi_pi2-{}'.format(i),
pulsar=qt.pulsar,
global_time=True,
time_offset=0.)
e.append(T)
e.append(fast_pi2)
e.append(pulse.cp(T,
length=self.params['free_evolution_times'][i]))
e.append(fast_pi)
e.append(pulse.cp(T,
length=self.params['free_evolution_times'][i]))
e.append(pulse.cp(fast_pi2, phase=self.params['pi2_phases'][i]))
e.append(T)
elts.append(e)
seq.append(name='MBI-{}'.format(i),
wfname=mbi_elt.name,
trigger_wait=True,
goto_target='MBI-{}'.format(i),
jump_target=e.name)
seq.append(name='pi2_pi_pi2-{}'.format(i),
wfname=e.name,
trigger_wait=True)
seq.append(name='sync-{}'.format(i), wfname=sync_elt.name)
if upload:
qt.pulsar.upload(mbi_elt, sync_elt, *elts)
qt.pulsar.program_sequence(seq)
def generate_sequence(self, upload=True):
#print 'test'
# define the necessary pulses
X1 = pulselib.IQ_CORPSE_pulse('CORPSE pi-pulse',
I_channel = 'MW_1',
Q_channel='dummy',
PM_channel = 'MW_pulsemod',
#second_MW_channel = 'MW_Qmod',
PM_risetime = self.params['MW_pulse_mod_risetime'],
amplitude = self.params['CORPSE_pi_amp'],
rabi_frequency = self.params['CORPSE_pi_frq'],
eff_rotation_angle = 180)
X1.channels.remove('dummy')
X2 = pulselib.IQ_CORPSE_pulse('CORPSE 2pi-pulse',
I_channel = 'MW_2',
PM_channel = 'MW_pulsemod',
#second_MW_channel = 'MW_Qmod',
PM_risetime = self.params['MW_pulse_mod_risetime'],
amplitude = self.params['CORPSE_2pi_amp'],
rabi_frequency = self.params['CORPSE_2pi_frq'],
eff_rotation_angle = 360)
X2.channels.remove('dummy')
RND_halt = pulse.SquarePulse(channel = 'RND_halt', amplitude = 1.0,
length = 400e-9)
sync = pulse.SquarePulse(channel = 'sync', length = 50e-9, amplitude = 1.0)
T = pulse.SquarePulse(channel='MW_1', name='delay',
length = 200e-9, amplitude = 0.)
RO_pulse = pulse.SquarePulse(channel = 'AOM_Matisse',
amplitude = self.params['E_RO_voltage_AWG'],
length = self.params['SSRO_duration']*1e-6)
# make the elements - one for each ssb frequency
elements = []
for i in range(self.params['pts']):
e = element.Element('ElectronRandom_pt-%d' % i, pulsar=qt.pulsar)
e.append(T)
e.append(sync)
e.append(T)
e.append(RND_halt)
ref=e.append(T)
e.add(X1, refpulse=ref)
e.add(X2, refpulse=ref)
e.append(pulse.cp(T, length = 1e-6))
e.append(RO_pulse)
e.append(T)
elements.append(e)
# create a sequence from the pulses
seq = pulsar.Sequence('ElectronRandom sequence')
for e in elements:
seq.append(name=e.name, wfname=e.name, trigger_wait=True)
# upload the waveforms to the AWG
if upload:
qt.pulsar.program_awg(seq,*elements)
def _create_wait_times(Gate):
Gate.TIQ = pulse.SquarePulse(channel = 'MW_Imod',length=2e-6)
Gate.T = pulse.SquarePulse(channel='MW_pulsemod',
length = 50e-9, amplitude = 0)
Gate.T_sync = pulse.SquarePulse(channel='sync',
length = 50e-9, amplitude = 0)
def generate_sequence(self, **kw):
upload = kw.pop('upload', True)
T = pulse.SquarePulse(channel = 'Velocity1AOM', length = 1e-6, amplitude = 0.)
R = pulse.SquarePulse(channel = 'Velocity1AOM', amplitude = 1.0)
Y = pulse.SquarePulse(channel = 'YellowAOM', amplitude = 1.0)
MW = pulselib.MW_IQmod_pulse('Long weak pulse',
I_channel='MW_Imod', Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
frequency = self.params['ms-1_cntr_frq'] - self.params['mw_frq'],
PM_risetime = self.params['MW_pulse_mod_risetime'],
amplitude = 0.1)
ionization_element = element.Element('ionization_element', pulsar = qt.pulsar)
ionization_element.add(pulse.cp(R,
amplitude = self.params['red_ionization_amplitude'],
length = 10e-6),
name = 'red ionization pulse')
ionization_element.add(pulse.cp(MW, length = 9.5e-6),
refpulse = 'red ionization pulse',
refpoint = 'start')
delay_element = element.Element('delay_element', pulsar = qt.pulsar)
delay_element.append(T)
sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar)
adwin_sync = pulse.SquarePulse(channel='adwin_sync',
length = 10e-6, amplitude = 2)
sync_elt.append(adwin_sync)
seq = pulsar.Sequence('Yellow RP Calibration sequence')
elements = []
for i in range(self.params['pts']):
self.params['AWG_yellow_rp_amplitude'] = \
self.repump_aom.power_to_voltage(
self.params['AWG_yellow_rp_powers'][i], controller='sec')
repump_element = element.Element('repump_element-{}'.format(i), pulsar = qt.pulsar)
repump_element.append(pulse.cp(Y, length = 10e-6, amplitude = self.params['AWG_yellow_rp_amplitude']))
elements.append(repump_element)
seq.append(name = ionization_element.name+'_{}'.format(i),
wfname = ionization_element.name,
trigger_wait = True,
repetitions = int(self.params['red_ionization_durations'][i]/10e-6))
seq.append(name = delay_element.name+'_{}'.format(i),
wfname = delay_element.name)
seq.append(name = repump_element.name+'_{}'.format(i),
wfname = repump_element.name,
repetitions = int(self.params['yellow_rp_durations'][i]/10e-6))
seq.append(name = sync_elt.name+'-{}'.format(i),
wfname = sync_elt.name)
# upload the waveforms to the AWG
if upload:
qt.pulsar.upload(ionization_element, delay_element, sync_elt, *elements)
# program the AWG
qt.pulsar.program_sequence(seq)
def jitter_timings(name, debug = False, upload = True, run_msmt = True):
m = SquarePulseJitter(name)
m.adwin_process = 'dynamic_jump'
m.params.from_dict(qt.exp_params['samples'][SAMPLE])
m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO'])
m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO'])
m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO-integrated'])
m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+espin'])
m.params.from_dict(qt.exp_params['protocols']['cr_mod'])
m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['pulses'])
m.params['pulse_type'] = 'Square'
m.params['pulse_shape'] = 'Square'
m.params['pts'] = 14
m.params['repetitions'] = 1e4
# lt3 params
m.params['AWG_start_DO_channel'] = 9
m.params['AWG_jump_strobe_DO_channel'] = 0
m.params['jump_bit_shift'] = 4
m.params['sweep_length'] = m.params['pts']
m.params['reps'] = m.params['repetitions'] * m.params['pts']
m.params['minimal_delay_time'] = 0
m.params['minimal_delay_cycles'] = 0
m.params['delay_clock_cycle_time'] = 20e-9
# m.params['delay_time'] = 2e-6;
pulseA = pulse.SquarePulse(channel='HHsync', amplitude = 5, length = 40e-9);
pulseB = pulse.SquarePulse(channel='tico_sync', amplitude = 5, length = 40e-9);
# Start measurement
m.generate_sequence(upload = upload, Square_A = pulseA, Square_B = pulseB)
# Print the tables that go to the adwin
# print m.params['jump_table']
# print m.params['next_seq_table']
# for delays in m.params['delays_before_jumps']:
# print [round(var, 12) for var in delays]
if run_msmt:
#delay_cycle = np.rint(m.params['delay_time'] / m.params['delay_clock_cycle_time']).astype(np.int32)
min_delay = 47
delay_cycles = np.zeros(m.params['pts'] * 2)
delay_cycles[0::2] = 100
delay_cycles[1::2] = np.array(range(min_delay, min_delay + m.params['pts']))
delay_cycles = delay_cycles.astype(np.int32)
print delay_cycles
seq_indices = np.arange(m.params['pts']+1)*2+1
random_jumps = np.random.randint(low = 1, high = 2, size = 1e3) # Unused atm
jump_table = np.array([1, 2] * m.params['pts'])
next_seq_table = np.repeat(0, 1) # Unused atm
m.adwin.start_dynamic_jump(do_init_only = 1) # Necessary for init
qt.msleep(0.05)
m.adwin.set_dynamic_jump_var(
jump_table = (2**m.params['jump_bit_shift']) * jump_table,
delay_cycles = delay_cycles,
next_seq_table = next_seq_table,
seq_indices = seq_indices,
random_ints = (2**m.params['jump_bit_shift']) * random_jumps,
)
print 'Waiting until AWG done'
qt.msleep(7)
m.awg.start()
qt.msleep(2)
print 'Starting msmt'
m.adwin.start_dynamic_jump(
AWG_start_DO_channel = m.params['AWG_start_DO_channel'],
AWG_jump_strobe_DO_channel = m.params['AWG_jump_strobe_DO_channel'],
do_init_only = 0,
jump_bit_shift = m.params['jump_bit_shift'],
sweep_length = m.params['sweep_length'],
reps = m.params['reps'],
)
pqt.run_HH('getTHdata')
low=0,
offset=0.,
delay=0.,
active=True)
qt.pulsar.define_channel(id='ch4_marker2',
name='th_ch1',
type='marker',
high=2.0,
low=0,
offset=0.,
delay=0.,
active=True)
#qt.pulsar.define_channel(id='ch4_marker2', name='th_ch1', type='marker',
# high=2.0, low=0, offset=0., delay=0., active=True)
test_pulse = pulse.SquarePulse(channel='th_sync', amplitude=1.0)
test_pulse2 = pulse.SquarePulse(channel='th_ch1', amplitude=1.0)
#test_pulse3 = pulse.SquarePulse(channel = 'th_ch1', amplitude = 1.0)
elt1 = element.Element('idle', pulsar=qt.pulsar)
#print 'Channel definitions: '
#pprint.pprint(test_element._channels)
elt1.add(pulse.cp(test_pulse2, amplitude=1.0, length=100e-9), start=100e-9)
elt1.add(pulse.cp(test_pulse, amplitude=1.0, length=1000e-9), start=600e-9)
elt1.add(pulse.cp(test_pulse2, amplitude=1.0, length=100e-9), start=1800e-9)
elt1.add(pulse.cp(test_pulse2, amplitude=0, length=1000e-9), start=1900e-9)
#elt1.add(pulse.cp(test_pulse3, amplitude = 1.0, length = 100e-9), start = 600e-9)
#elt1.add(pulse.cp(test_pulse3, amplitude = 0.0, length = 10000e-9), start = 800e-9)
def pulse_defs_lt1(msmt):
# a waiting pulse on the MW pulsemod channel
msmt.T = pulse.SquarePulse(channel='MW_pulsemod',
length=50e-9,
amplitude=0)
msmt.TIQ = pulse.SquarePulse(channel='MW_Imod', length=10e-9, amplitude=0)
# some not yet specified pulse on the electron
msmt.e_pulse = pulselib.MW_IQmod_pulse(
'MW pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=msmt.params['MW_pulse_mod_risetime'])
msmt.CORPSE_pi = pulselib.MW_CORPSE_pulse(
'CORPSE pi-pulse',
MW_channel='MW_Imod',
PM_channel='MW_pulsemod',
second_MW_channel='MW_Qmod',
PM_risetime=msmt.params['MW_pulse_mod_risetime'],
amplitude=msmt.params['CORPSE_pi_amp'],
rabi_frequency=msmt.params['CORPSE_rabi_frequency'],
eff_rotation_angle=180)
msmt.CORPSE_pi2 = pulselib.MW_CORPSE_pulse(
'CORPSE pi2-pulse',
MW_channel='MW_Imod',
PM_channel='MW_pulsemod',
second_MW_channel='MW_Qmod',
PM_risetime=msmt.params['MW_pulse_mod_risetime'],
amplitude=msmt.params['CORPSE_pi2_amp'],
rabi_frequency=msmt.params['CORPSE_rabi_frequency'],
eff_rotation_angle=90)
msmt.CORPSE_RND0 = pulselib.MW_CORPSE_pulse(
'CORPSE pi2-pulse',
MW_channel='MW_Imod',
PM_channel='MW_pulsemod',
PM_risetime=msmt.params['MW_pulse_mod_risetime'],
amplitude=msmt.params['CORPSE_RND_amp'],
rabi_frequency=msmt.params['CORPSE_rabi_frequency'],
eff_rotation_angle=msmt.params['RND_angle_0'])
msmt.CORPSE_RND1 = pulselib.MW_CORPSE_pulse(
'CORPSE pi2-pulse',
MW_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=msmt.params['MW_pulse_mod_risetime'],
amplitude=msmt.params['CORPSE_RND_amp'],
rabi_frequency=msmt.params['CORPSE_rabi_frequency'],
eff_rotation_angle=msmt.params['RND_angle_1'])
msmt.eom_pulse = eom_pulses.EOMAOMPulse(
'Eom Aom Pulse',
eom_channel='EOM_Matisse',
aom_channel='EOM_AOM_Matisse',
eom_pulse_duration=msmt.params['eom_pulse_duration'],
eom_off_duration=msmt.params['eom_off_duration'],
eom_off_amplitude=msmt.params['eom_off_amplitude'],
eom_pulse_amplitude=msmt.params['eom_pulse_amplitude'],
eom_overshoot_duration1=msmt.params['eom_overshoot_duration1'],
eom_overshoot1=msmt.params['eom_overshoot1'],
eom_overshoot_duration2=msmt.params['eom_overshoot_duration2'],
eom_overshoot2=msmt.params['eom_overshoot2'],
aom_risetime=msmt.params['aom_risetime'],
aom_amplitude=msmt.params['aom_amplitude'])
msmt.RND_halt_off_pulse = pulse.SquarePulse(
channel='RND_halt', amplitude=-2.0, length=msmt.params['RND_duration'])
### synchronizing, etc
msmt.adwin_trigger_pulse = pulse.SquarePulse(channel='adwin_sync',
length=5e-6,
amplitude=2)
msmt.adwin_success_pulse = pulse.SquarePulse(
channel='adwin_success_trigger', length=5e-6, amplitude=2)
msmt.sync = pulse.SquarePulse(channel='sync', length=50e-9, amplitude=1.0)
msmt.SP_pulse = pulse.SquarePulse(channel='AOM_Newfocus', amplitude=1.0)
msmt.RO_pulse = pulse.SquarePulse(channel='AOM_Matisse', amplitude=0.0)
msmt.yellow_pulse = pulse.SquarePulse(channel='AOM_Yellow', amplitude=1.0)
return True
def generate_sequence(self, upload=True):
# MBI element
mbi_elt = self._MBI_element()
# electron manipulation pulses
T = pulse.SquarePulse(channel='MW_pulsemod',
length=100e-9,
amplitude=0)
TIQ = pulse.SquarePulse(channel='MW_Imod', length=10e-9, amplitude=0)
fast_pi = pulselib.MW_IQmod_pulse(
'MW pi pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=self.params['MW_pulse_mod_risetime'],
frequency=self.params['fast_pi_mod_frq'],
amplitude=self.params['fast_pi_amp'],
length=self.params['fast_pi_duration'])
fast_pi2 = pulselib.MW_IQmod_pulse(
'MW pi2 pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=self.params['MW_pulse_mod_risetime'],
frequency=self.params['fast_pi2_mod_frq'],
amplitude=self.params['fast_pi2_amp'],
length=self.params['fast_pi2_duration'])
sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar)
adwin_sync = pulse.SquarePulse(channel='adwin_sync',
length=10e-6,
amplitude=2)
sync_elt.append(adwin_sync)
# electron manipulation elements
elts = []
seq = pulsar.Sequence('Pi2 Calibration')
for i in range(self.params['pts_awg']):
e = element.Element('Pi2_Pi-{}'.format(i),
pulsar=qt.pulsar,
global_time=True)
e.append(T)
e.append(
pulse.cp(fast_pi2, amplitude=self.params['pi2_sweep_amps'][i]))
e.append(pulse.cp(TIQ, length=200e-9))
e.append(pulse.cp(fast_pi))
e.append(T)
elts.append(e)
seq.append(name='MBIa-%d' % i,
wfname=mbi_elt.name,
trigger_wait=True,
goto_target='MBIa-%d' % i,
jump_target=e.name)
seq.append(name='Pi2_Pi-{}'.format(i),
wfname=e.name,
trigger_wait=True)
seq.append(name='synca-{}'.format(i), wfname=sync_elt.name)
e = element.Element('Pi2-{}'.format(i),
pulsar=qt.pulsar,
global_time=True)
e.append(T)
e.append(
pulse.cp(fast_pi2, amplitude=self.params['pi2_sweep_amps'][i]))
e.append(pulse.cp(TIQ, length=200e-9))
e.append(T)
elts.append(e)
seq.append(name='MBIb-%d' % i,
wfname=mbi_elt.name,
trigger_wait=True,
goto_target='MBIb-%d' % i,
jump_target=e.name)
seq.append(name='Pi2-{}'.format(i),
wfname=e.name,
trigger_wait=True)
seq.append(name='syncb-{}'.format(i), wfname=sync_elt.name)
if upload:
qt.pulsar.upload(mbi_elt, sync_elt, *elts)
qt.pulsar.program_sequence(seq)
def generate_sequence(self):
SP_A_pulse = pulse.SquarePulse(channel='AOM_Newfocus', amplitude=1.0)
SP_E_pulse = pulse.SquarePulse(channel='EOM_AOM_Matisse',
amplitude=1.0)
RO_pulse = pulse.SquarePulse(channel='EOM_AOM_Matisse', amplitude=1.0)
T = pulse.SquarePulse(channel='AOM_Newfocus',
length=self.params['wait_length'],
amplitude=0)
adwin_trigger_pulse = pulse.SquarePulse(channel='adwin_sync',
length=5e-6,
amplitude=2)
PQ_sync = pulse.SquarePulse(channel='sync',
length=self.params['pq_sync_length'],
amplitude=1.0)
MW_pi = pulselib.HermitePulse_Envelope(
'Hermite pi-pulse',
MW_channel='MW_Imod',
PM_channel='MW_pulsemod',
second_MW_channel='MW_Qmod',
amplitude=self.params['Hermite_pi_amp'],
length=self.params['Hermite_pi_length'],
PM_risetime=self.params['MW_pulse_mod_risetime'],
pi2_pulse=False)
elements = []
finished_element = element.Element('finished', pulsar=qt.pulsar)
finished_element.append(adwin_trigger_pulse)
elements.append(finished_element)
seq = pulsar.Sequence('FastSSRO')
for i in range(self.params['pts'] / 2):
e0 = element.Element('SSRO-ms0-{}'.format(i), pulsar=qt.pulsar)
e0.append(pulse.cp(T, length=1e-6))
e0.append(PQ_sync)
e0.append(T)
e0.append(
pulse.cp(SP_A_pulse,
length=self.params['A_SP_durations_AWG'][i]))
e0.append(T)
e0.append(
pulse.cp(RO_pulse,
length=self.params['pi_pulse_time'][i],
amplitude=self.params['E_RO_voltages_AWG'][i]))
e0.append(pulse.cp(T, length=self.params['wait_length_MW']))
e0.append(MW_pi)
e0.append(pulse.cp(T, length=self.params['wait_length_MW']))
e0.append(
pulse.cp(RO_pulse,
length=self.params['E_RO_durations_AWG'][i] -
self.params['pi_pulse_time'][i],
amplitude=self.params['E_RO_voltages_AWG'][i]))
e0.append(T)
elements.append(e0)
seq.append(name='SSRO-ms0-{}'.format(i),
wfname=e0.name,
trigger_wait=True)
seq.append(name='finished-ms0-{}'.format(i),
wfname=finished_element.name,
trigger_wait=False)
e1 = element.Element('SSRO-ms1-{}'.format(i), pulsar=qt.pulsar)
e1.append(pulse.cp(T, length=1e-6))
e1.append(PQ_sync)
e1.append(T)
e1.append(
pulse.cp(SP_E_pulse,
length=self.params['E_SP_durations_AWG'][i],
amplitude=self.params['E_SP_voltages_AWG'][i]))
e1.append(T)
e1.append(
pulse.cp(RO_pulse,
length=self.params['pi_pulse_time'][i],
amplitude=self.params['E_RO_voltages_AWG'][i]))
e1.append(pulse.cp(T, length=self.params['wait_length_MW']))
e1.append(MW_pi)
e1.append(pulse.cp(T, length=self.params['wait_length_MW']))
e1.append(
pulse.cp(RO_pulse,
length=self.params['E_RO_durations_AWG'][i] -
self.params['pi_pulse_time'][i],
amplitude=self.params['E_RO_voltages_AWG'][i]))
e1.append(T)
elements.append(e1)
seq.append(name='SSRO-ms1-{}'.format(i),
wfname=e1.name,
trigger_wait=True)
seq.append(name='finished-ms1-{}'.format(i),
wfname=finished_element.name,
trigger_wait=False)
qt.pulsar.program_awg(seq, *elements)
def generate_sequence(self):
#define the pulses
sq_p7889=pulse.SquarePulse(channel='p7889_start',name='p7889_square',amplitude=1)
sq_p7889.length=1e-6 #is the length of the p7889 start pulse a problem?? ## changed from 2e-6 to 1e-6
sq_AOMpulse=pulse.SquarePulse(channel='AOM_Green',name='Green_square')
sq_AOMpulse.amplitude=1 #sets the marker high
sq_AOMpulse.length=self.params['GreenAOM_pulse_length']
wait = pulse.SquarePulse(channel='AOM_Green',name='Green_square')
wait.amplitude = 0
wait.length=2e-6
X = pulselib.MW_IQmod_pulse('Rabi_MW_pulse',
I_channel='MW_Imod', Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
amplitude = self.params['ssbmod_amplitude'],
frequency = self.params['ssbmod_frequency'],
PM_risetime = self.params['MW_pulse_mod_risetime'])
#need one spin polarization pulse at the beginning.
init=element.Element('initialize',pulsar=qt.pulsar)
init.add(pulse.cp(sq_AOMpulse,length=1e-6,amplitude=0),name='wait')
init.add(sq_AOMpulse,name='init',refpulse='wait')
init.add(wait,name='init_wait',refpulse='init')
#generate a list of pulse elements. One for each modulation freuqency
elements=[]
elements.append(init)
# old sequence MJD
# e=element.Element('Rabi_length-%d' % k,pulsar=qt.pulsar)
# e.add(pulse.cp(wait,length=2e-6,amplitude=0),name='wait_int')
# e.add(X(length=t),name='MWpulse',refpulse='wait_int',refpoint='end')
# e.add(sq_p7889,name='p7889Start',refpulse='MWpulse',refpoint='end')
# e.add(sq_AOMpulse,start=1e-6,name='GreenLight',refpulse='p7889Start',refpoint='end')
# e.add(pulse.cp(sq_AOMpulse,length=50e-9,amplitude=0),name='wait',refpulse='GreenLight')
# elements.append(e)
for k,t in enumerate(self.params['sweep_pts']/1.e6):
e=element.Element('Rabi_length-%d' % k,pulsar=qt.pulsar)
e.add(pulse.cp(wait,length=-1e-6,amplitude=0),name='wait_int')
e.add(X(length=t),name='MWpulse',refpulse='wait_int',refpoint='end')
e.add(sq_p7889,name='p7889Start',start=0.4e-6,refpulse='MWpulse',refpoint='end')
e.add(sq_AOMpulse,start=2.1e-6,name='GreenLight',refpulse='p7889Start',refpoint='start')
elements.append(e)
# was 1.7 before the AOM greenlight pulse
# was 0.8 before the p7889Start
# wait length before was 1 e-6 but because there is a false delay in the green line (i guess, it doesn't work)
# wait length adjusted was -1.6e-6
# Start p7889start adjusted 0.4e-6
# Greenlight start adjusted 2.1e-6
#insert a delay at the end of the sequence such that all outputs of the AWG stay low.
end=element.Element('ending delay',pulsar=qt.pulsar)
end.add(pulse.cp(sq_AOMpulse,length=1e-6,amplitude=0),name='delay')
elements.append(end)
#create a sequence from the gathered elements
seq=pulsar.Sequence('RabiOsci sequence p7889')
for e in elements:
seq.append(name=e.name,wfname=e.name)
#upload to AWG
qt.pulsar.program_awg(seq,*elements)
def generate_sequence(self, upload=True, debug=False):
### define basic pulses/times ###
# pi-pulse, needs different pulses for ms=-1 and ms=+1 transitions in the future.
X = hermite_Xpi(self)
# Wait-times
T = pulse.SquarePulse(channel='MW_Imod',
name='delay',
length=self.params['wait_time_repeat_element'] *
1e-6,
amplitude=0.)
T_before_p = pulse.SquarePulse(
channel='MW_Imod', name='delay', length=100e-9,
amplitude=0.) #the unit waittime is 10e-6 s
T_after_p = pulse.SquarePulse(
channel='MW_Imod',
name='delay',
length=(1000. - self.params['Hermite_fast_pi_duration'] * 1e9) *
1e-9,
amplitude=0.
) # waiting time chosen s.t. T_before_p + X + T_after_p = 1 us
# Trigger pulse
Trig = pulse.SquarePulse(channel='adwin_sync',
length=5e-6,
amplitude=2)
### create the elements/waveforms from the basic pulses ###
list_of_elements = []
#Pi-pulse element/waveform
e = element.Element('Pi_pulse', pulsar=qt.pulsar, global_time=True)
e.append(T_before_p)
e.append(pulse.cp(X))
e.append(T_after_p)
list_of_elements.append(e)
#Wait time element/waveform
e = element.Element('T1_wait_time', pulsar=qt.pulsar, global_time=True)
e.append(T)
list_of_elements.append(e)
#Trigger element/waveform
e = element.Element('ADwin_trigger',
pulsar=qt.pulsar,
global_time=True)
e.append(Trig)
list_of_elements.append(e)
### create sequences from the elements/waveforms ###
seq = pulsar.Sequence('ElectronT1_sequence')
for i in range(len(self.params['wait_times'])):
if self.params['wait_times'][i] / self.params[
'wait_time_repeat_element'] != 0:
if self.params['T1_initial_state'] == 'ms=-1':
seq.append(name='Init_Pi_pulse_%d' % i,
wfname='Pi_pulse',
trigger_wait=True)
seq.append(name='ElectronT1_wait_time_%d' % i,
wfname='T1_wait_time',
trigger_wait=False,
repetitions=self.params['wait_times'][i] /
self.params['wait_time_repeat_element'])
if self.params['T1_readout_state'] == 'ms=-1':
seq.append(name='Readout_Pi_pulse_%d' % i,
wfname='Pi_pulse',
trigger_wait=False)
seq.append(name='ElectronT1_ADwin_trigger_%d' % i,
wfname='ADwin_trigger',
trigger_wait=False)
#elif self.params['T1_initial_state'] == 'ms=+1':
else:
seq.append(name='ElectronT1_wait_time_%d' % i,
wfname='T1_wait_time',
trigger_wait=True,
repetitions=self.params['wait_times'][i] /
self.params['wait_time_repeat_element'])
if self.params['T1_readout_state'] == 'ms=-1':
seq.append(name='Readout_Pi_pulse_%d' % i,
wfname='Pi_pulse',
trigger_wait=False)
seq.append(name='ElectronT1_ADwin_trigger_%d' % i,
wfname='ADwin_trigger',
trigger_wait=False)
else:
e = element.Element('Wait_time_%d' % i,
pulsar=qt.pulsar,
global_time=True)
e.append(
pulse.cp(T, length=self.params['wait_times'][i] * 1e-6))
if self.params['T1_initial_state'] == 'ms=-1' and self.params[
'T1_readout_state'] == 'ms=0':
seq.append(name='Init_Pi_pulse_%d' % i,
wfname='Pi_pulse',
trigger_wait=True)
seq.append(name='Wait_time_%d' % i,
wfname='Wait_time_%d' % i,
trigger_wait=False)
seq.append(name='ElectronT1_ADwin_trigger_%d' % i,
wfname='ADwin_trigger',
trigger_wait=False)
elif self.params['T1_initial_state'] == 'ms=0' and self.params[
'T1_readout_state'] == 'ms=-1':
seq.append(name='Wait_time_%d' % i,
wfname='Wait_time_%d' % i,
trigger_wait=False)
seq.append(name='Readout_Pi_pulse_%d' % i,
wfname='Pi_pulse',
trigger_wait=True)
seq.append(name='ElectronT1_ADwin_trigger_%d' % i,
wfname='ADwin_trigger',
trigger_wait=False)
#elif self.params['T1_initial_state'] == 'ms=+1' and self.params['T1_readout_state'] == 'ms=0':
#elif self.params['T1_readout_state'] == 'ms=+1' and self.params['T1_initial_state'] == 'ms=0':
else:
seq.append(name='ElectronT1_ADwin_trigger_%d' % i,
wfname='ADwin_trigger',
trigger_wait=True)
# upload the waveforms to the AWG
if upload:
qt.pulsar.program_awg(seq, *list_of_elements, debug=debug)
def generate_sequence(self):
#define the pulses
sq_p7889=pulse.SquarePulse(channel='p7889_start',name='p7889_square',amplitude=1)
sq_p7889.length=2e-6 #that is pretty long, can be reduced in the future.
wait = pulse.SquarePulse(channel='AOM_Green',name='Green_square')
wait.amplitude = 0
wait.length=2e-6
sq_AOMpulse=pulse.SquarePulse(channel='AOM_Green',name='Green_square')
sq_AOMpulse.amplitude=1 #just set the marker high
sq_AOMpulse.length=self.params['GreenAOM_pulse_length']
X = pulselib.MW_IQmod_pulse('Weak pi-pulse',
I_channel='MW_Imod', Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
amplitude = self.params['ssbmod_amplitude'],
length = self.params['MW_pulse_length'],
PM_risetime = self.params['MW_pulse_mod_risetime'])
#need one spin polarization pulse at the beginning.
init=element.Element('initialize',pulsar=qt.pulsar)
init.add(pulse.cp(sq_AOMpulse,length=1e-6,amplitude=0),name='wait')
init.add(sq_AOMpulse,name='init',refpulse='wait')
#generate a list of pulse elements. One for each modulation freuqency
elements=[]
elements.append(init)
for k,f in enumerate(np.linspace(self.params['ssbmod_frq_start'],self.params['ssbmod_frq_stop'],self.params['pts'])):
e=element.Element('DarkESR_frq-%d' % k,pulsar=qt.pulsar)
e.add(pulse.cp(wait,length=-1e-6,amplitude=0),name='wait_int')
e.add(X(frequency=f),name='MWpulse',refpulse='wait_int',refpoint='end')
e.add(sq_p7889,name='p7889Start',start=0.4e-6,refpulse='MWpulse',refpoint='end')
e.add(sq_AOMpulse,name='GreenLight',start=2.1e-6,refpulse='p7889Start',refpoint='start')
elements.append(e)
# was 1.7 before the AOM greenlight pulse
# was 0.8 before the p7889Start
# wait length before was 1 e-6 but because there is a false delay in the green line (i guess, it doesn't work)
# wait length adjusted was -1.6e-6
# Start p7889start adjusted 0.4e-6
# Greenlight start adjusted 2.1e-6
#insert a delay at the end of the sequence such that all outputs of the AWG stay low.
end=element.Element('ending delay',pulsar=qt.pulsar)
end.add(pulse.cp(sq_AOMpulse,length=1e-6,amplitude=0),name='delay')
elements.append(end)
#create a sequence from the gathered elements
seq=pulsar.Sequence('DarkESR sequence p7889')
for e in elements:
seq.append(name=e.name,wfname=e.name)
#upload to AWG
qt.pulsar.program_awg(seq,*elements)
def generate_sequence(self, upload=True, debug=False):
# MBI element
mbi_elt = self._MBI_element()
# electron manipulation pulses
T = pulse.SquarePulse(channel='MW_pulsemod', length=2e-6, amplitude=0)
# CORPSE_pi = pulselib.IQ_CORPSE_pi_pulse('msm1 CORPSE pi-pulse',
# I_channel = 'MW_Imod',
# Q_channel = 'MW_Qmod',
# PM_channel = 'MW_pulsemod',
# PM_risetime = self.params['MW_pulse_mod_risetime'],
# frequency = self.params['msm1_CORPSE_pi_mod_frq'],
# amplitude = self.params['msm1_CORPSE_pi_amp'],
# length_60 = self.params['msm1_CORPSE_pi_60_duration'],
# length_m300 = self.params['msm1_CORPSE_pi_m300_duration'],
# length_420 = self.params['msm1_CORPSE_pi_420_duration'])
SP = pulse.SquarePulse(channel='AOM_Newfocus',
length=self.params['AWG_SP_duration'],
amplitude=self.params['AWG_SP_amplitude'])
pi2pi_m1 = pulselib.MW_IQmod_pulse(
'pi2pi pulse mI=-1',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
Sw_channel='MW_switch',
PM_risetime=self.params['MW_pulse_mod_risetime'],
frequency=self.params['pi2pi_mIm1_mod_frq'],
amplitude=self.params['pi2pi_mIm1_amp'],
length=self.params['pi2pi_mIm1_duration'])
X = pulselib.MW_IQmod_pulse(
'electron X-Pi-pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
Sw_channel='MW_switch',
frequency=self.params['AWG_MBI_MW_pulse_mod_frq'],
PM_risetime=self.params['MW_pulse_mod_risetime'],
Sw_risetime=self.params['MW_switch_risetime'],
length=self.params['fast_pi_duration'],
amplitude=self.params['fast_pi_amp'],
phase=self.params['X_phase'])
sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar)
adwin_sync = pulse.SquarePulse(channel='adwin_sync',
length=10e-6,
amplitude=2)
sync_elt.append(adwin_sync)
wait_1us = element.Element('1us_delay', pulsar=qt.pulsar)
wait_1us.append(pulse.cp(T, length=1e-6))
SP_elt = element.Element('SP_element', pulsar=qt.pulsar)
SP_elt.append(T, X, T, SP, T)
RO_elt = element.Element('RO_element', pulsar=qt.pulsar)
RO_elt.append(T, pi2pi_m1)
seq = pulsar.Sequence('N spin flips')
for i, r in enumerate(self.params['AWG_sequence_repetitions']):
seq.append(name='MBI-%d' % i,
wfname=mbi_elt.name,
trigger_wait=True,
goto_target='MBI-%d' % i,
jump_target='SP-{}'.format(i))
if r > 0:
seq.append(name='SP-{}'.format(i),
wfname=SP_elt.name,
trigger_wait=True,
repetitions=r)
else:
seq.append(name='SP-{}'.format(i),
wfname=wait_1us.name,
trigger_wait=True)
seq.append(name='RO-{}'.format(i), wfname=RO_elt.name)
seq.append(name='sync-{}'.format(i), wfname=sync_elt.name)
combined_list_of_elements = [
mbi_elt, sync_elt, wait_1us, SP_elt, RO_elt
]
# program AWG
if upload:
qt.pulsar.program_awg(seq, *combined_list_of_elements, debug=debug)
def generate_sequence(self, upload=True):
SP_A_pulse = pulse.SquarePulse(channel = 'AOM_Newfocus', amplitude = 1.0)
SP_E_pulse = pulse.SquarePulse(channel = 'EOM_AOM_Matisse', amplitude = 1.0)
RO_pulse = pulse.SquarePulse(channel = 'EOM_AOM_Matisse', amplitude = 1.0)
T = pulse.SquarePulse(channel = 'AOM_Newfocus', length = self.params['wait_length'], amplitude = 0)
adwin_trigger_pulse = pulse.SquarePulse(channel = 'adwin_sync', length = 5e-6, amplitude = 2)
PQ_sync = pulse.SquarePulse(channel = 'sync', length = self.params['pq_sync_length'], amplitude = 1.0)
MW_pi_pulse = pulselib.HermitePulse_Envelope('Hermite pi-pulse',
MW_channel='MW_Imod',
PM_channel='MW_pulsemod',
second_MW_channel='MW_Qmod',
amplitude = self.params['Hermite_pi_amp'],
length = self.params['Hermite_pi_length'],
PM_risetime = self.params['MW_pulse_mod_risetime'],
pi2_pulse = False)
elements = []
finished_element = element.Element('finished', pulsar = qt.pulsar)
finished_element.append(adwin_trigger_pulse)
elements.append(finished_element)
seq = pulsar.Sequence('FastSSRO')
for i in range(self.params['pts']/2):
e0 = element.Element('SSRO-ms0-{}'.format(i), pulsar = qt.pulsar)
e0.append(pulse.cp(T,length=3e-6))
e0.append(PQ_sync)
e0.append(T)
e0.append(pulse.cp(SP_A_pulse, length=self.params['A_SP_durations_AWG'][i]))
e0.append(T)
e0.append(pulse.cp(RO_pulse, length=self.params['E_RO_durations_AWG'][i],
amplitude=self.params['E_RO_voltages_AWG'][i]))
e0.append(T)
elements.append(e0)
seq.append(name='SSRO-ms0-{}'.format(i), wfname=e0.name, trigger_wait=True)
seq.append(name='finished-ms0-{}'.format(i), wfname=finished_element.name, trigger_wait=False)
e1 = element.Element('SSRO-ms1-{}'.format(i), pulsar = qt.pulsar)
e1.append(pulse.cp(T,length=3e-6))
e1.append(PQ_sync)
e1.append(T)
if self.params['init_with_MW'] : #SP on ms=0 transition, then apply a MW pi pulse to transfer population into ms=-1
e1.append(pulse.cp(SP_A_pulse, length=self.params['A_SP_durations_AWG'][i]))
e1.append(T)
e1.append(MW_pi_pulse)
self.params['E_SP_durations_AWG'][i] = self.params['A_SP_durations_AWG'][i] + self.params['wait_length'] + self.params['Hermite_pi_length']
else:
e1.append(pulse.cp(SP_E_pulse, length=self.params['E_SP_durations_AWG'][i],
amplitude=self.params['E_SP_voltages_AWG'][i]))
e1.append(T)
e1.append(pulse.cp(RO_pulse, length=self.params['E_RO_durations_AWG'][i],
amplitude=self.params['E_RO_voltages_AWG'][i]))
e1.append(T)
elements.append(e1)
seq.append(name='SSRO-ms1-{}'.format(i), wfname=e1.name, trigger_wait=True)
seq.append(name='finished-ms1-{}'.format(i), wfname=finished_element.name, trigger_wait=False)
if upload:
if upload=='old_method':
qt.pulsar.upload(*elements)
qt.pulsar.program_sequence(seq)
else:
qt.pulsar.program_awg(seq,*elements)
def pulse_defs_lt4(msmt):
# a waiting pulse on the MW pulsemod channel
msmt.T = pulse.SquarePulse(channel='MW_pulsemod',
length=50e-9,
amplitude=0)
msmt.TIQ = pulse.SquarePulse(channel='MW_Imod', length=10e-9, amplitude=0)
msmt.T_sync = pulse.SquarePulse(channel='sync', length=50e-9, amplitude=0)
# some not yet specified pulse on the electron
msmt.e_pulse = pulselib.MW_IQmod_pulse(
'MW pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=msmt.params['MW_pulse_mod_risetime'])
msmt.MW_pi = pulselib.HermitePulse_Envelope(
'Hermite pi-pulse',
MW_channel='MW_Imod',
PM_channel='MW_pulsemod',
second_MW_channel='MW_Qmod',
amplitude=msmt.params['MW_pi_amp'],
length=msmt.params['MW_pi_duration'],
PM_risetime=msmt.params['MW_pulse_mod_risetime'],
pi2_pulse=False)
msmt.MW_pi2 = pulselib.HermitePulse_Envelope(
'Hermite pi/2-pulse',
MW_channel='MW_Imod',
PM_channel='MW_pulsemod',
second_MW_channel='MW_Qmod',
amplitude=msmt.params['MW_pi2_amp'],
length=msmt.params['MW_pi2_duration'],
PM_risetime=msmt.params['MW_pulse_mod_risetime'],
pi2_pulse=True)
msmt.MW_BellAngle = pulselib.HermitePulse_Envelope(
'Hermite pi/2-pulse',
MW_channel='MW_Imod',
PM_channel='MW_pulsemod',
second_MW_channel='MW_Qmod',
amplitude=msmt.params['MW_pi2_amp'] *
msmt.params['MW_BellStateFactor'],
length=msmt.params['MW_pi2_duration'],
PM_risetime=msmt.params['MW_pulse_mod_risetime'],
pi2_pulse=True)
msmt.MW_RND_I = pulselib.HermitePulse_Envelope(
'Hermite RND-pulse-I',
MW_channel='MW_Imod',
PM_channel='MW_pulsemod',
amplitude=msmt.params['MW_RND_amp_I'],
length=msmt.params['MW_RND_duration_I'],
PM_risetime=msmt.params['MW_pulse_mod_risetime'],
pi2_pulse=True)
msmt.MW_RND_Q = pulselib.HermitePulse_Envelope(
'Hermite RND-pulse-Q',
MW_channel='MW_Qmod',
PM_channel='MW_pulsemod',
amplitude=msmt.params['MW_RND_amp_Q'],
length=msmt.params['MW_RND_duration_Q'],
PM_risetime=msmt.params['MW_pulse_mod_risetime'],
pi2_pulse=True)
msmt.eom_pulse = eom_pulses.OriginalEOMAOMPulse(
'Eom Aom Pulse',
eom_channel='EOM_Matisse',
aom_channel='EOM_AOM_Matisse',
eom_pulse_duration=msmt.params['eom_pulse_duration'],
eom_off_duration=msmt.params['eom_off_duration'],
eom_off_amplitude=msmt.params['eom_off_amplitude'],
eom_pulse_amplitude=msmt.params['eom_pulse_amplitude'],
eom_overshoot_duration1=msmt.params['eom_overshoot_duration1'],
eom_overshoot1=msmt.params['eom_overshoot1'],
eom_overshoot_duration2=msmt.params['eom_overshoot_duration2'],
eom_overshoot2=msmt.params['eom_overshoot2'],
aom_risetime=msmt.params['aom_risetime'],
aom_amplitude=msmt.params['aom_amplitude'])
msmt.RND_halt_off_pulse = pulse.SquarePulse(
channel='RND_halt', amplitude=2.0, length=msmt.params['RND_duration'])
### synchronizing, etc
msmt.adwin_trigger_pulse = pulse.SquarePulse(channel='adwin_sync',
length=5e-6,
amplitude=2)
msmt.sync = pulse.SquarePulse(channel='sync', length=50e-9, amplitude=1.0)
msmt.SP_pulse = pulse.SquarePulse(channel='AOM_Newfocus', amplitude=1.0)
msmt.RO_pulse = pulse.SquarePulse(channel='EOM_AOM_Matisse', amplitude=0.0)
msmt.yellow_pulse = pulse.SquarePulse(channel='AOM_Yellow', amplitude=1.0)
msmt.plu_gate = pulse.SquarePulse(channel='plu_sync',
amplitude=1.0,
length=msmt.params['PLU_gate_duration'])
return True
def generate_sequence(self, upload=True, **kw):
# electron manipulation pulses
init_ms1 = kw.pop('init_ms1', False)
T = pulse.SquarePulse(channel='MW_pulsemod', length=10e-9, amplitude=0)
CORPSE_pi = self.CORPSE_pi
CORPSE_pi2 = self.CORPSE_pi2
# elts includes wait_rest_elts and second_pi2_elts, and if init_ms1: CORPSE_shelv_elt
elts = []
if init_ms1:
CORPSE_shelving_elt = element.Element('CORPSE_shelving_elt',
pulsar=qt.pulsar,
global_time=True,
time_offset=0.)
CORPSE_shelving_elt.append(pulse.cp(T, length=400e-9))
CORPSE_shelving_elt.append(
pulse.cp(CORPSE_pi,
amplitude=self.params['CORPSE_pi_shelv_amp']))
CORPSE_shelving_elt.append(pulse.cp(T, length=400e-9))
elts.append(CORPSE_shelving_elt)
# around each pulse I make an element with length 1600e-9;
# the centre of the pulse is in the centre of the element.
# this helps me to introduce the right waiting times,
# counting from centre of the pulses
CORPSE_pi_wait_length = 800e-9 - (
CORPSE_pi.length - 2 * self.params['MW_pulse_mod_risetime']) / 2
CORPSE_pi2_wait_length = 800e-9 - (
CORPSE_pi2.length - 2 * self.params['MW_pulse_mod_risetime']) / 2
first_pi2_elt = element.Element('first_pi2_elt',
pulsar=qt.pulsar,
global_time=True,
time_offset=0.)
first_pi2_elt.append(pulse.cp(T, length=100e-9))
first_pi2_elt.append(
pulse.cp(CORPSE_pi2, amplitude=self.params['CORPSE_pi2_amp']))
first_pi2_elt.append(pulse.cp(T, length=CORPSE_pi2_wait_length))
wait_1us = element.Element('1us_delay',
pulsar=qt.pulsar,
global_time=True)
wait_1us.append(pulse.cp(T, length=1e-6))
sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar)
adwin_sync = pulse.SquarePulse(channel='adwin_sync',
length=10e-6,
amplitude=2)
sync_elt.append(adwin_sync)
# sequence
seq = pulsar.Sequence('Dynamical decoupling sequence')
for i in range(self.params['pts']):
reduced_free_ev_time = self.params['free_evolution_times'][
i] - 800e-9 - 800e-9
# calculate how many waits of 1 us fit in the free evolution time (-1 repetition)
# this is twice the 800e-9 s that are the wrap-arounds of the pulses
delay_reps = np.floor(reduced_free_ev_time / 1e-6) - 2
#calculate how much wait time should be added to the above to fill the full free evolution time (+1 us to fill full elt)
rest_time = np.mod(reduced_free_ev_time, 1e-6) + 2e-6
wait_rest_elt = element.Element('wait_rest_elt-{}'.format(i),
pulsar=qt.pulsar,
global_time=True)
wait_rest_elt.append(pulse.cp(T, length=rest_time))
elts.append(wait_rest_elt)
if init_ms1:
seq.append(name='CORPSE_shelving-{}'.format(i),
wfname=CORPSE_shelving_elt.name,
trigger_wait=True)
seq.append(name='first_pi2-{}'.format(i),
wfname=first_pi2_elt.name)
else:
seq.append(name='first_pi2-{}'.format(i),
wfname=first_pi2_elt.name,
trigger_wait=True)
for j in range(self.params['multiplicity']):
#calculate the time offset for the CORPSE pulse element
# the case j>0 asks for adding extra wrap-around times,
# that are added to the CORPSE elements.
time_offset_CORPSE = first_pi2_elt.length() \
+ (2 * j + 1) * reduced_free_ev_time
if j > 0:
time_offset_CORPSE = time_offset_CORPSE \
+ (2 * j - 1) * 1600e-9 \
+ (j - 1) * self.params['extra_t_between_pulses'][i]
# 1600e-9 is free_ev_time - reduced_free_ev_time
CORPSE_elt = element.Element('CORPSE_elt-{}-{}'.format(i, j),
pulsar=qt.pulsar,
global_time=True,
time_offset=time_offset_CORPSE)
# append a longer waiting time for the not first CORPSE pulse, to get the right evolution time
if j == 0:
CORPSE_elt.append(pulse.cp(T,
length=CORPSE_pi_wait_length))
else:
# add an extra 1600e-9, that would otherwise be the wrap-around of a pulse
# also add the possibility to make the time between pi pulses different,
# this could correct for where the centre of the pi/2 pulse is.
CORPSE_elt.append(
pulse.cp(T,
length=CORPSE_pi_wait_length + 1600e-9 +
self.params['extra_t_between_pulses'][i]))
CORPSE_elt.append(
pulse.cp(CORPSE_pi,
amplitude=self.params['CORPSE_pi_amp'],
phase=self.params['CORPSE_pi_phases'][j]))
CORPSE_elt.append(pulse.cp(T, length=CORPSE_pi_wait_length))
elts.append(CORPSE_elt)
seq.append(name='wait1-{}-{}'.format(i, j),
wfname=wait_1us.name,
repetitions=delay_reps)
seq.append(name='wait_rest1-{}-{}'.format(i, j),
wfname=wait_rest_elt.name)
seq.append(name=CORPSE_elt.name + '-{}-{}'.format(i, j),
wfname=CORPSE_elt.name)
seq.append(name='wait2-{}-{}'.format(i, j),
wfname=wait_1us.name,
repetitions=delay_reps)
seq.append(name='wait_rest2-{}-{}'.format(i, j),
wfname=wait_rest_elt.name)
# calculate the right time offset, that is crucial for the right phase.
time_offset_pi2_2 = first_pi2_elt.length() \
+ (2 * self.params['multiplicity'] - 1) * 1600e-9 \
+ self.params['multiplicity'] * 2 * reduced_free_ev_time \
+ (self.params['multiplicity'] - 1 ) * self.params['extra_t_between_pulses'][i]
second_pi2_elt = element.Element('second_pi2_elt-{}'.format(i),
pulsar=qt.pulsar,
global_time=True,
time_offset=time_offset_pi2_2)
second_pi2_elt.append(
pulse.cp(T,
length=CORPSE_pi2_wait_length +
self.params['extra_ts_before_pi2'][i]))
second_pi2_elt.append(
pulse.cp(CORPSE_pi2,
amplitude=self.params['CORPSE_pi2_2_amp'],
phase=self.params['phases'][i]))
second_pi2_elt.append(pulse.cp(T, length=100e-9))
elts.append(second_pi2_elt)
seq.append(name='second_pi2-{}'.format(i),
wfname=second_pi2_elt.name)
seq.append(name='sync-{}'.format(i), wfname=sync_elt.name)
# program AWG
if upload:
qt.pulsar.upload(sync_elt, wait_1us, first_pi2_elt, *elts)
qt.pulsar.program_sequence(seq)
import qt
from measurement.lib.pulsar import pulse, pulselib, element, pulsar
awg = qt.instruments['AWG']
pts=1#self._pixel_pts
p_wait = pulse.SquarePulse('sync', length=10e-6, amplitude = 0)
p_sync = pulse.SquarePulse('sync', length=200e-9, amplitude = 1)
elts=[]
s= pulsar.Sequence('test_flim_seq')
e=element.Element('sync_elt', pulsar=qt.pulsar)
e.add(p_sync, start = 200e-9)
e.add(p_wait)
elts.append(e)
for i in range(pts):
s.append(name = 'sync_init'+str(i),
wfname = e.name,
trigger_wait = 0,
repetitions = 1)
qt.pulsar.program_awg(s,e)
# awg.start()
# i=0
# awg_ready = False
# while not awg_ready and i<100:
# if (msvcrt.kbhit() and (msvcrt.getch() == 'x')):
# raise Exception('User abort while waiting for AWG')
# try:
# if awg.get_state() == 'Waiting for trigger':
# qt.msleep(1)
# awg_ready = True
def generate_sequence(self, upload=True, debug=False):
# MBI element
mbi_elt = self._MBI_element()
ro_elt = self._RO_element()
# electron manipulation pulses
T = pulse.SquarePulse(channel='MW_pulsemod',
length=1000e-9,
amplitude=0)
X = pulselib.MW_IQmod_pulse(
'MBI MW pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
frequency=self.params['AWG_MBI_MW_pulse_ssbmod_frq'],
amplitude=self.params['AWG_MBI_MW_pulse_amp'],
length=self.params['AWG_MBI_MW_pulse_duration'],
PM_risetime=self.params['MW_pulse_mod_risetime'])
adwin_sync = pulse.SquarePulse(channel='adwin_sync',
length = (self.params['AWG_to_adwin_ttl_trigger_duration'] \
+ self.params['AWG_wait_for_adwin_MBI_duration']),
amplitude = 2)
# # define the necessary pulses
# T = pulse.SquarePulse(channel='MW_pulsemod',
# length = 100e-9, amplitude = 0)
# X = pulselib.MW_IQmod_pulse('MBI MW pulse',
# I_channel = 'MW_Imod', Q_channel = 'MW_Qmod',
# PM_channel = 'MW_pulsemod',
# frequency = self.params['AWG_MBI_MW_pulse_ssbmod_frq'],
# amplitude = self.params['AWG_MBI_MW_pulse_amp'],
# length = self.params['AWG_MBI_MW_pulse_duration'],
# PM_risetime = self.params['MW_pulse_mod_risetime'])
# # the actual element
# ro_element = element.Element(name, pulsar=qt.pulsar)
# ro_element.append(T)
# ro_element.append(X)
N_pulse = pulselib.RF_erf_envelope(
channel='RF',
amplitude=self.params['RF_pulse_amp'],
frequency=self.params['RF_pulse_frqs'])
# X = pulselib.HermitePulse_Envelope_IQ('MW pulse',
# I_channel = 'MW_Imod',
# Q_channel = 'MW_Qmod',
# PM_channel = 'MW_pulsemod',
# PM_risetime = self.params['MW_pulse_mod_risetime'] )
adwin_sync = pulse.SquarePulse(
channel='adwin_sync',
length=self.params['AWG_to_adwin_ttl_trigger_duration'],
amplitude=2)
# electron manipulation elements
elts = []
for i in range(self.params['pts']):
e = element.Element('RF_pt-%d' % i,
pulsar=qt.pulsar,
global_time=True)
e.append(pulse.cp(T, length=500e-9))
e.append(
pulse.cp(N_pulse,
length=self.params['RF_pulse_length'][i],
frequency=self.params['RF_pulse_frqs']))
e.append(pulse.cp(T, length=500e-9))
# for j in range(self.params['MW_pulse_multiplicities'][i]):
# e.append(
# pulse.cp(X,
# frequency = self.params['MW_pulse_mod_frqs'][i],
# amplitude = self.params['MW_pulse_amps'][i],
# length = self.params['MW_pulse_durations'][i]))
# e.append(
# pulse.cp(T, length=self.params['MW_pulse_delays'][i]))
#e.append(adwin_sync)
elts.append(e)
# gate_seq = []
# for pt in range(self.params['pts']):
# rabi_pulse = DD.Gate('Rabi_pulse_'+str(pt),'RF_pulse',
# length = self.params['RF_pulse_durations'][pt],
# RFfreq = self.params['RF_pulse_frqs'][pt],
# amplitude = self.params['RF_pulse_amps'][pt])
# gate_seq.extend([rabi_pulse])
# print 'Gate_seq', gate_seq
# gate_seq = DD.NitrogenRabiWithDirectRF.generate_AWG_elements(gate_seq,pt) # this will use resonance = 0 by default in
# ### Convert elements to AWG sequence and add to combined list
# list_of_elements, seq2 = DD.combine_to_AWG_sequence(gate_seq, explicit=True)
# sequence
seq = pulsar.Sequence('MBI Electron Rabi sequence')
for i, e in enumerate(elts):
seq.append(name='MBI-%d' % i,
wfname=mbi_elt.name,
trigger_wait=True,
goto_target='MBI-%d' % i,
jump_target=e.name)
seq.append(name=e.name, wfname=e.name, trigger_wait=True) #True
seq.append(name='RO_pt-%d' % i,
wfname=ro_elt.name,
trigger_wait=False)
# seq.append(name = 'RO-%d' % i, wfname = mbi_elt.name,
# trigger_wait = False) ## According to Norbert the trigger wait time should be set to False.
## This is implemented at the beginning of the MBI because it is waiting for a CR check from the adwin.
## For the readout this doesn't have to be implemented because it is deterministic.
print 'MBI at', self.params['AWG_MBI_MW_pulse_ssbmod_frq']
# print 'MW rotations at', self.params['MW_pulse_mod_frqs'][i]
# program AWG
if upload:
#qt.pulsar.upload(mbi_elt, *elts)
qt.pulsar.program_awg(seq, mbi_elt, ro_elt, *elts, debug=debug)
execfile(qt.reload_current_setup)
import msvcrt, time
import numpy as np
from measurement.lib.pulsar import pulse, pulselib, element, pulsar
p_start = pulse.SquarePulse('p7889_start', length=10e-9, amplitude = 1)
p_stop = pulse.SquarePulse('p7889_stop', length=10e-9, amplitude = 1)
p_wait = pulse.SquarePulse('p7889_start', length=100e-6, amplitude = 0)
e=element.Element('test_p7889_elt', pulsar=qt.pulsar)
#e.append(T)
e.add(p_start, start = 100e-9, name = 'start')
e.add(p_stop, start=1e-9, refpulse = 'start')
e.add(p_stop, start=30e-9, refpulse = 'start')
e.add(p_stop, start=100e-9, refpulse = 'start')
e.append(p_wait)
e.print_overview()
s= pulsar.Sequence('test_p7889_seq')
s.append(name = 'test_p7889_seq_1',
wfname = e.name,
trigger_wait = 0)
qt.pulsar.upload(e)
qt.pulsar.program_sequence(s)
qt.instruments['p7889'].Start()
qt.msleep(0.5)
qt.instruments['AWG'].start()
def generate_sequence(self, upload=True, debug=False):
#configure the dephasing beam. power and AWG channel
dephasing_AOM_voltage = qt.instruments[
self.params['dephasing_AOM']].power_to_voltage(
self.params['laser_dephasing_amplitude'], controller='sec')
if dephasing_AOM_voltage > (
qt.instruments[self.params['dephasing_AOM']]).get_sec_V_max():
print 'Suggested power level would exceed V_max of the AOM driver.'
else:
#not sure if the secondary channel of an AOM can be obtained in this way?
channelDict = {
'ch2m1': 'ch2_marker1',
'ch2m2': 'ch2_marker2',
'ch4m1': 'ch4_marker1'
}
print 'AOM voltage', dephasing_AOM_voltage
self.params['Channel_alias'] = qt.pulsar.get_channel_name_by_id(
channelDict[qt.instruments[
self.params['dephasing_AOM']].get_sec_channel()])
qt.pulsar.set_channel_opt(self.params['Channel_alias'], 'high',
dephasing_AOM_voltage)
print self.params['Channel_alias']
# MBI element
mbi_elt = self._MBI_element()
# electron manipulation pulses
T = pulse.SquarePulse(name='syncpulse',
channel='MW_pulsemod',
length=1000e-9,
amplitude=0)
Dephasing = pulse.SquarePulse(channel=self.params['Channel_alias'],
length=1000e-9,
amplitude=dephasing_AOM_voltage)
X = ps.X_pulse(self)
try:
Pi_mw2 = ps.pi_pulse_MW2(self)
except:
print 'No parameters for second MW source found'
adwin_sync = pulse.SquarePulse(
channel='adwin_sync',
length=self.params['AWG_to_adwin_ttl_trigger_duration'],
amplitude=2)
# electron manipulation elements
elts = []
for i in range(self.params['pts']):
e = element.Element('ERamsey_pt-%d' % i,
pulsar=qt.pulsar,
global_time=True)
e.append(T)
try:
init_with_second_source = self.params[
'init_with_second_source']
init_in_zero = self.params['init_in_zero']
except:
print 'Cannot init. Parameter not defined?'
init_with_second_source = False
init_in_zero = False
if init_with_second_source:
e.append(
pulse.cp(Pi_mw2,
length=self.params['MW_pulse_durations'][i],
amplitude=self.params['MW_pulse_amps'][i]))
elif not init_in_zero:
e.append(
pulse.cp(X,
frequency=self.params['MW_pulse_mod_frqs'][i],
amplitude=self.params['MW_pulse_amps'][i],
length=self.params['MW_pulse_durations'][i],
phase=self.params['MW_pulse_1_phases'][i]))
e.append(pulse.cp(T, length=self.params['MW_repump_delay1'][i]))
try: #MW2 used for repumping
pump_using_newfocus = self.params['pump_using_newfocus']
pump_using_repumper = self.params['pump_using_repumper']
except:
print 'pump using NF not defined, set default: True'
pump_using_newfocus = True
pump_using_repumper = False
if self.params['repumping_time'][i] != 0 and pump_using_newfocus:
e.append(
pulse.cp(Dephasing,
length=self.params['repumping_time'][i]))
if self.params['repumping_time'][i] != 0 and pump_using_repumper:
if pump_using_newfocus:
e.append(
pulse.cp(T, length=-self.params['repumping_time'][i]))
e.append(
pulse.cp(Dephasing,
channel='AOM_Repumper',
length=self.params['repumping_time'][i],
amplitude=qt.instruments['RepumperAOM'].
power_to_voltage(
self.params['repumper_amplitude'])))
try: #MW2 used for repumping
pump_using_MW2 = self.params['pump_using_MW2']
if pump_using_MW2 and (
self.params['pump_MW2_durations'][i] -
2 * self.params['pump_MW2_falltime'][i]) > 0:
#print self.params['pump_MW2_delay'][i]
e.append(
pulse.cp(T,
length=-self.params['repumping_time'][i] +
self.params['pump_MW2_delay'][i]))
e.append(
pulse.cp(
Pi_mw2,
length=(self.params['pump_MW2_durations'][i] -
2 * self.params['pump_MW2_falltime'][i]),
amplitude=self.params['MW2_pulse_amplitudes'][i]))
except:
print 'Exception in pump using MW2: ', sys.exc_info()
e.append(pulse.cp(T, length=self.params['MW_repump_delay2'][i]))
do_BB1 = False #Readout in pm1 basis
if do_BB1 and self.params['MW_pulse_2_amps'][i] != 0:
# necessary defs for BB1
T_BB1 = pulse.SquarePulse(
channel='adwin_sync',
name='Wait t',
length=5 * self.params['fast_pi_duration'] / 2 -
self.params['fast_pi2_duration'] / 2,
amplitude=0.)
# T_rep_BB1 = pulse.SquarePulse(channel='adwin_sync',name='Wait t-trep',
# length = t-t_rep-5*self.params['fast_pi_duration']/2, amplitude = 0.)
X_BB1 = pulse.cp(X,
length=self.params['BB1_fast_pi_duration'],
amplitude=self.params['BB1_fast_pi_amp'])
BB1_phase1 = pulse.cp(X_BB1,
phase=self.params['X_phase'] + 104.5)
BB1_phase2 = pulse.cp(X_BB1,
phase=self.params['X_phase'] + 313.4)
e.append(T_BB1)
e.append(BB1_phase1)
e.append(BB1_phase2)
e.append(BB1_phase2)
e.append(BB1_phase1)
e.append(X_BB1)
elif self.params['MW_pulse_2_amps'][i] != 0 and self.params[
'readout_with_second_source']:
e.append(
pulse.cp(Pi_mw2,
length=self.params['MW_pulse_2_durations'][i],
amplitude=self.params['MW_pulse_2_amps'][i]))
elif self.params['MW_pulse_2_amps'][i] != 0 and self.params[
'readout_with_second_source'] == False:
e.append(
pulse.cp(X,
frequency=self.params['MW_pulse_mod_frqs'][i],
amplitude=self.params['MW_pulse_2_amps'][i],
length=self.params['MW_pulse_2_durations'][i],
phase=self.params['MW_pulse_2_phases'][i]))
e.append(pulse.cp(T, length=2e-6))
# e.append(adwin_sync)
elts.append(e)
# sequence
# seq = pulsar.Sequence('MBI Electron Ramsey sequence')
# for i,e in enumerate(elts):
# seq.append(name = 'MBI-%d' % i, wfname = mbi_elt.name,
# trigger_wait = True, goto_target = 'MBI-%d' % i,
# jump_target = e.name)
# seq.append(name = e.name, wfname = e.name,
# trigger_wait = True)
# program AWG
# e = element.Element('Adwin_sync_pt-%d' % i, pulsar=qt.pulsar,
# global_time = True)
# e.append(adwin_sync)
# elts.append(e)
adwin_elt = element.Element('Adwin_sync',
pulsar=qt.pulsar,
global_time=True)
adwin_elt.append(adwin_sync)
# sequence
print len(elts)
seq = pulsar.Sequence('MBI Electron Ramsey sequence')
for i, e in enumerate(elts):
seq.append(name='MBI-%d' % i,
wfname=mbi_elt.name,
trigger_wait=True,
goto_target='MBI-%d' % i,
jump_target=e.name)
seq.append(name=e.name,
wfname=e.name,
trigger_wait=True,
repetitions=self.params['Repump_multiplicity'][i])
seq.append(name='Adwin-sync-%d' % i,
wfname=adwin_elt.name,
trigger_wait=False)
# program AWG
if upload:
qt.pulsar.program_awg(seq, mbi_elt, adwin_elt, *elts, debug=debug)
def generate_sequence(self, upload=True, **kw):
'''
'''
SP = pulse.SquarePulse(channel='AOM_Newfocus', name='SP')
def generate_sequence(self, upload=True, debug=False):
#configure the repumping beam. power and AWG channel
repumping_AOM_voltage = qt.instruments[
self.params['repump_AOM']].power_to_voltage(
self.params['laser_repump_amplitude'], controller='sec')
if repumping_AOM_voltage > (
qt.instruments[self.params['repump_AOM']]).get_sec_V_max():
print 'Suggested power level would exceed V_max of the AOM driver.'
return
else:
#not sure if the secondary channel of an AOM can be obtained in this way?
channelDict = {
'ch2m1': 'ch2_marker1',
'ch2m2': 'ch2_marker2',
'ch4m1': 'ch4_marker1'
}
print 'AOM voltage', repumping_AOM_voltage
print self.params['repump_AOM']
self.params['Channel_alias'] = qt.pulsar.get_channel_name_by_id(
channelDict[qt.instruments[
self.params['repump_AOM']].get_sec_channel()])
qt.pulsar.set_channel_opt(self.params['Channel_alias'], 'high',
repumping_AOM_voltage)
print self.params['Channel_alias']
# MBI element
mbi_elt = self._MBI_element()
# electron manipulation pulses
T = pulse.SquarePulse(name='syncpulse',
channel='MW_pulsemod',
length=1000e-9,
amplitude=0)
#Called dephasing, but does repump...
Dephasing = pulse.SquarePulse(channel=self.params['Channel_alias'],
length=1000e-9,
amplitude=repumping_AOM_voltage)
X = ps.X_pulse(self)
X_mw2 = ps.pi_pulse_MW2(self)
if False: #optical pumping using p1 transition
squareX = ps.mw2_squareX(self)
else: #optical pumping using m1 transition
squareX = ps.squareX(self)
adwin_sync = pulse.SquarePulse(
channel='adwin_sync',
length=self.params['AWG_to_adwin_ttl_trigger_duration'],
amplitude=2)
# electron manipulation elements
elts = []
for i in range(self.params['pts']):
e = element.Element('ERamsey_pt-%d' % i,
pulsar=qt.pulsar,
global_time=True)
e.append(T)
#initialize the electron after pumping to 0
if self.params['init_state'] == 'm1':
e.append(pulse.cp(X))
elif self.params['init_state'] == 'p1':
e.append(pulse.cp(X_mw2))
else: # init in zero
pass
e.append(pulse.cp(T, length=self.params['MW_repump_delay1'][i]))
pump_cycle_no = 0
while pump_cycle_no < self.params['pumping_cycles']:
pump_cycle_no += 1
if self.params['repumping_time'][i] != 0:
if pump_cycle_no > 1:
e.append(
pulse.cp(T,
length=self.params['delay_before_MW'][i]))
e.append(pulse.cp(squareX))
e.append(
pulse.cp(T,
length=self.params['delay_after_MW'][i]))
e.append(
pulse.cp(Dephasing,
length=self.params['repumping_time'][i]))
e.append(pulse.cp(T, length=self.params['MW_repump_delay2'][i]))
#initialize the electron after pumping to 0
if self.params['ro_state'] == 'm1':
e.append(pulse.cp(X))
elif self.params['ro_state'] == 'p1':
e.append(pulse.cp(X_mw2))
else: # ro zero
pass
e.append(pulse.cp(T, length=2e-6))
elts.append(e)
adwin_elt = element.Element('Adwin_sync',
pulsar=qt.pulsar,
global_time=True)
adwin_elt.append(adwin_sync)
seq = pulsar.Sequence('MBI Electron Ramsey sequence')
for i, e in enumerate(elts):
seq.append(name='MBI-%d' % i,
wfname=mbi_elt.name,
trigger_wait=True,
goto_target='MBI-%d' % i,
jump_target=e.name)
seq.append(name=e.name,
wfname=e.name,
trigger_wait=True,
repetitions=self.params['Repump_multiplicity'][i])
seq.append(name='Adwin-sync-%d' % i,
wfname=adwin_elt.name,
trigger_wait=False)
# program AWG
if upload:
qt.pulsar.program_awg(seq, mbi_elt, adwin_elt, *elts, debug=debug)
def _pulse_defs(self):
### electron manipulation pulses
# a waiting pulse on the MW pulsemod channel
self.T = pulse.SquarePulse(channel='MW_pulsemod',
length=10e-9,
amplitude=0)
self.TIQ = pulse.SquarePulse(channel='MW_Imod',
length=10e-9,
amplitude=0)
# some not yet specified pulse on the electron
self.e_pulse = pulselib.MW_IQmod_pulse(
'MW pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=self.params['MW_pulse_mod_risetime'])
# slow pi-pulse for MBI
self.slow_pi = pulselib.MW_IQmod_pulse(
'slow pi',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=self.params['MW_pulse_mod_risetime'],
frequency=self.params['selective_pi_mod_frq'],
amplitude=self.params['selective_pi_amp'],
length=self.params['selective_pi_duration'])
# reasonably fast pi and pi/2 pulses
self.pi_4MHz = pulselib.MW_IQmod_pulse(
'4MHz pi',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=self.params['MW_pulse_mod_risetime'],
frequency=self.params['4MHz_pi_mod_frq'],
amplitude=self.params['4MHz_pi_amp'],
length=self.params['4MHz_pi_duration'])
self.pi2_4MHz = pulselib.MW_IQmod_pulse(
'4MHz pi2',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=self.params['MW_pulse_mod_risetime'],
frequency=self.params['4MHz_pi2_mod_frq'],
amplitude=self.params['4MHz_pi2_amp'],
length=self.params['4MHz_pi2_duration'])
# shelving pi-pulse to bring electron to ms=-1 after mbi
self.shelving_pulse = pulselib.MW_IQmod_pulse(
'MBI shelving pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
frequency=self.params['AWG_MBI_MW_pulse_mod_frq'],
amplitude=self.params['AWG_shelving_pulse_amp'],
length=self.params['AWG_shelving_pulse_duration'],
PM_risetime=self.params['MW_pulse_mod_risetime'])
# CORPSE pi pulse
self.CORPSE_pi = pulselib.IQ_CORPSE_pi_pulse(
'CORPSE pi-pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=self.params['MW_pulse_mod_risetime'],
frequency=self.params['CORPSE_pi_mod_frq'],
amplitude=self.params['CORPSE_pi_amp'],
length_60=self.params['CORPSE_pi_60_duration'],
length_m300=self.params['CORPSE_pi_m300_duration'],
length_420=self.params['CORPSE_pi_420_duration'])
# CNOT operation on the electron
self.pi2pi_m1 = pulselib.MW_IQmod_pulse(
'pi2pi pulse mI=-1',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=self.params['MW_pulse_mod_risetime'],
frequency=self.params['pi2pi_mIm1_mod_frq'],
amplitude=self.params['pi2pi_mIm1_amp'],
length=self.params['pi2pi_mIm1_duration'])
### nuclear spin manipulation pulses
self.TN = pulse.SquarePulse(channel='RF', length=100e-9, amplitude=0)
self.N_pulse = pulselib.RF_erf_envelope(
channel='RF', frequency=self.params['N_0-1_splitting_ms-1'])
self.N_pi = pulselib.RF_erf_envelope(
channel='RF',
frequency=self.params['N_0-1_splitting_ms-1'],
length=self.params['N_pi_duration'],
amplitude=self.params['N_pi_amp'])
self.N_pi2 = pulselib.RF_erf_envelope(
channel='RF',
frequency=self.params['N_0-1_splitting_ms-1'],
length=self.params['N_pi2_duration'],
amplitude=self.params['N_pi2_amp'])
### synchronizing, etc
self.adwin_sync = pulse.SquarePulse(channel='adwin_sync',
length=10e-6,
amplitude=2)
### useful elements
self.mbi_elt = self._MBI_element()
self.sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar)
self.sync_elt.append(self.adwin_sync)
def generate_sequence(self, upload=True, debug=False):
# MBI element
mbi_elt = self._MBI_element()
# electron manipulation pulses
T = pulse.SquarePulse(channel='MW_pulsemod',
length=1000e-9,
amplitude=0)
X = pulselib.MW_IQmod_pulse(
'MW pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
Sw_channel='MW_switch',
PM_risetime=self.params['MW_pulse_mod_risetime'],
Sw_risetime=self.params['MW_switch_risetime'])
# X = pulselib.HermitePulse_Envelope_IQ('MW pulse',
# I_channel = 'MW_Imod',
# Q_channel = 'MW_Qmod',
# PM_channel = 'MW_pulsemod',
# PM_risetime = self.params['MW_pulse_mod_risetime'] )
adwin_sync = pulse.SquarePulse(
channel='adwin_sync',
length=self.params['AWG_to_adwin_ttl_trigger_duration'],
amplitude=2)
# electron manipulation elements
elts = []
for i in range(self.params['pts']):
e = element.Element('ERabi_pt-%d' % i,
pulsar=qt.pulsar,
global_time=True)
e.append(T)
for j in range(self.params['MW_pulse_multiplicities'][i]):
e.append(
pulse.cp(X,
frequency=self.params['MW_pulse_mod_frqs'][i],
amplitude=self.params['MW_pulse_amps'][i],
length=self.params['MW_pulse_durations'][i]))
e.append(pulse.cp(T, length=self.params['MW_pulse_delays'][i]))
e.append(adwin_sync)
elts.append(e)
# sequence
seq = pulsar.Sequence('MBI Electron Rabi sequence')
for i, e in enumerate(elts):
seq.append(name='MBI-%d' % i,
wfname=mbi_elt.name,
trigger_wait=True,
goto_target='MBI-%d' % i,
jump_target=e.name)
seq.append(name=e.name, wfname=e.name, trigger_wait=True)
print 'MBI at', self.params['AWG_MBI_MW_pulse_ssbmod_frq']
print 'MW rotations at', self.params['MW_pulse_mod_frqs'][i]
# program AWG
if upload:
#qt.pulsar.upload(mbi_elt, *elts)
qt.pulsar.program_awg(seq, mbi_elt, *elts, debug=debug)
def generate_new_sequence(m, seq, elements, upload = False):
qt.pulsar.AWG_sequence_cfg['JUMP_TIMING'] = 0 # ASYNC
[overview, pulse_array] = group_seq_elems(seq, elements)
seq_uniq = pulsar.Sequence(seq.name + '-unique')
seq_uniq.set_djump(True)
elements_uniq = []
unique_pulses = {}
jump_index = 0
# empty = pulse.SquarePulse(channel = 'tico_sync', length = 1e-6, amplitude = 0)
empty = pulse.SquarePulse(channel = 'adwin_sync', length = 1e-6, amplitude = 0)
e_loop = element.Element('loop', pulsar = qt.pulsar, global_time = True, min_samples = 1e3)
e_wait = element.Element('trigger_wait', pulsar = qt.pulsar, global_time = True, min_samples = 1e3) # currently not used
# e_start_tico = element.Element('start_tico', pulsar = qt.pulsar, global_time = True, min_samples = 1e3)
# e_loop.add(pulse.cp(empty, amplitude = 2, length = 100e-9), name = e_loop.name + '_sync')
e_wait.add(pulse.cp(empty), name = e_wait.name)
elements_uniq.append(e_wait)
seq_uniq.append(name = e_wait.name, wfname = e_wait.name, goto_target = e_loop.name, trigger_wait = True)
seq_uniq.add_djump_address(jump_index, e_wait.name)
# e_start_tico.add(pulse.cp(empty, amplitude = 2, length = 100e-9), name = e_start_tico.name)
# elements_uniq.append(e_start_tico)
# seq_uniq.append(name = e_start_tico.name, wfname = e_start_tico.name, goto_target = e_loop.name)
# seq_uniq.add_djump_address(jump_index, e_start_tico.name)
e_loop.add(pulse.cp(empty, length = 1e-3), name = e_loop.name) # + '_empty', refpulse = e_loop.name + '_sync')
elements_uniq.append(e_loop)
seq_uniq.append(name = e_loop.name, wfname = e_loop.name, goto_target = e_wait.name, repetitions = 65536)
m.params['jump_table'] = []
m.params['delays_before_jumps'] = []
m.params['next_seq_table'] = []
start_prev = 0
for seq_idx, (pulse_overview, pulse_seq) in enumerate(zip(overview, pulse_array)):
pulse_overview['jump_table'] = []
pulse_overview['delays'] = []
if pulse_overview['trigger_wait'] > 0:
start_prev = 0
for pul_idx, pul in enumerate(pulse_seq):
pul_physical = None
mid_point, length, phase, rotation, special = pul
phase = 180 * phase / np.pi
key = tuple([round(var, 5) for var in (length, phase, rotation, special)]) # rounding errors in pars
if key in unique_pulses:
pul_physical = unique_pulses[key][0]
else:
jump_index += 1 # We are adding a new pulse to the jump table
if special == 0:
if rotation == np.pi:
pul_physical = pulse.cp(ps.X_pulse(m), phase = phase)
else:
pul_physical = pulse.cp(ps.Xpi2_pulse(m), phase = phase)
elif special == 1:
pul_phsyical = pulse.SquarePulse(channel='AOM_Newfocus', length = length, amplitude = 0.2)
elif special == 2:
pul_physical = pulse.SquarePulse(channel='adwin_sync', length = length, amplitude = 2)
# ADWIN DOESN'T NEED TO SYNC WITH ITSELF?
else:
pul_phsyical = pulse.SquarePulse(channel='AOM_Matisse', length = length, amplitude = 0.2)
pul_name = pul_physical.name + ('-%i' % jump_index) # Give pulses unique names
e = element.Element(pul_name, pulsar = qt.pulsar, global_time = True, min_samples = 1e3)
e.add(pul_physical, name = pul_name)
elements_uniq.append(e)
seq_uniq.append(name = e.name, wfname = e.name, goto_target = e_loop.name)
seq_uniq.add_djump_address(jump_index, e.name)
unique_pulses[key] = [pul_physical, jump_index]
channel_offset = 0
for ch in pul_physical.channels:
if qt.pulsar.channels[ch]['delay'] > channel_offset:
channel_offset = qt.pulsar.channels[ch]['delay']
length += pul_physical.start_offset + pul_physical.stop_offset
start = mid_point - length / 2 - channel_offset
delay = start - start_prev
pulse_overview['jump_table'].append(unique_pulses[key][1])
pulse_overview['delays'].append(delay)
if pul_idx == len(pulse_seq) - 1:
pulse_overview['jump_table'].append(0)
pulse_overview['delays'].append(pulse_overview['final_time'] - start - length) # Not used atm
start_prev = start
m.params['jump_table'].append(pulse_overview['jump_table'])
m.params['delays_before_jumps'].append(pulse_overview['delays'])
if pulse_overview['goto_target'] != 'None':
start_prev = 0
next_goto = next(i for (i, o) in enumerate(overview) if o['goto_target'] == pulse_overview['goto_target'])
else:
start_prev = pulse_overview['final_time']
if seq_idx + 1 == len(overview):
next_goto = 1
else:
next_goto = seq_idx + 2
if pulse_overview['jump_target'] != 'None':
start_prev = 0
next_jump = next(i for (i, o) in enumerate(overview) if o['jump_target'] == pulse_overview['jump_target'])
else:
start_prev = pulse_overview['final_time']
next_jump = 0
m.params['next_seq_table'].append([next_goto, next_jump])
# upload new seq
if upload:
qt.pulsar.program_awg(seq_uniq, *elements_uniq)
def generate_sequence(self, upload=True, debug=False):
# MBI element
mbi_elt = self._MBI_element()
# electron manipulation pulses
T = pulse.SquarePulse(channel='MW_pulsemod',
length=100e-9,
amplitude=0)
X = pulselib.MW_IQmod_pulse(
'MW pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
Sw_channel='MW_switch',
PM_risetime=self.params['MW_pulse_mod_risetime'],
Sw_risetime=self.params['MW_switch_risetime'])
adwin_sync = pulse.SquarePulse(
channel='adwin_sync',
length=self.params['AWG_to_adwin_ttl_trigger_duration'],
amplitude=2)
# electron manipulation elements
pulse_elts = []
for i in range(self.params['pts']):
e = element.Element('ERabi_pt-%d' % i, pulsar=qt.pulsar)
e.append(T)
e.append(
pulse.cp(X,
frequency=self.params['MW_pulse_mod_frqs'][i],
amplitude=self.params['MW_pulse_amps'][i],
length=self.params['MW_pulse_durations'][i]))
# e.append(adwin_sync)
pulse_elts.append(e)
wait_elt = element.Element('pulse_delay', pulsar=qt.pulsar)
wait_elt.append(pulse.cp(T, length=1e-6))
sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar)
sync_elt.append(adwin_sync)
# sequence
seq = pulsar.Sequence('MBI Electron Rabi sequence')
for i, e in enumerate(pulse_elts):
seq.append(name='MBI-%d' % i,
wfname=mbi_elt.name,
trigger_wait=True,
goto_target='MBI-%d' % i,
jump_target=e.name + '-0')
if self.params['MW_pulse_multiplicities'][i] == 0:
seq.append(name=e.name + '-0',
wfname=wait_elt.name,
trigger_wait=True)
else:
for j in range(self.params['MW_pulse_multiplicities'][i]):
seq.append(name=e.name + '-%d' % j,
wfname=e.name,
trigger_wait=(j == 0))
seq.append(name='wait-%d-%d' % (i, j),
wfname=wait_elt.name,
repetitions=int(
self.params['MW_pulse_delays'][i] / 1e-6))
seq.append(name='sync-%d' % i, wfname=sync_elt.name)
# program AWG
if upload:
qt.pulsar.program_awg(seq,
mbi_elt,
wait_elt,
sync_elt,
*pulse_elts,
debug=debug)
def generate_sequence(self,upload=True):
#rewrite
chan_hhsync = 'HH_sync' # historically PH_start
chan_hh_ma1 = 'HH_MA1' # historically PH_sync
chan_plusync = 'PLU_gate'
chan_adwin='adwin_sync'
chan_alaser = 'AOM_Newfocus'
chan_yellowlaser = 'AOM_Yellow'
chan_eom = 'EOM_Matisse'
chan_eom_aom = 'EOM_AOM_Matisse'
qt.pulsar.set_channel_opt(chan_alaser,'high', self.params['AWG_A_SP_voltage'])
qt.pulsar.set_channel_opt(chan_yellowlaser,'high', self.params['AWG_yellow_voltage'])
e_lde = element.Element('lde', pulsar=qt.pulsar)
# 1: spin pumping
p_wait=pulse.SquarePulse(chan_alaser, 'initialdelay',
length = 10e-9, amplitude = 0)
last=e_lde.add(p_wait)
p_sp=pulse.SquarePulse(chan_alaser, 'spinpumping',
length = self.params['AWG_SP_duration'], amplitude = 1)
p_yellow=pulse.SquarePulse(chan_yellowlaser, 'yellowpumping',
length = self.params['AWG_yellow_duration'], amplitude = 1)
e_lde.add(p_yellow, refpulse=last, refpoint='end')
last=e_lde.add(p_sp, refpulse=last, refpoint='end')
p_sync=pulse.SquarePulse(chan_hhsync,'debug_sync',
length = 50e-9, amplitude = 1)
p_hh_marker=pulse.SquarePulse(chan_hh_ma1, 'hh_marker', length=50e-9,
amplitude=1)
P_eom_aom=EOMAOMPulse(chan_eom,chan_eom_aom,'opt_pi',**self.eom_pars)
# opt pi 1
i = 1
if self.params['long_histogram']:
e_lde.add(p_sync)
hhsync_amp=0
else:
hhsync_amp=1
last=e_lde.add(pulse.cp(p_sync(amplitude=hhsync_amp)),name='start'+str(i), t0= self.params['wait_after_sp'],
refpulse=last, refpoint='end')
e_lde.add(p_hh_marker,name='mrkr'+str(i), t0 = -20e-9,
refpulse=last, refpoint='start')
last=e_lde.add(pulse.cp(p_sync(amplitude=0)),name='start'+str(i)+'delay',
refpulse=last, refpoint='end')
last=e_lde.add(P_eom_aom, name='eom_pulse'+str(i), t0= self.params['eom_start'],
refpulse=last, refpoint = 'start')
# opt pi 2
i = 2
last=e_lde.add(pulse.cp(p_sync(amplitude=hhsync_amp)),name='start'+str(i), t0= self.params['opt_pi_separation'],
refpulse='start'+str(i-1), refpoint='start')
last=e_lde.add(pulse.cp(p_sync(amplitude=0)),name='start'+str(i)+'delay',
refpulse=last, refpoint='end')
last=e_lde.add(P_eom_aom, name='eom_pulse'+str(i), t0= self.params['eom_start'],
refpulse=last, refpoint = 'start')
#final delay
e_lde.add(pulse.cp(p_wait(length=self.params['finaldelay'])), refpulse=last, refpoint = 'end')
# idle element
e_idle=element.Element('idle', pulsar=qt.pulsar)
last=e_idle.add(pulse.cp(p_wait(length=200e-9)))
p_adwin=pulse.SquarePulse(chan_adwin,'adwin_sync',
length = 2000e-9, amplitude = 1)
e_idle.add(p_adwin, refpulse=last, refpoint = 'end', t0 = 50e-9)
seq = pulsar.Sequence('LDE protocol test sequence wo MW')
for i,r in enumerate(self.params['protocol_reps_sweep']):
#print i, r
seq.append(name = 'LDE-%d' % i, wfname = e_lde.name,
trigger_wait = True,
repetitions=r)
seq.append(name = 'wait-%d' % i, wfname = e_idle.name,
trigger_wait = False)
if upload:
qt.pulsar.upload(e_lde,e_idle)
qt.pulsar.program_sequence(seq)
def generate_sequence(self, upload=True):
#rewrite
chan_hhsync = 'HH_sync' # historically PH_start
chan_hh_ma1 = 'HH_MA1' # historically PH_sync
chan_plusync = 'PLU_gate'
self.chan_adwin_sync = 'adwin_sync'
self.chan_nf_aom = 'AOM_Newfocus'
self.chan_mwI = 'MW_Imod'
self.chan_mwQ = 'MW_Qmod'
self.chan_mw_pm = 'MW_pulsemod'
chan_yellowlaser = 'AOM_Yellow'
chan_eom = 'EOM_Matisse'
chan_eom_aom = 'EOM_AOM_Matisse'
qt.pulsar.set_channel_opt(self.chan_nf_aom, 'high',
self.params['AWG_A_SP_voltage'])
qt.pulsar.set_channel_opt(chan_yellowlaser, 'high',
self.params['AWG_yellow_voltage'])
#qt.pulsar.set_channel_opt(chan_eom_aom,'low', 0.1)
# MBI element
e_mbi = self._MBI_element()
# LDE element
e_lde = element.Element('lde', pulsar=qt.pulsar)
# 1: spin pumping
p_wait = pulse.SquarePulse(self.chan_nf_aom,
'initialdelay',
length=10e-9,
amplitude=0)
last = e_lde.add(p_wait)
p_sp = pulse.SquarePulse(self.chan_nf_aom,
'spinpumping',
length=self.params['AWG_SP_duration'],
amplitude=1)
p_yellow = pulse.SquarePulse(chan_yellowlaser,
'yellowpumping',
length=self.params['AWG_yellow_duration'],
amplitude=1)
e_lde.add(p_yellow, refpulse=last, refpoint='end')
last = e_lde.add(p_sp, refpulse=last, refpoint='end')
p_sync = pulse.SquarePulse(chan_hhsync,
'debug_sync',
length=50e-9,
amplitude=1)
p_hh_marker = pulse.SquarePulse(chan_hh_ma1,
'hh_marker',
length=50e-9,
amplitude=1)
P_eom_aom = EOMAOMPulse(chan_eom, chan_eom_aom, 'opt_pi',
**self.eom_pars)
#pi/2
p_pi2 = pulselib.MW_IQmod_pulse(
'mw_pi2',
I_channel=self.chan_mwI,
Q_channel=self.chan_mwQ,
PM_channel=self.chan_mw_pm,
PM_risetime=self.params['MW_pulse_mod_risetime'],
length=self.params['4MHz_pi2_duration'],
amplitude=self.params['4MHz_pi2_amp'],
frequency=self.params['4MHz_pi2_mod_frq'],
)
last = e_lde.add(p_pi2,
refpulse=last,
refpoint='end',
start=self.params['wait_after_sp'])
# opt pi 1
i = 1
if self.params['long_histogram']:
e_lde.add(p_sync)
hhsync_amp = 0
else:
hhsync_amp = 1
last = e_lde.add(pulse.cp(p_sync(amplitude=hhsync_amp)),
name='start' + str(i),
start=self.params['wait_after_pi2'],
refpulse=last,
refpoint='end')
e_lde.add(p_hh_marker,
name='mrkr' + str(i),
start=-20e-9,
refpulse=last,
refpoint='start')
last = e_lde.add(pulse.cp(p_sync(amplitude=0)),
name='start' + str(i) + 'delay',
refpulse=last,
refpoint='end')
last = e_lde.add(P_eom_aom,
name='eom_pulse' + str(i),
start=self.params['eom_start'],
refpulse=last,
refpoint='start')
#pi
p_pi = pulselib.MW_IQmod_pulse(
'mw_pi',
I_channel=self.chan_mwI,
Q_channel=self.chan_mwQ,
PM_channel=self.chan_mw_pm,
PM_risetime=self.params['MW_pulse_mod_risetime'],
length=self.params['4MHz_pi_duration'],
amplitude=self.params['4MHz_pi_amp'],
frequency=self.params['4MHz_pi_mod_frq'],
)
e_lde.add(p_pi,
refpulse=last,
refpoint='start',
start=self.params['wait_after_opt_pi'])
# opt pi 2
i = 2
last = e_lde.add(pulse.cp(p_sync(amplitude=hhsync_amp)),
name='start' + str(i),
start=self.params['opt_pi_separation'],
refpulse='start' + str(i - 1),
refpoint='start')
last = e_lde.add(pulse.cp(p_sync(amplitude=0)),
name='start' + str(i) + 'delay',
refpulse=last,
refpoint='end')
last = e_lde.add(P_eom_aom,
name='eom_pulse' + str(i),
start=self.params['eom_start'],
refpulse=last,
refpoint='start')
#pi/2
e_lde.add(p_pi2,
refpulse=last,
refpoint='start',
start=self.params['wait_after_opt_pi2'])
#final delay
e_lde.add(pulse.cp(p_wait(length=self.params['finaldelay'])),
refpulse=last,
refpoint='end')
#final SP element
e_sp_final = element.Element('sp_final', pulsar=qt.pulsar)
e_sp_final.append(
pulse.cp(p_sp(length=self.params['AWG__finalSP_duration'])))
#RO element
e_ro = element.Element('readout', pulsar=qt.pulsar)
p_RO = pulselib.MW_IQmod_pulse(
'readout pulse',
I_channel=self.chan_mwI,
Q_channel=self.chan_mwQ,
PM_channel=self.chan_mw_pm,
PM_risetime=int(self.params['MW_pulse_mod_risetime']),
length=self.params['AWG_RO_MW_pulse_duration'],
amplitude=self.params['AWG_RO_MW_pulse_amp'],
frequency=self.params['AWG_RO_MW_pulse_ssbmod_frq'])
p_ROsync = pulse.SquarePulse(
self.chan_adwin_sync,
'adwin_sync',
length=self.params['AWG_to_adwin_ttl_trigger_duration'],
amplitude=1)
e_ro.append(pulse.cp(p_wait(length=200e-9)))
last = e_ro.append(p_RO)
e_ro.add(p_ROsync, refpoint=last, start=50e-9)
seq = pulsar.Sequence('LDE protocol test sequence wo MW')
for i, r in enumerate(self.params['protocol_reps_sweep']):
#print i, r
# 1: MBI
seq.append(name='MBI-%d' % i,
wfname=e_mbi.name,
trigger_wait=True,
goto_target='MBI-%d' % i,
jump_target='LDE-%d' % i)
# 2: repeat LDE r times
seq.append(name='LDE-%d' % i, wfname=e_lde.name, repetitions=r)
# 3: spin pump a final time for the readout:
seq.append(name='sp_final' + str(i), wfname=e_sp_final.name)
seq.append(name='N_ro' + str(i), wfname=e_ro.name)
if upload:
qt.pulsar.upload(e_mbi, e_lde, e_sp_final, e_ro)
qt.pulsar.program_sequence(seq)
def generate_sequence(self, upload=True):
# electron manipulation pulses
T = pulse.SquarePulse(channel='MW_pulsemod',
length=100e-9,
amplitude=0)
TIQ = pulse.SquarePulse(channel='MW_Imod', length=10e-9, amplitude=0)
CORPSE_pi = pulselib.IQ_CORPSE_pulse(
'CORPSE pi-pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=self.params['MW_pulse_mod_risetime'],
frequency=self.params['CORPSE_mod_frq'],
rabi_frequency=self.params['CORPSE_rabi_frequency'],
amplitude=self.params['CORPSE_amp'],
pulse_delay=2e-9,
eff_rotation_angle=180)
CORPSE_pi2 = pulselib.IQ_CORPSE_pulse(
'CORPSE pi-pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=self.params['MW_pulse_mod_risetime'],
frequency=self.params['CORPSE_mod_frq'],
rabi_frequency=self.params['CORPSE_rabi_frequency'],
amplitude=self.params['CORPSE_amp'],
pulse_delay=2e-9,
eff_rotation_angle=90)
wait_1us = element.Element('1us_delay', pulsar=qt.pulsar)
wait_1us.append(pulse.cp(T, length=1e-6))
sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar)
adwin_sync = pulse.SquarePulse(channel='adwin_sync',
length=10e-6,
amplitude=2)
sync_elt.append(adwin_sync)
elts = []
seq = pulsar.Sequence('CORPSE Pi2 Calibration')
for i in range(self.params['pts_awg']):
e = element.Element('CORPSE_Pi2_Pi-{}'.format(i),
pulsar=qt.pulsar,
global_time=True)
e.append(T)
e.append(
pulse.cp(CORPSE_pi2,
amplitude=self.params['CORPSE_pi2_sweep_amps'][i]))
e.append(pulse.cp(TIQ, length=200e-9))
e.append(pulse.cp(CORPSE_pi))
e.append(T)
elts.append(e)
seq.append(name='CORPSE_Pi2_Pi-{}'.format(i),
wfname=e.name,
trigger_wait=True)
seq.append(name='synca-{}'.format(i), wfname=sync_elt.name)
e = element.Element('CORPSE_Pi2-{}'.format(i),
pulsar=qt.pulsar,
global_time=True)
e.append(T)
e.append(
pulse.cp(CORPSE_pi2,
amplitude=self.params['CORPSE_pi2_sweep_amps'][i]))
e.append(pulse.cp(TIQ, length=200e-9))
e.append(T)
elts.append(e)
seq.append(name='CORPSE_Pi2-{}'.format(i),
wfname=e.name,
trigger_wait=True)
seq.append(name='syncb-{}'.format(i), wfname=sync_elt.name)
# program AWG
if upload:
#qt.pulsar.upload(sync_elt, wait_1us, *elts)
qt.pulsar.program_awg(seq, sync_elt, wait_1us, *elts)
def generate_sequence(self, upload=True, debug=False):
# MBI element
mbi_elt = self._MBI_element()
# electron manipulation pulses
T = pulse.SquarePulse(channel='MW_pulsemod',
length = 750e-9, amplitude = 0)
X = pulselib.MW_IQmod_pulse('MW pulse',
I_channel = 'MW_Imod',
Q_channel = 'MW_Qmod',
PM_channel = 'MW_pulsemod',
PM_risetime = self.params['MW_pulse_mod_risetime'] )
N_pulse = pulselib.RF_erf_envelope(
channel = 'RF',
frequency = self.params['N_0-1_splitting_ms-1'])
pi2pi_0 = pulselib.MW_IQmod_pulse('pi2pi pulse mI=0',
I_channel = 'MW_Imod',
Q_channel = 'MW_Qmod',
PM_channel = 'MW_pulsemod',
PM_risetime = self.params['MW_pulse_mod_risetime'],
frequency = self.params['pi2pi_mI0_mod_frq'],
amplitude = self.params['pi2pi_mI0_amp'],
length = self.params['pi2pi_mI0_duration'])
adwin_sync = pulse.SquarePulse(channel='adwin_sync',
length = self.params['AWG_to_adwin_ttl_trigger_duration'],
amplitude = 2)
# electron manipulation elements
elts = []
for i in range(self.params['pts']):
e = element.Element('NRabi_pt-%d' % i, pulsar=qt.pulsar,
global_time = True)
e.append(T)
e.append(
pulse.cp(X,
frequency = self.params['MW_modulation_frequency'],
amplitude = self.params['MW_pi_pulse_amp'],
length = self.params['MW_pi_pulse_duration']))
e.append(T)
for j in range(self.params['RF_pulse_multiplicities'][i]):
e.append(
pulse.cp(N_pulse,
frequency = self.params['RF_pulse_frqs'][i],
amplitude = self.params['RF_pulse_amps'][i],
length = self.params['RF_pulse_durations'][i]))
e.append(
pulse.cp(T, length=self.params['RF_pulse_delays'][i]))
e.append(pulse.cp(pi2pi_0))
e.append(pulse.cp(T))
e.append(adwin_sync)
elts.append(e)
# sequence
seq = pulsar.Sequence('MBI Nitrogen Rabi sequence')
for i,e in enumerate(elts):
seq.append(name = 'MBI-%d' % i, wfname = mbi_elt.name,
trigger_wait = True, goto_target = 'MBI-%d' % i,
jump_target = e.name)
seq.append(name = e.name, wfname = e.name,
trigger_wait = True)
# program AWG
if upload:
#qt.pulsar.upload(mbi_elt, *elts)
qt.pulsar.program_awg(seq, mbi_elt, *elts , debug=debug)
