def generate_pulsedodmr_iq(self, name='pulsedODMR_iq', freq_start=50e6, freq_step=1e6,
measure_time=500e-9, num_of_points=10):
"""
"""
created_blocks = list()
created_ensembles = list()
created_sequences = list()
# Create frequency array
freq_array = freq_start + np.arange(num_of_points) * freq_step
# create the elements
# TODO delete this
waiting_element = self._get_idle_element(length=1e-03,
increment=0)
start_element = self._get_trigger_element(20e-9, 0, 'd_ch0')
waiting_element = self._get_idle_element(length=measure_time,
increment=0)
end_element = self._get_trigger_element(20e-9, 0, 'd_ch1')
# Create block and append to created_blocks list
pulsedodmr_block = PulseBlock(name=name)
for mw_freq in freq_array:
mw_element = self._get_iq_mix_element(length=self.rabi_period / 2,
increment=0,
amp=self.iq_amplitude,
freq=mw_freq,
phase=0)
pulsedodmr_block.append(mw_element)
pulsedodmr_block.append(start_element)
pulsedodmr_block.append(waiting_element)
pulsedodmr_block.append(end_element)
created_blocks.append(pulsedodmr_block)
# Create block ensemble
block_ensemble = PulseBlockEnsemble(name=name, rotating_frame=False)
block_ensemble.append((pulsedodmr_block.name, 0))
# Create and append sync trigger block if needed
if self.sync_channel:
sync_block = PulseBlock(name='sync_trigger')
sync_block.append(self._get_sync_element())
created_blocks.append(sync_block)
block_ensemble.append((sync_block.name, 0))
# add metadata to invoke settings later on
block_ensemble.measurement_information['alternating'] = False
block_ensemble.measurement_information['laser_ignore_list'] = list()
block_ensemble.measurement_information['controlled_variable'] = freq_array
block_ensemble.measurement_information['units'] = ('Hz', '')
block_ensemble.measurement_information['labels'] = ('Frequency', 'Signal')
block_ensemble.measurement_information['number_of_lasers'] = num_of_points
block_ensemble.measurement_information['counting_length'] = self._get_ensemble_count_length(
ensemble=block_ensemble, created_blocks=created_blocks)
# append ensemble to created ensembles
created_ensembles.append(block_ensemble)
return created_blocks, created_ensembles, created_sequences
def generate_laser_mw_on(self, name='laser_mw_on', length=3.0e-6):
""" General generation method for laser on and microwave on generation.
@param string name: Name of the PulseBlockEnsemble to be generated
@param float length: Length of the PulseBlockEnsemble in seconds
@return object: the generated PulseBlockEnsemble object.
"""
created_blocks = list()
created_ensembles = list()
created_sequences = list()
# create the laser_mw element
laser_mw_element = self._get_mw_laser_element(
length=length,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=0)
# Create block and append to created_blocks list
laser_mw_block = PulseBlock(name=name)
laser_mw_block.append(laser_mw_element)
created_blocks.append(laser_mw_block)
# Create block ensemble and append to created_ensembles list
block_ensemble = PulseBlockEnsemble(name=name, rotating_frame=False)
block_ensemble.append((laser_mw_block.name, 0))
created_ensembles.append(block_ensemble)
return created_blocks, created_ensembles, created_sequences
def generate_trig_click(self, name='trig_click(', num_clicks=3, num_reps=10, wait_time=100e-9):
"""
"""
created_blocks = list()
created_ensembles = list()
created_sequences = list()
# create the elements
waiting_element = self._get_idle_element(length=wait_time,
increment=0)
start_element = self._get_trigger_element(10e-9, 0, 'd_ch0')
click_element = self._get_trigger_element(10e-9, 0, 'd_ch1')
# Create block and append to created_blocks list
pulsedodmr_block = PulseBlock(name=name)
trig = 0
while trig < num_reps:
pulsedodmr_block.append(start_element)
pulsedodmr_block.append(waiting_element)
count = 0
while count < num_clicks:
pulsedodmr_block.append(click_element)
pulsedodmr_block.append(waiting_element)
count += 1
trig += 1
created_blocks.append(pulsedodmr_block)
# Create block ensemble
block_ensemble = PulseBlockEnsemble(name=name, rotating_frame=False)
block_ensemble.append((pulsedodmr_block.name, 0))
# Create and append sync trigger block if needed
if self.sync_channel:
sync_block = PulseBlock(name='sync_trigger')
sync_block.append(self._get_sync_element())
created_blocks.append(sync_block)
block_ensemble.append((sync_block.name, 0))
# add metadata to invoke settings later on
block_ensemble.measurement_information['alternating'] = False
block_ensemble.measurement_information['laser_ignore_list'] = list()
block_ensemble.measurement_information['controlled_variable'] = np.arange(num_reps)
block_ensemble.measurement_information['units'] = ('Hz', '')
block_ensemble.measurement_information['labels'] = ('Frequency', 'Signal')
block_ensemble.measurement_information['number_of_lasers'] = num_reps
block_ensemble.measurement_information['counting_length'] = self._get_ensemble_count_length(
ensemble=block_ensemble, created_blocks=created_blocks)
# append ensemble to created ensembles
created_ensembles.append(block_ensemble)
return created_blocks, created_ensembles, created_sequences
def generate_pODMR(self, name='pODMR', freq_step=0.2e6, num_of_points=30):
"""
"""
created_blocks = list()
created_ensembles = list()
created_sequences = list()
# Create frequency array
freq_array = 100.0e+6 + np.arange(num_of_points) * freq_step
# create the elements
waiting_element = self._get_idle_element(length=self.wait_time,
increment=0)
laser_element = self._get_laser_gate_element(length=self.laser_length,
increment=0)
delay_element = self._get_delay_gate_element()
# Create block and append to created_blocks list
pulsedodmr_block = PulseBlock(name=name)
for mw_freq in freq_array:
mw_element = self._get_mw_element(length=self.rabi_period / 2,
increment=0,
amp=self.microwave_amplitude,
freq=mw_freq,
phase=0)
pulsedodmr_block.append(mw_element)
pulsedodmr_block.append(laser_element)
pulsedodmr_block.append(delay_element)
pulsedodmr_block.append(waiting_element)
created_blocks.append(pulsedodmr_block)
# Create block ensemble
block_ensemble = PulseBlockEnsemble(name=name, rotating_frame=False)
block_ensemble.append((pulsedodmr_block.name, 1))
# Create and append sync trigger block if needed
if self.sync_channel:
sync_block = PulseBlock(name='sync_trigger')
sync_block.append(self._get_sync_element())
created_blocks.append(sync_block)
block_ensemble.append((sync_block.name, 0))
# add metadata to invoke settings later on
block_ensemble.measurement_information['alternating'] = False
block_ensemble.measurement_information['laser_ignore_list'] = list()
block_ensemble.measurement_information[
'controlled_variable'] = freq_array
block_ensemble.measurement_information['units'] = ('Hz', '')
block_ensemble.measurement_information[
'number_of_lasers'] = num_of_points
block_ensemble.measurement_information[
'counting_length'] = self._get_ensemble_count_length(
ensemble=block_ensemble, created_blocks=created_blocks)
# append ensemble to created ensembles
created_ensembles.append(block_ensemble)
return created_blocks, created_ensembles, created_sequences
def generate_idle(self, name='idle', length=3.0e-6):
""" Generate just a simple idle ensemble.
@param str name: Name of the PulseBlockEnsemble to be generated
@param float length: Length of the PulseBlockEnsemble in seconds
@return object: the generated PulseBlockEnsemble object.
"""
created_blocks = list()
created_ensembles = list()
created_sequences = list()
# create the laser_mw element
idle_element = self._get_idle_element(length=length, increment=0)
# Create block and append to created_blocks list
idle_block = PulseBlock(name=name)
idle_block.append(idle_element)
created_blocks.append(idle_block)
# Create block ensemble and append to created_ensembles list
block_ensemble = PulseBlockEnsemble(name=name, rotating_frame=False)
block_ensemble.append((idle_block.name, 0))
created_ensembles.append(block_ensemble)
return created_blocks, created_ensembles, created_sequences
def generate_laser_on(self, name='laser_on', length=3.0e-6):
""" Generates Laser on.
@param str name: Name of the PulseBlockEnsemble
@param float length: laser duration in seconds
@return object: the generated PulseBlockEnsemble object.
"""
created_blocks = list()
created_ensembles = list()
created_sequences = list()
# create the laser element
laser_element = self._get_laser_element(length=length, increment=0)
# Create block and append to created_blocks list
laser_block = PulseBlock(name=name)
laser_block.append(laser_element)
created_blocks.append(laser_block)
# Create block ensemble and append to created_ensembles list
block_ensemble = PulseBlockEnsemble(name=name, rotating_frame=False)
block_ensemble.append((laser_block.name, 0))
created_ensembles.append(block_ensemble)
return created_blocks, created_ensembles, created_sequences
def generate_simple_sin(self, name='simple_sin', length=1000e-9, amp=0.25,
freq=5e7, phase=0, num_of_points=50):
"""
"""
created_blocks = list()
created_ensembles = list()
created_sequences = list()
# Create the readout PulseBlockEnsemble
# Get necessary PulseBlockElements
iq_element = self._get_iq_mix_element(length=length, increment=0, amp=amp, freq=freq, phase=phase)
# Create PulseBlock and append PulseBlockElements
signal_block = PulseBlock(name=name)
signal_block.append(iq_element)
created_blocks.append(signal_block)
# Create PulseBlockEnsemble and append block to it
signal_ensemble = PulseBlockEnsemble(name=name, rotating_frame=False)
signal_ensemble.append((signal_block.name, 0))
if self.sync_channel:
# Create the last readout PulseBlockEnsemble including a sync trigger
# Get necessary PulseBlockElements
sync_element = self._get_sync_element()
# Create PulseBlock and append PulseBlockElements
sync_block = PulseBlock(name=name)
sync_block.append(iq_element)
sync_block.append(sync_element)
created_blocks.append(sync_block)
# Create PulseBlockEnsemble and append block to it
sync_ensemble = PulseBlockEnsemble(name=name, rotating_frame=False)
sync_ensemble.append((sync_block.name, 0))
created_ensembles.append(sync_ensemble)
# add metadata to invoke settings later on
signal_ensemble.measurement_information['alternating'] = False
signal_ensemble.measurement_information['laser_ignore_list'] = list()
signal_ensemble.measurement_information['units'] = ('s', '')
signal_ensemble.measurement_information['number_of_lasers'] = num_of_points
signal_ensemble.measurement_information['counting_length'] = 0
# Append PulseSequence to created_sequences list
created_ensembles.append(signal_ensemble)
return created_blocks, created_ensembles, created_sequences
def generate_xy8_freq(self,
name='xy8_freq',
freq_start=0.1e6,
freq_step=0.01e6,
num_of_points=50,
xy8_order=4,
alternating=True):
"""
"""
created_blocks = list()
created_ensembles = list()
created_sequences = list()
# get frequency array for measurement ticks
freq_array = freq_start + np.arange(num_of_points) * freq_step
# get tau array from freq array
tau_array = 1 / (2 * freq_array)
# calculate "real" tau array (finite pi-pulse length)
real_tau_array = tau_array - self.rabi_period / 2
np.clip(real_tau_array, 0, None, real_tau_array)
# Convert back to frequency in order to account for clipped values
freq_array = 1 / (2 * (real_tau_array + self.rabi_period / 2))
# create the elements
waiting_element = self._get_idle_element(length=self.wait_time,
increment=0)
laser_element = self._get_laser_gate_element(length=self.laser_length,
increment=0)
delay_element = self._get_delay_gate_element()
pihalf_element = self._get_mw_element(length=self.rabi_period / 4,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=0)
# Use a 180 deg phase shiftet pulse as 3pihalf pulse if microwave channel is analog
if self.microwave_channel.startswith('a'):
pi3half_element = self._get_mw_element(
length=self.rabi_period / 4,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=180)
else:
pi3half_element = self._get_mw_element(
length=3 * self.rabi_period / 4,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=0)
pix_element = self._get_mw_element(length=self.rabi_period / 2,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=0)
piy_element = self._get_mw_element(length=self.rabi_period / 2,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=90)
# Create block and append to created_blocks list
xy8_block = PulseBlock(name=name)
for ii, tau in enumerate(real_tau_array):
tauhalf_element = self._get_idle_element(length=tau / 2,
increment=0)
tau_element = self._get_idle_element(length=tau, increment=0)
xy8_block.append(pihalf_element)
xy8_block.append(tauhalf_element)
for n in range(xy8_order):
xy8_block.append(pix_element)
xy8_block.append(tau_element)
xy8_block.append(piy_element)
xy8_block.append(tau_element)
xy8_block.append(pix_element)
xy8_block.append(tau_element)
xy8_block.append(piy_element)
xy8_block.append(tau_element)
xy8_block.append(piy_element)
xy8_block.append(tau_element)
xy8_block.append(pix_element)
xy8_block.append(tau_element)
xy8_block.append(piy_element)
xy8_block.append(tau_element)
xy8_block.append(pix_element)
if n != xy8_order - 1:
xy8_block.append(tau_element)
xy8_block.append(tauhalf_element)
xy8_block.append(pihalf_element)
xy8_block.append(laser_element)
xy8_block.append(delay_element)
xy8_block.append(waiting_element)
if alternating:
xy8_block.append(pihalf_element)
xy8_block.append(tauhalf_element)
for n in range(xy8_order):
xy8_block.append(pix_element)
xy8_block.append(tau_element)
xy8_block.append(piy_element)
xy8_block.append(tau_element)
xy8_block.append(pix_element)
xy8_block.append(tau_element)
xy8_block.append(piy_element)
xy8_block.append(tau_element)
xy8_block.append(piy_element)
xy8_block.append(tau_element)
xy8_block.append(pix_element)
xy8_block.append(tau_element)
xy8_block.append(piy_element)
xy8_block.append(tau_element)
xy8_block.append(pix_element)
if n != xy8_order - 1:
xy8_block.append(tau_element)
xy8_block.append(tauhalf_element)
xy8_block.append(pi3half_element)
xy8_block.append(laser_element)
xy8_block.append(delay_element)
xy8_block.append(waiting_element)
created_blocks.append(xy8_block)
# Create block ensemble
block_ensemble = PulseBlockEnsemble(name=name, rotating_frame=True)
block_ensemble.append((xy8_block.name, 0))
# Create and append sync trigger block if needed
if self.sync_channel:
sync_block = PulseBlock(name='sync_trigger')
sync_block.append(self._get_sync_element())
created_blocks.append(sync_block)
block_ensemble.append((sync_block.name, 0))
# add metadata to invoke settings later on
number_of_lasers = num_of_points * 2 if alternating else num_of_points
block_ensemble.measurement_information['alternating'] = alternating
block_ensemble.measurement_information['laser_ignore_list'] = list()
block_ensemble.measurement_information[
'controlled_variable'] = freq_array
block_ensemble.measurement_information['units'] = ('Hz', '')
block_ensemble.measurement_information[
'number_of_lasers'] = number_of_lasers
block_ensemble.measurement_information[
'counting_length'] = self._get_ensemble_count_length(
ensemble=block_ensemble, created_blocks=created_blocks)
# append ensemble to created ensembles
created_ensembles.append(block_ensemble)
return created_blocks, created_ensembles, created_sequences
def generate_HHpol(self,
name='hh_pol',
spinlock_length=20.0e-6,
spinlock_amp=0.1,
polarization_steps=50):
"""
"""
created_blocks = list()
created_ensembles = list()
created_sequences = list()
# get steps array for measurement ticks
steps_array = np.arange(2 * polarization_steps)
# create the elements
waiting_element = self._get_idle_element(length=self.wait_time,
increment=0)
laser_element = self._get_laser_gate_element(length=self.laser_length,
increment=0)
delay_element = self._get_delay_gate_element()
pihalf_element = self._get_mw_element(length=self.rabi_period / 4,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=0)
# Use a 180 deg phase shiftet pulse as 3pihalf pulse if microwave channel is analog
if self.microwave_channel.startswith('a'):
pi3half_element = self._get_mw_element(
length=self.rabi_period / 4,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=180)
else:
pi3half_element = self._get_mw_element(
length=3 * self.rabi_period / 4,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=0)
sl_element = self._get_mw_element(length=spinlock_length,
increment=0,
amp=spinlock_amp,
freq=self.microwave_frequency,
phase=90)
# Create block for "up"-polarization and append to created_blocks list
up_block = PulseBlock(name=name + '_up')
up_block.append(pihalf_element)
up_block.append(sl_element)
up_block.append(pihalf_element)
up_block.append(laser_element)
up_block.append(delay_element)
up_block.append(waiting_element)
created_blocks.append(up_block)
# Create block for "down"-polarization and append to created_blocks list
down_block = PulseBlock(name=name + '_down')
down_block.append(pi3half_element)
down_block.append(sl_element)
down_block.append(pi3half_element)
down_block.append(laser_element)
down_block.append(delay_element)
down_block.append(waiting_element)
created_blocks.append(down_block)
# Create block ensemble
block_ensemble = PulseBlockEnsemble(name=name, rotating_frame=True)
block_ensemble.append((up_block.name, polarization_steps - 1))
block_ensemble.append((down_block.name, polarization_steps - 1))
# Create and append sync trigger block if needed
if self.sync_channel:
sync_block = PulseBlock(name='sync_trigger')
sync_block.append(self._get_sync_element())
created_blocks.append(sync_block)
block_ensemble.append((sync_block.name, 0))
# add metadata to invoke settings later on
block_ensemble.measurement_information['alternating'] = False
block_ensemble.measurement_information['laser_ignore_list'] = list()
block_ensemble.measurement_information[
'controlled_variable'] = steps_array
block_ensemble.measurement_information['units'] = ('#', '')
block_ensemble.measurement_information[
'number_of_lasers'] = 2 * polarization_steps
block_ensemble.measurement_information[
'counting_length'] = self._get_ensemble_count_length(
ensemble=block_ensemble, created_blocks=created_blocks)
# append ensemble to created ensembles
created_ensembles.append(block_ensemble)
return created_blocks, created_ensembles, created_sequences
def generate_HHtau(self,
name='hh_tau',
spinlock_amp=0.1,
tau_start=1e-6,
tau_step=1e-6,
num_of_points=50):
"""
"""
created_blocks = list()
created_ensembles = list()
created_sequences = list()
# get tau array for measurement ticks
tau_array = tau_start + np.arange(num_of_points) * tau_step
# create the elements
waiting_element = self._get_idle_element(length=self.wait_time,
increment=0)
laser_element = self._get_laser_gate_element(length=self.laser_length,
increment=0)
delay_element = self._get_delay_gate_element()
pihalf_element = self._get_mw_element(length=self.rabi_period / 4,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=0)
# Use a 180 deg phase shiftet pulse as 3pihalf pulse if microwave channel is analog
if self.microwave_channel.startswith('a'):
pi3half_element = self._get_mw_element(
length=self.rabi_period / 4,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=180)
else:
pi3half_element = self._get_mw_element(
length=3 * self.rabi_period / 4,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=0)
sl_element = self._get_mw_element(length=tau_start,
increment=tau_step,
amp=spinlock_amp,
freq=self.microwave_frequency,
phase=90)
# Create block and append to created_blocks list
hhtau_block = PulseBlock(name=name)
hhtau_block.append(pihalf_element)
hhtau_block.append(sl_element)
hhtau_block.append(pihalf_element)
hhtau_block.append(laser_element)
hhtau_block.append(delay_element)
hhtau_block.append(waiting_element)
hhtau_block.append(pi3half_element)
hhtau_block.append(sl_element)
hhtau_block.append(pihalf_element)
hhtau_block.append(laser_element)
hhtau_block.append(delay_element)
hhtau_block.append(waiting_element)
created_blocks.append(hhtau_block)
# Create block ensemble
block_ensemble = PulseBlockEnsemble(name=name, rotating_frame=True)
block_ensemble.append((hhtau_block.name, num_of_points - 1))
# Create and append sync trigger block if needed
if self.sync_channel:
sync_block = PulseBlock(name='sync_trigger')
sync_block.append(self._get_sync_element())
created_blocks.append(sync_block)
block_ensemble.append((sync_block.name, 0))
# add metadata to invoke settings later on
block_ensemble.measurement_information['alternating'] = True
block_ensemble.measurement_information['laser_ignore_list'] = list()
block_ensemble.measurement_information[
'controlled_variable'] = tau_array
block_ensemble.measurement_information['units'] = ('s', '')
block_ensemble.measurement_information[
'number_of_lasers'] = 2 * num_of_points
block_ensemble.measurement_information[
'counting_length'] = self._get_ensemble_count_length(
ensemble=block_ensemble, created_blocks=created_blocks)
# append ensemble to created ensembles
created_ensembles.append(block_ensemble)
return created_blocks, created_ensembles, created_sequences
def generate_rabi(self,
name='rabi',
tau_start=10.0e-9,
tau_step=10.0e-9,
number_of_taus=50):
"""
"""
created_blocks = list()
created_ensembles = list()
created_sequences = list()
# get tau array for measurement ticks
tau_array = tau_start + np.arange(number_of_taus) * tau_step
# create the laser_mw element
mw_element = self._get_mw_element(length=tau_start,
increment=tau_step,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=0)
waiting_element = self._get_idle_element(length=self.wait_time,
increment=0)
laser_element = self._get_laser_gate_element(length=self.laser_length,
increment=0)
delay_element = self._get_delay_gate_element()
# Create block and append to created_blocks list
rabi_block = PulseBlock(name=name)
rabi_block.append(mw_element)
rabi_block.append(laser_element)
rabi_block.append(delay_element)
rabi_block.append(waiting_element)
created_blocks.append(rabi_block)
# Create block ensemble
block_ensemble = PulseBlockEnsemble(name=name, rotating_frame=False)
block_ensemble.append((rabi_block.name, number_of_taus - 1))
# Create and append sync trigger block if needed
if self.sync_channel:
sync_block = PulseBlock(name='sync_trigger')
sync_block.append(self._get_sync_element())
created_blocks.append(sync_block)
block_ensemble.append((sync_block.name, 0))
# add metadata to invoke settings later on
block_ensemble.measurement_information['alternating'] = False
block_ensemble.measurement_information['laser_ignore_list'] = list()
block_ensemble.measurement_information[
'controlled_variable'] = tau_array
block_ensemble.measurement_information['units'] = ('s', '')
block_ensemble.measurement_information[
'number_of_lasers'] = number_of_taus
block_ensemble.measurement_information[
'counting_length'] = self._get_ensemble_count_length(
ensemble=block_ensemble, created_blocks=created_blocks)
# Append ensemble to created_ensembles list
created_ensembles.append(block_ensemble)
return created_blocks, created_ensembles, created_sequences
def generate_rot_echo_N(self,
name='rot_echo_N',
amp_hh=0.05,
tau=0.5e-6,
order_start=4,
order_step=1,
num_of_points=50,
alternating=True):
"""
Rotary echo - continuous dynamical decoupling with 0/180 phase changes.
"""
created_blocks = list()
created_ensembles = list()
created_sequences = list()
# get order array
order_array = order_start + np.arange(num_of_points) * order_step
# create the elements
waiting_element = self._get_idle_element(length=self.wait_time,
increment=0)
laser_element = self._get_laser_gate_element(length=self.laser_length,
increment=0)
delay_element = self._get_delay_gate_element()
pihalf_element = self._get_mw_element(length=self.rabi_period / 4,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=0)
# Use a 180 deg phase shifted pulse as 3pihalf pulse if microwave channel is analog
if self.microwave_channel.startswith('a'):
pi3half_element = self._get_mw_element(
length=self.rabi_period / 4,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=180)
else:
pi3half_element = self._get_mw_element(
length=3 * self.rabi_period / 4,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=0)
pix_element = self._get_mw_element(length=tau,
increment=0,
amp=amp_hh,
freq=self.microwave_frequency,
phase=0)
piy_element = self._get_mw_element(length=tau,
increment=0,
amp=amp_hh,
freq=self.microwave_frequency,
phase=180)
# Create block and append to created_blocks list
rot_echo_tau = PulseBlock(name=name)
for order in order_array:
rot_echo_tau.append(pihalf_element)
for n in range(order):
rot_echo_tau.append(pix_element)
rot_echo_tau.append(piy_element)
rot_echo_tau.append(pihalf_element)
rot_echo_tau.append(laser_element)
rot_echo_tau.append(delay_element)
rot_echo_tau.append(waiting_element)
if alternating:
rot_echo_tau.append(pihalf_element)
for n in range(order):
rot_echo_tau.append(pix_element)
rot_echo_tau.append(piy_element)
rot_echo_tau.append(pi3half_element)
rot_echo_tau.append(laser_element)
rot_echo_tau.append(delay_element)
rot_echo_tau.append(waiting_element)
created_blocks.append(rot_echo_tau)
# Create block ensemble
block_ensemble = PulseBlockEnsemble(name=name, rotating_frame=True)
block_ensemble.append((rot_echo_tau.name, 0))
# Create and append sync trigger block if needed
self._add_trigger(created_blocks=created_blocks,
block_ensemble=block_ensemble)
# add metadata to invoke settings later on
number_of_lasers = num_of_points * 2 if alternating else num_of_points
block_ensemble.measurement_information['alternating'] = alternating
block_ensemble.measurement_information['laser_ignore_list'] = list()
block_ensemble.measurement_information[
'controlled_variable'] = order_array
block_ensemble.measurement_information['units'] = ('', '')
block_ensemble.measurement_information['labels'] = ('order', 'Signal')
block_ensemble.measurement_information[
'number_of_lasers'] = number_of_lasers
block_ensemble.measurement_information[
'counting_length'] = self._get_ensemble_count_length(
ensemble=block_ensemble, created_blocks=created_blocks)
# append ensemble to created ensembles
created_ensembles.append(block_ensemble)
return created_blocks, created_ensembles, created_sequences
def generate_HHphase_tau(self,
name='HH_Phase',
amp_hh=0.5,
tau_start=0.5e-6,
tau_step=0.01e-6,
num_of_points=50,
xy8_order=4,
alternating=True):
"""
Continuous dynamical decoupling with XY8 like phase changes.
"""
created_blocks = list()
created_ensembles = list()
created_sequences = list()
# get tau array for measurement ticks
tau_array = tau_start + np.arange(num_of_points) * tau_step
# create the elements
waiting_element = self._get_idle_element(length=self.wait_time,
increment=0)
laser_element = self._get_laser_gate_element(length=self.laser_length,
increment=0)
delay_element = self._get_delay_gate_element()
pihalf_element = self._get_mw_element(length=self.rabi_period / 4,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=0)
# Use a 180 deg phase shifted pulse as 3pihalf pulse if microwave channel is analog
if self.microwave_channel.startswith('a'):
pi3half_element = self._get_mw_element(
length=self.rabi_period / 4,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=180)
else:
pi3half_element = self._get_mw_element(
length=3 * self.rabi_period / 4,
increment=0,
amp=self.microwave_amplitude,
freq=self.microwave_frequency,
phase=0)
pix_element = self._get_mw_element(length=tau_start,
increment=tau_step,
amp=amp_hh,
freq=self.microwave_frequency,
phase=0)
piy_element = self._get_mw_element(length=tau_start,
increment=tau_step,
amp=amp_hh,
freq=self.microwave_frequency,
phase=90)
# Create block and append to created_blocks list
hhphase_block = PulseBlock(name=name)
hhphase_block.append(pihalf_element)
for n in range(xy8_order):
hhphase_block.append(pix_element)
hhphase_block.append(piy_element)
hhphase_block.append(pix_element)
hhphase_block.append(piy_element)
hhphase_block.append(piy_element)
hhphase_block.append(pix_element)
hhphase_block.append(piy_element)
hhphase_block.append(pix_element)
hhphase_block.append(pihalf_element)
hhphase_block.append(laser_element)
hhphase_block.append(delay_element)
hhphase_block.append(waiting_element)
if alternating:
hhphase_block.append(pihalf_element)
for n in range(xy8_order):
hhphase_block.append(pix_element)
hhphase_block.append(piy_element)
hhphase_block.append(pix_element)
hhphase_block.append(piy_element)
hhphase_block.append(piy_element)
hhphase_block.append(pix_element)
hhphase_block.append(piy_element)
hhphase_block.append(pix_element)
hhphase_block.append(pi3half_element)
hhphase_block.append(laser_element)
hhphase_block.append(delay_element)
hhphase_block.append(waiting_element)
created_blocks.append(hhphase_block)
# Create block ensemble
block_ensemble = PulseBlockEnsemble(name=name, rotating_frame=True)
block_ensemble.append((hhphase_block.name, num_of_points - 1))
# Create and append sync trigger block if needed
self._add_trigger(created_blocks=created_blocks,
block_ensemble=block_ensemble)
# add metadata to invoke settings later on
number_of_lasers = num_of_points * 2 if alternating else num_of_points
block_ensemble.measurement_information['alternating'] = alternating
block_ensemble.measurement_information['laser_ignore_list'] = list()
block_ensemble.measurement_information[
'controlled_variable'] = tau_array
block_ensemble.measurement_information['units'] = ('s', '')
block_ensemble.measurement_information['labels'] = ('Frequency',
'Signal')
block_ensemble.measurement_information[
'number_of_lasers'] = number_of_lasers
block_ensemble.measurement_information[
'counting_length'] = self._get_ensemble_count_length(
ensemble=block_ensemble, created_blocks=created_blocks)
# append ensemble to created ensembles
created_ensembles.append(block_ensemble)
return created_blocks, created_ensembles, created_sequences