def generate_sequence(self, upload=True, period=200e-6, on_time=2e-6):
self_trigger = pulse.SquarePulse(channel='self_trigger',
length = on_time,
amplitude = 2.)
T = pulse.SquarePulse(channel='self_trigger', name='delay',
length = period - on_time, amplitude = 0)
elements = []
period_element = element.Element('Dummy_selftrigger_element', pulsar=qt.pulsar, global_time=True)
period_element.append(self_trigger)
period_element.append(T)
elements.append(period_element)
seq = pulsar.Sequence("Dummy self-trigger sequence")
seq.append(name=period_element.name,
wfname=period_element.name,
trigger_wait=True,
# goto_target=period_element.name
)
# upload the waveforms to the AWG
if upload:
if upload=='old_method':
qt.pulsar.upload(*elements)
qt.pulsar.program_sequence(seq)
else:
qt.pulsar.program_awg(seq,*elements)
def generate_sequence(self, upload=True):
# define the necessary pulses
X = hermite_Xpi(self)
T = pulse.SquarePulse(channel='MW_Imod', name='delay')
T.amplitude = 0.
T.length = 2e-6
# make the elements - one for each ssb frequency
elements = []
for i, f in enumerate(1e9 * self.params['sweep_pts'] -
self.params['mw_frq']):
e = element.Element('DarkESR_frq-%d' % i, pulsar=qt.pulsar)
e.add(T, name='wait')
e.add(X(frequency=f), refpulse='wait')
elements.append(e)
# create a sequence from the pulses
seq = pulsar.Sequence('DarkESR sequence')
for e in elements:
seq.append(name=e.name, wfname=e.name, trigger_wait=True)
# upload the waveforms to the AWG
if upload:
if upload == 'old_method':
qt.pulsar.upload(*elements)
qt.pulsar.program_sequence(seq)
else:
qt.pulsar.program_awg(seq, *elements)
def generate_sequence(self, upload=True):
# define the necessary pulse
V = self.E_aom.power_to_voltage(self.params['Ex_RO_amplitude'],
controller='sec')
print V
qt.pulsar_remote.set_channel_opt('Velocity1AOM', 'high', V)
HH_sync = pulse.SquarePulse(channel='HH_sync',
length=50e-9,
amplitude=1.0)
TT = pulse.SquarePulse(channel='HH_sync', length=1000e-9, amplitude=0)
RO = pulse.SquarePulse(channel='Velocity1AOM',
length=self.params['SSRO_duration'] * 1e-6,
amplitude=1)
# make the elements - one for each ssb frequency
e = element.Element('RO', pulsar=qt.pulsar_remote)
e.append(TT)
e.append(HH_sync)
e.append(TT)
e.append(RO)
# create a sequence from the pulses
seq = pulsar.Sequence('SSRO sequence')
seq.append(name=e.name, wfname=e.name, trigger_wait=True)
# upload the waveforms to the AWG
if upload:
qt.pulsar_remote.upload(e)
# program the AWG
qt.pulsar_remote.program_sequence(seq)
def dd_sweep_free_ev_time_w_LDE_msmt(self):
self.seq = pulsar.Sequence('{}_{}_sequence'.format(
self.mprefix, self.name))
self.elements = []
LDE_elt = self.LDE_element(eom_pulse_amplitude=0.)
self.seq.append(name='LDE_element', wfname=LDE_elt.name)
self.elements.append(LDE_elt)
print 'LDE'
for i in range(self.params['pts']):
seq, total_elt_time, elts = self.dynamical_decoupling(
self.seq,
name=i,
time_offset=LDE_elt.length(),
begin_offset_time=800e-9 +
self.params_lt2['dd_spin_echo_time'],
free_evolution_time=self.params_lt2['free_evolution_times'][i])
second_pi2_elt = self.second_pi2(name=i,
time_offset=LDE_elt.length() +
total_elt_time)
self.seq.append(name='second_pi2-{}'.format(i),
wfname=second_pi2_elt.name)
for e in elts:
if e not in self.elements:
self.elements.append(e)
self.elements.append(second_pi2_elt)
def lt3_sequence(self):
print "Make lt3 sequence... "
self.lt3_seq = pulsar.Sequence('TailLT3')
elements = []
dummy_element = bseq._lt3_dummy_element(self)
finished_element = bseq._lt3_sequence_finished_element(self)
elements.append(dummy_element)
elements.append(finished_element)
for i in range(self.params['pts']):
eom_p = self.create_eom_pulse(i)
e = bseq._lt3_LDE_element(
self,
name='LT3 Tail sweep element {}'.format(i),
eom_pulse=eom_p)
#print e.print_overview()
elements.append(e)
self.lt3_seq.append(
name='LT3 Tail sweep {}'.format(i),
wfname=e.name,
trigger_wait=self.params['trigger_wait'],
repetitions=self.params['LDE_attempts_before_CR'])
qt.pulsar.upload(*elements)
qt.pulsar.program_sequence(self.lt3_seq)
def generate_sequence(self, upload=True):
#print 'test'
# define the necessary pulses
X = pulselib.MW_pulse('Weak pi-pulse',
MW_channel='MW_Imod',
PM_channel='MW_pulsemod',
PM_risetime = self.params['MW_pulse_mod_risetime'])
T = pulse.SquarePulse(channel='MW_Qmod', name='delay',
length = 200e-9, amplitude = 0.)
# make the elements - one for each ssb frequency
elements = []
for i in range(self.params['pts']):
e = element.Element('ElectronRabi_pt-%d' % i, pulsar=qt.pulsar)
e.append(T)
e.append(pulse.cp(X,
length = self.params['MW_pulse_durations'][i],
amplitude = self.params['MW_pulse_amplitudes'][i]))
elements.append(e)
# create a sequence from the pulses
seq = pulsar.Sequence('ElectronRabi 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 generate_sequence(self, upload=True):
# define the necessary pulse
TT = pulse.SquarePulse(channel='HH_sync', length=1000e-9, amplitude=0)
SP = pulse.SquarePulse(channel=self.params['sp_channel'],
length=self.params['AWG_SP_duration'][0],
amplitude=self.params['AWG_SP_voltage'][0])
#print self.params['AWG_SP_voltage']
# make the elements - one for each ssb frequency
elements = []
for i in range(self.params['pts']):
e = element.Element('AWG_SP_sweep-%d' % i, pulsar=self.pulsar)
e.add(TT, name='wait')
e.append(
pulse.cp(
SP(length=self.params['AWG_SP_duration'][i],
amplitude=self.params['AWG_SP_voltage'][i])))
elements.append(e)
# create a sequence from the pulses
seq = pulsar.Sequence('SSRO sequence')
for e in elements:
seq.append(name=e.name, wfname=e.name, trigger_wait=True)
# upload the waveforms to the AWG
if upload:
self.pulsar.upload(*elements)
# program the AWG
self.pulsar.program_sequence(seq)
def program_test_master():
#p=pulse.SinePulse(channel='EOM_Matisse', name='pp', length=100e-6, frequency=1/(100e-6), amplitude = 1.8)
T = pulse.SquarePulse('scope_sync', length=200e-9, amplitude = 0)
p_sync = pulse.SquarePulse('scope_sync', length=50e-9, amplitude = 1)
p_pulse = pulse.SquarePulse('scope_pulse', length=200e-9, amplitude = 1)
p_trig = pulse.SquarePulse('awg_lt1_trigger', length=50e-9, amplitude = 1)
e=element.Element('Sinde', pulsar=qt.pulsar)
e.append(T)
e.append(p_trig)
e.append(pulse.cp(T, length = 500e-9))
e.append(p_sync)
e.append(T)
e.append(p_pulse)
e.append(pulse.cp(T, length = 100
\
0e-9))
e.print_overview()
s= pulsar.Sequence('TEST_AWG_SYNC_LT3')
s.append(name = 't1',
wfname = e.name,
trigger_wait = 0)
qt.pulsar.upload(e)
qt.pulsar.program_sequence(s)
qt.instruments['AWG'].start()
def test_BSM_contrast(self, bs='psi'):
sweep_elements = []
self.flattened_elements = []
self.seq = pulsar.Sequence('{}_{}-Sequence'.format(
self.mprefix, self.name))
bs_elt = self._BS_element(bs, bs)
self.flattened_elements.append(bs_elt)
for i in range(self.params['pts']):
CNOT, UNROT_H = self.BSM_elements(
'{}'.format(i),
time_offset=bs_elt.length(),
H_phase=self.params_lt1['H_phases'][i],
evolution_time=self.params_lt1['H_evolution_time'])
self.flattened_elements.append(CNOT)
self.flattened_elements.append(UNROT_H)
sweep_elements.append([bs_elt, CNOT, UNROT_H])
self.seq = self._add_MBI_and_sweep_elements_to_sequence(
sweep_elements,
self.N_RO_CNOT_elt,
self.adwin_lt1_trigger_element,
N_RO_repetitions=1 if not self.repetitive_readout else
self.params_lt1['N_RO_repetitions'])
def test_BSM_with_LDE_element_calibrate_echo_time(self):
sweep_elements = []
self.flattened_elements = []
self.seq = pulsar.Sequence('{}_{}-Sequence'.format(
self.mprefix, self.name))
for i in range(self.params['pts']):
N_init = self.N_init_element(
'N_init-{}'.format(i),
basis='Z',
echo_time_after_LDE=self.params_lt1['echo_times_after_LDE'][i],
end_offset_time=-100e-9)
e_pi2_elt = element.Element('e_pi2-{}'.format(i),
pulsar=qt.pulsar,
global_time=True,
time_offset=self.LDE_element.length() +
N_init.length())
e_pi2_elt.append(pulse.cp(self.TIQ, length=100e-9))
e_pi2_elt.append(self.fast_pi2)
self.flattened_elements.append(self.LDE_element)
self.flattened_elements.append(N_init)
self.flattened_elements.append(e_pi2_elt)
sweep_elements.append([self.LDE_element, N_init, e_pi2_elt])
self.seq = self._add_MBI_and_sweep_elements_to_sequence(
sweep_elements, self.N_RO_CNOT_elt, self.adwin_lt1_trigger_element)
def generate_sequence(self, upload=True, **kw):
# define the necessary pulses
# rotations
pulse_pi2 = kw.get('pulse_pi2', None)
pulse_pi = kw.get('pulse_pi', None)
# waiting element
T = pulse.SquarePulse(channel='MW_Imod', name='delay',
length = 200e-9, amplitude = 0.)
adwin_sync = pulse.SquarePulse(channel='adwin_sync',
length = self.params['AWG_to_adwin_ttl_trigger_duration'],
amplitude = 2)
# self_trigger = pulse.SquarePulse(channel='self_trigger',
# length = self.params['self_trigger_duration'],
# amplitude = 2)
# make the elements, one for each evolution time
elements = []
for i in range(self.params['pts']):
e1 = element.Element('ElectronT2_notrigger_pt-%d_A' % i, pulsar=qt.pulsar,
global_time = True)
e1.append(pulse.cp(T,
length = 3000e-9))
e1.append(pulse.cp(pulse_pi2,
phase = self.params['pulse_sweep_pi2_phases1'][i]))
e1.append(pulse.cp(T,
length = self.params['evolution_times'][i] / 2.))
e1.append(pulse.cp(pulse_pi,
phase = self.params['pulse_sweep_pi_phases'][i]))
e1.append(pulse.cp(T,
length = self.params['evolution_times'][i] / 2.))
e1.append(pulse.cp(pulse_pi2,
phase = self.params['pulse_sweep_pi2_phases2'][i]))
e1.append(adwin_sync)
elements.append(e1)
# return_e=e
# create a sequence from the pulses
seq = pulsar.Sequence('Electron T2 with AWG timing with {} pulses'.format(self.params['pulse_shape']))
for e in elements:
seq.append(name=e.name, wfname=e.name, trigger_wait=True)
# upload the waveforms to the AWG
if upload:
if upload=='old_method':
qt.pulsar.upload(*elements)
qt.pulsar.program_sequence(seq)
else:
qt.pulsar.program_awg(seq,*elements)
def dd_sweep_free_ev_time_msmt(self):
self.seq = pulsar.Sequence('{}_{}_sequence'.format(
self.mprefix, self.name))
self.elements = []
first_pi2_elt = self.first_pi2()
self.elements.append(first_pi2_elt)
for i in range(self.params['pts']):
self.seq.append(name='first_pi2-{}'.format(i),
wfname=first_pi2_elt.name,
trigger_wait=True)
seq, total_elt_time, elts = self.dynamical_decoupling(
self.seq,
name=i,
time_offset=first_pi2_elt.length(),
free_evolution_time=self.params_lt2['free_evolution_times'][i])
second_pi2_elt = self.second_pi2(
name=i, time_offset=first_pi2_elt.length() + total_elt_time)
self.seq.append(name='second_pi2-{}'.format(i),
wfname=second_pi2_elt.name)
self.seq.append(name='sync_elt-{}'.format(i),
wfname=self.adwin_lt2_trigger_element.name)
for e in elts:
if e not in self.elements:
self.elements.append(e)
self.elements.append(second_pi2_elt)
self.elements.append(self.adwin_lt2_trigger_element)
def turn_on_lt4_pulse_path():
#qt.instruments['PMServo'].move_in()
p=pulse.SinePulse(channel='EOM_Matisse', name='pp', length=100e-6, frequency=1/(100e-6), amplitude = 1.8)
opt = 'offset' if qt.pulsar.channels['EOM_AOM_Matisse']['type']=='analog' else 'low'
qt.pulsar.set_channel_opt('EOM_AOM_Matisse', opt, 1.0)
e=element.Element('Sinde', pulsar=qt.pulsar)
e.append(p)
e.print_overview()
s= pulsar.Sequence('Sinde')
s.append(name = 'Sine',
wfname = e.name,
trigger_wait = 0)
qt.pulsar.upload(e)
qt.pulsar.program_sequence(s)
qt.instruments['AWG'].set_runmode('SEQ')
qt.instruments['AWG'].start()
while 1:
if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): break
qt.msleep(0.1)
qt.instruments['AWG'].stop()
qt.instruments['AWG'].set_runmode('CONT')
qt.pulsar.set_channel_opt('EOM_AOM_Matisse', opt, 0.0)
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',
PM_risetime = self.params['MW_pulse_mod_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)
# seq.append(name = 'RO-%d' % i, wfname = mbi_elt.name,
# trigger_wait = True, goto_target = 'MBI-%d' % i,
# jump_target = e.name)
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_sequence(self, upload=True):
# MBI element
mbi_elt = self._MBI_element()
# electron manipulation pulses
T = pulse.SquarePulse(channel='MW_pulsemod', length=10e-9, amplitude=0)
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'])
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))
elts = []
for i in range(self.params['pts']):
e = element.Element('CORPSE-{}'.format(i), pulsar=qt.pulsar)
e.append(
T,
pulse.cp(CORPSE_pi,
amplitude=self.params['CORPSE_pi_sweep_amps'][i]))
elts.append(e)
# sequence
seq = pulsar.Sequence('CORPSE pi calibration')
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 + '-0')
for j in range(self.params['multiplicity']):
seq.append(name=e.name + '-{}'.format(j),
wfname=e.name,
trigger_wait=(j == 0))
seq.append(name='wait-{}-{}'.format(i, j),
wfname=wait_1us.name,
repetitions=self.params['delay_reps'])
seq.append(name='sync-{}'.format(i), wfname=sync_elt.name)
# program AWG
if upload:
qt.pulsar.upload(mbi_elt, sync_elt, wait_1us, *elts)
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'],
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'],
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 test')
for i in range(self.params['pts']):
e = element.Element('CORPSE_Pi2_Pi-{}'.format(i),
pulsar=qt.pulsar,
global_time=True)
e.append(T)
e.append(pulse.cp(CORPSE_pi2))
e.append(pulse.cp(TIQ, length=self.params['delays'][i]))
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='sync-{}'.format(i), wfname=sync_elt.name)
if upload:
qt.pulsar.upload(sync_elt, wait_1us, *elts)
qt.pulsar.program_sequence(seq)
def calibrate_CORPSE_pi_phase_shift_or_e_time(self):
"""
Do a Hahn echo sequence with the CORPSE pi pulse, and sweep it's zero
phase with respect the rotating frame at that time.
"""
sweep_elements = []
self.flattened_elements = []
self.seq = pulsar.Sequence('{}_{}-Sequence'.format(
self.mprefix, self.name))
first_pi2_elt = element.Element('first pi2',
pulsar=qt.pulsar,
global_time=True)
first_pi2_elt.append(pulse.cp(self.T, length=1e-6))
first_pi2_name = first_pi2_elt.append(self.fast_pi2)
first_pi2_elt.append(pulse.cp(self.TIQ, length=100e-9))
self.flattened_elements.append(first_pi2_elt)
# the start time of the second pi2, and the evolution time depends on the time when the
# pulse stops in the first pi2 element:
t_pi2 = first_pi2_elt.length() - \
first_pi2_elt.effective_pulse_end_time(first_pi2_name, 'MW_Imod')
# calculate the evolution time from the interpulse delay
etimes = self.params_lt1[
'interpulse_delays'] - t_pi2 - self.fast_pi2.effective_length() / 2.
pi_elts = []
second_pi2_elts = []
for i in range(self.params['pts']):
e = self.UNROT_element('pi-{}'.format(i),
None, etimes[i], first_pi2_elt.length(),
CORPSE_pi_phase_shift = \
self.params_lt1['CORPSE_pi_phase_shifts'][i])
self.flattened_elements.append(e)
pi_elts.append(e)
# make the element
second_pi2_elt = element.Element('second pi2-{}'.format(i),
pulsar=qt.pulsar,
global_time=True,
time_offset=e.length() +
first_pi2_elt.length())
second_pi2_elt.append(pulse.cp(self.TIQ, length=t_pi2))
second_pi2_elt.append(self.fast_pi2)
self.flattened_elements.append(second_pi2_elt)
second_pi2_elts.append(second_pi2_elt)
self.flattened_elements.append(self.N_RO_CNOT_elt)
for i in range(self.params['pts']):
sweep_elements.append(
[first_pi2_elt, pi_elts[i], second_pi2_elts[i]])
self.seq = self._add_MBI_and_sweep_elements_to_sequence(
sweep_elements, self.N_RO_CNOT_elt, self.adwin_lt1_trigger_element)
def generate_sequence(self, upload=True):
#print 'test'
# define the necessary pulses
X1 = pulselib.MW_CORPSE_pulse('CORPSE pi-pulse',
MW_channel = 'MW_1',
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)
X2 = pulselib.MW_CORPSE_pulse('CORPSE 2pi-pulse',
MW_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)
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 generate_sequence(self, upload=True, **kw):
# define the necessary pulses
X=kw.get('pulse_pi2', None)
T = pulse.SquarePulse(channel='MW_Imod', name='delay',
length = 200e-9, amplitude = 0.)
adwin_sync = pulse.SquarePulse(channel='adwin_sync',
length = self.params['AWG_to_adwin_ttl_trigger_duration'],
amplitude = 2)
self_trigger = pulse.SquarePulse(channel='self_trigger',
length = self.params['self_trigger_duration'],
amplitude = 2)
# make the elements - one for each ssb frequency
elements = []
for i in range(self.params['pts']):
e1 = element.Element('ElectronRamsey_pt-%d_A' % i, pulsar=qt.pulsar,
global_time = True)
e1.append(pulse.cp(T,
length = 1000e-9))
e1.append(pulse.cp(X,
phase = self.params['pulse_sweep_pi2_phases1'][i]))
e1.append(pulse.cp(T,
length = self.params['evolution_times'][i] - self.params['self_trigger_delay']))
e1.append(pulse.cp(self_trigger))
elements.append(e1)
e2 = element.Element('ElectronRamsey_pt-%d_B' % i, pulsar=qt.pulsar,
global_time = True)
e2.append(pulse.cp(X,
phase = self.params['pulse_sweep_pi2_phases2'][i]))
e2.append(T)
e2.append(adwin_sync)
elements.append(e2)
# return_e=e
# create a sequence from the pulses
seq = pulsar.Sequence('ElectronRamsey self-triggered sequence with {} pulses'.format(self.params['pulse_shape']))
for e in elements:
seq.append(name=e.name, wfname=e.name, trigger_wait=True)
# upload the waveforms to the AWG
if upload:
if upload=='old_method':
qt.pulsar.upload(*elements)
qt.pulsar.program_sequence(seq)
else:
qt.pulsar.program_awg(seq,*elements)
def generate_sequence(self, upload=True):
# MBI element
mbi_elt = self._MBI_element()
# electron manipulation pulses
self.T = pulse.SquarePulse(channel='MW_pulsemod',
length = 100e-9, amplitude = 0)
self.g_pulse = self.PulseClass('gaussian IQ pulse',
I_channel = 'MW_Imod',
Q_channel = 'MW_Qmod',
PM_channel = 'MW_pulsemod',
PM_risetime = self.params['MW_pulse_mod_risetime'],
frequency = self.params['pulse_mod_frqs'][0],
amplitude = self.params['pulse_amps'][0],
length = self.params['pulse_durations'][0])
elts = []
for i in range(self.params['pts']):
e = element.Element('ERabi_pt-{}'.format(i), pulsar=qt.pulsar)
e.append(self.T)
for j in range(self.params['MW_pulse_multiplicities'][i]):
e.append(
pulse.cp(self.g_pulse,
frequency = self.params['pulse_mod_frqs'][i],
amplitude = self.params['pulse_amps'][i],
length = self.params['pulse_durations'][i]))
e.append(
pulse.cp(self.T, length=self.params['MW_pulse_delays'][i]))
elts.append(e)
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('CNOT sequence')
for i in range(self.params['pts']):
seq.append(name = 'MBI-%d' % i,
wfname = mbi_elt.name,
trigger_wait = True,
goto_target = 'MBI-%d' % i,
jump_target = 'pulse-{}'.format(i))
seq.append(name = 'pulse-{}'.format(i),
wfname = elts[i].name,
trigger_wait=True)
seq.append(name = 'sync-{}'.format(i),
wfname = sync_elt.name)
# program AWG
if upload:
qt.pulsar.upload(mbi_elt, sync_elt, *elts)
qt.pulsar.program_sequence(seq)
def generate_sweep_test_sequence(pts, syncs_per_sweep):
sync = pulse.SquarePulse(channel = 'sync',
length = 50e-9, amplitude = 2)
sync_T = pulse.SquarePulse(channel = 'sync',
length = 1e-6, amplitude = 0)
ch0 = pulse.SquarePulse(channel = 'AOM_Yellow',
length = 50e-9, amplitude = 2)
#photon_T = pulse.SquarePulse(channel = 'AOM_Yellow',
# length = 1e-6, amplitude = 0)
ch1 = pulse.SquarePulse(channel = 'RND_halt',
length = 50e-9, amplitude = 2)
#MA1_T = pulse.SquarePulse(channel = 'RND_halt',
# length = 1e-6, amplitude = 0)
seq = pulsar.Sequence('PQ_testing')
elts=[]
for i in range(pts):
elt = element.Element('el-{}'.format(i), pulsar=qt.pulsar)
elt.add(sync_T,
name='sync_T')
elt.add(sync,
refpulse='sync_T',
name='sync')
elt.add(ch0,
start = 500e-9+i*10e-9,
refpulse = 'sync',
refpoint = 'start')
elt.add(ch1,
start = 250e-9+i*10e-9,
refpulse = 'sync',
refpoint = 'start')
#elt.append(pulse.cp(photon_T, length=1e-6))
#syncs_elt_mod0 = element.Element('2_syncs_photon_after_first', pulsar=qt.pulsar)
#syncs_elt_mod0.append(sync_T)
#s1 = syncs_elt_mod0.append(sync)
#syncs_elt_mod0.append(pulse.cp(sync_T, length=500e-9))
#s2 = syncs_elt_mod0.append(sync)
#syncs_elt_mod0.append(pulse.cp(sync_T, length=10e-6))
#syncs_elt_mod0.add(photon,
# start = 50e-9,
# refpulse = s1)
elts.append(elt)
seq.append(name = 'test-{}'.format(i),
wfname = elt.name,
repetitions = syncs_per_sweep,
trigger_wait = True if i == 0 else False)
#seq.append(name = 'photon_after_sync1',
# wfname = syncs_elt_mod0.name,
# repetitions = 100)
#qt.pulsar.upload(no_syncs_elt, syncs_elt_mod0)
#qt.pulsar.program_sequence(seq)
qt.pulsar.program_awg(seq,*elts)
def generate_sequence(self, upload=True):
# electron manipulation pulses
T = pulse.SquarePulse(channel='MW_pulsemod', length=10e-9, amplitude=0)
CORPSE = pulselib.IQ_CORPSE_pulse(
'CORPSE pi-pulse',
I_channel=self.params['cur_MW_channel'],
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'],
frequency=self.params['frq_mod'],
rabi_frequency=self.params['CORPSE_rabi_frequency'],
pulse_delay=self.params['CORPSE_pulse_delay'],
eff_rotation_angle=self.params['CORPSE_eff_rotation_angle'])
CORPSE.channels.remove('dummy')
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 = []
for i in range(self.params['pts']):
e = element.Element('CORPSE-{}'.format(i), pulsar=qt.pulsar)
e.append(
T,
pulse.cp(CORPSE,
amplitude=self.params['CORPSE_pi_sweep_amps'][i],
pulse_delay=self.params['CORPSE_pulse_delays'][i]))
elts.append(e)
# sequence
seq = pulsar.Sequence('CORPSE pi calibration')
for i, e in enumerate(elts):
for j in range(self.params['multiplicity']):
seq.append(name=e.name + '-{}'.format(j),
wfname=e.name,
trigger_wait=(j == 0))
seq.append(name='wait-{}-{}'.format(i, j),
wfname=wait_1us.name,
repetitions=self.params['delay_reps'])
seq.append(name='sync-{}'.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):
seq = pulsar.Sequence('Belllt3')
bseq.pulse_defs_lt3(self)
elements = []
#dummy_element = bseq._dummy_element(self)
finished_element = bseq._lt3_sequence_finished_element(self)
start_element = bseq._lt3_sequence_start_element(self)
succes_element = bseq._lt3_entanglement_event_element(self)
elements.append(start_element)
elements.append(finished_element)
elements.append(succes_element)
LDE_element = bseq._LDE_element(self, name='LDE_lt3')
elements.append(LDE_element)
#seq.append(name = 'start_LDE',
# trigger_wait = True,
# wfname = start_element.name)
seq.append(name='LDE_lt3',
wfname=LDE_element.name,
trigger_wait=True,
jump_target='RO_dummy',
repetitions=self.joint_params['LDE_attempts_before_CR'])
seq.append(
name='LDE_timeout',
wfname=finished_element.name,
goto_target='LDE_lt3_TPQI_norm' if
self.joint_params['TPQI_normalisation_measurement'] else 'LDE_lt3')
if self.joint_params['TPQI_normalisation_measurement']:
seq.append(name='LDE_lt3_TPQI_norm',
trigger_wait=True,
wfname=LDE_element.name,
jump_target='RO_dummy',
repetitions=self.joint_params['LDE_attempts_before_CR'])
seq.append(name='LDE_timeout_2',
wfname=finished_element.name,
goto_target='LDE_lt3')
seq.append(name='RO_dummy',
wfname=succes_element.name,
goto_target='LDE_lt3')
#qt.pulsar.program_awg(seq,*elements)
qt.pulsar.upload(*elements)
qt.pulsar.program_sequence(seq)
def generate_sequence(self, upload = True, **kw):
qt.pulsar.AWG_sequence_cfg['JUMP_TIMING'] = 0 # ASYNC
seq = pulsar.Sequence('Square Pulses')
seq.set_djump(True)
elements = []
adwin_sync = pulse.SquarePulse(channel='adwin_sync', length = 1e-6, amplitude = 2)
empty = pulse.SquarePulse(channel = 'adwin_sync', length = 1e-6, amplitude = 0)
jump_index = 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_wait.add(pulse.cp(empty), name = e_wait.name)
elements.append(e_wait)
seq.append(name = e_wait.name, wfname = e_wait.name, goto_target = e_loop.name, trigger_wait = True)
# seq.add_djump_address(jump_index, e_wait.name)
e_loop.add(pulse.cp(empty, length = 1e-3), name = e_loop.name)
elements.append(e_loop)
seq.append(name = e_loop.name, wfname = e_loop.name, goto_target = e_wait.name, repetitions = 65536)
for name, ps in kw.iteritems():
jump_index += 1
e = element.Element(name + '-%d' % jump_index, pulsar = qt.pulsar, global_time = True, min_samples = 1e3)
e.add(pulse.cp(ps), name = e.name)
elements.append(e)
seq.append(name = e.name, wfname = e.name, goto_target = e_loop.name)
seq.add_djump_address(jump_index, e.name)
# For some strange reason the last pulse doenst treat goto_target correctly
e_sync = element.Element('sync', pulsar = qt.pulsar, global_time = True, min_samples = 1e3)
e_sync.add(pulse.cp(adwin_sync), name = e_sync.name)
elements.append(e_sync)
seq.append(name = e_sync.name, wfname = e_sync.name, goto_target = e_loop.name)
seq.add_djump_address(0, e_sync.name)
# upload the waveforms to the AWG
if upload:
if upload=='old_method':
qt.pulsar.upload(*elements)
qt.pulsar.program_sequence(seq)
else:
qt.pulsar.program_awg(seq,*elements)
def generate_test_sequence():
RND_halt_combiner_ch = 'RND_halt'
RND_halt_QRNG_ch = 'plu_sync'
sync_ch = 'adwin_success_trigger'
sync = pulse.SquarePulse(channel=sync_ch, length=50e-9, amplitude=2)
RND_halt_QRNG = pulse.SquarePulse(channel=RND_halt_QRNG_ch,
length=200e-9,
amplitude=2)
RND_halt_combiner = pulse.SquarePulse(channel=RND_halt_combiner_ch,
length=200e-9,
amplitude=2)
elt = element.Element('combiner_test_elt', pulsar=qt.pulsar)
elt.add(sync, name='sync_T', start=100e-9)
elt.add(RND_halt_QRNG,
start=500e-9,
refpulse='sync_T',
name='RND_halt_QRNG_p')
elt.add(RND_halt_combiner,
start=100e-9,
refpulse='RND_halt_QRNG_p',
refpoint='start',
name='RND_halt_combiner_p')
elt.add(pulse.cp(sync, amplitude=0, length=15e-6))
elt2 = element.Element('combiner_test_wait_elt', pulsar=qt.pulsar)
elt2.add(pulse.cp(sync, amplitude=0, length=15e-6), start=500e-9)
seq = pulsar.Sequence('combiner_test_seq')
seq.append(name='combiner_test_seq1',
wfname=elt2.name,
repetitions=1,
trigger_wait=True)
seq.append(name='combiner_test_seq2',
wfname=elt.name,
repetitions=50000,
trigger_wait=False)
#seq.append(name = 'photon_after_sync1',
# wfname = syncs_elt_mod0.name,
# repetitions = 100)
#qt.pulsar.upload(no_syncs_elt, syncs_elt_mod0)
#qt.pulsar.program_sequence(seq)
qt.pulsar.program_awg(seq, elt, elt2)
def generate_sequence(self, upload=True):
# electron manipulation pulses
T = pulse.SquarePulse(channel='MW_pulsemod',
length=100e-9,
amplitude=0)
CORPSE = pulselib.IQ_CORPSE_pulse(
'CORPSE 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'])
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))
elts = []
for i in range(self.params['pts']):
e = element.Element('CORPSE-{}'.format(i),
pulsar=qt.pulsar,
global_time=True)
e.append(T)
e.append(
pulse.cp(CORPSE,
amplitude=self.params['CORPSE_sweep_amps'][i],
eff_rotation_angle=self.
params['CORPSE_effective_rotation_angles'][i]))
elts.append(e)
# sequence
seq = pulsar.Sequence('CORPSE (any angle) calibration')
for i, e in enumerate(elts):
seq.append(name=e.name + '-{}'.format(i),
wfname=e.name,
trigger_wait=True)
seq.append(name='sync-{}'.format(i), wfname=sync_elt.name)
# program AWG
if upload:
#qt.pulsar.upload(sync_elt, *elts)
qt.pulsar.program_awg(seq, sync_elt, wait_1us, *elts)
def _add_MBI_and_sweep_elements_to_sequence(self, sweep_elements,
*N_RO_elements, **kw):
append_sync = kw.pop('append_sync', True)
N_RO_repetitions = kw.pop('N_RO_repetitions', 1)
# the sequence
seq = pulsar.Sequence('{}_{} sequence'.format(self.mprefix, self.name))
for i, e in enumerate(sweep_elements):
# the element we jump to after MBI depends on the type of
# list we supply as sweep elements
if type(e) == list:
jmp = 'sweep_element-{}-{}'.format(i, 0)
else:
jmp = 'sweep_element-{}'.format(i)
# for each sweep point we want first an MBI step
seq.append(name='MBI-{}'.format(i),
wfname=self.mbi_elt.name,
trigger_wait=True,
goto_target='MBI-{}'.format(i),
jump_target=jmp)
# append either the only element or the specified sequence of
# elements for this sweep point
if type(e) != list:
seq.append(name='sweep_element-{}'.format(i),
wfname=e.name,
trigger_wait=True)
else:
for j, sub_e in enumerate(e):
seq.append(name='sweep_element-{}-{}'.format(i, j),
wfname=sub_e.name,
trigger_wait=(j == 0))
if append_sync:
seq.append(name='sync-{}'.format(i),
wfname=self.adwin_lt1_trigger_element.name)
for k in range(N_RO_repetitions):
for j, e in enumerate(N_RO_elements):
seq.append(name='N_RO-{}-{}-{}'.format(i, k, j),
wfname=e.name,
trigger_wait=(j == 0 and append_sync))
return seq
def lt2_sequence(self):
print "Make lt2 sequence... "
self.lt2_seq = pulsar.Sequence('TeleportationLT2')
dummy_element = tseq._lt2_dummy_element(self)
LDE_element = tseq._lt2_LDE_element(
self, use_short_eom_pulse=self.params['use_short_eom_pulse'])
finished_element = tseq._lt2_sequence_finished_element(self)
self.lt2_seq.append(
name='LDE_LT2',
wfname=(LDE_element.name
if DO_LDE_SEQUENCE else dummy_element.name),
trigger_wait=True,
# jump_target = 'DD', TODO: not implemented yet
goto_target='LDE_LT2',
repetitions=self.params['LDE_attempts_before_CR'])
elements = []
elements.append(dummy_element)
elements.append(finished_element)
if DO_LDE_SEQUENCE:
elements.append(LDE_element)
qt.pulsar.upload(*elements)
qt.pulsar.program_sequence(self.lt2_seq)
self.awg_lt2.set_runmode('SEQ')
self.awg_lt2.start()
i = 0
awg_ready = False
while not awg_ready and i < 40:
try:
if self.awg_lt2.get_state() == 'Waiting for trigger':
awg_ready = True
except:
print 'waiting for awg: usually means awg is still busy and doesnt respond'
print 'waiting', i, '/40'
i = i + 1
qt.msleep(0.5)
if not awg_ready:
raise Exception('AWG not ready')
def finish(self):
self.awg_lt2.stop()
self.awg_lt2.set_runmode('CONT')
def program_test_slave(reset=False):
T = pulse.SquarePulse('sync', length=10e-9, amplitude=0)
p_sync = pulse.SquarePulse('sync', length=50e-9, amplitude=1)
e = element.Element('Test_trigger', pulsar=qt.pulsar)
e.append(T)
e.append(p_sync)
e.append(pulse.cp(T, length=5e-6))
s = pulsar.Sequence('TEST_AWG_SYNC_lt3')
s.append(name='Slave', wfname=e.name, trigger_wait=1)
if reset:
print 'RESETTING AWG'
qt.pulsar.program_awg(s, e)
else:
qt.pulsar.upload(e)
qt.pulsar.program_sequence(s)
qt.instruments['AWG'].start()
def generate_sequence(self, upload=True):
''' if self.params['setup'] == 'lt4':
bseq.pulse_defs_lt4(self)
elif self.params['setup'] == 'lt3':
bseq.pulse_defs_lt3(self)
'''
# Here is our pi pulse for excitation
eom_pulse = self.eom_pulse
# A handy sync pulse for the time tagger
T_sync = pulse.SquarePulse(channel='sync', length=50e-9, amplitude=0)
# Everyone likes delays
T = pulse.SquarePulse(channel='MW_Imod', name='delay')
T.amplitude = 0.
# make the elements - one for each delay
elements = []
for i, delay in enumerate(self.params['opt_pulse_delays']):
e = element.Element('seq_TPQI_delay-%d' % i, pulsar=qt.pulsar)
e.append(T_sync)
# Add in a bunch of optical pi pulses, separated by our precious delay
for i in range(self.params['opt_pi_pulses']):
name = 'opt pi {}'.format(i + 1)
T.length = delay
e.append(eom_pulse)
e.append(T)
elements.append(e)
print "Done"
# create a sequence from the pulses
seq = pulsar.Sequence('seq_TPQI sequence')
for e in elements:
seq.append(name=e.name, wfname=e.name, trigger_wait=True)
# upload the waveforms to the AWG
if upload:
if upload == 'old_method':
qt.pulsar.upload(*elements)
qt.pulsar.program_sequence(seq)
else:
qt.pulsar.program_awg(seq, *elements)
