def __init__(self,
pulses: list = None,
allow_untargeted_pulses: bool = True,
allow_targeted_pulses: bool = True,
allow_pulse_overlap: bool = True,
final_delay: float = None):
super().__init__(use_as_attributes=True,
log_changes=False,
simplify_snapshot=True)
# For PulseSequence.satisfies_conditions, we need to separate conditions
# into those relating to pulses and to connections. We perform an import
# here because it otherwise otherwise leads to circular imports
if self.connection_conditions is None or self.pulse_conditions is None:
from silq.meta_instruments.layout import connection_conditions
from silq.pulses import pulse_conditions
PulseSequence.connection_conditions = connection_conditions
PulseSequence.pulse_conditions = pulse_conditions
self.allow_untargeted_pulses = Parameter(
initial_value=allow_untargeted_pulses,
set_cmd=None,
vals=vals.Bool())
self.allow_targeted_pulses = Parameter(
initial_value=allow_targeted_pulses,
set_cmd=None,
vals=vals.Bool())
self.allow_pulse_overlap = Parameter(initial_value=allow_pulse_overlap,
set_cmd=None,
vals=vals.Bool())
self.duration = Parameter(unit='s', set_cmd=None)
self.final_delay = Parameter(unit='s',
set_cmd=None,
vals=vals.Numbers())
if final_delay is not None:
self.final_delay = final_delay
else:
self.final_delay = self.default_final_delay
self.t_list = Parameter(initial_value=[0])
self.t_start_list = Parameter(initial_value=[])
self.t_stop_list = Parameter()
self.enabled_pulses = Parameter(initial_value=[],
set_cmd=None,
vals=vals.Lists())
self.disabled_pulses = Parameter(initial_value=[],
set_cmd=None,
vals=vals.Lists())
self.pulses = Parameter(initial_value=[],
vals=vals.Lists(),
set_cmd=None)
self.duration = None # Reset duration to t_stop of last pulse
# Perform a separate set to ensure set method is called
self.pulses = pulses or []
def _initialize_parameters(self):
"""Add parameters to instrument upon initialization.
"""
v_limits = []
for axis in ['x', 'y', 'z']:
lims = self.voltage_limits[self.temp][axis]
lims_V = [lim.to('V').magnitude for lim in lims]
v_limits += lims_V
self.add_parameter(
'position',
label='Scanner position',
unit='V',
vals=vals.Lists(
elt_validator=vals.Numbers(min(v_limits), max(v_limits))),
get_cmd=self.get_pos,
set_cmd=self.goto)
for i, axis in enumerate(['x', 'y', 'z']):
lims = self.voltage_limits[self.temp][axis]
lims_V = [lim.to('V').magnitude for lim in lims]
self.add_parameter('position_{}'.format(axis),
label='{} position'.format(axis),
unit='V',
vals=vals.Numbers(min(lims_V), max(lims_V)),
get_cmd=(lambda idx=i: self.get_pos()[idx]),
set_cmd=getattr(self, '_goto_{}'.format(axis)))
def __init__(self, name, **kw):
super().__init__(name, **kw)
trnsf_mat_docst = ('Converts dac voltages to virtual flux.'
'This matrix is defined as'
'flux = T dac_voltages'
'T is then d flux/ d dac')
# Ramiro will expand this to include the proper equations
self.add_parameter('transfer_matrix',
label='Transfer Matrix',
docstring=trnsf_mat_docst,
parameter_class=ManualParameter,
vals=vals.Arrays())
self._inv_transfer_matrix = None
self.add_parameter('inv_transfer_matrix',
label='Inverse transfer Matrix',
docstring=('Returns the inverse of the transfer'
' matrix, unless explictly specified'),
set_cmd=self._do_set_inv_transfer_matrix,
get_cmd=self._do_get_inv_transfer_matrix,
vals=vals.Arrays())
self.add_parameter(
'dac_mapping',
label='mapping of flux channels to current/voltage channels',
parameter_class=ManualParameter,
vals=vals.Lists())
def __init__(self, name, **kw):
super().__init__(name, **kw)
self.msmt_suffix = '_' + name # used to append to measurement labels
self.add_parameter('qasm_config',
docstring='used for generating qumis instructions',
parameter_class=ManualParameter,
vals=vals.Anything())
self.add_parameter('qubits',
parameter_class=ManualParameter,
initial_value=[],
vals=vals.Lists(elt_validator=vals.Strings()))
self.add_parameter('acquisition_instrument',
parameter_class=InstrumentParameter)
self.add_parameter('RO_acq_averages',
initial_value=1024,
vals=vals.Ints(),
parameter_class=ManualParameter)
self._sequencer_config = {}
self.delegate_attr_dicts += ['_sequencer_config']
# Add buffer parameters for every pulse type
pulse_types = ['MW', 'Flux', 'RO']
self.add_parameter('sequencer_config',
get_cmd=self._get_sequencer_config,
vals=vals.Anything())
for pt_a in pulse_types:
for pt_b in pulse_types:
self.add_parameter('Buffer_{}_{}'.format(pt_a, pt_b),
unit='s',
initial_value=0,
parameter_class=ManualParameter)
self.add_sequencer_config_param(
self.parameters['Buffer_{}_{}'.format(pt_a, pt_b)])
self.add_parameter(
'RO_fixed_point',
unit='s',
initial_value=1e-6,
docstring=('The Tektronix sequencer shifts all elements in a ' +
'sequence such that the first RO encountered in each ' +
'element is aligned with the fixpoint.\nIf the ' +
'sequence length is longer than the fixpoint, ' +
'it will shift such that the first RO aligns with a ' +
'multiple of the fixpoint.'),
parameter_class=ManualParameter,
vals=vals.Numbers(1e-9, 500e-6))
self.add_sequencer_config_param(self.RO_fixed_point)
self.add_parameter(
'Flux_comp_dead_time',
unit='s',
initial_value=3e-6,
docstring=('Used to determine the wait time between the end of a' +
'sequence and the beginning of Flux compensation' +
' pulses.'),
parameter_class=ManualParameter,
vals=vals.Numbers(1e-9, 500e-6))
self.add_sequencer_config_param(self.Flux_comp_dead_time)
def create_awg_parameters(self, channel_name_map):
super().create_awg_parameters(channel_name_map)
pulsar = self.pulsar
name = self.awg.name
# Override _min_length parameter created in base class
# TODO: Check if this makes sense, it is a constant for the other AWGs
# Furthermore, it does not really make sense to manually set the minimum
# length which is a property of the instrument...
del pulsar.parameters[f"{name}_min_length"]
pulsar.add_parameter(f"{name}_min_length",
initial_value=self.MIN_LENGTH,
parameter_class=ManualParameter)
pulsar.add_parameter(f"{name}_use_placeholder_waves",
initial_value=False, vals=vals.Bool(),
parameter_class=ManualParameter)
pulsar.add_parameter(f"{name}_trigger_source",
initial_value="Dig1",
vals=vals.Enum("Dig1", "DIO", "ZSync"),
parameter_class=ManualParameter,
docstring="Defines for which trigger source the "
"AWG should wait, before playing the "
"next waveform. Allowed values are: "
"'Dig1', 'DIO', 'ZSync'.")
pulsar.add_parameter(f"{name}_prepend_zeros",
initial_value=None,
vals=vals.MultiType(vals.Enum(None), vals.Ints(),
vals.Lists(vals.Ints())),
parameter_class=ManualParameter)
group = []
for ch_nr in range(8):
id = f"ch{ch_nr + 1}"
ch_name = channel_name_map.get(id, f"{name}_{id}")
self.create_channel_parameters(id, ch_name, "analog")
pulsar.channels.add(ch_name)
group.append(ch_name)
id = f"ch{ch_nr + 1}m"
ch_name = channel_name_map.get(id, f"{name}_{id}")
self.create_channel_parameters(id, ch_name, "marker")
pulsar.channels.add(ch_name)
group.append(ch_name)
# channel pairs plus the corresponding marker channels are
# considered as groups
if (ch_nr + 1) % 2 == 0:
for ch_name in group:
pulsar.channel_groups.update({ch_name: group})
group = []
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
ZI_AcquisitionDevice.__init__(self, *args, **kwargs)
self.n_acq_units = len(self.qachannels)
self.lo_freqs = [None] * self.n_acq_units # re-create with correct length
self.n_acq_int_channels = self.max_qubits_per_channel
self._reset_acq_poll_inds()
# Mode of the acquisition units ('readout' or 'spectroscopy')
# This is different from self._acq_mode (allowed_modes)
self._acq_units_modes = {}
self._awg_program = [None]*self.n_acq_units
self.seqtrigger = None
self.timer = None
self.awg_active = [False] * self.n_acq_units
self.add_parameter(
'allowed_lo_freqs',
initial_value=np.arange(1e9, 8.1e9, 100e6),
parameter_class=ManualParameter,
docstring='List of values that the center frequency (LO) is '
'allowed to take. As of now this is limited to steps '
'of 100 MHz.',
set_parser=lambda x: list(np.atleast_1d(x).flatten()),
vals=validators.MultiType(validators.Lists(), validators.Arrays(),
validators.Numbers()))
self.add_parameter(
'use_hardware_sweeper',
initial_value=False,
parameter_class=ManualParameter,
docstring='Bool indicating whether the hardware sweeper should '
'be used in spectroscopy mode',
vals=validators.Bool())
self.add_parameter(
'acq_trigger_delay',
initial_value=200e-9,
parameter_class=ManualParameter,
docstring='Delay between the pulse generation and acquisition. '
'This is used both in the scope and the integration '
'units for consistency.',
vals=validators.Numbers())
def __init__(self, name, **kw):
logging.info(__name__ + ' : Initializing instrument')
super().__init__(name, **kw)
self.add_parameter('QWG', parameter_class=InstrumentParameter)
self.add_parameter('F_kernel_instr',
parameter_class=InstrumentParameter)
self.add_parameter('F_amp', unit='frac',
docstring=('Amplitude of flux pulse as fraction of '
'the peak amplitude. Beware of factor 2'
' with Vpp in the QWG'),
initial_value=0.5,
parameter_class=ManualParameter)
self.add_parameter('F_length', unit='s',
parameter_class=ManualParameter,
initial_value=200e-9)
self.add_parameter('F_ch', label='Flux channel',
vals=vals.Ints(),
parameter_class=ManualParameter)
self.add_parameter('F_delay', label='Flux pulse delay',
unit='s',
initial_value=0,
vals=vals.Numbers(),
parameter_class=ManualParameter)
self.add_parameter('F_compensation_delay',
label='compens. pulse delay',
unit='s',
initial_value=4e-6,
vals=vals.Numbers(),
parameter_class=ManualParameter)
self.add_parameter('F_lambda_1',
docstring='first lambda coef. for martinis pulse',
label='Lambda_1',
unit='',
initial_value=0,
vals=vals.Numbers(),
parameter_class=ManualParameter)
self.add_parameter('F_lambda_2',
docstring='second lambda coef. for martinis pulse',
label='Lambda_2',
unit='',
initial_value=0,
vals=vals.Numbers(),
parameter_class=ManualParameter)
self.add_parameter('F_lambda_3',
docstring='third lambda coef. for martinis pulse',
label='Lambda_3',
unit='',
initial_value=0,
vals=vals.Numbers(),
parameter_class=ManualParameter)
self.add_parameter('F_theta_f',
docstring='theta_f for martinis pulse',
label='theta_f',
unit='deg',
initial_value=90,
vals=vals.Numbers(),
parameter_class=ManualParameter)
self.add_parameter('F_J2',
docstring='coupling between 11-02',
label='J2',
unit='Hz',
initial_value=10e6,
vals=vals.Numbers(),
parameter_class=ManualParameter)
self.add_parameter('F_f_interaction',
label='interaction frequency',
unit='Hz',
initial_value=5e9,
vals=vals.Numbers(),
parameter_class=ManualParameter)
self.add_parameter('F_dac_flux_coef',
docstring='conversion factor AWG voltage to flux',
label='dac flux coef',
unit='(V^-1)',
initial_value=1.0,
vals=vals.Numbers(),
parameter_class=ManualParameter)
self.add_parameter('F_E_c',
label='qubit E_c',
unit='Hz',
initial_value=250e6,
vals=vals.Numbers(),
parameter_class=ManualParameter)
self.add_parameter('F_f_01_max',
label='sweet spot freq',
unit='Hz',
initial_value=6e9,
vals=vals.Numbers(),
parameter_class=ManualParameter)
self.add_parameter('F_asymmetry',
label='qubit asymmetry',
unit='Hz',
initial_value=0.0,
vals=vals.Numbers(),
parameter_class=ManualParameter)
self.add_parameter('codeword_dict',
docstring='Dict assigning codewords to pulses',
label='codeword dict',
unit='',
initial_value={},
vals=vals.Anything(),
parameter_class=ManualParameter)
self.add_parameter('sampling_rate',
docstring='Sampling rate of the QWG',
label='sampling rate',
unit='Hz',
initial_value=1.0e9,
vals=vals.Numbers(),
parameter_class=ManualParameter)
self.add_parameter('Z_length',
docstring=('Duration of single qubit Z pulse in'
' seconds'),
label='Z length',
unit='s',
initial_value=10e-9,
vals=vals.Numbers(),
parameter_class=ManualParameter)
self.add_parameter('Z_amp',
docstring=('Amplitude of the single qubit phase '
'correction in CZ pulses.'),
label='Z amplitude',
unit='frac',
initial_value=0.0,
vals=vals.Numbers(),
parameter_class=ManualParameter)
self.add_parameter('Z_amp_grover',
docstring=('Amplitude of the single qubit phase '
'correction for the second CZ pulse '
"used in Grover's algorithm."),
label='Z amplitude 2',
unit='frac',
initial_value=0.0,
vals=vals.Numbers(),
parameter_class=ManualParameter)
self.add_parameter('max_waveform_length', unit='s',
parameter_class=ManualParameter,
initial_value=30e-6)
self.add_parameter('codeword_channels',
parameter_class=ManualParameter,
docstring='Channels used for triggering specific '
'codewords.',
vals=vals.Lists(vals.Ints()))
self.add_parameter('disable_CZ',
parameter_class=ManualParameter,
vals=vals.Bool(),
initial_value=False)
self.add_parameter('pulse_map',
initial_value={'cz': 'adiabatic_Z',
'cz_grover': 'adiabatic_Z_grover',
'square': 'square'},
parameter_class=ManualParameter,
vals=vals.Dict())
self.add_parameter('wave_dict_unit',
get_cmd=self._get_wave_dict_unit,
set_cmd=self._set_wave_dict_unit,
docstring='Unit in which the waveforms are '
'specified.\n'
'"frac" means "fraction of the maximum QWG '
'range".\n'
'"V" means volts.',
vals=vals.Enum('frac', 'V'))
self._wave_dict_unit = 'frac' # Initial value for wave_dict_unit
self.add_parameter('V_offset',
unit='V',
label='V offset',
docstring='pulsed sweet spot offset',
parameter_class=ManualParameter,
initial_value=0,
vals=vals.Numbers())
self.add_parameter('V_per_phi0',
unit='V',
label='V per phi_0',
docstring='pulsed voltage required for one phi0 '
'of flux',
parameter_class=ManualParameter,
initial_value=1,
vals=vals.Numbers())
self.add_parameter('S_gauss_sigma',
unit='s',
label='gauss sigma',
docstring='Width (sigma) of Gaussian shaped flux '
'pulse.',
parameter_class=ManualParameter,
initial_value=40e-9,
vals=vals.Numbers())
self.add_parameter('S_amp',
unit='frac',
label='S_amp',
docstring='Amplitude of scoping flux pulse.',
parameter_class=ManualParameter,
initial_value=0.5,
vals=vals.Numbers())
self._wave_dict = {}
def __init__(self, name, **kw):
super().__init__(name, **kw)
self.add_parameter('channel',
initial_value=1,
vals=vals.Ints(),
parameter_class=ManualParameter)
self.add_parameter(
'kernel_list', initial_value=[], vals=vals.Lists(vals.Strings()),
parameter_class=ConfigParameter,
docstring='List of filenames of external kernels to be loaded')
self.add_parameter('kernel_dir',
initial_value='kernels/',
vals=vals.Strings(),
parameter_class=ManualParameter,
docstring='Path for loading external kernels,' +
'such as room temperature correction kernels.')
self.add_parameter('config_changed',
vals=vals.Bool(),
get_cmd=self._get_config_changed)
self.add_parameter(
'kernel', vals=vals.Arrays(), get_cmd=self._get_kernel,
docstring=('Returns the predistortion kernel. \n' +
'Recalculates if the parameters changed,\n' +
'otherwise returns a precalculated kernel.\n' +
'Kernel is based on parameters in kernel object \n' +
'and files specified in the kernel list.'))
self.add_parameter('skineffect_alpha', unit='',
parameter_class=ConfigParameter,
initial_value=0,
vals=vals.Numbers())
self.add_parameter('skineffect_length', unit='s',
parameter_class=ConfigParameter,
initial_value=600e-9,
vals=vals.Numbers())
self.add_parameter('decay_amp_1', unit='',
initial_value=0,
parameter_class=ConfigParameter,
vals=vals.Numbers())
self.add_parameter('decay_tau_1', unit='s',
initial_value=1e-9,
parameter_class=ConfigParameter,
vals=vals.Numbers())
self.add_parameter('decay_length_1', unit='s',
initial_value=100e-9,
parameter_class=ConfigParameter,
vals=vals.Numbers())
self.add_parameter('decay_amp_2', unit='',
initial_value=0,
parameter_class=ConfigParameter,
vals=vals.Numbers())
self.add_parameter('decay_tau_2', unit='s',
initial_value=1e-9,
parameter_class=ConfigParameter,
vals=vals.Numbers())
self.add_parameter('decay_length_2', unit='s',
initial_value=100e-9,
parameter_class=ConfigParameter,
vals=vals.Numbers())
self.add_parameter('bounce_amp_1', unit='',
initial_value=0,
parameter_class=ConfigParameter,
vals=vals.Numbers())
self.add_parameter('bounce_tau_1', unit='s',
initial_value=0,
parameter_class=ConfigParameter,
vals=vals.Numbers())
self.add_parameter('bounce_length_1', unit='s',
initial_value=1e-9,
parameter_class=ConfigParameter,
vals=vals.Numbers())
self.add_parameter('bounce_amp_2', unit='',
initial_value=0,
parameter_class=ConfigParameter,
vals=vals.Numbers())
self.add_parameter('bounce_tau_2', unit='s',
initial_value=0,
parameter_class=ConfigParameter,
vals=vals.Numbers())
self.add_parameter('bounce_length_2', unit='s',
initial_value=1e-9,
parameter_class=ConfigParameter,
vals=vals.Numbers())
self.add_parameter('poly_a', unit='',
initial_value=0,
parameter_class=ConfigParameter,
vals=vals.Numbers())
self.add_parameter('poly_b', unit='',
initial_value=0,
parameter_class=ConfigParameter,
vals=vals.Numbers())
self.add_parameter('poly_c', unit='',
initial_value=1,
parameter_class=ConfigParameter,
vals=vals.Numbers())
self.add_parameter('poly_length', unit='s',
initial_value=600e-9,
parameter_class=ConfigParameter,
vals=vals.Numbers())
self.add_parameter('corrections_length', unit='s',
parameter_class=ConfigParameter,
initial_value=10e-6,
vals=vals.Numbers())
self.add_parameter('sampling_rate',
parameter_class=ManualParameter,
initial_value=1e9,
vals=vals.Numbers())
def __init__(self, instrument_name, **kwargs):
super().__init__(instrument_name, **kwargs)
self.pulse_sequence.allow_untargeted_pulses = True
self.pulse_sequence.allow_pulse_overlap = True
# Initialize channels
self._acquisition_channels = {
f'ch{k}': Channel(instrument_name=self.instrument_name(),
name=f'ch{k}',
id=k,
input=True)
for k in self.instrument.channel_idxs
}
self._pxi_channels = {
f'pxi{k}': Channel(instrument_name=self.instrument_name(),
name=f'pxi{k}',
id=4000 + k,
input_trigger=True,
output=True,
input=True)
for k in range(self.instrument.n_triggers)
}
self._channels = {
**self._acquisition_channels,
**self._pxi_channels,
'trig_in':
Channel(instrument_name=self.instrument_name(),
name='trig_in',
input=True),
}
self.add_parameter(name='acquisition_controller',
set_cmd=None,
snapshot_value=False,
docstring='Acquisition controller for acquiring '
'data with SD digitizer. '
'Must be acquisition controller object.')
self.add_parameter(name='acquisition_channels',
initial_value=[],
set_cmd=None,
vals=vals.Lists(),
docstring='Names of acquisition channels '
'[chA, chB, etc.]. Set by the layout')
self.add_parameter('sample_rate',
vals=vals.Numbers(),
set_cmd=None,
docstring='Acquisition sampling rate (Hz)')
self.add_parameter('samples',
vals=vals.Numbers(),
set_cmd=None,
docstring='Number of times to acquire the pulse '
'sequence.')
self.add_parameter(
'points_per_trace',
get_cmd=lambda: self.acquisition_controller().samples_per_trace(),
docstring='Number of points in a trace.')
self.add_parameter('channel_selection',
set_cmd=None,
docstring='Active channel indices to acquire. '
'Zero-based index (chA -> 0, etc.). '
'Set during setup and should not be set'
'manually.')
self.add_parameter(
'minimum_timeout_interval',
unit='s',
vals=vals.Numbers(),
initial_value=5,
set_cmd=None,
docstring='Minimum value for timeout when acquiring '
'data. If 2.1 * pulse_sequence.duration '
'is lower than this value, it will be '
'used instead')
self.add_parameter(
'trigger_in_duration',
unit='s',
vals=vals.Numbers(),
initial_value=15e-6,
set_cmd=None,
docstring="Duration for a receiving trigger signal. "
"This is passed the the interface that is "
"sending the triggers to this instrument.")
self.add_parameter('capture_full_trace',
initial_value=False,
vals=vals.Bool(),
set_cmd=None,
docstring='Capture from t=0 to end of pulse '
'sequence. False by default, in which '
'case start and stop times correspond to '
'min(t_start) and max(t_stop) of all '
'pulses with the flag acquire=True, '
'respectively.')
# dict of raw unsegmented traces {ch_name: ch_traces}
self.traces = {}
# Segmented traces per pulse, {pulse_name: {channel_name: {ch_pulse_traces}}
self.pulse_traces = {}
# Set up the driver to a known default state
self.initialize_driver()
def __init__(self, name, **kw):
super().__init__(name, **kw)
# Instrument parameters
for parname in ["x", "y", "z", "x0", "y0", "z0"]:
self.add_parameter(
parname,
unit="m",
parameter_class=ManualParameter,
vals=vals.Numbers(),
initial_value=0.,
)
# Instrument integer parameters
for parname in [
"x_int", "y_int", "z_int", "x0_int", "y0_int", "z0_int"
]:
self.add_parameter(
parname,
unit="m",
parameter_class=ManualParameter,
vals=vals.Ints(),
initial_value=0,
)
self.add_parameter(
"noise",
unit="V",
label="white noise amplitude",
parameter_class=ManualParameter,
vals=vals.Numbers(),
initial_value=0,
)
self.add_parameter(
"delay",
unit="s",
label="Sampling delay",
parameter_class=ManualParameter,
vals=vals.Numbers(),
initial_value=0,
)
self.add_parameter("parabola",
unit="V",
get_cmd=self._measure_parabola)
self.add_parameter("parabola_int",
unit="V",
get_cmd=self._measure_parabola_int)
self.add_parameter("parabola_float_int",
unit="V",
get_cmd=self._measure_parabola_float_int)
self.add_parameter("parabola_list",
unit="V",
get_cmd=self._measure_parabola_list)
self.add_parameter("skewed_parabola",
unit="V",
get_cmd=self._measure_skewed_parabola)
self.add_parameter("cos_mod_parabola",
unit="V",
get_cmd=self._measure_cos_mod_parabola)
self.add_parameter("lorentz_dip",
unit="V",
get_cmd=self._measure_lorentz_dip)
self.add_parameter("lorentz_dip_cos_mod",
unit="V",
get_cmd=self._measure_lorentz_dip_cos_mod)
self.add_parameter(
"array_like",
unit="a.u.",
parameter_class=ManualParameter,
vals=vals.Arrays(),
)
self.add_parameter("nested_lists_like",
unit="a.u.",
parameter_class=ManualParameter,
vals=vals.Lists(elt_validator=vals.Lists()))
self.add_parameter("dict_like",
unit="a.u.",
parameter_class=ManualParameter,
vals=vals.Dict())
self.add_parameter("complex_like",
unit="a.u.",
parameter_class=ManualParameter,
vals=vals.ComplexNumbers())
self.add_parameter("status",
vals=vals.Anything(),
parameter_class=ManualParameter)
def _add_waveform_parameters(self):
# mixer corrections are done globally, can be specified per resonator
self.add_parameter('mixer_apply_predistortion_matrix',
vals=vals.Bool(),
parameter_class=ManualParameter,
initial_value=False)
self.add_parameter('gaussian_convolution',
vals=vals.Bool(),
parameter_class=ManualParameter,
initial_value=False)
self.add_parameter('gaussian_convolution_sigma',
vals=vals.Numbers(),
parameter_class=ManualParameter,
initial_value=5.0e-9,
unit='s')
self.add_parameter('mixer_alpha',
vals=vals.Numbers(),
parameter_class=ManualParameter,
initial_value=1.0)
self.add_parameter('mixer_phi',
vals=vals.Numbers(),
unit='deg',
parameter_class=ManualParameter,
initial_value=0.0)
self.add_parameter('mixer_offs_I',
unit='V',
parameter_class=ManualParameter,
initial_value=0)
self.add_parameter('mixer_offs_Q',
unit='V',
parameter_class=ManualParameter,
initial_value=0)
comb_msg = (
'Resonator combinations specifies which pulses are uploaded to'
'the device. Given as a list of lists:'
'e.g. [[0], [2], [0, 2]] specifies that pulses for readout'
'of resonator 0, 2, and a pulse for mux readout on both should be'
'uploaded.')
self.add_parameter('resonator_combinations',
vals=vals.Lists(),
docstring=comb_msg,
set_cmd=self._set_resonator_combinations,
get_cmd=self._get_resonator_combinations)
self.add_parameter(
'pulse_type',
vals=vals.Enum('M_up_down_down', 'M_simple',
'M_up_down_down_final'),
set_cmd=self._set_pulse_type,
get_cmd=self._get_pulse_type,
docstring='defines sequence of segments of the pulse')
self.add_parameter(
'pulse_primitive_shape',
vals=vals.Enum('square', 'gaussian'),
parameter_class=ManualParameter,
docstring='defines the shape of the segments of the pulse',
initial_value='square')
for res in self._resonator_codeword_bit_mapping:
self.add_parameter('M_modulation_R{}'.format(res),
vals=vals.Numbers(),
unit='Hz',
parameter_class=ManualParameter,
initial_value=20.0e6)
self.add_parameter('M_length_R{}'.format(res),
unit='s',
vals=vals.Numbers(1e-9, 8000e-9),
parameter_class=ManualParameter,
initial_value=2000e-9)
self.add_parameter('M_amp_R{}'.format(res),
unit='V',
vals=vals.Numbers(0, 1),
parameter_class=ManualParameter,
initial_value=0.1)
self.add_parameter('M_final_amp_R{}'.format(res),
unit='V',
vals=vals.Numbers(0, 1),
parameter_class=ManualParameter,
initial_value=0.1)
self.add_parameter('M_final_length_R{}'.format(res),
unit='s',
vals=vals.Numbers(1e-9, 8000e-9),
parameter_class=ManualParameter,
initial_value=1000e-9)
self.add_parameter('M_final_delay_R{}'.format(res),
unit='s',
vals=vals.Numbers(1e-9, 8000e-9),
parameter_class=ManualParameter,
initial_value=200e-9)
self.add_parameter('M_phi_R{}'.format(res),
unit='deg',
parameter_class=ManualParameter,
initial_value=0.0)
self.add_parameter('M_down_length0_R{}'.format(res),
unit='s',
vals=vals.Numbers(1e-9, 8000e-9),
parameter_class=ManualParameter,
initial_value=200.0e-9)
self.add_parameter('M_down_length1_R{}'.format(res),
unit='s',
vals=vals.Numbers(1e-9, 8000e-9),
parameter_class=ManualParameter,
initial_value=200.0e-9)
self.add_parameter('M_down_amp0_R{}'.format(res),
unit='V',
vals=vals.Numbers(-1, 1),
parameter_class=ManualParameter,
initial_value=0.1)
self.add_parameter('M_down_amp1_R{}'.format(res),
unit='V',
vals=vals.Numbers(-1, 1),
parameter_class=ManualParameter,
initial_value=0.1)
self.add_parameter('M_down_phi0_R{}'.format(res),
unit='deg',
parameter_class=ManualParameter,
initial_value=180.0)
self.add_parameter('M_down_phi1_R{}'.format(res),
unit='deg',
parameter_class=ManualParameter,
initial_value=180.0)
def __init__(self, name: str, digitizer: Instrument, **kwargs):
"""
Initialises a generic Keysight digitizer and its parameters
Args:
name: Acquisition controller name
digitizer: Keysight digitizer instrument
"""
super().__init__(name, digitizer, **kwargs)
self.add_parameter(
'average_mode',
set_cmd=None,
initial_value='none',
vals=vals.Enum('none', 'point', 'trace'),
docstring=
'The averaging mode used for acquisition, either none, point or trace'
)
self.add_parameter(
'channel_selection',
set_cmd=None,
vals=vals.Lists(),
docstring='The list of channels on which to acquire data.')
# Set_cmds are lambda to ensure current active_channels is used
self.add_parameter(
'sample_rate',
vals=vals.Numbers(min_value=1),
set_parser=self._sample_rate_to_prescaler,
set_cmd=lambda prescaler: self.active_channels.prescaler(prescaler
),
docstring='Sets the sample rate for all channels. The sample rate '
'will be converted to a prescaler, which must be an int, '
'and could thus result in a modified sample rate')
self.add_parameter(
'trigger_channel',
vals=vals.Enum('trig_in', *[f'ch{k}' for k in range(8)],
*[f'pxi{k}' for k in range(8)]),
set_cmd=self.set_trigger_channel,
docstring='The channel on which acquisition is triggered.')
self.add_parameter(
'analog_trigger_edge',
vals=vals.Enum('rising', 'falling', 'both'),
initial_value='rising',
set_cmd=lambda edge: self.active_channels.analog_trigger_edge(edge
),
docstring=
'Sets the trigger edge sensitivity for the active acquisition controller.'
)
self.add_parameter(
'analog_trigger_threshold',
vals=vals.Numbers(-3, 3),
initial_value=1,
set_cmd=lambda threshold: self.active_channels.
analog_trigger_threshold(threshold),
docstring=f'the value in volts for the trigger threshold')
self.add_parameter(
'digital_trigger_mode',
vals=vals.Enum('active_high', 'active_low', 'rising', 'falling'),
initial_value='rising',
set_cmd=lambda mode: self.active_channels.digital_trigger_mode(mode
),
docstring=
'Sets the digital trigger mode for the active trigger channel.')
self.add_parameter(
'trigger_delay_samples',
vals=vals.Numbers(),
initial_value=0,
set_parser=int,
set_cmd=lambda delay: self.active_channels.trigger_delay_samples(
delay),
docstring='Sets the trigger delay before starting acquisition.')
self.add_parameter(
'samples_per_trace',
vals=vals.Multiples(divisor=2, min_value=2),
set_parser=lambda val: int(round(val)),
set_cmd=lambda samples: self.active_channels.points_per_cycle(
samples),
docstring='The number of points to capture per trace.')
self.add_parameter(
'traces_per_acquisition',
vals=vals.Numbers(min_value=1),
set_parser=lambda val: int(round(val)),
set_cmd=lambda n_cycles: self.active_channels.n_cycles(n_cycles),
docstring='The number of traces to capture per acquisition. '
'Must be set after channel_selection is modified.')
self.add_parameter(
'traces_per_read',
set_cmd=None,
vals=vals.Numbers(min_value=1),
set_parser=lambda val: int(round(val)),
docstring='The number of traces to get per read. '
'Can be use to break acquisition into multiple reads.')
self.add_parameter(
'timeout',
vals=vals.Numbers(min_value=0),
set_cmd=None,
unit='s',
docstring=
'The maximum time (s) spent trying to read a single channel. '
'An acquisition request is sent every timeout_interval. '
'This must be set after channel_selection is modified.')
self.add_parameter(
'timeout_interval',
vals=vals.Numbers(min_value=0),
set_cmd=lambda timeout: self.active_channels.timeout(timeout),
unit='s',
docstring=
'The maximum time (s) spent trying to read a single channel. '
'This must be set after channel_selection is modified.')
self.buffers = {}
self.is_acquiring = False
def __init__(self, name, **kw):
super().__init__(name, **kw)
self.add_parameter(
"channel",
initial_value=1,
vals=vals.Ints(),
parameter_class=ManualParameter,
)
self.add_parameter(
"kernel_list",
initial_value=[],
vals=vals.Lists(vals.Strings()),
parameter_class=ConfigParameter,
docstring="List of filenames of external kernels to be loaded",
)
self.add_parameter(
"kernel_dir",
initial_value="kernels/",
vals=vals.Strings(),
parameter_class=ManualParameter,
docstring="Path for loading external kernels," +
"such as room temperature correction kernels.",
)
self.add_parameter("config_changed",
vals=vals.Bool(),
get_cmd=self._get_config_changed)
self.add_parameter(
"kernel",
vals=vals.Arrays(),
get_cmd=self._get_kernel,
docstring=("Returns the predistortion kernel. \n" +
"Recalculates if the parameters changed,\n" +
"otherwise returns a precalculated kernel.\n" +
"Kernel is based on parameters in kernel object \n" +
"and files specified in the kernel list."),
)
self.add_parameter(
"skineffect_alpha",
unit="",
parameter_class=ConfigParameter,
initial_value=0,
vals=vals.Numbers(),
)
self.add_parameter(
"skineffect_length",
unit="s",
parameter_class=ConfigParameter,
initial_value=600e-9,
vals=vals.Numbers(),
)
self.add_parameter(
"decay_amp_1",
unit="",
initial_value=0,
parameter_class=ConfigParameter,
vals=vals.Numbers(),
)
self.add_parameter(
"decay_tau_1",
unit="s",
initial_value=1e-9,
parameter_class=ConfigParameter,
vals=vals.Numbers(),
)
self.add_parameter(
"decay_length_1",
unit="s",
initial_value=100e-9,
parameter_class=ConfigParameter,
vals=vals.Numbers(),
)
self.add_parameter(
"decay_amp_2",
unit="",
initial_value=0,
parameter_class=ConfigParameter,
vals=vals.Numbers(),
)
self.add_parameter(
"decay_tau_2",
unit="s",
initial_value=1e-9,
parameter_class=ConfigParameter,
vals=vals.Numbers(),
)
self.add_parameter(
"decay_length_2",
unit="s",
initial_value=100e-9,
parameter_class=ConfigParameter,
vals=vals.Numbers(),
)
self.add_parameter(
"bounce_amp_1",
unit="",
initial_value=0,
parameter_class=ConfigParameter,
vals=vals.Numbers(),
)
self.add_parameter(
"bounce_tau_1",
unit="s",
initial_value=0,
parameter_class=ConfigParameter,
vals=vals.Numbers(),
)
self.add_parameter(
"bounce_length_1",
unit="s",
initial_value=1e-9,
parameter_class=ConfigParameter,
vals=vals.Numbers(),
)
self.add_parameter(
"bounce_amp_2",
unit="",
initial_value=0,
parameter_class=ConfigParameter,
vals=vals.Numbers(),
)
self.add_parameter(
"bounce_tau_2",
unit="s",
initial_value=0,
parameter_class=ConfigParameter,
vals=vals.Numbers(),
)
self.add_parameter(
"bounce_length_2",
unit="s",
initial_value=1e-9,
parameter_class=ConfigParameter,
vals=vals.Numbers(),
)
self.add_parameter(
"poly_a",
unit="",
initial_value=0,
parameter_class=ConfigParameter,
vals=vals.Numbers(),
)
self.add_parameter(
"poly_b",
unit="",
initial_value=0,
parameter_class=ConfigParameter,
vals=vals.Numbers(),
)
self.add_parameter(
"poly_c",
unit="",
initial_value=1,
parameter_class=ConfigParameter,
vals=vals.Numbers(),
)
self.add_parameter(
"poly_length",
unit="s",
initial_value=600e-9,
parameter_class=ConfigParameter,
vals=vals.Numbers(),
)
self.add_parameter(
"corrections_length",
unit="s",
parameter_class=ConfigParameter,
initial_value=10e-6,
vals=vals.Numbers(),
)
self.add_parameter(
"sampling_rate",
parameter_class=ManualParameter,
initial_value=1e9,
vals=vals.Numbers(),
)
def __init__(self, name, qubits, connectivity_graph, **kw):
"""
Instantiates device instrument and adds its parameters.
Args:
name (str): name of the device
qubits (list of QudevTransmon or names of QudevTransmon objects): qubits of the device
connectivity_graph: list of elements of the form [qb1, qb2] with qb1 and qb2 QudevTransmon objects or names
thereof. qb1 and qb2 should be physically connected on the device.
"""
super().__init__(name, **kw)
qb_names = [qb if isinstance(qb, str) else qb.name for qb in qubits]
qubits = [qb if not isinstance(qb, str) else self.find_instrument(qb) for qb in qubits]
connectivity_graph = [[qb1 if isinstance(qb1, str) else qb1.name,
qb2 if isinstance(qb2, str) else qb2.name] for [qb1, qb2] in connectivity_graph]
self._two_qb_gates = []
for qb in qubits:
setattr(self, qb.name, qb)
self.qubits = qubits
self.add_parameter('qb_names',
vals=vals.Lists(),
initial_value=qb_names,
parameter_class=ManualParameter)
self._operations = {} # dictionary containing dictionaries of operations with parameters
# Instrument reference parameters
self.add_parameter('instr_mc',
parameter_class=InstrumentRefParameter)
self.add_parameter('instr_pulsar',
parameter_class=InstrumentRefParameter)
self.add_parameter('instr_dc_source',
parameter_class=InstrumentRefParameter)
self.add_parameter('instr_trigger',
parameter_class=InstrumentRefParameter)
self.add_parameter('connectivity_graph',
vals=vals.Lists(),
label="Qubit Connectivity Graph",
docstring="Stores the connections between the qubits "
"in form of a list of lists [qbi_name, qbj_name]",
parameter_class=ManualParameter,
initial_value=connectivity_graph
)
self.add_parameter('last_calib',
vals=vals.Strings(),
initial_value='',
docstring='stores timestamp of last calibration',
parameter_class=ManualParameter)
self.add_parameter('operations',
docstring='a list of operations on the device, without single QB operations.',
get_cmd=self._get_operations)
self.add_parameter('two_qb_gates',
docstring='stores all two qubit gate names',
get_cmd=lambda s=self: copy(s._two_qb_gates)
)
self.add_parameter('relative_delay_graph',
label='Relative Delay Graph',
docstring='Stores the relative delays between '
'drive and flux channels of the device.',
initial_value=RelativeDelayGraph(),
parameter_class=ManualParameter,
set_parser=RelativeDelayGraph)
self.add_parameter('flux_crosstalk_calibs',
parameter_class=ManualParameter,
)
# Pulse preparation parameters
default_prep_params = dict(preparation_type='wait',
post_ro_wait=1e-6, reset_reps=1)
self.add_parameter('preparation_params', parameter_class=ManualParameter,
initial_value=default_prep_params, vals=vals.Dict())
def __init__(self, parent, name, awg_model):
super().__init__(parent, name)
self.awg_model = awg_model
self.channels = []
self.parameters['separation'] = self._parent.separation
self.add_parameter('mixer_power',
unit='dBm',
set_cmd=None,
get_parser=float,
vals=vals.Numbers(-120, 16),
docstring='Power output for mixer.')
self.mixer_power(16.)
self.add_parameter(
'sigma',
unit='s',
set_cmd=None,
get_parser=float,
vals=vals.Numbers(),
docstring='Length unit of GaussianPulse and DRAGGaussPulse pulses.'
)
self.sigma(2e-8)
self.add_parameter(
'truncate',
set_cmd=None,
get_parser=float,
vals=vals.Numbers(),
docstring='Truncate GaussianPulse at truncate sigmas from centre.')
self.truncate(2)
self.add_parameter(
'qscale',
set_cmd=None,
get_parser=float,
vals=vals.Numbers(),
docstring='Quadrature scale factor of DRAGGaussPulse')
self.qscale(0.5)
self.add_parameter(
'anharmonicity',
unit='rad/s',
set_cmd=None,
get_parser=float,
vals=vals.Numbers(),
docstring='Anharmonicity argument to DRAGGaussPulse')
self.anharmonicity(2 * math.pi * 300e6)
self.add_parameter('length',
unit='s',
set_cmd=None,
get_parser=float,
vals=vals.Numbers(),
docstring='Default length of SquarePulse')
self.length(20e-9)
self.add_parameter('pulse_shape',
set_cmd=None,
docstring='Supported pulse shapes are:\n\t' +
'\n\t'.join(PULSE_SHAPES.keys()))
self.pulse_shape('GaussianPulse')
self.add_parameter(
'pi_amp',
set_cmd=None,
get_parser=float,
vals=vals.Numbers(),
docstring='Amplitude of pi pulses created by pix() and piy().')
self.pi_amp(0.9)
self.add_parameter(
'pi_half_amp',
set_cmd=None,
get_parser=float,
vals=vals.Numbers(),
docstring=
'Amplitude of pi/2 pulses created by pihalfx() and pihalfy().')
self.pi_half_amp(0.45)
self.add_parameter('mixer_calibration',
set_cmd=None,
get_parser=list,
vals=vals.Lists())
self.mixer_calibration([[1., math.pi / 2.], [1., 0.]])
self.add_parameter('if_freq',
unit='rad/s',
set_cmd=None,
get_parser=float,
vals=vals.Numbers())
self.if_freq(100e6)
