def generate_RF_pulse_element(self,Gate):
'''
Written by MB.
Generate arbitrary RF pulse gate, so a pulse that is directly created by the AWG.
Pulse is build up out of a starting element, a repeated middle element and an end
element to save the memory of the AWG.
Copied by MJD 201711
'''
###################
## Set paramters ##
###################
Gate.scheme = 'RF_pulse'
length = Gate.length
freq = Gate.RFfreq
amplitude = Gate.amplitude
prefix = Gate.prefix
phase = Gate.phase
list_of_elements = []
X = pulselib.RF_erf_envelope(
channel = 'RF',
length = length,
frequency = freq,
amplitude = amplitude,
phase = phase)
e_middle = element.Element('%s_RF_pulse_middle' %(prefix), pulsar=qt.pulsar,
global_time = True)
e_middle.append(pulse.cp(X))
list_of_elements.append(e_middle)
Gate.tau_cut = 1e-6
Gate.wait_time = Gate.length + 2e-6
Gate.elements= list_of_elements
return Gate
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)
# mw pulses
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_lt1['MW_pulse_mod_risetime'])
msmt.fast_pi = pulselib.MW_IQmod_pulse(
'MW pi pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=msmt.params_lt1['MW_pulse_mod_risetime'],
frequency=msmt.params_lt1['fast_pi_mod_frq'],
amplitude=msmt.params_lt1['fast_pi_amp'],
length=msmt.params_lt1['fast_pi_duration'])
msmt.fast_pi2 = pulselib.MW_IQmod_pulse(
'MW pi2 pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=msmt.params_lt1['MW_pulse_mod_risetime'],
frequency=msmt.params_lt1['fast_pi2_mod_frq'],
amplitude=msmt.params_lt1['fast_pi2_amp'],
length=msmt.params_lt1['fast_pi2_duration'])
msmt.slow_pi = pulselib.MW_IQmod_pulse(
'slow pi',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=msmt.params_lt1['MW_pulse_mod_risetime'],
frequency=msmt.params_lt1['selective_pi_mod_frq'],
amplitude=msmt.params_lt1['selective_pi_amp'],
length=msmt.params_lt1['selective_pi_duration'])
msmt.shelving_pulse = pulselib.MW_IQmod_pulse(
'MBI shelving pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
frequency=msmt.params_lt1['AWG_MBI_MW_pulse_mod_frq'],
amplitude=msmt.params_lt1['fast_pi_amp'],
length=msmt.params_lt1['fast_pi_duration'],
PM_risetime=msmt.params_lt1['MW_pulse_mod_risetime'])
# CORPSE pi pulse
msmt.CORPSE_pi = pulselib.IQ_CORPSE_pi_pulse(
'CORPSE pi-pulse',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=msmt.params_lt1['MW_pulse_mod_risetime'],
frequency=msmt.params_lt1['CORPSE_pi_mod_frq'],
amplitude=msmt.params_lt1['CORPSE_pi_amp'],
length_60=msmt.params_lt1['CORPSE_pi_60_duration'],
length_m300=msmt.params_lt1['CORPSE_pi_m300_duration'],
length_420=msmt.params_lt1['CORPSE_pi_420_duration'])
# CNOT operations on the electron
msmt.pi2pi_m1 = pulselib.MW_IQmod_pulse(
'pi2pi pulse mI=-1',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=msmt.params_lt1['MW_pulse_mod_risetime'],
frequency=msmt.params_lt1['pi2pi_mIm1_mod_frq'],
amplitude=msmt.params_lt1['pi2pi_mIm1_amp'],
length=msmt.params_lt1['pi2pi_mIm1_duration'])
msmt.pi2pi_0 = pulselib.MW_IQmod_pulse(
'pi2pi pulse mI=0',
I_channel='MW_Imod',
Q_channel='MW_Qmod',
PM_channel='MW_pulsemod',
PM_risetime=msmt.params_lt1['MW_pulse_mod_risetime'],
frequency=msmt.params_lt1['pi2pi_mI0_mod_frq'],
amplitude=msmt.params_lt1['pi2pi_mI0_amp'],
length=msmt.params_lt1['pi2pi_mI0_duration'])
# rf pulses
msmt.TN = pulse.SquarePulse(channel='RF', length=100e-9, amplitude=0)
msmt.N_pulse = pulselib.RF_erf_envelope(
channel='RF', frequency=msmt.params_lt1['N_0-1_splitting_ms-1'])
msmt.N_pi = pulselib.RF_erf_envelope(
channel='RF',
frequency=msmt.params_lt1['N_0-1_splitting_ms-1'],
length=msmt.params_lt1['N_pi_duration'],
amplitude=msmt.params_lt1['N_pi_amp'])
msmt.N_pi2 = pulselib.RF_erf_envelope(
channel='RF',
frequency=msmt.params_lt1['N_0-1_splitting_ms-1'],
length=msmt.params_lt1['N_pi2_duration'],
amplitude=msmt.params_lt1['N_pi2_amp'])
### synchronizing, etc
msmt.adwin_lt1_trigger_pulse = pulse.SquarePulse(channel='adwin_sync',
length=10e-6,
amplitude=2)
msmt.adwin_lt1_trigger_pulse_mbi = pulse.SquarePulse(channel='adwin_sync',
length=17e-6,
amplitude=2)
# mbi pulse trigger should be longer, because it needs to receive a jump from the ADwin while still going.
# it also needs to be short enough such that it is finished when the ADWin triggers the next element
msmt.AWG_LT2_trigger_pulse = pulse.SquarePulse(channel='AWG_LT2_trigger',
length=10e-9,
amplitude=2)
msmt.HH_sync = pulse.SquarePulse(channel='HH_sync',
length=50e-9,
amplitude=1.0)
# light
msmt.SP_pulse = pulse.SquarePulse(channel='Velocity1AOM', amplitude=1.0)
msmt.yellow_pulse = pulse.SquarePulse(channel='YellowAOM', amplitude=1.0)
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()
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)
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)