def __init__(self,
channel_dict=default_digi_dict,
laser_time=150 * Q_(1, "us"),
readout_time=150 * Q_(1, "us"),
buffer_after_init=450 * Q_(1, "us"),
buffer_after_readout=2 * Q_(1, "us"),
polarize_time=900 * Q_(1, "us"),
settle=150 * Q_(1, "us"),
reset=100 * Q_(1, "ns"),
IQ=[0.5, 0],
ip="192.168.1.111"):
"""
:param channel_dict: Dictionary of which channels correspond to which instr controls
:param laser_time: Laser time in us
:param CTR: When False CTR0 When True CTR1
:param readout_time: Readout time in us
:param buffer_after_init: Buffer after laser turns off in us to allow the population to thermalize
:param buffer_after_readout: Buffer between the longest pulse and the readout in us to prevent laser to leak in
:param IQ: IQ vector that rotates the spin
"""
super().__init__()
self.channel_dict = channel_dict
self.laser_time = int(round(laser_time.to("ns").magnitude))
self.readout_time = int(round(readout_time.to("ns").magnitude))
self.buffer_after_init = int(
round(buffer_after_init.to("ns").magnitude))
self.buffer_after_readout = int(
round(buffer_after_readout.to("ns").magnitude))
self.polarize_time = int(round(polarize_time.to("ns").magnitude))
self.settle = int(round(settle.to("ns").magnitude))
self.reset = int(round(reset.to("ns").magnitude))
self._normalize_IQ(IQ)
self.Pulser = PulseStreamer(ip)
def __init__(self,
channel_dict=default_digi_dict,
laser_time=150 * Q_(1, "us"),
readout_time=150 * Q_(1, "us"),
buf_after_init=450 * Q_(1, "us"),
buf_after_readout=2 * Q_(1, "us"),
polarize_time=900 * Q_(1, "us"),
settle=150 * Q_(1, "us"),
reset=100 * Q_(1, "ns"),
IQ=[0.5, 0],
ip="192.168.1.111"):
"""
:param channel_dict: Dictionary of which channels correspond to which instr controls
:param laser_time: Laser time in us
:param CTR: When False CTR0 When True CTR1
:param readout_time: Readout time in us
:param buf_after_init: buf after laser turns off in us to allow the population to thermalize
:param buf_after_readout: buf between the longest pulse and the readout in us to prevent laser to leak in
:param IQ: IQ vector that rotates the spin
"""
super().__init__()
self.channel_dict = channel_dict
self._reverse_dict = {
0: "laser",
1: "offr_laser",
2: 'current_gate',
3: 'laser2',
4: "EOM",
5: "CTR",
6: "switch",
7: "gate",
8: "I",
9: "V"
} # rev_dict
self.laser_time = int(round(laser_time.to("ns").magnitude))
self.readout_time = int(round(readout_time.to("ns").magnitude))
self.buf_after_init = int(round(buf_after_init.to("ns").magnitude))
self.buf_after_readout = int(
round(buf_after_readout.to("ns").magnitude))
self.polarize_time = int(round(polarize_time.to("ns").magnitude))
self.settle = int(round(settle.to("ns").magnitude))
self.reset = int(round(reset.to("ns").magnitude))
self._normalize_IQ(IQ)
self.Pulser = PulseStreamer(ip)
self.latest_streamed = pd.DataFrame({})
self.total_time = -1 # update when a pulse sequence is streamed
class Pulses(Driver):
default_digi_dict = {
"laser": "ch0",
"offr_laser": "ch1",
'laser2': 'ch3',
"EOM": "ch4",
"CTR": "ch5",
"switch": "ch6",
"gate": "ch7",
"": None
}
default_digi_dict = {
"laser": 0,
"offr_laser": 1,
'laser2': 3,
"EOM": 4,
"CTR": 5,
"switch": 6,
"gate": 7,
"": None
}
rev_dict = {
0: "laser",
1: "offr_laser",
3: 'laser2',
4: "EOM",
5: "CTR",
6: "switch",
7: "gate",
8: "I",
9: "Q"
}
def __init__(self,
channel_dict=default_digi_dict,
laser_time=150 * Q_(1, "us"),
readout_time=150 * Q_(1, "us"),
buf_after_init=450 * Q_(1, "us"),
buf_after_readout=2 * Q_(1, "us"),
polarize_time=900 * Q_(1, "us"),
settle=150 * Q_(1, "us"),
reset=100 * Q_(1, "ns"),
IQ=[0.5, 0],
ip="192.168.1.111"):
"""
:param channel_dict: Dictionary of which channels correspond to which instr controls
:param laser_time: Laser time in us
:param CTR: When False CTR0 When True CTR1
:param readout_time: Readout time in us
:param buf_after_init: buf after laser turns off in us to allow the population to thermalize
:param buf_after_readout: buf between the longest pulse and the readout in us to prevent laser to leak in
:param IQ: IQ vector that rotates the spin
"""
super().__init__()
self.channel_dict = channel_dict
self._reverse_dict = {
0: "laser",
1: "offr_laser",
3: 'laser2',
4: "EOM",
5: "CTR",
6: "switch",
7: "gate",
8: "I",
9: "Q"
} # rev_dict
self.laser_time = int(round(laser_time.to("ns").magnitude))
self.readout_time = int(round(readout_time.to("ns").magnitude))
self.buf_after_init = int(round(buf_after_init.to("ns").magnitude))
self.buf_after_readout = int(
round(buf_after_readout.to("ns").magnitude))
self.polarize_time = int(round(polarize_time.to("ns").magnitude))
self.settle = int(round(settle.to("ns").magnitude))
self.reset = int(round(reset.to("ns").magnitude))
self._normalize_IQ(IQ)
self.Pulser = PulseStreamer(ip)
self.latest_streamed = pd.DataFrame({})
self.total_time = -1 # update when a pulse sequence is streamed
@Feat()
def has_sequence(self):
"""
Has Sequence
"""
return self.Pulser.hasSequence()
def stream(self, seq):
self.latest_streamed = self.convert_sequence(seq)
self.Pulser.stream(seq)
def _normalize_IQ(self, IQ):
self.IQ = IQ / (2 * np.linalg.norm(IQ))
def convert_sequence(self, seqs):
# 0-7 are the 8 digital channels
# 8-9 are the 2 analog channels
data = {}
time = -0.01
for seq in seqs:
col = np.zeros(10)
col[seq[1]] = 1
col[8] = seq[2]
col[9] = seq[3]
init_time = time + 0.01
data[init_time] = col
time = time + seq[0]
# data[prev_time_stamp + 0.01] = col
data[time] = col
# prev_time_stamp = seq[0]
dft = pd.DataFrame(data)
df = dft.T
sub_df = df[list(self._reverse_dict.keys())]
fin = sub_df.rename(columns=self._reverse_dict)
return fin
# Constant Pulse Sequences
def Transient_Measure(self):
excitation = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
buf = \
[(self.buf_after_readout, [], *self.IQ)]
self.total_time = self.laser_time + self.buf_after_init + self.readout_time + self.buf_after_readout
return excitation + bg_decay + readout + buf
def Continuous_Measure(self):
excitation = \
[(int(1e9), [self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["gate"],
self.channel_dict["EOM"], self.channel_dict["switch"]], 0.5, 0)]
self.total_time = int(1e9)
return excitation
def CODMR(self):
excitation = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["switch"]],
*self.IQ)]
bg_decay = \
[(self.buf_after_init, [self.channel_dict["switch"]], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["switch"], self.channel_dict["gate"]], *self.IQ)]
buf = \
[(self.buf_after_readout, [self.channel_dict["switch"]], *self.IQ)]
self.total_time = self.laser_time + self.buf_after_init + self.readout_time + self.buf_after_readout
return excitation + bg_decay + readout + buf
def EOM(self):
excitation = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["switch"],
self.channel_dict["EOM"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [self.channel_dict["switch"], self.channel_dict["EOM"]], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["switch"], self.channel_dict["gate"], self.channel_dict["EOM"]],
*self.IQ)]
buf = \
[(self.buf_after_readout, [self.channel_dict["switch"], self.channel_dict["EOM"]], *self.IQ)]
self.total_time = self.laser_time + self.buf_after_init + self.readout_time + self.buf_after_readout
return excitation + bg_decay + readout + buf
def Finder(self):
total_time = self.laser_time + self.buf_after_readout + self.readout_time + self.buf_after_readout
rep = int(3e7 / (2 * total_time))
excitation = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["switch"],
self.channel_dict["EOM"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [self.channel_dict["switch"]], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["switch"], self.channel_dict["gate"]], *self.IQ)]
buf = \
[(self.buf_after_readout, [self.channel_dict["switch"]], *self.IQ)]
L_excitation = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"]], *self.IQ)]
L_bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
L_buf = \
[(self.buf_after_readout, [], *self.IQ)]
sig = excitation + bg_decay + readout + buf
bg = L_excitation + L_bg_decay + L_readout + L_buf
return rep * sig + rep * bg
# Single Color Pulsed ODMR
def S_Pulsed_ODMR(self, pi):
excitation = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
rabi = \
[(pi, [self.channel_dict["switch"]], *self.IQ)]
wait = \
[(self.buf_after_readout, [], *self.IQ)]
self.total_time = self.laser_time + self.buf_after_init + pi + self.readout_time + self.buf_after_readout
return excitation + bg_decay + readout + rabi + wait
# EOM Pulsed ODMR
def D_Pulsed_ODMR(self, pi):
polarize = \
[(self.polarize_time, [self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["EOM"]],
*self.IQ)]
settle = \
[(self.settle, [], *self.IQ)]
pi_pulse = \
[(pi, [self.channel_dict["switch"]], *self.IQ)]
probe = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
wait = \
[(self.buf_after_readout, [], *self.IQ)]
self.total_time = self.polarize_time + self.settle + pi + self.laser_time + self.buf_after_init + self.readout_time + self.buf_after_readout
return polarize + settle + pi_pulse + probe + bg_decay + readout + wait
# Lockin Style EOM Pulsed ODMR
def L_D_Pulsed_ODMR(self, pi):
polarize = \
[(self.polarize_time, [self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["EOM"]],
*self.IQ)]
settle = \
[(self.settle, [], *self.IQ)]
pi_pulse = \
[(pi, [self.channel_dict["switch"]], *self.IQ)]
probe = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
wait = \
[(self.buf_after_readout, [], *self.IQ)]
L_pi_pulse = \
[(pi, [], *self.IQ)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
self.total_time = self.polarize_time + self.settle + pi + self.laser_time + self.buf_after_init + self.readout_time + self.buf_after_readout
return polarize + settle + pi_pulse + probe + bg_decay + readout + wait + \
polarize + settle + L_pi_pulse + probe + bg_decay + L_readout + wait
# Time Varying Pulse Sequences
# EOM Hole burnt Lockin Style Rabi
def Resetting_L_Rabi(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
def single_rabi(mw_on):
# wait = self.reset + self.polarize_time + self.buf_after_init * 2 + self.settle + longest_time + self.laser_time + self.readout_time - mw_on
wait = longest_time - mw_on
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], *self.IQ)]
polarize = \
[(self.polarize_time,
[self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["EOM"]], *self.IQ)]
# bg_decay = \
# [(self.buf_after_init, [], *self.IQ)]
background = \
[(self.settle, [], *self.IQ)]
rabi = \
[(mw_on, [self.channel_dict["switch"]], *self.IQ)]
probe = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
# Lockin Part
L_rabi = \
[(mw_on, [], *self.IQ)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return reset + polarize + background + rabi + wait + probe + bg_decay + readout + \
reset + polarize + background + L_rabi + wait + probe + bg_decay + L_readout
self.total_time = self.reset + self.polarize_time + self.settle + longest_time + self.laser_time + self.buf_after_init + self.readout_time
seqs = [
single_rabi(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
# def Resetting_L_EOM_Rabi(self, params):
# longest_time = int(round(params["stop"].to("ns").magnitude))
# def single_rabi(mw_on):
# wait = longest_time - mw_on
# polarize = \
# [(self.polarize_time, [self.channel_dict["laser"],self.channel_dict["laser2"], self.channel_dict["EOM"]], *self.IQ)]
# background = \
# [(self.settle, [], *self.IQ)]
# rabi = \
# [(mw_on, [self.channel_dict["switch"]], *self.IQ)]
# probe = \
# [(self.laser_time, [self.channel_dict["laser"],self.channel_dict["laser2"]], *self.IQ)]
# bg_decay = \
# [(self.buf_after_init, [], *self.IQ)]
# readout = \
# [(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
# #Lockin Part
# L_rabi = \
# [(mw_on, [], *self.IQ)]
# L_readout = \
# [(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
# wait = \
# [(wait, [], *self.IQ)]
# return polarize + background + rabi + wait + probe + bg_decay + readout + \
# polarize + background + L_rabi + wait + probe + bg_decay + L_readout
# self.total_time = self.polarize_time + self.settle + longest_time + self.laser_time + self.buf_after_init + self.readout_time
# seqs = [single_rabi(int(round(mw_time.to("ns").magnitude))) for mw_time in params.array]
# return seqs
def Resetting_L_Ramsey(self, params, pi):
'''
:param params: the iteration array
:param pi: length of the physik_instrumente pulse
:return: an array of pulse sequences
'''
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(pi.to("ns").magnitude)
def single_ramsey(tau):
wait = longest_time - tau
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], *self.IQ)]
polarize = \
[(self.polarize_time,
[self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["EOM"]], *self.IQ)]
background = \
[(self.settle, [], *self.IQ)]
first_pi = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
dephase = \
[(tau, [], *self.IQ)]
second_pi = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
probe = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
# Lockin Part
L_first_pi = \
[(pi_ns // 2, [], *self.IQ)]
L_dephase = \
[(tau, [], *self.IQ)]
L_second_pi = \
[(pi_ns // 2, [], *self.IQ)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return reset + polarize + background + first_pi + dephase + second_pi + wait + probe + bg_decay + readout + \
reset + polarize + background + L_first_pi + L_dephase + L_second_pi + wait + probe + bg_decay + L_readout
self.total_time = self.reset + self.polarize_time + self.settle + pi_ns + longest_time + self.laser_time + self.buf_after_init + self.readout_time
seqs = [
single_ramsey(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_L_T2(self, params, pi, style=[[-1, 0], [1, 0], [1, 0]]):
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(round(pi.to("ns").magnitude))
if style[0] == [0, 0]:
f_pi2 = [0, 0]
first_pi2gate = []
else:
f_pi2 = style[0] / (2 * np.linalg.norm(style[0]))
first_pi2gate = [self.channel_dict["switch"]]
if style[1] == [0, 0]:
L_pi = [0, 0]
pigate = []
else:
L_pi = style[1] / (2 * np.linalg.norm(style[1]))
pigate = [self.channel_dict["switch"]]
if style[2] == [0, 0]:
s_pi2 = [0, 0]
second_pi2gate = []
else:
s_pi2 = style[2] / (2 * np.linalg.norm(style[2]))
second_pi2gate = [self.channel_dict["switch"]]
def single_T2(tau):
wait = longest_time - tau
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], *self.IQ)]
polarize = \
[(self.polarize_time,
[self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["EOM"]], *self.IQ)]
background = \
[(self.settle, [], *self.IQ)]
first_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
dephase = \
[(tau // 2, [], *self.IQ)]
flip = \
[(pi_ns, [self.channel_dict["switch"]], *self.IQ)]
rephase = \
[(tau // 2, [], *self.IQ)]
second_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
probe = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
# Lockin Part
L_background = \
[(self.settle, [], *f_pi2)]
L_first_pi2 = \
[(pi_ns // 2, first_pi2gate, *f_pi2)]
L_dephase = \
[(tau // 2, [], *L_pi)]
L_flip = \
[(pi_ns, pigate, *L_pi)]
L_rephase = \
[(tau // 2, [], *s_pi2)]
L_second_pi2 = \
[(pi_ns // 2, second_pi2gate, *s_pi2)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return reset + polarize + background + first_pi2 + dephase + flip + rephase + second_pi2 + wait + probe + bg_decay + readout + \
reset + polarize + L_background + L_first_pi2 + L_dephase + L_flip + L_rephase + L_second_pi2 + wait + probe + bg_decay + L_readout
self.total_time = self.reset + self.polarize_time + self.settle + pi_ns * 2 + longest_time + self.laser_time + self.buf_after_init + self.readout_time
seqs = [
single_T2(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_L_Y_T2(self, params, pi):
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(round(pi.to("ns").magnitude))
def single_T2(tau):
wait = longest_time - tau
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], *self.IQ)]
polarize = \
[(self.polarize_time,
[self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["EOM"]], *self.IQ)]
background = \
[(self.settle, [], -0.5, 0)]
first_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], -0.5, 0)]
dephase = \
[(tau // 2, [], 0, 0.5)]
flip = \
[(pi_ns, [self.channel_dict["switch"]], 0, 0.5)]
rephase = \
[(tau // 2, [], 0.5, 0)]
second_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], 0.5, 0)]
probe = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
# Lockin Part
L_background = \
[(self.settle, [], 0.5, 0)]
L_first_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], 0.5, 0)]
L_dephase = \
[(tau // 2, [], 0, 0.5)]
L_flip = \
[(pi_ns, [self.channel_dict["switch"]], 0, 0.5)]
L_rephase = \
[(tau // 2, [], 0.5, 0)]
L_second_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], 0.5, 0)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return reset + polarize + background + first_pi2 + dephase + flip + rephase + second_pi2 + wait + probe + bg_decay + readout + \
reset + polarize + L_background + L_first_pi2 + L_dephase + L_flip + L_rephase + L_second_pi2 + wait + probe + bg_decay + L_readout
self.total_time = self.reset + self.polarize_time + self.settle + pi_ns * 2 + longest_time + self.laser_time + self.buf_after_init + self.readout_time
seqs = [
single_T2(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_L_CPMG(self, params, pi, N):
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(round(pi.to("ns").magnitude))
def CPMG_core(tau, N, IQ=[1, 0]):
L_pi2_IQ = IQ / (2 * np.linalg.norm(IQ))
L_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], *L_pi2_IQ)]
pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
wait_pi2 = \
[(tau // (2 * N), [], *self.IQ)]
pi = [(pi_ns, [self.channel_dict["switch"]], *self.IQ)]
return L_pi2 + N * (wait_pi2 + pi + wait_pi2) + pi2
def single_T2(tau):
wait = longest_time - tau
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], *self.IQ)]
polarize = \
[(self.polarize_time,
[self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["EOM"]], *self.IQ)]
background = \
[(self.settle, [], *self.IQ)]
CPMG_Core = CPMG_core(tau, N=N, IQ=[1, 0])
probe = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
# Lockin Part
L_background = \
[(self.settle, [], -0.5, 0)]
L_CPMG_Core = CPMG_core(tau, N=N, IQ=[-1, 0])
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return reset + polarize + background + CPMG_Core + wait + probe + bg_decay + readout + \
reset + polarize + L_background + L_CPMG_Core + wait + probe + bg_decay + L_readout
self.total_time = self.reset + self.polarize_time + self.settle + pi_ns * (
1 + N
) + longest_time + self.laser_time + self.buf_after_init + self.readout_time
seqs = [
single_T2(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_L_T1(self, params, pi):
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(round(pi.to("ns").magnitude))
def single_T1(tau):
# wait = self.reset + self.polarize_time + self.buf_after_init * 2 + self.settle + longest_time + self.laser_time + self.readout_time - mw_on
wait = longest_time - tau + self.buf_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], *self.IQ)]
polarize = \
[(self.polarize_time,
[self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["EOM"]], *self.IQ)]
background = \
[(self.settle, [], *self.IQ)]
tau_wait = \
[(tau, [], *self.IQ)]
flip = \
[(pi_ns, [self.channel_dict["switch"]], *self.IQ)]
flip2 = \
[(pi_ns, [], *self.IQ)]
probe = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
# Lockin Part
L_flip = \
[(2 * pi_ns, [self.channel_dict["switch"]], *self.IQ)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return reset + polarize + background + tau_wait + flip + probe + bg_decay + readout + wait + \
reset + polarize + background + tau_wait + L_flip + probe + bg_decay + L_readout + wait
self.total_time = self.reset + self.polarize_time + self.settle + 2 * pi_ns + longest_time + self.laser_time + self.buf_after_init + self.readout_time + self.buf_after_readout
seqs = [
single_T1(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_L_T1_Adaptive(self, params, pi):
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(round(pi.to("ns").magnitude))
def single_T1(tau):
# wait = self.reset + self.polarize_time + self.buf_after_init * 2 + self.settle + longest_time + self.laser_time + self.readout_time - mw_on
wait = longest_time - tau
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], *self.IQ)]
polarize = \
[(self.polarize_time,
[self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["EOM"]], *self.IQ)]
background = \
[(self.settle, [], *self.IQ)]
tau_wait = \
[(tau, [], *self.IQ)]
flip = \
[(pi_ns, [self.channel_dict["switch"]], *self.IQ)]
flip2 = \
[(pi_ns, [], *self.IQ)]
probe = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
wait_readout = \
[(self.buf_after_readout, [], *self.IQ)]
# Lockin Part
L_flip = \
[(2 * pi_ns, [self.channel_dict["switch"]], *self.IQ)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
wait = \
[(wait, [], 0, 0)]
return reset + polarize + background + flip + flip2 + tau_wait + probe + bg_decay + readout + wait_readout + \
reset + polarize + background + L_flip + tau_wait + probe + bg_decay + L_readout + wait_readout
self.total_time = self.reset + self.polarize_time + self.settle + 2 * pi_ns + longest_time + self.laser_time + self.buf_after_init + self.readout_time + self.buf_after_readout
seqs = [
single_T1(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Polarization_Time(self, params, pi):
'''
:param params: the iteration array
:param pi: length of the physik_instrumente pulse
:return: an array of pulse sequences
'''
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(pi.to("ns").magnitude)
def single_polarization(tau):
wait = longest_time - tau
polarize = \
[(tau, [self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["EOM"]], *self.IQ)]
background = \
[(self.settle, [], *self.IQ)]
pi = \
[(pi_ns, [self.channel_dict["switch"]], *self.IQ)]
probe = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"]], *self.IQ)]
readout_reset = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
# Lockin Part
L_pi = \
[(pi_ns, [], *self.IQ)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return polarize + background + pi + probe + readout_reset + bg_decay + readout + wait + \
polarize + background + L_pi + probe + readout_reset + bg_decay + L_readout + wait
self.total_time = longest_time + self.settle + pi_ns + self.laser_time + pi_ns // 2 + self.buf_after_init + self.readout_time
seqs = [
single_polarization(int(round(laser_time.to("ns").magnitude)))
for laser_time in params.array
]
return seqs
def res_background_Topt(self, params):
start_time = int(round(params["start"].to("ns").magnitude))
end_time = int(round(params["stop"].to("ns").magnitude))
bin_time = int(round(params["step"].to("ns").magnitude))
num_bins = len(params.array)
dur = end_time - start_time
def single_Topt(i):
# While the bin overlaps with the laser but not the transient
remainin_laser_overlap = self.laser_time - bin_time * (
i + 1) - start_time
if remainin_laser_overlap > 0:
excitation = \
[(int(start_time + i * bin_time), [self.channel_dict["laser"], self.channel_dict["laser2"]],
*self.IQ)]
binned_excitation = \
[(bin_time, [self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["gate"]],
*self.IQ)]
rest_excitation = \
[(int(self.laser_time - bin_time * (i + 1) - start_time),
[self.channel_dict["laser"], self.channel_dict["laser2"]], *self.IQ)]
wait = \
[(self.settle, [], *self.IQ)]
return excitation + binned_excitation + rest_excitation + wait
# While the bin overlaps with transient but not the laser
else:
bin_in_laser = bin_time + remainin_laser_overlap
if bin_in_laser < 0:
rev_bin_number = num_bins - i
excitation = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"]], *self.IQ)]
before_bin = \
[(int(i * bin_time) - self.laser_time, [], *self.IQ)]
binned_PL = \
[(bin_time, [self.channel_dict["gate"]], *self.IQ)]
after_bin = \
[(int(self.settle + self.laser_time - bin_time * (i + 1) + 1), [], *self.IQ)]
return excitation + before_bin + binned_PL + after_bin
# If the bin overlaps with both the laser and the transient
else:
bin_in_readout = -1 * remainin_laser_overlap
excitation1 = \
[(
int(self.laser_time - bin_in_laser),
[self.channel_dict["laser"], self.channel_dict["laser2"]],
*self.IQ)]
excitation2 = \
[(bin_in_laser,
[self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["gate"]],
*self.IQ)]
readout1 = \
[(bin_in_readout, [self.channel_dict["gate"]], *self.IQ)]
readout2 = \
[(int(self.settle - bin_in_readout), [], *self.IQ)]
return excitation1 + excitation2 + readout1 + readout2
self.total_time = end_time
seqs = [single_Topt(i) for i in np.arange(num_bins)]
return seqs
def res_Topt(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
bin_time = int(round(params["step"].to("ns").magnitude))
def single_T1(start):
wait = longest_time - start + bin_time
excitation = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["laser2"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
before_bin = \
[(start, [], *self.IQ)]
readout = \
[(bin_time, [self.channel_dict["gate"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return excitation + bg_decay + before_bin + readout + wait
self.total_time = self.laser_time + self.buf_after_init + longest_time + bin_time
seqs = [
single_T1(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def res_Topt_MW(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
bin_time = int(round(params["step"].to("ns").magnitude))
def single_T1(start):
wait = longest_time - start + bin_time + self.buf_after_readout
excitation = \
[(self.laser_time,
[self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["switch"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [self.channel_dict["switch"]], *self.IQ)]
before_bin = \
[(start, [self.channel_dict["switch"]], *self.IQ)]
readout = \
[(bin_time, [self.channel_dict["gate"], self.channel_dict["switch"]], *self.IQ)]
wait = \
[(wait, [self.channel_dict["switch"]], *self.IQ)]
return excitation + bg_decay + before_bin + readout + wait
self.total_time = self.laser_time + self.buf_after_init + longest_time + bin_time
seqs = [
single_T1(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def off_res_Topt(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
bin_time = int(round(params["step"].to("ns").magnitude))
def single_T1(start):
wait = longest_time - start + bin_time + self.buf_after_readout
excitation = \
[(self.laser_time, [self.channel_dict["offr_laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
before_bin = \
[(start, [], *self.IQ)]
readout = \
[(bin_time, [self.channel_dict["gate"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return excitation + bg_decay + before_bin + readout + wait
self.total_time = self.laser_time + self.buf_after_init + longest_time + bin_time
seqs = [
single_T1(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def red_Laser_Power(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
def single_RLP(e_time):
wait = longest_time - e_time + self.buf_after_readout
# wait = self.buf_after_readout
excitation = \
[(e_time, [self.channel_dict["offr_laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return excitation + bg_decay + readout + wait
self.total_time = longest_time + self.buf_after_init + self.readout_time + self.buf_after_readout
seqs = [
single_RLP(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Laser_Power(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
def single_LP(e_time):
wait = longest_time - e_time + self.buf_after_readout
# wait = self.buf_after_readout
excitation = \
[(e_time, [self.channel_dict["laser"], self.channel_dict["laser2"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return excitation + bg_decay + readout + wait
self.total_time = longest_time + self.buf_after_init + self.readout_time + self.buf_after_readout
seqs = [
single_LP(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Laser_Power_MW(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
def single_LP(e_time):
wait = longest_time - e_time + self.buf_after_readout
# wait = self.buf_after_readout
excitation = \
[(e_time, [self.channel_dict["laser"], self.channel_dict["laser2"], self.channel_dict["switch"]],
*self.IQ)]
bg_decay = \
[(self.buf_after_init, [self.channel_dict["switch"]], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["switch"]], *self.IQ)]
wait = \
[(wait, [self.channel_dict["switch"]], *self.IQ)]
return excitation + bg_decay + readout + wait
self.total_time = longest_time + self.buf_after_init + self.readout_time + self.buf_after_readout
seqs = [
single_LP(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
# Don't worry about this...
def L_Inv_Optical_Rabi(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
def single_OR(e_time):
wait = longest_time - e_time
# wait = self.buf_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], 0, 0)]
background = \
[(self.settle, [self.channel_dict["offr_laser"]], 0, 0)]
excitation = \
[(e_time, [self.channel_dict["laser"], self.channel_dict["laser2"]], 0, 0)]
bg_decay = \
[(self.buf_after_init, [], 0, 0)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
wait = \
[(wait, [], 0, 0)]
L_excitation = \
[(e_time, [], 0, 0)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], 0, 0)]
return reset + background + excitation + bg_decay + readout + wait + \
reset + background + L_excitation + bg_decay + L_readout + wait
seqs = [
single_OR(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
class Pulses(Driver):
default_digi_dict = {
"laser": "ch0",
"offr_laser": "ch1",
"CTR": "ch5",
"switch": "ch6",
"gate": "ch7",
"": None
}
default_anal_dict = {"ai0": "I", "ai1": "Q"}
def __init__(self,
channel_dict=default_digi_dict,
laser_time=150 * Q_(1, "us"),
readout_time=150 * Q_(1, "us"),
buffer_after_init=450 * Q_(1, "us"),
buffer_after_readout=2 * Q_(1, "us"),
polarize_time=900 * Q_(1, "us"),
settle=150 * Q_(1, "us"),
reset=100 * Q_(1, "ns"),
IQ=[0.5, 0],
ip="192.168.1.111"):
"""
:param channel_dict: Dictionary of which channels correspond to which instr controls
:param laser_time: Laser time in us
:param CTR: When False CTR0 When True CTR1
:param readout_time: Readout time in us
:param buffer_after_init: Buffer after laser turns off in us to allow the population to thermalize
:param buffer_after_readout: Buffer between the longest pulse and the readout in us to prevent laser to leak in
:param IQ: IQ vector that rotates the spin
"""
super().__init__()
self.channel_dict = channel_dict
self.laser_time = int(round(laser_time.to("ns").magnitude))
self.readout_time = int(round(readout_time.to("ns").magnitude))
self.buffer_after_init = int(
round(buffer_after_init.to("ns").magnitude))
self.buffer_after_readout = int(
round(buffer_after_readout.to("ns").magnitude))
self.polarize_time = int(round(polarize_time.to("ns").magnitude))
self.settle = int(round(settle.to("ns").magnitude))
self.reset = int(round(reset.to("ns").magnitude))
self._normalize_IQ(IQ)
self.Pulser = PulseStreamer(ip)
@Feat()
def has_sequence(self):
"""
Has Sequence
"""
return self.Pulser.hasSequence()
def stream(self, seq):
initial = (0, [], 0, 0)
final = (0, [], 0, 0)
underflow = (0, [], 0, 0)
self.Pulser.stream(seq, -1, initial, final, underflow, "IMMEDIATE")
def _normalize_IQ(self, IQ):
norm_iq = IQ / (2 * np.linalg.norm(IQ))
self.I = norm_iq[0]
self.Q = norm_iq[1]
def Transient_Measure(self):
excitation = \
[(self.laser_time, [self.channel_dict["laser"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
buffer = \
[(self.buffer_after_readout, [], 0, 0)]
return excitation + bg_decay + readout + buffer
def CODMR(self):
excitation = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["switch"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [self.channel_dict["switch"]], 0, 0)]
readout = \
[(self.readout_time, [self.channel_dict["switch"], self.channel_dict["gate"]], 0, 0)]
buffer = \
[(self.buffer_after_readout, [self.channel_dict["switch"]], 0, 0)]
return excitation + bg_decay + readout + buffer
def L_CODMR(self, measure=0):
s_excitation = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["switch"]], 0, 0)]
s_bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
s_readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
s_buffer = \
[(self.buffer_after_readout, [], 0, 0)]
s = s_excitation + s_bg_decay + s_readout + s_buffer
m_excitation = \
[(self.laser_time, [self.channel_dict["laser"]], 0, 0)]
m_bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
m_readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
m_buffer = \
[(self.buffer_after_readout, [], 0, 0)]
m = m_excitation + m_bg_decay + m_readout + m_buffer
b_excitation = \
[(self.laser_time, [self.channel_dict["CTR"], self.channel_dict["laser"]], 0, 0)]
b_bg_decay = \
[(self.buffer_after_init, [self.channel_dict["CTR"]], 0, 0)]
b_readout = \
[(self.readout_time, [self.channel_dict["CTR"], self.channel_dict["gate"]], 0, 0)]
b_buffer = \
[(self.buffer_after_readout, [self.channel_dict["CTR"]], 0, 0)]
b = b_excitation + b_bg_decay + b_readout + b_buffer
return s + m * measure + b
def Rabi(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
def single_rabi(mw_on):
wait = longest_time - mw_on + self.buffer_after_readout
excitation = \
[(self.laser_time, [self.channel_dict["laser"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
rabi = \
[(mw_on, [self.channel_dict["switch"]], 0, 0)]
wait = \
[(wait, [], 0, 0)]
return excitation + bg_decay + readout + rabi + wait
seqs = [
single_rabi(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_Rabi(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
def single_rabi(mw_on):
# wait = self.reset + self.polarize_time + self.buffer_after_init * 2 + self.settle + longest_time + self.laser_time + self.readout_time - mw_on
wait = longest_time - mw_on + self.buffer_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], 0, 0)]
polarize = \
[(self.polarize_time, [self.channel_dict["laser"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
background = \
[(self.settle, [self.channel_dict["gate"], self.channel_dict["CTR"]], 0, 0)]
rabi = \
[(mw_on, [self.channel_dict["switch"]], 0, 0)]
probe = \
[(self.laser_time, [self.channel_dict["laser"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
wait = \
[(wait, [], 0, 0)]
return reset + polarize + bg_decay + background + rabi + probe + bg_decay + readout + wait
seqs = [
single_rabi(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_L_Rabi(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
def single_rabi(mw_on):
# wait = self.reset + self.polarize_time + self.buffer_after_init * 2 + self.settle + longest_time + self.laser_time + self.readout_time - mw_on
wait = longest_time - mw_on + self.buffer_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], 0, 0)]
polarize = \
[(self.polarize_time, [self.channel_dict["laser"]], 0, 0)]
# bg_decay = \
# [(self.buffer_after_init, [], 0, 0)]
background = \
[(self.settle, [], 0, 0)]
rabi = \
[(mw_on, [self.channel_dict["switch"]], 0, 0)]
probe = \
[(self.laser_time, [self.channel_dict["laser"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
# Lockin Part
L_rabi = \
[(mw_on, [], 0, 0)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], 0, 0)]
wait = \
[(wait, [], 0, 0)]
return reset + polarize + bg_decay + background + rabi + probe + bg_decay + readout + wait + \
reset + polarize + bg_decay + background + L_rabi + probe + bg_decay + L_readout + wait
seqs = [
single_rabi(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def T2(self, params, pi):
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(round(pi.to("ns").magnitude))
def single_T2(tau):
# wait = self.reset + self.polarize_time + self.buffer_after_init * 2 + self.settle + longest_time + self.laser_time + self.readout_time - mw_on
wait = longest_time - tau
excitation = \
[(self.laser_time, [self.channel_dict["laser"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
first_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], 0, 0)]
dephase = \
[(tau // 2, [], 0, 0)]
flip = \
[(pi_ns, [self.channel_dict["switch"]], 0, 0)]
rephase = \
[(tau // 2, [], 0, 0)]
second_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], 0, 0)]
wait = \
[(wait, [], 0, 0)]
return excitation + bg_decay + readout + first_pi2 + dephase + flip + rephase + second_pi2 + wait
seqs = [
single_T2(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_T2(self, params, pi):
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(round(pi.to("ns").magnitude))
def single_T2(tau):
# wait = self.reset + self.polarize_time + self.buffer_after_init * 2 + self.settle + longest_time + self.laser_time + self.readout_time - mw_on
wait = longest_time - tau + self.buffer_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], 0, 0)]
polarize = \
[(self.polarize_time, [self.channel_dict["laser"]], 0, 0)]
background = \
[(self.settle, [self.channel_dict["gate"], self.channel_dict["CTR"]], 0, 0)]
first_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], 0, 0)]
dephase = \
[(tau // 2, [], 0, 0)]
flip = \
[(pi_ns, [self.channel_dict["switch"]], 0, 0)]
rephase = \
[(tau // 2, [], 0, 0)]
second_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], 0, 0)]
probe = \
[(self.laser_time, [self.channel_dict["laser"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
wait = \
[(wait, [], 0, 0)]
return reset + polarize + bg_decay + background + first_pi2 + dephase + flip + rephase + second_pi2 + probe + bg_decay + readout + wait
seqs = [
single_T2(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_L_T2(self, params, pi):
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(round(pi.to("ns").magnitude))
def single_T2(tau):
# wait = self.reset + self.polarize_time + self.buffer_after_init * 2 + self.settle + longest_time + self.laser_time + self.readout_time - mw_on
wait = longest_time - tau + self.buffer_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], 0, 0)]
polarize = \
[(self.polarize_time, [self.channel_dict["laser"]], 0, 0)]
background = \
[(self.settle, [], 0, 0)]
first_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], 0, 0)]
dephase = \
[(tau // 2, [], 0, 0)]
flip = \
[(pi_ns, [self.channel_dict["switch"]], 0, 0)]
rephase = \
[(tau // 2, [], 0, 0)]
second_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], 0, 0)]
probe = \
[(self.laser_time, [self.channel_dict["laser"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
# Lockin Part
L_first_pi2 = \
[(pi_ns // 2, [], 0, 0)]
L_dephase = \
[(tau // 2, [], 0, 0)]
L_flip = \
[(pi_ns, [], 0, 0)]
L_rephase = \
[(tau // 2, [], 0, 0)]
L_second_pi2 = \
[(pi_ns // 2, [], 0, 0)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], 0, 0)]
wait = \
[(wait, [], 0, 0)]
return reset + polarize + bg_decay + background + first_pi2 + dephase + flip + rephase + second_pi2 + wait + probe + bg_decay + readout + \
reset + polarize + bg_decay + background + L_first_pi2 + L_dephase + L_flip + L_rephase + L_second_pi2 + wait + probe + bg_decay + L_readout
seqs = [
single_T2(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
# def Experimental_Rabi(self, params):
# longest_time = int(round(params["stop"].to("ns").magnitude))
# def single_rabi(mw_on):
# wait = longest_time-mw_on
# polarization = [(self.polarize_time, [self.channel_dict["laser"]], 0, 0)]
# settle = [(self.settle, [], 0, 0)]
# rabi = \
# [(mw_on, [self.channel_dict["switch"]], 0, 0)]
# wait = \
# [(wait, [], 0, 0)]
# probe = [(self.laser_time, [self.channel_dict["laser"]], 0, 0)]
# bg_decay = \
# [(self.buffer_after_init, [], 0, 0)]
# readout = \
# [(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
# return polarization + settle + rabi + wait + probe + bg_decay + readout
# seqs = [single_rabi(int(round(mw_time.to("ns").magnitude))) for mw_time in params.array]
# return seqs
#
# def L_Experimental_Rabi(self, params, cycle=0):
# longest_time = int(round(params["stop"].to("ns").magnitude))
# def single_rabi(mw_on):
# wait = longest_time-mw_on
# polarization = [(self.polarize_time, [self.channel_dict["laser"]], 0, 0)]
# settle = [(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], 0, 0)]
# rabi = \
# [(mw_on, [self.channel_dict["switch"]], 0, 0)]
# wait = \
# [(wait, [], 0, 0)]
# probe = [(self.laser_time, [self.channel_dict["laser"]], 0, 0)]
# bg_decay = \
# [(self.buffer_after_init, [], 0, 0)]
# readout = \
# [(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
# return polarization + bg_decay + settle + rabi + wait + probe + bg_decay + readout
# seqs = [single_rabi(int(round(mw_time.to("ns").magnitude))) for mw_time in params.array]
# return seqs
# def Traditional_Rabi(self, params, cycle=1):
# longest_time = int(round(params["stop"].to("ns").magnitude))
# def single_rabi(mw_on):
# wait = longest_time-mw_on
# polarization = [(self.polarize_time, [self.channel_dict["laser"], self.channel_dict["gate"], self.channel_dict["CTR"]], 0, 0)]
# bg_decay = \
# [(self.buffer_after_init, [], 0, 0)]
# rabi = \
# [(mw_on, [self.channel_dict["switch"]], 0, 0)]
# wait = \
# [(wait, [], 0, 0)]
# probe = [(self.polarize_time, [self.channel_dict["laser"], self.channel_dict["gate"],], 0, 0)]
# b_bg_decay = \
# [(self.buffer_after_init, [], 0, 0)]
# b_rabi = \
# [(mw_on, [], 0, 0)]
# # b_wait = \
# # [(wait, [], 0, 0)]
# return (polarization + bg_decay + rabi + wait)* cycle + (probe + b_bg_decay + b_rabi + wait)*cycle
# seqs = [single_rabi(int(round(mw_time.to("ns").magnitude))) for mw_time in params.array]
# return seqs
def Pulsed_ODMR(self, pi):
excitation = \
[(self.laser_time, [self.channel_dict["laser"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
rabi = \
[(pi, [self.channel_dict["switch"]], 0, 0)]
wait = \
[(self.buffer_after_readout, [], 0, 0)]
return excitation + bg_decay + readout + rabi + wait
def Ramsey(self, params, pi):
'''
:param params: the iteration array
:param pi: length of the physik_instrumente pulse
:return: an array of pulse sequences
'''
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(pi.to("ns").magnitude)
def single_ramsey(tau):
wait = longest_time - tau + self.buffer_after_readout
excitation = \
[(self.laser_time, [self.channel_dict["laser"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
first_pi = \
[(pi_ns // 2, [self.channel_dict["switch"]], 0, 0)]
dephase = \
[(tau, [], 0, 0)]
second_pi = \
[(pi_ns // 2, [self.channel_dict["switch"]], 0, 0)]
wait = \
[(wait, [], 0, 0)]
return excitation + bg_decay + readout + first_pi + dephase + second_pi + wait
seqs = [
single_ramsey(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_Ramsey(self, params, pi):
'''
:param params: the iteration array
:param pi: length of the physik_instrumente pulse
:return: an array of pulse sequences
'''
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(pi.to("ns").magnitude)
def single_ramsey(tau):
wait = longest_time - tau + self.buffer_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], 0, 0)]
polarize = \
[(self.polarize_time, [self.channel_dict["laser"]], 0, 0)]
background = \
[(self.settle, [self.channel_dict["gate"], self.channel_dict["CTR"]], 0, 0)]
first_pi = \
[(pi_ns // 2, [self.channel_dict["switch"]], 0, 0)]
dephase = \
[(tau, [], 0, 0)]
second_pi = \
[(pi_ns // 2, [self.channel_dict["switch"]], 0, 0)]
probe = \
[(self.laser_time, [self.channel_dict["laser"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
wait = \
[(wait, [], 0, 0)]
return reset + polarize + background + first_pi + dephase + second_pi + probe + bg_decay + readout + wait
seqs = [
single_ramsey(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_L_Ramsey(self, params, pi):
'''
:param params: the iteration array
:param pi: length of the physik_instrumente pulse
:return: an array of pulse sequences
'''
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(pi.to("ns").magnitude)
def single_ramsey(tau):
wait = longest_time - tau + self.buffer_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], 0, 0)]
polarize = \
[(self.polarize_time, [self.channel_dict["laser"]], 0, 0)]
background = \
[(self.settle, [], 0, 0)]
first_pi = \
[(pi_ns // 2, [self.channel_dict["switch"]], 0, 0)]
dephase = \
[(tau, [], 0, 0)]
second_pi = \
[(pi_ns // 2, [self.channel_dict["switch"]], 0, 0)]
probe = \
[(self.laser_time, [self.channel_dict["laser"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
# Lockin Part
L_first_pi = \
[(pi_ns // 2, [], 0, 0)]
L_dephase = \
[(tau, [], 0, 0)]
L_second_pi = \
[(pi_ns // 2, [], 0, 0)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], 0, 0)]
wait = \
[(wait, [], 0, 0)]
return reset + polarize + background + first_pi + dephase + second_pi + probe + bg_decay + readout + wait + \
reset + polarize + background + L_first_pi + L_dephase + L_second_pi + probe + bg_decay + L_readout + wait
seqs = [
single_ramsey(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def T1(self, params, pi):
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(pi.to("ns").magnitude)
def single_T1(tau):
wait = longest_time - tau + self.buffer_after_readout
excitation = \
[(self.laser_time, [self.channel_dict["laser"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
pi = \
[(pi_ns, [self.channel_dict["switch"]], 0, 0)]
flip = \
[(tau, [], 0, 0)]
wait = \
[(wait, [], 0, 0)]
return excitation + bg_decay + readout + pi + flip + wait
seqs = [
single_T1(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def res_Topt(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
bin_time = int(round(params["step"].to("ns").magnitude))
def single_T1(start):
wait = longest_time - start + bin_time + self.buffer_after_readout
excitation = \
[(self.laser_time, [self.channel_dict["laser"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
before_bin = \
[(start, [], 0, 0)]
readout = \
[(self.bin_time, [self.channel_dict["gate"]], 0, 0)]
wait = \
[(wait, [], 0, 0)]
return excitation + bg_decay + before_bin + readout + wait
seqs = [
single_T1(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs[:-1]
def off_res_Topt(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
bin_time = int(round(params["step"].to("ns").magnitude))
def single_T1(start):
wait = longest_time - start + bin_time + self.buffer_after_readout
excitation = \
[(self.laser_time, [self.channel_dict["offr_laser"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
before_bin = \
[(start, [], 0, 0)]
readout = \
[(self.bin_time, [self.channel_dict["gate"]], 0, 0)]
wait = \
[(wait, [], 0, 0)]
return excitation + bg_decay + before_bin + readout + wait
seqs = [
single_T1(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs[:-1]
def red_Laser_Power(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
def single_RLP(e_time):
wait = longest_time - e_time + self.buffer_after_readout
# wait = self.buffer_after_readout
excitation = \
[(e_time, [self.channel_dict["offr_laser"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
wait = \
[(wait, [], 0, 0)]
return excitation + bg_decay + readout + wait
seqs = [
single_RLP(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Laser_Power(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
def single_LP(e_time):
wait = longest_time - e_time + self.buffer_after_readout
# wait = self.buffer_after_readout
excitation = \
[(e_time, [self.channel_dict["laser"]], 0, 0)]
bg_decay = \
[(self.buffer_after_init, [], 0, 0)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
wait = \
[(wait, [], 0, 0)]
return excitation + bg_decay + readout + wait
seqs = [
single_LP(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
class Pulses(Driver):
default_digi_dict = {
"laser": "ch0",
"offr_laser": "ch1",
"EOM": "ch4",
"CTR": "ch5",
"switch": "ch6",
"gate": "ch7",
"": None
}
default_digi_dict = {
"laser": 0,
"offr_laser": 1,
"EOM": 4,
"CTR": 5,
"switch": 6,
"gate": 7,
"": None
}
rev_dict = {
0: "laser",
1: "offr_laser",
4: "EOM",
5: "CTR",
6: "switch",
7: "gate",
8: "I",
9: "Q"
}
def __init__(self,
channel_dict=default_digi_dict,
laser_time=150 * Q_(1, "us"),
readout_time=150 * Q_(1, "us"),
buf_after_init=450 * Q_(1, "us"),
buf_after_readout=2 * Q_(1, "us"),
polarize_time=900 * Q_(1, "us"),
settle=150 * Q_(1, "us"),
reset=100 * Q_(1, "ns"),
IQ=[0.5, 0],
ip="192.168.1.111"):
"""
:param channel_dict: Dictionary of which channels correspond to which instr controls
:param laser_time: Laser time in us
:param CTR: When False CTR0 When True CTR1
:param readout_time: Readout time in us
:param buf_after_init: buf after laser turns off in us to allow the population to thermalize
:param buf_after_readout: buf between the longest pulse and the readout in us to prevent laser to leak in
:param IQ: IQ vector that rotates the spin
"""
super().__init__()
self.channel_dict = channel_dict
self._reverse_dict = {
0: "laser",
1: "offr_laser",
4: "EOM",
5: "CTR",
6: "switch",
7: "gate",
8: "I",
9: "Q"
} # rev_dict
self.laser_time = int(round(laser_time.to("ns").magnitude))
self.readout_time = int(round(readout_time.to("ns").magnitude))
self.buf_after_init = int(round(buf_after_init.to("ns").magnitude))
self.buf_after_readout = int(
round(buf_after_readout.to("ns").magnitude))
self.polarize_time = int(round(polarize_time.to("ns").magnitude))
self.settle = int(round(settle.to("ns").magnitude))
self.reset = int(round(reset.to("ns").magnitude))
self._normalize_IQ(IQ)
self.Pulser = PulseStreamer(ip)
self.latest_streamed = pd.DataFrame({})
@Feat()
def has_sequence(self):
"""
Has Sequence
"""
return self.Pulser.hasSequence()
def stream(self, seq):
self.latest_streamed = self.convert_sequence(seq)
self.Pulser.stream(seq)
def _normalize_IQ(self, IQ):
self.IQ = IQ / (2 * np.linalg.norm(IQ))
def convert_sequence(self, seqs):
# 0-7 are the 8 digital channels
# 8-9 are the 2 analog channels
data = {}
time = -0.01
for seq in seqs:
col = np.zeros(10)
col[seq[1]] = 1
col[8] = seq[2]
col[9] = seq[3]
init_time = time + 0.01
data[init_time] = col
time = time + seq[0]
# data[prev_time_stamp + 0.01] = col
data[time] = col
# prev_time_stamp = seq[0]
dft = pd.DataFrame(data)
df = dft.T
sub_df = df[list(self._reverse_dict.keys())]
fin = sub_df.rename(columns=self._reverse_dict)
return fin
def Transient_Measure(self):
excitation = \
[(self.laser_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
buf = \
[(self.buf_after_readout, [], *self.IQ)]
return excitation + bg_decay + readout + buf
def CODMR(self):
excitation = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["switch"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [self.channel_dict["switch"]], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["switch"], self.channel_dict["gate"]], *self.IQ)]
buf = \
[(self.buf_after_readout, [self.channel_dict["switch"]], *self.IQ)]
return excitation + bg_decay + readout + buf
def EOM(self):
excitation = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["switch"], self.channel_dict["EOM"]],
*self.IQ)]
bg_decay = \
[(self.buf_after_init, [self.channel_dict["switch"]], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["switch"], self.channel_dict["gate"]], *self.IQ)]
buf = \
[(self.buf_after_readout, [self.channel_dict["switch"]], *self.IQ)]
return excitation + bg_decay + readout + buf
def MW_L_EOM(self):
excitation = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["switch"], self.channel_dict["EOM"]],
*self.IQ)]
bg_decay = \
[(self.buf_after_init, [self.channel_dict["switch"]], *[0, 0])]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *[0, 0])]
buf = \
[(self.buf_after_readout, [], *[0, 0])]
L_excitation = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["EOM"]], *[0, 0])]
L_bg_decay = \
[(self.buf_after_init, [self.channel_dict["switch"]], *self.IQ)]
L_readout = \
[(self.readout_time, [self.channel_dict["switch"], self.channel_dict["gate"], self.channel_dict["CTR"]],
*self.IQ)]
L_buf = \
[(self.buf_after_readout, [self.channel_dict["switch"]], *self.IQ)]
return excitation + bg_decay + readout + buf + L_excitation + L_bg_decay + L_readout + L_buf
def L_CODMR(self, measure=0):
s_excitation = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["switch"]], *self.IQ)]
s_bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
s_readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
s_buf = \
[(self.buf_after_readout, [], *self.IQ)]
s = s_excitation + s_bg_decay + s_readout + s_buf
m_excitation = \
[(self.laser_time, [self.channel_dict["laser"]], *self.IQ)]
m_bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
m_readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
m_buf = \
[(self.buf_after_readout, [], *self.IQ)]
m = m_excitation + m_bg_decay + m_readout + m_buf
b_excitation = \
[(self.laser_time, [self.channel_dict["CTR"], self.channel_dict["laser"]], *self.IQ)]
b_bg_decay = \
[(self.buf_after_init, [self.channel_dict["CTR"]], *self.IQ)]
b_readout = \
[(self.readout_time, [self.channel_dict["CTR"], self.channel_dict["gate"]], *self.IQ)]
b_buf = \
[(self.buf_after_readout, [self.channel_dict["CTR"]], *self.IQ)]
b = b_excitation + b_bg_decay + b_readout + b_buf
return s + m * measure + b
def Rabi(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
def single_rabi(mw_on):
wait = longest_time - mw_on + self.buf_after_readout
excitation = \
[(self.laser_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
rabi = \
[(mw_on, [self.channel_dict["switch"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return excitation + bg_decay + readout + rabi + wait
seqs = [
single_rabi(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_Rabi(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
def single_rabi(mw_on):
# wait = self.reset + self.polarize_time + self.buf_after_init * 2 + self.settle + longest_time + self.laser_time + self.readout_time - mw_on
wait = longest_time - mw_on + self.buf_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], *self.IQ)]
polarize = \
[(self.polarize_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
background = \
[(self.settle, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
rabi = \
[(mw_on, [self.channel_dict["switch"]], *self.IQ)]
probe = \
[(self.laser_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return reset + polarize + bg_decay + background + rabi + probe + bg_decay + readout + wait
seqs = [
single_rabi(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_L_Rabi(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
def single_rabi(mw_on):
# wait = self.reset + self.polarize_time + self.buf_after_init * 2 + self.settle + longest_time + self.laser_time + self.readout_time - mw_on
wait = longest_time - mw_on + self.buf_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], *self.IQ)]
polarize = \
[(self.polarize_time, [self.channel_dict["laser"]], *self.IQ)]
# bg_decay = \
# [(self.buf_after_init, [], *self.IQ)]
background = \
[(self.settle, [], *self.IQ)]
rabi = \
[(mw_on, [self.channel_dict["switch"]], *self.IQ)]
probe = \
[(self.laser_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
# Lockin Part
L_rabi = \
[(mw_on, [], *self.IQ)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return reset + polarize + bg_decay + background + rabi + wait + probe + bg_decay + readout + \
reset + polarize + bg_decay + background + L_rabi + wait + probe + bg_decay + L_readout
seqs = [
single_rabi(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def T2(self, params, pi):
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(round(pi.to("ns").magnitude))
def single_T2(tau):
# wait = self.reset + self.polarize_time + self.buf_after_init * 2 + self.settle + longest_time + self.laser_time + self.readout_time - mw_on
wait = longest_time - tau
excitation = \
[(self.laser_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
first_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
dephase = \
[(tau // 2, [], *self.IQ)]
flip = \
[(pi_ns, [self.channel_dict["switch"]], *self.IQ)]
rephase = \
[(tau // 2, [], *self.IQ)]
second_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return excitation + bg_decay + readout + first_pi2 + dephase + flip + rephase + second_pi2 + wait
seqs = [
single_T2(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_T2(self, params, pi):
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(round(pi.to("ns").magnitude))
def single_T2(tau):
# wait = self.reset + self.polarize_time + self.buf_after_init * 2 + self.settle + longest_time + self.laser_time + self.readout_time - mw_on
wait = longest_time - tau + self.buf_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], *self.IQ)]
polarize = \
[(self.polarize_time, [self.channel_dict["laser"]], *self.IQ)]
background = \
[(self.settle, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
first_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
dephase = \
[(tau // 2, [], *self.IQ)]
flip = \
[(pi_ns, [self.channel_dict["switch"]], *self.IQ)]
rephase = \
[(tau // 2, [], *self.IQ)]
second_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
probe = \
[(self.laser_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return reset + polarize + bg_decay + background + first_pi2 + dephase + flip + rephase + second_pi2 + probe + bg_decay + readout + wait
seqs = [
single_T2(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_L_T2(self, params, pi, style=[[-1, 0], [1, 0], [1, 0]]):
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(round(pi.to("ns").magnitude))
if style[0] == [0, 0]:
f_pi2 = [0, 0]
first_pi2gate = []
else:
f_pi2 = style[0] / (2 * np.linalg.norm(style[0]))
first_pi2gate = [self.channel_dict["switch"]]
if style[1] == [0, 0]:
L_pi = [0, 0]
pigate = []
else:
L_pi = style[1] / (2 * np.linalg.norm(style[1]))
pigate = [self.channel_dict["switch"]]
if style[2] == [0, 0]:
s_pi2 = [0, 0]
second_pi2gate = []
else:
s_pi2 = style[2] / (2 * np.linalg.norm(style[2]))
second_pi2gate = [self.channel_dict["switch"]]
def single_T2(tau):
# wait = self.reset + self.polarize_time + self.buf_after_init * 2 + self.settle + longest_time + self.laser_time + self.readout_time - mw_on
wait = longest_time - tau + self.buf_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], *self.IQ)]
polarize = \
[(self.polarize_time, [self.channel_dict["laser"]], *self.IQ)]
background = \
[(self.settle, [], *self.IQ)]
first_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
dephase = \
[(tau // 2, [], *self.IQ)]
flip = \
[(pi_ns, [self.channel_dict["switch"]], *self.IQ)]
rephase = \
[(tau // 2, [], *self.IQ)]
second_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
probe = \
[(self.laser_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
# Lockin Part
L_background = \
[(self.settle, [], *f_pi2)]
L_first_pi2 = \
[(pi_ns // 2, first_pi2gate, *f_pi2)]
L_dephase = \
[(tau // 2, [], *L_pi)]
L_flip = \
[(pi_ns, pigate, *L_pi)]
L_rephase = \
[(tau // 2, [], *s_pi2)]
L_second_pi2 = \
[(pi_ns // 2, second_pi2gate, *s_pi2)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return reset + polarize + background + first_pi2 + dephase + flip + rephase + second_pi2 + wait + probe + bg_decay + readout + \
reset + polarize + L_background + L_first_pi2 + L_dephase + L_flip + L_rephase + L_second_pi2 + wait + probe + bg_decay + L_readout
seqs = [
single_T2(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_L_CPMG(self, params, pi, N):
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(round(pi.to("ns").magnitude))
def CPMG_core(tau, N, IQ=[1, 0]):
L_pi2_IQ = IQ / (2 * np.linalg.norm(IQ))
L_pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], *L_pi2_IQ)]
pi2 = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
wait_pi2 = \
[(tau // (2 * N), [], *self.IQ)]
pi = [(pi_ns, [self.channel_dict["switch"]], *self.IQ)]
return L_pi2 + N * (wait_pi2 + pi + wait_pi2) + pi2
def single_T2(tau):
# wait = self.reset + self.polarize_time + self.buf_after_init * 2 + self.settle + longest_time + self.laser_time + self.readout_time - mw_on
wait = longest_time - tau + self.buf_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], *self.IQ)]
polarize = \
[(self.polarize_time, [self.channel_dict["laser"]], *self.IQ)]
background = \
[(self.settle, [], *self.IQ)]
CPMG_Core = CPMG_core(tau, N=N, IQ=[1, 0])
probe = \
[(self.laser_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
# Lockin Part
L_background = \
[(self.settle, [], -0.5, 0)]
L_CPMG_Core = CPMG_core(tau, N=N, IQ=[-1, 0])
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return reset + polarize + background + CPMG_Core + wait + probe + bg_decay + readout + \
reset + polarize + L_background + L_CPMG_Core + wait + probe + bg_decay + L_readout
seqs = [
single_T2(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_L_T1(self, params, pi):
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(round(pi.to("ns").magnitude))
def single_T1(tau):
# wait = self.reset + self.polarize_time + self.buf_after_init * 2 + self.settle + longest_time + self.laser_time + self.readout_time - mw_on
wait = longest_time - tau + self.buf_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], *self.IQ)]
polarize = \
[(self.polarize_time, [self.channel_dict["laser"]], *self.IQ)]
background = \
[(self.settle, [], *self.IQ)]
tau_wait = \
[(tau, [], *self.IQ)]
flip = \
[(pi_ns, [self.channel_dict["switch"]], *self.IQ)]
probe = \
[(self.laser_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
# Lockin Part
L_flip = \
[(pi_ns, [], 0, 0)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], 0, 0)]
wait = \
[(wait, [], 0, 0)]
return reset + polarize + background + flip + tau_wait + probe + bg_decay + readout + wait + \
reset + polarize + background + L_flip + tau_wait + probe + bg_decay + L_readout + wait
seqs = [
single_T1(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_L_T1_Adaptive(self, params, pi):
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(round(pi.to("ns").magnitude))
def single_T1(tau):
# wait = self.reset + self.polarize_time + self.buf_after_init * 2 + self.settle + longest_time + self.laser_time + self.readout_time - mw_on
wait = longest_time - tau + self.buf_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], *self.IQ)]
polarize = \
[(self.polarize_time, [self.channel_dict["laser"]], *self.IQ)]
background = \
[(self.settle, [], *self.IQ)]
tau_wait = \
[(tau, [], *self.IQ)]
flip = \
[(pi_ns, [self.channel_dict["switch"]], *self.IQ)]
probe = \
[(self.laser_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
# Lockin Part
L_flip = \
[(pi_ns, [], 0, 0)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], 0, 0)]
wait = \
[(wait, [], 0, 0)]
return reset + polarize + background + flip + tau_wait + probe + bg_decay + readout + \
reset + polarize + background + L_flip + tau_wait + probe + bg_decay + L_readout
seqs = [
single_T1(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Pulsed_ODMR(self, pi):
excitation = \
[(self.laser_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
rabi = \
[(pi, [self.channel_dict["switch"]], *self.IQ)]
wait = \
[(self.buf_after_readout, [], *self.IQ)]
return excitation + bg_decay + readout + rabi + wait
def Ramsey(self, params, pi):
'''
:param params: the iteration array
:param pi: length of the physik_instrumente pulse
:return: an array of pulse sequences
'''
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(pi.to("ns").magnitude)
def single_ramsey(tau):
wait = longest_time - tau + self.buf_after_readout
excitation = \
[(self.laser_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
first_pi = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
dephase = \
[(tau, [], *self.IQ)]
second_pi = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return excitation + bg_decay + readout + first_pi + dephase + second_pi + wait
seqs = [
single_ramsey(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_Ramsey(self, params, pi):
'''
:param params: the iteration array
:param pi: length of the physik_instrumente pulse
:return: an array of pulse sequences
'''
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(pi.to("ns").magnitude)
def single_ramsey(tau):
wait = longest_time - tau + self.buf_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], *self.IQ)]
polarize = \
[(self.polarize_time, [self.channel_dict["laser"]], *self.IQ)]
background = \
[(self.settle, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
first_pi = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
dephase = \
[(tau, [], *self.IQ)]
second_pi = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
probe = \
[(self.laser_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return reset + polarize + background + first_pi + dephase + second_pi + probe + bg_decay + readout + wait
seqs = [
single_ramsey(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_L_Ramsey(self, params, pi):
'''
:param params: the iteration array
:param pi: length of the physik_instrumente pulse
:return: an array of pulse sequences
'''
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(pi.to("ns").magnitude)
def single_ramsey(tau):
wait = longest_time - tau + self.buf_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], *self.IQ)]
polarize = \
[(self.polarize_time, [self.channel_dict["laser"]], *self.IQ)]
background = \
[(self.settle, [], *self.IQ)]
first_pi = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
dephase = \
[(tau, [], *self.IQ)]
second_pi = \
[(pi_ns // 2, [self.channel_dict["switch"]], *self.IQ)]
probe = \
[(self.laser_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
# Lockin Part
L_first_pi = \
[(pi_ns // 2, [], *self.IQ)]
L_dephase = \
[(tau, [], *self.IQ)]
L_second_pi = \
[(pi_ns // 2, [], *self.IQ)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return reset + polarize + background + first_pi + dephase + second_pi + wait + probe + bg_decay + readout + \
reset + polarize + background + L_first_pi + L_dephase + L_second_pi + wait + probe + bg_decay + L_readout
seqs = [
single_ramsey(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def T1(self, params, pi):
longest_time = int(round(params["stop"].to("ns").magnitude))
pi_ns = int(pi.to("ns").magnitude)
def single_T1(tau):
wait = longest_time - tau + self.buf_after_readout
excitation = \
[(self.laser_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
pi = \
[(pi_ns, [self.channel_dict["switch"]], *self.IQ)]
flip = \
[(tau, [], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return excitation + bg_decay + readout + pi + flip + wait
seqs = [
single_T1(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def res_Topt(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
bin_time = int(round(params["step"].to("ns").magnitude))
def single_T1(start):
wait = longest_time - start + bin_time + self.buf_after_readout
excitation = \
[(self.laser_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
before_bin = \
[(start, [], *self.IQ)]
readout = \
[(bin_time, [self.channel_dict["gate"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return excitation + bg_decay + before_bin + readout + wait
seqs = [
single_T1(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def res_Topt_MW(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
bin_time = int(round(params["step"].to("ns").magnitude))
def single_T1(start):
wait = longest_time - start + bin_time + self.buf_after_readout
excitation = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["switch"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [self.channel_dict["switch"]], *self.IQ)]
before_bin = \
[(start, [self.channel_dict["switch"]], *self.IQ)]
readout = \
[(bin_time, [self.channel_dict["gate"], self.channel_dict["switch"]], *self.IQ)]
wait = \
[(wait, [self.channel_dict["switch"]], *self.IQ)]
return excitation + bg_decay + before_bin + readout + wait
seqs = [
single_T1(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def off_res_Topt(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
bin_time = int(round(params["step"].to("ns").magnitude))
def single_T1(start):
wait = longest_time - start + bin_time + self.buf_after_readout
excitation = \
[(self.laser_time, [self.channel_dict["offr_laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
before_bin = \
[(start, [], *self.IQ)]
readout = \
[(bin_time, [self.channel_dict["gate"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return excitation + bg_decay + before_bin + readout + wait
seqs = [
single_T1(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def red_Laser_Power(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
def single_RLP(e_time):
wait = longest_time - e_time + self.buf_after_readout
# wait = self.buf_after_readout
excitation = \
[(e_time, [self.channel_dict["offr_laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return excitation + bg_decay + readout + wait
seqs = [
single_RLP(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Laser_Power(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
def single_LP(e_time):
wait = longest_time - e_time + self.buf_after_readout
# wait = self.buf_after_readout
excitation = \
[(e_time, [self.channel_dict["laser"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *self.IQ)]
wait = \
[(wait, [], *self.IQ)]
return excitation + bg_decay + readout + wait
seqs = [
single_LP(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Laser_Power_MW(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
def single_LP(e_time):
wait = longest_time - e_time + self.buf_after_readout
# wait = self.buf_after_readout
excitation = \
[(e_time, [self.channel_dict["laser"], self.channel_dict["switch"]], *self.IQ)]
bg_decay = \
[(self.buf_after_init, [self.channel_dict["switch"]], *self.IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["switch"]], *self.IQ)]
wait = \
[(wait, [self.channel_dict["switch"]], *self.IQ)]
return excitation + bg_decay + readout + wait
seqs = [
single_LP(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def L_Inv_Optical_Rabi(self, params):
longest_time = int(round(params["stop"].to("ns").magnitude))
def single_OR(e_time):
wait = longest_time - e_time + self.buf_after_readout
# wait = self.buf_after_readout
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], 0, 0)]
background = \
[(self.settle, [self.channel_dict["offr_laser"]], 0, 0)]
excitation = \
[(e_time, [self.channel_dict["laser"]], 0, 0)]
bg_decay = \
[(self.buf_after_init, [], 0, 0)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], 0, 0)]
wait = \
[(wait, [], 0, 0)]
L_excitation = \
[(e_time, [], 0, 0)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], 0, 0)]
return reset + background + excitation + bg_decay + readout + wait + \
reset + background + L_excitation + bg_decay + L_readout + wait
seqs = [
single_OR(int(round(mw_time.to("ns").magnitude)))
for mw_time in params.array
]
return seqs
def Resetting_L_EOM(self):
IQ = [0, 0]
reset = \
[(self.reset, [self.channel_dict["offr_laser"]], *IQ)]
polarize = \
[(self.polarize_time, [self.channel_dict["laser"]], *IQ)]
background = \
[(self.settle, [], *IQ)]
probe = \
[(self.laser_time, [self.channel_dict["laser"], self.channel_dict["EOM"]], *IQ)]
bg_decay = \
[(self.buf_after_init, [], *IQ)]
readout = \
[(self.readout_time, [self.channel_dict["gate"]], *IQ)]
L_probe = \
[(self.laser_time, [self.channel_dict["laser"]], *IQ)]
L_readout = \
[(self.readout_time, [self.channel_dict["gate"], self.channel_dict["CTR"]], *IQ)]
return reset + polarize + background + probe + bg_decay + readout + \
reset + polarize + background + L_probe + bg_decay + L_readout